请教有关C#开发抓取、分析网络数据包的程序，好象这方面的资料比较少，大家帮忙讨论一下

Question

老师让写一个抓包分析的程序，我看了一下C#方面的资料感觉比较少，所以请教一下大家，有没有什么思路，或是代码给一些，十分感谢了

Answer 1

using System;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Windows.Forms;
 
[StructLayout(LayoutKind.Explicit)]
public struct IPHeader
{
[FieldOffset(0)] public byte    ip_verlen; 
[FieldOffset(1)] public byte    ip_tos; 
[FieldOffset(2)] public ushort  ip_totallength;
[FieldOffset(4)] public ushort  ip_id;
[FieldOffset(6)] public ushort  ip_offset; 
[FieldOffset(8)] public byte    ip_ttl; 
[FieldOffset(9)] public byte    ip_protocol; 
[FieldOffset(10)] public ushort ip_checksum; 
[FieldOffset(12)] public uint   ip_srcaddr; 
[FieldOffset(16)] public uint   ip_destaddr; 
} 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_R = unchecked((int)0x98000001);
const int SIO_1=unchecked((int)0x98000002);
const int SIO_2=unchecked((int)0x98000003);
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;
} public void Shutdown()
{
if(socket != null)
{
socket.Shutdown(SocketShutdown.Both);
socket.Close();
}
} private bool SetSocketOption()
{
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];  
int ret_code = socket.IOControl(SIO_R, IN, OUT);//低级别操作模式
ret_code = OUT[0] + OUT[1] + OUT[2] + OUT[3];//把4个8位字节合成一个32位整数
System.Windows.Forms.MessageBox.Show(ret_code.ToString());
if(ret_code != 0) ret_value = false;
}
catch(SocketException)
{
ret_value = false;
}
return ret_value;
}

Answer 2

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; //return; PacketArrivedEventArgs e=new PacketArrivedEventArgs(); fixed(byte *fixed_buf = buf)
{
IPHeader * head = (IPHeader *) fixed_buf;
e.HeaderLength=(uint)(head->ip_verlen & 0x0F) << 2;
    
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;
e.IPVersion = temp_version.ToString(); 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();
// if(e.DestinationAddress!="211.87.212.116"||int.Parse(e.DestinationPort)>1000)
// {
//  return;
// }
e.PacketLength =(uint)len;
e.MessageLength =(uint)len - e.HeaderLength; 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();
}

Answer 3

public class PacketArrivedEventArgs : EventArgs 
{
public PacketArrivedEventArgs() 
{
this.protocol = "";
this.destination_port  = "";
this.origination_port  = "";
this.destination_address  = "";
this.origination_address  = "";
this.ip_version  = ""; this.total_packet_length =0;
this.message_length =0;
this.header_length =0; this.receive_buf_bytes=new byte[len_receive_buf];
this.ip_header_bytes=new byte[len_receive_buf];
this.message_bytes=new byte[len_receive_buf];
} public string Protocol
{
get {return protocol;}
set {protocol=value;}
}
public string DestinationPort
{
get {return destination_port;}
set {destination_port=value;}
}
public string OriginationPort
{
get {return origination_port;}
set {origination_port=value;}
}
public string DestinationAddress
{
get {return destination_address;}
set {destination_address=value;}
}
public string OriginationAddress
{
get {return origination_address;}
set {origination_address=value;}
}
public string IPVersion
{
get {return ip_version;}
set {ip_version=value;}
}
public uint PacketLength
{
get {return total_packet_length;}
set {total_packet_length=value;}
}
public uint MessageLength
{
get {return message_length;}
set {message_length=value;}
}
public uint HeaderLength
{
get {return header_length;}
set {header_length=value;}
}
public byte [] ReceiveBuffer
{
get {return receive_buf_bytes;}
set {receive_buf_bytes=value;}
}
public byte [] IPHeaderBuffer
{
get {return ip_header_bytes;}
set {ip_header_bytes=value;}
}
public byte [] MessageBuffer
{
get {return message_bytes;}
set {message_bytes=value;}
}
private string protocol;
private string destination_port;
private string origination_port;
private string destination_address;
private string origination_address;
private string ip_version;
private uint total_packet_length;
private uint message_length;
private uint header_length;
private byte []receive_buf_bytes = null;
private byte []ip_header_bytes = null;
private byte []message_bytes = null;
} public delegate void PacketArrivedEventHandler(
Object sender, PacketArrivedEventArgs args); public event PacketArrivedEventHandler PacketArrival; protected virtual void OnPacketArrival(PacketArrivedEventArgs e) 
{
if (PacketArrival != null) 
{
PacketArrival(this, e);
}
}
}
}