注入的DLL：cheat8.dll如何注入 注入的近义词
一、注入的DLL：cheat8.dll如何注入？
答：“加入修改后写文件，取特定目录 “文件名DLL”＃dll 图标文件名写到文件 (取特定目录 ＋“＼文件名DLL”, ＃DLL图标文件名)“
二、dll注入技术原理？
DLL注入的职业原理是强制目标程序调用LoadLibary（）函数加载dll文件，因此会强制执行DLLMain函数，同时，被注入的DLL拥有目标进程的内存访问权限从而实现一些有用的功能。
三、进程注入的dll文件该如何编写？
用了半个暑假学C++，hook WX，成功调用发送消息call，接收消息响应call。在B站参考了Hezone和Hellmessage两位大神的视频，虽然WX更新较快，汇编代码已经面目全非，但思路很有启发性。写篇文章记下实现经过，方便日后复习。
用到的工具有：visual studio，cheat engine，ollydbg。
写壹个DLL
这个DLL等于于大家的间谍，潜入WX内部，接着和外部主程序通信进行相应操作。
- 打开VS，创建新项目，选择”动态链接库“
创建了壹个名为Dll1的DLL，dllmain.cpp里有vs为大家准备好的DLL程序入口。
大家的执行的代码要在DLL_PROCESS_ATTACH下面写。
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
/*大家的代码，注入DLL后会执行*/
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
先打开头文件pch.h，接着写上
#include <windows.h>再回到dllmain，加壹个弹窗。
case DLL_PROCESS_ATTACH:
/*大家的代码，注入DLL后会执行*/
MessageBox(0,L"成功潜入微信内部！",L"报告主人",NULL);按F5生成。
打开项目目录下的Debug文件夹，大家可以看到大家生成的Dll1.dll和Dll1.pdb。
DLL注入程序
写完简单的DLL，接着写壹个Inject DLL 注入程序(exe)，用超距离线程注入的方式，把自己的DLL注入到WX进程。
大家再创建壹个新项目，选择“控制台程序”，将项目命名为Inject。
方式是先通过WX程序的Pid，调用OpenProcess用可获取的全部权限打开进程，再用VirtualAllocEx在WX进程的地址空间开辟一块内存，调用WriteProcessMemory把大家写的DLL的途径写到WX的内存里。[1]
大家要想办法创建壹个超距离线程（CreateRemoteThreadEx），让线程执行“LoadLibrary"让微信载入大家的DLL。大家不能直接&LoadLibrary取到函数地址接着传过去让线程执行，由于大家的注入程序的LoadLibrary地址和WX地址空间的LoadLibrary地址不一致。因此大家要用GetProcAddress获取LoadLibrary的地址。
完整代码如下：
int main() {
DWORD pid = 0;
scanf("%d",pid);
HANDLE hprocess = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
if (!hprocess) {
std::cout << "can not get handle" << std::endl;
return 1;
}
SIZE_T PathSize = (strlen(DLLPath) + 1) * sizeof(TCHAR);
LPVOID StartAddress = VirtualAllocEx(hprocess, NULL, PathSize, MEM_COMMIT, PAGE_READWRITE);
if (!StartAddress) {
std::cout << "开辟内存失败" << std::endl;
return 1;
}
if (!WriteProcessMemory(hprocess, StartAddress, DLLPath, PathSize, NULL)) {
std::cout << "无法写入DLL途径" << std::endl;
return 1;
}
PTHREAD_START_ROUTINE pfnStartAddress = (PTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(_T("kernel32.dll")), "LoadLibraryA");
if (!pfnStartAddress) {
std::cout << "无法获取函数地址" << std::endl;
return 1;
}
HANDLE hThread = CreateRemoteThreadEx(hprocess, NULL, NULL, pfnStartAddress, StartAddress, NULL, NULL, NULL);
if (!hThread) {
std::cout << "创建线程失败" << std::endl;
return 1;
}
//WaitForSingleObject(hThread, INFINITE);//等待DLL结束
std::cout << "注入成功！\n";
CloseHandle(hThread);
CloseHandle(hprocess);
return 0;
}
接着生成。
登录WX，大家再在cmd输入tasklist，找到WeChat.exe，这个WX的主进程，记下PID，之后运行我大家写的Inject.exe，输入pid。
成功显示，任务栏下方还光明正大的表示成WX的图标，真是血统正宗！
还是来更新一下，做个预告吧。
上面大家让大家的DLL注入到WX里了，这等于于大家光明正大的闯进了他的房子，可以为所欲为！
是的，大家的DLL可以像操作自己的内存一样，读取修改WX的内存，甚至调用和修改他的执行代码！
接下来会以获取到用户信息，如昵称，WX号，电话号码，头像等，讲如何读取他的内存。
经点评区知友好心提醒，怕被抓，因此#define WX 微信
我又过来啦！
DLL读取用户信息
登录微信后，打开CE，添加微信。
将Value Type改成String，接着输入大家的微信号，一定要一字符不差。
接着first scan扫描，会发现两个绿色的地址。绿色就代表着这个地址的相对位置是不变的，由于大家的微信号、手机号这些，登录之后就不会变化，因此这两个地址符合大家的条件。把他们添加到下栏。
鼠标悬停在上面可以看到，如果你的绿色地址和我一样一个dll加壹个十六进制数，那么后面的0x1D29B60就是大家要找的偏移量。大家可以用WeChatWin.dll基址加上偏移量，就能得出每次运行微信后，微信号的地址。
如果你只是个绿色的地址，那就点击add address manually，输入WeChatWin.dll,接着OK，下栏会多出壹个以4个0小编觉得的地址，这就是这次启动微信WeChatWin.dll的值。
打开计算器，选程序员玩法，换到十六进制，用刚刚的壹个绿色地址和这个值相减，得出的数值便是偏移。
得到偏移后，找个踏实的地方记下来，以免丢失，又要从头来过。可以直接define到大家的DLL源码里。
用同样方式可以找出微信昵称和电话号码、微信头像啥子的。
因此，要获取微信号的地址，只要获取WeChatWin模块基址和偏移接着相加，大家已经找到偏移，如何让dll了解基址呢？
由于这会大家的DLL已经注入进去，是和WeChatWin.dll等同属壹个进程，因此大家可以直接调用GetModuleHandle:
GetModuleHandle(L"WeChatWin.dll");
为了方便易领会，大家封装成函数:
HMODULE GetWechatWin() {
return GetModuleHandle(L"WeChatWin.dll");
}
现在就可以计算出微信号的地址：
pwxid = (DWORD)hModule + WXIDOFFSET;
pphone = (DWORD)hModule + PHONEOFFSET;
接着难点来了，虽然得到了地址，但它是一串DWORD，如何转换成指针呢。
由于我是从Python入门，没有强制转换这个概念，因此脑筋转不过来。
wxid = (char*)pwxid;
phone = (char*)pphone;把DWORD强制转换成壹个指给char字符串的指针，大家真正就得到了微信号。
来，开个弹窗看看找没找对：
MessageBoxA(0,wxid,0,0);
对了，忘了说，前面wxid和Phone两个char*不是要先定义再运用的嘛，然而呢你在case下面定义，vs就会提示说wxid的定义被跳过，因此这些数据要在switch外定义好，你可以在DllMain函数下面定义初始化，也可以全局。
接下来会说下发送消息。
我一开始是先选发送消息的，由于看着汇编代码相对简单。然而写好了注入进去之后调用call，不是让微信异常终止，就是没错误但调用不了，用OD和VS都调试不出个因此然，因此就暂时言败，又去hook接收消息，虽然复杂，但好领会，最后成功了。接着回过头来重捋一遍发送消息，才搞定，但始终没清楚一开始何故会不行，是啥子难题导致的。
但能用就行了，管他呢。
之后的一些内容也许会分开几篇文章来写，全堆到这一篇的话，又难维护又难阅读。
Dll1发送消息函数
下面这篇是发送消息的解析教程：
C++ DLL注入微信实现自动接收、发送消息之调用发送callPython获取用户信息
为了让python调用，实现注入DLL，我又新建了壹个DLL项目名为InjectDll,把前面的DLL注入程序(Inject.exe)的代码复制过来，接着让Python ctypes载入InjectDll就可以注入，实现Python和注入进WX的DLL沟通。
然而一大堆的函数，复制来还得从头调整，由于数据类型难题很难调用，因此我就言败了。
原本最长的注入函数，被我改成了：
void injectdll() {
system("D:\\vsproject\\Inject\\Debug\\Inject.exe");
}或许这才是真正的优雅。
内存映射传递数据
重点是通信，管他是如何注入的，进去了就行。
接着用内存映射文件让里面的DLL把用户信息传出来。
在Dll1里新建壹个cpp源文件，名为shareMsg.cpp[2]。函数有：
int createMapping(PCTSTR pszPathname,PTSTR mapname) {
HANDLE s_hFileMap = CreateFileMapping(pszPathname == NULL ? INVALID_HANDLE_VALUE : CreateFile(pszPathname, GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL), NULL, PAGE_READWRITE, 0, 8 * 1024, mapname);
if (s_hFileMap != NULL) {
if (GetLastError() == ERROR_ALREADY_EXISTS) {
//MessageBox(NULL, L"Mapping already exists - not created.", 0, 0);
CloseHandle(s_hFileMap);
return 1;
}
else {
PVOID pView = MapViewOfFile(s_hFileMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
if (pView != NULL) {
UnmapViewOfFile(pView);
return 0;
}
else {
//MessageBox(NULL, L"Can't map view of file.",0,0);
return 2;
}
}
}
else {
//MessageBox(NULL, L"Can't create file mapping.", 0, 0);
return 3;
}
}
创建Mapping，如果没有文件名会用-1。文件创建的相对大，由于wx的一些独特消息比如动画表情，图片，链接等，是以xml的形式呈现的。
int share(PTSTR mapname,PTSTR source, rsize_t sourceSize) {
HANDLE hFileMapT = OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE, FALSE, mapname);
if (hFileMapT != NULL) {
PVOID pView = MapViewOfFile(hFileMapT, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
if (pView != NULL) {
wchar_t null[0x1000] = { 0 };
wmemcpy_s((PTSTR)pView, 8 * 1024, null, 0x1000);
wmemcpy_s((PTSTR)pView, 8 * 1024, source, sourceSize);
UnmapViewOfFile(pView);
return 0;
}
else { //MessageBox(NULL, L"can't map view.", 0, 0);
return 1;
}
CloseHandle(hFileMapT);
}
else {
//MessageBox(NULL, L"can't open mapping.", 0, 0);
return 2;
}
}写入mapping。
PTSTR readMapping(PCTSTR mapname, PTSTR buff, const rsize_t buffSize) {
HANDLE hFileMapT = OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE, FALSE, mapname);
if (hFileMapT != NULL) {
PVOID pView = MapViewOfFile(hFileMapT, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
if (pView != NULL) {
rsize_t pViewSize = _tcslen((PTSTR)pView);
wmemcpy_s(buff, buffSize, (PTSTR)pView, buffSize > pViewSize ? pViewSize + 1 : buffSize);
UnmapViewOfFile(pView);
return buff;
}
else { //MessageBox(NULL, L"can't map view.", 0, 0);
return NULL;
}
CloseHandle(hFileMapT);
}
else {
//MessageBox(NULL, L"can't open mapping.", 0, 0);
return NULL;
}
}读Mapping，虽然没用到，但还是写出来吧。
好，接着在DllMain处，createmapping.
createMapping(L"C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python38\\wechat\\userdata.dat", (PTSTR)L"UserData");
由于要传递用户信息，和接收消息内容，因此要创建多个内存映射，第壹个参数最好是个数据文件，而不要写NULL。
接着拼接用户信息：
strcat_s(userdata, 0x40, wxid);
strcat_s(userdata, 0x40, "\n");
strcat_s(userdata, 0x40, phone);接着同享：
if (share((PTSTR)L"UserData", (PTSTR)userdata, 0x40) != 0)
MessageBox(0, L"userdata lose", 0, 0);写入方准备好了，之后是Python的读取。
在InjectDll里加上函数：
LPSTR readMappingA(LP反恐精英TR mapname, LPSTR buff, const rsize_t buffSize) {
HANDLE hFileMapT = OpenFileMappingA(FILE_MAP_READ | FILE_MAP_WRITE, FALSE, mapname);
if (hFileMapT != NULL) {
PVOID pView = MapViewOfFile(hFileMapT, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
if (pView != NULL) {
rsize_t pViewSize = strlen((LPSTR)pView);
memcpy_s(buff, buffSize, (LPSTR)pView, buffSize > pViewSize ? pViewSize + 1 : buffSize);
UnmapViewOfFile(pView);
return buff;
}
else { //MessageBox(NULL, L"can't map view.", 0, 0);
return NULL;
}
CloseHandle(hFileMapT);
}
else {
//MessageBox(NULL, L"can't open mapping.", 0, 0);
return NULL;
}
}让其可以导出：
extern "C"{
__declspec(dllexport) LPSTR readMappingA(LP反恐精英TR mapname, LPSTR buff, const rsize_t buffSize);
}创建壹个Python项目，名为wechat。
在wechat.py中，
注入DLL：
from ctypes import *
inject_dll = windll.LoadLibrary("D:\\vsproject\\InjectDll\\x64\\Debug\\InjectDll.dll")获取用户信息的函数：
def getuserdata(self):
inject_dll.readMappingA.restype = c_char_p
buff = create_string_buffer(1000)
x=inject_dll.readMappingA(c_char_p(bytes("UserData","utf-8")),buff,len(buff))
#print(x)
x=x.decode('utf-8').split('\n')
return xPy和Dll1管道通信
在发送消息这篇中，大家在DLL内部实现了壹个发送WX消息的函数
void SendWechatMessage(wchar_t* wxid, wchar_t* msg);
在DLL内部调用就能发送消息。然而如何让外部程序调用？把DLL注入进去之后，就不和大家壹个进程了，大家调用不了DLL里面的函数。
因此只能靠通信了，让DLL进去后开个循环，一直监听大家的消息，一有消息就执行相应操作。去网上查了查进程间通信的方法，有内存映射文件，信号，管道，套接字等，粗看觉得管道最直接简单，就选了命名管道。
觉得管道相对适合面给对象编程，本来我的代码就已经够乱了，不能再乱下去，顺便进修下C++ class，就打算写个pipe类。
去MSDN翻了翻，发现有CreateNamedPipe创建管道的函数，有WaitNamedPipe等待，和ConnectNamedPipe连接。
因此分两个类来写吧，服务器和客户端。
class Serverpipe {
public:
HANDLE h_Pipe;
bool create() {
h_Pipe = CreateNamedPipe(
TEXT("\\\\.\\Pipe\\mypipe"), //管道名字
PIPE_ACCESS_DUPLEX, //管道类型
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, //管道参数
PIPE_UNLIMITED_INSTANCES, //管道能创建的最大实例数量
0, //输出缓冲区的长度 0表示默认
0, //输入缓冲区的长度 0表示默认
NMPWAIT_WAIT_FOREVER/*NMPWAIT_USE_DEFAULT_WAIT*/, //超时时刻
NULL);
if (h_Pipe == INVALID_HANDLE_VALUE)
{
MessageBox(0, L"Failed to CreateNamedPipe!", 0, 0);
return false;
}
return true;
}
DWORD connect() {
if (ConnectNamedPipe(h_Pipe, NULL) == NULL) //连接,等待
{
if (GetLastError() == ERROR_PIPE_CONNECTED) {
//MessageBox(0, L"我还没准备好，先别进来！", 0, 0);
return ERROR_PIPE_CONNECTED;
}
MessageBox(0, L"Failed to Connect!", 0, 0);
return FALSE;
}
else
{
return TRUE;
}
}
DWORD read(wchar_t* buff,DWORD nNumberOfBytesToWrite) {
DWORD len = 0;
if (ReadFile(h_Pipe, buff, nNumberOfBytesToWrite, &len, NULL) == FALSE) //接收客户端
{
//wchar_t error[100];
//swprintf_s(error, 100, L"错误代码为0x%x", GetLastError());
//MessageBox(0, error, L"Failed to read data!", 0);
return FALSE/*GetLastError()*/;
}
return len;
}
DWORD write(wchar_t* buff,DWORD nNumberOfBytesToWrite) {
DWORD len_ = 0;
WriteFile(h_Pipe, buff, nNumberOfBytesToWrite, &len_, 0); //给客户端发送内容}
return len_;
}
DWORD close() {
return CloseHandle(h_Pipe);
}
};
现在就可以在dllmain.cpp中，创建壹个实例。
Serverpipe pipe;
接着，
wchar_t* senddata = new wchar_t[0x3000];
wchar_t seps[] = L"|cut|";
wchar_t* token1 = NULL;
wchar_t* token2 = NULL;
wchar_t* next_token1 = NULL;
wchar_t* next_token2 = NULL;
wchar_t Wxid[20] = { 0 };
wchar_t *Msg = new wchar_t[0x3000];由于要传两个参数，发送目标和消息内容，因此读取管道内容后，以"|cut|"为分割标记，用strok截断字符串，标记之前作为发送目标，标记之后作为发送内容，也算是一种解析吧。[3]
在DllMain里，
pipe.create();
if(pipe.connect()!=0){
while (true) {
memset(senddata, '\0', 0x3000);
while (pipe.read(senddata, 0x3000) == 0) {}
_tcscpy_s(Wxid, 20, _tcstok_s(senddata, seps, &next_token1));
_tcscpy_s(Msg, 0x3000, _tcstok_s(NULL, seps, &next_token1));
MessageBox(0, Msg, Wxid, 0);
SendWechatMessage(Wxid, Msg);
}
}接着大家再给InjectDll写上客户端pipe。
class Clientpipe{
public:
HANDLE h_Pipe;
DWORD connect() {
bool bRet = WaitNamedPipe(TEXT("\\\\.\\Pipe\\mypipe"), NMPWAIT_WAIT_FOREVER);
if (!bRet)
{
MessageBox(0, L"Failed to connect pipeline!", 0, 0);
return -1;
}
h_Pipe = CreateFile( //管道属于一种独特的文件
TEXT("\\\\.\\Pipe\\mypipe"), //文件名字
GENERIC_READ | GENERIC_WRITE, //文件玩法
0, //是否共享
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, //文件属性(只读，默认...)NORMAL 为默认属性
NULL);
if (h_Pipe == INVALID_HANDLE_VALUE)
{
//MessageBox(0, L"Failed to CreateFile pipeline file!", 0, 0);
return FALSE;
}
return TRUE;
}
DWORD read(wchar_t* buff, DWORD nNumberOfBytesToWrite) {
DWORD len = 0;
if (ReadFile(h_Pipe, buff, nNumberOfBytesToWrite, &len, NULL) == FALSE) //接收客户端发送的内容
{
//wchar_t error[100];
//swprintf_s(error, 100, L"错误代码为0x%x", GetLastError());
//MessageBox(0, error, L"Failed to read data!", 0);
return GetLastError();
}
return len;
}
DWORD write(wchar_t* buff, DWORD nNumberOfBytesToWrite) {
DWORD len_ = 0;
if (WriteFile(h_Pipe, buff, nNumberOfBytesToWrite, &len_, 0) == FALSE)
return GetLastError();//给客户端发送内容}
return len_;
}
};
生成后，给Python导入，却发现Python貌似根本用不了这个C++类诶。。。
几番折腾还是导出不了，
见知乎上有大佬直接写两个函数，壹个创建类实例并返回指针，壹个销毁。接着导出两个函数。
我就干脆把class去掉了。
HANDLE h_Pipe;
DWORD connect() {
bool bRet = WaitNamedPipe(TEXT("\\\\.\\Pipe\\mypipe"), NMPWAIT_WAIT_FOREVER);
if (!bRet)
{
MessageBox(0, L"Failed to connect pipeline!", 0, 0);
return -1;
}
h_Pipe = CreateFile( //管道属于一种独特的文件
TEXT("\\\\.\\Pipe\\mypipe"), //文件名字
GENERIC_READ | GENERIC_WRITE, //文件玩法
0, //是否共享
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, //文件属性(只读，默认...)NORMAL 为默认属性
NULL);
if (h_Pipe == INVALID_HANDLE_VALUE)
{
//MessageBox(0, L"Failed to CreateFile pipeline file!", 0, 0);
return FALSE;
}
return TRUE;
}
DWORD read(wchar_t* buff, DWORD nNumberOfBytesToWrite) {
DWORD len = 0;
if (ReadFile(h_Pipe, buff, nNumberOfBytesToWrite, &len, NULL) == FALSE) //接收客户端发送的内容
{
//wchar_t error[100];
//swprintf_s(error, 100, L"错误代码为0x%x", GetLastError());
//MessageBox(0, error, L"Failed to read data!", 0);
return GetLastError();
}
return len;
}
DWORD write(wchar_t* buff, DWORD nNumberOfBytesToWrite) {
DWORD len_ = 0;
if (WriteFile(h_Pipe, buff, nNumberOfBytesToWrite, &len_, 0) == FALSE)
return GetLastError();//给客户端发送内容}
return len_;
}让类方式变成全局函数。
接着逐个导出：
extern "C"{
__declspec(dllexport) DWORD connect();
__declspec(dllexport) DWORD read(wchar_t* buff, DWORD nNumberOfBytesToWrite);
__declspec(dllexport) DWORD write(wchar_t* buff, DWORD nNumberOfBytesToWrite);
}
OK,搞定。
Python发送消息函数
回到wechat.py，写壹个发送消息的函数：
def send(self,msg,wxid=None,name=None,findtime=1.8):
if wxid:
msg=wxid+'|cut|'+msg
buff = create_unicode_buffer(msg)
x=inject_dll.write(buff,len(buff)*2)
elif name:
self.find(name)
self.write(msg)
pag.hotkey('alt', 's')
return True
return x如果传入了wxid也就是发送目标，就会构造发送目标+发送内容的字符串，接着写入管道，管道对面的Dll1监听到后立马进行发送操作，函数最后返回写入管道的字节数。如果只输入了好友昵称，就搜索找到对应好友聊天框，发送窗口消息+模拟按键发送。
多线程化解无响应
于是，感觉大功告成的我激动地打开IDLE，调用send函数，然而wx却是
无 响 应 。。
这当头一棒，打得我措手不及。
回想刚写的代码，就只有管道和接收消息循环。管道是不会出啥子大难题的，那肯定是Dll1里的循环了。当时想着，写下无限循环，最多卡着当前的线程，不会影响到整个进程，其他GUI组件应该还能用。或许真有难题吧。
于是我回到Dll1，把最后的while循环整个包装入壹个函数里，
void waitmsg() {
while (true) {
memset(senddata, '\0', 0x3000);
while (pipe.read(senddata, 0x3000) == 0) {}
_tcscpy_s(Wxid, 20, _tcstok_s(senddata, seps, &next_token1));
_tcscpy_s(Msg, 0x3000, _tcstok_s(NULL, seps, &next_token1));
MessageBox(0, Msg, Wxid, 0);
SendWechatMessage(Wxid, Msg);
}
}接着在DllMain调用此函数。
重启wx，ctrl+F6 IDLE，再send。
诶哟，成功发送了！
来让我再发几条~
第二次调用send，WX又卡死了。。
看来要不卡死，只能并发了。
#include <thread>
thread th(waitmsg);创建壹个线程th，线程执行函数waitmsg。
把DllMain最后的
waitmsg();改为
thread th(waitmsg);这样，到最后，就会创建新线程，单独执行while循环，这样就不会影响主线程了。
从头生成，VS却提示“th的初始化被标签case跳过”。
可是这个线程实例，我啥子时候初始化它，它就啥子时候开始执行，你不给我在里面初始化，那我只能在外部提前初始化，管道没连接就开始了监听，肯定会引发错误啊。
不管了，我非要在里面初始化类实例。于是我又写了壹个函数，
void _th() {
thread th(waitmsg);
}接着在DllMain里的最后改为
_th();生成，vs不报错了。
然而想到在函数里创建的变量啥子的，函数执行完毕会被销毁哦，保险起见，加个static
void _th() {
static thread th(waitmsg);
}OK。再次打开IDLE，发送消息，成了！
成了！
成了！
至此，终于封装好了发送wx消息的Python函数。
Dll1接收消息Hook
下面是HOOK接收消息
C++ DLL注入微信hook实现自动接收消息具体的找函数和写代码hook已经单独写在上文。
Python获取新消息
在接收消息那篇文章中，大家写了响应函数，一有消息就会内存映射并弹窗显示，现在Python只需要读内存映射就行了。
在大家写的InjectDll中有读取内存映射文件的函数readMapping，大家上面已经让Python导入了InjectDll，现在就用它的函数。
这里涉及到ctypes库，相对繁杂，提议先看一下文档，再继续。
inject_dll.readMapping.restype = c_wchar_p
buff = create_unicode_buffer(5000)
msg = inject_dll.readMapping("NewMessageLog",buff,5000)配置readMapping函数的返回值类型为cwchar指针，接着创建buff传参。这里的buff等于于c++ 的
wchar_t buff[5000]={0};
包装成函数：
def getmsg(self):
inject_dll.readMapping.restype = c_wchar_p
buff = create_unicode_buffer(5000)
msg = inject_dll.readMapping("NewMessageLog",buff,5000)
for i in range(-1, -20, -1):
if msg[i] == '}':
j = i
if msg[i] == '{':
k = i
break
msgtype = ''
try:
for i in range(k + 1, j):
msgtype = msgtype + msg[i]
except UnboundLocalError:
msgtype = '长链接'
return {"text":msg,"wxid":None,"type":msgtype}
msgwxid = msgtype.split('[')[1].replace(']','')
msgtype = msgtype.split('[')[0]
msg = msg[::-1].replace(msgtype[::-1],'')[::-1]
msg = msg[::-1].replace(msgwxid[::-1], '')[::-1].replace('{[]}','')
return {"text":msg,"wxid":msgwxid,"type":msgtype}到这里已经写了多少Python函数，为了方便管理和日后调用，提议把它们包装成壹个Wechat类。
以后就可以
>>> import wechat
>>> myweixin = wechat.Wechat()
...
>>> myweixin.send(...)
...
>>> myweixin.getmsg()
...也可以给其他程序调用。
自定义新消息响应函数
大家现在可以获取到新鲜一条的消息了，然而我还想要能自定义壹个回调函数，每有新消息，就让程序调用大家的处理函数。
要及时响应，就要开循环去监听对吧，大家在写DLL的时候试过了，直接开while循环就会卡死做不了其他事务，对于Python这个动态语言肯定是自断功力的。吃一堑长一智，大家同样可以用多线程的方式化解这个难题。
Python中的多线程库有threading，这是标准库。
导出线程类：
from threading import Thread继承，写子类：
class myThread (Thread):
def __init__(self, threadID, name, getmsgfunc,cbfunc):
Thread.__init__(self)
self.running = True
self.threadID = threadID
self.name = name
self.getmsgfunc = getmsgfunc
self.cbfunc = cbfunc
def run(self):
while True:
if self.running:
msglist = self.getmsgfunc()
if msglist:
self.cbfunc(msglist)
time.sleep(1)类接收这四个参数，其中threadID和name是大家自己设定的，用来区分。之后是两个函数引用，分别是获关掉息的函数和大家自定义的回调函数。之后子线程开循环一直get消息接着将消息列表传参给回调函数。
这时注意了，如果大家的getmsg函数一直返回消息的话，循环就会一直执行回调函数，由于他不了解这是不是新鲜消息了，消息是否被处理过了。因此大家要做好区分，让新消息只能接收一次。下一次就return False。
调整一下：
def getmsg(self):
inject_dll.readMapping.restype = c_wchar_p
buff = create_unicode_buffer(5000)
msg = inject_dll.readMapping("NewMessageLog",buff,5000)
if not msg:
return False
buff = create_unicode_buffer(50)
inject_dll.writeMapping("NewMessageLog",buff,50)
for i in range(-1, -20, -1):
if msg[i] == '}':
j = i
if msg[i] == '{':
k = i
break
msgtype = ''
try:
for i in range(k + 1, j):
msgtype = msgtype + msg[i]
except UnboundLocalError:
msgtype = '长链接'
return {"text":msg,"wxid":None,"type":msgtype}
msgwxid = msgtype.split('[')[1].replace(']','')
msgtype = msgtype.split('[')[0]
msg = msg[::-1].replace(msgtype[::-1],'')[::-1]
msg = msg[::-1].replace(msgwxid[::-1], '')[::-1].replace('{[]}','')
return {"text":msg,"wxid":msgwxid,"type":msgtype}这样，大家每获取一次消息，就把内存映射文件清空，表明大家已经收到了这个消息，下次再读取就会读到None，表明已经没有新消息了。
感觉我这getmsg后面这么长一段解析字符串的代码，可以用正则去匹配哦。大家可以自己改进一下，我也懒得改了。
th = myThread(2, "hook", self.getmsg, self.hookcallback)
self.th = th
print(self.th)
self.th.start()接着大家可以在wechat类的_init_里start线程。
之后大家可以实时调整callback函数（应该可以，没试过调整)。
接着大家可以：
>>> mywx = wechat.Wechat()
>>> def cb(alist):
print(f'好友{alist["wxid"]}像你发送了这条{alist["type"]}消息: {alist["text]}')
>>> mywx.hookcallback = cb
...这是最基本的，这个回调大家看如何用了。
进阶应用
1.手机命令PC
手机控制PC，这是个鸡肋的功能，但保不准有啥子用，比如职业时暂时离开，给文件传输助手发个shutdown -s就能关机，如果有某些心怀不轨的同事兄弟偷偷看大家的PC，大家可以给文件传输助手发送take Photos命令截图留下证据接着锁屏，还可以发送模拟键盘鼠标操作命令在手机上运用PC……
甚至给配置个多功能聊天机器人，就可以在文件传输助手查天气聊闲天查资料啥子的，（我手机的语音助手太垃了，连GUI界面都没有，和其他手机相比简直就是猪和人的差距）。
不知不觉已经两万多字了，手机端几乎编辑不了了，要卡死，因此后文分几篇文章写。
手机命令PC之后可以有很多分支，比如自动回复，消息语音播报，我不手把手说了，自己寻觅吧（安全第一，我选择苟）。
接下来打算把InjectDll这个DLL改成壹个Python库的形式，直接Import，不需要又用ctypes载入DLL，不然调用个函数都要几行代码，还无法导出类。
C++给python写扩展库按点评区提议，又来补充上了在群里@人的教程。
C++ DLL注入微信之发送群@消息四、DLL注入是啥子原理？
所谓DLL注入就是将壹个DLL放进某个进程的地址空间里，让它成为那个进程的一部分。
要实现DLL注入，首先需要打开目标进程。
既然DLL放进了进程地址空间，进程当然改变，而且是通过进程去调用DLL的代码，原来的进程的功能并不会改变，也不会导致进程不能运用，如果你要DLL注入后，定时触发一些功能，DLL加载后建立定时的线程即可。
五、dll注入工具如何用？
1、配置后在无论兄弟们的体系上启动RemoteDll
2、默认情况下，“注入DLL”操作被选中。
3、选择注入方式，提议运用CreateRemoteThread。
4、现在通过点击“处理按钮”选择目标进程。这将显示全部正在运行的进程的详细信息。
5、进程选择后，你必须选择要注入的DLL。你可以在这里拖放DLL文件。
六、穿梭火线出现MissingshellDllcshell.dll怎样化解？
这说明CF里的反恐精英hell.dll这个文件损坏或丢失了，自己去网上下载个新鲜补丁包，把里面得反恐精英hell.dll复制出来，接着放到CF根目录里，如果不行，就把C:\WINDOWS\System32\反恐精英hell.dll也删除了，替换上新鲜补丁包里的文件。具体操作流程如下：
1、Windows 95/98/Me体系，则复制到C:\Windows\System\ 目录下。
2、Windows NT/2000体系，则复制到C:\WINNT\System32\ 目录下。
七、dll文件注入之后没效果？
无论兄弟们好，也许有下面内容几种情况：
1. 注入的dll文件不兼容：如果dll文件是针对不同的操作体系或软件版本编译的，也许会导致注入无效。确保运用的dll文件和目标软件版本和操作体系相匹配。
2. 注入位置不正确：有些程序也许有多个进程或线程，需要确定正确的注入位置。可以运用工具如Process Explorer或DLL Export Viewer来定位正确的进程和线程。
3. 安全软件拦截：一些杀毒软件或安全软件也许会拦截dll注入操作，需要关闭或禁用它们。
4. 注入代码有误：注入代码也许存在错误，导致注入失败或无效。需要检查代码并进行调试。
5. 目标软件有防注入机制：一些软件也许会有防注入机制，需要运用更顶级的注入技术或绕过这些机制。
八、使命召唤dll注入的辅助
近年来，随着网络游戏的盛行和电竞产业的蓬勃进步，游戏辅助软件也逐渐成为许多玩家和职业选手的关注焦点。而在众多辅助软件中，使命召唤系列游戏中的dll注入辅助尤为引人瞩目。
使命召唤系列游戏
《使命召唤》（Duty of Duty）是一款由美国游戏企业Infinity Ward和Treyarch开发的STG类游戏，自2003年首发以来，在全球范围内拥有庞大的玩家群体。该系列游戏以其丰盛的战斗场景、逼真的画面和极具挑战性的游戏性而备受玩家喜爱。
dll注入辅助
dll注入辅助是一种通过注入动态链接库（Dynamic Link Library）来修改游戏进程，从而获取游戏内信息、实现辅助功能的技术手段。通过dll注入辅助，玩家可以实现诸如自瞄、透视、加速等功能，从而在游戏中取得不正当的优势。
辅助软件的争议
虽然辅助软件在一定程度上可以提高玩家的游戏尝试和技能，然而其带来的负面影响也不要忽视。作弊行为严重破坏了游戏的公正性和竞技性，影响了整个游戏生态的健壮进步。
特别是在竞技游戏中，辅助软件的运用更是严重影响了职业选手的公正竞技环境，损害了电竞产业的良性进步。因此，游戏企业和相关监管部门常常积极打击辅助软件，加强游戏安全防护和监管力度。
使命召唤dll注入辅助的风险
在使命召唤系列游戏中运用dll注入辅助存在诸多风险。首先，游戏企业往往会针对辅助软件进行反作弊体系，一旦被体系检测到运用外挂，玩家将面临封号、封禁等处罚，甚至也许被永久封停账号。
其次，运用不明来源的辅助软件存在安全风险，也许导致个人信息被窃取、PC受到病毒攻击等难题，给玩家带来不必要的损失和困扰。
合法游戏竞技灵魂
作为一名合法玩家，应当尊重游戏制度和灵魂，遵守公正竞技守则，摒弃作弊行为，树立正面的游戏榜样。通过自身的努力和技术提高，才能获取真正的游戏趣味和成就感。
在电竞竞技环境中，职业选手更应当以正面的态度和良好的职业道德积极参和比赛，展现专业水平，树立榜样，为电竞产业的进步贡献自己的力量。
小编归纳一下
小编认为啊，使命召唤系列游戏中的dll注入辅助在一定程度上影响了游戏的公正性和竞技性，给玩家和游戏企业带来了诸多困扰和挑战。作为玩家，大家应当树立正确的游戏态度，远离辅助作弊行为，共同维护良好的游戏环境。
九、C#注入的dll，如何能让dll自动运行？
运用windows服务实现自动运行程序，接着在程序中直接调用dll就可以了
十、csgo注入dll之后如何办？
1、配置后在无论兄弟们的体系上启动RemoteDll
2、默认情况下，“注入DLL”操作被选中。
3、选择注入方式，提议运用CreateRemoteThread。
4、现在通过点击“处理按钮”选择目标进程。这将显示全部正在运行的进程的详细信息。
5、进程选择后，你必须选择要注入的DLL。你可以在这里拖放DLL文件。