经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » 编程经验 » 查看文章
驱动开发：内核封装WFP防火墙入门
来源：cnblogs　　作者：lyshark　　时间：2023/6/8 9:25:57　　对本文有异议

WFP框架是微软推出来替代TDIHOOK传输层驱动接口网络通信的方案，其默认被设计为分层结构，该框架分别提供了用户态与内核态相同的AIP函数，在两种模式下均可以开发防火墙产品，以下代码我实现了一个简单的驱动过滤防火墙。

WFP 框架分为两大层次模块,用户态基础过滤引擎BFE (BaseFilteringEngine) ,以及内核态过滤引擎 KMFE (KMFilteringEngine),基础过滤引擎对上提供C语言调用方式的API以及RPC接口,这些接口都被封装在FWPUCLNT.dll模块中,开发时可以调用该模块中的导出函数.

  • WFP程序工作流程:
  • 使用 FwpmEngineOpen() 开启 WFP 引擎,获得WFP使用句柄
  • 使用 FwpmTransactionBegin() 设置对网络通信内容的过滤权限 (只读/允许修改)
  • 使用 FwpsCalloutRegister(),FwpmCalloutAdd(),FwpmFilterAdd() 选择要过滤的内容,并添加过滤器对象和回调函数.
  • 使用 FwpmTransactionCommit() 确认刚才的内容,让刚才添加的回调函数开始生效.
  • 使用 FwpmFilterDeleteById(),FwpmCalloutDeleteById(),FwpsCalloutUnregisterById()函数撤销对象和回调函数.
  • 使用 FwpmEngineClose() 关闭WFP引擎类句柄.

默认情况下WFP一次需要注册3个回调函数,只有一个是事前回调,另外两个是事后回调,通常情况下我们只关注事前回调即可,此外WFP能过滤很对内容,我们需要指定过滤条件标志来输出我们所需要的数据.

  • 一般可设置为FWPM_LAYER_ALE_AUTH_CONNECT_V4意思是设置IPV4过滤.
  • 还需要设置一个GUID值,该值可随意设置,名称为GUID_ALE_AUTH_CONNECT_CALLOUT_V4宏.

