PC微信逆向之发送消息

最新推荐文章于 2025-03-23 14:42:56 发布
最新推荐文章于 2025-03-23 14:42:56 发布
阅读量3.6k 收藏 24
点赞数 4
分类专栏： 软件逆向 文章标签： 微信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljc545w/article/details/122751284
版权

PC微信逆向之发送消息

写在前面

最近在搞微信的发送消息CALL，跟着网上的教程，一步一步走，很容易定位到CALL的地址，在适当的地方用OD断下，修改压入的参数内容，消息内容或接收人成功改变，但在使用C++调用的时候，因为不懂汇编指令，所以踩了一些坑。

工具

微信 3.5.0.46
Windows10 Pro
OllyICE 1.10
Cheat Engine 7.0
Visual Studio 2019

定位CALL地址

这部分感觉自己讲不太明白，而且网上有很多现成的教程，找这个CALL的思路还是比较简单的，推荐阅读下面这篇文章：
CSDN:PC微信逆向：发送与接收消息的分析与代码实现
下面是我定位到的内容：

787D42EE    8D46 38         lea     eax, dword ptr [esi+38]          ; 取at结构体
787D42F1    6A 01           push    1                                ; 0x1
787D42F3    50              push    eax                              ; 群消息at好友，非at消息为0
787D42F4    57              push    edi                              ; 消息内容,[edi]
787D42F5    8D95 7CFFFFFF   lea     edx, dword ptr [ebp-84]          ; 接收人,[edx]
787D42FB    8D8D 58FCFFFF   lea     ecx, dword ptr [ebp-3A8]         ; 缓冲区，据说是类本身
787D4301    E8 7A793300     call    78B0BC80                         ; 发送消息CALL
787D4306    83C4 0C         add     esp, 0C                          ; 平衡堆栈

CALL的偏移：0x78B0BC80 - 0x78670000 = 0x49BC80
0x78670000是WeChatWin.dll的基地址，可以在OD中查看可执行模块获取

调用

拿到了汇编代码，下一步自然是调用，不过在这之前要搞清楚接收人和消息内容的结构，不然发送的东西CALL看不明白，微信可能就崩了。
消息内容结构：

0ABBFC1C  122B2CF8  UNICODE "123456"
0ABBFC20  00000006
0ABBFC24  00000006
0ABBFC28  00000000
0ABBFC2C  00000000

地址122B2CF8指向消息内容本身，所以结构体第一个元素是消息文本的指针，后面第一个6是消息文本的长度，第二个是消息最大长度，一般分配消息文本长度两倍大小，会多耗费一点内存，CALL执行完就回收了；再往后面就是0了，为了保证安全，可以在结构体末尾添加DWORD类型占位字符。
接收人结构：

012FE504  12290278  UNICODE "filehelper"
012FE508  0000000A
012FE50C  0000000A
012FE510  00000000
012FE514  00000000

可以看到该结构体跟消息内容基本一致，都是字符串地址加长度，在OD中还可以看到接收人结构体后面跟了一个消息内容结构体，似乎没什么用。
最终结构体应该是这个样子：

struct WxString
{
	// 存字符串
	wchar_t* buffer;
	// 存字符串长度
	DWORD length;
	// 字符串最大长度
	DWORD maxLength;
	// 补充两个占位符
	DWORD fill1;
	DWORD fill2;
};

因为是调用已有的函数，不需要加Hook，直接使用内联汇编调用就可以了：

