蛙蛙推荐：自己做一个抓包工具（类库是用的别人的）

蛙蛙推荐：自己做个抓包工具（半成品）
用wireshark的命令行模式和windump抓包有时候很难满足抓包的需求，比如我们在一台http服务器上抓http的某个头是指定值的包及iis给其的响应，而其它的包都不要，用现有工具好像就不好实现了，winddump的规则也顶多指定协议、端口之类，具体包的内容过滤上好像就束手无策了，于是想自己做一个，找了一些wincap开发的资料，貌似c#相关的资料不多，找到一个却不能调试，于是又找了一篇讲c#监控网络流量的文章，改造了一下，做了一个命令行抓包工具，因为遇到一些问题，所以还是半成品。

先贴代码，这是类库

using  System;
using  System.Collections.Generic;
using  System.Text;
using  System.Runtime.InteropServices;
using  System.Net.Sockets;
using  System.Net;

namespace  WawaSoft.WawaCapturer
{
    [StructLayout(LayoutKind.Explicit)]
     public   struct  IPHeader
    {
        [FieldOffset( 0 )]
         public   byte  ip_verlen;         // I4位首部长度+4位IP版本号
        [FieldOffset( 1 )]
         public   byte  ip_tos;             // 8位服务类型TOS
        [FieldOffset( 2 )]
         public   ushort  ip_totallength;  // 16位数据包总长度（字节）
        [FieldOffset( 4 )]
         public   ushort  ip_id;              // 16位标识
        [FieldOffset( 6 )]
         public   ushort  ip_offset;        // 3位标志位
        [FieldOffset( 8 )]
         public   byte  ip_ttl;             // 8位生存时间 TTL
        [FieldOffset( 9 )]
         public   byte  ip_protocol;     // 8位协议(TCP, UDP, ICMP, Etc.)
        [FieldOffset( 10 )]
         public   ushort  ip_checksum;  // 16位IP首部校验和
        [FieldOffset( 12 )]
         public   uint  ip_srcaddr;      // 32位源IP地址
        [FieldOffset( 16 )]
         public   uint  ip_destaddr;    // 32位目的IP地址
    }

     public   class  RawSocket
    {
         private   bool  error_occurred;           // 套接字在接收包时是否产生错误
         public   bool  KeepRunning;               // 是否继续进行
         private   static   int  len_receive_buf;  // 得到的数据流的长度
         byte [] receive_buf_bytes;           // 收到的字节
         private  Socket socket  =   null ;        // 声明套接字
         const   int  SIO_RCVALL  =   unchecked (( int ) 0x98000001 ); // 监听所有的数据包

         public  RawSocket()                     // 构造函数
        {
            error_occurred  =   false ;
            len_receive_buf  =   4096 ;
            receive_buf_bytes  =   new   byte [len_receive_buf];
        }
         public   void  CreateAndBindSocket( string  IP)                   // 建立并绑定套接字
        {
            socket  =   new  Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);
            socket.Blocking  =   false ;                                          // 置socket非阻塞状态
            socket.Bind( new  IPEndPoint(IPAddress.Parse(IP),  0 ));  // 绑定套接字

             if  (SetSocketOption()  ==   false ) error_occurred  =   true ;
        }

