socket做的简单网络嗅探器

最新推荐文章于 2022-05-06 23:57:12 发布
最新推荐文章于 2022-05-06 23:57:12 发布
阅读量902 收藏 9
点赞数
分类专栏： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BooleanWater/article/details/106590893
版权
本文详细介绍了一个基于Windows平台的网络数据包监听程序的设计与实现，涵盖了数据包捕获、解析及显示等核心功能。文章深入探讨了IP、TCP、UDP、ICMP等协议的解析方法，展示了如何通过Winsock API进行原始套接字编程，实现网络监听。此外，还介绍了如何利用多线程技术提高监听效率，以及如何在GUI中展示解析后的数据包信息。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

SniffDlg.h : 头文件

	
// SniffDlg.h : 头文件
//

#pragma once
#include "afxcmn.h"
#include "afxwin.h"
typedef struct _PROTN2T
{
	int proto;
	char *pprototext;
}PROTN2T;

#define PROTO_NUM 11

/* The IP header */
typedef struct _IPHEADER {
	unsigned char  header_len : 4;
	unsigned char  version : 4;
	unsigned char  tos;            // type of service
	unsigned short total_len;      // length of the packet
	unsigned short ident;          // unique identifier
	unsigned short flags;
	unsigned char  ttl;
	unsigned char  proto;          // protocol ( IP , TCP, UDP etc)
	unsigned short checksum;
	unsigned int   sourceIP;
	unsigned int   destIP;

}IPHEADER;

#define UDP_HEAD_LEN 8	/* UDP head length */

#define PSEUDO_HEAD_LEN 12	/* Pseudo head length */

#define ICMP_HEAD_LEN 4	/* ICMP head length */

struct TCPPacketHead {
	WORD SourPort;
	WORD DestPort;
	DWORD SeqNo;
	DWORD AckNo;
	BYTE HLen;
	BYTE Flag;
	WORD WndSize;
	WORD ChkSum;
	WORD UrgPtr;
};

struct ICMPPacketHead {
	BYTE Type;
	BYTE Code;
	WORD ChkSum;
};

struct UDPPacketHead {
	WORD SourPort;
	WORD DestPort;
	WORD Len;
	WORD ChkSum;
};

// CSniffDlg 对话框
class CSniffDlg : public CDialogEx
{
// 构造
public:
	CSniffDlg(CWnd* pParent = NULL);	// 标准构造函数
	void AddData(CString s0, CString s1, CString s2, CString s3, CString s4, CString s5, CString s6);
// 对话框数据
#ifdef AFX_DESIGN_TIME
	enum { IDD = IDD_SNIFF_DIALOG };
#endif
	CListCtrl m_ctrList;
	CButton m_start;

protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV 支持


// 实现
protected:
	HICON m_hIcon;

	DWORD  m_ipsource; // IP in net format
	DWORD  m_iphostsource; // same IP in host format
	DWORD  m_iphost;
	DWORD  m_ipcheckedhost;
	SOCKET m_s;
	DWORD  m_threadID;
	BOOL   m_Multihomed;
	BOOL   m_Local;
	CDWordArray m_IPArr;

	friend UINT threadFunc(LPVOID p);

	// 生成的消息映射函数
	virtual BOOL OnInitDialog();
	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	DECLARE_MESSAGE_MAP()
	
public:
	afx_msg void OnBnClickedLookup();
	afx_msg void OnBnClickedOk();
private:
	CComboBox m_cAdapter;
public:
	afx_msg void OnSelendokComboAdapter();
};

SniffDlg.cpp : 实现文件


// SniffDlg.cpp : 实现文件
//

#include "stdafx.h"
#include "Sniff.h"
#include "SniffDlg.h"
#include "afxdialogex.h"

#pragma comment(lib, "IPHLPAPI.lib") 
#include "Iphlpapi.h"
#include "mstcpip.h"//SIO_RCVALL

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