void SendWxMessage(wchar_t* wsWxId,wchar_t* wsTextMsg) {
	// 1、构造参数
	
	// 构造接收者结构
	WxString wxWxid = { 0 };
	wxWxid.buffer = wsWxId;
	wxWxid.length = wcslen(wsWxId);
	// OD显示与字符串长度一致，但可以给大一点
	wxWxid.maxLength= wcslen(wsWxId) * 2;

	// 构造消息结构
	WxString wxTextMsg = { 0 };
	wxTextMsg.buffer = wsTextMsg;
	wxTextMsg.length = wcslen(wsTextMsg);
	// OD显示与字符串长度一致，但可以给大一点
	wxTextMsg.maxLength = wcslen(wsTextMsg) * 2;

	// 取出消息地址
	wchar_t** pWxmsg = &wxTextMsg.buffer;

	// 构造空buffer
	char buffer[0x3A8] = { 0 };

	WxString wxNull = { 0 };

	// 2、获取DLL模块基址

	// 模块基址
	DWORD dllBaseAddress = (DWORD)GetModuleHandle(L"WeChatWin.dll");

	// 3、计算函数的内存地址
	
	// 函数偏移，不同的微信版本会有变化
	DWORD callOffset = 0x49BC80;
	// 函数内存地址
	DWORD callAddress = dllBaseAddress + callOffset;

	__asm {
		lea eax, wxNull;
		// 参数5:1
		push 0x1;

		// 参数4:空结构
		push eax;

		// 参数3:发送的消息，传递消息内容的地址
		mov edi, pWxmsg;
		push edi;

		// 参数2:接收人，传递结构体地址，要特别注意lea和mov的区别
		lea edx, wxWxid;

		// 参数1:空buffer
		lea ecx, buffer;

		// 调用函数
		call callAddress;

		// 堆栈平衡，否则会崩溃
		add esp, 0xC;
	}
}

上面容易踩坑的地方是edi和edx两处，一个是mov赋值，一个是用lea取有效地址，mov传递字符串地址，lea取结构体地址，如果lea取字符串地址，就变成了字符串地址的地址，这里比较绕，其实就是指针那点破事儿，对于汇编也不太了解，如有错误欢迎指正。
可以把mov替换成lea，那么edi也直接取结构体地址就行了，已验证通过，但不知道会不会出什么问题。

生成DLL

写好了调用函数，就要编译成DLL，然后注入到微信的内存空间，测试一下了，这部分直接给完整的代码：
pch.h

// pch.h: 这是预编译标头文件。
// 下方列出的文件仅编译一次，提高了将来生成的生成性能。
// 这还将影响 IntelliSense 性能，包括代码完成和许多代码浏览功能。
// 但是，如果此处列出的文件中的任何一个在生成之间有更新，它们全部都将被重新编译。
// 请勿在此处添加要频繁更新的文件，这将使得性能优势无效。

#ifndef PCH_H
#define PCH_H

// 添加要在此处预编译的标头
#include "framework.h"
#include <string>
#include <iostream>
#include <io.h>
#include <fcntl.h>

#endif //PCH_H
#define DLLEXPORT extern "C" __declspec(dllexport)
DLLEXPORT void SendWxMessage(wchar_t* wsWxId, wchar_t* wsTextMsg);
BOOL CreateConsole(void);
// 外部调用的入口，必须export，不然无法计算函数地址
DLLEXPORT void SendWxMessageAPI(LPVOID lpParameter);

pch.cpp

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

#include "pch.h"

using namespace std;
#define STRUCT_OFFSET(stru_name, element) (unsigned long)&((struct stru_name*)0)->element

// 当使用预编译的头时，需要使用此源文件，编译才能成功。
struct WxString
{
	// 存字符串
	wchar_t* buffer;

	// 存字符串长度
	DWORD length;
	//字符串最大长度
	DWORD maxLength;

	// 补充两个占位符
	DWORD fill1;
	DWORD fill2;
};

// 外部调用时使用
struct RemoteParam
{
	DWORD wxid;
	DWORD wxmsg;
};

// 启动一个控制台窗口，以便调试
BOOL CreateConsole(void) {
	if (AllocConsole()) {
		AttachConsole(GetCurrentProcessId());
		FILE* retStream;
		freopen_s(&retStream, "CONOUT$", "w", stdout);
		if (!retStream) throw std::runtime_error("Stdout redirection failed.");
		freopen_s(&retStream, "CONOUT$", "w", stderr);
		if (!retStream) throw std::runtime_error("Stderr redirection failed.");
		return 0;
	}
	return 1;
}

