Refactoring
This commit is contained in:
Changhua
parent
ade2c1c22a
commit
c96d85db30
@ -48,7 +48,7 @@ inline void InitLogger(const std::string &path)
|
||||
logger = spdlog::rotating_logger_mt(DEFAULT_LOGGER_NAME, filename.string(), DEFAULT_LOGGER_MAX_SIZE,
|
||||
DEFAULT_LOGGER_MAX_FILES);
|
||||
} catch (const spdlog::spdlog_ex &ex) {
|
||||
MessageBox(NULL, String2Wstring(ex.what()).c_str(), L"Init LOGGER ERROR", MB_ICONERROR);
|
||||
MessageBox(NULL, util::s2w(ex.what()).c_str(), L"Init LOGGER ERROR", MB_ICONERROR);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@ -1,177 +1,67 @@
|
||||
#include "Shlwapi.h"
|
||||
#include "framework.h"
|
||||
#include "util.h"
|
||||
|
||||
#include <codecvt>
|
||||
#include <locale>
|
||||
#include <memory>
|
||||
#include <string.h>
|
||||
#include <strsafe.h>
|
||||
#include <tlhelp32.h>
|
||||
#include <vector>
|
||||
#include <wchar.h>
|
||||
|
||||
#include "framework.h"
|
||||
|
||||
#include "log.hpp"
|
||||
#include "util.h"
|
||||
|
||||
#pragma comment(lib, "shlwapi")
|
||||
#pragma comment(lib, "Version.lib")
|
||||
|
||||
using namespace std;
|
||||
|
||||
wstring String2Wstring(string s)
|
||||
namespace util
|
||||
{
|
||||
if (s.empty())
|
||||
return wstring();
|
||||
int size_needed = MultiByteToWideChar(CP_UTF8, 0, &s[0], (int)s.size(), NULL, 0);
|
||||
wstring ws(size_needed, 0);
|
||||
MultiByteToWideChar(CP_UTF8, 0, &s[0], (int)s.size(), &ws[0], size_needed);
|
||||
|
||||
std::wstring s2w(const std::string &s)
|
||||
{
|
||||
if (s.empty()) return std::wstring();
|
||||
int size_needed = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), static_cast<int>(s.size()), nullptr, 0);
|
||||
std::wstring ws(size_needed, 0);
|
||||
MultiByteToWideChar(CP_UTF8, 0, s.c_str(), static_cast<int>(s.size()), &ws[0], size_needed);
|
||||
return ws;
|
||||
}
|
||||
|
||||
string Wstring2String(wstring ws)
|
||||
std::string w2s(const std::wstring &ws)
|
||||
{
|
||||
if (ws.empty())
|
||||
return string();
|
||||
int size_needed = WideCharToMultiByte(CP_UTF8, 0, &ws[0], (int)ws.size(), NULL, 0, NULL, NULL);
|
||||
string s(size_needed, 0);
|
||||
WideCharToMultiByte(CP_UTF8, 0, &ws[0], (int)ws.size(), &s[0], size_needed, NULL, NULL);
|
||||
if (ws.empty()) return std::string();
|
||||
int size_needed
|
||||
= WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), static_cast<int>(ws.size()), nullptr, 0, nullptr, nullptr);
|
||||
std::string s(size_needed, 0);
|
||||
WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), static_cast<int>(ws.size()), &s[0], size_needed, nullptr, nullptr);
|
||||
return s;
|
||||
}
|
||||
|
||||
string GB2312ToUtf8(const char *gb2312)
|
||||
std::string gb2312_to_utf8(const char *gb2312)
|
||||
{
|
||||
int size_needed = 0;
|
||||
if (!gb2312) return "";
|
||||
|
||||
size_needed = MultiByteToWideChar(CP_ACP, 0, gb2312, -1, NULL, 0);
|
||||
wstring ws(size_needed, 0);
|
||||
int size_needed = MultiByteToWideChar(CP_ACP, 0, gb2312, -1, nullptr, 0);
|
||||
std::wstring ws(size_needed, 0);
|
||||
MultiByteToWideChar(CP_ACP, 0, gb2312, -1, &ws[0], size_needed);
|
||||
|
||||
size_needed = WideCharToMultiByte(CP_UTF8, 0, &ws[0], -1, NULL, 0, NULL, NULL);
|
||||
string s(size_needed, 0);
|
||||
WideCharToMultiByte(CP_UTF8, 0, &ws[0], -1, &s[0], size_needed, NULL, NULL);
|
||||
size_needed = WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), -1, nullptr, 0, nullptr, nullptr);
|
||||
std::string s(size_needed, 0);
|
||||
WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), -1, &s[0], size_needed, nullptr, nullptr);
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
static int GetWeChatPath(wchar_t *path)
|
||||
DWORD get_wechat_pid()
|
||||
{
|
||||
int ret = -1;
|
||||
HKEY hKey = NULL;
|
||||
// HKEY_CURRENT_USER\Software\Tencent\WeChat InstallPath = xx
|
||||
if (ERROR_SUCCESS != RegOpenKey(HKEY_CURRENT_USER, L"Software\\Tencent\\WeChat", &hKey)) {
|
||||
ret = GetLastError();
|
||||
return ret;
|
||||
}
|
||||
DWORD pid = 0;
|
||||
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
||||
if (hSnapshot == INVALID_HANDLE_VALUE) return 0;
|
||||
|
||||
DWORD Type = REG_SZ;
|
||||
DWORD cbData = MAX_PATH * sizeof(WCHAR);
|
||||
if (ERROR_SUCCESS != RegQueryValueEx(hKey, L"InstallPath", 0, &Type, (LPBYTE)path, &cbData)) {
|
||||
ret = GetLastError();
|
||||
goto __exit;
|
||||
}
|
||||
|
||||
if (path != NULL) {
|
||||
PathAppend(path, WECHAREXE);
|
||||
}
|
||||
|
||||
__exit:
|
||||
if (hKey) {
|
||||
RegCloseKey(hKey);
|
||||
}
|
||||
|
||||
return ERROR_SUCCESS;
|
||||
}
|
||||
|
||||
static int GetWeChatWinDLLPath(wchar_t *path)
|
||||
{
|
||||
int ret = GetWeChatPath(path);
|
||||
if (ret != ERROR_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
PathRemoveFileSpecW(path);
|
||||
PathAppendW(path, WECHATWINDLL);
|
||||
if (!PathFileExists(path)) {
|
||||
// 微信从（大约）3.7开始，增加了一层版本目录: [3.7.0.29]
|
||||
PathRemoveFileSpec(path);
|
||||
_wfinddata_t findData;
|
||||
wstring dir = wstring(path) + L"\\[*.*";
|
||||
intptr_t handle = _wfindfirst(dir.c_str(), &findData);
|
||||
if (handle == -1) { // 检查是否成功
|
||||
return -1;
|
||||
}
|
||||
wstring dllPath = wstring(path) + L"\\" + findData.name;
|
||||
wcscpy_s(path, MAX_PATH, dllPath.c_str());
|
||||
PathAppend(path, WECHATWINDLL);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool GetFileVersion(const wchar_t *filePath, wchar_t *version)
|
||||
{
|
||||
if (wcslen(filePath) > 0 && PathFileExists(filePath)) {
|
||||
VS_FIXEDFILEINFO *pVerInfo = NULL;
|
||||
DWORD dwTemp, dwSize;
|
||||
BYTE *pData = NULL;
|
||||
UINT uLen;
|
||||
|
||||
dwSize = GetFileVersionInfoSize(filePath, &dwTemp);
|
||||
if (dwSize == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
pData = new BYTE[dwSize + 1];
|
||||
if (pData == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!GetFileVersionInfo(filePath, 0, dwSize, pData)) {
|
||||
delete[] pData;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!VerQueryValue(pData, TEXT("\\"), (void **)&pVerInfo, &uLen)) {
|
||||
delete[] pData;
|
||||
return false;
|
||||
}
|
||||
|
||||
UINT64 verMS = pVerInfo->dwFileVersionMS;
|
||||
UINT64 verLS = pVerInfo->dwFileVersionLS;
|
||||
UINT64 major = HIWORD(verMS);
|
||||
UINT64 minor = LOWORD(verMS);
|
||||
UINT64 build = HIWORD(verLS);
|
||||
UINT64 revision = LOWORD(verLS);
|
||||
delete[] pData;
|
||||
|
||||
StringCbPrintf(version, 0x20, TEXT("%d.%d.%d.%d"), major, minor, build, revision);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
int GetWeChatVersion(wchar_t *version)
|
||||
{
|
||||
WCHAR Path[MAX_PATH] = { 0 };
|
||||
|
||||
int ret = GetWeChatWinDLLPath(Path);
|
||||
if (ret != ERROR_SUCCESS) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = GetFileVersion(Path, version);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
DWORD GetWeChatPid()
|
||||
{
|
||||
DWORD pid = 0;
|
||||
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
||||
PROCESSENTRY32 pe32 = { sizeof(PROCESSENTRY32) };
|
||||
while (Process32Next(hSnapshot, &pe32)) {
|
||||
wstring strProcess = pe32.szExeFile;
|
||||
if (strProcess == WECHAREXE) {
|
||||
if (std::wstring(pe32.szExeFile) == WECHATEXE) {
|
||||
pid = pe32.th32ProcessID;
|
||||
break;
|
||||
}
|
||||
@ -180,52 +70,20 @@ DWORD GetWeChatPid()
|
||||
return pid;
|
||||
}
|
||||
|
||||
enum class WindowsArchiture { x32, x64 };
|
||||
static WindowsArchiture GetWindowsArchitecture()
|
||||
int open_wechat(DWORD *pid)
|
||||
{
|
||||
#ifdef _WIN64
|
||||
return WindowsArchiture::x64;
|
||||
#else
|
||||
return WindowsArchiture::x32;
|
||||
#endif
|
||||
}
|
||||
*pid = get_wechat_pid();
|
||||
if (*pid) return ERROR_SUCCESS;
|
||||
|
||||
BOOL IsProcessX64(DWORD pid)
|
||||
{
|
||||
BOOL isWow64 = false;
|
||||
HANDLE hProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid);
|
||||
if (!hProcess)
|
||||
return false;
|
||||
BOOL result = IsWow64Process(hProcess, &isWow64);
|
||||
CloseHandle(hProcess);
|
||||
if (!result)
|
||||
return false;
|
||||
if (isWow64)
|
||||
return false;
|
||||
else if (GetWindowsArchitecture() == WindowsArchiture::x32)
|
||||
return false;
|
||||
else
|
||||
return true;
|
||||
}
|
||||
|
||||
int OpenWeChat(DWORD *pid)
|
||||
{
|
||||
*pid = GetWeChatPid();
|
||||
if (*pid) {
|
||||
return ERROR_SUCCESS;
|
||||
WCHAR path[MAX_PATH] = { 0 };
|
||||
if (GetModuleFileNameW(nullptr, path, MAX_PATH) == 0) {
|
||||
return GetLastError();
|
||||
}
|
||||
|
||||
int ret = -1;
|
||||
STARTUPINFO si = { sizeof(si) };
|
||||
WCHAR Path[MAX_PATH] = { 0 };
|
||||
PROCESS_INFORMATION pi = { 0 };
|
||||
|
||||
ret = GetWeChatPath(Path);
|
||||
if (ERROR_SUCCESS != ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (!CreateProcess(NULL, Path, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi)) {
|
||||
if (!CreateProcessW(nullptr, path, nullptr, nullptr, FALSE, CREATE_NEW_CONSOLE, nullptr, nullptr, &si, &pi)) {
|
||||
return GetLastError();
|
||||
}
|
||||
|
||||
@ -233,115 +91,153 @@ int OpenWeChat(DWORD *pid)
|
||||
CloseHandle(pi.hProcess);
|
||||
|
||||
*pid = pi.dwProcessId;
|
||||
|
||||
return ERROR_SUCCESS;
|
||||
}
|
||||
|
||||
size_t GetWstringByAddress(UINT64 addr, wchar_t *buffer, UINT64 buffer_size)
|
||||
static std::optional<std::string> get_wechat_win_dll_path()
|
||||
{
|
||||
size_t strLength = GET_DWORD(addr + 8);
|
||||
if (strLength == 0) {
|
||||
return 0;
|
||||
} else if (strLength > buffer_size) {
|
||||
strLength = buffer_size - 1;
|
||||
char path[MAX_PATH] = { 0 };
|
||||
if (GetWeChatPath(path) != ERROR_SUCCESS) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
wmemcpy_s(buffer, strLength + 1, GET_WSTRING(addr), strLength + 1);
|
||||
PathRemoveFileSpecA(path);
|
||||
PathAppendA(path, WECHATWINDLL);
|
||||
|
||||
return strLength;
|
||||
if (!PathFileExistsA(path)) {
|
||||
// 微信 3.7+ 版本增加了一层目录
|
||||
PathRemoveFileSpecA(path);
|
||||
_finddata_t findData;
|
||||
std::string dir = std::string(path) + "\\[*.*";
|
||||
intptr_t handle = _findfirst(dir.c_str(), &findData);
|
||||
if (handle == -1) {
|
||||
return std::nullopt;
|
||||
}
|
||||
_findclose(handle);
|
||||
|
||||
std::string dllPath = std::string(path) + "\\" + findData.name + "\\" + WECHATWINDLL;
|
||||
return dllPath;
|
||||
}
|
||||
|
||||
return std::string(path);
|
||||
}
|
||||
|
||||
string GetStringByAddress(UINT64 addr)
|
||||
static std::optional<std::string> get_file_version(const std::string &filePath)
|
||||
{
|
||||
size_t strLength = GET_DWORD(addr + 8);
|
||||
return Wstring2String(wstring(GET_WSTRING(addr), strLength));
|
||||
if (filePath.empty() || !PathFileExistsA(filePath.c_str())) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
DWORD handle = 0;
|
||||
DWORD size = GetFileVersionInfoSizeA(filePath.c_str(), &handle);
|
||||
if (size == 0) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
std::vector<BYTE> data(size);
|
||||
if (!GetFileVersionInfoA(filePath.c_str(), 0, size, data.data())) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
VS_FIXEDFILEINFO *verInfo = nullptr;
|
||||
UINT len = 0;
|
||||
if (!VerQueryValueA(data.data(), "\\", reinterpret_cast<void **>(&verInfo), &len) || len == 0) {
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
char version[32];
|
||||
StringCbPrintfA(version, sizeof(version), "%d.%d.%d.%d", HIWORD(verInfo->dwFileVersionMS),
|
||||
LOWORD(verInfo->dwFileVersionMS), HIWORD(verInfo->dwFileVersionLS),
|
||||
LOWORD(verInfo->dwFileVersionLS));
|
||||
|
||||
return std::string(version);
|
||||
}
|
||||
|
||||
string GetStringByStrAddr(UINT64 addr)
|
||||
std::string get_wechat_version()
|
||||
{
|
||||
size_t strLength = GET_DWORD(addr + 8);
|
||||
return strLength ? string(GET_STRING(addr), strLength) : string();
|
||||
std::string version = "";
|
||||
|
||||
auto dllPath = get_wechat_win_dll_path();
|
||||
if (!dllPath) {
|
||||
return version;
|
||||
}
|
||||
|
||||
version = get_file_version(*dllPath);
|
||||
return version ? version : "";
|
||||
}
|
||||
|
||||
string GetStringByWstrAddr(UINT64 addr)
|
||||
uint32_t get_memory_int_by_address(HANDLE hProcess, uint64_t addr)
|
||||
{
|
||||
size_t strLength = GET_DWORD(addr + 8);
|
||||
return strLength ? Wstring2String(wstring(GET_WSTRING(addr), strLength)) : string();
|
||||
}
|
||||
|
||||
UINT32 GetMemoryIntByAddress(HANDLE hProcess, UINT64 addr)
|
||||
{
|
||||
UINT32 value = 0;
|
||||
uint32_t value = 0;
|
||||
if (!addr || !hProcess) return value;
|
||||
|
||||
unsigned char data[4] = { 0 };
|
||||
if (ReadProcessMemory(hProcess, (LPVOID)addr, data, 4, 0)) {
|
||||
value = data[0] & 0xFF;
|
||||
value |= ((data[1] << 8) & 0xFF00);
|
||||
value |= ((data[2] << 16) & 0xFF0000);
|
||||
value |= ((data[3] << 24) & 0xFF000000);
|
||||
if (ReadProcessMemory(hProcess, reinterpret_cast<LPCVOID>(addr), data, sizeof(data), nullptr)) {
|
||||
value = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
wstring GetUnicodeInfoByAddress(HANDLE hProcess, UINT64 address)
|
||||
std::wstring get_unicode_info_by_address(HANDLE hProcess, uint64_t address)
|
||||
{
|
||||
wstring value = L"";
|
||||
if (!hProcess || !address) return L"";
|
||||
|
||||
UINT64 strAddress = GetMemoryIntByAddress(hProcess, address);
|
||||
UINT64 strLen = GetMemoryIntByAddress(hProcess, address + 0x4);
|
||||
if (strLen > 500)
|
||||
return value;
|
||||
uint64_t str_address = get_memory_int_by_address(hProcess, address);
|
||||
uint64_t str_len = get_memory_int_by_address(hProcess, address + 0x4);
|
||||
if (str_len > 500) return L"";
|
||||
|
||||
wchar_t cValue[500] = { 0 };
|
||||
memset(cValue, 0, sizeof(cValue) / sizeof(wchar_t));
|
||||
if (ReadProcessMemory(hProcess, (LPVOID)strAddress, cValue, (strLen + 1) * 2, 0)) {
|
||||
value = wstring(cValue);
|
||||
if (ReadProcessMemory(hProcess, reinterpret_cast<LPCVOID>(str_address), cValue, (str_len + 1) * sizeof(wchar_t),
|
||||
nullptr)) {
|
||||
return std::wstring(cValue);
|
||||
}
|
||||
|
||||
return value;
|
||||
return L"";
|
||||
}
|
||||
|
||||
void DbgMsg(const char *zcFormat, ...)
|
||||
void dbg_msg(const char *format, ...)
|
||||
{
|
||||
// initialize use of the variable argument array
|
||||
va_list vaArgs;
|
||||
va_start(vaArgs, zcFormat);
|
||||
if (!format) return;
|
||||
|
||||
// reliably acquire the size
|
||||
// from a copy of the variable argument array
|
||||
// and a functionally reliable call to mock the formatting
|
||||
va_list vaArgsCopy;
|
||||
va_copy(vaArgsCopy, vaArgs);
|
||||
const int iLen = std::vsnprintf(NULL, 0, zcFormat, vaArgsCopy);
|
||||
va_end(vaArgsCopy);
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
|
||||
// return a formatted string without risking memory mismanagement
|
||||
// and without assuming any compiler or platform specific behavior
|
||||
std::vector<char> zc(iLen + 1);
|
||||
std::vsnprintf(zc.data(), zc.size(), zcFormat, vaArgs);
|
||||
va_end(vaArgs);
|
||||
std::string strText(zc.data(), iLen);
|
||||
va_list args_copy;
|
||||
va_copy(args_copy, args);
|
||||
int len = vsnprintf(nullptr, 0, format, args_copy);
|
||||
va_end(args_copy);
|
||||
|
||||
OutputDebugStringA(strText.c_str());
|
||||
std::vector<char> buffer(len + 1);
|
||||
vsnprintf(buffer.data(), buffer.size(), format, args);
|
||||
va_end(args);
|
||||
|
||||
OutputDebugStringA(buffer.data());
|
||||
}
|
||||
|
||||
WxString *NewWxStringFromStr(const string &str) { return NewWxStringFromWstr(String2Wstring(str)); }
|
||||
|
||||
WxString *NewWxStringFromWstr(const wstring &ws)
|
||||
std::unique_ptr<WxString> new_wx_string(const char *str)
|
||||
{
|
||||
WxString *p = (WxString *)HeapAlloc(GetProcessHeap(), 0, sizeof(WxString));
|
||||
wchar_t *pWstring = (wchar_t *)HeapAlloc(GetProcessHeap(), 0, (ws.size() + 1) * 2);
|
||||
if (p == NULL || pWstring == NULL) {
|
||||
LOG_ERROR("Out of Memory...");
|
||||
return NULL;
|
||||
return new_wx_string(str ? std::string(str) : std::string());
|
||||
}
|
||||
|
||||
std::unique_ptr<WxString> new_wx_string(const std::string &str) { return std::make_unique<WxString>(s2w(str)); }
|
||||
|
||||
std::unique_ptr<WxString> new_wx_string(const wchar_t *wstr)
|
||||
{
|
||||
return new_wx_string(wstr ? std::wstring(wstr) : std::wstring());
|
||||
}
|
||||
|
||||
std::unique_ptr<WxString> new_wx_string(const std::wstring &wstr) { return std::make_unique<WxString>(wstr); }
|
||||
|
||||
std::vector<WxString> parse_wxids(const std::string &wxids)
|
||||
{
|
||||
std::vector<WxString> wx_members;
|
||||
std::wstringstream wss(s2w(wxids));
|
||||
std::wstring wstr;
|
||||
while (getline(wss, wstr, L',')) {
|
||||
wx_members.emplace_back(wstr);
|
||||
}
|
||||
|
||||
wmemcpy(pWstring, ws.c_str(), ws.size() + 1);
|
||||
p->wptr = pWstring;
|
||||
p->size = (DWORD)ws.size();
|
||||
p->capacity = (DWORD)ws.size();
|
||||
p->ptr = 0;
|
||||
p->clen = 0;
|
||||
return p;
|
||||
return wx_members;
|
||||
}
|
||||
|
||||
} // namespace util
|
||||
|
||||
@ -1,41 +1,81 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
|
||||
#include "spy_types.h"
|
||||
|
||||
#define WECHAREXE L"WeChat.exe"
|
||||
#define WECHATWINDLL L"WeChatWin.dll"
|
||||
#define WCFSDKDLL L"sdk.dll"
|
||||
#define WCFSPYDLL L"spy.dll"
|
||||
#define WCFSPYDLL_DEBUG L"spy_debug.dll"
|
||||
namespace util
|
||||
{
|
||||
|
||||
#define GET_UINT64(addr) ((UINT64) * (UINT64 *)(addr))
|
||||
#define GET_DWORD(addr) ((DWORD) * (UINT64 *)(addr))
|
||||
#define GET_QWORD(addr) ((UINT64) * (UINT64 *)(addr))
|
||||
#define GET_STRING(addr) ((CHAR *)(*(UINT64 *)(addr)))
|
||||
#define GET_WSTRING(addr) ((WCHAR *)(*(UINT64 *)(addr)))
|
||||
#define GET_STRING_FROM_P(addr) ((CHAR *)(addr))
|
||||
#define GET_WSTRING_FROM_P(addr) ((WCHAR *)(addr))
|
||||
inline constexpr wchar_t WECHATEXE[] = L"WeChat.exe";
|
||||
inline constexpr wchar_t WECHATWINDLL[] = L"WeChatWin.dll";
|
||||
inline constexpr wchar_t WCFSDKDLL[] = L"sdk.dll";
|
||||
inline constexpr wchar_t WCFSPYDLL[] = L"spy.dll";
|
||||
inline constexpr wchar_t WCFSPYDLL_DEBUG[] = L"spy_debug.dll";
|
||||
|
||||
typedef struct PortPath {
|
||||
struct PortPath {
|
||||
int port;
|
||||
char path[MAX_PATH];
|
||||
} PortPath_t;
|
||||
};
|
||||
|
||||
DWORD GetWeChatPid();
|
||||
BOOL IsProcessX64(DWORD pid);
|
||||
int OpenWeChat(DWORD *pid);
|
||||
int GetWeChatVersion(wchar_t *version);
|
||||
size_t GetWstringByAddress(UINT64 address, wchar_t *buffer, UINT64 buffer_size);
|
||||
UINT32 GetMemoryIntByAddress(HANDLE hProcess, UINT64 address);
|
||||
std::wstring GetUnicodeInfoByAddress(HANDLE hProcess, UINT64 address);
|
||||
std::wstring String2Wstring(std::string s);
|
||||
std::string Wstring2String(std::wstring ws);
|
||||
std::string GB2312ToUtf8(const char *gb2312);
|
||||
std::string GetStringByAddress(UINT64 address);
|
||||
std::string GetStringByStrAddr(UINT64 addr);
|
||||
std::string GetStringByWstrAddr(UINT64 addr);
|
||||
void DbgMsg(const char *zcFormat, ...);
|
||||
WxString *NewWxStringFromStr(const std::string &str);
|
||||
WxString *NewWxStringFromWstr(const std::wstring &ws);
|
||||
inline DWORD get_dword(uint64_t addr) { return addr ? *reinterpret_cast<DWORD *>(addr) : 0; }
|
||||
inline QWORD get_qword(uint64_t addr) { return addr ? *reinterpret_cast<QWORD *>(addr) : 0; }
|
||||
inline uint64_t get_uint64(uint64_t addr) { return addr ? *reinterpret_cast<uint64_t *>(addr) : 0; }
|
||||
inline std::string get_p_string(uint64_t addr) { return addr ? std::string(reinterpret_cast<const char *>(addr)) : ""; }
|
||||
inline std::string get_p_string(uint64_t addr, size_t len)
|
||||
{
|
||||
return addr ? std::string(reinterpret_cast<const char *>(addr), len) : "";
|
||||
}
|
||||
inline std::wstring get_p_wstring(uint64_t addr)
|
||||
{
|
||||
return addr ? std::wstring(reinterpret_cast<const wchar_t *>(addr)) : L"";
|
||||
}
|
||||
inline std::wstring get_p_wstring(uint64_t addr, size_t len)
|
||||
{
|
||||
return addr ? std::wstring(reinterpret_cast<const wchar_t *>(addr), len) : L"";
|
||||
}
|
||||
inline std::string get_pp_string(uint64_t addr)
|
||||
{
|
||||
if (!addr) return "";
|
||||
|
||||
const char *ptr = *reinterpret_cast<const char **>(addr);
|
||||
return (ptr && *ptr) ? std::string(ptr) : "";
|
||||
}
|
||||
inline std::wstring get_pp_wstring(uint64_t addr)
|
||||
{
|
||||
if (!addr) return L"";
|
||||
|
||||
const wchar_t *ptr = *reinterpret_cast<const wchar_t **>(addr);
|
||||
return (ptr && *ptr) ? std::wstring(ptr) : "";
|
||||
}
|
||||
inline std::string get_pp_len_string(uint64_t addr)
|
||||
{
|
||||
size_t len = get_dword(addr + 8);
|
||||
return (addr && len) ? std::string(*reinterpret_cast<const char **>(addr), len) : L"";
|
||||
}
|
||||
inline std::wstring get_pp_len_wstring(uint64_t addr)
|
||||
{
|
||||
size_t len = get_dword(addr + 8);
|
||||
return (addr && len) ? std::wstring(*reinterpret_cast<const wchar_t **>(addr), len) : L"";
|
||||
}
|
||||
inline std::string get_str_by_wstr_addr(uint64_t addr) { return w2s(get_pp_len_wstring(addr)); }
|
||||
|
||||
DWORD get_wechat_pid();
|
||||
int open_wechat(DWORD *pid);
|
||||
std::string get_wechat_version();
|
||||
uint32_t get_memory_int_by_address(HANDLE hProcess, uint64_t addr);
|
||||
std::wstring get_unicode_info_by_address(HANDLE hProcess, uint64_t addr);
|
||||
std::wstring s2w(const std::string &s);
|
||||
std::string w2s(const std::wstring &ws);
|
||||
std::string gb2312_to_utf8(const char *gb2312);
|
||||
void dbg_msg(const char *format, ...);
|
||||
|
||||
std::unique_ptr<WxString> new_wx_string(const char *str);
|
||||
std::unique_ptr<WxString> new_wx_string(const wchar_t *wstr);
|
||||
std::unique_ptr<WxString> new_wx_string(const std::string &str);
|
||||
std::unique_ptr<WxString> new_wx_string(const std::wstring &wstr);
|
||||
|
||||
std::vector<WxString> parse_wxids(const std::string &wxids);
|
||||
|
||||
} // namespace util
|
||||
|
||||
@ -80,7 +80,7 @@ HANDLE InjectDll(DWORD pid, LPCWSTR dllPath, HMODULE *injectedBase)
|
||||
WaitForSingleObject(hThread, -1);
|
||||
CloseHandle(hThread);
|
||||
|
||||
*injectedBase = GetTargetModuleBase(hProcess, filesystem::path(Wstring2String(dllPath)).filename().string());
|
||||
*injectedBase = GetTargetModuleBase(hProcess, filesystem::path(util::w2s(dllPath)).filename().string());
|
||||
|
||||
VirtualFreeEx(hProcess, pRemoteAddress, 0, MEM_RELEASE);
|
||||
// CloseHandle(hProcess); // Close when exit
|
||||
|
||||
@ -28,7 +28,7 @@ static std::optional<std::wstring> ReadDisclaimerText(const char *filePath)
|
||||
}
|
||||
|
||||
std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
|
||||
return String2Wstring(content);
|
||||
return util::s2w(content);
|
||||
}
|
||||
|
||||
static bool ShowDisclaimer()
|
||||
@ -94,7 +94,7 @@ int WxInitSDK(bool debug, int port)
|
||||
return ERROR_FILE_NOT_FOUND; // DLL 文件路径不存在
|
||||
}
|
||||
|
||||
status = OpenWeChat(&wcPid);
|
||||
status = util::open_wechat(&wcPid);
|
||||
if (status != 0) {
|
||||
MessageBox(NULL, L"打开微信失败", L"WxInitSDK", 0);
|
||||
return status;
|
||||
|
||||
@ -24,7 +24,7 @@ using invite_member_to_chatroom_t = QWORD (*)(QWORD, QWORD, QWORD, QWORD);
|
||||
static vector<WxString> parse_wxids(const string &wxids)
|
||||
{
|
||||
vector<WxString> wx_members;
|
||||
wstringstream wss(String2Wstring(wxids));
|
||||
wstringstream wss(util::s2w(wxids));
|
||||
wstring wstr;
|
||||
while (getline(wss, wstr, L',')) {
|
||||
wx_members.emplace_back(wstr);
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#pragma execution_character_set("utf-8")
|
||||
|
||||
#include "contact_mgmt.h"
|
||||
|
||||
#include "fill_response.h"
|
||||
#include "log.hpp"
|
||||
#include "pb_util.h"
|
||||
@ -55,7 +56,7 @@ static string get_cnt_string(QWORD start, QWORD end, const uint8_t *feat, size_t
|
||||
return "";
|
||||
}
|
||||
|
||||
return Wstring2String(wstring(GET_WSTRING_FROM_P(pfeat + FEAT_LEN + 4), lfeat));
|
||||
return util::w2s(util::get_p_wstring(pfeat + FEAT_LEN + 4, lfeat));
|
||||
}
|
||||
|
||||
vector<RpcContact_t> get_contacts()
|
||||
@ -80,10 +81,10 @@ vector<RpcContact_t> get_contacts()
|
||||
QWORD pbin = GET_QWORD(pstart + OS_CONTACT_BIN);
|
||||
QWORD lenbin = GET_DWORD(pstart + OS_CONTACT_BIN_LEN);
|
||||
|
||||
cnt.wxid = GetStringByWstrAddr(pstart + OS_CONTACT_WXID);
|
||||
cnt.code = GetStringByWstrAddr(pstart + OS_CONTACT_CODE);
|
||||
cnt.remark = GetStringByWstrAddr(pstart + OS_CONTACT_REMARK);
|
||||
cnt.name = GetStringByWstrAddr(pstart + OS_CONTACT_NAME);
|
||||
cnt.wxid = util::get_str_by_wstr_addr(pstart + OS_CONTACT_WXID);
|
||||
cnt.code = util::get_str_by_wstr_addr(pstart + OS_CONTACT_CODE);
|
||||
cnt.remark = util::get_str_by_wstr_addr(pstart + OS_CONTACT_REMARK);
|
||||
cnt.name = util::get_str_by_wstr_addr(pstart + OS_CONTACT_NAME);
|
||||
|
||||
cnt.country = get_cnt_string(pbin, pbin + lenbin, FEAT_COUNTRY, FEAT_LEN);
|
||||
cnt.province = get_cnt_string(pbin, pbin + lenbin, FEAT_PROVINCE, FEAT_LEN);
|
||||
@ -112,8 +113,8 @@ int accept_new_friend(const std::string &v3, const std::string &v4, int scene)
|
||||
|
||||
LOG_DEBUG("\nv3: {}\nv4: {}\nscene: {}", v3, v4, scene);
|
||||
|
||||
wstring ws_v3 = String2Wstring(v3);
|
||||
wstring ws_v4 = String2Wstring(v4);
|
||||
wstring ws_v3 = util::s2w(v3);
|
||||
wstring ws_v4 = util::s2w(v4);
|
||||
WxString wx_v3(ws_v3);
|
||||
WxString wx_v4(ws_v4);
|
||||
|
||||
@ -154,7 +155,7 @@ RpcContact_t get_contact_by_wxid(const string &wxid)
|
||||
RpcContact_t contact;
|
||||
#if 0
|
||||
char buff[0x440] = { 0 };
|
||||
wstring ws_wxid = String2Wstring(wxid);
|
||||
wstring ws_wxid = util::s2w(wxid);
|
||||
WxString pri(ws_wxid);
|
||||
|
||||
DWORD contact_mgr_addr = g_WeChatWinDllAddr + 0x75A4A0;
|
||||
@ -176,9 +177,9 @@ RpcContact_t get_contact_by_wxid(const string &wxid)
|
||||
}
|
||||
|
||||
contact.wxid = wxid;
|
||||
contact.code = GetStringByWstrAddr(reinterpret_cast<DWORD>(buff) + g_WxCalls.contact.wxCode);
|
||||
contact.remark = GetStringByWstrAddr(reinterpret_cast<DWORD>(buff) + g_WxCalls.contact.wxRemark);
|
||||
contact.name = GetStringByWstrAddr(reinterpret_cast<DWORD>(buff) + g_WxCalls.contact.wxName);
|
||||
contact.code = util::get_str_by_wstr_addr(reinterpret_cast<DWORD>(buff) + g_WxCalls.contact.wxCode);
|
||||
contact.remark = util::get_str_by_wstr_addr(reinterpret_cast<DWORD>(buff) + g_WxCalls.contact.wxRemark);
|
||||
contact.name = util::get_str_by_wstr_addr(reinterpret_cast<DWORD>(buff) + g_WxCalls.contact.wxName);
|
||||
contact.gender = GET_DWORD(reinterpret_cast<DWORD>(buff) + 0x148);
|
||||
|
||||
__asm {
|
||||
|
||||
@ -1,7 +1,8 @@
|
||||
#include <algorithm>
|
||||
#include "exec_sql.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
|
||||
#include "exec_sql.h"
|
||||
#include "fill_response.h"
|
||||
#include "log.hpp"
|
||||
#include "pb_util.h"
|
||||
@ -29,7 +30,7 @@ static db_map_t db_map;
|
||||
static void get_db_handle(QWORD base, QWORD offset)
|
||||
{
|
||||
auto *wsp = reinterpret_cast<wchar_t *>(*(QWORD *)(base + offset + OFFSET_DB_NAME));
|
||||
std::string dbname = Wstring2String(std::wstring(wsp));
|
||||
std::string dbname = util::w2s(std::wstring(wsp));
|
||||
db_map[dbname] = GET_QWORD(base + offset);
|
||||
}
|
||||
|
||||
@ -41,12 +42,12 @@ static void get_msg_db_handle(QWORD msg_mgr_addr)
|
||||
QWORD db_addr = GET_QWORD(p_start + i * 0x08);
|
||||
if (db_addr) {
|
||||
// MSGi.db
|
||||
std::string dbname = Wstring2String(GET_WSTRING(db_addr));
|
||||
std::string dbname = util::w2s(get_pp_wstring(db_addr));
|
||||
db_map[dbname] = GET_QWORD(db_addr + 0x78);
|
||||
|
||||
// MediaMsgi.db
|
||||
QWORD mmdb_addr = GET_QWORD(db_addr + 0x20);
|
||||
std::string mmdbname = Wstring2String(GET_WSTRING(mmdb_addr + 0x78));
|
||||
std::string mmdbname = util::w2s(get_pp_wstring(mmdb_addr + 0x78));
|
||||
db_map[mmdbname] = GET_QWORD(mmdb_addr + 0x50);
|
||||
}
|
||||
}
|
||||
@ -199,7 +200,7 @@ int get_local_id_and_dbidx(uint64_t id, uint64_t *local_id, uint32_t *db_idx)
|
||||
continue;
|
||||
}
|
||||
|
||||
std::string dbname = Wstring2String(GET_WSTRING(db_addr));
|
||||
std::string dbname = util::w2s(get_pp_wstring(db_addr));
|
||||
db_map[dbname] = GET_QWORD(db_addr + 0x78);
|
||||
|
||||
std::string sql = "SELECT localId FROM MSG WHERE MsgSvrID=" + std::to_string(id) + ";";
|
||||
|
||||
@ -1,12 +1,13 @@
|
||||
#pragma warning(disable : 4244)
|
||||
#include "funcs.h"
|
||||
|
||||
#include "framework.h"
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
|
||||
#include "framework.h"
|
||||
|
||||
#include "codec.h"
|
||||
#include "exec_sql.h"
|
||||
#include "funcs.h"
|
||||
#include "log.hpp"
|
||||
#include "receive_msg.h"
|
||||
#include "spy_types.h"
|
||||
@ -342,7 +343,7 @@ OcrResult_t GetOcrResult(string path)
|
||||
QWORD *pUnk1 = &unk1;
|
||||
QWORD *pUnk2 = &unk2;
|
||||
// 路径分隔符有要求，必须为 `\`
|
||||
wstring wsPath = String2Wstring(fs::path(path).make_preferred().string());
|
||||
wstring wsPath = util::s2w(fs::path(path).make_preferred().string());
|
||||
WxString wxPath(wsPath);
|
||||
vector<QWORD> *pv = (vector<QWORD> *)HeapAlloc(GetProcessHeap(), 0, 0x20);
|
||||
RawVector_t *pRv = (RawVector_t *)pv;
|
||||
@ -358,7 +359,7 @@ OcrResult_t GetOcrResult(string path)
|
||||
QWORD header = GET_QWORD(buff);
|
||||
for (QWORD i = 0; i < count; i++) {
|
||||
QWORD content = GET_QWORD(header);
|
||||
ret.result += Wstring2String(GET_WSTRING(content + 0x28));
|
||||
ret.result += util::w2s(get_pp_wstring(content + 0x28));
|
||||
ret.result += "\n";
|
||||
header = content;
|
||||
}
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
|
||||
#include "receive_msg.h"
|
||||
|
||||
#include <condition_variable>
|
||||
#include <mutex>
|
||||
#include <queue>
|
||||
@ -6,7 +7,6 @@
|
||||
#include "framework.h"
|
||||
|
||||
#include "log.hpp"
|
||||
#include "receive_msg.h"
|
||||
#include "user_info.h"
|
||||
#include "util.h"
|
||||
|
||||
@ -42,20 +42,21 @@ QWORD MessageHandler::DispatchMsg(QWORD arg1, QWORD arg2)
|
||||
wxMsg.type = GET_DWORD(arg2 + OS_RECV_MSG_TYPE);
|
||||
wxMsg.is_self = GET_DWORD(arg2 + OS_RECV_MSG_SELF);
|
||||
wxMsg.ts = GET_DWORD(arg2 + OS_RECV_MSG_TS);
|
||||
wxMsg.content = GetStringByWstrAddr(arg2 + OS_RECV_MSG_CONTENT);
|
||||
wxMsg.sign = GetStringByWstrAddr(arg2 + OS_RECV_MSG_SIGN);
|
||||
wxMsg.xml = GetStringByWstrAddr(arg2 + OS_RECV_MSG_XML);
|
||||
wxMsg.roomid = GetStringByWstrAddr(arg2 + OS_RECV_MSG_ROOMID);
|
||||
wxMsg.content = util::get_str_by_wstr_addr(arg2 + OS_RECV_MSG_CONTENT);
|
||||
wxMsg.sign = util::get_str_by_wstr_addr(arg2 + OS_RECV_MSG_SIGN);
|
||||
wxMsg.xml = util::get_str_by_wstr_addr(arg2 + OS_RECV_MSG_XML);
|
||||
wxMsg.roomid = util::get_str_by_wstr_addr(arg2 + OS_RECV_MSG_ROOMID);
|
||||
|
||||
if (wxMsg.roomid.find("@chatroom") != std::string::npos) {
|
||||
wxMsg.is_group = true;
|
||||
wxMsg.sender = wxMsg.is_self ? user_info::get_self_wxid() : GetStringByWstrAddr(arg2 + OS_RECV_MSG_WXID);
|
||||
wxMsg.sender
|
||||
= wxMsg.is_self ? user_info::get_self_wxid() : util::get_str_by_wstr_addr(arg2 + OS_RECV_MSG_WXID);
|
||||
} else {
|
||||
wxMsg.is_group = false;
|
||||
wxMsg.sender = wxMsg.is_self ? user_info::get_self_wxid() : wxMsg.roomid;
|
||||
}
|
||||
} catch (const std::exception &e) {
|
||||
LOG_ERROR(GB2312ToUtf8(e.what()));
|
||||
LOG_ERROR(util::gb2312_to_utf8(e.what()));
|
||||
}
|
||||
|
||||
{
|
||||
@ -77,7 +78,7 @@ QWORD MessageHandler::PrintWxLog(QWORD a1, QWORD a2, QWORD a3, QWORD a4, QWORD a
|
||||
return p;
|
||||
}
|
||||
|
||||
LOG_INFO("【WX】\n{}", GB2312ToUtf8((char *)p));
|
||||
LOG_INFO("【WX】\n{}", util::gb2312_to_utf8((char *)p));
|
||||
return p;
|
||||
}
|
||||
|
||||
@ -99,9 +100,9 @@ void MessageHandler::DispatchPyq(QWORD arg1, QWORD arg2, QWORD arg3)
|
||||
wxMsg.is_group = false;
|
||||
wxMsg.id = GET_QWORD(startAddr);
|
||||
wxMsg.ts = GET_DWORD(startAddr + OS_PYQ_MSG_TS);
|
||||
wxMsg.xml = GetStringByWstrAddr(startAddr + OS_PYQ_MSG_XML);
|
||||
wxMsg.sender = GetStringByWstrAddr(startAddr + OS_PYQ_MSG_SENDER);
|
||||
wxMsg.content = GetStringByWstrAddr(startAddr + OS_PYQ_MSG_CONTENT);
|
||||
wxMsg.xml = util::get_str_by_wstr_addr(startAddr + OS_PYQ_MSG_XML);
|
||||
wxMsg.sender = util::get_str_by_wstr_addr(startAddr + OS_PYQ_MSG_SENDER);
|
||||
wxMsg.content = util::get_str_by_wstr_addr(startAddr + OS_PYQ_MSG_CONTENT);
|
||||
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(handler.mutex_);
|
||||
|
||||
@ -1,5 +1,7 @@
|
||||
#pragma warning(disable : 4251)
|
||||
|
||||
#include "rpc_server.h"
|
||||
|
||||
#include <chrono>
|
||||
#include <condition_variable>
|
||||
#include <filesystem>
|
||||
@ -26,7 +28,6 @@
|
||||
#include "pb_types.h"
|
||||
#include "pb_util.h"
|
||||
#include "receive_msg.h"
|
||||
#include "rpc_server.h"
|
||||
#include "send_msg.h"
|
||||
#include "spy.h"
|
||||
#include "spy_types.h"
|
||||
@ -158,7 +159,7 @@ static bool func_send_img(char *path, char *receiver, uint8_t *out, size_t *len)
|
||||
if ((path == NULL) || (receiver == NULL)) {
|
||||
LOG_ERROR("Empty path or receiver.");
|
||||
rsp.msg.status = -1;
|
||||
} else if (!fs::exists(String2Wstring(path))) {
|
||||
} else if (!fs::exists(util::s2w(path))) {
|
||||
LOG_ERROR("Path does not exist: {}", path);
|
||||
rsp.msg.status = -2;
|
||||
} else {
|
||||
@ -174,7 +175,7 @@ static bool func_send_file(char *path, char *receiver, uint8_t *out, size_t *len
|
||||
if ((path == nullptr) || (receiver == nullptr)) {
|
||||
LOG_ERROR("Empty path or receiver.");
|
||||
rsp.msg.status = -1;
|
||||
} else if (!fs::exists(String2Wstring(path))) {
|
||||
} else if (!fs::exists(util::s2w(path))) {
|
||||
LOG_ERROR("Path does not exist: {}", path);
|
||||
rsp.msg.status = -2;
|
||||
} else {
|
||||
@ -685,7 +686,7 @@ static int RunRpcServer()
|
||||
}
|
||||
}
|
||||
} catch (const std::exception &e) {
|
||||
LOG_ERROR(GB2312ToUtf8(e.what()));
|
||||
LOG_ERROR(util::gb2312_to_utf8(e.what()));
|
||||
} catch (...) {
|
||||
LOG_ERROR("Unknow exception.");
|
||||
}
|
||||
|
||||
@ -56,13 +56,13 @@ std::unique_ptr<WxString> SendMsgManager::new_wx_string(const char *str)
|
||||
}
|
||||
std::unique_ptr<WxString> SendMsgManager::new_wx_string(const std::string &str)
|
||||
{
|
||||
return std::make_unique<WxString>(String2Wstring(str));
|
||||
return std::make_unique<WxString>(util::s2w(str));
|
||||
}
|
||||
|
||||
std::vector<WxString> SendMsgManager::parse_wxids(const string &wxids)
|
||||
{
|
||||
vector<WxString> wx_members;
|
||||
wstringstream wss(String2Wstring(wxids));
|
||||
wstringstream wss(util::s2w(wxids));
|
||||
wstring wstr;
|
||||
while (getline(wss, wstr, L',')) {
|
||||
wx_members.emplace_back(wstr);
|
||||
|
||||
@ -1,44 +1,37 @@
|
||||
#include <filesystem>
|
||||
#include "spy.h"
|
||||
|
||||
#include <filesystem>
|
||||
#include <string_view>
|
||||
|
||||
#include "log.hpp"
|
||||
#include "rpc_server.h"
|
||||
#include "spy.h"
|
||||
#include "util.h"
|
||||
|
||||
constexpr std::string_view SUPPORT_VERSION = "3.9.11.25";
|
||||
|
||||
UINT64 g_WeChatWinDllAddr = 0;
|
||||
|
||||
static bool IsWxVersionMatched(const wchar_t *version)
|
||||
{
|
||||
if (wcscmp(version, SUPPORT_VERSION) != 0) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void InitSpy(LPVOID args)
|
||||
{
|
||||
|
||||
wchar_t version[16] = { 0 };
|
||||
PortPath_t *pp = (PortPath_t *)args;
|
||||
auto *pp = static_cast<PortPath_t *>(args);
|
||||
|
||||
Log::InitLogger(pp->path);
|
||||
g_WeChatWinDllAddr = (UINT64)GetModuleHandle(L"WeChatWin.dll"); // 获取wechatWin模块地址
|
||||
if (g_WeChatWinDllAddr == 0) {
|
||||
LOG_ERROR("获取 wechatWin.dll 模块地址失败");
|
||||
if (auto dll_addr = GetModuleHandle(L"WeChatWin.dll")) {
|
||||
g_WeChatWinDllAddr = reinterpret_cast<UINT64>(dll_addr);
|
||||
} else {
|
||||
LOG_ERROR("获取 WeChatWin.dll 模块地址失败");
|
||||
return; // TODO: 退出进程，避免后面操作失败
|
||||
}
|
||||
|
||||
if (!GetWeChatVersion(version)) { // 获取微信版本
|
||||
LOG_ERROR("获取微信版本失败");
|
||||
return;
|
||||
}
|
||||
LOG_INFO("WeChat version: {}", Wstring2String(version).c_str());
|
||||
if (!IsWxVersionMatched(version)) {
|
||||
LOG_ERROR("不支持当前版本");
|
||||
MessageBox(NULL, L"不支持当前版本", L"错误", 0);
|
||||
std::string version = util::get_wechat_version();
|
||||
std::string msg = "WCF 支持版本: " + SUPPORT_VERSION + "，当前版本: " + version;
|
||||
if (version != SUPPORT_VERSION) {
|
||||
LOG_ERROR(msg);
|
||||
MessageBoxA(NULL, msg.c_str(), "错误", MB_ICONERROR);
|
||||
return;
|
||||
}
|
||||
|
||||
LOG_INFO(msg);
|
||||
RpcStartServer(pp->port);
|
||||
}
|
||||
|
||||
|
||||
@ -2,7 +2,5 @@
|
||||
|
||||
#include "framework.h"
|
||||
|
||||
#define SUPPORT_VERSION L"3.9.11.25"
|
||||
|
||||
void InitSpy(int port);
|
||||
void CleanupSpy();
|
||||
|
||||
@ -1,9 +1,10 @@
|
||||
#include <filesystem>
|
||||
#include "user_info.h"
|
||||
|
||||
#include <filesystem>
|
||||
#include <mutex>
|
||||
|
||||
#include "fill_response.h"
|
||||
#include "log.hpp"
|
||||
#include "user_info.h"
|
||||
#include "util.h"
|
||||
|
||||
extern UINT64 g_WeChatWinDllAddr;
|
||||
@ -15,14 +16,13 @@ namespace user_info
|
||||
#define OS_USER_NAME 0x595C3D8
|
||||
#define OS_USER_MOBILE 0x595C318
|
||||
|
||||
std::string
|
||||
get_home_path()
|
||||
std::string get_home_path()
|
||||
{
|
||||
static std::once_flag flag;
|
||||
static std::string home_path;
|
||||
|
||||
std::call_once(flag, [] {
|
||||
std::string path = Wstring2String(GET_WSTRING(g_WeChatWinDllAddr + OS_USER_HOME)) + "\\WeChat Files\\";
|
||||
std::string path = util::w2s(get_pp_wstring(g_WeChatWinDllAddr + OS_USER_HOME)) + "\\WeChat Files\\";
|
||||
home_path = std::filesystem::absolute(path).string();
|
||||
});
|
||||
|
||||
@ -39,9 +39,9 @@ std::string get_self_wxid()
|
||||
try {
|
||||
wxid_type = GET_UINT64(g_WeChatWinDllAddr + OS_USER_WXID + 0x18);
|
||||
if (wxid_type == 0xF) {
|
||||
wxid = GET_STRING_FROM_P(g_WeChatWinDllAddr + OS_USER_WXID);
|
||||
wxid = util::get_p_string(g_WeChatWinDllAddr + OS_USER_WXID);
|
||||
} else {
|
||||
wxid = GET_STRING(g_WeChatWinDllAddr + OS_USER_WXID);
|
||||
wxid = util::get_pp_string(g_WeChatWinDllAddr + OS_USER_WXID);
|
||||
}
|
||||
|
||||
} catch (...) {
|
||||
@ -59,10 +59,10 @@ UserInfo_t get_user_info()
|
||||
ui.wxid = get_self_wxid();
|
||||
|
||||
UINT64 name_type = GET_UINT64(g_WeChatWinDllAddr + OS_USER_NAME + 0x18);
|
||||
ui.name = (name_type == 0xF) ? GET_STRING_FROM_P(g_WeChatWinDllAddr + OS_USER_NAME)
|
||||
: GET_STRING(g_WeChatWinDllAddr + OS_USER_NAME);
|
||||
ui.name = (name_type == 0xF) ? util::get_p_string(g_WeChatWinDllAddr + OS_USER_NAME)
|
||||
: util::get_pp_string(g_WeChatWinDllAddr + OS_USER_NAME);
|
||||
|
||||
ui.mobile = GET_STRING_FROM_P(g_WeChatWinDllAddr + OS_USER_MOBILE);
|
||||
ui.mobile = util::get_p_string(g_WeChatWinDllAddr + OS_USER_MOBILE);
|
||||
ui.home = get_home_path();
|
||||
|
||||
return ui;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user