PROTN2T aOfProto[PROTO_NUM + 1] =
{
	{ IPPROTO_IP   , "IP" },
	{ IPPROTO_ICMP , "ICMP" },
	{ IPPROTO_IGMP , "IGMP" },
	{ IPPROTO_GGP  , "GGP" },
	{ IPPROTO_TCP  , "TCP" },
	{ IPPROTO_PUP  , "PUP" },
	{ IPPROTO_UDP  , "UDP" },
	{ IPPROTO_IDP  , "IDP" },
	{ IPPROTO_ND   , "NP" },
	{ IPPROTO_RAW  , "RAW" },
	{ IPPROTO_MAX  , "MAX" },
	{ NULL , "" }
};

char *get_proto_name(unsigned char proto)
{
	BOOL bFound = FALSE;
	int i;
	for (i = 0; i < PROTO_NUM; i++)
	{
		if (aOfProto[i].proto == proto)
		{
			bFound = TRUE;
			break;
		}
	}
	if (bFound)
		return aOfProto[i].pprototext;
	return aOfProto[PROTO_NUM].pprototext;
}
// 用于应用程序“关于”菜单项的 CAboutDlg 对话框

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();

// 对话框数据
#ifdef AFX_DESIGN_TIME
	enum { IDD = IDD_ABOUTBOX };
#endif

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

// 实现
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()


// CSniffDlg 对话框



CSniffDlg::CSniffDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(IDD_SNIFF_DIALOG, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

	m_threadID = 0;
	m_Multihomed = FALSE;
	m_Local = TRUE;
}

void CSniffDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST, m_ctrList);
	DDX_Control(pDX, IDC_LOOKUP, m_start);
	DDX_Control(pDX, IDC_COMBO_ADAPTER, m_cAdapter);
}

BEGIN_MESSAGE_MAP(CSniffDlg, CDialogEx)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_LOOKUP, &CSniffDlg::OnBnClickedLookup)
	ON_BN_CLICKED(IDOK, &CSniffDlg::OnBnClickedOk)
	ON_CBN_SELENDOK(IDC_COMBO_ADAPTER, &CSniffDlg::OnSelendokComboAdapter)
END_MESSAGE_MAP()


// CSniffDlg 消息处理程序

BOOL CSniffDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	// 将“关于...”菜单项添加到系统菜单中。

	// IDM_ABOUTBOX 必须在系统命令范围内。
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// 设置此对话框的图标。  当应用程序主窗口不是对话框时，框架将自动
	//  执行此操作
	SetIcon(m_hIcon, TRUE);			// 设置大图标
	SetIcon(m_hIcon, FALSE);		// 设置小图标

	// TODO: 在此添加额外的初始化代码
	CHAR		szHostName[128] = { 0 };
	HOSTENT*	pHost = NULL;
	CHAR*		pszIp = NULL;
	int			iNum = 0;
	if (AfxSocketInit(NULL) == FALSE)
	{
		AfxMessageBox("Sorry, socket load error!");
		return FALSE;
	}
	if (gethostname(szHostName, 128) == 0)
	{
		pHost = gethostbyname(szHostName);
		if (pHost != NULL)
		{
			for (pszIp = *pHost->h_addr_list;pszIp != NULL;pszIp = *(pHost->h_addr_list + iNum))
			{
				m_cAdapter.InsertString(iNum++, inet_ntoa(*(in_addr*)pszIp));
			}
			pszIp = inet_ntoa(*(in_addr*)pHost->h_addr_list[0]);
			m_ipsource = inet_addr(pszIp);
			m_cAdapter.SetCurSel(0);
		}
		else
		{
			AfxMessageBox("pHost = NULL!");
		}
	}
	else
	{
		AfxMessageBox("can't find host name!");
	}

	DWORD dwStyle = GetWindowLong(m_ctrList.GetSafeHwnd(), GWL_STYLE);
	dwStyle &= ~LVS_TYPEMASK;
	dwStyle |= LVS_REPORT;
	SetWindowLong(m_ctrList.GetSafeHwnd(), GWL_STYLE, dwStyle);

	m_ctrList.InsertColumn(0, "数据", LVCFMT_LEFT, 525);
	m_ctrList.InsertColumn(0, "大小", LVCFMT_LEFT, 80);
	m_ctrList.InsertColumn(0, "端口", LVCFMT_LEFT, 40);
	m_ctrList.InsertColumn(0, "目的地址", LVCFMT_LEFT, 100);
	m_ctrList.InsertColumn(0, "端口", LVCFMT_LEFT, 40);
	m_ctrList.InsertColumn(0, "源地址", LVCFMT_LEFT, 100);
	m_ctrList.InsertColumn(0, "协议", LVCFMT_LEFT, 50);

	::SendMessage(m_ctrList.m_hWnd, LVM_SETEXTENDEDLISTVIEWSTYLE,
		LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);

	// Here read all IPs of this host
	DWORD dwSize = 0;
	GetIpAddrTable(NULL, &dwSize, FALSE);
	PMIB_IPADDRTABLE pIpAddrTable = (PMIB_IPADDRTABLE)new BYTE[dwSize];
	if (pIpAddrTable)
	{
		if (GetIpAddrTable((PMIB_IPADDRTABLE)pIpAddrTable,   // // buffer for IP table
			&dwSize,                // size of buffer
			FALSE                  // sort by IP address 
			) == NO_ERROR)
		{
			if (pIpAddrTable->dwNumEntries > 2) // Second is MS TCP loopback IP ( 127.0.0.1 )
			{
				m_Multihomed = TRUE;
				char szIP[16];
				for (int i = 0; i < (int)pIpAddrTable->dwNumEntries; i++)
				{
					in_addr ina;
					ina.S_un.S_addr = pIpAddrTable->table[i].dwAddr;
					char *pIP = inet_ntoa(ina);
					strcpy(szIP, pIP);
					if (stricmp(szIP, "127.0.0.1"))
						m_IPArr.Add(pIpAddrTable->table[i].dwAddr);
				}
			}
		}
		delete[] pIpAddrTable;
	}
	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

void CSniffDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialogEx::OnSysCommand(nID, lParam);
	}
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。  对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CSniffDlg::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 CSniffDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

UINT threadFunc(LPVOID p)
{
	CSniffDlg *pDlg = static_cast<CSniffDlg *>(p);
	char  buf[1000], *bufwork;
	MSG   msg;
	int   iRet;
	DWORD dwErr;
	char  *pSource, *pDest;
	IPHEADER *pIpHeader;
	in_addr ina;
	char   szSource[16], szDest[16], szErr[50];
	char *pLastBuf = NULL;

	int		HdrLen, totallen;
	WORD	sourport, destport;

	struct TCPPacketHead	*pTCPHead;
	struct ICMPPacketHead	*pICMPHead;
	struct UDPPacketHead	*pUDPHead;
	BYTE					*pdata = NULL;

	/*---------------------------------------------------------------------*/

	PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE); // Force to make the queue强制为该线程创建消息队列
	pDlg->m_threadID = GetCurrentThreadId();

	while (TRUE)
	{
		if (PeekMessage(&msg, 0, WM_CLOSE, WM_CLOSE, PM_NOREMOVE))
		{
			closesocket(pDlg->m_s);
			pDlg->m_threadID = 0;
			pDlg->m_start.EnableWindow(TRUE);
			break;
		}
		memset(buf, 0, sizeof(buf));
		iRet = recv(pDlg->m_s, buf, sizeof(buf), 0);
		if (iRet == SOCKET_ERROR)
		{
			dwErr = WSAGetLastError();
			sprintf(szErr, "Error recv() = %ld ", dwErr);
			continue;
		}
		else
		{
			if (*buf)
			{
				bufwork = buf;
				pIpHeader = (IPHEADER *)bufwork;
				WORD iLen = ntohs(pIpHeader->total_len);
				while (TRUE)
				{
					if (iLen <= iRet)
					{
						ina.S_un.S_addr = pIpHeader->sourceIP;
						pSource = inet_ntoa(ina);
						strcpy(szSource, pSource);
						ina.S_un.S_addr = pIpHeader->destIP;
						pDest = inet_ntoa(ina);
						strcpy(szDest, pDest);
						CString str, strProto, strSourPort, strDestPort, strData, strSize;


						strProto = get_proto_name(pIpHeader->proto);

						/*-------------------zhuwei add(2002.11.9)-----------------------------*/
						HdrLen = pIpHeader->header_len & 0xf;
						HdrLen *= 4;
						totallen = ntohs(pIpHeader->total_len);
						totallen -= HdrLen;
						switch (pIpHeader->proto)
						{
						case IPPROTO_ICMP:
						{
							pICMPHead = (struct ICMPPacketHead *)(buf + HdrLen);
							//strL4.Format(" type:%d code:%d\n",pICMPHead->Type,pICMPHead->Code);
							strSourPort = "-";
							strDestPort = "-";
							pdata = ((BYTE *)pICMPHead) + ICMP_HEAD_LEN;
							totallen -= ICMP_HEAD_LEN;
							break;
						}
						case IPPROTO_TCP:
						{
							pTCPHead = (struct TCPPacketHead *)(buf + HdrLen);
							sourport = ntohs(pTCPHead->SourPort);
							destport = ntohs(pTCPHead->DestPort);
							//strL4.Format(" sour port:%d,dest port:%d",sourport,destport);
							strSourPort.Format("%d", sourport);
							strDestPort.Format("%d", destport);
							HdrLen = (pTCPHead->HLen) >> 4;  //in fact only 4 bits
							HdrLen *= 4;
							pdata = ((BYTE *)pTCPHead) + HdrLen;
							totallen -= HdrLen;
							break;
						}
						case IPPROTO_UDP:
						{
							pUDPHead = (struct UDPPacketHead *)(buf + HdrLen);
							sourport = ntohs(pUDPHead->SourPort);
							destport = ntohs(pUDPHead->DestPort);
							//strL4.Format(" sour port:%d,dest port:%d",sourport,destport);
							strSourPort.Format("%d", sourport);
							strDestPort.Format("%d", destport);
							pdata = ((BYTE *)pUDPHead) + UDP_HEAD_LEN;
							totallen -= UDP_HEAD_LEN;
							break;
						}
						}

						if (pIpHeader->proto == IPPROTO_ICMP)
							strData.Format("type:%d code:%d data:%s", pICMPHead->Type, pICMPHead->Code, pdata);
						else strData.Format("  %s", pdata);

						strSize.Format("%d", totallen);
						pDlg->AddData(strProto, szSource, strSourPort, szDest, strDestPort, strSize, strData);

						if (iLen < iRet)
						{
							iRet -= iLen;
							bufwork += iLen;
							pIpHeader = (IPHEADER *)bufwork;
						}
						else
							break; // pIpHeader->total_len == iRet and go out
					}
					else
					{ // read last part of buf. I wrote it , but always recv() read exactly 
					  // the lenght of the packet
						int iLast = iLen - iRet;
						pLastBuf = new char[iLen];
						int iReaden = iRet;
						memcpy(pLastBuf, bufwork, iReaden);
						iRet = recv(pDlg->m_s, pLastBuf + iReaden, iLast, 0);
						if (iRet == SOCKET_ERROR)
						{
							dwErr = WSAGetLastError();
							sprintf(szErr, "Error recv() = %ld ", dwErr);
							break;
						}
						else
						{
							bufwork = pLastBuf;
							pIpHeader = (IPHEADER *)bufwork;
							if (iRet == iLast)
								iRet = iLen;
							else
							{ // read all last data
								iReaden += iRet;
								iLast -= iRet;
								while (TRUE)
								{
									iRet = recv(pDlg->m_s, pLastBuf + iReaden, iLast, 0);
									if (iRet == SOCKET_ERROR)
									{
										dwErr = WSAGetLastError();
										sprintf(szErr, "Error recv() = %ld ", dwErr);
										break;
									}
									else
									{
										iReaden += iRet;
										iLast -= iRet;
										if (iLast <= 0)
										{
											/*iRet = iReaden;*/
											break;
										}
									}
								} // while
							}
						}
					}
				}   // while
				if (pLastBuf)
					delete[] pLastBuf;
			}
			else
			{
				AfxMessageBox("No data on network");
				continue;
			}
		}
	}
	return TRUE;
}