// 测试用的函数
void testMessage(DWORD edx_, DWORD edi_,int s) {
	wcout.imbue(locale("chs"));
	printf("s->%d,edi->0x%08X,edx->0x%08X\n",s,edi_,edx_);
	unsigned long offset = STRUCT_OFFSET(WxString, buffer);
	// edx是通过lea取的结构体地址，所以直接强制类型转换
	WxString* wxWxid = (WxString*)edx_;
	// edi是结构体成员buffer地址，要反推结构体首地址，再进行强制类型转换
	printf("wxTextMsg结构体首地址为: 0x%08X\n", edi_ - offset);
	WxString* wxTextMsg = (WxString*)(edi_ - offset);
	// edi实际上是wchar_t**变量
	wcout << L"接收人wxid：" << wxWxid->buffer << "," << L"消息内容：" << *(wchar_t**)edi_ << endl;

	wcout << wxWxid->buffer << ",";
	printf("%d,%d,%d,%d\n", wxWxid->length, wxWxid->maxLength, wxWxid->fill1, wxWxid->fill2);
	wcout << wxTextMsg->buffer << ",";
	printf("%d,%d,%d,%d\n", wxTextMsg->length, wxTextMsg->maxLength, wxTextMsg->fill1, wxTextMsg->fill2);
}

void SendWxMessageAPI(LPVOID lpParameter) {
	RemoteParam* rp = (RemoteParam*)lpParameter;
	wchar_t* wsWxId = (WCHAR*)rp->wxid;
	wchar_t* wsTextMsg = (WCHAR*)rp->wxmsg;
	SendWxMessage(wsWxId, wsTextMsg);
}

void SendWxMessage(wchar_t* wsWxId,wchar_t* wsTextMsg) {
	// 1、构造参数
	
	// 构造接收者结构
	WxString wxWxid = { 0 };
	wxWxid.buffer = wsWxId;
	wxWxid.length = wcslen(wsWxId);
	// OD显示与字符串长度一致，但可以给大一点
	wxWxid.maxLength= wcslen(wsWxId) * 2;

	// 构造消息结构
	WxString wxTextMsg = { 0 };
	wxTextMsg.buffer = wsTextMsg;
	wxTextMsg.length = wcslen(wsTextMsg);
	// OD显示与字符串长度一致，但可以给大一点
	wxTextMsg.maxLength = wcslen(wsTextMsg) * 2;

	//取出消息地址
	wchar_t** pWxmsg = &wxTextMsg.buffer;

	// 构造空buffer
	char buffer[0x3A8] = { 0 };

	WxString wxNull = { 0 };

	// 2、获取DLL模块基址

	// 模块基址
	DWORD dllBaseAddress = (DWORD)GetModuleHandle(L"WeChatWin.dll");

	// 3、计算函数的内存地址

	// 函数偏移，不同的微信版本会有变化
	DWORD callOffset = 0x49BC80;
	// 函数内存地址
	DWORD callAddress = dllBaseAddress + callOffset;
	// printf("发消息CALL地址：0x%08X\n", callAddress);
	// 一段测试代码，参数是按从右到左的顺序压入的
	/*__asm {
		push 0x1;
		mov edi, pWxmsg;
		push edi;
		lea edx, wxWxid;
		push edx;
		call testMessage;
		add esp, 0xC;
	}*/

	// 4、编写调用函数的代码
	/*
		787D42EE    8D46 38         lea     eax, dword ptr [esi+38]          ; 取at结构体
		787D42F1    6A 01           push    1                                ; 0x1
		787D42F3    50              push    eax                              ; 群消息at好友，非at消息为0
		787D42F4    57              push    edi                              ; 消息内容,[edi]
		787D42F5    8D95 7CFFFFFF   lea     edx, dword ptr [ebp-84]          ; 接收人,[edx]
		787D42FB    8D8D 58FCFFFF   lea     ecx, dword ptr [ebp-3A8]         ; 缓冲区，据说是类本身
		787D4301    E8 7A793300     call    78B0BC80                         ; 发送消息CALL
		787D4306    83C4 0C         add     esp, 0C                          ; 平衡堆栈
	*/
	__asm {
		lea eax, wxNull;
		// 参数5:1
		push 0x1;

		// 参数4:空结构
		push eax;

		// 参数3:发送的消息，传递消息内容的地址
		mov edi, pWxmsg;
		push edi;

		// 参数2:接收人，传递结构体地址，要特别注意lea和mov的区别
		lea edx, wxWxid;

		// 参数1:空buffer
		lea ecx, buffer;

		// 调用函数
		call callAddress;

		// 堆栈平衡，否则会崩溃
		add esp, 0xC;
	}
	printf("over\n");
}

