← 返回列表

Windows下不触发任何进程监控的创建进程

单站 冲鸭安全 发布 Sat, 24 Jan 2026 16:30:00 +0800 入库 2026-11-18T16:58:13

原创 为了安全鸭 2026-01-24 16:30 北京

这几年AI用多了,脑子坏了,比如之前写代码很容易进入心流解决问题,这个过程很爽,但是现在只会开五六个ai的console让他帮我打工。

一开始是很急的让AI写功能,

但是到后来恨不得遇到bug,编译不通过,甚至是思考都托管给AI。

我把它叫做脑腐现象.所以为了避免这种现象,我准备用纯手工打造的方式搞点项目做。锻炼一下大脑。正巧,操作系统内核目前还是AI无法触及的领域。所以,here we go。

所以,让我们来复习一下内核创建进程,这里不会说太多的基础,因为chatgpt都能回答了。我们直接说简单一点的。我们先实现一个简单的调用ntcreateuserprocess创建进程的例子,在内核里面这需要三步:

  1. 定位ntcreateuserprocess
  2. 填好参数
  3. call

我是懒得定位了,直接特征码写死了:

ntcreateuserpcoess在R3的执行的时候需要用到RtlCreateProcessParametersEx和RtlDestroyProcessParameters去填_RTL_USER_PROCESS_PARAMETERS

我们R0是没有这个两个参数的,所以要自己填.填完直接call就行:

但是坑来了,

而这个RTL_USER_PROCESS_PARAMETERS 微软故意隐藏了东西,导致如果你按照微软的来写是没有办法跑起来的,跑起来会直接segment fault.这是因为没有正确的填参数,CRT初始化的时候就崩溃了。因此我写了一个R3程序,打印一下里面需要什么东西:

