登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›驱动开发：内核封装WFP防火墙入门

驱动开发：内核封装WFP防火墙入门

寨重 2025-6-6 19:49:58
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访问任何页面都将提示无法访问。
1.png

拦截指定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命令。
2.png

抓取底层数据包： 如果仅仅只是想要输出流经自身主机的数据包，则只需要对特定数据包进行解码即可得到原始数据。
  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);
复制代码
当这段驱动程序被加载后，则用户可看到流经本机的所有数据包。
3.png


来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
寨重
2025-6-6 19:49:58

0

粉丝关注

9

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