dllmain.cpp

// 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:
    {
        // DLL注入后，会执行到此处
        // CreateConsole();
        wchar_t* wsWxId = (WCHAR*)L"filehelper";
        wchar_t* wsTextMsg = (WCHAR*)L"发送的消息";
        SendWxMessage(wsWxId, wsTextMsg);
        DWORD pfunc = (DWORD)SendWxMessageAPI;
        printf("发送消息的函数地址：0x%08X\n",pfunc);
    }
    break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH: 
        break;
    }
    return TRUE;
}

注入与外部调用

DLL注入的部分，网上也有很多教程，此处不做过多讲解，思路如下：

  1. OpenProcess开启远程进程
  2. VirtualAllocEx在进程内开辟内存空间
  3. WriteProcessMemory在指定内存写入DLL的绝对路径
  4. CreateRemoteThread创建一个远程线程，让目标进程调用LoadLibrary
  5. 适当的时候卸载DLL（参考2-4，先GetModuleHandle，再FreeLibrary）

关键说一下怎么在外部调用发送消息的接口，在编译的DLL中，导出了SendWxMessageAPI这个函数，其实也可以不导出，只要提前算好该函数相对DLL基地址的偏移即可，具体思路如下：

  1. DLL注入微信
  2. CreateRemoteThread调用GetModuleHandle获取DLL在微信的基地址
  3. 加上算好的偏移，得到SendWxMessageAPI的地址
  4. WriteProcessMemory将消息内容和接收人写入远程进程，得到两处地址
  5. 组装结构体，保存第四步的两处地址
  6. WriteProcessMemory将结构体写入远程进程，得到结构体地址
  7. CreateRemoteThread调用SendWxMessageAPI，参数是第6步得到的结构体地址
  8. SendWxMessageAPI解引用指针，再从目标地址获取消息内容地址和接收人地址
  9. SendWxMessageAPI调用SendWxMessage，完成消息发送

看起来比较复杂，可能有人会问为什么不直接调用SendWxMessage，我理解的是，CreateRemoteThread只能传递一个LPVOID类型的参数，所以要用结构体来保存所有的参数，但是结构体中不能有指针，否则把结构体写入远程进程的时候，只是写了一些冰冷的数字进去，访问的时候还会出现NULL指针错误。

注入部分代码

injert.h

#pragma once
#include <iostream>
#include "stdlib.h"
#include <tchar.h>
#include <Windows.h>
#include <stdio.h>
#include <windows.h>
#include <TlHelp32.h>
#include <atlconv.h>
#include <tchar.h>
#include <sys/stat.h>

using namespace std;

bool Inject(DWORD dwId, WCHAR* szPath);
bool isFileExists_stat(string& name);
string wstring2string(wstring wstr);

main.cpp

#include "injert.h"

