先上源码：
#include "Inject_Main.h"
#include "resource.h"
#include <Windows.h>
#include <TlHelp32.h>
#include <string>
#include <TCHAR.H>
using namespace std;
/// <summary>
/// 通过进程名称获取该进程句柄
/// </summary>
/// <param name="processName"></param>
/// <returns>成功返回 DWORD，失败返回 0</returns>
DWORD GetProcessByName(CONST TCHAR* processName) {
// 获取到整个系统的进程
HANDLE processALL = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
// 定义一个容器，该容器用来接收，进程信息
PROCESSENTRY32W processInfo = { 0 };
processInfo.dwSize = sizeof(PROCESSENTRY32W);
// 根据进程名称，循环判断是否是指定的进程
do
{
if (_tcscmp(processInfo.szExeFile, processName) == 0)
{
// 释放进程快照，防止内存泄露
CloseHandle(processALL);
// 如果是返回指定进程句柄
return processInfo.th32ProcessID;
}
// 一个迭代函数
} while (Process32Next(processALL, &processInfo));
// 释放进程快照，防止内存泄露
CloseHandle(processALL);
return 0;
}
/// <summary>
/// 获取指定 DLL 的内存地址
/// </summary>
/// <param name="pid"></param>
/// <param name="moduleName"></param>
/// <returns></returns>
HMODULE GetProcessModuleHandle(DWORD pid, CONST TCHAR* moduleName) {
MODULEENTRY32 moduleEntry;
HANDLE handle = NULL;
handle = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
if (!handle) {
CloseHandle(handle);
return NULL;
}
ZeroMemory(&moduleEntry, sizeof(MODULEENTRY32));
moduleEntry.dwSize = sizeof(MODULEENTRY32);
if (!Module32First(handle, &moduleEntry)) {
CloseHandle(handle);
return NULL;
}
do {
if (_tcscmp(moduleEntry.szModule, moduleName) == 0) {
// 释放进程快照，防止内存泄露
CloseHandle(handle);
return moduleEntry.hModule;
}
} while (Module32Next(handle, &moduleEntry));
CloseHandle(handle);
return 0;
}
/// <summary>
/// 把指定DLL注入到指定进程中
/// </summary>
/// <param name="processName">processName 进程名称</param>
/// <param name="dllPath">dllPath dll路径</param>
void InjectDll(const wchar_t* processName, const char* dllPath) {
// 获取指定进程的句柄
DWORD dword = GetProcessByName(processName);
if (dword == 0)
{
MessageBox(NULL, TEXT("没有找到指定进程"), TEXT("错误"), 0);
return;
}
// 打开指定进程
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dword);
if (hProcess == NULL)
{
MessageBox(NULL, TEXT("指定进程打开失败"), TEXT("错误"), 0);
return;
}
/*
在指定进程的地址，开辟一块内存空间，用来保存 DLL的路径信息
LPVOID VirtualAllocEx(
[in] HANDLE hProcess, 在那个进程中开辟内存
[in, optional] LPVOID lpAddress, 开辟内存的起始地址 (NULL，不需要控制起始位置)
[in] SIZE_T dwSize, 开辟内存的大小（当前保存的内容是 DLL的路径）
[in] DWORD flAllocationType, 内存分配的类型。（开辟内存）
[in] DWORD flProtect，设置内存的权限 （可读可写）
);
*/
LPVOID DLLAddress = VirtualAllocEx(hProcess, NULL, strlen(dllPath), MEM_COMMIT, PAGE_READWRITE);
/*
把DLL的路径，写入到刚开辟出来的内存中
BOOL WriteProcessMemory(
[in] HANDLE hProcess, // 指定的进程
[in] LPVOID lpBaseAddress, // DLL路径字符串，写入的基址
[in] LPCVOID lpBuffer, // DLL路径字符串，的指针
[in] SIZE_T nSize, // 需要写入内存的字节长度
[out] SIZE_T *lpNumberOfBytesWritten // [out] 返回一个指针，不需要，NULL
);
*/
if (WriteProcessMemory(hProcess, DLLAddress, dllPath, strlen(dllPath), NULL) == 0)
{
MessageBox(NULL, TEXT("路径写入失败"), TEXT("错误"), 0);
return;
}
// 获取 Kernel32.dll 这个模块
HMODULE k32 = GetModuleHandle(TEXT("Kernel32.dll"));
// 在 Kernel32.dll 模块中找到 LoadLibrary 这个函数的内存地址
LPVOID loadADD = GetProcAddress(k32, "LoadLibraryA");
/*
在指定进程中，创建一个线程
并通过这个线程，调用 LoadLibrary 函数
通过 LoadLibrary 函数，把 DLL 载入到目标进程中
HANDLE CreateRemoteThread(
[in] HANDLE hProcess, // 指定进程
[in] LPSECURITY_ATTRIBUTES lpThreadAttributes, // 设置线程安全属性，表示线程是否可以继承，NULL就够了
[in] SIZE_T dwStackSize, // 堆栈的初始大小，0 表示使用可执行文件的默认大小
[in] LPTHREAD_START_ROUTINE lpStartAddress, // 远程进程中，需要执行的那个函数的指针
[in] LPVOID lpParameter, // 目前进程中 DLL路径的指针
[in] DWORD dwCreationFlags, // 0 线程在创建后立即运行。
[out] LPDWORD lpThreadId // [out] 当前不需要这个返回值
);
*/
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)loadADD, DLLAddress, 0, NULL);
// 释放指定的模块
CloseHandle(hThread);
CloseHandle(hProcess);
}
/// <summary>
/// 把指定进程中的DLL卸载掉
/// </summary>
/// <param name="processName"></param>
/// <param name="dllPath"></param>
void UnInjectDll(const wchar_t* processName) {
// 通过进程名称获取该进程句柄
DWORD dword = GetProcessByName(processName);
if (dword == 0)
{
MessageBox(NULL, TEXT("没有找到指定进程"), TEXT("错误"), 0);
return;
}
// 获取指定进程中指定模块的内存地址
HMODULE hmodule = GetProcessModuleHandle(dword, L"WX_Read_Write.dll");
// 打开指定进程
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dword);
if (hProcess == NULL)
{
MessageBox(NULL, TEXT("指定进程打开失败"), TEXT("错误"), 0);
return;
}
// 获取 Kernel32.dll 这个模块
HMODULE k32 = GetModuleHandle(TEXT("Kernel32.dll"));
// 在 Kernel32.dll 模块中找到 LoadLibrary 这个函数的内存地址
LPVOID loadADD = GetProcAddress(k32, "FreeLibrary");
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)loadADD, (LPVOID)hmodule, 0, NULL);
// 释放指定的模块
CloseHandle(hThread);
CloseHandle(hProcess);
}
/// <summary>
///
/// </summary>
/// <param name="hwndDlg"></param>
/// <param name="uMsg"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <returns></returns>
INT_PTR CALLBACK dialogProc(_In_ HWND hwndDlg, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam)
{
wchar_t processName[100] = L"WeChat.exe";
char dllPath[400] = { "C://Users//qiaoas//documents//visual studio 2015//Projects//ConsoleApplication1//Debug//WX_Read_Write.dll" };
switch (uMsg)
{
case WM_INITDIALOG:
break;
case WM_CLOSE:
EndDialog(hwndDlg, 0); // 关闭窗体
break;
case WM_COMMAND:
/*GetDlgItemText(hwndDlg, Text_ProcessName, processName, sizeof(processName));
GetDlgItemText(hwndDlg, Text_DLLPath, (LPWSTR)dllPath, sizeof(dllPath));*/
if (wParam == Btn_Inject_DLL)
{
if (sizeof(processName) == 0)
{
MessageBox(NULL, TEXT("进程名称不能为空"), TEXT("错误"), 0);
}
if (sizeof(dllPath) == 0)
{
MessageBox(NULL, TEXT("DLL路径不能为空"), TEXT("错误"), 0);
}
InjectDll(processName, dllPath); // 注入DLL
}
if (wParam == Btn_unInject_DLL)
{
UnInjectDll(processName); // 卸载DLL
}
break;
default:
break;
}
return FALSE;
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="hInstance"></param>
/// <param name="hPrevInstance"></param>
/// <param name="lpCmdLine"></param>
/// <param name="nCmdShow"></param>
/// <returns></returns>
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPWSTR lpCmdLine,
_In_ int nCmdShow)
{
DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, &dialogProc);
return 0;
}
初学C++，代码可能有些地方写的不够好，但是注入卸载是完全没问题的。
注入逻辑解释：
使用CreateRemoteThread 函数可以为目标进程创建一个新的线程。
在一个进程为另一个进程创建的线程就是远程线程。
使用 LoadLibrary 函数把指定的DLL加载到进程中
因此就可以在创建远程线程的同时调用 LoadLibrary 函数，把指定的DLL加载到目标进程中。
为什么创建远程线程的时候调用 LoadLibrary 函数就能把 DLL 注入到目标进程中？
- LoadLibrary 函数是 Kernel32.dll 中的一个成员
- Kernel32.dll 这个DLL是创建进程必须的一个DLL，并且所有进程在内存中指向的 Kernel32.dll 是同一个地址
- 所以只要获取到当前进程中 LoadLibrary 函数的地址就够了
为什么要在目标进程中开辟一块内存，再把DLL路径写入到块内存中？
- LoadLibrary 函数需要一个参数，就是DLL的路径
- 把当前进程中的一个地址传到另一个进程中，鬼知道另一个进程获取这个地址中的数据时，读取到的是否是我们想要的。
- 因此需要把DLL的路径直接写入到目标进程中。
- VirtualAllocEx 函数，在目标进程中开辟一块空间，用来存放DLL路径
- WriteProcessMemory 函数，把DLL的路径写入进去
- GetModuleHandle 获取 Kernel32.dll 模块
- GetProcAddress 获取 LoadLibraryA 函数在内存中的地址
- CreateRemoteThread 创建远程线程，并调用 LoadLibraryA 函数
LoadLibrary 、LoadLibraryA、LoadLibraryW 这三者的区别。
LoadLibrary 是一个宏，可以根据字符集的不同，自动决定是使用 LoadLibraryA 还是 LoadLibraryW
LoadLibrary 宏定义的源码：
WINBASEAPI _Ret_maybenull_ HMODULE WINAPI LoadLibraryA( _In_ LPCSTR lpLibFileName ); WINBASEAPI _Ret_maybenull_ HMODULE WINAPI LoadLibraryW( _In_ LPCWSTR lpLibFileName ); #ifdef UNICODE #define LoadLibrary LoadLibraryW #else #define LoadLibrary LoadLibraryA #endif // !UNICODE
卸载逻辑：
使用 CreateRemoteThread 函数创建一个远程线程
调用 FreeLibrary 函数，卸载DLL
FreeLibrary 函数在 Kernel32.dll 模块中，逻辑同上
FreeLibrary 函数需要 DLL 的内存地址
遍历进程快照可以获取到指定模块的内存地址
卸载和注入的思路都是一样的
确认DLL是否注入到目标进程中：
方式一：使用 procexp
方式二：Cheat Engine
确认 Kernel32.dll 中的 FreeLibrary 和 LoadLibraryA 在多个进程中是否指向同一块内存地址：
可以通过CE查看多个进程中 Kernel32.dll 的内存地址是否相同
再通过 Kernel32.dll 中函数的内存地址，确认 FreeLibrary 和 LoadLibraryA 这两个函数
到此这篇关于C++ DLL注入工具(完整源码)的文章就介绍到这了,更多相关C++ DLL注入工具内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://www.cnblogs.com/ansheng/p/15855896.html