         private   bool  SetSocketOption()                            // 设置raw socket
        {
             bool  ret_value  =   true ;
             try
            {
                socket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded,  1 );
                 byte [] IN  =   new   byte [ 4 ] {  1 ,  0 ,  0 ,  0  };
                 byte [] OUT  =   new   byte [ 4 ];

                 // 低级别操作模式,接受所有的数据包，这一步是关键，必须把socket设成raw和IP Level才可用SIO_RCVALL
                 int  ret_code  =  socket.IOControl(SIO_RCVALL, IN, OUT);
                ret_code  =  OUT[ 0 ]  +  OUT[ 1 ]  +  OUT[ 2 ]  +  OUT[ 3 ]; // 把4个8位字节合成一个32位整数
                 if  (ret_code  !=   0 ) ret_value  =   false ;
            }
             catch  (SocketException)
            {
                ret_value  =   false ;
            }
             return  ret_value;
        }

         public   bool  ErrorOccurred
        {
             get
            {
                 return  error_occurred;
            }
        }
         // 解析接收的数据包，形成PacketArrivedEventArgs事件数据类对象，并引发PacketArrival事件
         unsafe   private   void  Receive( byte [] buf,  int  len)
        {
             byte  temp_protocol  =   0 ;
             uint  temp_version  =   0 ;
             uint  temp_ip_srcaddr  =   0 ;
             uint  temp_ip_destaddr  =   0 ;
             short  temp_srcport  =   0 ;
             short  temp_dstport  =   0 ;
            IPAddress temp_ip;

            PacketArrivedEventArgs e  =   new  PacketArrivedEventArgs(); // 新网络数据包信息事件

             fixed  ( byte *  fixed_buf  =  buf)
            {
                IPHeader *  head  =  (IPHeader * )fixed_buf; // 把数据流整和为IPHeader结构
                e.HeaderLength  =  ( uint )(head -> ip_verlen  &   0x0F )  <<   2 ;
                e.IPHeaderBuffer  =   new   byte [e.HeaderLength];

                temp_protocol  =  head -> ip_protocol;
                 switch  (temp_protocol) // 提取协议类型
                {
                     case   1 : e.Protocol  =   " ICMP " ;  break ;
                     case   2 : e.Protocol  =   " IGMP " ;  break ;
                     case   6 : e.Protocol  =   " TCP " ;  break ;
                     case   17 : e.Protocol  =   " UDP " ;  break ;
                     default : e.Protocol  =   " UNKNOWN " ;  break ;
                }

                temp_version  =  ( uint )(head -> ip_verlen  &   0xF0 )  >>   4 ; // 提取IP协议版本
                e.IPVersion  =  temp_version.ToString();

                 // 以下语句提取出了PacketArrivedEventArgs对象中的其他参数
                temp_ip_srcaddr  =  head -> ip_srcaddr;
                temp_ip_destaddr  =  head -> ip_destaddr;
                temp_ip  =   new  IPAddress(temp_ip_srcaddr);
                e.OriginationAddress  =  temp_ip.ToString();
                temp_ip  =   new  IPAddress(temp_ip_destaddr);
                e.DestinationAddress  =  temp_ip.ToString();

                temp_srcport  =   * ( short * ) & fixed_buf[e.HeaderLength];
                temp_dstport  =   * ( short * ) & fixed_buf[e.HeaderLength  +   2 ];
                e.OriginationPort  =  IPAddress.NetworkToHostOrder(temp_srcport).ToString();
                e.DestinationPort  =  IPAddress.NetworkToHostOrder(temp_dstport).ToString();

                e.PacketLength  =  ( uint )len;
                e.MessageLength  =  ( uint )len  -  e.HeaderLength;
                e.MessageBuffer  =   new   byte [e.MessageLength];

                e.ReceiveBuffer  =  buf;
                 // 把buf中的IP头赋给PacketArrivedEventArgs中的IPHeaderBuffer
                Array.Copy(buf,  0 , e.IPHeaderBuffer,  0 , ( int )e.HeaderLength);
                 // 把buf中的包中内容赋给PacketArrivedEventArgs中的MessageBuffer
                Array.Copy(buf, ( int )e.HeaderLength, e.MessageBuffer,  0 , ( int )e.MessageLength);
            }
             // 引发PacketArrival事件
            OnPacketArrival(e);
        }
         public   void  Run()  // 开始监听
        {
            IAsyncResult ar  =  socket.BeginReceive(receive_buf_bytes,  0 , len_receive_buf, SocketFlags.None,  new  AsyncCallback(CallReceive),  this );
        }
         private   void  CallReceive(IAsyncResult ar) // 异步回调
        {
             int  received_bytes;
            received_bytes  =  socket.EndReceive(ar);
            Receive(receive_buf_bytes, received_bytes);
             if  (KeepRunning) Run();
        }
 
         public   void  Shutdown()                                        // 关闭raw socket
        {
             if  (socket  !=   null )
            {
                socket.Shutdown(SocketShutdown.Both);
                socket.Close();
            }
        }

         public   delegate   void  PacketArrivedEventHandler(Object sender, PacketArrivedEventArgs args);
         // 事件句柄：包到达时引发事件
         public   event  PacketArrivedEventHandler PacketArrival; // 声明时间句柄函数
         private   void  OnPacketArrival(PacketArrivedEventArgs e)
        {
            PacketArrivedEventHandler temp  =  PacketArrival;
             if  (temp  !=   null )
                temp( this , e);
        }

         public   class  PacketArrivedEventArgs : EventArgs
        {
             public   uint  HeaderLength;
             public   string  Protocol;
             public   string  IPVersion;
             public   string  OriginationAddress;
             public   string  DestinationAddress;
             public   string  OriginationPort;
             public   string  DestinationPort;
             public   uint  PacketLength;
             public   uint  MessageLength;
             public   byte [] ReceiveBuffer;
             public   byte [] IPHeaderBuffer;
             public   byte [] MessageBuffer;
             public  PacketArrivedEventArgs()
            {
            }
             public   override   string  ToString()
            {
                StringBuilder sb  =   new  StringBuilder();
                sb.Append( "" r " n---------------- " r " n " );
                sb.AppendFormat( " src = {0}:{1}, dst= {2}:{3} " r " n " ,OriginationAddress,OriginationPort,
                    DestinationAddress, DestinationPort);
                sb.AppendFormat( " protocol = {0}, ipVersion={1} " r " n " , Protocol, IPVersion);
                sb.AppendFormat( " PacketLength={0},MessageLength={1} " ,PacketLength,MessageLength);
                sb.Append( "" r " n---------------- " r " n " );
                 return  sb.ToString();
            }
        }

    }
}