// DLL中有一个同样的结构体
struct RemoteParam
{
    DWORD wxid;
    DWORD wxmsg;
};
// 参数1：申请的远程进程句柄，参数2：要调用的函数地址
void SendWxMessage(HANDLE hProcess, DWORD addrsend) {
    DWORD dwId = 0;
    DWORD dwWriteSize = 0;
    RemoteParam RemoteData;
    ZeroMemory(&RemoteData, sizeof(RemoteParam));
    LPVOID wxidaddr = VirtualAllocEx(hProcess, NULL, 1, MEM_COMMIT, PAGE_READWRITE);
    LPVOID wxmsgaddr = VirtualAllocEx(hProcess, NULL, 1, MEM_COMMIT, PAGE_READWRITE);
    RemoteParam* paramAndFunc = (RemoteParam*)::VirtualAllocEx(hProcess, 0, sizeof(RemoteData), MEM_COMMIT, PAGE_READWRITE);
    if (!wxidaddr || !wxmsgaddr || !paramAndFunc || !addrsend)
        return;
    DWORD dwTId = 0;
    // wxid和wxmsg写入远程线程
    WCHAR* wxid = (WCHAR*)L"filehelper";
    if (wxidaddr)
        WriteProcessMemory(hProcess, wxidaddr, wxid, wcslen(wxid) * 2 + 2, &dwWriteSize);

    WCHAR* wxmsg = (WCHAR*)L"发送的消息";
    if (wxmsgaddr)
        WriteProcessMemory(hProcess, wxmsgaddr, wxmsg, wcslen(wxmsg) * 2 + 2, &dwWriteSize);
    // 结构体存储wxid和wxmsg的地址
    RemoteData.wxid = (DWORD)wxidaddr;
    RemoteData.wxmsg = (DWORD)wxmsgaddr;

    // 远程线程写入结构体
    if (paramAndFunc != NULL)
        printf("wxid地址：0x%08X,wxmsg地址：0x%08X\n", (DWORD)wxidaddr, (DWORD)wxmsgaddr);
    if (paramAndFunc) {
        if (!::WriteProcessMemory(hProcess, paramAndFunc, &RemoteData, sizeof(RemoteData), &dwTId))
        {
            printf("写入paramAndFunc失败!error:0x%08X\n", GetLastError());
        }
        else {
            printf("写入paramAndFunc成功!要写入的size:%d,实际写入的size:%d\n", sizeof(RemoteData), dwTId);
        }
    }
    else {
        printf("申请内存空间paramAndFunc失败!error:0x%08X\n", GetLastError());
    }
    printf("写入的结构体首地址：0x%08X\n", (DWORD)paramAndFunc);
    // 在此处打断点，然后用CE验证指针中的数据是否正确
    // system("pause");
    HANDLE hThread = ::CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)addrsend, (LPVOID)paramAndFunc, 0, &dwId);
    if (hThread) {
        WaitForSingleObject(hThread, INFINITE);
        CloseHandle(hThread);
    }
    else {
        printf("调用消息发送函数失败!\n");
    }
    // 释放内存，释放后可以再次查看CE
    VirtualFreeEx(hProcess, wxidaddr, 0, MEM_RELEASE);
    VirtualFreeEx(hProcess, wxmsgaddr, 0, MEM_RELEASE);
    VirtualFreeEx(hProcess, paramAndFunc, 0, MEM_RELEASE);
}