void CSniffDlg::OnBnClickedLookup()
{
	char        szErr[50], szHostName[MAX_PATH];
	DWORD       dwErr;
	SOCKADDR_IN sa;

	gethostname(szHostName, sizeof(szHostName));
	m_iphostsource = m_ipsource;


	m_ipcheckedhost = ntohl(m_iphost);
	
	if (0 == m_threadID)
	{
		SetDlgItemText(IDC_LOOKUP, "停止查看!");
		m_cAdapter.EnableWindow(false);
	}
	else
	{
		if (m_threadID)
		{
			PostThreadMessage(m_threadID, WM_CLOSE, 0, 0);
			SetDlgItemText(IDC_LOOKUP, "开始查看!");
			m_start.EnableWindow(FALSE);
			m_cAdapter.EnableWindow(true);
		}
		return;
	}
	DWORD dwBufferLen[10];
	DWORD dwBufferInLen = 1;
	DWORD dwBytesReturned = 0;
	m_s = socket(AF_INET, SOCK_RAW, IPPROTO_IP);
	if (INVALID_SOCKET == m_s)
	{
		dwErr = WSAGetLastError();
		sprintf(szErr, "Error socket() = %ld ", dwErr);
		AfxMessageBox(szErr);
		closesocket(m_s);
		return;

	}
	int rcvtimeo = 5000;
	if (setsockopt(m_s, SOL_SOCKET, SO_RCVTIMEO, (const char *)&rcvtimeo, sizeof(rcvtimeo)) == SOCKET_ERROR)
	{
		dwErr = WSAGetLastError();
		sprintf(szErr, "Error WSAIoctl = %ld ", dwErr);
		AfxMessageBox(szErr);
		closesocket(m_s);
		return;
	}
	sa.sin_family = AF_INET;
	sa.sin_port = htons(7000);
	sa.sin_addr.s_addr = m_iphostsource;
	if (bind(m_s, (PSOCKADDR)&sa, sizeof(sa)) == SOCKET_ERROR)
	{
		dwErr = WSAGetLastError();
		sprintf(szErr, "Error bind() = %ld ", dwErr);
		AfxMessageBox(szErr);
		closesocket(m_s);
		return;
	}
	if (SOCKET_ERROR != WSAIoctl(m_s, SIO_RCVALL, &dwBufferInLen, sizeof(dwBufferInLen),
		&dwBufferLen, sizeof(dwBufferLen),
		&dwBytesReturned, NULL, NULL))
		AfxBeginThread(threadFunc, (LPVOID)this);
	else
	{
		dwErr = WSAGetLastError();
		sprintf(szErr, "Error WSAIoctl = %ld ", dwErr);
		AfxMessageBox(szErr);
		closesocket(m_s);
		return;
	}
}