首先我们通过上方的流程实现一个简单的网络控制驱动，该驱动运行后可对自身机器访问指定地址端口进行控制，例如实现指定应用断网，禁止指定页面被访问等，在配置WFP开发环境时需要在链接器选项卡中的附加依赖项中增加fwpkclnt.lib，uuid.lib这两个库文件，并且需要使用WDM开发模板，否则编译将不通过。

  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #define NDIS_SUPPORT_NDIS6 1
  7. #define DEV_NAME L"\\Device\\MY_WFP_DEV_NAME"
  8. #define SYM_NAME L"\\DosDevices\\MY_WFP_SYM_NAME"
  10. #include <ntifs.h>
  11. #include <fwpsk.h>
  12. #include <fwpmk.h>
  13. #include <stdio.h>
  15. // 过滤器引擎句柄
  16. HANDLE g_hEngine;
  18. // 过滤器引擎中的callout的运行时标识符
  19. ULONG32 g_AleConnectCalloutId;
  21. // 过滤器的运行时标识符
  22. ULONG64 g_AleConnectFilterId;
  24. // 指定唯一UUID值(只要不冲突即可,内容可随意)
  25. GUID GUID_ALE_AUTH_CONNECT_CALLOUT_V4 = { 0x6812fc83, 0x7d3e, 0x499a, 0xa0, 0x12, 0x55, 0xe0, 0xd8, 0x5f, 0x34, 0x8b };
  27. // ------------------------------------------------------------------------------
  28. // 头部函数声明
  29. // ------------------------------------------------------------------------------
  31. // 注册Callout并设置过滤点
  32. NTSTATUS RegisterCalloutForLayer(
  33. 	IN PDEVICE_OBJECT pDevObj,
  34. 	IN const GUID *layerKey,
  35. 	IN const GUID *calloutKey,
  36. 	IN FWPS_CALLOUT_CLASSIFY_FN classifyFn,
  37. 	IN FWPS_CALLOUT_NOTIFY_FN notifyFn,
  38. 	IN FWPS_CALLOUT_FLOW_DELETE_NOTIFY_FN flowDeleteNotifyFn,
  39. 	OUT ULONG32 *calloutId,
  40. 	OUT ULONG64 *filterId,
  41. 	OUT HANDLE *engine);
  43. // 注册Callout
  44. NTSTATUS RegisterCallout(
  45. 	PDEVICE_OBJECT pDevObj,
  46. 	IN const GUID *calloutKey,
  47. 	IN FWPS_CALLOUT_CLASSIFY_FN classifyFn,
  48. 	IN FWPS_CALLOUT_NOTIFY_FN notifyFn,
  49. 	IN FWPS_CALLOUT_FLOW_DELETE_NOTIFY_FN flowDeleteNotifyFn,
  50. 	OUT ULONG32 *calloutId);
  52. // 设置过滤点
  53. NTSTATUS SetFilter(
  54. 	IN const GUID *layerKey,
  55. 	IN const GUID *calloutKey,
  56. 	OUT ULONG64 *filterId,
  57. 	OUT HANDLE *engine);
  59. // Callout函数 flowDeleteFn
  60. VOID NTAPI flowDeleteFn(
  61. 	_In_ UINT16 layerId,
  62. 	_In_ UINT32 calloutId,
  63. 	_In_ UINT64 flowContext
  64. 	);
  66. // Callout函数 classifyFn
  67. #if (NTDDI_VERSION >= NTDDI_WIN8)
  68. VOID NTAPI classifyFn(
  69. 	_In_ const FWPS_INCOMING_VALUES0* inFixedValues,
  70. 	_In_ const FWPS_INCOMING_METADATA_VALUES0* inMetaValues,
  71. 	_Inout_opt_ void* layerData,
  72. 	_In_opt_ const void* classifyContext,
  73. 	_In_ const FWPS_FILTER2* filter,
  74. 	_In_ UINT64 flowContext,
  75. 	_Inout_ FWPS_CLASSIFY_OUT0* classifyOut
  76. 	);
  77. #elif (NTDDI_VERSION >= NTDDI_WIN7)                       
  78. VOID NTAPI classifyFn(
  79. 	_In_ const FWPS_INCOMING_VALUES0* inFixedValues,
  80. 	_In_ const FWPS_INCOMING_METADATA_VALUES0* inMetaValues,
  81. 	_Inout_opt_ void* layerData,
  82. 	_In_opt_ const void* classifyContext,
  83. 	_In_ const FWPS_FILTER1* filter,
  84. 	_In_ UINT64 flowContext,
  85. 	_Inout_ FWPS_CLASSIFY_OUT0* classifyOut
  86. 	);
  87. #else
  88. VOID NTAPI classifyFn(
  89. 	_In_ const FWPS_INCOMING_VALUES0* inFixedValues,
  90. 	_In_ const FWPS_INCOMING_METADATA_VALUES0* inMetaValues,
  91. 	_Inout_opt_ void* layerData,
  92. 	_In_ const FWPS_FILTER0* filter,
  93. 	_In_ UINT64 flowContext,
  94. 	_Inout_ FWPS_CLASSIFY_OUT0* classifyOut
  95. 	);
  96. #endif
  98. // Callout函数 notifyFn
  99. #if (NTDDI_VERSION >= NTDDI_WIN8)
  100. NTSTATUS NTAPI notifyFn(
  101. 	_In_ FWPS_CALLOUT_NOTIFY_TYPE notifyType,
  102. 	_In_ const GUID* filterKey,
  103. 	_Inout_ FWPS_FILTER2* filter
  104. 	);
  105. #elif (NTDDI_VERSION >= NTDDI_WIN7)
  106. NTSTATUS NTAPI notifyFn(
  107. 	_In_ FWPS_CALLOUT_NOTIFY_TYPE notifyType,
  108. 	_In_ const GUID* filterKey,
  109. 	_Inout_ FWPS_FILTER1* filter
  110. 	);
  111. #else
  112. NTSTATUS NTAPI notifyFn(
  113. 	_In_ FWPS_CALLOUT_NOTIFY_TYPE notifyType,
  114. 	_In_ const GUID* filterKey,
  115. 	_Inout_ FWPS_FILTER0* filter
  116. 	);
  117. #endif
  119. // ------------------------------------------------------------------------------
  120. // 函数实现部分
  121. // ------------------------------------------------------------------------------
  123. // 协议判断
  124. NTSTATUS ProtocalIdToName(UINT16 protocalId, PCHAR lpszProtocalName)
  125. {
  126. 	NTSTATUS status = STATUS_SUCCESS;
  128. 	switch (protocalId)
  129. 	{
  130. 	case 1:
  131. 	{
  132. 		// ICMP
  133. 		RtlCopyMemory(lpszProtocalName, "ICMP", 5);
  134. 		break;
  135. 	}
  136. 	case 2:
  137. 	{
  138. 		// IGMP
  139. 		RtlCopyMemory(lpszProtocalName, "IGMP", 5);
  140. 		break;
  141. 	}
  142. 	case 6:
  143. 	{
  144. 		// TCP
  145. 		RtlCopyMemory(lpszProtocalName, "TCP", 4);
  146. 		break;
  147. 	}
  148. 	case 17:
  149. 	{
  150. 		// UDP
  151. 		RtlCopyMemory(lpszProtocalName, "UDP", 4);
  152. 		break;
  153. 	}
  154. 	case 27:
  155. 	{
  156. 		// RDP
  157. 		RtlCopyMemory(lpszProtocalName, "RDP", 6);
  158. 		break;
  159. 	}
  160. 	default:
  161. 	{
  162. 		// UNKNOW
  163. 		RtlCopyMemory(lpszProtocalName, "UNKNOWN", 8);
  164. 		break;
  165. 	}
  166. 	}
  168. 	return status;
  169. }
  171. // 启动WFP
  172. NTSTATUS WfpLoad(PDEVICE_OBJECT pDevObj)
  173. {
  174. 	NTSTATUS status = STATUS_SUCCESS;
  176. 	// 注册Callout并设置过滤点
  177. 	// classifyFn, notifyFn, flowDeleteFn 注册三个回调函数,一个事前回调,两个事后回调
  178. 	status = RegisterCalloutForLayer(pDevObj, &FWPM_LAYER_ALE_AUTH_CONNECT_V4, &GUID_ALE_AUTH_CONNECT_CALLOUT_V4,
  179. 		classifyFn, notifyFn, flowDeleteFn, &g_AleConnectCalloutId, &g_AleConnectFilterId, &g_hEngine);
  180. 	if (!NT_SUCCESS(status))
  181. 	{
  182. 		DbgPrint("注册回调失败 \n");
  183. 		return status;
  184. 	}
  186. 	return status;
  187. }
  189. // 卸载WFP
  190. NTSTATUS WfpUnload()
  191. {
  192. 	if (NULL != g_hEngine)
  193. 	{
  194. 		// 删除FilterId
  195. 		FwpmFilterDeleteById(g_hEngine, g_AleConnectFilterId);
  196. 		// 删除CalloutId
  197. 		FwpmCalloutDeleteById(g_hEngine, g_AleConnectCalloutId);
  198. 		// 清空Filter
  199. 		g_AleConnectFilterId = 0;
  200. 		// 反注册CalloutId
  201. 		FwpsCalloutUnregisterById(g_AleConnectCalloutId);
  202. 		// 清空CalloutId
  203. 		g_AleConnectCalloutId = 0;
  204. 		// 关闭引擎
  205. 		FwpmEngineClose(g_hEngine);
  206. 		g_hEngine = NULL;
  207. 	}
  209. 	return STATUS_SUCCESS;
  210. }
  212. // 注册Callout并设置过滤点
  213. NTSTATUS RegisterCalloutForLayer(IN PDEVICE_OBJECT pDevObj, IN const GUID *layerKey, IN const GUID *calloutKey, IN FWPS_CALLOUT_CLASSIFY_FN classifyFn, IN FWPS_CALLOUT_NOTIFY_FN notifyFn, IN FWPS_CALLOUT_FLOW_DELETE_NOTIFY_FN flowDeleteNotifyFn, OUT ULONG32 *calloutId, OUT ULONG64 *filterId, OUT HANDLE *engine)
  214. {
  215. 	NTSTATUS status = STATUS_SUCCESS;
  217. 	// 注册Callout
  218. 	status = RegisterCallout(pDevObj, calloutKey, classifyFn, notifyFn, flowDeleteNotifyFn, calloutId);
  219. 	if (!NT_SUCCESS(status))
  220. 	{
  221. 		return status;
  222. 	}
  224. 	// 设置过滤点
  225. 	status = SetFilter(layerKey, calloutKey, filterId, engine);
  226. 	if (!NT_SUCCESS(status))
  227. 	{
  228. 		return status;
  229. 	}
  231. 	return status;
  232. }
  234. // 注册Callout
  235. NTSTATUS RegisterCallout(PDEVICE_OBJECT pDevObj, IN const GUID *calloutKey, IN FWPS_CALLOUT_CLASSIFY_FN classifyFn, IN FWPS_CALLOUT_NOTIFY_FN notifyFn, IN FWPS_CALLOUT_FLOW_DELETE_NOTIFY_FN flowDeleteNotifyFn, OUT ULONG32 *calloutId)
  236. {
  237. 	NTSTATUS status = STATUS_SUCCESS;
  238. 	FWPS_CALLOUT sCallout = { 0 };
  240. 	// 设置Callout
  241. 	sCallout.calloutKey = *calloutKey;
  242. 	sCallout.classifyFn = classifyFn;
  243. 	sCallout.flowDeleteFn = flowDeleteNotifyFn;
  244. 	sCallout.notifyFn = notifyFn;
  246. 	// 注册Callout
  247. 	status = FwpsCalloutRegister(pDevObj, &sCallout, calloutId);
  248. 	if (!NT_SUCCESS(status))
  249. 	{
  250. 		DbgPrint("注册Callout失败 \n");
  251. 		return status;
  252. 	}
  254. 	return status;
  255. }
  257. // 设置过滤点
  258. NTSTATUS SetFilter(IN const GUID *layerKey, IN const GUID *calloutKey, OUT ULONG64 *filterId, OUT HANDLE *engine)
  259. {
  260. 	HANDLE hEngine = NULL;
  261. 	NTSTATUS status = STATUS_SUCCESS;
  262. 	FWPM_SESSION session = { 0 };
  263. 	FWPM_FILTER mFilter = { 0 };
  264. 	FWPM_CALLOUT mCallout = { 0 };
  265. 	FWPM_DISPLAY_DATA mDispData = { 0 };
  267. 	// 创建Session
  268. 	session.flags = FWPM_SESSION_FLAG_DYNAMIC;
  269. 	status = FwpmEngineOpen(NULL, RPC_C_AUTHN_WINNT, NULL, &session, &hEngine);
  270. 	if (!NT_SUCCESS(status))
  271. 	{
  272. 		return status;
  273. 	}
  275. 	// 开始事务
  276. 	status = FwpmTransactionBegin(hEngine, 0);
  277. 	if (!NT_SUCCESS(status))
  278. 	{
  279. 		return status;
  280. 	}
  282. 	// 设置Callout参数
  283. 	mDispData.name = L"MY WFP LyShark";
  284. 	mDispData.description = L"WORLD OF DEMON";
  285. 	mCallout.applicableLayer = *layerKey;
  286. 	mCallout.calloutKey = *calloutKey;
  287. 	mCallout.displayData = mDispData;
  289. 	// 添加Callout到Session中
  290. 	status = FwpmCalloutAdd(hEngine, &mCallout, NULL, NULL);
  291. 	if (!NT_SUCCESS(status))
  292. 	{
  293. 		return status;
  294. 	}
  296. 	// 设置过滤器参数
  297. 	mFilter.action.calloutKey = *calloutKey;
  298. 	mFilter.action.type = FWP_ACTION_CALLOUT_TERMINATING;
  299. 	mFilter.displayData.name = L"MY WFP LyShark";
  300. 	mFilter.displayData.description = L"WORLD OF DEMON";
  301. 	mFilter.layerKey = *layerKey;
  302. 	mFilter.subLayerKey = FWPM_SUBLAYER_UNIVERSAL;
  303. 	mFilter.weight.type = FWP_EMPTY;
  305. 	// 添加过滤器
  306. 	status = FwpmFilterAdd(hEngine, &mFilter, NULL, filterId);
  307. 	if (!NT_SUCCESS(status))
  308. 	{
  309. 		return status;
  310. 	}
  312. 	// 提交事务
  313. 	status = FwpmTransactionCommit(hEngine);
  314. 	if (!NT_SUCCESS(status))
  315. 	{
  316. 		return status;
  317. 	}
  319. 	*engine = hEngine;
  320. 	return status;
  321. }
  323. // Callout函数 classifyFn 事前回调函数
  324. VOID NTAPI classifyFn(_In_ const FWPS_INCOMING_VALUES0* inFixedValues, _In_ const FWPS_INCOMING_METADATA_VALUES0* inMetaValues, _Inout_opt_ void* layerData, _In_opt_ const void* classifyContext, _In_ const FWPS_FILTER2* filter, _In_ UINT64 flowContext, _Inout_ FWPS_CLASSIFY_OUT0* classifyOut)
  325. {
  326. 	// 数据包的方向,取值 FWP_DIRECTION_INBOUND = 1 或 FWP_DIRECTION_OUTBOUND = 0
  327. 	WORD wDirection = inFixedValues->incomingValue[FWPS_FIELD_ALE_FLOW_ESTABLISHED_V4_DIRECTION].value.int8;
  329. 	// 定义本机地址与本机端口
  330. 	ULONG ulLocalIp = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_LOCAL_ADDRESS].value.uint32;
  331. 	UINT16 uLocalPort = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_LOCAL_PORT].value.uint16;
  333. 	// 定义对端地址与对端端口
  334. 	ULONG ulRemoteIp = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_REMOTE_ADDRESS].value.uint32;
  335. 	UINT16 uRemotePort = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_REMOTE_PORT].value.uint16;
  337. 	// 获取当前进程IRQ
  338. 	KIRQL kCurrentIrql = KeGetCurrentIrql();
  340. 	// 获取进程ID
  341. 	ULONG64 processId = inMetaValues->processId;
  342. 	UCHAR szProcessPath[256] = { 0 };
  343. 	CHAR szProtocalName[256] = { 0 };
  344. 	RtlZeroMemory(szProcessPath, 256);
  346. 	// 获取进程路径
  347. 	for (ULONG i = 0; i < inMetaValues->processPath->size; i++)
  348. 	{
  349. 		// 里面是宽字符存储的
  350. 		szProcessPath[i] = inMetaValues->processPath->data[i];
  351. 	}
  353. 	// 获取当前协议类型
  354. 	ProtocalIdToName(inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_PROTOCOL].value.uint16, szProtocalName);
  356. 	// 设置默认规则 允许连接
  357. 	classifyOut->actionType = FWP_ACTION_PERMIT;
  359. 	// 禁止指定进程网络连接
  360. 	if (NULL != wcsstr((PWCHAR)szProcessPath, L"iexplore.exe"))
  361. 	{
  362. 		// 设置拒绝规则 拒绝连接
  363. 		classifyOut->actionType = FWP_ACTION_BLOCK;
  364. 		classifyOut->rights = classifyOut->rights & (~FWPS_RIGHT_ACTION_WRITE);
  365. 		classifyOut->flags = classifyOut->flags | FWPS_CLASSIFY_OUT_FLAG_ABSORB;
  366. 		DbgPrint("[LyShark.com] 拦截IE网络链接请求... \n");
  367. 	}
  369. 	// 输出对端地址字符串 并阻断链接
  370. 	char szRemoteAddress[256] = { 0 };
  371. 	char szRemotePort[128] = { 0 };
  373. 	char szLocalAddress[256] = { 0 };
  374. 	char szLocalPort[128] = { 0 };
  376. 	sprintf(szRemoteAddress, "%u.%u.%u.%u", (ulRemoteIp >> 24) & 0xFF, (ulRemoteIp >> 16) & 0xFF, (ulRemoteIp >> 8) & 0xFF, (ulRemoteIp)& 0xFF);
  377. 	sprintf(szRemotePort, "%d", uRemotePort);
  379. 	sprintf(szLocalAddress, "%u.%u.%u.%u", (ulLocalIp >> 24) & 0xFF, (ulLocalIp >> 16) & 0xFF, (ulLocalIp >> 8) & 0xFF, (ulLocalIp)& 0xFF);
  380. 	sprintf(szLocalPort, "%d", uLocalPort);
  382. 	// DbgPrint("本端: %s : %s --> 对端: %s : %s \n", szLocalAddress, szLocalPort, szRemoteAddress, szRemotePort);
  384. 	// 如果对端地址是 8.141.58.64 且对端端口是 443 则拒绝连接
  385. 	if (strcmp(szRemoteAddress, "8.141.58.64") == 0 && strcmp(szRemotePort, "443") == 0)
  386. 	{
  387. 		DbgPrint("[LyShark.com] 拦截网站访问请求 --> %s : %s \n", szRemoteAddress, szRemotePort);
  388. 		// 设置拒绝规则 拒绝连接
  389. 		classifyOut->actionType = FWP_ACTION_BLOCK;
  390. 		classifyOut->rights = classifyOut->rights & (~FWPS_RIGHT_ACTION_WRITE);
  391. 		classifyOut->flags = classifyOut->flags | FWPS_CLASSIFY_OUT_FLAG_ABSORB;
  392. 	}
  393. 	else if (strcmp(szRemotePort, "0") == 0)
  394. 	{
  395. 		DbgPrint("[LyShark.com] 拦截Ping访问请求 --> %s \n", szRemoteAddress);
  397. 		// 设置拒绝规则 拒绝连接
  398. 		classifyOut->actionType = FWP_ACTION_BLOCK;
  399. 		classifyOut->rights = classifyOut->rights & (~FWPS_RIGHT_ACTION_WRITE);
  400. 		classifyOut->flags = classifyOut->flags | FWPS_CLASSIFY_OUT_FLAG_ABSORB;
  401. 	}
  403. 	// 显示
  404. 	DbgPrint("[LyShark.com] 方向: %d -> 协议类型: %s -> 本端地址: %u.%u.%u.%u:%d -> 对端地址: %u.%u.%u.%u:%d -> IRQL: %d -> 进程ID: %I64d -> 路径: %S \n",
  405. 	wDirection,
  406. 	szProtocalName,
  407. 	(ulLocalIp >> 24) & 0xFF,
  408. 	(ulLocalIp >> 16) & 0xFF,
  409. 	(ulLocalIp >> 8) & 0xFF,
  410. 	(ulLocalIp)& 0xFF,
  411. 	uLocalPort,
  412. 	(ulRemoteIp >> 24) & 0xFF,
  413. 	(ulRemoteIp >> 16) & 0xFF,
  414. 	(ulRemoteIp >> 8) & 0xFF,
  415. 	(ulRemoteIp)& 0xFF,
  416. 	uRemotePort,
  417. 	kCurrentIrql,
  418. 	processId,
  419. 	(PWCHAR)szProcessPath);
  421. }
  423. // Callout函数 notifyFn 事后回调函数
  424. NTSTATUS NTAPI notifyFn(_In_ FWPS_CALLOUT_NOTIFY_TYPE notifyType, _In_ const GUID* filterKey, _Inout_ FWPS_FILTER2* filter)
  425. {
  426. 	NTSTATUS status = STATUS_SUCCESS;
  427. 	return status;
  428. }
  430. // Callout函数 flowDeleteFn 事后回调函数
  431. VOID NTAPI flowDeleteFn(_In_ UINT16 layerId, _In_ UINT32 calloutId, _In_ UINT64 flowContext)
  432. {
  433. 	return;
  434. }
  436. // 默认派遣函数
  437. NTSTATUS DriverDefaultHandle(PDEVICE_OBJECT pDevObj, PIRP pIrp)
  438. {
  439. 	NTSTATUS status = STATUS_SUCCESS;
  440. 	pIrp->IoStatus.Status = status;
  441. 	pIrp->IoStatus.Information = 0;
  442. 	IoCompleteRequest(pIrp, IO_NO_INCREMENT);
  444. 	return status;
  445. }
  447. // 创建设备
  448. NTSTATUS CreateDevice(PDRIVER_OBJECT pDriverObject)
  449. {
  450. 	NTSTATUS status = STATUS_SUCCESS;
  451. 	PDEVICE_OBJECT pDevObj = NULL;
  452. 	UNICODE_STRING ustrDevName, ustrSymName;
  453. 	RtlInitUnicodeString(&ustrDevName, DEV_NAME);
  454. 	RtlInitUnicodeString(&ustrSymName, SYM_NAME);
  456. 	status = IoCreateDevice(pDriverObject, 0, &ustrDevName, FILE_DEVICE_NETWORK, 0, FALSE, &pDevObj);
  457. 	if (!NT_SUCCESS(status))
  458. 	{
  459. 		return status;
  460. 	}
  461. 	status = IoCreateSymbolicLink(&ustrSymName, &ustrDevName);
  462. 	if (!NT_SUCCESS(status))
  463. 	{
  464. 		return status;
  465. 	}
  466. 	return status;
  467. }
  469. // 卸载驱动
  470. VOID UnDriver(PDRIVER_OBJECT driver)
  471. {
  472. 	// 删除回调函数和过滤器,关闭引擎
  473. 	WfpUnload();
  475. 	UNICODE_STRING ustrSymName;
  476. 	RtlInitUnicodeString(&ustrSymName, SYM_NAME);
  477. 	IoDeleteSymbolicLink(&ustrSymName);
  478. 	if (driver->DeviceObject)
  479. 	{
  480. 		IoDeleteDevice(driver->DeviceObject);
  481. 	}
  482. }
  484. // 驱动入口
  485. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  486. {
  487. 	NTSTATUS status = STATUS_SUCCESS;
  488. 	Driver->DriverUnload = UnDriver;
  489. 	for (ULONG i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
  490. 	{
  491. 		Driver->MajorFunction[i] = DriverDefaultHandle;
  492. 	}
  494. 	// 创建设备
  495. 	CreateDevice(Driver);
  497. 	// 启动WFP
  498. 	WfpLoad(Driver->DeviceObject);
  500. 	Driver->DriverUnload = UnDriver;
  501. 	return STATUS_SUCCESS;
  502. }

上方代码是一个最基本的WFP过滤框架头部函数，声明部分来源于微软的定义此处不做解释，需要注意GUID_ALE_AUTH_CONNECT_CALLOUT_V4代表的是一个随机UUID值，该值可以任意定义只要不一致即可，驱动程序运行后会率先执行WfpLoad()这个函数，该函数内部通过RegisterCalloutForLayer()注册了一个过滤点，此处我们必须要注意三个回调函数，classifyFn, notifyFn, flowDeleteFn 他们分别的功能时，事前回调，事后回调，事后回调，而WFP框架中我们最需要注意的也就是对这三个函数进行重定义，也就是需要重写函数来实现我们特定的功能。

  1. NTSTATUS RegisterCalloutForLayer
  2. (
  3.     IN const GUID* layerKey,
  4.     IN const GUID* calloutKey,
  5.     IN FWPS_CALLOUT_CLASSIFY_FN classifyFn,
  6.     IN FWPS_CALLOUT_NOTIFY_FN notifyFn,
  7.     IN FWPS_CALLOUT_FLOW_DELETE_NOTIFY_FN flowDeleteNotifyFn,
  8.     OUT UINT32* calloutId,
  9.     OUT UINT64* filterId
  10. }

既然是防火墙那么必然classifyFn事前更重要一些，如果需要监控网络流量则需要在事前函数中做处理，而如果是监视则可以在事后做处理，既然要在事前进行处理，那么我们就来看看事前是如何处理的流量。

  1. // Callout函数 classifyFn 事前回调函数
  2. VOID NTAPI classifyFn(_In_ const FWPS_INCOMING_VALUES0* inFixedValues, _In_ const FWPS_INCOMING_METADATA_VALUES0* inMetaValues, _Inout_opt_ void* layerData, _In_opt_ const void* classifyContext, _In_ const FWPS_FILTER2* filter, _In_ UINT64 flowContext, _Inout_ FWPS_CLASSIFY_OUT0* classifyOut)
  3. {
  4. 	// 数据包的方向,取值 FWP_DIRECTION_INBOUND = 1 或 FWP_DIRECTION_OUTBOUND = 0
  5. 	WORD wDirection = inFixedValues->incomingValue[FWPS_FIELD_ALE_FLOW_ESTABLISHED_V4_DIRECTION].value.int8;
  7. 	// 定义本机地址与本机端口
  8. 	ULONG ulLocalIp = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_LOCAL_ADDRESS].value.uint32;
  9. 	UINT16 uLocalPort = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_LOCAL_PORT].value.uint16;
  11. 	// 定义对端地址与对端端口
  12. 	ULONG ulRemoteIp = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_REMOTE_ADDRESS].value.uint32;
  13. 	UINT16 uRemotePort = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_REMOTE_PORT].value.uint16;
  15. 	// 获取当前进程IRQ
  16. 	KIRQL kCurrentIrql = KeGetCurrentIrql();
  18. 	// 获取进程ID
  19. 	ULONG64 processId = inMetaValues->processId;
  20. 	UCHAR szProcessPath[256] = { 0 };
  21. 	CHAR szProtocalName[256] = { 0 };
  22. 	RtlZeroMemory(szProcessPath, 256);
  24. 	// 获取进程路径
  25. 	for (ULONG i = 0; i < inMetaValues->processPath->size; i++)
  26. 	{
  27. 		// 里面是宽字符存储的
  28. 		szProcessPath[i] = inMetaValues->processPath->data[i];
  29. 	}
  31. 	// 获取当前协议类型
  32. 	ProtocalIdToName(inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_PROTOCOL].value.uint16, szProtocalName);
  34. 	// 设置默认规则 允许连接
  35. 	classifyOut->actionType = FWP_ACTION_PERMIT;
  37. 	// 禁止指定进程网络连接
  38. 	if (NULL != wcsstr((PWCHAR)szProcessPath, L"qq.exe"))
  39. 	{
  40. 		// 设置拒绝规则 拒绝连接
  41. 		classifyOut->actionType = FWP_ACTION_BLOCK;
  42. 		classifyOut->rights = classifyOut->rights & (~FWPS_RIGHT_ACTION_WRITE);
  43. 		classifyOut->flags = classifyOut->flags | FWPS_CLASSIFY_OUT_FLAG_ABSORB;
  44. 	}
  46. 	// 输出对端地址字符串 并阻断链接
  47. 	char szRemoteAddress[256] = { 0 };
  48. 	char szRemotePort[128] = { 0 };
  50. 	char szLocalAddress[256] = { 0 };
  51. 	char szLocalPort[128] = { 0 };
  53. 	sprintf(szRemoteAddress, "%u.%u.%u.%u", (ulRemoteIp >> 24) & 0xFF, (ulRemoteIp >> 16) & 0xFF, (ulRemoteIp >> 8) & 0xFF, (ulRemoteIp)& 0xFF);
  54. 	sprintf(szRemotePort, "%d", uRemotePort);
  56. 	sprintf(szLocalAddress, "%u.%u.%u.%u", (ulLocalIp >> 24) & 0xFF, (ulLocalIp >> 16) & 0xFF, (ulLocalIp >> 8) & 0xFF, (ulLocalIp)& 0xFF);
  57. 	sprintf(szLocalPort, "%d", uLocalPort);
  59. 	// DbgPrint("本端: %s : %s --> 对端: %s : %s \n", szLocalAddress, szLocalPort, szRemoteAddress, szRemotePort);
  61. 	// 如果对端地址是 8.141.58.64 且对端端口是 443 则拒绝连接
  62. 	if (strcmp(szRemoteAddress, "8.141.58.64") == 0 && strcmp(szRemotePort, "443") == 0)
  63. 	{
  64. 		DbgPrint("拦截网站访问请求 --> %s : %s \n", szRemoteAddress, szRemotePort);
  65. 		// 设置拒绝规则 拒绝连接
  66. 		classifyOut->actionType = FWP_ACTION_BLOCK;
  67. 		classifyOut->rights = classifyOut->rights & (~FWPS_RIGHT_ACTION_WRITE);
  68. 		classifyOut->flags = classifyOut->flags | FWPS_CLASSIFY_OUT_FLAG_ABSORB;
  69. 	}
  70. 	else if (strcmp(szRemotePort, "0") == 0)
  71. 	{
  72. 		DbgPrint("拦截Ping访问请求 --> %s \n", szRemoteAddress);
  74. 		// 设置拒绝规则 拒绝连接
  75. 		classifyOut->actionType = FWP_ACTION_BLOCK;
  76. 		classifyOut->rights = classifyOut->rights & (~FWPS_RIGHT_ACTION_WRITE);
  77. 		classifyOut->flags = classifyOut->flags | FWPS_CLASSIFY_OUT_FLAG_ABSORB;
  78. 	}
  80. 	/*
  81. 	// 显示
  82. 	DbgPrint("方向: %d -> 协议类型: %s -> 本端地址: %u.%u.%u.%u:%d -> 对端地址: %u.%u.%u.%u:%d -> IRQL: %d -> 进程ID: %I64d -> 路径: %S \n",
  83. 	wDirection,
  84. 	szProtocalName,
  85. 	(ulLocalIp >> 24) & 0xFF,
  86. 	(ulLocalIp >> 16) & 0xFF,
  87. 	(ulLocalIp >> 8) & 0xFF,
  88. 	(ulLocalIp)& 0xFF,
  89. 	uLocalPort,
  90. 	(ulRemoteIp >> 24) & 0xFF,
  91. 	(ulRemoteIp >> 16) & 0xFF,
  92. 	(ulRemoteIp >> 8) & 0xFF,
  93. 	(ulRemoteIp)& 0xFF,
  94. 	uRemotePort,
  95. 	kCurrentIrql,
  96. 	processId,
  97. 	(PWCHAR)szProcessPath);
  98. 	*/
  99. }