bool Inject(DWORD dwId, WCHAR* szPath)//参数1：目标进程PID  参数2：DLL路径
{
    //一、在目标进程中申请一个空间
    /*
    【1.1 获取目标进程句柄】
    */
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwId);
    printf("目标窗口的句柄为:%d\n", (int)hProcess);

    /*
    【1.2 在目标进程的内存里开辟空间】
    */
    LPVOID pRemoteAddress = VirtualAllocEx(hProcess,NULL,1,MEM_COMMIT,PAGE_READWRITE);

    //二、 把dll的路径写入到目标进程的内存空间中
    DWORD dwWriteSize = 0;
    /*
    【写一段数据到刚才给指定进程所开辟的内存空间里】
    */
    if (pRemoteAddress)
    {
        WriteProcessMemory(hProcess, pRemoteAddress, szPath, wcslen(szPath) * 2 + 2, &dwWriteSize);
    }
    else {
        printf("写入失败!\n");
        return 1;
    }

    //三、 创建一个远程线程，让目标进程调用LoadLibrary
    HANDLE hThread = CreateRemoteThread(hProcess,NULL,0,(LPTHREAD_START_ROUTINE)LoadLibrary,pRemoteAddress,NULL,NULL);
    if (hThread) {
        WaitForSingleObject(hThread, -1); //当句柄所指的线程有信号的时候，才会返回
    }
    else {
        printf("调用失败!\n");
        return 1;
    }
    CloseHandle(hThread);
    WCHAR* dllname = (WCHAR*)L"DllSendMessage.dll";
    WriteProcessMemory(hProcess, pRemoteAddress, dllname, wcslen(dllname) * 2 + 2, &dwWriteSize);
    // 调用GetModuleHandleW
    DWORD dwHandle, dwID;
    LPVOID pFunc = GetModuleHandleW;
    hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFunc, pRemoteAddress, 0, &dwID);
    if (hThread) {
        WaitForSingleObject(hThread, INFINITE);
        // 获取远程线程的返回值
        GetExitCodeThread(hThread, &dwHandle);
    }
    else {
        printf("GetModuleHandleW调用失败!\n");
        return 1;
    }
    CloseHandle(hThread);
    // 获取发送消息接口函数地址
    HMODULE hd = LoadLibrary(szPath);
    DWORD addrsend = 0;
    // 计算对应函数的地址，已经算好偏移就不需要加载DLL进本进程了
    if (hd) {
        DWORD localsendaddr = (DWORD)GetProcAddress(hd, "SendWxMessageAPI");
        printf("模块基址：0x%08X，函数地址：0x%08X，偏移：0x%08X\n", (DWORD)hd, localsendaddr, localsendaddr - (DWORD)hd);
        addrsend = dwHandle + localsendaddr - (DWORD)hd;
        printf("目标进程发送消息函数地址：0x%08X\n", addrsend);
        // 当前进程卸载DLL
        FreeLibrary(hd);
    }
    SendWxMessage(hProcess, addrsend);
    // 四、 【释放申请的虚拟内存空间】
    VirtualFreeEx(hProcess, pRemoteAddress, 0, MEM_RELEASE);
    // 释放console窗口，不然关闭console的同时微信也会退出
    pFunc = FreeConsole;
    hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFunc, NULL, 0, &dwID);
    if (hThread) {
        WaitForSingleObject(hThread, INFINITE);
        CloseHandle(hThread);
    }
    else {
        printf("FreeConsole调用失败!\n");
        return 1;
    }

    // 使目标进程调用FreeLibrary，卸载DLL
    pFunc = FreeLibrary;
    hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFunc, (LPVOID)dwHandle, 0, &dwID);
    if (hThread) {
        WaitForSingleObject(hThread, INFINITE);
        CloseHandle(hThread);
    }
    else {
        printf("FreeLibrary调用失败!\n");
        return 1;
    }
    CloseHandle(hProcess);
    return 0;
}

bool isFileExists_stat(string& name) {
    struct stat buffer;
    return (stat(name.c_str(), &buffer) == 0);
}

string wstring2string(wstring wstr)
{
    std::string result;
    //获取缓冲区大小，并申请空间，缓冲区大小事按字节计算的  
    int len = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), NULL, 0, NULL, NULL);
    char* buffer = new char[len + 1];
    //宽字节编码转换成多字节编码  
    WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), buffer, len, NULL, NULL);
    buffer[len] = '\0';
    //删除缓冲区并返回值  
    result.append(buffer);
    delete[] buffer;
    return result;
}

int _tmain(int nargv,WCHAR* argvs[])
{
    wchar_t* wStr = (WCHAR*)L"";
    if (nargv == 1) {
        return 0;
    }
    else {
        wStr = argvs[1];
    }
    string name = wstring2string((wstring)wStr);
    DWORD dwId = 0;
    if (!isFileExists_stat(name)) {
        wstring info = L"注入失败！请检查DLL路径！";
        MessageBox(NULL, info.c_str(), _T("警告"), MB_ICONWARNING);
        return 0;
    }

    // 参数1：NULL
    // 参数2：目标窗口的标题
    // 返回值：目标窗口的句柄
    HWND hCalc = FindWindow(NULL, L"微信");
    printf("目标窗口的句柄为:%d\n", (int)hCalc);

    DWORD dwPid = 0;

    //参数1：目标进程的窗口句柄
    //参数2：把目标进程的PID存放进去
    DWORD dwRub = GetWindowThreadProcessId(hCalc, &dwPid);
    printf("目标窗口的进程PID为:%d\n", dwPid);

    //参数1：目标进程的PID
    //参数2：想要注入DLL的路径
    Inject(processID, wStr);
    return 0;
}