// ConsoleApplication1.cpp
// Dumps the raw payload produced by RtlCreateProcessParametersEx (user-mode).
//0x18 bytes (sizeof)
struct _CURDIR
{
    struct _UNICODE_STRING DosPath;                                         //0x0
    VOID* Handle;                                                           //0x10
};
//0x18 bytes (sizeof)
struct _RTL_DRIVE_LETTER_CURDIR
{
    USHORT Flags;                                                           //0x0
    USHORT Length;                                                          //0x2
    ULONG TimeStamp;                                                        //0x4
    struct _STRING DosPath;                                                 //0x8
};
//0x410 bytes (sizeof)
struct _RTL_USER_PROCESS_PARAMETERSEX
{
    ULONG MaximumLength;                                                    //0x0
    ULONG Length;                                                           //0x4
    ULONG Flags;                                                            //0x8
    ULONG DebugFlags;                                                       //0xc
    VOID* ConsoleHandle;                                                    //0x10
    ULONG ConsoleFlags;                                                     //0x18
    VOID* StandardInput;                                                    //0x20
    VOID* StandardOutput;                                                   //0x28
    VOID* StandardError;                                                    //0x30
    struct _CURDIR CurrentDirectory;                                        //0x38
    struct _UNICODE_STRING DllPath;                                         //0x50
    struct _UNICODE_STRING ImagePathName;                                   //0x60
    struct _UNICODE_STRING CommandLine;                                     //0x70
    VOID* Environment;                                                      //0x80
    ULONG StartingX;                                                        //0x88
    ULONG StartingY;                                                        //0x8c
    ULONG CountX;                                                           //0x90
    ULONG CountY;                                                           //0x94
    ULONG CountCharsX;                                                      //0x98
    ULONG CountCharsY;                                                      //0x9c
    ULONG FillAttribute;                                                    //0xa0
    ULONG WindowFlags;                                                      //0xa4
    ULONG ShowWindowFlags;                                                  //0xa8
    struct _UNICODE_STRING WindowTitle;                                     //0xb0
    struct _UNICODE_STRING DesktopInfo;                                     //0xc0
    struct _UNICODE_STRING ShellInfo;                                       //0xd0
    struct _UNICODE_STRING RuntimeData;                                     //0xe0
    struct _RTL_DRIVE_LETTER_CURDIR CurrentDirectores[32];                  //0xf0
    ULONGLONG EnvironmentSize;                                              //0x3f0
    ULONGLONG EnvironmentVersion;                                           //0x3f8
    VOID* PackageDependencyData;                                            //0x400
    ULONG ProcessGroupId;                                                   //0x408
    ULONG LoaderThreads;                                                    //0x40c
};
// Some SDKs do not declare this prototype in user-mode headers.
using fnRtlCreateProcessParametersEx = NTSTATUS(NTAPI*)(
    _RTL_USER_PROCESS_PARAMETERSEX* pProcessParameters,
    PUNICODE_STRING ImagePathName,
    PUNICODE_STRING DllPath,
    PUNICODE_STRING CurrentDirectory,
    PUNICODE_STRING CommandLine,
    PVOID Environment,
    PUNICODE_STRING WindowTitle,
    PUNICODE_STRING DesktopInfo,
    PUNICODE_STRING ShellInfo,
    PUNICODE_STRING RuntimeData,
    ULONG Flags
);
using fnRtlDestroyProcessParameters = NTSTATUS(NTAPI*)(_RTL_USER_PROCESS_PARAMETERSEX ProcessParameters);
static UNICODE_STRING MakeUnicodeString(const std::wstring& s)
{
    UNICODE_STRING us{};
    us.Buffer = const_cast<PWSTR>(s.c_str());
    us.Length = static_cast<USHORT>(s.size() * sizeof(wchar_t));
    us.MaximumLength = us.Length + sizeof(wchar_t);
    return us;
}
static void HexDump(const void* data, size_t size)
{
    const auto* p = static_cast<const unsigned char*>(data);
    for (size_t i = 0; i < size; i += 16) {
        std::printf("%08zx  ", i);
        for (size_t j = 0; j < 16; ++j) {
            if (i + j < size) std::printf("%02X ", p[i + j]);
            else std::printf("   ");
        }
        std::printf(" ");
        for (size_t j = 0; j < 16 && i + j < size; ++j) {
            unsigned char c = p[i + j];
            std::printf("%c", (c >= 32 && c <= 126) ? c : '.');
        }
        std::printf("\n");
    }
}
static void PrintUs(const char* name, const UNICODE_STRING& us, const void* base)
{
    const auto baseAddr = reinterpret_cast<uintptr_t>(base);
    const auto bufAddr = reinterpret_cast<uintptr_t>(us.Buffer);
    std::wprintf(L"%hs: Len=%u Max=%u Buf=%p (off=0x%Ix)  \"%.*s\"\n",
        name,
        us.Length,
        us.MaximumLength,
        us.Buffer,
        (bufAddr >= baseAddr) ? (bufAddr - baseAddr) : 0,
        us.Length / 2,
        us.Buffer ? us.Buffer : L"");
}
int wmain()
{
    // Example payload: create cmd.exe parameters (NOT actually launching here).
    std::wstring imagePath = L"\\??\\C:\\Windows\\System32\\cmd.exe";
    std::wstring cmdLine = L"\"C:\\Windows\\System32\\cmd.exe\"";
    UNICODE_STRING usImage = MakeUnicodeString(imagePath);
    UNICODE_STRING usCmd = MakeUnicodeString(cmdLine);
    HMODULE ntdll = ::GetModuleHandleW(L"ntdll.dll");
    if (!ntdll) {
        std::printf("GetModuleHandleW(ntdll) failed: %lu\n", ::GetLastError());
        return 1;
    }
    auto pRtlCreate = reinterpret_cast<fnRtlCreateProcessParametersEx>(
        ::GetProcAddress(ntdll, "RtlCreateProcessParametersEx"));
    auto pRtlDestroy = reinterpret_cast<fnRtlDestroyProcessParameters>(
        ::GetProcAddress(ntdll, "RtlDestroyProcessParameters"));
    if (!pRtlCreate || !pRtlDestroy) {
        std::printf("GetProcAddress failed. RtlCreate=%p RtlDestroy=%p\n", pRtlCreate, pRtlDestroy);
        return 1;
    }
    _RTL_USER_PROCESS_PARAMETERSEX* p = nullptr;
    constexpr ULONG RTL_USER_PROCESS_PARAMETERS_NORMALIZED = 0x01;
    NTSTATUS st = pRtlCreate(
        (_RTL_USER_PROCESS_PARAMETERSEX*)&p,
        &usImage,
        nullptr,
        nullptr,
        &usCmd,
        nullptr,
        nullptr,
        nullptr,
        nullptr,
        nullptr,
        RTL_USER_PROCESS_PARAMETERS_NORMALIZED);
    std::printf("RtlCreateProcessParametersEx -> 0x%08X, p=%p\n", static_cast<unsigned>(st), p);
    if (st < 0 || !p)
        return 1;
    // Raw payload dump (what you'd want to mirror in kernel if you're hand-building).
    HexDump(p, sizeof(_RTL_USER_PROCESS_PARAMETERSEX));
    //pRtlDestroy(p);
    return 0;
}

