fix：修复获取个人信息错误的bug

.gitignore

@@ -30,3 +30,6 @@
 #*.exe
 *.out
 *.app
+/out
+CMakePresets.json
+.vscode

CMakeLists.txt

@@ -5,13 +5,13 @@ project(wxhelper VERSION 1.0.0)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D '0_UNICODE' /D 'UNICODE'")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D '_UNICODE' /D 'UNICODE'")
 
 file(GLOB CPP_FILES  ${PROJECT_SOURCE_DIR}/src/*.cc  ${PROJECT_SOURCE_DIR}/src/*.cpp)
 
 
 
-include_directories(c:/soft/vcpkg/installed/x86-windows/include)
+include_directories(${VCPKG_INSTALLED_DIR}/x86-windows/include)
 
 # add_subdirectory(3rd)
 

src/api.cc

@@ -18,6 +18,11 @@
 #include "chat_room.h"
 #include "self_info.h"
 #include "hook_img.h"
+#include "ocr.h"
+#include "pat.h"
+#include "confirm_receipt.h"
+#include "sns.h"
+#include "search_contact.h"
 
 #pragma comment(lib, "ws2_32.lib")
 using namespace std;
@@ -216,9 +221,8 @@ void api_handle(mg_http_message *hm, struct mg_connection *c, string &ret) {
             {"account", self_info.account},
             {"wxid", self_info.wxid},
             {"mobile", self_info.mobile},
-            {"smallImage", self_info.small_img},
-            {"bigImage", self_info.big_img},
-            {"dataRootPath",self_info.data_root_path},
+            {"headImage", self_info.head_img},
+            {"signature",self_info.signature},
             {"dataSavePath",self_info.data_save_path},
             {"currentDataPath",self_info.current_data_path},
         };
@@ -265,7 +269,11 @@ void api_handle(mg_http_message *hm, struct mg_connection *c, string &ret) {
     }
     case WECHAT_MSG_START_HOOK: {
       int port = get_http_req_param_int(hm, j_param, "port", is_post);
-      int success = HookRecvMsg(port);
+      wstring ip = get_http_req_param(hm, j_param, "ip", is_post);
+      string client_ip = Wstring2String(ip);
+      char ip_cstr[16];
+      strcpy_s(ip_cstr,client_ip.c_str());
+      int success = HookRecvMsg(ip_cstr,port);
       json ret_data = {{"code", success}, {"result", "OK"}};
       ret = ret_data.dump();
       break;
@@ -313,9 +321,33 @@ void api_handle(mg_http_message *hm, struct mg_connection *c, string &ret) {
       break;
     }
     case WECHAT_CONTACT_SEARCH_BY_NET: {
+      wstring keyword = get_http_req_param(hm, j_param, "keyword", is_post);
+      UserInfo *user = nullptr;
+      int success = SearchContactNetScene(WS2LW(keyword), &user);
+      json ret_data = {{"code", success}, {"result", "OK"}};
+      if (user) {
+        json info = {
+            {"bigImage", unicode_to_utf8(user->big_image)},
+            {"smallImage", unicode_to_utf8(user->small_image)},
+            {"city", unicode_to_utf8(user->city)},
+            {"nation", unicode_to_utf8(user->nation)},
+            {"nickname", unicode_to_utf8(user->nickname)},
+            {"province", unicode_to_utf8(user->province)},
+            {"sex", user->sex},
+            {"signature", unicode_to_utf8(user->signature)},
+            {"v2", unicode_to_utf8(user->v2)},
+            {"v3", unicode_to_utf8(user->v3)},
+        };
+        ret_data["userInfo"] = info;
+      }
+      ret = ret_data.dump();
       break;
     }
     case WECHAT_CONTACT_ADD_BY_WXID: {
+      wstring user_id = get_http_req_param(hm, j_param, "wxid", is_post);
+      int success = AddFriendByWxid(WS2LW(user_id));
+      json ret_data = {{"code", success}, {"result", "OK"}};
+      ret = ret_data.dump();
       break;
     }
     case WECHAT_CONTACT_ADD_BY_V3: {
@@ -347,6 +379,12 @@ void api_handle(mg_http_message *hm, struct mg_connection *c, string &ret) {
       break;
     }
     case WECHAT_CHATROOM_GET_MEMBER_NICKNAME: {
+      wstring room_id = get_http_req_param(hm, j_param, "chatRoomId", is_post);
+      wstring member_id = get_http_req_param(hm, j_param, "memberId", is_post);
+      
+      wstring nickname = GetChatRoomMemberNickname(WS2LW(room_id),WS2LW(member_id));
+      json ret_data = {{"code", 1}, {"result", "OK"},{"nickname",unicode_to_utf8(WS2LW(nickname))}};
+      ret = ret_data.dump();
       break;
     }
     case WECHAT_CHATROOM_DEL_MEMBER: {
@@ -380,6 +418,12 @@ void api_handle(mg_http_message *hm, struct mg_connection *c, string &ret) {
       break;
     }
     case WECHAT_CHATROOM_SET_SELF_NICKNAME: {
+      wstring room_id = get_http_req_param(hm, j_param, "chatRoomId", is_post);
+      wstring wxid = get_http_req_param(hm, j_param, "wxid", is_post);
+      wstring nick = get_http_req_param(hm, j_param, "nickName", is_post);
+      int success = ModChatRoomMemberNickName(WS2LW(room_id),WS2LW(wxid),WS2LW(nick));
+      json ret_data = {{"code", success}, {"result", "OK"}};
+      ret = ret_data.dump();
       break;
     }
     case WECHAT_DATABASE_GET_HANDLES: {
@@ -460,9 +504,18 @@ void api_handle(mg_http_message *hm, struct mg_connection *c, string &ret) {
       break;
     }
     case WECHAT_LOGOUT: {
+      int success = Logout();
+      json ret_data = {{"code", success}, {"result", "OK"}};
+      ret = ret_data.dump();
       break;
     }
     case WECHAT_GET_TRANSFER: {
+      wstring wxid = get_http_req_param(hm, j_param, "wxid", is_post);
+      wstring transcationid = get_http_req_param(hm, j_param, "transcationId", is_post);
+      wstring transferid = get_http_req_param(hm, j_param, "transferId", is_post);
+      BOOL response = DoConfirmReceipt(WS2LW(wxid), WS2LW(transcationid), WS2LW(transferid));
+      json ret_data = {{"msg", response}, {"result", "OK"}};
+      ret = ret_data.dump();
       break;
     }
     case WECHAT_GET_CONTACT_ALL: {
@@ -535,6 +588,59 @@ void api_handle(mg_http_message *hm, struct mg_connection *c, string &ret) {
       int success = GetImgByName(WS2LW(image_path),WS2LW(save_path));
       json ret_data = {{"code", success}, {"result", "OK"}};
       ret = ret_data.dump();
+      break;
+    }
+    case  WECHAT_DO_OCR:{
+      wstring image_path = get_http_req_param(hm, j_param, "imagePath", is_post);
+      string text("");
+      int success = DoOCRTask(WS2LW(image_path),text);
+      json ret_data = {{"code", success}, {"result", "OK"},{"text",text}};
+      ret = ret_data.dump();
+      break;
+    }
+    case  WECHAT_SEND_PAT_MSG:{
+      wstring room_id = get_http_req_param(hm, j_param, "chatRoomId", is_post);
+      wstring wxid = get_http_req_param(hm, j_param, "wxid", is_post);
+      int success = SendPatMsg(WS2LW(room_id),WS2LW(wxid));
+      json ret_data = {{"code", success}, {"result", "OK"}};
+      ret = ret_data.dump();
+      break;
+    }
+    case WECHAT_SET_TOP_MSG:{
+      wstring wxid = get_http_req_param(hm, j_param, "wxid", is_post);
+      ULONG64 msgid = get_http_param_ulong64(hm, j_param, "msgid", is_post);
+      int success = SetTopMsg(WS2LW(wxid),msgid);
+      json ret_data = {{"code", success}, {"result", "OK"}};
+      ret = ret_data.dump();
+      break;
+    }
+    case WECHAT_REMOVE_TOP_MSG:{
+      wstring room_id = get_http_req_param(hm, j_param, "chatRoomId", is_post);
+      ULONG64 msgid = get_http_param_ulong64(hm, j_param, "msgid", is_post);
+      int success = RemoveTopMsg(WS2LW(room_id),msgid);
+      json ret_data = {{"code", success}, {"result", "OK"}};
+      ret = ret_data.dump();
+      break;
+    }
+    case WECHAT_SNS_GET_FIRST_PAGE:{
+      int success = GetFirstPage();
+      json ret_data = {{"code", success}, {"result", "OK"}};
+      ret = ret_data.dump();
+      break;
+    }
+    case WECHAT_SNS_GET_NEXT_PAGE: {
+      ULONG64 snsid = get_http_param_ulong64(hm, j_param, "snsId", is_post);
+      int success = GetNextPage(snsid);
+      json ret_data = {{"code", success}, {"result", "OK"}};
+      ret = ret_data.dump();
+      break;
+    }
+    case WECHAT_CONTACT_NAME:{
+      wstring pri_id = get_http_req_param(hm, j_param, "id", is_post);
+      wstring name =GetContactOrChatRoomNickname(WS2LW(pri_id));
+      json ret_data = {{"code", 1}, {"result", "OK"},{"name",unicode_to_utf8(WS2LW(name))}};
+      ret = ret_data.dump();
+      break;
     }
     default:
       break;
@@ -594,6 +700,22 @@ int http_start(int port) {
   #endif
   kHttpRuning = true;
   kHttpThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)http_server,
-                             (LPVOID)port, NULL, 0);
+                              (LPVOID)port, NULL, 0);
+  return 0;
+}
+
+int http_close() {
+  if (!kHttpRuning) {
+    return 1;
+  }
+  kHttpRuning = false;
+  if (kHttpThread) {
+    WaitForSingleObject(kHttpThread, -1);
+    CloseHandle(kHttpThread);
+    kHttpThread = NULL;
+  }
+  UnHookRecvMsg();
+  UnHookImg();
+  UnHookSearchContact();
   return 0;
 }

src/api.h

@@ -63,9 +63,17 @@ typedef enum WECHAT_HTTP_APISTag
     WECHAT_GET_CONTACT_ALL,
     WECHAT_GET_CHATROOM_INFO,
     WECHAT_GET_IMG_BY_NAME,
+    WECHAT_DO_OCR,
+    WECHAT_SEND_PAT_MSG,
+    WECHAT_SET_TOP_MSG,
+    WECHAT_REMOVE_TOP_MSG,
+    WECHAT_SNS_GET_FIRST_PAGE,
+    WECHAT_SNS_GET_NEXT_PAGE,
+    WECHAT_CONTACT_NAME,
 } WECHAT_HTTP_APIS,
     *PWECHAT_HTTP_APIS;
 
 
-int http_start(int port);
+extern "C" __declspec(dllexport) int http_start(int port);
+extern "C" __declspec(dllexport) int http_close();
 #endif

src/chat_room.cc

@@ -2,19 +2,31 @@
 #include "chat_room.h"
 
 #include "common.h"
-
+#include "get_db_handle.h"
 #include "wechat_data.h"
-#define WX_CHAT_ROOM_MGR_OFFSET 0x686e40
-#define WX_GET_CHAT_ROOM_DETAIL_INFO_OFFSET 0xa70920
-#define WX_NEW_CHAT_ROOM_INFO_OFFSET 0xd03ec0
-#define WX_FREE_CHAT_ROOM_INFO_OFFSET 0x7226e0
-#define WX_DEL_CHAT_ROOM_MEMBER_OFFSET 0xa668f0
-#define WX_INIT_CHAT_MSG_OFFSET 0xdbcc40
-#define WX_FREE_CHAT_MSG_OFFSET 0x651c40
-#define WX_ADD_MEMBER_TO_CHAT_ROOM_OFFSET 0xa66400
-#define WX_GET_MEMBER_FROM_CHAT_ROOM_OFFSET 0xa71650
-#define WX_INIT_CHAT_ROOM_OFFSET 0xd01c30
-#define WX_FREE_CHAT_ROOM_OFFSET 0xa79310
+#include "base64.h"
+using namespace std;
+
+#define WX_CHAT_ROOM_MGR_OFFSET 0x72cf60
+#define WX_GET_CHAT_ROOM_DETAIL_INFO_OFFSET 0xb6f260
+#define WX_NEW_CHAT_ROOM_INFO_OFFSET 0xe15de0
+#define WX_FREE_CHAT_ROOM_INFO_OFFSET 0xe160b0
+#define WX_DEL_CHAT_ROOM_MEMBER_OFFSET 0xb64180
+#define WX_INIT_CHAT_MSG_OFFSET 0xed3be0
+#define WX_ADD_MEMBER_TO_CHAT_ROOM_OFFSET 0xb63c50
+#define WX_GET_MEMBER_FROM_CHAT_ROOM_OFFSET 0xB70260
+#define WX_INIT_CHAT_ROOM_OFFSET 0xe13b30
+#define WX_FREE_CHAT_ROOM_OFFSET 0xe13d50
+#define WX_MOD_CHAT_ROOM_MEMBER_NICK_NAME_OFFSET 0xb6adf0
+#define WX_NEW_CHAT_MSG_OFFSET 0x70e2a0
+#define WX_FREE_CHAT_MSG_OFFSET 0x6f4ea0
+#define WX_TOP_MSG_OFFSET 0xb727e0
+#define WX_REMOVE_TOP_MSG_OFFSET 0xb725a0
+#define WX_FREE_CHAT_MSG_INSTANCE_COUNTER_OFFSET  0x6f5370
+#define WX_GET_MEMBER_NICKNAME_OFFSET  0xb703f0
+#define WX_CONTACT_MGR_INSTANCE_OFFSET 0x6f8990
+#define WX_GET_CONTACT_OFFSET  0xb93b20
+#define WX_FREE_CONTACT_OFFSET  0xe23690
 
 int GetChatRoomDetailInfo(wchar_t* chat_room_id, ChatRoomInfoInner& room_info) {
   int success = 0;
@@ -24,7 +36,7 @@ int GetChatRoomDetailInfo(wchar_t* chat_room_id, ChatRoomInfoInner& room_info) {
   DWORD get_chat_room_detail_addr = base + WX_GET_CHAT_ROOM_DETAIL_INFO_OFFSET;
   DWORD create_chat_room_info_addr = base + WX_NEW_CHAT_ROOM_INFO_OFFSET;
   DWORD free_chat_room_info_addr = base + WX_FREE_CHAT_ROOM_INFO_OFFSET;
-  char chat_room_info[0xA4] = {0};
+  char chat_room_info[0xDC] = {0};
   __asm {
          PUSHAD
          LEA        ECX,chat_room_info
@@ -40,21 +52,54 @@ int GetChatRoomDetailInfo(wchar_t* chat_room_id, ChatRoomInfoInner& room_info) {
          MOV        success,EAX  
          POPAD
   }
-  room_info.chat_room_id.ptr = *(wchar_t**)(chat_room_info + 0x4);
-  room_info.chat_room_id.length = *(DWORD*)(chat_room_info + 0x8);
-  room_info.chat_room_id.max_length = *(DWORD*)(chat_room_info + 0xC);
+  DWORD room_id_len = *(DWORD*)(chat_room_info + 0x8);
+  DWORD room_id_max_len = *(DWORD*)(chat_room_info + 0xC);
+  wchar_t * room_id = new wchar_t[room_id_len + 1];
+  wmemcpy(room_id,*(wchar_t**)(chat_room_info + 0x4),room_id_len + 1);
+  room_info.chat_room_id.ptr = room_id;
+  room_info.chat_room_id.length = room_id_len;
+  room_info.chat_room_id.max_length = room_id_max_len;
+  
 
-  room_info.notice.ptr = *(wchar_t**)(chat_room_info + 0x18);
-  room_info.notice.length = *(DWORD*)(chat_room_info + 0x1C);
-  room_info.notice.max_length = *(DWORD*)(chat_room_info + 0x20);
+  DWORD notice_len = *(DWORD*)(chat_room_info + 0x1C);
+  DWORD notice_max_len = *(DWORD*)(chat_room_info + 0x20);
+  wchar_t* notice_ptr = *(wchar_t**)(chat_room_info + 0x18);
+  if(notice_len <= 0){
+    room_info.notice.ptr = nullptr;
+  }else{
+    wchar_t * notice = new wchar_t[notice_len + 1];
+    wmemcpy(notice,notice_ptr,notice_len+1);
+    room_info.notice.ptr = notice;
+  }
+  room_info.notice.length = notice_len;
+  room_info.notice.max_length = notice_max_len;
 
-  room_info.admin.ptr = *(wchar_t**)(chat_room_info + 0x2C);
-  room_info.admin.length = *(DWORD*)(chat_room_info + 0x30);
-  room_info.admin.max_length = *(DWORD*)(chat_room_info + 0x34);
+  DWORD admin_len = *(DWORD*)(chat_room_info + 0x30);
+  DWORD admin_max_len = *(DWORD*)(chat_room_info + 0x34);
+  wchar_t* admin_ptr = *(wchar_t**)(chat_room_info + 0x2C);
+  if(admin_len <= 0){
+    room_info.admin.ptr = nullptr;
+  }else{
+    wchar_t * admin = new wchar_t[admin_len + 1];
+    wmemcpy(admin,admin_ptr,admin_len+1);
+    room_info.admin.ptr = admin;
+  }
+  room_info.admin.length = admin_len;
+  room_info.admin.max_length = admin_max_len;
+
+  DWORD xml_len = *(DWORD*)(chat_room_info + 0x54);
+  DWORD xml_max_len = *(DWORD*)(chat_room_info + 0x58);
+  wchar_t* xml_ptr = *(wchar_t**)(chat_room_info + 0x50);
+  if (xml_len <= 0){
+    room_info.xml.ptr = nullptr;
+  }else{
+    wchar_t * xml = new wchar_t[xml_len + 1];
+    wmemcpy(xml,xml_ptr,xml_len+1);
+    room_info.xml.ptr = xml;
+  }
+  room_info.xml.length = xml_len;
+  room_info.xml.max_length = xml_max_len;
 
-  room_info.xml.ptr = *(wchar_t**)(chat_room_info + 0x50);
-  room_info.xml.length = *(DWORD*)(chat_room_info + 0x54);
-  room_info.xml.max_length = *(DWORD*)(chat_room_info + 0x58);
   __asm {
         PUSHAD
         LEA         ECX,chat_room_info
@@ -142,9 +187,9 @@ int AddMemberToChatRoom(wchar_t* chat_room_id, wchar_t** wxids,int len){
 
 int GetMemberFromChatRoom(wchar_t* chat_room_id,ChatRoomInner & out){
   int success = 0;
-   WeChatString chat_room(chat_room_id);
-   DWORD chat_room_ptr = (DWORD) &chat_room;
-  char buffer[0x1A0] = {0};
+  WeChatString chat_room(chat_room_id);
+  DWORD chat_room_ptr = (DWORD) &chat_room;
+  char buffer[0x1D4] = {0};
   DWORD base = GetWeChatWinBase();
   DWORD get_member_addr =  base + WX_GET_MEMBER_FROM_CHAT_ROOM_OFFSET;
   DWORD get_chat_room_mgr_addr = base + WX_CHAT_ROOM_MGR_OFFSET;
@@ -182,3 +227,192 @@ int GetMemberFromChatRoom(wchar_t* chat_room_id,ChatRoomInner & out){
   }  
   return success;
 }
+
+int ModChatRoomMemberNickName(wchar_t* chat_room_id,wchar_t* wxid,wchar_t * nick){
+  int success = 0;
+  WeChatString chat_room(chat_room_id);
+  WeChatString self_wxid(wxid);
+  WeChatString new_nick(nick);
+  DWORD base = GetWeChatWinBase();
+  DWORD get_chat_room_mgr_addr = base + WX_CHAT_ROOM_MGR_OFFSET;
+  DWORD mod_member_nick_name_addr = base + WX_MOD_CHAT_ROOM_MEMBER_NICK_NAME_OFFSET;
+  DWORD init_chat_msg_addr = base + WX_INIT_CHAT_MSG_OFFSET;
+  __asm{
+    PUSHAD
+    CALL       get_chat_room_mgr_addr                               
+    SUB        ESP,0x14
+    MOV        ECX,ESP
+    LEA        EDI,new_nick
+    PUSH       EDI
+    CALL       init_chat_msg_addr                                      
+    SUB        ESP,0x14
+    LEA        EAX,self_wxid
+    MOV        ECX,ESP
+    PUSH       EAX
+    CALL       init_chat_msg_addr                                      
+    SUB        ESP,0x14
+    LEA        EAX,chat_room
+    MOV        ECX,ESP
+    PUSH       EAX
+    CALL       init_chat_msg_addr                                      
+    CALL       mod_member_nick_name_addr   
+    MOVZX     EAX,AL
+    MOV       success,EAX      
+    POPAD
+  }
+  return success;
+}
+
+
+int SetTopMsg(wchar_t* wxid,ULONG64 msg_id){
+  int success = -1;
+  char chat_msg[0x2C4] ={0};
+  DWORD base = GetWeChatWinBase();
+  DWORD new_chat_msg_addr = base + WX_NEW_CHAT_MSG_OFFSET;
+  DWORD get_chat_room_mgr_addr = base + WX_CHAT_ROOM_MGR_OFFSET;
+  DWORD handle_top_msg_addr = base + WX_TOP_MSG_OFFSET;
+  // DWORD free_addr = base +  WX_FREE_CHAT_MSG_OFFSET;
+  DWORD free_addr = base +  WX_FREE_CHAT_MSG_INSTANCE_COUNTER_OFFSET;
+  vector<string> local_msg = GetChatMsgByMsgId(msg_id);
+  if(local_msg.empty()){
+    return -2;
+  }
+  string  type = local_msg[3];
+  string  status = local_msg[10];
+  string  talker = local_msg[13];
+  string  content = local_msg[14];
+  wstring w_talker = String2Wstring(talker);
+  wstring w_content = String2Wstring(content);
+  int msg_type =stoi(type);
+  int msg_status =stoi(status);
+
+  #ifdef _DEBUG
+  wcout << "w_talker:"  <<w_talker  <<endl;
+  wcout << "w_content:"  <<w_content  <<endl;
+  #endif
+  WeChatString  chat_room(w_talker);
+  WeChatString msg_content(w_content);
+
+  WeChatString user_id(wxid);
+
+  __asm{
+    PUSHAD
+    LEA        ECX,chat_msg
+    CALL       new_chat_msg_addr
+    POPAD
+  }
+
+  memcpy(&chat_msg[0x30],&msg_id,sizeof(msg_id));
+  memcpy(&chat_msg[0x38],&msg_type,sizeof(msg_type));
+  memcpy(&chat_msg[0x40],&msg_status,sizeof(msg_status));
+  memcpy(&chat_msg[0x48],&chat_room,sizeof(chat_room));
+ 
+  memcpy(&chat_msg[0x70],&msg_content,sizeof(msg_content));
+  memcpy(&chat_msg[0x174],&user_id,sizeof(user_id));
+ 
+
+  __asm{
+    PUSHAD
+    CALL       get_chat_room_mgr_addr                             
+    PUSH       0x0
+    LEA        EAX,chat_msg
+    PUSH       EAX
+    CALL       handle_top_msg_addr
+    MOV        success,EAX
+    LEA        ECX,chat_msg
+    PUSH       0x0
+    CALL       free_addr
+    POPAD
+  }
+  return success;
+}
+
+
+int RemoveTopMsg(wchar_t* chat_room_id,ULONG64 msg_id){
+
+  int success = -1;
+  WeChatString chat_room(chat_room_id);
+  DWORD base = GetWeChatWinBase();
+  DWORD get_chat_room_mgr_addr = base + WX_CHAT_ROOM_MGR_OFFSET;
+  DWORD new_chat_msg_addr = base + WX_NEW_CHAT_MSG_OFFSET;
+  DWORD init_chat_msg_addr = base + WX_INIT_CHAT_MSG_OFFSET;
+  DWORD remove_top_msg_addr = base + WX_REMOVE_TOP_MSG_OFFSET;
+
+  __asm{
+    PUSHAD
+    CALL       get_chat_room_mgr_addr                                   
+    MOV        EDI,dword ptr [msg_id]
+    LEA        EAX,chat_room
+    MOV        ESI,dword ptr [msg_id + 0x4]
+    SUB        ESP,0x14
+    MOV        ECX,ESP
+    PUSH       EAX
+    CALL       init_chat_msg_addr                                      
+    PUSH       ESI
+    PUSH       EDI
+    CALL       remove_top_msg_addr     
+    MOV        success,EAX 
+    POPAD                               
+  }
+
+  return success;
+}
+
+
+
+std::wstring GetChatRoomMemberNickname(wchar_t* chat_room_id,wchar_t* wxid){
+  WeChatString chat_room(chat_room_id);
+  WeChatString member_id(wxid);
+  WeChatString nickname(NULL);
+  DWORD base = GetWeChatWinBase();
+  DWORD get_chat_room_mgr_addr = base + WX_CHAT_ROOM_MGR_OFFSET;
+  DWORD get_nickname_addr = base + WX_GET_MEMBER_NICKNAME_OFFSET;
+  DWORD contact_mgr_addr = base + WX_CONTACT_MGR_INSTANCE_OFFSET;
+  DWORD get_contact_addr = base + WX_GET_CONTACT_OFFSET;
+  DWORD free_contact_addr = base + WX_FREE_CONTACT_OFFSET;
+  __asm{
+    PUSHAD
+    PUSHFD
+    CALL       get_chat_room_mgr_addr                                   
+    LEA        ECX,nickname
+    PUSH       ECX
+    LEA        ECX,member_id
+    PUSH       ECX
+    LEA        ECX,chat_room
+    PUSH       ECX
+    MOV        ECX,EAX
+    CALL       get_nickname_addr                            
+    POPFD
+    POPAD
+  }
+  wstring name = L"";
+  if (nickname.ptr) {
+    name += wstring(nickname.ptr);
+  }else {
+    char buff[0x440] = {0};
+    __asm {
+      PUSHAD
+      PUSHFD
+      CALL       contact_mgr_addr                                   
+      LEA        ECX,buff
+      PUSH       ECX
+      LEA        ECX,member_id
+      PUSH       ECX
+      MOV        ECX,EAX
+      CALL       get_contact_addr                            
+      POPFD
+      POPAD
+    }
+    name += READ_WSTRING(buff, 0x6C);
+
+    __asm{
+      PUSHAD
+      PUSHFD
+      LEA        ECX,buff
+      CALL       free_contact_addr    
+      POPFD
+      POPAD
+    }
+  }
+  return name;
+}

src/chat_room.h

@@ -7,4 +7,10 @@ int DelMemberFromChatRoom(wchar_t* chat_room_id,wchar_t** wxids,int len);
 int AddMemberToChatRoom(wchar_t* chat_room_id, wchar_t** wxids,int len);
 
 int GetMemberFromChatRoom(wchar_t* chat_room_id,ChatRoomInner & out);
+int ModChatRoomMemberNickName(wchar_t* chat_room_id,wchar_t* wxid,wchar_t * nick);
+
+int SetTopMsg(wchar_t* wxid,ULONG64 msg_id);
+int RemoveTopMsg(wchar_t* chat_room_id,ULONG64 msg_id);
+
+std::wstring GetChatRoomMemberNickname(wchar_t* chat_room_id,wchar_t* wxid);
 #endif

src/common.cc

@@ -25,7 +25,7 @@ wstring utf8_to_unicode(const char *buffer) {
 /// @param wstr unicode
 /// @return string utf8
 string unicode_to_utf8(wchar_t *wstr) {
-   int c_size = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, FALSE);
+  int c_size = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, FALSE);
   if (c_size > 0) {
     char *buffer = new char[c_size + 1];
     WideCharToMultiByte(CP_UTF8, 0, wstr, -1, buffer, c_size, NULL, FALSE);
@@ -135,4 +135,11 @@ BOOL FindOrCreateDirectoryW(const wchar_t *path) {
     return false;
   }
   return true;
+}
+
+void CloseConsole(){
+  fclose(stdin);
+  fclose(stdout);
+  fclose(stderr);
+  FreeConsole();
 }

src/common.h

@@ -1,18 +1,17 @@
 #ifndef COMMON_H_
 #define COMMON_H_
 #include <string>
-using namespace std;
-#define READ_WSTRING(addr, offset) ((*(DWORD *)(addr + offset + 0x4) == 0) ? wstring(L"") : wstring((wchar_t *)(*(DWORD *)(addr + offset)), *(DWORD *)(addr + offset + 0x4)))
+#define READ_WSTRING(addr, offset) ((*(DWORD *)(addr + offset + 0x4) == 0) ? std::wstring(L"") : std::wstring((wchar_t *)(*(DWORD *)(addr + offset)), *(DWORD *)(addr + offset + 0x4)))
 
 /// @brief utf8 转换成unicode
 /// @param buffer utf8
 /// @return  unicode
-wstring utf8_to_unicode(const char *buffer);
+std::wstring utf8_to_unicode(const char *buffer);
 
 /// @brief unicode转换utf8
 /// @param wstr unicode
 /// @return utf8
-string unicode_to_utf8(wchar_t *wstr);
+std::string unicode_to_utf8(wchar_t *wstr);
 
 /// @brief 获取WeChatWin.dll基址
 /// @return 基址
@@ -35,7 +34,7 @@ void UnHookAnyAddress(DWORD hook_addr, char *origin);
 /// @brief get timeW
 /// @param timestamp timestamp
 /// @return str
-wstring GetTimeW(long long timestamp);
+std::wstring GetTimeW(long long timestamp);
 /// @brief  unicode trans utf8
 /// @param str unicode str
 /// @return  utf8 str
@@ -43,20 +42,21 @@ std::string UnicodeToUtf8(const wchar_t *str);
 /// @brief  string convert wstring
 /// @param str 
 /// @return 
-wstring String2Wstring(string str);
+std::wstring String2Wstring(std::string str);
 /// @brief wstring convert string
 /// @param str 
 /// @return 
-string Wstring2String(wstring wstr);
+std::string Wstring2String(std::wstring wstr);
 
 /// @brief create dir
 /// @param path 
 /// @return 
 BOOL FindOrCreateDirectoryW(const wchar_t *path);
 
+void CloseConsole();
 
 template <typename T1, typename T2>
-vector<T1> split(T1 str, T2 letter) {
+std::vector<T1> split(T1 str, T2 letter) {
   vector<T1> arr;
   size_t pos;
   while ((pos = str.find_first_of(letter)) != T1::npos) {

src/confirm_receipt.cc

@@ -0,0 +1,49 @@
+#include "pch.h"
+#include "confirm_receipt.h"
+
+#include "common.h"
+#include "wechat_data.h"
+
+#define WX_NEW_WCPAYINFO_OFFSET 0x756340
+#define WX_FREE_WCPAYINFO_OFFSET 0x73c170
+#define WX_CONFIRM_RECEIPT_OFFSET 0x15287a0
+
+int DoConfirmReceipt(wchar_t *wxid, wchar_t *transcationid,
+                     wchar_t *transferid) {
+  int success = -1;
+  WeChatString recv_id(wxid);
+  WeChatString transcation_id(transcationid);
+  WeChatString transfer_id(transferid);
+  char pay_info[0x134] = {0};
+  DWORD base = GetWeChatWinBase();
+  DWORD new_pay_info_addr = base + WX_NEW_WCPAYINFO_OFFSET;
+  DWORD free_pay_info_addr = base + WX_FREE_WCPAYINFO_OFFSET;
+  DWORD do_confirm_addr = base + WX_CONFIRM_RECEIPT_OFFSET;
+  __asm {
+    PUSHAD
+    LEA        ECX,pay_info
+    CALL       new_pay_info_addr
+    MOV        dword ptr [pay_info + 0x4], 0x1
+    MOV        dword ptr [pay_info + 0x4C], 0x1        
+    POPAD
+  }
+  memcpy(&pay_info[0x1c], &transcation_id, sizeof(transcation_id));
+  memcpy(&pay_info[0x38], &transfer_id, sizeof(transfer_id));
+
+  __asm {
+    PUSHAD
+    PUSH       0x1
+    SUB        ESP,0x8
+    LEA        EDX,recv_id
+    LEA        ECX,pay_info
+    CALL       do_confirm_addr  
+    MOV        success,EAX  
+    ADD        ESP,0xC
+    PUSH       0x0
+    LEA        ECX,pay_info
+    CALL       free_pay_info_addr 
+    POPAD
+  }
+
+  return success;
+}

src/confirm_receipt.h

@@ -0,0 +1,6 @@
+#ifndef CONFIRM_RECEIPT_H
+#define CONFIRM_RECEIPT_H
+
+int  DoConfirmReceipt(wchar_t* wxid,wchar_t *transcationid, wchar_t *transferid);
+
+#endif

src/contact.cc

@@ -3,16 +3,18 @@
 
 #include "common.h"
 #include "wechat_data.h"
+using namespace std;
+#define WX_CONTACT_MGR_INSTANCE_OFFSET 0x6f8990
+#define WX_CONTACT_GET_LIST_OFFSET 0xb97550
+#define WX_CONTACT_DEL_OFFSET 0xb9b3b0
+#define WX_INIT_CHAT_MSG_OFFSET 0xed3be0
+#define WX_SYNC_MGR_OFFSET 0xa87fd0
+#define WX_SET_VALUE_OFFSET 0x1f80900
+#define WX_DO_DEL_CONTACT_OFFSET 0xca6480
+#define WX_FREE_CONTACT_OFFSET  0xe23690
+#define WX_GET_CONTACT_OFFSET  0xb93b20
+#define WX_DO_VERIFY_USER_OFFSET  0xB91160
 
-#define WX_CONTACT_MGR_INSTANCE_OFFSET 0x655d60
-#define WX_CONTACT_GET_LIST_OFFSET 0xa97da0
-#define WX_CONTACT_DEL_OFFSET 0xa9bd10
-#define WX_INIT_CHAT_MSG_OFFSET 0xdbcc40
-#define WX_DB_QUERY_OFFSET 0xa9ba20
-#define WX_SYNC_MGR_OFFSET 0x993fa0
-#define WX_SYNC_MGR_OFFSET 0x993fa0
-#define WX_DO_DEL_CONTACT_OFFSET 0xb9a750
-#define WX_DEL_CONTACT_VTABLE_OFFSET  0x2886990
 int GetAllContact(vector<Contact> &vec) {
   DWORD base = GetWeChatWinBase();
   DWORD get_instance = base + WX_CONTACT_MGR_INSTANCE_OFFSET;
@@ -66,41 +68,125 @@ int GetAllContact(vector<Contact> &vec) {
    temp.type = *(DWORD *)(start + 0x50);
    temp.verify_flag = *(DWORD *)(start + 0x54);
    vec.push_back(temp);
-   start += 0x3E8;
+   start += 0x438;
     }
     return success;
 }
-// todo 
+// note maybe  not delete 
 int DelContact(wchar_t *wxid) {
-    int success = 0;
+    int success = -1;
     WeChatString user_id(wxid);
     DWORD id_ptr = (DWORD) &user_id;
     DWORD base = GetWeChatWinBase();
-    DWORD get_instance_addr = base + WX_CONTACT_MGR_INSTANCE_OFFSET;
-    DWORD init_chat_msg_addr = base + WX_INIT_CHAT_MSG_OFFSET;
-    DWORD del_addr = base + WX_CONTACT_DEL_OFFSET;
-    DWORD db_op_addr = base + WX_DB_QUERY_OFFSET;
+    DWORD sync_mgr_addr = base + WX_SYNC_MGR_OFFSET;
+    DWORD set_id_addr = base + WX_SET_VALUE_OFFSET;
+    DWORD del_contact_addr = base + WX_DO_DEL_CONTACT_OFFSET;
+    int len = user_id.length;
+    
+    string id_cstr = unicode_to_utf8(wxid);
+    char id_[0x20]={0};
+    memcpy(id_,id_cstr.c_str(),id_cstr.size()+1);
+    char buff[0x10]={0}; 
     __asm{
         PUSHAD
         PUSHFD
-        CALL       get_instance_addr   
-        MOV        ECX,dword ptr[id_ptr]
-        PUSH       ECX
+        CALL       sync_mgr_addr
         MOV        ECX,EAX
-        MOV        ESI,EAX
-        CALL       db_op_addr                                     
-        SUB        ESP,0x14
-        MOV        EAX,dword ptr[id_ptr]
-        MOV        ECX,ESP
-        PUSH       EAX
-        CALL       init_chat_msg_addr                                     
-        MOV        ECX,ESI
-        CALL       del_addr
-        MOV        success,EAX      
+        LEA        EAX,buff
+        MOV        [ECX + 4],EAX
+        LEA        EAX,id_
+        Mov        dword ptr[buff +0x4],EAX
+        CALL       del_contact_addr 
+        MOV        success,EAX            
         POPFD                 
         POPAD      
     }
     return success;
 }
 
+std::wstring GetContactOrChatRoomNickname(wchar_t *id) {
+    int success = -1;
+    char buff[0x440] = {0};
+    WeChatString pri(id);
+    DWORD base = GetWeChatWinBase();
+    DWORD contact_mgr_addr = base + WX_CONTACT_MGR_INSTANCE_OFFSET;
+    DWORD get_contact_addr = base + WX_GET_CONTACT_OFFSET;
+    DWORD free_contact_addr = base + WX_FREE_CONTACT_OFFSET;
+    wstring name = L"";
+    __asm {
+      PUSHAD
+      PUSHFD
+      CALL       contact_mgr_addr                                   
+      LEA        ECX,buff
+      PUSH       ECX
+      LEA        ECX,pri
+      PUSH       ECX
+      MOV        ECX,EAX
+      CALL       get_contact_addr                            
+      POPFD
+      POPAD
+    }
+    name += READ_WSTRING(buff, 0x6C);
+    __asm {
+      PUSHAD
+      PUSHFD
+      LEA        ECX,buff
+      CALL       free_contact_addr    
+      POPFD
+      POPAD
+    }
+    return name;
+}
 
+
+int AddFriendByWxid(wchar_t *wxid){
+  int success = -1;
+  DWORD base = GetWeChatWinBase();
+  DWORD contact_mgr_addr = base + WX_CONTACT_MGR_INSTANCE_OFFSET;
+  DWORD set_group_addr = base + 0x746E20;
+  DWORD fn2_addr = base + 0x285D968;
+  DWORD fn3_addr = base + 0x6F6050;
+  DWORD fn4_addr = base + 0xED3BE0;
+  DWORD do_verify_user_addr = base + WX_DO_VERIFY_USER_OFFSET;
+
+  DWORD instance =0;
+  WeChatString chat_room(NULL);
+  WeChatString user_id(wxid);
+  __asm{
+    PUSHAD
+    PUSHFD
+    CALL        contact_mgr_addr    
+    SUB         ESP,0x18                                     
+    MOV         dword ptr [instance],EAX                  
+    MOV         ECX,ESP                                    
+    PUSH        ECX                                       
+    LEA         ECX,chat_room                  
+    CALL        set_group_addr 
+    MOV         EAX,fn2_addr                     
+    SUB         ESP,0x18                                     
+    MOV         ECX,ESP                                    
+    PUSH        EAX                                       
+    CALL        fn3_addr                       
+    PUSH        0x0                                         
+    PUSH        0XE                    
+    SUB         ESP,0x14                                     
+    MOV         ESI,ESP                                    
+    MOV         dword ptr [ESI],0x0                       
+    MOV         dword ptr [ESI+0x4],0x0                     
+    MOV         dword ptr [ESI+0x8],0x0                     
+    MOV         dword ptr [ESI+0xC],0x0                     
+    MOV         dword ptr [ESI+0x10],0x0                                      
+    PUSH        0x1                                         
+    SUB         ESP,0x14                                     
+    MOV         ECX,ESP      
+    LEA         EAX,user_id                              
+    PUSH        EAX                   
+    CALL        fn4_addr                        
+    MOV         ECX,dword ptr [instance]                  
+    CALL        do_verify_user_addr            
+    MOV         success,EAX         
+    POPFD
+    POPAD
+  }
+  return success;
+}

src/contact.h

@@ -3,9 +3,13 @@
 #include <vector>
 #include "wechat_data.h"
 
-int GetAllContact(vector<Contact> &vec);
+int GetAllContact(std::vector<Contact> &vec);
 
 
 
 int DelContact(wchar_t* wxid);
+
+std::wstring GetContactOrChatRoomNickname(wchar_t* id);
+
+int AddFriendByWxid(wchar_t *wxid);
 #endif

src/db_operation.cc

@@ -4,7 +4,7 @@
 #include "base64.h"
 #include "common.h"
 #include "new_sqlite3.h"
-
+using namespace std;
 
 /// @brief free data
 void FreeResult(vector<vector<SqlResult>> &data) {
@@ -15,11 +15,11 @@ void FreeResult(vector<vector<SqlResult>> &data) {
     for (unsigned j = 0; j < data[i].size(); j++) {
       SqlResult *sr = (SqlResult *)&data[i][j];
       if (sr->column_name) {
-        delete sr->column_name;
+        delete[] sr->column_name;
         sr->column_name = NULL;
       }
       if (sr->content) {
-        delete sr->content;
+        delete[] sr->content;
         sr->content = NULL;
       }
     }
@@ -97,10 +97,15 @@ int Select(DWORD db_hanle, const char *sql,
   if (status == 0) {
     return 0;
   }
+  if(data.size() == 0){
+    return 1;
+  }
   vector<string> index;
-  for (size_t i = 0; i < data[0].size(); i++)
+  for (size_t i = 0; i < data[0].size(); i++){
     index.push_back(data[0][i].column_name);
+  }
   query_result.push_back(index);
+ 
   for (auto it : data) {
     vector<string> item;
     for (size_t i = 0; i < it.size(); i++) {

src/db_operation.h

@@ -2,7 +2,6 @@
 #define DB_OPERATION_H_
 #include <windows.h>
 #include <vector>
-using namespace std;
 struct SqlResult {
   char *column_name;
   DWORD column_name_len;
@@ -18,6 +17,6 @@ struct SqlResult {
 /// @return 
 int ExecuteSQL(DWORD db, const char *sql, DWORD callback, void *data);
 
-int Select(DWORD db_hanle, const char *sql,vector<vector<string>> &query_result);
+int Select(DWORD db_hanle, const char *sql,std::vector<std::vector<std::string>> &query_result);
 
 #endif

src/dllMain.cc

@@ -16,6 +16,8 @@ BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call,
       break;
     }
     case DLL_PROCESS_DETACH: {
+      CloseConsole();
+      http_close();
       break;
     }
   }

src/forward.cc

@@ -4,8 +4,8 @@
 #include "common.h"
 #include "get_db_handle.h"
 #include "wechat_data.h"
-#define WX_FORWARD_MSG_OFFSET 0xb68c80
-#define WX_INIT_CHAT_MSG_OFFSET 0xdbcc40
+#define WX_FORWARD_MSG_OFFSET 0xc715f0
+#define WX_INIT_CHAT_MSG_OFFSET 0xed3be0
 
 int ForwardMsg(wchar_t *wxid, unsigned long long msgid) {
   int success = 0;
@@ -27,11 +27,11 @@ int ForwardMsg(wchar_t *wxid, unsigned long long msgid) {
     PUSH       EAX
     SUB        ESP,0x14
     MOV        ECX,ESP
-    LEA        ESI, to_user;
+    LEA        ESI,to_user
     PUSH       ESI
     CALL       init_chat_msg_addr                                
     CALL       forward_msg_addr
-    MOVZX      EAX,AL;
+    MOVZX      EAX,AL
     MOV        success,EAX
     ADD        ESP,0x1c
     POPFD

src/get_db_handle.cc

@@ -5,7 +5,7 @@
 #include "new_sqlite3.h"
 #include "pch.h"
 #include "wechat_data.h"
-#define CONTACT_G_PINSTANCE 0x2bee928
+#define CONTACT_G_PINSTANCE_OFFSET 0x2e2d628
 #define DB_MICRO_MSG_OFFSET 0x68
 #define DB_CHAT_MSG_OFFSET 0x1C0
 #define DB_MISC_OFFSET 0x3D8
@@ -15,10 +15,10 @@
 #define DB_FUNCTION_MSG_OFFSET 0x11B0
 #define DB_NAME_OFFSET 0x14
 
-#define PUBLIC_MSG_MGR_OFFSET  0x2c294c0
-#define MULTI_DB_MSG_MGR_OFFSET  0x2c2aff4
-#define FAVORITE_STORAGE_MGR_OFFSET  0x2c2aa14
-#define FTS_FAVORITE_MGR_OFFSET  0x2bef468
+#define PUBLIC_MSG_MGR_OFFSET  0x2e6ce20
+#define MULTI_DB_MSG_MGR_OFFSET  0x2e6ec84
+#define FAVORITE_STORAGE_MGR_OFFSET  0x2e6e630
+#define FTS_FAVORITE_MGR_OFFSET  0x2e2e168
 
 using namespace std;
 map<wstring, DatabaseInfo> dbmap;
@@ -64,7 +64,7 @@ std::vector<void *> GetDbHandles() {
   dbs.clear();
   dbmap.clear();
   DWORD base = GetWeChatWinBase();
-  DWORD p_contact_addr = *(DWORD *)(base + CONTACT_G_PINSTANCE);
+  DWORD p_contact_addr = *(DWORD *)(base + CONTACT_G_PINSTANCE_OFFSET);
   DWORD micro_msg_db_addr = *(DWORD *)(p_contact_addr + DB_MICRO_MSG_OFFSET);
   DWORD chat_msg_db_addr = *(DWORD *)(p_contact_addr + DB_CHAT_MSG_OFFSET);
   DWORD misc_db_addr = *(DWORD *)(p_contact_addr + DB_MISC_OFFSET);
@@ -296,4 +296,23 @@ unsigned int GetLocalIdByMsgId(ULONG64 msgid, int &dbIndex) {
     return stoi(result[1][0]);
   }
   return 0;
+}
+
+vector<string> GetChatMsgByMsgId(ULONG64 msgid){
+  char sql[260] = {0};
+  sprintf_s(sql, "select localId,TalkerId,MsgSvrID,Type,SubType,IsSender,CreateTime,Sequence,StatusEx,FlagEx,Status,MsgServerSeq,MsgSequence,StrTalker,StrContent,BytesExtra from MSG where MsgSvrID=%llu;", msgid);
+  wchar_t dbname[20] = {0};
+  for (int i = 0;; i++) {
+    swprintf_s(dbname, L"MSG%d.db", i);
+    DWORD handle = GetDbHandleByDbName(dbname);
+    if (handle == 0) return {};
+    vector<vector<string>> result;
+    int ret = Select(handle, (const char *)sql, result);
+    #ifdef _DEBUG
+    cout <<" size =" <<result.size()<<endl;
+    #endif
+    if (result.size() == 0) continue;
+    return result[1];
+  }
+  return {};
 }

src/get_db_handle.h

@@ -2,8 +2,10 @@
 #define GET_DB_HANDLE_H_
 #include "windows.h"
 #include <vector>
+#include <string>
 
 std::vector<void *> GetDbHandles();
 DWORD GetDbHandleByDbName(wchar_t *dbname);
 unsigned int GetLocalIdByMsgId(ULONG64 msgid, int &dbIndex);
+std::vector<std::string> GetChatMsgByMsgId(ULONG64 msgid);
 #endif

src/hook_img.cc

@@ -2,13 +2,13 @@
 #include "hook_img.h"
 
 #include "common.h"
-
+using namespace std;
 
 // #define WX_HOOK_IMG_OFFSET 0xd7eaa5
 // #define WX_HOOK_IMG_NEXT_OFFSET 0xda56e0
-#define WX_HOOK_IMG_OFFSET 0xc63ebc
-#define WX_HOOK_IMG_NEXT_OFFSET 0xd7e9e0
-#define WX_SELF_ID_OFFSET 0x2BEE08C
+#define WX_HOOK_IMG_OFFSET 0xd723dc
+#define WX_HOOK_IMG_NEXT_OFFSET 0xe91d90
+#define WX_SELF_ID_OFFSET 0x2E2CD3C
 #define BUFSIZE 1024
 
 #define JPEG0 0xFF

src/hook_img.h

@@ -1,9 +1,8 @@
 #ifndef HOOK_IMG_H_
 #define HOOK_IMG_H_
 #include  "windows.h"
-using namespace std;
 
-int HookImg(wstring save_path);
+int HookImg(std::wstring save_path);
 int UnHookImg();
 
 int GetImgByName(wchar_t* file_path,wchar_t* save_dir);

src/hook_recv_msg.cc

@@ -10,8 +10,10 @@
 using namespace nlohmann;
 
 using namespace std;
-#define WX_RECV_MSG_HOOK_OFFSET 0xb94796
-#define WX_RECV_MSG_HOOK_NEXT_OFFSET 0x6fe2c0
+#define WX_RECV_MSG_HOOK_OFFSET 0xca0284
+#define WX_RECV_MSG_HOOK_NEXT_OFFSET 0x7d5030
+#define WX_SNS_HOOK_OFFSET  0x143ef09
+#define WX_SNS_HOOK_NEXT_OFFSET 0x143f1b0
 
 // SyncMgr::addMsgListToDB
 // #define WX_RECV_MSG_HOOK_OFFSET 0xB9C919
@@ -20,6 +22,7 @@ using namespace std;
 #define CLIENT_IP "127.0.0.1"
 static int kServerPort = 0;
 static int kMessageHooked = FALSE;
+static char kServerIp[16]= "127.0.0.1";
 static DWORD kWeChatWinBase = GetWeChatWinBase();
 
 static char kOriginReceMsgAsmCode[5] = {0};
@@ -28,6 +31,13 @@ static DWORD kReceMsgJmpBackAddress =
 static DWORD kReceMsgNextAddress =
     kWeChatWinBase + WX_RECV_MSG_HOOK_NEXT_OFFSET;
 
+
+static char kOriginSnsMsgAsmCode[5] = {0};
+static DWORD kSnsMsgJmpBackAddress =
+    kWeChatWinBase + WX_SNS_HOOK_OFFSET + 0x5;
+static DWORD kSnsMsgNextAddress =
+    kWeChatWinBase + WX_SNS_HOOK_NEXT_OFFSET;
+
 struct InnerMessageStruct {
   char *buffer;
   int length;
@@ -59,10 +69,12 @@ BOOL SendBySocket(const char *buffer, size_t len) {
   memset(&client_addr, 0, sizeof(client_addr));
   client_addr.sin_family = AF_INET;
   client_addr.sin_port = htons((u_short)kServerPort);
-  InetPtonA(AF_INET, CLIENT_IP, &client_addr.sin_addr.s_addr);
+  InetPtonA(AF_INET, kServerIp, &client_addr.sin_addr.s_addr);
   if (connect(client_socket, reinterpret_cast<sockaddr *>(&client_addr),
               sizeof(sockaddr)) < 0) {
 #ifdef _DEBUG
+    cout << "kServerIp:" << kServerIp <<endl;
+    cout << "port:" << kServerPort <<endl;
     cout << "connect error,"
          << " errno:" << errno << endl;
 #endif
@@ -109,7 +121,7 @@ void SendSocketMessage(InnerMessageStruct *msg) {
 }
 /// @brief msg handle
 /// @param msg_addr msg address in memory
-void OnRecvMsg(DWORD msg_addr) {
+void __cdecl OnRecvMsg(DWORD msg_addr) {
   json j_msg;
   unsigned long long msgid = *(unsigned long long *)(msg_addr + 0x30);
   j_msg["msgId"] = msgid;
@@ -135,9 +147,6 @@ void OnRecvMsg(DWORD msg_addr) {
   if (content_len > 0) {
     j_msg["content"] =
         unicode_to_utf8((wchar_t *)READ_WSTRING(msg_addr, 0x70).c_str());
-#ifdef _DEBUG
-    printf("%s", j_msg["content"].get<std::string>().c_str());
-#endif
   }
   int sign_len = *(DWORD *)(msg_addr + 0x18C);
   if (sign_len > 0) {
@@ -172,6 +181,50 @@ void OnRecvMsg(DWORD msg_addr) {
     CloseHandle(thread);
   }
 }
+
+
+
+ void __cdecl OnSnsTimeLineMsg(DWORD msg_addr) {
+  json j_sns;
+  DWORD begin_addr = *(DWORD *)(msg_addr + 0x20);
+  DWORD end_addr = *(DWORD *)(msg_addr + 0x24);
+   #ifdef _DEBUG
+   cout << "begin" <<begin_addr<<endl;
+   cout << "end" <<end_addr<<endl;
+  #endif
+  if (begin_addr == 0) {
+    j_sns = {{"data", json::array()}};
+  } else {
+    while (begin_addr < end_addr) {
+      json j_item;
+      j_item["snsId"] = *(unsigned long long *)(begin_addr);
+      j_item["createTime"] = *(DWORD *)(begin_addr + 0x2C);
+
+      j_item["senderId"] =
+          unicode_to_utf8((wchar_t *)READ_WSTRING(begin_addr, 0x18).c_str());
+
+      j_item["content"] =
+          unicode_to_utf8((wchar_t *)READ_WSTRING(begin_addr, 0x3c).c_str());
+
+      j_item["xml"] =
+          unicode_to_utf8((wchar_t *)READ_WSTRING(begin_addr, 0x384).c_str());
+
+      j_sns["data"].push_back(j_item);
+      begin_addr += 0xB48;
+    }
+  }
+  string jstr = j_sns.dump() + '\n';
+  InnerMessageStruct *inner_msg = new InnerMessageStruct;
+  inner_msg->buffer = new char[jstr.size() + 1];
+  memcpy(inner_msg->buffer, jstr.c_str(), jstr.size() + 1);
+  inner_msg->length = jstr.size();
+  HANDLE thread = CreateThread(
+      NULL, 0, (LPTHREAD_START_ROUTINE)SendSocketMessage, inner_msg, NULL, 0);
+  if (thread) {
+    CloseHandle(thread);
+  }
+}
+
 /// @brief  hook implement
 _declspec(naked) void handle_sync_msg() {
   __asm {
@@ -187,11 +240,29 @@ _declspec(naked) void handle_sync_msg() {
   }
 }
 
+
+/// @brief  hook sns msg implement
+_declspec(naked) void handle_sns_msg() {
+  __asm {
+    PUSHAD
+		PUSHFD
+    PUSH    [ESP + 0x24]
+		CALL    OnSnsTimeLineMsg
+		ADD     ESP, 0x4
+    POPFD
+		POPAD
+		CALL    kSnsMsgNextAddress
+		JMP     kSnsMsgJmpBackAddress
+  }
+}
+
+
 /// @brief hook any address   address+0x5
 /// @param port 端口
 /// @return 成功返回1,已经hook返回2,失败返回-1
-int HookRecvMsg(int port) {
+int HookRecvMsg(char* client_ip,int port) {
   kServerPort = port;
+  strcpy_s(kServerIp,client_ip);
   kWeChatWinBase = GetWeChatWinBase();
   if (!kWeChatWinBase) {
     return -1;
@@ -206,6 +277,14 @@ int HookRecvMsg(int port) {
   kReceMsgJmpBackAddress = hook_recv_msg_addr + 0x5;
   HookAnyAddress(hook_recv_msg_addr, (LPVOID)handle_sync_msg,
                  kOriginReceMsgAsmCode);
+  
+  DWORD hook_sns_msg_addr = kWeChatWinBase + WX_SNS_HOOK_OFFSET;
+  kSnsMsgNextAddress = kWeChatWinBase + WX_SNS_HOOK_NEXT_OFFSET;
+  kSnsMsgJmpBackAddress = hook_sns_msg_addr + 0x5;
+  HookAnyAddress(hook_sns_msg_addr, (LPVOID)handle_sns_msg,
+                 kOriginSnsMsgAsmCode);
+  
+
   kMessageHooked = TRUE;
   return 1;
 }
@@ -214,7 +293,9 @@ int UnHookRecvMsg() {
   kServerPort = 0;
   if (!kMessageHooked) return 2;
   DWORD hook_recv_msg_addr = kWeChatWinBase + WX_RECV_MSG_HOOK_OFFSET;
+  DWORD hook_sns_addr = kWeChatWinBase + WX_SNS_HOOK_OFFSET;
   UnHookAnyAddress(hook_recv_msg_addr, kOriginReceMsgAsmCode);
+  UnHookAnyAddress(hook_sns_addr, kOriginSnsMsgAsmCode);
   kMessageHooked = FALSE;
   return 1;
 }

src/hook_recv_msg.h

@@ -4,7 +4,7 @@
 /// @brief hook any address   address+0x5
 /// @param port 端口
 /// @return 成功返回1,已经hook返回2
-int  HookRecvMsg(int port);
+int  HookRecvMsg(char* client_ip,int port);
 
 int UnHookRecvMsg();
 #endif

src/new_sqlite3.h

@@ -135,24 +135,24 @@
 #define SQLITE_NULL     5
 #define SQLITE_TEXT     3
 
-#define SQLITE3_EXEC_OFFSET 0x1b623b0
-#define SQLITE3_BACKUP_INIT_OFFSET 0x1b27d50
-#define SQLITE3_PREPARE_OFFSET 0x1b68d00
-#define SQLITE3_OPEN_OFFSET 0x1b96cf0
-#define SQLITE3_BACKUP_STEP_OFFSET 0x1b28150
-#define SQLITE3_BACKUP_REMAINING_OFFSET 0x1b28890
-#define SQLITE3_BACKUP_PAGECOUNT_OFFSET 0x1b288a0
-#define SQLITE3_BACKUP_FINISH_OFFSET 0x1b28790
-#define SQLITE3_SLEEP_OFFSET 0x1b97530
-#define SQLITE3_ERRCODE_OFFSET 0x1b95990
-#define SQLITE3_CLOSE_OFFSET 0x1b94110
-#define SQLITE3_STEP_OFFSET 0x1b30bc0
-#define SQLITE3_COLUMN_COUNT_OFFSET 0x1b310d0
-#define SQLITE3_COLUMN_NAME_OFFSET 0x1b319c0
-#define SQLITE3_COLUMN_TYPE_OFFSET 0x1b31860
-#define SQLITE3_COLUMN_BLOB_OFFSET 0x1b31110
-#define SQLITE3_COLUMN_BYTES_OFFSET 0x1b311f0
-#define SQLITE3_FINALIZE_OFFSET 0x1b2fb90
+#define SQLITE3_EXEC_OFFSET 0x1d5cf70
+#define SQLITE3_BACKUP_INIT_OFFSET 0x1d228d0
+#define SQLITE3_PREPARE_OFFSET 0x1d638c0
+#define SQLITE3_OPEN_OFFSET 0x1d918b0
+#define SQLITE3_BACKUP_STEP_OFFSET 0x1d22ce0
+#define SQLITE3_BACKUP_REMAINING_OFFSET 0x1d23420
+#define SQLITE3_BACKUP_PAGECOUNT_OFFSET 0x1d23430
+#define SQLITE3_BACKUP_FINISH_OFFSET 0x1d23320
+#define SQLITE3_SLEEP_OFFSET 0x1d920f0
+#define SQLITE3_ERRCODE_OFFSET 0x1d90550
+#define SQLITE3_CLOSE_OFFSET 0x1d8ecd0
+#define SQLITE3_STEP_OFFSET 0x1d2b750
+#define SQLITE3_COLUMN_COUNT_OFFSET 0x1d2bc60
+#define SQLITE3_COLUMN_NAME_OFFSET 0x1d2c550
+#define SQLITE3_COLUMN_TYPE_OFFSET 0x1d2c3f0
+#define SQLITE3_COLUMN_BLOB_OFFSET 0x1d2bca0
+#define SQLITE3_COLUMN_BYTES_OFFSET 0x1d2bd80
+#define SQLITE3_FINALIZE_OFFSET 0x1d2a720
 
 typedef int (*Sqlite3_callback)(void*, int, char**, char**);
 

src/ocr.cc

@@ -0,0 +1,64 @@
+#include "pch.h"
+#include "ocr.h"
+
+#include "common.h"
+#include "wechat_data.h"
+
+#define WX_INIT_OBJ_OFFSET 0x7a98f0
+#define WX_OCR_MANAGER_OFFSET 0x7ae470
+#define WX_DO_OCR_TASK_OFFSET 0x13230c0
+using namespace std;
+int DoOCRTask(wchar_t *img_path, std::string &result) {
+  int success = -1;
+  WeChatString path(img_path);
+  WeChatString null_obj = {0};
+  WeChatString ocr_result = {0};
+  DWORD base = GetWeChatWinBase();
+  DWORD ocr_manager_addr = base + WX_OCR_MANAGER_OFFSET;
+  DWORD do_ocr_task_addr = base + WX_DO_OCR_TASK_OFFSET;
+  DWORD init_addr = base + WX_INIT_OBJ_OFFSET;
+  DWORD flag = 0;
+  __asm {
+        PUSHAD
+        PUSHFD
+        LEA        ECX,ocr_result
+        CALL       init_addr
+        CALL       ocr_manager_addr                                  
+        LEA        ECX,null_obj
+        PUSH       ECX
+        LEA        ECX,flag
+        PUSH       ECX
+        LEA        ECX,ocr_result
+        PUSH       ECX
+        PUSH       0x0
+        LEA        ECX,path
+        PUSH       ECX
+        MOV        ECX,EAX
+        CALL       do_ocr_task_addr    
+        MOV        success,EAX  
+        POPFD
+        POPAD
+  }
+
+  if (success == 0) {
+    DWORD addr = (DWORD)&ocr_result;
+    DWORD ptr = *(DWORD *)addr;
+    DWORD num = *(DWORD *)(addr + 0x4);
+    if (num <= 0) {
+      return success;
+    }
+
+    DWORD header = *(DWORD *)ptr;
+    for (unsigned int i = 0; i < num -1; i++) {
+      DWORD content = *(DWORD *)header;
+      result += unicode_to_utf8((wchar_t *)READ_WSTRING(content, 0x14).c_str());
+     
+      header = content;
+    }
+#ifdef _DEBUG
+    cout << "num:" << num << endl;
+    cout << "all:" << result << endl;
+#endif
+  }
+  return success;
+}

src/ocr.h

@@ -0,0 +1,5 @@
+#ifndef OCR_H_
+#define OCR_H_
+#include <string>
+int  DoOCRTask(wchar_t* img_path,std::string &result);
+#endif

src/pat.cc

@@ -0,0 +1,34 @@
+#include "pch.h"
+#include "pat.h"
+
+#include "common.h"
+#include "wechat_data.h"
+
+#define  WX_PAT_MGR_OFFSET  0x8d0c00
+#define  WX_SEND_PAT_MSG_OFFSET  0x1369850
+#define  WX_RET_OFFSET   0x1C94D34
+
+int SendPatMsg(wchar_t* chat_room_id, wchar_t* wxid) {
+  int success = -1;
+  WeChatString chat_room(chat_room_id);
+  WeChatString self_wxid(wxid);
+  DWORD base = GetWeChatWinBase();
+  DWORD get_pat_mgr_addr = base + WX_PAT_MGR_OFFSET;
+  DWORD send_pat_msg_addr = base + WX_SEND_PAT_MSG_OFFSET;
+  DWORD ret_addr = base + WX_RET_OFFSET;
+  __asm {
+    PUSHAD
+    CALL       get_pat_mgr_addr
+    PUSH       ret_addr
+    PUSH       0x0
+    PUSH       EAX
+    LEA        ECX,chat_room
+    LEA        EDX,self_wxid
+    CALL       send_pat_msg_addr                           
+    ADD        ESP,0xc
+    MOVZX      EAX,AL
+    MOV        success,EAX      
+    POPAD
+  }
+  return success;
+}

src/pat.h

@@ -0,0 +1,4 @@
+#ifndef PAT_H_
+#define PAT_H_
+int  SendPatMsg(wchar_t* chat_room_id,wchar_t* wxid);
+#endif

src/search_contact.cc

@@ -0,0 +1,275 @@
+#include "pch.h"
+#include "search_contact.h"
+
+#include "common.h"
+
+#include "wechat_data.h"
+
+#define WX_SEARCH_CONTACT_ERROR_CODE_HOOK_OFFSeT 0xd94d1e
+#define WX_SEARCH_CONTACT_ERROR_CODE_HOOK_NEXT_OFFSeT 0xed13a0
+#define WX_SEARCH_CONTACT_DETAIL_HOOK_OFFSeT 0xa2a260
+#define WX_SEARCH_CONTACT_DETAIL_HOOK_NEXT_OFFSeT 0xa2a4c0
+
+
+#define WX_SEARCH_CONTACT_OFFSeT 0xc5bb00
+#define WX_SEARCH_CONTACT_MGR_OFFSeT 0xa0d550
+
+
+
+static BOOL kSearchContactHooked = false;
+static char kHookSearchContactErrcodeOldAsm[5] = {0};
+static char kHookUserInfoOldAsm[5] = {0};
+static DWORD kWeChatWinBase = GetWeChatWinBase();
+
+static DWORD kHookSearchContactErrcodeNextAddr =
+    kWeChatWinBase + WX_SEARCH_CONTACT_ERROR_CODE_HOOK_NEXT_OFFSeT;
+static DWORD kHookSearchContactErrcodeAddr =
+    kWeChatWinBase + WX_SEARCH_CONTACT_ERROR_CODE_HOOK_OFFSeT;
+static DWORD kHookSearchContactErrcodeJmpBackAddr =
+    kHookSearchContactErrcodeAddr + 0x5;
+
+static DWORD kHookUserInfoNextAddr =
+    kWeChatWinBase + WX_SEARCH_CONTACT_DETAIL_HOOK_NEXT_OFFSeT;
+static DWORD kHookUserInfoAddr =
+    kWeChatWinBase + WX_SEARCH_CONTACT_DETAIL_HOOK_OFFSeT;
+static DWORD kHookUserInfoJmpBackAddr = kHookUserInfoAddr + 0x5;
+
+static UserInfo userinfo;
+
+void SetErrorCode(int code) { userinfo.error_code = code; }
+
+void SetUserInfoDetail(DWORD address) {
+  DWORD length = *(DWORD *)(address + 0x8);
+  userinfo.keyword = new wchar_t[length + 1];
+  userinfo.keyword_len = length;
+  if (length) {
+    memcpy(userinfo.keyword, (wchar_t *)(*(DWORD *)(address + 0x4)),
+           (length + 1) * sizeof(wchar_t));
+  } else {
+    ZeroMemory(userinfo.keyword, (length + 1) * sizeof(wchar_t));
+  }
+
+  length = *(DWORD *)(address + 0x1C);
+  userinfo.v3 = new wchar_t[length + 1];
+  userinfo.v3_len = length;
+  if (length) {
+    memcpy(userinfo.v3, (wchar_t *)(*(DWORD *)(address + 0x18)),
+           (length + 1) * sizeof(wchar_t));
+  }else {
+    ZeroMemory(userinfo.v3, (length + 1) * sizeof(wchar_t));
+  }
+
+  length = *(DWORD *)(address + 0x30);
+  userinfo.big_image = new wchar_t[length + 1];
+  userinfo.big_image_len = length;
+  if (length) {
+    memcpy(userinfo.big_image, (wchar_t *)(*(DWORD *)(address + 0x2C)),
+           (length + 1) * sizeof(wchar_t));
+  } else {
+    ZeroMemory(userinfo.big_image, (length + 1) * sizeof(wchar_t));
+  }
+
+  length = *(DWORD *)(address + 0xC8);
+  userinfo.nickname = new wchar_t[length + 1];
+  userinfo.nickname_len = length;
+  if (length) {
+    memcpy(userinfo.nickname, (wchar_t *)(*(DWORD *)(address + 0xC4)),
+           (length + 1) * sizeof(wchar_t));
+  }else {
+    ZeroMemory(userinfo.nickname, (length + 1) * sizeof(wchar_t));
+  }
+
+  length = *(DWORD *)(address + 0x108);
+  userinfo.v2 = new wchar_t[length + 1];
+  userinfo.v2_len = length;
+  if (length) {
+    memcpy(userinfo.v2, (wchar_t *)(*(DWORD *)(address + 0x104)),
+           (length + 1) * sizeof(wchar_t));
+  }else {
+    ZeroMemory(userinfo.v2, (length + 1) * sizeof(wchar_t));
+  }
+
+  length = *(DWORD *)(address + 0x16C);
+  userinfo.small_image = new wchar_t[length + 1];
+  userinfo.small_image_len = length;
+  if (length) {
+    memcpy(userinfo.small_image, (wchar_t *)(*(DWORD *)(address + 0x168)),
+           (length + 1) * sizeof(wchar_t));
+  }else {
+    ZeroMemory(userinfo.small_image, (length + 1) * sizeof(wchar_t));
+  }
+
+  length = *(DWORD *)(address + 0x1F8);
+  userinfo.signature = new wchar_t[length + 1];
+  userinfo.signature_len = length;
+  if (length) {
+    memcpy(userinfo.signature, (wchar_t *)(*(DWORD *)(address + 0x1F4)),
+           (length + 1) * sizeof(wchar_t));
+  } else {
+    ZeroMemory(userinfo.signature, (length + 1) * sizeof(wchar_t));
+  }
+
+  length = *(DWORD *)(address + 0x20C);
+  userinfo.nation = new wchar_t[length + 1];
+  userinfo.nation_len = length;
+  if (length) {
+    memcpy(userinfo.nation, (wchar_t *)(*(DWORD *)(address + 0x208)),
+           (length + 1) * sizeof(wchar_t));
+  } else {
+    ZeroMemory(userinfo.nation, (length + 1) * sizeof(wchar_t));
+  }
+
+  length = *(DWORD *)(address + 0x220);
+  userinfo.province = new wchar_t[length + 1];
+  userinfo.province_len = length;
+  if (length) {
+    memcpy(userinfo.province, (wchar_t *)(*(DWORD *)(address + 0x21C)),
+           (length + 1) * sizeof(wchar_t));
+  } else {
+    ZeroMemory(userinfo.province, (length + 1) * sizeof(wchar_t));
+  }
+
+  length = *(DWORD *)(address + 0x234);
+  userinfo.city = new wchar_t[length + 1];
+  userinfo.city_len = length;
+  if (length) {
+    memcpy(userinfo.city, (wchar_t *)(*(DWORD *)(address + 0x230)),
+           (length + 1) * sizeof(wchar_t));
+  } else {
+    ZeroMemory(userinfo.city, (length + 1) * sizeof(wchar_t));
+  }
+
+  userinfo.sex = *(DWORD *)(address + 0x1BC);
+  userinfo.over = true;
+}
+
+static void DeleteUserInfoCache() {
+  if (userinfo.keyword) {
+    delete userinfo.keyword;
+  }
+  if (userinfo.v2) {
+    delete userinfo.v2;
+  }
+  if (userinfo.v3) {
+    delete userinfo.v3;
+  }
+  if (userinfo.nickname) {
+    delete userinfo.nickname;
+  }
+  if (userinfo.nation) {
+    delete userinfo.nation;
+  }
+  if (userinfo.province) {
+    delete userinfo.province;
+  }
+  if (userinfo.city) {
+    delete userinfo.city;
+  }
+  if (userinfo.signature) {
+    delete userinfo.signature;
+  }
+  if (userinfo.small_image) {
+    delete userinfo.small_image;
+  }
+  if (userinfo.big_image) {
+    delete userinfo.big_image;
+  }
+  ZeroMemory(&userinfo, sizeof(UserInfo));
+  userinfo.error_code = 1;
+}
+
+__declspec(naked) void HandleErrorCode() {
+  __asm {
+		pushad;
+		pushfd;
+		push edi;
+		call SetErrorCode;
+		add esp, 0x4;
+		popfd;
+		popad;
+		call kHookSearchContactErrcodeNextAddr;
+		jmp kHookSearchContactErrcodeJmpBackAddr;
+  }
+}
+
+__declspec(naked) void HandleUserInfoDetail() {
+  __asm {
+		pushad;
+		pushfd;
+		push dword ptr [ebp + 0x14];
+		call SetUserInfoDetail;
+		add esp, 0x4;
+		popfd;
+		popad;
+		call kHookUserInfoNextAddr;
+		jmp kHookUserInfoJmpBackAddr;
+  }
+}
+
+int SearchContactNetScene(wchar_t *keyword,UserInfo ** user) {
+  int success = -1;
+  HookSearchContact();
+  DeleteUserInfoCache();
+  DWORD base = GetWeChatWinBase();
+  DWORD search_contact_mgr_addr = base + WX_SEARCH_CONTACT_MGR_OFFSeT;
+  DWORD search_contact_addr = base + WX_SEARCH_CONTACT_OFFSeT;
+  WeChatString key(keyword);
+
+  __asm {
+		pushad;
+		pushfd;
+		call search_contact_mgr_addr;
+		lea ebx, key;
+		push ebx;
+		mov ecx, eax;
+		call search_contact_addr;
+		popfd;
+		popad;
+  }
+  success = 1;
+  while (userinfo.error_code == 1 && kSearchContactHooked) {
+    Sleep(20);
+  }
+  if (userinfo.error_code == 0) {
+    while (userinfo.over == false && kSearchContactHooked) {
+      Sleep(20);
+    }
+  }
+  *user= &userinfo;
+  return success;
+}
+
+int HookSearchContact() {
+  kWeChatWinBase = GetWeChatWinBase();
+  if (!kWeChatWinBase) {
+    return -1;
+  }
+  if (kSearchContactHooked) {
+    return 2;
+  }
+  kHookSearchContactErrcodeNextAddr =
+      kWeChatWinBase + WX_SEARCH_CONTACT_ERROR_CODE_HOOK_NEXT_OFFSeT;
+  kHookSearchContactErrcodeAddr =
+      kWeChatWinBase + WX_SEARCH_CONTACT_ERROR_CODE_HOOK_OFFSeT;
+  kHookSearchContactErrcodeJmpBackAddr = kHookSearchContactErrcodeAddr + 0x5;
+
+  kHookUserInfoNextAddr =
+      kWeChatWinBase + WX_SEARCH_CONTACT_DETAIL_HOOK_NEXT_OFFSeT;
+  kHookUserInfoAddr = kWeChatWinBase + WX_SEARCH_CONTACT_DETAIL_HOOK_OFFSeT;
+  kHookUserInfoJmpBackAddr = kHookUserInfoAddr + 0x5;
+  HookAnyAddress(kHookSearchContactErrcodeAddr,
+                 (LPVOID)HandleErrorCode,
+                 kHookSearchContactErrcodeOldAsm);
+  HookAnyAddress(kHookUserInfoAddr, (LPVOID)HandleUserInfoDetail, kHookUserInfoOldAsm);
+  kSearchContactHooked = true;
+  return 1;
+}
+
+int UnHookSearchContact() {
+  if (!kSearchContactHooked) return 2;
+  UnHookAnyAddress(kHookSearchContactErrcodeAddr,
+                   kHookSearchContactErrcodeOldAsm);
+  UnHookAnyAddress(kHookUserInfoAddr, kHookUserInfoOldAsm);
+  kSearchContactHooked = false;
+  return 1;
+}

src/search_contact.h

@@ -0,0 +1,8 @@
+#ifndef SEARCH_CONTACT_H_
+#define SEARCH_CONTACT_H_
+#include "wechat_data.h"
+int SearchContactNetScene(wchar_t *keyword,UserInfo ** user);
+
+int HookSearchContact();
+int UnHookSearchContact();
+#endif

src/self_info.cc

@@ -4,136 +4,220 @@
 #include "common.h"
 
 #include "wechat_data.h"
+using namespace std;
 
-#define WX_SELF_NAME_OFFSET 0x2bee198
-#define WX_SELF_MOBILE_OFFSET 0x2BEE108
-#define WX_SELF_CITY_OFFSET 0x2BEE168
-#define WX_SELF_PROVINCE_OFFSET 0x2BEE150
-#define WX_SELF_COUNTRY_OFFSET 0x2BEE138
-#define WX_SELF_ACCOUNT_OFFSET 0x2BEE0F0
-#define WX_SELF_ID_OFFSET 0x2BEE08C
-#define WX_SELF_SMALL_IMG_OFFSET 0x2BEE34C
-#define WX_SELF_BIG_IMG_OFFSET 0x2BEE364
-#define WX_LOGIN_STATUS_OFFSET 0x2BEE4C0
-#define WX_APP_DATA_ROOT_PATH_OFFSET 0x2c2f478
-#define WX_APP_DATA_SAVE_PATH_OFFSET 0x2C10D04
-#define WX_CURRENT_DATA_PATH_OFFSET 0x2C0EC38
-
-
+#define WX_SELF_NAME_OFFSET 0x2E2CE48
+#define WX_SELF_MOBILE_OFFSET 0x2E2CDB8
+#define WX_SELF_CITY_OFFSET 0x2E2CE18
+#define WX_SELF_PROVINCE_OFFSET 0x2E2CE00
+#define WX_SELF_COUNTRY_OFFSET 0x2E2CDE8
+#define WX_SELF_ACCOUNT_OFFSET 0x2e2d1d0
+#define WX_SELF_ID_OFFSET 0x2E2CD3C
+#define WX_SELF_SMALL_IMG_OFFSET 0x2E2D014
+#define WX_SELF_BIG_IMG_OFFSET 0x2E2CFFC
+#define WX_LOGIN_STATUS_OFFSET 0x2E2D1C0
+#define WX_APP_DATA_ROOT_PATH_OFFSET 0x2E73010
+#define WX_APP_DATA_SAVE_PATH_OFFSET 0x2E52DB0
+#define WX_CURRENT_DATA_PATH_OFFSET 0x2E4F290
 
+#define WX_LOGOUT_OFFSET 0xdd5c90
+#define WX_ACCOUNT_SERVICE_OFFSET 0x707960
+#define WX_GET_APP_DATA_SAVE_PATH_OFFSET 0xeb4b00
+#define WX_GET_CURRENT_DATA_PATH_OFFSET 0xc11140
 int GetSelfInfo(SelfInfoInner &out) {
   DWORD base = GetWeChatWinBase();
-#ifdef _DEBUG
-  cout << "mobile:" << (char *)(base + WX_SELF_MOBILE_OFFSET) << endl;
-  cout << "name:" << (char *)(base + WX_SELF_NAME_OFFSET) << endl;
-  cout << "city:" << (char *)(base + WX_SELF_CITY_OFFSET) << endl;
-  cout << "city:" << (char *)(base + WX_SELF_CITY_OFFSET) << endl;
-  cout << "province:" << (char *)(base + WX_SELF_PROVINCE_OFFSET) << endl;
-  cout << "country:" << (char *)(base + WX_SELF_COUNTRY_OFFSET) << endl;
-  cout << "account:" << (char *)(base + WX_SELF_ACCOUNT_OFFSET) << endl;
-  cout << "wxid:" << (char *)(base + WX_SELF_ID_OFFSET) << endl;
-  cout << "small_img:" << (char *)(base + WX_SELF_SMALL_IMG_OFFSET) << endl;
-  cout << "big_img:" << (char *)(base + WX_SELF_BIG_IMG_OFFSET) << endl;
-#endif
-  if (*(DWORD *)(base + WX_SELF_NAME_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_SELF_NAME_OFFSET + 0x10) == 0) {
-    out.name = string();
-  } else {
-    out.name = string((char *)(base + WX_SELF_NAME_OFFSET),
-                      *(DWORD *)(base + WX_SELF_NAME_OFFSET + 0x10));
+  DWORD accout_service_addr = base + WX_ACCOUNT_SERVICE_OFFSET;
+  DWORD get_app_save_addr = base + WX_GET_APP_DATA_SAVE_PATH_OFFSET;
+  DWORD get_current_data_path_addr = base + WX_GET_CURRENT_DATA_PATH_OFFSET;
+  DWORD service_addr = NULL;
+  __asm {
+      PUSHAD 
+      CALL       accout_service_addr                          
+      MOV        service_addr,EAX
+      POPAD
   }
-  if (*(DWORD *)(base + WX_SELF_MOBILE_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_SELF_MOBILE_OFFSET + 0x10) == 0) {
-    out.mobile = string();
-  } else {
-    out.mobile = string((char *)(base + WX_SELF_MOBILE_OFFSET),
-                       *(DWORD *)(base + WX_SELF_MOBILE_OFFSET + 0x10));
+  if (service_addr) {
+    if (*(DWORD *)(service_addr + 0x44) == 0 ||
+        *(DWORD *)(service_addr + 0x44 + 0x10) == 0) {
+      out.wxid = string();
+    } else {
+      if (*(DWORD *)(service_addr + 0x44 + 0x14) == 0xF) {
+        out.wxid = string((char *)(service_addr + 0x44),
+                          *(DWORD *)(service_addr + 0x44 + 0x10));
+      } else {
+        out.wxid = string(*(char **)(service_addr + 0x44),
+                          *(DWORD *)(service_addr + 0x44 + 0x10));
+      }
+    }
+
+    if (*(DWORD *)(service_addr + 0xA8) == 0 ||
+        *(DWORD *)(service_addr + 0xA8 + 0x10) == 0) {
+      out.account = string();
+    } else {
+      if (*(DWORD *)(service_addr + 0xA8 + 0x14) == 0xF) {
+        out.account = string((char *)(service_addr + 0xA8),
+                             *(DWORD *)(service_addr + 0xA8 + 0x10));
+      } else {
+        out.account = string(*(char **)(service_addr + 0xA8),
+                             *(DWORD *)(service_addr + 0xA8 + 0x10));
+      }
+    }
+
+    if (*(DWORD *)(service_addr + 0xC0) == 0 ||
+        *(DWORD *)(service_addr + 0xC0 + 0x10) == 0) {
+      out.mobile = string();
+    } else {
+      if (*(DWORD *)(service_addr + 0xC0 + 0x14) == 0xF) {
+        out.mobile = string((char *)(service_addr + 0xC0),
+                            *(DWORD *)(service_addr + 0xC0 + 0x10));
+      } else {
+        out.mobile = string(*(char **)(service_addr + 0xC0),
+                            *(DWORD *)(service_addr + 0xC0 + 0x10));
+      }
+    }
+
+    if (*(DWORD *)(service_addr + 0xD8) == 0 ||
+        *(DWORD *)(service_addr + 0xD8 + 0x10) == 0) {
+      out.signature = string();
+    } else {
+      if (*(DWORD *)(service_addr + 0xD8 + 0x14) == 0xF) {
+        out.signature = string((char *)(service_addr + 0xD8),
+                               *(DWORD *)(service_addr + 0xD8 + 0x10));
+      } else {
+        out.signature = string(*(char **)(service_addr + 0xD8),
+                               *(DWORD *)(service_addr + 0xD8 + 0x10));
+      }
+    }
+
+    if (*(DWORD *)(service_addr + 0xF0) == 0 ||
+        *(DWORD *)(service_addr + 0xF0 + 0x10) == 0) {
+      out.country = string();
+    } else {
+      if (*(DWORD *)(service_addr + 0xF0 + 0x14) == 0xF) {
+        out.country = string((char *)(service_addr + 0xF0),
+                             *(DWORD *)(service_addr + 0xF0 + 0x10));
+      } else {
+        out.country = string(*(char **)(service_addr + 0xF0),
+                             *(DWORD *)(service_addr + 0xF0 + 0x10));
+      }
+    }
+
+    if (*(DWORD *)(service_addr + 0x108) == 0 ||
+        *(DWORD *)(service_addr + 0x108 + 0x10) == 0) {
+      out.province = string();
+    } else {
+      if (*(DWORD *)(service_addr + 0x108 + 0x14) == 0xF) {
+        out.province = string((char *)(service_addr + 0x108),
+                              *(DWORD *)(service_addr + 0x108 + 0x10));
+      } else {
+        out.province = string(*(char **)(service_addr + 0x108),
+                              *(DWORD *)(service_addr + 0x108 + 0x10));
+      }
+    }
+
+    if (*(DWORD *)(service_addr + 0x120) == 0 ||
+        *(DWORD *)(service_addr + 0x120 + 0x10) == 0) {
+      out.city = string();
+    } else {
+      if (*(DWORD *)(service_addr + 0x120 + 0x14) == 0xF) {
+        out.city = string((char *)(service_addr + 0x120),
+                          *(DWORD *)(service_addr + 0x120 + 0x10));
+      } else {
+        out.city = string(*(char **)(service_addr + 0x120),
+                          *(DWORD *)(service_addr + 0x120 + 0x10));
+      }
+    }
+
+    if (*(DWORD *)(service_addr + 0x150) == 0 ||
+        *(DWORD *)(service_addr + 0x150 + 0x10) == 0) {
+      out.name = string();
+    } else {
+      if (*(DWORD *)(service_addr + 0x150 + 0x14) == 0xF) {
+        out.name = string((char *)(service_addr + 0x150),
+                          *(DWORD *)(service_addr + 0x150 + 0x10));
+      } else {
+        out.name = string(*(char **)(service_addr + 0x150),
+                          *(DWORD *)(service_addr + 0x150 + 0x10));
+      }
+    }
+
+    if (*(DWORD *)(service_addr + 0x304) == 0 ||
+        *(DWORD *)(service_addr + 0x304 + 0x10) == 0) {
+      out.head_img = string();
+    } else {
+      if (*(DWORD *)(service_addr + 0x304 + 0x14) == 0xF) {
+        out.head_img = string((char *)(service_addr + 0x304),
+                              *(DWORD *)(service_addr + 0x304 + 0x10));
+      } else {
+        out.head_img = string(*(char **)(service_addr + 0x304),
+                              *(DWORD *)(service_addr + 0x304 + 0x10));
+      }
+    }
   }
 
-  if (*(DWORD *)(base + WX_SELF_CITY_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_SELF_CITY_OFFSET + 0x10) == 0) {
-    out.city = string();
-  } else {
-    out.city = string((char *)(base + WX_SELF_CITY_OFFSET),
-                      *(DWORD *)(base + WX_SELF_CITY_OFFSET + 0x10));
+  WeChatString data_save_path;
+  WeChatString current_data_path;
+
+  __asm {
+      PUSHAD
+      LEA     ECX,data_save_path
+      CALL    get_app_save_addr
+      LEA     ECX,current_data_path
+      CALL    get_current_data_path_addr
+      POPAD
   }
 
-  if (*(DWORD *)(base + WX_SELF_PROVINCE_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_SELF_PROVINCE_OFFSET + 0x10) == 0) {
-    out.province = string();
-  } else {
-    out.province = string((char *)(base + WX_SELF_PROVINCE_OFFSET),
-                          *(DWORD *)(base + WX_SELF_PROVINCE_OFFSET + 0x10));
+  if (data_save_path.ptr) {
+    out.data_save_path =
+        Wstring2String(wstring(data_save_path.ptr, data_save_path.length));
   }
-
-  if (*(DWORD *)(base + WX_SELF_COUNTRY_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_SELF_COUNTRY_OFFSET + 0x10) == 0) {
-    out.country = string();
-  } else {
-    out.country = string((char *)(base + WX_SELF_COUNTRY_OFFSET),
-                         *(DWORD *)(base + WX_SELF_COUNTRY_OFFSET + 0x10));
-  }
-
-  if (*(DWORD *)(base + WX_SELF_ACCOUNT_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_SELF_ACCOUNT_OFFSET + 0x10) == 0) {
-    out.account = string();
-  } else {
-    out.account = string(*(char **)(base + WX_SELF_ACCOUNT_OFFSET),
-                         *(DWORD *)(base + WX_SELF_ACCOUNT_OFFSET + 0x10));
-  }
-
-  if (*(DWORD *)(base + WX_SELF_ID_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_SELF_ID_OFFSET + 0x10) == 0) {
-    out.wxid = string();
-  } else {
-    out.wxid = string(*(char **)(base + WX_SELF_ID_OFFSET),
-                      *(DWORD *)(base + WX_SELF_ID_OFFSET + 0x10));
-  }
-
-  if (*(DWORD *)(base + WX_SELF_SMALL_IMG_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_SELF_SMALL_IMG_OFFSET + 0x10) == 0) {
-    out.small_img = string();
-  } else {
-    out.small_img = string(*(char **)(base + WX_SELF_SMALL_IMG_OFFSET),
-                           *(DWORD *)(base + WX_SELF_SMALL_IMG_OFFSET + 0x10));
-  }
-
-  if (*(DWORD *)(base + WX_SELF_BIG_IMG_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_SELF_BIG_IMG_OFFSET + 0x10) == 0) {
-    out.big_img = string();
-  } else {
-    out.big_img = string(*(char **)(base + WX_SELF_BIG_IMG_OFFSET),
-                         *(DWORD *)(base + WX_SELF_BIG_IMG_OFFSET + 0x10));
-  }
-
-  if (*(DWORD *)(base + WX_APP_DATA_ROOT_PATH_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_APP_DATA_ROOT_PATH_OFFSET + 0x4) == 0) {
-    out.data_root_path = string();
-  } else {
-    out.data_root_path = Wstring2String(wstring(*(wchar_t **)(base + WX_APP_DATA_ROOT_PATH_OFFSET),
-                         *(DWORD *)(base + WX_APP_DATA_ROOT_PATH_OFFSET + 0x4)));
-  }
-
-  if (*(DWORD *)(base + WX_APP_DATA_SAVE_PATH_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_APP_DATA_SAVE_PATH_OFFSET + 0x4) == 0) {
+  else {
     out.data_save_path = string();
-  } else {
-    out.data_save_path = Wstring2String(wstring(*(wchar_t **)(base + WX_APP_DATA_SAVE_PATH_OFFSET),
-                         *(DWORD *)(base + WX_APP_DATA_SAVE_PATH_OFFSET + 0x4)));
-  }
-  if (*(DWORD *)(base + WX_CURRENT_DATA_PATH_OFFSET) == 0 ||
-      *(DWORD *)(base + WX_CURRENT_DATA_PATH_OFFSET + 0x4) == 0) {
-    out.current_data_path = string();
-  } else {
-    out.current_data_path = Wstring2String(wstring(*(wchar_t **)(base + WX_CURRENT_DATA_PATH_OFFSET),
-                         *(DWORD *)(base + WX_CURRENT_DATA_PATH_OFFSET + 0x4)));
   }
 
+  if (current_data_path.ptr) {
+    out.current_data_path = Wstring2String(
+        wstring(current_data_path.ptr, current_data_path.length));
+  } else {
+    out.current_data_path = string();
+  }
   return 1;
 }
 
-
-int CheckLogin(){
+int CheckLogin() {
   DWORD base = GetWeChatWinBase();
-  return *(DWORD*) (base + WX_LOGIN_STATUS_OFFSET);
+  DWORD accout_service_addr = base + WX_ACCOUNT_SERVICE_OFFSET;
+  DWORD service_addr = NULL;
+  __asm {
+      PUSHAD 
+      CALL       accout_service_addr                          
+      MOV        service_addr,EAX
+      POPAD
+  }
+  if (service_addr) {
+    return *(DWORD *)(service_addr + 0x4C8);
+  }
+  else {
+    return 0;
+  }
+}
+
+int Logout() {
+  int success = 0;
+  if (!CheckLogin()) {
+    return success;
+  }
+  DWORD base = GetWeChatWinBase();
+  DWORD account_service_addr = base + WX_ACCOUNT_SERVICE_OFFSET;
+  DWORD logout_addr = base + WX_LOGOUT_OFFSET;
+  __asm {
+    PUSHAD
+    CALL       account_service_addr                              
+    PUSH       0x0
+    MOV        ECX,EAX
+    CALL       logout_addr 
+    MOV        success,EAX                         
+    POPAD
+  }
+  return success;
 }

src/self_info.h

@@ -4,4 +4,6 @@
 int GetSelfInfo(SelfInfoInner& out);
 
 int CheckLogin();
+
+int Logout();
 #endif

src/send_file.cc

@@ -3,16 +3,16 @@
 #include "common.h"
 #include "wechat_data.h"
 
-#define WX_APP_MSG_MGR_OFFSET   0x665f60
-#define WX_SEND_FILE_OFFSET     0xa0ce20
-#define WX_INIT_CHAT_MSG_OFFSET 0xdbcc40
-#define WX_FREE_CHAT_MSG_OFFSET 0x651c40
+#define WX_APP_MSG_MGR_OFFSET   0x709bb0
+#define WX_SEND_FILE_OFFSET     0xb06240
+#define WX_INIT_CHAT_MSG_OFFSET 0xed3be0
+#define WX_FREE_CHAT_MSG_OFFSET 0x6f4ea0
 
 int  SendFile(wchar_t *wxid, wchar_t *file_path){
   int success = 0;
   WeChatString to_user(wxid);
   WeChatString path(file_path);
-  char chat_msg[0x2A8] = {0};
+  char chat_msg[0x2C4] = {0};
   DWORD base = GetWeChatWinBase();
   DWORD app_msg_mgr_addr = base + WX_APP_MSG_MGR_OFFSET;
   DWORD init_chat_msg_addr = base + WX_INIT_CHAT_MSG_OFFSET;

src/send_image.cc

@@ -3,17 +3,17 @@
 #include "common.h"
 #include "wechat_data.h"
 
-#define WX_SEND_IMAGE_OFFSET  0xb68b90
-#define WX_SEND_MESSAGE_MGR_OFFSET 0x663320
-#define WX_INIT_CHAT_MSG_OFFSET  0xdbcc40
-#define WX_FREE_CHAT_MSG_OFFSET 0x651c40
+#define WX_SEND_IMAGE_OFFSET  0xc71500
+#define WX_SEND_MESSAGE_MGR_OFFSET 0x706d30
+#define WX_INIT_CHAT_MSG_OFFSET  0xed3be0
+#define WX_FREE_CHAT_MSG_OFFSET 0x6f4ea0
 
 int SendImage(wchar_t *wxid, wchar_t *image_path){
 
   int success = 0;
   WeChatString to_user(wxid);
   WeChatString path(image_path);
-  char chat_msg[0x2A8] ={0};
+  char chat_msg[0x2C4] ={0};
   DWORD base = GetWeChatWinBase();
   DWORD send_message_mgr_addr = base + WX_SEND_MESSAGE_MGR_OFFSET;
   DWORD init_chat_msg_addr = base + WX_INIT_CHAT_MSG_OFFSET;

src/send_text.cc

@@ -5,40 +5,43 @@
 #include "common.h"
 #include "wechat_data.h"
 
-#define WX_SEND_TEXT_OFFSET 0xb690a0
+#define WX_SEND_TEXT_OFFSET 0xc71a60
 
-#define WX_SEND_MESSAGE_MGR_OFFSET 0x663320
+#define WX_SEND_MESSAGE_MGR_OFFSET 0x706d30
 
-#define WX_FREE_CHAT_MSG_OFFSET 0x651c40
+#define WX_FREE_CHAT_MSG_OFFSET 0x6f4ea0
 /// @brief 发生文本消息
 /// @param wxid wxid
 /// @param msg  文本消息
 /// @return  成功返回1
-int SendText(wchar_t* wxid, wchar_t* msg) {
+int  SendText(wchar_t* wxid, wchar_t* msg) {
   int success = 0;
   WeChatString to_user(wxid);
   WeChatString text_msg(msg);
   wchar_t **msg_pptr = &text_msg.ptr;
-  char chat_msg[0x2A8] ={0};
+  
   DWORD base = GetWeChatWinBase();
   DWORD send_message_mgr_addr = base + WX_SEND_MESSAGE_MGR_OFFSET;
   DWORD send_text_msg_addr = base + WX_SEND_TEXT_OFFSET;
-  DWORD free_msg_addr = base + WX_FREE_CHAT_MSG_OFFSET;
+  DWORD free_chat_msg_addr = base + WX_FREE_CHAT_MSG_OFFSET;
+  char chat_msg[0x2C4] ={0};
   __asm{
       PUSHAD
+      CALL       send_message_mgr_addr
+      PUSH       0x0
       PUSH       0x0
       PUSH       0x0
       PUSH       0x1
       PUSH       0x0
-      MOV        EDI,msg_pptr
-      PUSH       EDI
+      MOV        EAX,msg_pptr
+      PUSH       EAX
       LEA        EDX,to_user
       LEA        ECX,chat_msg
-      CALL       send_text_msg_addr               
-      ADD        ESP,0x14
+      CALL       send_text_msg_addr 
       MOV        success,EAX
-      LEA        ECX,chat_msg
-      CALL       free_msg_addr
+      ADD        ESP,0x18
+      LEA        ECX,chat_msg        
+      CALL       free_chat_msg_addr
       POPAD
   }
   return success;

src/sns.cc

@@ -0,0 +1,55 @@
+#include "pch.h"
+#include "sns.h"
+
+#include "common.h"
+#include "wechat_data.h"
+using namespace std;
+#define WX_SNS_DATA_MGR_OFFSET 0xbc4100
+#define WX_SNS_GET_FIRST_PAGE_OFFSET 0x1427be0
+#define WX_SNS_GET_NEXT_PAGE_OFFSET  0x1427c80
+
+int GetFirstPage() {
+  int success = -1;
+  DWORD base = GetWeChatWinBase();
+  DWORD sns_data_mgr_addr = base + WX_SNS_DATA_MGR_OFFSET;
+  DWORD get_first_page_addr = base + WX_SNS_GET_FIRST_PAGE_OFFSET;
+
+  char buff[0xB44] = {};
+  __asm {
+    PUSHAD
+    CALL       sns_data_mgr_addr                                 
+    PUSH       0x1
+    LEA        ECX,buff
+    PUSH       ECX
+    MOV        ECX,EAX
+    CALL       get_first_page_addr   
+    MOV        success,EAX
+    POPAD
+  }
+
+  return success;
+}
+
+
+int GetNextPage(ULONG64 sns_id) {
+  int success = -1;
+  DWORD base = GetWeChatWinBase();
+  DWORD sns_data_mgr_addr = base + WX_SNS_DATA_MGR_OFFSET;
+  DWORD get_next_page_addr = base + WX_SNS_GET_NEXT_PAGE_OFFSET;
+  VectorInner temp = {};
+  __asm{
+    PUSHAD
+    CALL       sns_data_mgr_addr                                    
+    LEA        ECX,temp
+    PUSH       ECX
+    MOV        EBX,dword ptr [sns_id + 0x4]
+    PUSH       EBX
+    MOV        EDI,dword ptr [sns_id ]
+    PUSH       EDI
+    MOV        ECX,EAX
+    CALL       get_next_page_addr
+    MOV        success,EAX
+    POPAD
+  }
+  return success;
+}

src/sns.h

@@ -0,0 +1,6 @@
+#ifndef SNS_H_
+#define SNS_H_
+
+int GetFirstPage();
+int GetNextPage(ULONG64 sns_id);
+#endif

src/wechat_data.h

@@ -4,7 +4,6 @@
 // #include <windows.h>
 
 #include <vector>
-using namespace std;
 struct WeChatString {
   wchar_t *ptr;
   DWORD length;
@@ -13,7 +12,7 @@ struct WeChatString {
   DWORD c_len = 0;
   WeChatString() { WeChatString(NULL); }
 
-  WeChatString(wstring &s) {
+  WeChatString(std::wstring &s) {
     ptr = (wchar_t *)(s.c_str());
     length = s.length();
     max_length = s.length() * 2;
@@ -51,7 +50,7 @@ struct DatabaseInfo {
   DWORD handle = 0;
   wchar_t *db_name = NULL;
   DWORD db_name_len = 0;
-  vector<TableInfo> tables;
+  std::vector<TableInfo> tables;
   DWORD count = 0;
   DWORD extrainfo = 0;
 };
@@ -101,6 +100,25 @@ struct ChatRoomInfoInner {
   WeChatString notice;
   WeChatString admin;
   WeChatString xml;
+
+  ~ChatRoomInfoInner(){
+      if(chat_room_id.ptr){
+        delete []chat_room_id.ptr;
+        chat_room_id.ptr = nullptr;
+      }
+      if(notice.ptr){
+        delete []notice.ptr;
+        notice.ptr = nullptr;
+      }
+      if(admin.ptr){
+        delete []admin.ptr;
+        admin.ptr = nullptr;
+      }
+      if(xml.ptr){
+        delete []xml.ptr;
+        xml.ptr = nullptr;
+      }
+  }
 };
 
 struct VectorInner {
@@ -124,17 +142,42 @@ struct ChatRoomInner{
 };
 
 struct SelfInfoInner{
-  string name;
-  string city;
-  string province;
-  string country;
-  string account;
-  string wxid;
-  string mobile;
-  string  small_img;
-  string big_img;
-  string data_root_path;
-  string data_save_path;
-  string current_data_path;
+  std::string name;
+  std::string city;
+  std::string province;
+  std::string country;
+  std::string account;
+  std::string wxid;
+  std::string mobile;
+  std::string head_img;
+  std::string data_save_path;
+  std::string signature;
+  std::string current_data_path;
+};
+
+struct UserInfo {
+  int error_code;
+  wchar_t *keyword;
+  int keyword_len;
+  wchar_t *v3;
+  int v3_len;
+  wchar_t *nickname;
+  int nickname_len;
+  wchar_t *signature;
+  int signature_len;
+  wchar_t *v2;
+  int v2_len;
+  wchar_t *nation;
+  int nation_len;
+  wchar_t *province;
+  int province_len;
+  wchar_t *city;
+  int city_len;
+  wchar_t *big_image;
+  int big_image_len;
+  wchar_t *small_image;
+  int small_image_len;
+  DWORD sex;
+  BOOL over;
 };
 #endif