具体原理不说了，详情请看这篇文章
http://www.cnblogs.com/onlytiancai/archive/2007/10/14/924075.html

这是控制台代码，愿意是想加上一个tcp分析类和http分析类，然后可以实现http头和内容的过滤。

using  System;
using  System.Collections.Generic;
using  System.Text;
using  System.IO;

namespace  WawaSoft.WawaCapturer
{
     class  Program
    {
         static   void  Main( string [] args)
        {
            RawSocket socket  =   null ;

             try
            {
                socket  =   new  RawSocket();
                socket.CreateAndBindSocket( " 192.168.1.100 " );
                 if  (socket.ErrorOccurred)
                {
                    Console.WriteLine( " 监听出错了 " );
                     return ;
                }
                socket.KeepRunning  =   true ;
                socket.PacketArrival  +=  socket_PacketArrival;
                socket.Run();
            }
             catch  (Exception ex)
            {
                Console.WriteLine(ex);
                 throw ;
            }
             finally
            {
                Console.Read();
                socket.Shutdown();
            }

        }

         static   void  socket_PacketArrival( object  sender, RawSocket.PacketArrivedEventArgs args)
        {
             if  (args.Protocol  ==   " TCP "   &&  (args.OriginationPort  ==   " 80 "   ||  args.DestinationPort  ==   " 80 " ))
            {
                Console.WriteLine(args);
                 byte [] httpData  =   new   byte [args.MessageLength - 20 ];
                Buffer.BlockCopy(args.MessageBuffer,  20 , httpData,  0 , httpData.Length);

                 using  (BinaryWriter bw  =   new  BinaryWriter(File.Open( string .Format( " {0}.cap " ,
                    DateTime.Now.ToString( " yyyyMMdd hh " )),
                    FileMode.OpenOrCreate)))
                {
                    bw.Write(DateTime.Now.ToString());
                    bw.Write(httpData,  0 , httpData.Length);
                    bw.Write( new   byte [] {  0 ,  0 ,  0 ,  0  },  0 ,  4 );  // 结束
                }
                 return ;

                 // System.IO.MemoryStream s = new System.IO.MemoryStream(httpData);
                 // System.IO.BinaryReader r = new System.IO.BinaryReader(s);
                 // byte temp = new byte();
                 // byte temp1;
                 // int i;
                 // bool find = false;
                 // for (i = 0; i < s.Length; i++)
                 // {
                 //     temp1 = r.ReadByte();
                 //     if (temp == 0x0d && temp1 == 0x0a)
                 //     {
                 //         find = true;
                 //         break;
                 //     }
                 //     temp = temp1;
                 // }
                 // if (!find) return;
                 // byte[] httpHeaderData = new byte[httpData.Length - i -1];
                 // Buffer.BlockCopy(httpData, i, httpHeaderData, 0, httpHeaderData.Length);                

                 // Console.WriteLine("http头内容如下"r"n{0}",Encoding.UTF8.GetString(httpHeaderData));

                 // byte[] body = new byte[httpData.Length - httpHeaderData.Length];
                 // Buffer.BlockCopy(httpData, httpHeaderData.Length, body, 0, body.Length);
                 // Console.WriteLine("http内容如下"r"n{0}", Encoding.UTF8.GetString(body));
            }
        }
    }
}

