一步一步开发sniffer(Winpcap+MFC)(五)莫道无人能识君,其实我懂你的心——解析数据包

前文已经讲过,解析数据包主要通过analyze_frame()这个函数实现的,实际上并非这个函数完成了所有的功能,其实从名字就可以看出,它只是完成了对“帧”的解析,也就是链路层数据的解析,还有analyze_arp()、analyze_ip()、analyze_ip6()、analyze_icmp()……等来完成其他协议层的解析工作。

为什么会这样定义?熟悉协议栈工作流程的都知道,数据是由应用层把数据加上应用层协议头后给传输层,传输层在最外面加上它的头部后给网络层,网络层在外面加上它的头部后再给链路层……所以当数据包被捕获到之后最外面的就是链路层的协议头,因此首先要解析的就是链路层协议,这也就是为什么首先要调用analyze_frame()这个函数了,然后再一层一层把它“剥开”,最终获得里面的数据。

每一层的上层可能有多种协议在工作,比如IP上层就有TCP和UDP等之分,所以在解析数据包的时候需要根据不同的特征来判断上层协议到底是什么,然后再来调用相关的函数对其进行解析,下面将列出一些主要的判断特征:

1、  链路层--网络层

网络层可能会有arp、ipv4、ipv6这三种不同的情况,在链路层定义了一个type字段,专门用于指示网络层数据包是什么类型。

type == 0x0806 表示这是一个arp包

type == 0x0800 表示这是一个ipv4包

type == 0x86dd 表示这是一个ipv6包

2、  网络层(IP层)--传输层

IP层之上可能会有tcp、udp、icmp等

IPv4协议定义了proto字段来指示传输层协议是什么。还记得上一章的Protocol.h文件中的这段定义不?proto什么值对应什么协议很明白了吧?

#definePROTO_ICMP 1

#define PROTO_TCP 6                                          

#define PROTO_UDP 17 

IPv6使用nh字段来标明传输层协议,如下:

nh== 0x3a 表示上层是icmpv6

nh== 0x06 表示上层是tcp

nh== 0x11 表示上层是udp

3、  传输层之上就是应用层了,这里我们的应用层只支持http协议,判断方法很简单,就是看目的或源端口是不是80。

余下的工作就是一个字段一个字段地获取数据包的值了。函数的整体调用关系如下图:


需要特别说明的一点是,网络中的字节顺序跟主机中的字节顺序是完全不一样的,所以特别是要获得数字的值的时候,一定要先调用ntohs()函数(network to host short)或ntohl()函数(network to host long)将数据包的网络字节顺转换为主机字节序,这样在做一些判断的时候才是准确的。

下一章:千呼万唤始出来,不抱琵琶也露面——将解析数据写到GUI上


解析函数的代码如下:

/*pkt为网络中捕获的包,data为要存为本机上的数据*/

/*分析链路层*/
int analyze_frame(const u_char * pkt,struct datapkt * data,struct pktcount *npacket)
{
		int i;
		struct ethhdr *ethh = (struct ethhdr*)pkt;
		data->ethh = (struct ethhdr*)malloc(sizeof(struct ethhdr));
		if(NULL == data->ethh)
			return -1;
	
		for(i=0;i<6;i++)
		{
			data->ethh->dest[i] = ethh->dest[i];
			data->ethh->src[i] = ethh->src[i];
		}
	
		npacket->n_sum++;

		/*由于网络字节顺序原因,需要对齐*/
		data->ethh->type = ntohs(ethh->type);

		//处理ARP还是IP包?
		switch(data->ethh->type)
		{
			case 0x0806:
				return analyze_arp((u_char*)pkt+14,data,npacket);      //mac 头大小为14
				break;
			case 0x0800:				
				return analyze_ip((u_char*)pkt+14,data,npacket);
				break;
			case 0x86dd:		
				return analyze_ip6((u_char*)pkt+14,data,npacket);			
				return -1;
				break;
			default:
				npacket->n_other++;
				return -1;
				break;
		}
		return 1;
}