当有新的网络数据包路由到事前函数时，程序中会通过如下案例直接得到我们所需要的数据包头，ProtocalIdToName函数则是一个将特定类型数字转为字符串的转换函数。

  1. // 数据包的方向,取值 FWP_DIRECTION_INBOUND = 1 或 FWP_DIRECTION_OUTBOUND = 0
  2. WORD wDirection = inFixedValues->incomingValue[FWPS_FIELD_ALE_FLOW_ESTABLISHED_V4_DIRECTION].value.int8;
  4. // 定义本机地址与本机端口
  5. ULONG ulLocalIp = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_LOCAL_ADDRESS].value.uint32;
  6. UINT16 uLocalPort = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_LOCAL_PORT].value.uint16;
  8. // 定义对端地址与对端端口
  9. ULONG ulRemoteIp = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_REMOTE_ADDRESS].value.uint32;
  10. UINT16 uRemotePort = inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_REMOTE_PORT].value.uint16;
  12. // 获取当前进程IRQ
  13. KIRQL kCurrentIrql = KeGetCurrentIrql();
  15. // 获取进程ID
  16. ULONG64 processId = inMetaValues->processId;
  17. UCHAR szProcessPath[256] = { 0 };
  18. CHAR szProtocalName[256] = { 0 };
  19. RtlZeroMemory(szProcessPath, 256);
  21. // 获取进程路径
  22. for (ULONG i = 0; i < inMetaValues->processPath->size; i++)
  23. {
  24. 	// 里面是宽字符存储的
  25. 	szProcessPath[i] = inMetaValues->processPath->data[i];
  26. }
  28. // 获取当前协议类型
  29. ProtocalIdToName(inFixedValues->incomingValue[FWPS_FIELD_ALE_AUTH_CONNECT_V4_IP_PROTOCOL].value.uint16, szProtocalName);