写在后面

感觉越来越有判头了。

MacOS微信逆向分析-Frida
2403_87731058的博客
11-18 1262
PC下的微信二次开发相信大家都会了，那么本篇文章将带领大家使用Frida框架对Mac下微信来进行！PS：还有一种静态注入的方式也不错，但是考虑到大家xcode安装包太大就不在这里展开啦。PS：frida如何去使用大家得自己去学，本文不过多展开。PS：文章编写不易，转载请标注出处PS：欢迎大家跟帖交流。
逆向探索微信消息界面实现
zhenganzhong_csdn的博客
08-24 6390
转自:https://everettjf.github.io/2016/06/19/reverse-explore-wechat-message-design 逆向探索微信消息界面实现 Jun 19, 2016 背景准备初步窥探 定位Controller观察Views RevealMMTableViewMessageNodeView简单总结 观察Controller
PC微信逆向之发送消息参考代码
01-30
介绍逆向入门知识
PC微信逆向) 读取内存联系人链表
最新发布
Qwertyuiop2016的博客
03-23 1590
首先从一些网络上搜索到的信息可以得出联系人列表是保存在内存里的，并且是全局变量不会被释放，所以我们可以通过搜索某个联系人的信息来定位
微信逆向：文本消息发送
wtujoxk的博客
07-03 609
第二篇，分析文本消息发送call，并自己写代码调用实现发文本消息。
PC微信逆向：发送与接收消息的分析与代码实现
鬼手的博客
06-22 5万+
文章目录定位微信的消息接收函数定位消息接收函数的相关思路定位消息内容的地址分析接收消息函数好友消息群消息总结代码实现定位微信的消息发送函数定位消息发送函数的相关思路过滤当前聊天窗口的微信ID定位当前聊天窗口的ID定位发送消息的函数分析发送消息的函数普通消息艾特某人消息总结代码实现最终效果 定位微信的消息接收函数 我们先来定位一下消息接收函数，这对我们后面分析消息发送函数会有所帮助 定位消息接收函数...
PC版微信数据库解密详细教程
Welcome to Garywang's IT BLOG.
09-29 2万+
转载自：https://bbs.pediy.com/thread-251303.htm，写得比较详细，未测试，备查！ 在电子取证过程中，也会遇到提取PC版微信数据的情况，看雪、52破解和CSDN等网上的PC版微信数据库破解文章实在是太简略了，大多数只有结果没有过程。经过反复试验终于成功解密了数据库，现在把详细过程记录下来，希望大家不要继续在已经解决的问题上过度浪费时间，以便更投入地研究尚未解决的...
PC微信逆向分析之《获取登录二维码》
热门推荐
weixin_44678558的博客
04-03 11万+
所有png图片都是有统一格式的文件头数据块：89 50 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52文件尾数据块：00 00 00 00 49 45 4e 44 ae 42 60 82使用16进制查看器随便打开一张png图片，可以看出文件头确实跟上述一致，那么我们就从这里做切入点。
C++发送PC微信文本消息示例代码（V2.6.7.57）
04-23
标题中的"C++发送PC微信文本消息示例代码（V2.6.7.57）"涉及的是一个使用C++编程语言编写的程序，目的是在Windows PC上的微信客户端（版本2.6.7.57）中发送文本消息。这个程序可能通过与微信客户端的API接口交互或对...
C++实现PC微信文本消息发送的实例教程
在这里，它指代了一个实际的C++源代码文件，该文件包含了可以发送文本消息到PC微信的相关实现代码。 ### 描述知识点 - **测试通过：** 描述中提到代码在特定版本的PC微信上测试通过，意味着该代码示例是经过实际...
最新微信3.3.0.104PC微信HOOK
07-04
标题中的“最新微信3.3.0.104PC微信HOOK”指的是微信的最新桌面版客户端，版本号为3.3.0.104，这里的“HOOK”通常是指一种编程技术，用于拦截和修改应用程序内部的函数调用，以此来实现额外的功能或监控程序行为。...
PC微信逆向分析の绕过加密访问SQLite数据库.7z
01-03
PC微信逆向分析の绕过加密访问SQLite数据库源码，注入微信，读取微信数据库内容，在线备份数据库。 源代码包括C语言和E语言的具体实现。
pc微信逆向最新3.9.8.25版本
奔跑的坏蜗牛
02-21 3438
PC微信逆向最新版本3.9.8.25，开发一个关于微信的计数、统计、自动回复功能的机器人，主要是用在win10上面。
pc微信逆向最新3.9.2.23版本
qwe_cao的博客
01-05 1万+
微信逆向，pc微信逆向，wechat逆向
x32dbg、x64dbg逆向微信发送信息
云舒的博客
04-05 4407
一、流程分析 进行逆向之前，先分析一下微chat程序，构思一下整体思路。 PC端微chat使用的协议我们可以通过对每种协议相关的API设置断点来确定是哪个协议。一般PC端客户端程序的通信协议常用的是tcp和udp。 关于tcp,udp的API： 协议 函数 tcp send udp sendto 因此我们可以通过断点send，来寻找我们需要的发送消息事件。 打开Exeinfo PE分析一下WeChat.exe(桌面的是.lnk文件，为快捷方式，可能找不到，因此我们右键-打开文件
PC微信逆向：分析通用设置数组
鬼手的博客
05-15 5531
文章目录前言通用设置切入点分析通用设置数据结构分析通用设置数组随机的数组下标 前言 微信版本2.8.0.121 分析诉求->通过代码实现关闭微信通用设置里的“有更新时自动升级微信"。 通用设置切入点 这种复选框的设置无非就是一个标志位的问题，分析起来比较简单，中间肯定会涉及到一些数据结构。作为开发者肯定不会把每一个设置选项都单独存放，而是放在一个数据结构里方便管理。 首先用CE附加微信 在取消勾选状态下搜索0 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jksK
微信收发消息逆向分析-最新微信版本（3.2.1.154）
h1028962069的专栏
05-18 1862
微信大部分功能都在这个里面 发消息分析 搜索字符串newsendmsg 堆栈回溯就可以找到 对应的模块和偏移 WeChatWin.dll 0x3B63B0 DWORD dwEdi[4] = { 0 }; wxMsg id = { 0 }; id.pMsg = wsWxId; id.msgLen = wcslen(wsWxId); id.buffLen = wcslen(wsWxId); //消息内容 wxMsg text = { 0 }; text.pMsg = wsCon
微信PC逆向HOOK原理讲解-svip
weixin_65409651的博客
05-27 1716
这个过程中使用了诸如CE（ Cheat Engine，一个开源的作弊引擎软件）、Ollydbg（一个流行的Windows平台下的十六进制编辑器和调试软件）等工具。PC微信Hook是指通过注入DLL文件到Windows版微信（PC微信）进程中，从而实现对微信某些功能的拦截和自定义操作。为了获取登录二维码地址，操作者需要打开CE并附加到微信上，然后搜索特定的标记（如"IHDR"），找到相关的内存地址。通过hook这个地址，可以实现在没有登录的情况下获取登录二维码的目的。
PC微信逆向--定位sqlite3_exec和数据库句柄
ljc545w的博客
04-20 7740
写在前面 最近在做PC端微信逆向，搞定了基本的首发消息，通讯录获取等，这期间遇到一个小小的问题，从通讯录获取到的内容不全，除非登录后手动点击过某个好友，不然获取不到头像、V3等，所以产生了解密数据库的想法。 收集资料 首先要明确一个想法，这个世界很大，想做的事情，至少90%都可能是别人做过的，有些人会把他们的经历分享到互联网上，我们可以利用这些知识，让自己不需要从0开始。 在这个日新月异的时代，技术存在时效性，找到的资料可以作为参考，我们需要做的，是更新替换那些过期的内容，让别人分享的东西在重新跑起来。 下
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值