/*分析网络层:ARP*/
int analyze_arp(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	int i;
	struct arphdr *arph = (struct arphdr*)pkt;
	data->arph = (struct arphdr*)malloc(sizeof(struct arphdr));
	
	if(NULL == data->arph )
		return -1;
	
	//复制IP及MAC
	for(i=0;i<6;i++)
	{
		if(i<4)
		{
			data->arph->ar_destip[i] = arph->ar_destip[i];
			data->arph->ar_srcip[i] = arph->ar_srcip[i];
		}
		data->arph->ar_destmac[i] = arph->ar_destmac[i];
		data->arph->ar_srcmac[i]= arph->ar_srcmac[i];
	}

	data->arph->ar_hln = arph->ar_hln;
	data->arph->ar_hrd = ntohs(arph->ar_hrd);
	data->arph->ar_op = ntohs(arph->ar_op);
	data->arph->ar_pln = arph->ar_pln;
	data->arph->ar_pro = ntohs(arph->ar_pro);

	strcpy(data->pktType,"ARP");
	npacket->n_arp++;
	return 1;
}

/*分析网络层:IP*/
int analyze_ip(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	int i;
	struct iphdr *iph = (struct iphdr*)pkt;
	data->iph = (struct iphdr*)malloc(sizeof(struct iphdr));
	
	if(NULL == data->iph)
		return -1;
	data->iph->check = iph->check;
	npacket->n_ip++;
	
	/*for(i = 0;i<4;i++)
	{
		data->iph->daddr[i] = iph->daddr[i];
		data->iph->saddr[i] = iph->saddr[i];
	}*/
	data->iph->saddr = iph->saddr;
	data->iph->daddr = iph->daddr;

	data->iph->frag_off = iph->frag_off;
	data->iph->id = iph->id;
	data->iph->proto = iph->proto;
	data->iph->tlen = ntohs(iph->tlen);
	data->iph->tos = iph->tos;
	data->iph->ttl = iph->ttl;
	data->iph->ihl = iph->ihl;
	data->iph->version = iph->version;
	//data->iph->ver_ihl= iph->ver_ihl;
	data->iph->op_pad = iph->op_pad;

	int iplen = iph->ihl*4;							//ip头长度
	switch(iph->proto)
	{
		case PROTO_ICMP:
			return analyze_icmp((u_char*)iph+iplen,data,npacket);
			break;
		case PROTO_TCP:
			return analyze_tcp((u_char*)iph+iplen,data,npacket);
			break;
		case PROTO_UDP:
			return analyze_udp((u_char*)iph+iplen,data,npacket);
			break;
		default :
			return-1;
			break;
	}
	return 1;
}

/*分析网络层:IPV6*/
int analyze_ip6(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	int i;
	struct iphdr6 *iph6 = (struct iphdr6*)pkt;
	data->iph6 = (struct iphdr6*)malloc(sizeof(struct iphdr6));
	
	if(NULL == data->iph6)
		return -1;

	npacket->n_ip6++;
	
	data->iph6->version = iph6->version;
	data->iph6->flowtype = iph6->flowtype;
	data->iph6->flowid = iph6->flowid;
	data->iph6->plen = ntohs(iph6->plen);
	data->iph6->nh = iph6->nh;
	data->iph6->hlim =iph6->hlim;

	for(i=0;i<16;i++)
	{
		data->iph6->saddr[i] = iph6->saddr[i];
		data->iph6->daddr[i] = iph6->daddr[i];
	}
	
	switch(iph6->nh)
	{
		case 0x3a:					
			return analyze_icmp6((u_char*)iph6+40,data,npacket);
			break;
		case 0x06:
			return analyze_tcp((u_char*)iph6+40,data,npacket);
			break;
		case 0x11:
			return analyze_udp((u_char*)iph6+40,data,npacket);
			break;
		default :
			return-1;
			break;
	}
	//npacket->n_ip6++;
	//strcpy(data->pktType,"IPV6");
	return 1;
}
	
/*分析传输层:ICMP*/
int analyze_icmp(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	struct icmphdr* icmph = (struct icmphdr*)pkt;
	data->icmph = (struct icmphdr*)malloc(sizeof(struct icmphdr));
	
	if(NULL == data->icmph)
		return -1;

	data->icmph->chksum = icmph->chksum;
	data->icmph->code = icmph->code;
	data->icmph->seq =icmph->seq;
	data->icmph->type = icmph->type;
	strcpy(data->pktType,"ICMP");
	npacket->n_icmp++;
	return 1;
}