拦截浏览器上网： 防火墙的默认规则我们将其改为放行所有classifyOut->actionType = FWP_ACTION_PERMIT;，当我们需要拦截特定进程上网时则只需要判断调用原，如果时特定进程则直接设置拒绝网络访问。

  1. // 设置默认规则 允许连接
  2. classifyOut->actionType = FWP_ACTION_PERMIT;
  4. // 禁止指定进程网络连接
  5. if (NULL != wcsstr((PWCHAR)szProcessPath, L"iexplore.exe"))
  6. {
  7. 	// 设置拒绝规则 拒绝连接
  8. 	classifyOut->actionType = FWP_ACTION_BLOCK;
  9. 	classifyOut->rights = classifyOut->rights & (~FWPS_RIGHT_ACTION_WRITE);
  10. 	classifyOut->flags = classifyOut->flags | FWPS_CLASSIFY_OUT_FLAG_ABSORB;
  11. 	DbgPrint("[LyShark.com] 拦截IE网络链接请求... \n");
  12. }

当这段驱动程序被加载后，则用户使用IE访问任何页面都将提示无法访问。

拦截指定IP地址： 防火墙的另一个重要功能就是拦截主机自身访问特定网段，此功能只需要增加过滤条件即可实现，如下当用户访问8.141.58.64这个IP地址是则会被拦截，如果监测到用户时Ping请求则也会被拦截。

  1. // 如果对端地址是 8.141.58.64 且对端端口是 443 则拒绝连接
  2. if (strcmp(szRemoteAddress, "8.141.58.64") == 0 && strcmp(szRemotePort, "443") == 0)
  3. {
  4. 	DbgPrint("拦截网站访问请求 --> %s : %s \n", szRemoteAddress, szRemotePort);
  5. 	// 设置拒绝规则 拒绝连接
  6. 	classifyOut->actionType = FWP_ACTION_BLOCK;
  7. 	classifyOut->rights = classifyOut->rights & (~FWPS_RIGHT_ACTION_WRITE);
  8. 	classifyOut->flags = classifyOut->flags | FWPS_CLASSIFY_OUT_FLAG_ABSORB;
  9. }
  10. else if (strcmp(szRemotePort, "0") == 0)
  11. {
  12. 	DbgPrint("拦截Ping访问请求 --> %s \n", szRemoteAddress);
  14. 	// 设置拒绝规则 拒绝连接
  15. 	classifyOut->actionType = FWP_ACTION_BLOCK;
  16. 	classifyOut->rights = classifyOut->rights & (~FWPS_RIGHT_ACTION_WRITE);
  17. 	classifyOut->flags = classifyOut->flags | FWPS_CLASSIFY_OUT_FLAG_ABSORB;
  18. }