void CSniffDlg::OnBnClickedOk()
{
	// TODO: 在此添加控件通知处理程序代码
	if (NULL != m_threadID)
	{
		PostThreadMessage(m_threadID, WM_CLOSE, 0, 0);
	}
	if (m_IPArr.GetSize())
	{
		m_IPArr.RemoveAll();
	}
	CDialogEx::OnOK();
}

void CSniffDlg::AddData(CString s0, CString s1, CString s2, CString s3, CString s4, CString s5, CString s6)
{
	int index;
	index = m_ctrList.InsertItem(0, s0);
	m_ctrList.SetItem(index, 1, LVIF_TEXT, s1, 0, 0, 0, 0);
	m_ctrList.SetItem(index, 2, LVIF_TEXT, s2, 0, 0, 0, 0);
	m_ctrList.SetItem(index, 3, LVIF_TEXT, s3, 0, 0, 0, 0);
	m_ctrList.SetItem(index, 4, LVIF_TEXT, s4, 0, 0, 0, 0);
	m_ctrList.SetItem(index, 5, LVIF_TEXT, s5, 0, 0, 0, 0);
	m_ctrList.SetItem(index, 6, LVIF_TEXT, s6, 0, 0, 0, 0);
}


void CSniffDlg::OnSelendokComboAdapter()
{
	CHAR pszIp[100];
	int index=m_cAdapter.GetCurSel();
	m_cAdapter.GetLBText(index, pszIp);
	m_ipsource = inet_addr(pszIp);
}
DWORD_PTR a;

Sniff.rc