/*分析传输层:ICMPv6*/
int analyze_icmp6(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	int i;
	struct icmphdr6* icmph6 = (struct icmphdr6*)pkt;
	data->icmph6 = (struct icmphdr6*)malloc(sizeof(struct icmphdr6));
	
	if(NULL == data->icmph6)
		return -1;

	data->icmph6->chksum = icmph6->chksum;
	data->icmph6->code = icmph6->code;
	data->icmph6->seq =icmph6->seq;
	data->icmph6->type = icmph6->type;
	data->icmph6->op_len = icmph6->op_len;
	data->icmph6->op_type = icmph6->op_type;
	for(i=0;i<6;i++)
	{
		data->icmph6->op_ethaddr[i] = icmph6->op_ethaddr[i];
	}
	strcpy(data->pktType,"ICMPv6");
	npacket->n_icmp6++;
	return 1;
}

/*分析传输层:TCP*/
int analyze_tcp(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	struct tcphdr *tcph = (struct tcphdr*)pkt;
	data->tcph = (struct tcphdr*)malloc(sizeof(struct tcphdr));
	if(NULL == data->tcph)
		return -1;
	
	data->tcph->ack_seq = tcph->ack_seq;
	data->tcph->check = tcph->check;
	
	data->tcph->doff = tcph->doff;
	data->tcph->res1 = tcph->res1;
	data->tcph->cwr = tcph->cwr;
	data->tcph->ece = tcph->ece;
	data->tcph->urg = tcph->urg;
	data->tcph->ack = tcph->ack;
	data->tcph->psh = tcph->psh;
	data->tcph->rst = tcph->rst;
	data->tcph->syn = tcph->syn;
	data->tcph->fin = tcph->fin;
	//data->tcph->doff_flag = tcph->doff_flag;

	data->tcph->dport = ntohs(tcph->dport);
	data->tcph->seq = tcph->seq;
	data->tcph->sport = ntohs(tcph->sport);
	data->tcph->urg_ptr = tcph->urg_ptr;
	data->tcph->window= tcph->window;
	data->tcph->opt = tcph->opt;
	
	/*不要忘记http分支*/
	if(ntohs(tcph->dport) == 80 || ntohs(tcph->sport)==80)
	{
		npacket->n_http++;
		strcpy(data->pktType,"HTTP");
	}
	else{
		npacket->n_tcp++;
		strcpy(data->pktType,"TCP");	
	}
	return 1;
}

