C++代码注入

一、C++代码注入原则:

1. 在注入代码中不允许使用API。
2. 在注入代码中不允许使用全局变量。
3. 在注入代码中不允许使用字符串（编译时也被当做全局变量）。
4. 在注入代码中不允许使用函数嵌套。

二、注入代码编写思路：

1. 在本进程通过获取 LoadLibraryA 与 GetProcess 函数的地址。
2. 涉及一组参数，里面包括 {函数地址、模块地址、函数名、传递参数}。
3. 传入进去后，利用LoadLibraryA 与 GetProcess 函数,在注入代码中直接现场"加载模块-获取函数-调用"，来达到调用API的目的。

三、编写过程的几个坑：

1. 使用typedef定义函数指针，先在msdn搜索函数原型，复制过去，将名字定义成指针并大写。
2. 申请内存时的权限，参数的内存使用 PAGE_READWRITE权限；代码的内存使用PAGE_EXECUTE_READWRITE权限，否则代码无法被执行。
3. 一定要预先在msdn上搜索确定函数要加载的模块以及函数名，这一步很容易出错。如果出错只能调试被注入程序获取结果，比较麻烦。

四、olldbg调试思路：

1. 在 "选项-调试设置-事件"中勾选“中断于新线程”。
2. 注入后就可以在新线程上一步步进行调试。

五、源代码(练习了两套，一套是注入MessageBoxA，另一套是注入CreateFileA)

 // 代码注入.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
 // 代码注入，实现在任意进程注入 messagebox() 这段代码

 #include "pch.h"
 #include <stdio.h>
 #include <Windows.h>
 DWORD WINAPI ThreadProc(LPVOID lpParameter);
     // 定义传入参数
     typedef struct _THREAD_PARAM {
         FARPROC pFunc[]; // 存放两个函数 LoadLibraryA ; GetProcess;
         char szBuff[][]; // 存放四个参数
     }THREAD_PARAM, *PTHREAD_PARAM;

 // LoadLibraryA函数
 typedef HMODULE(WINAPI *PFLOADLIBARAYA)(LPCSTR lpLibFileName);

 // GetProcAddress()函数
 typedef FARPROC(WINAPI *PGETPROCADDRESS)(HMODULE hModule, LPCSTR lpProcName);

 // MessageBox()函数
 typedef int(WINAPI *PMESSAGEBOXA)(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType);

 // 注入目标进程的线程函数
 DWORD WINAPI ThreadProc(LPVOID lpParameter) {
     /*
         牢记：在代码注入中
         1. 不能使用系统函数。
         2. 不能使用全局变量。
         2. 不能使用字符串(因为这会被当成全局函数)
     */

     // 先将传入的参数值取出来
     PTHREAD_PARAM pParam = (PTHREAD_PARAM)lpParameter;
     HMODULE hMod = NULL;
     FARPROC pFunc = NULL; // messageBox这个函数

     // 先调用 LoadLibarayA函数来加载user32.dll
     hMod = ((PFLOADLIBARAYA)pParam->pFunc[])(pParam->szBuff[]); //LoadLibraryA(kernel32.dll) 先获取模块句柄，在获取 MessageBox这个函数。
     if (!hMod) return ;
     // 再来调用 GetProcess 得到 MessageBox 这个函数
     pFunc = (FARPROC)((PGETPROCADDRESS)pParam->pFunc[])(hMod, pParam->szBuff[]);
     if (!pFunc) return ;
     // 调用函数来弹出对话框
     ((PMESSAGEBOXA)pFunc)(NULL, pParam->szBuff[], pParam->szBuff[], MB_OK);

     return ;
 }

 BOOL InjectCode(DWORD Pid) {

     THREAD_PARAM param = { , };
     LPVOID lpBuffer[] = { , }; // 存储两块开辟内存,一块存储参数，另一块存储代码

     // 获取 kernel32.dll模块句柄，因为需要的函数全部存储在此
     HMODULE hModule = GetModuleHandleA(("kernel32.dll"));

     // 初始化传入线程的参数
     param.pFunc[] = GetProcAddress(hModule, "LoadLibraryA");
     param.pFunc[] = GetProcAddress(hModule, "GetProcAddress");
     strcpy_s(param.szBuff[], "user32.dll"); //加载的模块名
     strcpy_s(param.szBuff[], "MessageBoxA"); //加载的函数名
     strcpy_s(param.szBuff[], "abc"); //传入的第一个参数
     strcpy_s(param.szBuff[], "def"); // 传入的第二个参数

     //开辟内存，将线程参数传入内存中
     HANDLE hProcessHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, Pid);
     DWORD dwSize = sizeof(THREAD_PARAM);

     lpBuffer[] = VirtualAllocEx(hProcessHandle, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);

     if (WriteProcessMemory(hProcessHandle, lpBuffer[], (LPVOID)&param, dwSize, NULL)) {
         printf("第一段代码写入成功\n");
     }
     else {
         printf("第一段代码写入失败，错误码:%d\n", GetLastError());
         return FALSE;
     }

     // 开辟内存给线程，并将注入代码写入
     dwSize = (DWORD)InjectCode - (DWORD)ThreadProc;
     lpBuffer[] = VirtualAllocEx(hProcessHandle, NULL, dwSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
     if (WriteProcessMemory(hProcessHandle, lpBuffer[], (LPVOID)ThreadProc, dwSize, NULL)) {
         printf("第二段代码写入成功\n");
     }
     else {
         printf("第二段代码写入失败，错误码:%d\n", GetLastError());
         return FALSE;
     }

     // 开始创建远程线程
     HANDLE hThread = CreateRemoteThread(hProcessHandle, NULL, , (LPTHREAD_START_ROUTINE)lpBuffer[], (LPVOID)lpBuffer[], , NULL);
     if (hThread) {
         printf("线程开始执行！\n");
     }
     else {
         printf("创建远程线程失败，错误码:%d\n", GetLastError());
         return FALSE;
     }
     // 等待线程开始执行
     printf("到目前位置成功!");
     WaitForSingleObject(hThread, INFINITE);
     CloseHandle(hProcessHandle);
     CloseHandle(hThread);

     return TRUE;
 }

 // 拒绝访问时的提权代码
 BOOL SetPrivilege(LPCTSTR lpszPrivilege, BOOL bEnablePrivilege)
 {
     TOKEN_PRIVILEGES tp;
     HANDLE hToken;
     LUID luid;

     if (!OpenProcessToken(GetCurrentProcess(),
         TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
         &hToken))
     {
         wprintf(L"OpenProcessToken error: %u\n", GetLastError());
         return FALSE;
     }

     if (!LookupPrivilegeValue(NULL,           // lookup privilege on local system
         lpszPrivilege,  // privilege to lookup
         &luid))        // receives LUID of privilege
     {
         wprintf(L"LookupPrivilegeValue error: %u\n", GetLastError());
         return FALSE;
     }

     tp.PrivilegeCount = ;
     tp.Privileges[].Luid = luid;
     if (bEnablePrivilege)
         tp.Privileges[].Attributes = SE_PRIVILEGE_ENABLED;
     else
         tp.Privileges[].Attributes = ;

     // Enable the privilege or disable all privileges.
     if (!AdjustTokenPrivileges(hToken,
         FALSE,
         &tp,
         sizeof(TOKEN_PRIVILEGES),
         (PTOKEN_PRIVILEGES)NULL,
         (PDWORD)NULL))
     {
         wprintf(L"AdjustTokenPrivileges error: %u\n", GetLastError());
         return FALSE;
     }

     if (GetLastError() == ERROR_NOT_ALL_ASSIGNED)
     {
         wprintf(L"The token does not have the specified privilege. \n");
         return FALSE;
     }

     return TRUE;
 }

 int main(int argc,char *argv[])
 {
     //判断参数个数
     if (argc != ) {
         printf("\n USAGE  : %s <pid>\n", argv[]);
         return ;
     }
     if (!SetPrivilege(SE_DEBUG_NAME, TRUE)) {
         printf("提权失败!\n");
     }
     else {
         printf("提权成功!\n");
         //atol 将字符串转换为数字
         if (InjectCode(atol(argv[]))) {
             printf("开启成功!\n");
         }
         else {
             printf("开启失败!\n");
         }
     }

     getchar();
 }