简单说明：ip的头是20个字节，在RawSocket里已经提取出来了，tcp的头也是20字节，我在console里也取了出来，但没有分析（要分析的话看相关链接的第二篇文章），就是说args.MessageBuffer的20字节以后就是http协议的内容了（假如是抓的http的包），然后http的内容基本上是文本的（当然http也传输图片啥的，取决于contenttype头），在第一个回车换行（"r"n，也就是0x0d,0x0a）前面是http头部分，我们根据这个标志位可以取出http头，然后"r"n下面就是http的正文消息了，我们根据http头的ContentType来决定把正文的数据解析成一个图片还是一段html。如果我们只抓取html正文里包含"蛙蛙池塘"的数据包，我们就可以用响应编码类的getstring方法获取html正文字符串后用indexof方法来判断是否抓取该包。
以上纯属个人想法，结果编码的时候死活编不出来，问题如下，请高手指教。
1、我用Encoding.UTF8.GetString所有http的数据，结果中文死活出不来，我把byte[]保存到硬盘上用UE打开，转换编码，还是不能识别中文，我就抓的google的包，铁定是utf-8编码的，我就纳闷了，怎么能取出中文的数据呀。
2、每次触发PacketArrival事件，是不是有可能是收到半截儿的数据呀，比方是tcp的一次传输数据大于MTU的1500的值，一个数据传输了5次，会不会触发5次PacketArrival事件呀。难道还得自己根据ip协议的序号来拼合多次接受的数据不成？
3、在一个byte[]里怎么查找"r"n的值呀，我的算法是用一个循环加两个临时变量做的，貌似复杂了点儿，而且算法根本就不对好像，用Array.IndexOf<T>()方法和Array.FindAll方法貌似也不行，大家看看怎么弄比较好。

最后我就想着，做成一个命令行工具，参数里可以设置要抓取包的协议，来源地址，目的地址，来源端口，目的端口，数据里包含的字符串，有这几个就够了，因为我们一般在服务器出错，或者怀疑有人攻击服务器的时候会抓取某些包含特殊攻击字符或者来源于某些特定访问者（不一定是IP，IP的话用windump的规则就可以指定，而可能是一个http头或者cookie标识的一个应用层的用户）的数据包，要把所有包都抓回来，分析起来会很费力。

有了这个小工具，会很方便做网络应用的朋友，大家谁有兴趣，一起完善哦，哥们是积穷了，弄了三四个小时了还没弄好

相关链接：
用协议分析工具学习TCP/IP
http://www.cnpaf.net/class/OtherAnalysis/0532918532942694.html
TCP/IP协议数据报结构详解
http://www.itvue.com/Article/CISCO/CIROUTE/200607/1683.html
Raw Socket Capturing Using C#
http://www.codeproject.com/csharp/pktcap.asp

声明：类库是我从一篇文章里整理出来的，版权规原作者所有，但实在找不出出处了。