[#define] WIN32_LEAN_AND_MEAN[#include] [#include] [#include] [#include] [#include] 

实际上,缺失的内容是,我们需要填工作目录,并且要有完整的结构体:

再然后稍微的手工填一下,这一步很想用AI忍不住了:

然后我们就跑起来了

但是这个有第二个问题,结束了就会蓝屏:

让我们调查一下,根据信息,错误代码在结束时候,

执行MmSessionGetWin32Callouts的时候:

.text:000000014008A220                                     MmSessionGetWin32Callouts proc near     ; CODE XREF: NtDeleteAtom+F↓p
.text:000000014008A220                                                                             ; PsConvertToGuiThread:loc_14060BEFE↓p ...
.text:000000014008A220 65 48 8B 04 25 88 01 00 00                          mov     rax, gs:188h
.text:000000014008A229 48 8B 88 B8 00 00 00                                mov     rcx, [rax+0B8h]
.text:000000014008A230 48 8B 81 00 04 00 00                                mov     rax, [rcx+400h]
.text:000000014008A237 48 83 B8 C0 03 00 00 02                             cmp     qword ptr [rax+3C0h], 2
.text:000000014008A23F 48 8D 05 52 E7 3A 00                                lea     rax, PsWin32CallBack
.text:000000014008A246 73 07                                               jnb     short locret_14008A24F
.text:000000014008A248 48 8D 05 41 E7 3A 00                                lea     rax, PsWin32NullCallBack
.text:000000014008A24F
.text:000000014008A24F                                     locret_14008A24F:                       ; CODE XREF: MmSessionGetWin32Callouts+26↑j
.text:000000014008A24F C3                                                  retn
.text:000000014008A24F                                     MmSessionGetWin32Callouts endp

而这个MmSessionGetWin32Callouts读

cmp     qword ptr [rax+3C0h], 2
的时候蓝屏了,这说明我们有什么东西没初始化。寻找这玩意的最好的办法是,ida搜索[rax+3C0h]访问的特征码:

根据特征码找一下cal,可以定位到,这个是在初始化win32k pfn的时候填的东西

就不卖关子了,我直接说为什么:

在操作系统创建进程时,分配进程内存和初始化进程的pfn的时候,会考虑进程的会话和上下文信息,以决定是否允许该进程访问 win32k 的pfn。而我们是直接在系统线程启动的进程,自然就没这些信息。

解决方法是附加到一个带界面的信息,比如我附加到资源管理器,这样会话也会自动分配到1而不是0:

这样你结束就不会蓝屏了,至此我们成功的实现了内核创建进程

我们在

《[2022]新瓶装旧酒: 微软CreateProcessNotify的设计缺陷》

https://key08.com/index.php/2022/10/12/1606.html

中提到过 进程创建会触发createprocessnotify回调,这也是现在很多安全软件所用来监控进程创建的回调。

而这些回调会加入到PspCreateProcessNotifyRoutine里面.在有进程创建的时候,会被逐个执行

这些call最后被”PspCallProcessNotifyRoutines”这个执行:

so,有什么不搞DKOM的方法去不触发此类回调呢?有的兄弟,有的,那就是CPU模拟

既然我们控制不了系统的执行流程,那么我们就不控制了,我们自己模拟一个CPU进行执行,只不过给的是真实的信息数据,唯一区别是,在执行PspCallProcessNotifyRoutines的时候,我们就跳过,其他时候跟操作系统一样就行。输入输出完全一样。

至于系统的call,我们除了PspCallProcessNotifyRoutines其他的就直接转发。这样我们就能达到目的。

如果不理解,这里有一个简单的图:

我这边就最简单的zydis了,手搓的不需要太复杂。一个简单的X86虚拟就只需要指令行为模拟和栈就行,遇到call,我们要么选择转发,要么选择接管。

简单来说

比如mov rax,那就是给vcpu写入值

这一段让AI干了,纯苦力牛马活,没AI干不动

值得注意的是,一些指令会影响elflags,所以也记得让AI干好,AI会忽略这些影响elfags的指令:

之后就能愉快的把参数PUSH到vm里面并且执行了

值得注意的几个问题是,遇到cfg guard的时候,不要虚拟执行,因为CFG guard的bitmap会校验来源,我们的这种call肯定是非法的。最好的办法是跳过他如何call cfg,我之前手写的时候跳过是硬编码地址,但是GPT说有更好的,嗯…直接硬编码

如果遇到了直接跳过就行

call转发我之前也想的是人模拟参数,但是GPT给了一个更野的,直接全参数call,爱用哪个用哪个:

还得是AI,真的野,

此外我们设置返回地址为0,这样当模拟执行到0的时候,代表执行完成了。

我们来试一下直接模拟+call转发的:

可以看到,我们成功的运行了。

接下来跳过指定的函数,这也非常容易,我们直接跳过并且返回一个自定义的rax就行,我们跳过的是PspCallProcessNotifyRoutines,他不会修改传递的参数里面的内容,所以简单点就行:

这样我们就实现了完整跳过内核回调了

让我们写个简单的createprocess回调看看,他会捕获所有cmd的执行

当我们执行cmd的时候,他会执行:

我们试试,传统内核直接ntcreateuserprocess:

很明显,因为会触发PspCallProcessNotifyRoutines,导致我们被发现:

而使用cpu模拟的ntcreateuserprocess,不会触发内核的进程回调的:

so…可能好奇的你问,这有什么用.

此技术有三个用途:

第一个是反作弊,总所周知,部分外挂会通过这些进程创建回调等回调,去拿真实的CR3或者做进程APC注入.而部分反作弊使用这种技术去不触发这些系统的回调启动游戏进程实现保护的效果

第二个是,目前绝大部分安全软件,都是基于PspCallProcessNotifyRoutines里面的回调创建进程管理器的,一旦一个进程不在安全软件自己的进程管理器里面,会导致安全软件无法监控到这个进程所有的行为,虽然有些脱裤子放屁的嫌疑,因为都驱动了都可以各种手段致盲安全软件了。

第三个是,他本来就没什么用,就跟大部分东西一样,写了就是为了提高自己技术.不要以”有什么用”去做某件事,要以”好玩就行”去做某件事。

原文链接:https://mp.weixin.qq.com/s?__biz=MzkyOTc0NDY2Nw==&mid=2247485866&idx=1&sn=027c346f42696ff753a8681b2308e3c2