当这段驱动程序被加载后，则用户主机无法访问8.141.58.64且无法使用ping命令。

抓取底层数据包： 如果仅仅只是想要输出流经自身主机的数据包，则只需要对特定数据包进行解码即可得到原始数据。

  1. // 输出对端地址字符串 并阻断链接
  2. char szRemoteAddress[256] = { 0 };
  3. char szRemotePort[128] = { 0 };
  5. char szLocalAddress[256] = { 0 };
  6. char szLocalPort[128] = { 0 };
  8. sprintf(szRemoteAddress, "%u.%u.%u.%u", (ulRemoteIp >> 24) & 0xFF, (ulRemoteIp >> 16) & 0xFF, (ulRemoteIp >> 8) & 0xFF, (ulRemoteIp)& 0xFF);
  9. sprintf(szRemotePort, "%d", uRemotePort);
  11. sprintf(szLocalAddress, "%u.%u.%u.%u", (ulLocalIp >> 24) & 0xFF, (ulLocalIp >> 16) & 0xFF, (ulLocalIp >> 8) & 0xFF, (ulLocalIp)& 0xFF);
  12. sprintf(szLocalPort, "%d", uLocalPort);
  14. // 显示
  15. DbgPrint("[LyShark.com] 方向: %d -> 协议类型: %s -> 本端地址: %u.%u.%u.%u:%d -> 对端地址: %u.%u.%u.%u:%d -> IRQL: %d -> 进程ID: %I64d -> 路径: %S \n",
  16. wDirection,
  17. szProtocalName,
  18. (ulLocalIp >> 24) & 0xFF,
  19. (ulLocalIp >> 16) & 0xFF,
  20. (ulLocalIp >> 8) & 0xFF,
  21. (ulLocalIp)& 0xFF,
  22. uLocalPort,
  23. (ulRemoteIp >> 24) & 0xFF,
  24. (ulRemoteIp >> 16) & 0xFF,
  25. (ulRemoteIp >> 8) & 0xFF,
  26. (ulRemoteIp)& 0xFF,
  27. uRemotePort,
  28. kCurrentIrql,
  29. processId,
  30. (PWCHAR)szProcessPath);