注入调用MessageBoxA()

 // 代码注入CreateFile函数.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
 //

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

 // 构建参数
 typedef struct _thread_param {
     FARPROC pFunc[];  // LoadLibrary / GetProcAddress 函数
     // 这里应该存放字符
     char szBuffer[][]; // 加载的模块名字 user32.dll / CreateFileA / szFilePath
 }THREAD_PARAM,*PTHREAD_PARAM;

 // 先来构建函数指针
 typedef HANDLE (WINAPI *PCREATEFILEA)(
     LPCSTR                lpFileName,
     DWORD                 dwDesiredAccess,
     DWORD                 dwShareMode,
     LPSECURITY_ATTRIBUTES lpSecurityAttributes,
     DWORD                 dwCreationDisposition,
     DWORD                 dwFlagsAndAttributes,
     HANDLE                hTemplateFile
 );

 // LoadLibrary
 typedef HMODULE (WINAPI* PLOADLIBRARYA)(
     LPCSTR lpLibFileName
 );

 // GetProcAddress
 typedef FARPROC (WINAPI* PGETPROCADDRESS)(
     HMODULE hModule,
     LPCSTR  lpProcName
 );

 // GetProcess
 DWORD WINAPI ThreadProc(_In_ LPVOID lpParameter) {

     // 先取出参数,注意：传入一个指针，对应的也应该生成一个指针变量
     PTHREAD_PARAM pParam = (PTHREAD_PARAM)lpParameter;

     // 注意：loadLibraryA与getprocaddress 在kernel32.dll，这个不用导出，因为我们直接传入其函数地址，直接根据函数指针调用即可

     // 调用 LoadLibarayA来获取存放CreateFile模块
     HMODULE hModule = (HMODULE)((PLOADLIBRARYA)pParam->pFunc[])(pParam->szBuffer[]);
     if (!hModule) return ;

     // 调用GetPrcAddress来加载模块
     FARPROC pFunc = (FARPROC)((PGETPROCADDRESS)pParam->pFunc[])(hModule, pParam->szBuffer[]);
     if (!pFunc) return ;

     // 现在调用CreateFileA函数
     ((PCREATEFILEA)pFunc)(pParam->szBuffer[], GENERIC_READ | GENERIC_WRITE, , NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

     return ;
 }

 BOOL CodeInject(DWORD Pid) {

     // 我们的思路是获取目标进程句柄，分配-写入，最后再根据地址开启返回线程

     // 加载LoadLibraryA和GetProcAddress 两个函数的地址并且初始化参数
     THREAD_PARAM param;
     HMODULE hMoudle = LoadLibraryA("kernel32.dll");
     param.pFunc[] = (FARPROC)GetProcAddress(hMoudle, "LoadLibraryA");
     param.pFunc[] = (FARPROC)GetProcAddress(hMoudle, "GetProcAddress");
     strcpy_s(param.szBuffer[], "Kernel32.dll");
     strcpy_s(param.szBuffer[], "CreateFileA");
     strcpy_s(param.szBuffer[], "OneFile.txt");

     LPVOID pBuffer[]; // 两个存储目标进程地址的数组。
     int Res;
     HANDLE hProcessHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, Pid);

     // 向目标进程分配参数内存，参数内存可读写。
     DWORD dwSize = sizeof(THREAD_PARAM);
     pBuffer[] = VirtualAllocEx(hProcessHandle, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
     if (!WriteProcessMemory(hProcessHandle, pBuffer[], (LPVOID)&param, dwSize, NULL)) {
         printf("写入参数失败,错误码:%d", GetLastError());
         return FALSE;
     }

     // 向目标进程分配代码内存，参数内存读写-可执行。
     dwSize = (DWORD)CodeInject - (DWORD)ThreadProc;
     pBuffer[] = VirtualAllocEx(hProcessHandle, NULL, dwSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
     if (!WriteProcessMemory(hProcessHandle, pBuffer[], (LPVOID)ThreadProc, dwSize, NULL)) {
         printf("写入代码失败,错误码:%d", GetLastError());
         return FALSE;
     }

     // 创建远程线程并执行
     HANDLE hThread = CreateRemoteThread(hProcessHandle, NULL, , (LPTHREAD_START_ROUTINE)pBuffer[], (LPVOID)pBuffer[], , (LPDWORD )&Res);
     if (!hThread) {
         printf("创建远程线程失败,错误码:%d", GetLastError());
         return FALSE;
     }
     printf("线程结果:%d\n", Res);
     // 关闭资源句柄
     WaitForSingleObject(hThread, INFINITE);
     CloseHandle(hMoudle);
     CloseHandle(hThread);

     return TRUE;
 }

 BOOL SetPrivilege(LPCTSTR lpszPrivilege, BOOL bEnablePrivilege)
 {
     TOKEN_PRIVILEGES tp;
     HANDLE hToken;
     LUID luid;

     if (!OpenProcessToken(GetCurrentProcess(),
         TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
         &hToken))
     {
         wprintf(L"OpenProcessToken error: %u\n", GetLastError());
         return FALSE;
     }

     if (!LookupPrivilegeValue(NULL,           // lookup privilege on local system
         lpszPrivilege,  // privilege to lookup
         &luid))        // receives LUID of privilege
     {
         wprintf(L"LookupPrivilegeValue error: %u\n", GetLastError());
         return FALSE;
     }

     tp.PrivilegeCount = ;
     tp.Privileges[].Luid = luid;
     if (bEnablePrivilege)
         tp.Privileges[].Attributes = SE_PRIVILEGE_ENABLED;
     else
         tp.Privileges[].Attributes = ;

     // Enable the privilege or disable all privileges.
     if (!AdjustTokenPrivileges(hToken,
         FALSE,
         &tp,
         sizeof(TOKEN_PRIVILEGES),
         (PTOKEN_PRIVILEGES)NULL,
         (PDWORD)NULL))
     {
         wprintf(L"AdjustTokenPrivileges error: %u\n", GetLastError());
         return FALSE;
     }

     if (GetLastError() == ERROR_NOT_ALL_ASSIGNED)
     {
         wprintf(L"The token does not have the specified privilege. \n");
         return FALSE;
     }

     return TRUE;
 }

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

     // 在本地创建一个文件夹
     // HANDLE hFile = CreateFileA("一个文件", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
     //CloseHandle(hFile);
     // 现在实现代码注入，要求在notepad.exe中运行上段代码。

     //判断参数个数
     if (argc != ) {
         printf("\n USAGE  : %s <pid>\n", argv[]);
         return ;
     }

     if (!SetPrivilege(SE_DEBUG_NAME, TRUE)) {
         printf("提权失败!\n");
     }
     else {
         printf("提权成功!\n");
         if (CodeInject(atol(argv[]))) {
             printf("开启成功1!\n");
         }
         else {
             printf("开启失败!\n");
         }
     }

     getchar();

 }

注入调用CreateFileA（）