/*分析传输层:UDP*/
int analyze_udp(const u_char* pkt,datapkt *data,struct pktcount *npacket)
{
	struct udphdr* udph = (struct udphdr*)pkt;
	data->udph = (struct udphdr*)malloc(sizeof(struct udphdr));
	if(NULL == data->udph )
		return -1;

	data->udph->check = udph->check;
	data->udph->dport = ntohs(udph->dport);
	data->udph->len = ntohs(udph->len);
	data->udph->sport = ntohs(udph->sport);

	strcpy(data->pktType,"UDP");
	npacket->n_udp++;
	return 1;
}


  • 5
    点赞
  • 32
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
以下是基于MFC+WinPcap网络嗅探器的实现步骤: 1. 创建MFC对话框应用程序。 2. 下载和安装WinPcap库,并将其添加到项目中。 3. 在对话框中添加一个列表框控件,用于显示捕获到的数据包。 4. 在对话框头文件中包含WinPcap库的头文件pcap.h,并定义一个pcap_t类型的变量用于打开网络适配器。 5. 在OnInitDialog()函数中初始化WinPcap库,并打开网络适配器。 6. 创建一个线程来捕获数据包,在线程函数中使用pcap_loop()函数来持续捕获数据包,并将捕获到的数据包添加到列表框中。 7. 在OnDestroy()函数中关闭网络适配器和WinPcap库。 以下是基于MFC+WinPcap网络嗅探器的代码示例: ```cpp #include "stdafx.h" #include "MySnifferDlg.h" #include "afxdialogex.h" #include <pcap.h> #ifdef _DEBUG #define new DEBUG_NEW #endif // CMySnifferDlg 对话框 CMySnifferDlg::CMySnifferDlg(CWnd* pParent /*=nullptr*/) : CDialogEx(IDD_MYSNIFFER_DIALOG, pParent) { m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); } void CMySnifferDlg::DoDataExchange(CDataExchange* pDX) { CDialogEx::DoDataExchange(pDX); DDX_Control(pDX, IDC_LIST_PACKETS, m_listPackets); } BEGIN_MESSAGE_MAP(CMySnifferDlg, CDialogEx) ON_WM_PAINT() ON_WM_QUERYDRAGICON() ON_WM_DESTROY() END_MESSAGE_MAP() // CMySnifferDlg 消息处理程序 BOOL CMySnifferDlg::OnInitDialog() { CDialogEx::OnInitDialog(); // 将“关于...”菜单项添加到系统菜单中。 // IDM_ABOUTBOX 必须在系统命令范围内。 ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX); ASSERT(IDM_ABOUTBOX < 0xF000); CMenu* pSysMenu = GetSystemMenu(FALSE); if (pSysMenu != nullptr) { CString strAboutMenu; strAboutMenu.LoadString(IDS_ABOUTBOX); if (!strAboutMenu.IsEmpty()) { pSysMenu->AppendMenu(MF_SEPARATOR); pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu); } } // 设置此对话框的图标。当应用程序主窗口不是对话框时,框架将自动 // 执行此操作 SetIcon(m_hIcon, TRUE); // 设置大图标 SetIcon(m_hIcon, FALSE); // 设置小图标 // TODO: 在此添加额外的初始化代码 // 初始化WinPcap库 char errbuf[PCAP_ERRBUF_SIZE]; pcap_t* pcapHandle = pcap_open_live("\\Device\\NPF_{E908B419-FF05-408B-B4F6-8E82FBC3D16D}", // 网络适配器名称 65536, // 数据包最大长度 1, // 混杂模式 1000, // 超时时间(毫秒) errbuf); // 错误信息缓冲区 if (pcapHandle == NULL) { AfxMessageBox(_T("打开网络适配器失败!")); return TRUE; } // 开始捕获数据包 AfxBeginThread(CaptureThreadProc, (LPVOID)pcapHandle); return TRUE; // 除非将焦点设置到控件,否则返回 TRUE } void CMySnifferDlg::OnDestroy() { CDialogEx::OnDestroy(); // TODO: 在此处添加消息处理程序代码 // 关闭WinPcap库和网络适配器 pcap_t* pcapHandle = (pcap_t*)GetWindowLongPtr(GetSafeHwnd(), GWLP_USERDATA); pcap_close(pcapHandle); } void CMySnifferDlg::OnPaint() { if (IsIconic()) { CPaintDC dc(this); // 用于绘制的设备上下文 SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0); // 使图标在工作区矩形中居中 int cxIcon = GetSystemMetrics(SM_CXICON); int cyIcon = GetSystemMetrics(SM_CYICON); CRect rect; GetClientRect(&rect); int x = (rect.Width() - cxIcon + 1) / 2; int y = (rect.Height() - cyIcon + 1) / 2; // 绘制图标 dc.DrawIcon(x, y, m_hIcon); } else { CDialogEx::OnPaint(); } } HCURSOR CMySnifferDlg::OnQueryDragIcon() { return static_cast<HCURSOR>(m_hIcon); } UINT CMySnifferDlg::CaptureThreadProc(LPVOID lpParam) { pcap_t* pcapHandle = (pcap_t*)lpParam; // 定义捕获数据包时的回调函数 void packetHandler(u_char* userData, const struct pcap_pkthdr* pkthdr, const u_char* packetData) { CMySnifferDlg* pThis = (CMySnifferDlg*)userData; // 将捕获到的数据包添加到列表框中 CString strPacket; strPacket.Format(_T("Packet size: %d bytes"), pkthdr->len); pThis->m_listPackets.AddString(strPacket); } // 开始捕获数据包 pcap_loop(pcapHandle, 0, packetHandler, (u_char*)AfxGetApp()->m_pMainWnd); return 0; } ``` 注意:上述代码中的网络适配器名称需要根据实际情况修改。可以使用WinPcap提供的pcap_findalldevs()函数来获取可用的网络适配器列表。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值