当这段驱动程序被加载后，则用户可看到流经本机的所有数据包。

原文链接：https://www.cnblogs.com/LyShark/p/17134954.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

编程经验热门文章

  • Prometheus监控之SNMP Exporter介绍和数据展现
  • Intel 82599网卡异常挂死原因
  • 腾讯防水墙的分析识别与破解
  • 桌面应用自动化WinAppDriver入门
  • 文档在线预览（三）使用js前端实现word、excel、pdf、ppt 在线预览
  • 「教程」如何下载AcFun网站上的视频、A站视频下载工具
  • 基于Hi3559AV100的SVP(NNIE)开发整体流程
  • GBDT(梯度提升树)scikit-klearn中的参数说明及简汇
  • antd之RangePicker设置默认值方式
  • 决胜经典算法之插入排序

    • 编程经验推荐文章

  • wifi基础(一)：无线电波与WIFI信号干扰、衰减
  • 甲方扔给两个存在包名与类名均相同的Jar包，要在工程中同时使用怎么办？
  • 《花100块做个摸鱼小网站! 》第三篇—热搜表结构设计和热搜数据存储
  • Fluent Editor：一个基于 Quill 2.0 的富文本编辑器，功能强大、开箱即用！
  • 方法的三种调用形式
  • 《花100块做个摸鱼小网站! 》第二篇—后端应用搭建和完成第一个爬虫
  • 《熬夜整理》保姆级系列教程-玩转Wireshark抓包神器教程(4)-再识Wireshark - 北京-宏哥
  • 《软件性能测试分析与调优实践之路》(第2版) 读书笔记（二）总体介绍（下）-真正从性能分析与调优来看性能测试
  • 架构知识点（三）
  • 《花100块做个摸鱼小网站! 》第一篇—买云服务器和初始化环境

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号