IDD_SNIFF_DIALOG DIALOGEX 0, 0, 320, 200
STYLE DS_SETFONT | DS_FIXEDSYS | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME
EXSTYLE WS_EX_APPWINDOW
CAPTION "Sniff嗅探器"
FONT 9, "MS Shell Dlg", 0, 0, 0x1
BEGIN
    CONTROL         "",IDC_LIST,"SysListView32",LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP,15,31,291,135
    PUSHBUTTON      "查看",IDC_LOOKUP,109,172,45,14
    PUSHBUTTON      "确定",IDOK,178,172,45,14
    COMBOBOX        IDC_COMBO_ADAPTER,15,14,291,86,CBS_DROPDOWN | CBS_SORT | WS_VSCROLL | WS_TABSTOP
END
嗅探器c语言源码,一个简单的网络嗅探器（源码）
weixin_42419508的博客
05-21 1223
#include #include #include #include #include #include #include #include #pragma comment( lib, "ws2_32.lib" )using namespace std;struct IPHeader{unsigned char mHeaderLengthAndVersion;unsigned char mTyp...
网络嗅探器 java_网络嗅探软件的设计与分析
weixin_39879881的博客
02-21 713
摘 要本文介绍了网络嗅探器软件的功能，以及网络嗅探软件设计的原理，并以软件设计的模块化思想为主介绍了编写一个网络嗅探软件的总体设计思想以及主要代码设计，同时对涉及到的若干网络编程知识以及一些网络基本知识进行了介绍。本文的最后也指出了此网络嗅探软件设计的另一个发展方向。关键词网络嗅探器混杂模式模块化设计1引言随着网络技术的发展，网络系统对于整个社会的工作和建设发挥着越来越大的作用，网络环境也变得越来...
Socket实现网络嗅探器代码
11-25
Socket实现网络嗅探器 代码 VC++2010
Socket实现网络嗅探器代码-网络监控代码类资源
10-11
Socket实现网络嗅探器 代码 VC++2010
基于socket原始套接字的网络嗅探器
依然那霖哥
11-28 7874
// NetSniffer.cpp : 定义控制台应用程序的入口点。 // /* 简单说明一下什么是网络嗅探器，网络嗅探器是一个抓取所有经过网卡数据的软件，在一般使用电脑时，网卡 只接受到发送至本机的数据，那是因为这是网卡是非混杂模式的，挡一个目的地址非本机地址的数据包经过网 卡时，网卡在数据链路层（mac地址）检测到是非本机数据，则直接丢弃，当设置为混杂模式时，所有经过网卡 的数据包均可被读取出
Raw Socket（原始套接字）实现Sniffer（嗅探）
zerray's
06-08 1616
 一. 摘要   Raw Socket: 原始套接字   可以用它来发送和接收 IP 层以上的原始数据包, 如 ICMP, TCP, UDP...     int sockRaw = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);   这样我们就创建了一个 Raw Socket   Sniffer: 嗅探器   关于嗅探器的原理我想大多数人可能都知道   1. 把网
python-socket编程-一个简单的嗅探器
as you know, nlp is fantasitc!
05-06 1214
一个嗅探器 sniff.py import socket HOST = socket.gethostbyname(socket.gethostname()) #gethostname 返回当前运行python解释器的机器名 #gethostbyname 将主机名转换成IPv4格式地址， s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP) #这是socket的类型，采用raw类型的套接字，接收 IP报文， 还
网络嗅探器的编程仿真.rar
11-30
在这个项目中，我们将深入探讨如何使用原始套接字编程来实现一个简单的网络嗅探器，特别是针对TCP/IP协议栈。 首先，我们需要了解TCP/IP协议族的基本构成。TCP（传输控制协议）和IP（互联网协议）是其核心部分，TCP...
winsock实现简单网络嗅探器：捕获与解析包
在C++编程环境下，"Sniffer网络嗅探器"项目由作者Prasshhant Pugalia设计，主要目的是实现一个简单的网络监听器，专注于接收并处理进入系统的网络包。该项目的核心部分包括几个关键函数： 1. `#include "winsock2.h...
简单的网络嗅探器（Linux 源码）
10-04
标题中的“简单的网络嗅探器（Linux 源码）”指的是一个专为Linux系统设计的网络嗅探工具，它的主要功能是捕获并分析网络数据包。在IT领域，网络嗅探器是一种用于监控网络通信的重要工具，常用于网络故障排查、安全...
基于原始套接字的网络嗅探器
01-09
基于原始套接字的网络嗅探器，主要就是把网卡设置为混杂模式，用vs可直接编译运行，必须使用管理员权限才能运行，抓到包，用c++写的
WinForm 网络嗅探器 C#
02-01
—————————————————————— Hearen's SimpleSniffer —————————————————————— 一、功能简介： .针对同一局域网中的所有主机进行监听并返回处理优化后的数据供研究使用； .在数据表中显示了所有当前侦听到的数据包包括源IP、源端口、目的IP、目的端口、数据包协议类型、数据包捕获时间及数据包简略信息（仅应用层数据）； .可以针对某一特定IP地址（源或目的），某特定端口（源或目的）以及特定类型数据包进行侦听 -- 捕获前过滤； .当数据过多时可以随时点击‘清理’对当前的数据表进行清空 -- 不过捕获的数据是不会被清除的，仅清除列表中显示的数据； .双击‘清理’时清空所有嗅探到的数据 -- 不仅仅是列表中显示的数据； .选择列表中的数据时，数据详细信息会显示在下方的面板中； 此时可以通过选择特定字符串来查看在其左侧的十六进制表示以供研究之用； .左下角会显示当前在该局域网中捕获到的数据包个数及总大小（该大小包含IP协议及其建立在该协议以上协议的头部）-- 数据单位会自动进行切换当数据大小达到2G时将重置清零； .在获取数据包后可以针对某一IP，PORT，IP:PORT或IP/PORT及协议进行筛选，同时可以查阅当前所有捕获的数据包（如果没有设置捕获前过滤，否则只能查阅过滤后的数据）。 二、使用说明：本应用的使用环境为Windows 7、Windows 8及Windows 8.1。 在使用过程中需要获得管理员权限 - 捕获数据包需要访问底层数据，需要获得最高权限才可以正常运行该应用； 三、作者留言 该应用的开发环境为VS2013，所用语言为C#，界面设计属于WinForm（比较老式的界面风格，推荐使用WPF）。因本人水平有限，在该应用中不免存在很多漏洞和不足；如果你有更多更好的想法或者发现该小应用中的bug还望批评指正。
基于C#实现的嗅探器
08-18
基于C#实现的简单网络嗅探器源码，可以抓到本机上满足指定IP地址的数据包，分析源，目的IP地址，源，目的端口，基础协议类型以及16进制包数据，对于学习C#和TCP/IP很有帮助。
网络嗅探器 C# 源码 详细注释及文档
10-08
—————————————————————— Hearen's SimpleSniffer —————————————————————— 一、功能简介： 1.针对同一局域网中的所有主机进行监听并返回处理优化后的数据供研究使用； 2.在数据表中显示了所有当前侦听到的数据包包括源IP、源端口、目的IP、目的端口、数据包协议类型、数据包捕获时间及数据包简略信息（仅应用层数据）； 3.可以针对某一特定IP地址（源或目的），某特定端口（源或目的）以及特定类型数据包进行侦听 -- 捕获前过滤； 4.当数据过多时可以随时点击‘清理’对当前的数据表进行清空 -- 不过捕获的数据是不会被清除的，仅清除列表中显示的数据； 5.双击‘清理’时清空所有嗅探到的数据 -- 不仅仅是列表中显示的数据； 6.选择列表中的数据时，数据详细信息会显示在下方的面板中； 此时可以通过选择特定字符串来查看在其左侧的十六进制表示以供研究之用； 7.左下角会显示当前在该局域网中捕获到的数据包个数及总大小（该大小包含IP协议及其建立在该协议以上协议的头部）-- 数据单位会自动进行切换当数据大小达到2G时将重置清零； 8.在获取数据包后可以针对某一IP，PORT，IP:PORT或IP/PORT及协议进行筛选，同时可以查阅当前所有捕获的数据包（如果没有设置捕获前过滤，否则只能查阅过滤后的数据）。 二、使用说明：本应用的使用环境为Windows 7、Windows 8及Windows 8.1。 在使用过程中需要获得管理员权限 - 捕获数据包需要访问底层数据，需要获得最高权限才可以正常运行该应用； 三、作者留言 该应用的开发环境为VS2013，所用语言为C#，界面设计属于WinForm（比较老式的界面风格，推荐使用WPF）。因本人水平有限，在该应用中不免存在很多漏洞和不足；如果你有更多更好的想法或者发现该小应用中的bug还望批评指正。 ||联系方式：LHearen@126.com|| 四、免责声明 本系统仅用于学习交流之用，本人不承担该应用的技术及版权问题，且不对该应用负法律责任。
C# WinForm 网络嗅探器 带源码
11-13
一、功能简介： 1.针对同一局域网中的所有主机进行监听并返回处理优化后的数据供用户研究使用； 2.在数据表中显示了所有当前侦听到的数据包包括源IP、源端口、目的IP、目的端口、数据包协议类型、数据包捕获时间及数据包简略信息（仅应用层数据）； 3.可以对某种特定类型协议的数据进行针对性监听； 4.可以针对某一特定源IP地址进行侦听； 5.当数据过多时可以随时点击‘清理’对当前的数据表进行清空 - 不过捕获的数据是不会被清除的，仅清除列表中的数据； 6.在数据显示区域可以通过选择特定字符串以此查看在其左侧的十六进制表示以供研究之用； 7.在应用左下角显示当前应用在该局域网中捕获到的数据包个数及总大小（该大小包含IP协议及其建立在该协议以上协议的头部）- 当数据大小达到2G时将重置清零； 8.在获取数据包后可以针对某一IP或IP:PORT或IP/PORT及协议进行筛选，同时可以查阅当前所有的捕获的数据包（如果没有设置捕获前过滤，否则只能查阅过滤后的数据）。 二、安装环境说明：本应用的安装环境为Windows 7、Windows 8及Windows 8.1。 三、安装过程说明 1.在安装过程中需要获得管理员权限 - 捕获数据包需要访问底层数据，需要获得最高权限才可以正常运行该应用； 2.在安装结束时，用户可以选择此时启动应用还是结束安装流程；当选择此时启动时系统会再次提醒用户允许应用获取管理员权限-原因同上。 四、作者留言 该应用的开发环境为VS2013，所用语言为C#，界面设计属于WinForm（比较老式的界面风格，推荐使用WPF），在后期程序发布打包使用的是InstallShield Limited Edition(如果需要长期打包窗体应用发布最好购买正版，可以获得更多个性化的功能)。因本人水平有限，在该应用中不免存在很多漏洞和不足；如果你有更多更好的想法或者发现该小应用中的bug还望批评指正。 ||联系方式：LHearen@gmail.com|| 五、免责声明 本系统仅用于学习交流之用，本人不承担该应用的技术及版权问题，且不对该应用负法律责任。
Socket嗅探
李晨光原创IT博客
02-07 1788
Socket嗅探 上面几篇博文介绍了基础支持至此，在我们的代码示例中已经使用过流套接字了。使用流套接字发送和接收时，数据被简洁地包装在一个TCP/IP连接中。访问OSI模型的会话层(5)，操作系统负责所有传输过程中的低级细节、纠错和路由。使用原始套接字可以在较低层对网络进行访问。在网络的较低层，程序员必须处理所有暴露出来的细节。通过使用类型SOCKRAW即可指定原始套接字
在c#用raw socket进行sniff嗅探（一）
! ( ! 思维空间 && ! 记忆碎片)
02-12 6436
raw socket 三部曲：socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);socket.Bind(new IPEndPoint(IPAddress.Parse(IP), 0));同步下：rcv_size = socket.Receive(buffer);异步下：so
linux socket嗅探,socket实现ping嗅探，获取局域网所有活动主机
weixin_39975261的博客
05-15 494
大概思路是：获取本主机IP，然后将它和子网掩码进行与操作，可知道子网的主机号范围，然后逐个进行Ping，最多ping4次。ping是基于icmp报文的，它被封装在ip中发送出去。主要问题是，这样单线程Ping速度真的非常慢，所以我尝试了多线程，不过过程并不顺利，主要是在recvIcmp过程中，内部或许有些更复杂的步骤。不过，有个简单的实现方法是通过system函数调用DOS指令ping，并将它的输...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值