Merge pull request #5 from yuzifu/master

Update partial offset for 3.9.11.25

README.md

@@ -1 +1,143 @@
-https://github.com/ttttupup/wxhelper  重编译版
+https://github.com/ttttupup/wxhelper  VS2022重编译版
+
+
+```c++
+注入:
+injector.exe -p pid -i wxhelper.dll
+或
+injector.exe -n wechat.exe -i wxhelper.dll
+
+验证端口:
+netstat -ano | findstr 19088
+```
+```c++
+#define V_3_9_8_25 39825  
+#define V_3_9_9_43 39943  
+#define V_3_9_10_19 391019  
+#define V_3_9_11_19 391119  
+#define V_3_9_11_25 391125
+```
+WECHAT_VERSION=391125   
+![image](https://github.com/laomms/wxhelper/blob/master/version.png)     
+偏移自己查找修改      
+
+```c++
+const uint64_t kGetAccountServiceMgr = 0x1B557D0;
+const uint64_t kSyncMsg = 0xc39680;
+const uint64_t kSyncMsgNext = 0xc39680;
+const uint64_t kGetCurrentDataPath = 0x224D830;
+const uint64_t kGetAppDataSavePath = 0x25E1040;
+const uint64_t kGetSendMessageMgr = 0x1B53FD0;
+const uint64_t kSendTextMsg = 0x22C6B60;
+const uint64_t kFreeChatMsg = 0x1B55850;
+
+const uint64_t kDoAddMsg = 0x230EF30;
+const uint64_t kSendImageMsg = 0x22BC2F0;
+const uint64_t kChatMsgInstanceCounter = 0x1B5E140;
+const uint64_t kSendFileMsg = 0x20D0230;
+const uint64_t kGetAppMsgMgr = 0x1B58F70;
+const uint64_t kGetContactMgr = 0x1B417A0;
+const uint64_t kGetContactList = 0x219ED10;
+
+const uint64_t k_sqlite3_exec = 0x3a5eda0;
+const uint64_t k_sqlite3_prepare = 0x3a66a80;
+const uint64_t k_sqlite3_open = 0x3a235c0;
+const uint64_t k_sqlite3_step = 0x3a22da0;
+const uint64_t k_sqlite3_column_count = 0x3a235c0;
+const uint64_t k_sqlite3_column_name = 0x3a23fc0;
+const uint64_t k_sqlite3_column_type = 0x3a23e10;
+const uint64_t k_sqlite3_column_blob = 0x3a235f0;
+const uint64_t k_sqlite3_column_bytes = 0x3a236e0;
+const uint64_t k_sqlite3_finalize = 0x3a21e50;
+
+const uint64_t kGPInstance = 0x58dd300;
+const uint64_t kMultiDBMgr = 0x593abf8;
+const uint64_t kPublicMsgMgr = 0x5938198;
+const uint64_t kFavoriteStorageMgr = 0x593b790;
+const uint64_t kHardLinkMgr = 0x593ab28;
+
+const uint64_t kChatRoomMgr = 0x1B876C0;
+const uint64_t kGetChatRoomDetailInfo = 0x2160bb0;
+const uint64_t kNewChatRoomInfo = 0x2509CD0;
+const uint64_t kFreeChatRoomInfo = 0x2509EB0;
+const uint64_t kDoAddMemberToChatRoom = 0x21505b0;
+const uint64_t kDoModChatRoomMemberNickName = 0x215EEB0;
+const uint64_t kDelMemberFromChatRoom = 0x2150bf0;
+const uint64_t kGetMemberFromChatRoom = 0x2162400;
+const uint64_t kNewChatRoom = 0x2502540;
+const uint64_t kFreeChatRoom = 0x2502740;
+
+const uint64_t kTopMsg = 0x1d7d160;
+const uint64_t kRemoveTopMsg = 0x2166090;
+const uint64_t kInviteMember = 0x214ff90;
+const uint64_t kHookLog = 0x1304e60;
+
+const uint64_t kCreateChatRoom = 0x214fc60;
+const uint64_t kQuitChatRoom = 0x215ac00;
+const uint64_t kForwardMsg = 0x22c1590;
+
+const uint64_t kOnSnsTimeLineSceneFinish = 0x1a73150;
+const uint64_t kSNSGetFirstPage = 0x2e1bec0;
+const uint64_t kSNSGetNextPageScene = 0x2e41a70;
+const uint64_t kSNSDataMgr = 0x21dd6b0;
+const uint64_t kSNSTimeLineMgr = 0x2dadf20;
+const uint64_t kGetMgrByPrefixLocalId = 0x213afb0;
+const uint64_t kAddFavFromMsg = 0x2930e40;
+const uint64_t kGetChatMgr = 0x1b82bf0;
+const uint64_t kGetFavoriteMgr = 0x1B5C670;
+const uint64_t kAddFavFromImage = 0x293d0f0;
+const uint64_t kGetContact = 0x21945d0;
+const uint64_t kNewContact = 0x2519300;
+const uint64_t kFreeContact = 0x25199b0;
+const uint64_t kNewMMReaderItem = 0x8c79a0;
+const uint64_t kFreeMMReaderItem = 0x8c6da0;
+const uint64_t kForwordPublicMsg = 0xddc6c0;
+const uint64_t kParseAppMsgXml = 0x11b0a70;
+const uint64_t kNewAppMsgInfo = 0x91a550;
+const uint64_t kFreeAppMsgInfo = 0x8fd1a0;
+const uint64_t kGetPreDownLoadMgr = 0x1c0a3a0;
+const uint64_t kPushAttachTask = 0x1cda920;
+const uint64_t kGetCustomSmileyMgr = 0x1ca0320;
+const uint64_t kSendCustomEmotion = 0x21b04c0;
+const uint64_t kNewJsApiShareAppMessage = 0x26cda20;
+const uint64_t kInitJsConfig = 0x137bc00;
+const uint64_t kSendApplet = 0x13c0920;
+const uint64_t kSendAppletSecond = 0x13c1150;
+const uint64_t kGetAppInfoByWaid = 0x13c5790;
+const uint64_t kCopyShareAppMessageRequest = 0x13c0670;
+const uint64_t kNewWAUpdatableMsgInfo = 0x1BD27E0;
+const uint64_t kFreeWAUpdatableMsgInfo = 0x1B97590;
+const uint64_t kSendPatMsg = 0xB2BB00;
+const uint64_t kGetOCRManager = 0x999780;
+const uint64_t kDoOCRTask = 0x2c53910;
+
+const uint64_t kGetLockWechatMgr = 0x1c85010;
+const uint64_t kRequestLockWechat = 0x1c397d0;
+const uint64_t kRequestUnLockWechat = 0x1c39a70;
+
+const uint64_t kOnLoginBtnClick = 0x202bc30;
+
+const uint64_t kGetQRCodeLoginMgr = 0x201e350;
+
+const uint64_t kUpdateMsg = 0x21421a0;
+const uint64_t kGetVoiceMgr = 0x1e13320;
+const uint64_t kChatMsg2NetSceneSendMsg = 0x1b70fd0;
+const uint64_t kTranslateVoice = 0x2353d50;
+const uint64_t kNewWebViewPageConfig = 0x1b53ae0;
+const uint64_t kFreeWebViewPageConfig = 0x1b53d10;
+const uint64_t kGetWebViewMgr = 0x1b43950;
+const uint64_t kShowWebView = 0x302ed30;
+const uint64_t kSetUrl = 0x13dd410;
+
+const uint64_t kNewPayInfo = 0x1bcd930;
+const uint64_t kFreePayInfo = 0x1b92450;
+const uint64_t kTransferConfirm = 0x2f8c750;
+const uint64_t kTransferRefuse = 0x2f8d340;
+
+const uint64_t kAddFriend = 0x1f3a350;
+const uint64_t kVerifyApply = 0x1B3BBE0;
+const uint64_t kDoDelContact = 0x2310120;
+
+const uint64_t kGetSearchContactMgr = 0x1f9a730;
+const uint64_t kStartSearch = 0x22a4200;
+```

inc/Detours/detver.h

@@ -0,0 +1,27 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Common version parameters.
+//
+//  Microsoft Research Detours Package, Version 4.0.1
+//
+//  Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+
+#define _USING_V110_SDK71_ 1
+#include "winver.h"
+#if 0
+#include <windows.h>
+#include <detours.h>
+#else
+#ifndef DETOURS_STRINGIFY
+#define DETOURS_STRINGIFY_(x)    #x
+#define DETOURS_STRINGIFY(x)    DETOURS_STRINGIFY_(x)
+#endif
+
+#define VER_FILEFLAGSMASK   0x3fL
+#define VER_FILEFLAGS       0x0L
+#define VER_FILEOS          0x00040004L
+#define VER_FILETYPE        0x00000002L
+#define VER_FILESUBTYPE     0x00000000L
+#endif
+#define VER_DETOURS_BITS    DETOURS_STRINGIFY(DETOURS_BITS)

inc/chat_controller.h

@@ -20,7 +20,6 @@ class ChatController : public http::HttpController<ChatController> {
   ADD_PATH("/api/forwardMsg", ForwardMsg);
   ADD_PATH("/api/forwardPublicMsgByMsgId", ForwardPublicMsgByMsgId);
   ADD_PATH("/api/forwardPublicMsg", ForwardPublicMsg);
-
   PATHS_END
 
  public:

inc/http_router.h

@@ -1,9 +1,9 @@
 #ifndef WXHELPER_HTTP_ROUTER_H_
 #define WXHELPER_HTTP_ROUTER_H_
 #include <functional>
-#include <map>
-#include <string>
 #include <unordered_map>
+#include <string>
+
 #include "singleton.h"
 
 namespace http {

inc/include/utils.h

@@ -7,6 +7,13 @@
 namespace base {
 
 namespace utils {
+
+#define STRINGIFY(S) #S
+#define DEFER_STRINGIFY(S) STRINGIFY(S)
+#define PRAGMA_MESSAGE(MSG) _Pragma(STRINGIFY(message(MSG)))
+#define FORMATTED_MESSAGE(MSG) "warning [TODO-" DEFER_STRINGIFY(__COUNTER__) "] " MSG " : "  __FILE__ "(" DEFER_STRINGIFY(__LINE__)  ")"
+#define TODO(MSG)  PRAGMA_MESSAGE(FORMATTED_MESSAGE(MSG))
+
 std::wstring Utf8ToWstring(const std::string &str);
 
 std::string WstringToUtf8(const std::wstring &str);

inc/lz4/lz4.h

@@ -0,0 +1,862 @@
+/*
+ *  LZ4 - Fast LZ compression algorithm
+ *  Header File
+ *  Copyright (C) 2011-2020, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+    - LZ4 homepage : http://www.lz4.org
+    - LZ4 source repository : https://github.com/lz4/lz4
+*/
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#ifndef LZ4_H_2983827168210
+#define LZ4_H_2983827168210
+
+    /* --- Dependency --- */
+#include <stddef.h>   /* size_t */
+
+
+/**
+  Introduction
+
+  LZ4 is lossless compression algorithm, providing compression speed >500 MB/s per core,
+  scalable with multi-cores CPU. It features an extremely fast decoder, with speed in
+  multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
+
+  The LZ4 compression library provides in-memory compression and decompression functions.
+  It gives full buffer control to user.
+  Compression can be done in:
+    - a single step (described as Simple Functions)
+    - a single step, reusing a context (described in Advanced Functions)
+    - unbounded multiple steps (described as Streaming compression)
+
+  lz4.h generates and decodes LZ4-compressed blocks (doc/lz4_Block_format.md).
+  Decompressing such a compressed block requires additional metadata.
+  Exact metadata depends on exact decompression function.
+  For the typical case of LZ4_decompress_safe(),
+  metadata includes block's compressed size, and maximum bound of decompressed size.
+  Each application is free to encode and pass such metadata in whichever way it wants.
+
+  lz4.h only handle blocks, it can not generate Frames.
+
+  Blocks are different from Frames (doc/lz4_Frame_format.md).
+  Frames bundle both blocks and metadata in a specified manner.
+  Embedding metadata is required for compressed data to be self-contained and portable.
+  Frame format is delivered through a companion API, declared in lz4frame.h.
+  The `lz4` CLI can only manage frames.
+*/
+
+/*^***************************************************************
+*  Export parameters
+*****************************************************************/
+/*
+*  LZ4_DLL_EXPORT :
+*  Enable exporting of functions when building a Windows DLL
+*  LZ4LIB_VISIBILITY :
+*  Control library symbols visibility.
+*/
+#ifndef LZ4LIB_VISIBILITY
+#  if defined(__GNUC__) && (__GNUC__ >= 4)
+#    define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default")))
+#  else
+#    define LZ4LIB_VISIBILITY
+#  endif
+#endif
+#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
+#  define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY
+#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
+#  define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define LZ4LIB_API LZ4LIB_VISIBILITY
+#endif
+
+/*! LZ4_FREESTANDING :
+ *  When this macro is set to 1, it enables "freestanding mode" that is
+ *  suitable for typical freestanding environment which doesn't support
+ *  standard C library.
+ *
+ *  - LZ4_FREESTANDING is a compile-time switch.
+ *  - It requires the following macros to be defined:
+ *    LZ4_memcpy, LZ4_memmove, LZ4_memset.
+ *  - It only enables LZ4/HC functions which don't use heap.
+ *    All LZ4F_* functions are not supported.
+ *  - See tests/freestanding.c to check its basic setup.
+ */
+#if defined(LZ4_FREESTANDING) && (LZ4_FREESTANDING == 1)
+#  define LZ4_HEAPMODE 0
+#  define LZ4HC_HEAPMODE 0
+#  define LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION 1
+#  if !defined(LZ4_memcpy)
+#    error "LZ4_FREESTANDING requires macro 'LZ4_memcpy'."
+#  endif
+#  if !defined(LZ4_memset)
+#    error "LZ4_FREESTANDING requires macro 'LZ4_memset'."
+#  endif
+#  if !defined(LZ4_memmove)
+#    error "LZ4_FREESTANDING requires macro 'LZ4_memmove'."
+#  endif
+#elif ! defined(LZ4_FREESTANDING)
+#  define LZ4_FREESTANDING 0
+#endif
+
+
+ /*------   Version   ------*/
+#define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
+#define LZ4_VERSION_MINOR    9    /* for new (non-breaking) interface capabilities */
+#define LZ4_VERSION_RELEASE  4    /* for tweaks, bug-fixes, or development */
+
+#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
+
+#define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE
+#define LZ4_QUOTE(str) #str
+#define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
+#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)  /* requires v1.7.3+ */
+
+    LZ4LIB_API int LZ4_versionNumber(void);  /**< library version number; useful to check dll version; requires v1.3.0+ */
+    LZ4LIB_API const char* LZ4_versionString(void);   /**< library version string; useful to check dll version; requires v1.7.5+ */
+
+
+    /*-************************************
+    *  Tuning parameter
+    **************************************/
+#define LZ4_MEMORY_USAGE_MIN 10
+#define LZ4_MEMORY_USAGE_DEFAULT 14
+#define LZ4_MEMORY_USAGE_MAX 20
+
+    /*!
+     * LZ4_MEMORY_USAGE :
+     * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; )
+     * Increasing memory usage improves compression ratio, at the cost of speed.
+     * Reduced memory usage may improve speed at the cost of ratio, thanks to better cache locality.
+     * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
+     */
+#ifndef LZ4_MEMORY_USAGE
+# define LZ4_MEMORY_USAGE LZ4_MEMORY_USAGE_DEFAULT
+#endif
+
+#if (LZ4_MEMORY_USAGE < LZ4_MEMORY_USAGE_MIN)
+#  error "LZ4_MEMORY_USAGE is too small !"
+#endif
+
+#if (LZ4_MEMORY_USAGE > LZ4_MEMORY_USAGE_MAX)
+#  error "LZ4_MEMORY_USAGE is too large !"
+#endif
+
+     /*-************************************
+     *  Simple Functions
+     **************************************/
+     /*! LZ4_compress_default() :
+      *  Compresses 'srcSize' bytes from buffer 'src'
+      *  into already allocated 'dst' buffer of size 'dstCapacity'.
+      *  Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize).
+      *  It also runs faster, so it's a recommended setting.
+      *  If the function cannot compress 'src' into a more limited 'dst' budget,
+      *  compression stops *immediately*, and the function result is zero.
+      *  In which case, 'dst' content is undefined (invalid).
+      *      srcSize : max supported value is LZ4_MAX_INPUT_SIZE.
+      *      dstCapacity : size of buffer 'dst' (which must be already allocated)
+      *     @return  : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity)
+      *                or 0 if compression fails
+      * Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer).
+      */
+    LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity);
+
+    /*! LZ4_decompress_safe() :
+     * @compressedSize : is the exact complete size of the compressed block.
+     * @dstCapacity : is the size of destination buffer (which must be already allocated),
+     *                is an upper bound of decompressed size.
+     * @return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
+     *           If destination buffer is not large enough, decoding will stop and output an error code (negative value).
+     *           If the source stream is detected malformed, the function will stop decoding and return a negative result.
+     * Note 1 : This function is protected against malicious data packets :
+     *          it will never writes outside 'dst' buffer, nor read outside 'source' buffer,
+     *          even if the compressed block is maliciously modified to order the decoder to do these actions.
+     *          In such case, the decoder stops immediately, and considers the compressed block malformed.
+     * Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them.
+     *          The implementation is free to send / store / derive this information in whichever way is most beneficial.
+     *          If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead.
+     */
+    LZ4LIB_API int LZ4_decompress_safe(const char* src, char* dst, int compressedSize, int dstCapacity);
+
+
+    /*-************************************
+    *  Advanced Functions
+    **************************************/
+#define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
+#define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
+
+    /*! LZ4_compressBound() :
+        Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
+        This function is primarily useful for memory allocation purposes (destination buffer size).
+        Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
+        Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize)
+            inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
+            return : maximum output size in a "worst case" scenario
+                  or 0, if input size is incorrect (too large or negative)
+    */
+    LZ4LIB_API int LZ4_compressBound(int inputSize);
+
+    /*! LZ4_compress_fast() :
+        Same as LZ4_compress_default(), but allows selection of "acceleration" factor.
+        The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
+        It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
+        An acceleration value of "1" is the same as regular LZ4_compress_default()
+        Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c).
+        Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c).
+    */
+    LZ4LIB_API int LZ4_compress_fast(const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
+
+
+    /*! LZ4_compress_fast_extState() :
+     *  Same as LZ4_compress_fast(), using an externally allocated memory space for its state.
+     *  Use LZ4_sizeofState() to know how much memory must be allocated,
+     *  and allocate it on 8-bytes boundaries (using `malloc()` typically).
+     *  Then, provide this buffer as `void* state` to compression function.
+     */
+    LZ4LIB_API int LZ4_sizeofState(void);
+    LZ4LIB_API int LZ4_compress_fast_extState(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
+
+
+    /*! LZ4_compress_destSize() :
+     *  Reverse the logic : compresses as much data as possible from 'src' buffer
+     *  into already allocated buffer 'dst', of size >= 'targetDestSize'.
+     *  This function either compresses the entire 'src' content into 'dst' if it's large enough,
+     *  or fill 'dst' buffer completely with as much data as possible from 'src'.
+     *  note: acceleration parameter is fixed to "default".
+     *
+     * *srcSizePtr : will be modified to indicate how many bytes where read from 'src' to fill 'dst'.
+     *               New value is necessarily <= input value.
+     * @return : Nb bytes written into 'dst' (necessarily <= targetDestSize)
+     *           or 0 if compression fails.
+     *
+     * Note : from v1.8.2 to v1.9.1, this function had a bug (fixed un v1.9.2+):
+     *        the produced compressed content could, in specific circumstances,
+     *        require to be decompressed into a destination buffer larger
+     *        by at least 1 byte than the content to decompress.
+     *        If an application uses `LZ4_compress_destSize()`,
+     *        it's highly recommended to update liblz4 to v1.9.2 or better.
+     *        If this can't be done or ensured,
+     *        the receiving decompression function should provide
+     *        a dstCapacity which is > decompressedSize, by at least 1 byte.
+     *        See https://github.com/lz4/lz4/issues/859 for details
+     */
+    LZ4LIB_API int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize);
+
+
+    /*! LZ4_decompress_safe_partial() :
+     *  Decompress an LZ4 compressed block, of size 'srcSize' at position 'src',
+     *  into destination buffer 'dst' of size 'dstCapacity'.
+     *  Up to 'targetOutputSize' bytes will be decoded.
+     *  The function stops decoding on reaching this objective.
+     *  This can be useful to boost performance
+     *  whenever only the beginning of a block is required.
+     *
+     * @return : the number of bytes decoded in `dst` (necessarily <= targetOutputSize)
+     *           If source stream is detected malformed, function returns a negative result.
+     *
+     *  Note 1 : @return can be < targetOutputSize, if compressed block contains less data.
+     *
+     *  Note 2 : targetOutputSize must be <= dstCapacity
+     *
+     *  Note 3 : this function effectively stops decoding on reaching targetOutputSize,
+     *           so dstCapacity is kind of redundant.
+     *           This is because in older versions of this function,
+     *           decoding operation would still write complete sequences.
+     *           Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize,
+     *           it could write more bytes, though only up to dstCapacity.
+     *           Some "margin" used to be required for this operation to work properly.
+     *           Thankfully, this is no longer necessary.
+     *           The function nonetheless keeps the same signature, in an effort to preserve API compatibility.
+     *
+     *  Note 4 : If srcSize is the exact size of the block,
+     *           then targetOutputSize can be any value,
+     *           including larger than the block's decompressed size.
+     *           The function will, at most, generate block's decompressed size.
+     *
+     *  Note 5 : If srcSize is _larger_ than block's compressed size,
+     *           then targetOutputSize **MUST** be <= block's decompressed size.
+     *           Otherwise, *silent corruption will occur*.
+     */
+    LZ4LIB_API int LZ4_decompress_safe_partial(const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity);
+
+
+    /*-*********************************************
+    *  Streaming Compression Functions
+    ***********************************************/
+    typedef union LZ4_stream_u LZ4_stream_t;  /* incomplete type (defined later) */
+
+    /**
+     Note about RC_INVOKED
+
+     - RC_INVOKED is predefined symbol of rc.exe (the resource compiler which is part of MSVC/Visual Studio).
+       https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros
+
+     - Since rc.exe is a legacy compiler, it truncates long symbol (> 30 chars)
+       and reports warning "RC4011: identifier truncated".
+
+     - To eliminate the warning, we surround long preprocessor symbol with
+       "#if !defined(RC_INVOKED) ... #endif" block that means
+       "skip this block when rc.exe is trying to read it".
+    */
+#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+    LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
+    LZ4LIB_API int           LZ4_freeStream(LZ4_stream_t* streamPtr);
+#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */
+#endif
+
+    /*! LZ4_resetStream_fast() : v1.9.0+
+     *  Use this to prepare an LZ4_stream_t for a new chain of dependent blocks
+     *  (e.g., LZ4_compress_fast_continue()).
+     *
+     *  An LZ4_stream_t must be initialized once before usage.
+     *  This is automatically done when created by LZ4_createStream().
+     *  However, should the LZ4_stream_t be simply declared on stack (for example),
+     *  it's necessary to initialize it first, using LZ4_initStream().
+     *
+     *  After init, start any new stream with LZ4_resetStream_fast().
+     *  A same LZ4_stream_t can be re-used multiple times consecutively
+     *  and compress multiple streams,
+     *  provided that it starts each new stream with LZ4_resetStream_fast().
+     *
+     *  LZ4_resetStream_fast() is much faster than LZ4_initStream(),
+     *  but is not compatible with memory regions containing garbage data.
+     *
+     *  Note: it's only useful to call LZ4_resetStream_fast()
+     *        in the context of streaming compression.
+     *        The *extState* functions perform their own resets.
+     *        Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive.
+     */
+    LZ4LIB_API void LZ4_resetStream_fast(LZ4_stream_t* streamPtr);
+
+    /*! LZ4_loadDict() :
+     *  Use this function to reference a static dictionary into LZ4_stream_t.
+     *  The dictionary must remain available during compression.
+     *  LZ4_loadDict() triggers a reset, so any previous data will be forgotten.
+     *  The same dictionary will have to be loaded on decompression side for successful decoding.
+     *  Dictionary are useful for better compression of small data (KB range).
+     *  While LZ4 accept any input as dictionary,
+     *  results are generally better when using Zstandard's Dictionary Builder.
+     *  Loading a size of 0 is allowed, and is the same as reset.
+     * @return : loaded dictionary size, in bytes (necessarily <= 64 KB)
+     */
+    LZ4LIB_API int LZ4_loadDict(LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
+
+    /*! LZ4_compress_fast_continue() :
+     *  Compress 'src' content using data from previously compressed blocks, for better compression ratio.
+     * 'dst' buffer must be already allocated.
+     *  If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
+     *
+     * @return : size of compressed block
+     *           or 0 if there is an error (typically, cannot fit into 'dst').
+     *
+     *  Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block.
+     *           Each block has precise boundaries.
+     *           Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata.
+     *           It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together.
+     *
+     *  Note 2 : The previous 64KB of source data is __assumed__ to remain present, unmodified, at same address in memory !
+     *
+     *  Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB.
+     *           Make sure that buffers are separated, by at least one byte.
+     *           This construction ensures that each block only depends on previous block.
+     *
+     *  Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB.
+     *
+     *  Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed.
+     */
+    LZ4LIB_API int LZ4_compress_fast_continue(LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
+
+    /*! LZ4_saveDict() :
+     *  If last 64KB data cannot be guaranteed to remain available at its current memory location,
+     *  save it into a safer place (char* safeBuffer).
+     *  This is schematically equivalent to a memcpy() followed by LZ4_loadDict(),
+     *  but is much faster, because LZ4_saveDict() doesn't need to rebuild tables.
+     * @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error.
+     */
+    LZ4LIB_API int LZ4_saveDict(LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize);
+
+
+    /*-**********************************************
+    *  Streaming Decompression Functions
+    *  Bufferless synchronous API
+    ************************************************/
+    typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* tracking context */
+
+    /*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() :
+     *  creation / destruction of streaming decompression tracking context.
+     *  A tracking context can be re-used multiple times.
+     */
+#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+    LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
+    LZ4LIB_API int                 LZ4_freeStreamDecode(LZ4_streamDecode_t* LZ4_stream);
+#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */
+#endif
+
+    /*! LZ4_setStreamDecode() :
+     *  An LZ4_streamDecode_t context can be allocated once and re-used multiple times.
+     *  Use this function to start decompression of a new stream of blocks.
+     *  A dictionary can optionally be set. Use NULL or size 0 for a reset order.
+     *  Dictionary is presumed stable : it must remain accessible and unmodified during next decompression.
+     * @return : 1 if OK, 0 if error
+     */
+    LZ4LIB_API int LZ4_setStreamDecode(LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
+
+    /*! LZ4_decoderRingBufferSize() : v1.8.2+
+     *  Note : in a ring buffer scenario (optional),
+     *  blocks are presumed decompressed next to each other
+     *  up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize),
+     *  at which stage it resumes from beginning of ring buffer.
+     *  When setting such a ring buffer for streaming decompression,
+     *  provides the minimum size of this ring buffer
+     *  to be compatible with any source respecting maxBlockSize condition.
+     * @return : minimum ring buffer size,
+     *           or 0 if there is an error (invalid maxBlockSize).
+     */
+    LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize);
+#define LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize) (65536 + 14 + (maxBlockSize))  /* for static allocation; maxBlockSize presumed valid */
+
+    /*! LZ4_decompress_safe_continue() :
+     *  This decoding function allows decompression of consecutive blocks in "streaming" mode.
+     *  The difference with the usual independent blocks is that
+     *  new blocks are allowed to find references into former blocks.
+     *  A block is an unsplittable entity, and must be presented entirely to the decompression function.
+     *  LZ4_decompress_safe_continue() only accepts one block at a time.
+     *  It's modeled after `LZ4_decompress_safe()` and behaves similarly.
+     *
+     * @LZ4_streamDecode : decompression state, tracking the position in memory of past data
+     * @compressedSize : exact complete size of one compressed block.
+     * @dstCapacity : size of destination buffer (which must be already allocated),
+     *                must be an upper bound of decompressed size.
+     * @return : number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
+     *           If destination buffer is not large enough, decoding will stop and output an error code (negative value).
+     *           If the source stream is detected malformed, the function will stop decoding and return a negative result.
+     *
+     *  The last 64KB of previously decoded data *must* remain available and unmodified
+     *  at the memory position where they were previously decoded.
+     *  If less than 64KB of data has been decoded, all the data must be present.
+     *
+     *  Special : if decompression side sets a ring buffer, it must respect one of the following conditions :
+     *  - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize).
+     *    maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes.
+     *    In which case, encoding and decoding buffers do not need to be synchronized.
+     *    Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize.
+     *  - Synchronized mode :
+     *    Decompression buffer size is _exactly_ the same as compression buffer size,
+     *    and follows exactly same update rule (block boundaries at same positions),
+     *    and decoding function is provided with exact decompressed size of each block (exception for last block of the stream),
+     *    _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB).
+     *  - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes.
+     *    In which case, encoding and decoding buffers do not need to be synchronized,
+     *    and encoding ring buffer can have any size, including small ones ( < 64 KB).
+     *
+     *  Whenever these conditions are not possible,
+     *  save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression,
+     *  then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block.
+    */
+    LZ4LIB_API int
+        LZ4_decompress_safe_continue(LZ4_streamDecode_t* LZ4_streamDecode,
+            const char* src, char* dst,
+            int srcSize, int dstCapacity);
+
+
+    /*! LZ4_decompress_safe_usingDict() :
+     *  Works the same as
+     *  a combination of LZ4_setStreamDecode() followed by LZ4_decompress_safe_continue()
+     *  However, it's stateless: it doesn't need any LZ4_streamDecode_t state.
+     *  Dictionary is presumed stable : it must remain accessible and unmodified during decompression.
+     *  Performance tip : Decompression speed can be substantially increased
+     *                    when dst == dictStart + dictSize.
+     */
+    LZ4LIB_API int
+        LZ4_decompress_safe_usingDict(const char* src, char* dst,
+            int srcSize, int dstCapacity,
+            const char* dictStart, int dictSize);
+
+    /*! LZ4_decompress_safe_partial_usingDict() :
+     *  Behaves the same as LZ4_decompress_safe_partial()
+     *  with the added ability to specify a memory segment for past data.
+     *  Performance tip : Decompression speed can be substantially increased
+     *                    when dst == dictStart + dictSize.
+     */
+    LZ4LIB_API int
+        LZ4_decompress_safe_partial_usingDict(const char* src, char* dst,
+            int compressedSize,
+            int targetOutputSize, int maxOutputSize,
+            const char* dictStart, int dictSize);
+
+#endif /* LZ4_H_2983827168210 */
+
+
+    /*^*************************************
+     * !!!!!!   STATIC LINKING ONLY   !!!!!!
+     ***************************************/
+
+     /*-****************************************************************************
+      * Experimental section
+      *
+      * Symbols declared in this section must be considered unstable. Their
+      * signatures or semantics may change, or they may be removed altogether in the
+      * future. They are therefore only safe to depend on when the caller is
+      * statically linked against the library.
+      *
+      * To protect against unsafe usage, not only are the declarations guarded,
+      * the definitions are hidden by default
+      * when building LZ4 as a shared/dynamic library.
+      *
+      * In order to access these declarations,
+      * define LZ4_STATIC_LINKING_ONLY in your application
+      * before including LZ4's headers.
+      *
+      * In order to make their implementations accessible dynamically, you must
+      * define LZ4_PUBLISH_STATIC_FUNCTIONS when building the LZ4 library.
+      ******************************************************************************/
+
+#ifdef LZ4_STATIC_LINKING_ONLY
+
+#ifndef LZ4_STATIC_3504398509
+#define LZ4_STATIC_3504398509
+
+#ifdef LZ4_PUBLISH_STATIC_FUNCTIONS
+#define LZ4LIB_STATIC_API LZ4LIB_API
+#else
+#define LZ4LIB_STATIC_API
+#endif
+
+
+      /*! LZ4_compress_fast_extState_fastReset() :
+       *  A variant of LZ4_compress_fast_extState().
+       *
+       *  Using this variant avoids an expensive initialization step.
+       *  It is only safe to call if the state buffer is known to be correctly initialized already
+       *  (see above comment on LZ4_resetStream_fast() for a definition of "correctly initialized").
+       *  From a high level, the difference is that
+       *  this function initializes the provided state with a call to something like LZ4_resetStream_fast()
+       *  while LZ4_compress_fast_extState() starts with a call to LZ4_resetStream().
+       */
+    LZ4LIB_STATIC_API int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
+
+    /*! LZ4_attach_dictionary() :
+     *  This is an experimental API that allows
+     *  efficient use of a static dictionary many times.
+     *
+     *  Rather than re-loading the dictionary buffer into a working context before
+     *  each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a
+     *  working LZ4_stream_t, this function introduces a no-copy setup mechanism,
+     *  in which the working stream references the dictionary stream in-place.
+     *
+     *  Several assumptions are made about the state of the dictionary stream.
+     *  Currently, only streams which have been prepared by LZ4_loadDict() should
+     *  be expected to work.
+     *
+     *  Alternatively, the provided dictionaryStream may be NULL,
+     *  in which case any existing dictionary stream is unset.
+     *
+     *  If a dictionary is provided, it replaces any pre-existing stream history.
+     *  The dictionary contents are the only history that can be referenced and
+     *  logically immediately precede the data compressed in the first subsequent
+     *  compression call.
+     *
+     *  The dictionary will only remain attached to the working stream through the
+     *  first compression call, at the end of which it is cleared. The dictionary
+     *  stream (and source buffer) must remain in-place / accessible / unchanged
+     *  through the completion of the first compression call on the stream.
+     */
+    LZ4LIB_STATIC_API void
+        LZ4_attach_dictionary(LZ4_stream_t* workingStream,
+            const LZ4_stream_t* dictionaryStream);
+
+
+    /*! In-place compression and decompression
+     *
+     * It's possible to have input and output sharing the same buffer,
+     * for highly constrained memory environments.
+     * In both cases, it requires input to lay at the end of the buffer,
+     * and decompression to start at beginning of the buffer.
+     * Buffer size must feature some margin, hence be larger than final size.
+     *
+     * |<------------------------buffer--------------------------------->|
+     *                             |<-----------compressed data--------->|
+     * |<-----------decompressed size------------------>|
+     *                                                  |<----margin---->|
+     *
+     * This technique is more useful for decompression,
+     * since decompressed size is typically larger,
+     * and margin is short.
+     *
+     * In-place decompression will work inside any buffer
+     * which size is >= LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize).
+     * This presumes that decompressedSize > compressedSize.
+     * Otherwise, it means compression actually expanded data,
+     * and it would be more efficient to store such data with a flag indicating it's not compressed.
+     * This can happen when data is not compressible (already compressed, or encrypted).
+     *
+     * For in-place compression, margin is larger, as it must be able to cope with both
+     * history preservation, requiring input data to remain unmodified up to LZ4_DISTANCE_MAX,
+     * and data expansion, which can happen when input is not compressible.
+     * As a consequence, buffer size requirements are much higher,
+     * and memory savings offered by in-place compression are more limited.
+     *
+     * There are ways to limit this cost for compression :
+     * - Reduce history size, by modifying LZ4_DISTANCE_MAX.
+     *   Note that it is a compile-time constant, so all compressions will apply this limit.
+     *   Lower values will reduce compression ratio, except when input_size < LZ4_DISTANCE_MAX,
+     *   so it's a reasonable trick when inputs are known to be small.
+     * - Require the compressor to deliver a "maximum compressed size".
+     *   This is the `dstCapacity` parameter in `LZ4_compress*()`.
+     *   When this size is < LZ4_COMPRESSBOUND(inputSize), then compression can fail,
+     *   in which case, the return code will be 0 (zero).
+     *   The caller must be ready for these cases to happen,
+     *   and typically design a backup scheme to send data uncompressed.
+     * The combination of both techniques can significantly reduce
+     * the amount of margin required for in-place compression.
+     *
+     * In-place compression can work in any buffer
+     * which size is >= (maxCompressedSize)
+     * with maxCompressedSize == LZ4_COMPRESSBOUND(srcSize) for guaranteed compression success.
+     * LZ4_COMPRESS_INPLACE_BUFFER_SIZE() depends on both maxCompressedSize and LZ4_DISTANCE_MAX,
+     * so it's possible to reduce memory requirements by playing with them.
+     */
+
+#define LZ4_DECOMPRESS_INPLACE_MARGIN(compressedSize)          (((compressedSize) >> 8) + 32)
+#define LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize)   ((decompressedSize) + LZ4_DECOMPRESS_INPLACE_MARGIN(decompressedSize))  /**< note: presumes that compressedSize < decompressedSize. note2: margin is overestimated a bit, since it could use compressedSize instead */
+
+#ifndef LZ4_DISTANCE_MAX   /* history window size; can be user-defined at compile time */
+#  define LZ4_DISTANCE_MAX 65535   /* set to maximum value by default */
+#endif
+
+#define LZ4_COMPRESS_INPLACE_MARGIN                           (LZ4_DISTANCE_MAX + 32)   /* LZ4_DISTANCE_MAX can be safely replaced by srcSize when it's smaller */
+#define LZ4_COMPRESS_INPLACE_BUFFER_SIZE(maxCompressedSize)   ((maxCompressedSize) + LZ4_COMPRESS_INPLACE_MARGIN)  /**< maxCompressedSize is generally LZ4_COMPRESSBOUND(inputSize), but can be set to any lower value, with the risk that compression can fail (return code 0(zero)) */
+
+#endif   /* LZ4_STATIC_3504398509 */
+#endif   /* LZ4_STATIC_LINKING_ONLY */
+
+
+
+#ifndef LZ4_H_98237428734687
+#define LZ4_H_98237428734687
+
+     /*-************************************************************
+      *  Private Definitions
+      **************************************************************
+      * Do not use these definitions directly.
+      * They are only exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
+      * Accessing members will expose user code to API and/or ABI break in future versions of the library.
+      **************************************************************/
+#define LZ4_HASHLOG   (LZ4_MEMORY_USAGE-2)
+#define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
+#define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)       /* required as macro for static allocation */
+
+#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+# include <stdint.h>
+    typedef  int8_t  LZ4_i8;
+    typedef uint8_t  LZ4_byte;
+    typedef uint16_t LZ4_u16;
+    typedef uint32_t LZ4_u32;
+#else
+    typedef   signed char  LZ4_i8;
+    typedef unsigned char  LZ4_byte;
+    typedef unsigned short LZ4_u16;
+    typedef unsigned int   LZ4_u32;
+#endif
+
+    /*! LZ4_stream_t :
+     *  Never ever use below internal definitions directly !
+     *  These definitions are not API/ABI safe, and may change in future versions.
+     *  If you need static allocation, declare or allocate an LZ4_stream_t object.
+    **/
+
+    typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
+    struct LZ4_stream_t_internal {
+        LZ4_u32 hashTable[LZ4_HASH_SIZE_U32];
+        const LZ4_byte* dictionary;
+        const LZ4_stream_t_internal* dictCtx;
+        LZ4_u32 currentOffset;
+        LZ4_u32 tableType;
+        LZ4_u32 dictSize;
+        /* Implicit padding to ensure structure is aligned */
+    };
+
+#define LZ4_STREAM_MINSIZE  ((1UL << LZ4_MEMORY_USAGE) + 32)  /* static size, for inter-version compatibility */
+    union LZ4_stream_u {
+        char minStateSize[LZ4_STREAM_MINSIZE];
+        LZ4_stream_t_internal internal_donotuse;
+    }; /* previously typedef'd to LZ4_stream_t */
+
+
+    /*! LZ4_initStream() : v1.9.0+
+     *  An LZ4_stream_t structure must be initialized at least once.
+     *  This is automatically done when invoking LZ4_createStream(),
+     *  but it's not when the structure is simply declared on stack (for example).
+     *
+     *  Use LZ4_initStream() to properly initialize a newly declared LZ4_stream_t.
+     *  It can also initialize any arbitrary buffer of sufficient size,
+     *  and will @return a pointer of proper type upon initialization.
+     *
+     *  Note : initialization fails if size and alignment conditions are not respected.
+     *         In which case, the function will @return NULL.
+     *  Note2: An LZ4_stream_t structure guarantees correct alignment and size.
+     *  Note3: Before v1.9.0, use LZ4_resetStream() instead
+    **/
+    LZ4LIB_API LZ4_stream_t* LZ4_initStream(void* buffer, size_t size);
+
+
+    /*! LZ4_streamDecode_t :
+     *  Never ever use below internal definitions directly !
+     *  These definitions are not API/ABI safe, and may change in future versions.
+     *  If you need static allocation, declare or allocate an LZ4_streamDecode_t object.
+    **/
+    typedef struct {
+        const LZ4_byte* externalDict;
+        const LZ4_byte* prefixEnd;
+        size_t extDictSize;
+        size_t prefixSize;
+    } LZ4_streamDecode_t_internal;
+
+#define LZ4_STREAMDECODE_MINSIZE 32
+    union LZ4_streamDecode_u {
+        char minStateSize[LZ4_STREAMDECODE_MINSIZE];
+        LZ4_streamDecode_t_internal internal_donotuse;
+    };   /* previously typedef'd to LZ4_streamDecode_t */
+
+
+
+    /*-************************************
+    *  Obsolete Functions
+    **************************************/
+
+    /*! Deprecation warnings
+     *
+     *  Deprecated functions make the compiler generate a warning when invoked.
+     *  This is meant to invite users to update their source code.
+     *  Should deprecation warnings be a problem, it is generally possible to disable them,
+     *  typically with -Wno-deprecated-declarations for gcc
+     *  or _CRT_SECURE_NO_WARNINGS in Visual.
+     *
+     *  Another method is to define LZ4_DISABLE_DEPRECATE_WARNINGS
+     *  before including the header file.
+     */
+#ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
+#  define LZ4_DEPRECATED(message)   /* disable deprecation warnings */
+#else
+#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
+#    define LZ4_DEPRECATED(message) [[deprecated(message)]]
+#  elif defined(_MSC_VER)
+#    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
+#  elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 45))
+#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
+#  elif defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 31)
+#    define LZ4_DEPRECATED(message) __attribute__((deprecated))
+#  else
+#    pragma message("WARNING: LZ4_DEPRECATED needs custom implementation for this compiler")
+#    define LZ4_DEPRECATED(message)   /* disabled */
+#  endif
+#endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
+
+     /*! Obsolete compression functions (since v1.7.3) */
+    LZ4_DEPRECATED("use LZ4_compress_default() instead")       LZ4LIB_API int LZ4_compress(const char* src, char* dest, int srcSize);
+    LZ4_DEPRECATED("use LZ4_compress_default() instead")       LZ4LIB_API int LZ4_compress_limitedOutput(const char* src, char* dest, int srcSize, int maxOutputSize);
+    LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState(void* state, const char* source, char* dest, int inputSize);
+    LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
+    LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue(LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
+    LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue(LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
+
+    /*! Obsolete decompression functions (since v1.8.0) */
+    LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress(const char* source, char* dest, int outputSize);
+    LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize(const char* source, char* dest, int isize, int maxOutputSize);
+
+    /* Obsolete streaming functions (since v1.7.0)
+     * degraded functionality; do not use!
+     *
+     * In order to perform streaming compression, these functions depended on data
+     * that is no longer tracked in the state. They have been preserved as well as
+     * possible: using them will still produce a correct output. However, they don't
+     * actually retain any history between compression calls. The compression ratio
+     * achieved will therefore be no better than compressing each chunk
+     * independently.
+     */
+    LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create(char* inputBuffer);
+    LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int   LZ4_sizeofStreamState(void);
+    LZ4_DEPRECATED("Use LZ4_resetStream() instead")  LZ4LIB_API int   LZ4_resetStreamState(void* state, char* inputBuffer);
+    LZ4_DEPRECATED("Use LZ4_saveDict() instead")     LZ4LIB_API char* LZ4_slideInputBuffer(void* state);
+
+    /*! Obsolete streaming decoding functions (since v1.7.0) */
+    LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k(const char* src, char* dst, int compressedSize, int maxDstSize);
+    LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k(const char* src, char* dst, int originalSize);
+
+    /*! Obsolete LZ4_decompress_fast variants (since v1.9.0) :
+     *  These functions used to be faster than LZ4_decompress_safe(),
+     *  but this is no longer the case. They are now slower.
+     *  This is because LZ4_decompress_fast() doesn't know the input size,
+     *  and therefore must progress more cautiously into the input buffer to not read beyond the end of block.
+     *  On top of that `LZ4_decompress_fast()` is not protected vs malformed or malicious inputs, making it a security liability.
+     *  As a consequence, LZ4_decompress_fast() is strongly discouraged, and deprecated.
+     *
+     *  The last remaining LZ4_decompress_fast() specificity is that
+     *  it can decompress a block without knowing its compressed size.
+     *  Such functionality can be achieved in a more secure manner
+     *  by employing LZ4_decompress_safe_partial().
+     *
+     *  Parameters:
+     *  originalSize : is the uncompressed size to regenerate.
+     *                 `dst` must be already allocated, its size must be >= 'originalSize' bytes.
+     * @return : number of bytes read from source buffer (== compressed size).
+     *           The function expects to finish at block's end exactly.
+     *           If the source stream is detected malformed, the function stops decoding and returns a negative result.
+     *  note : LZ4_decompress_fast*() requires originalSize. Thanks to this information, it never writes past the output buffer.
+     *         However, since it doesn't know its 'src' size, it may read an unknown amount of input, past input buffer bounds.
+     *         Also, since match offsets are not validated, match reads from 'src' may underflow too.
+     *         These issues never happen if input (compressed) data is correct.
+     *         But they may happen if input data is invalid (error or intentional tampering).
+     *         As a consequence, use these functions in trusted environments with trusted data **only**.
+     */
+    LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe() instead")
+        LZ4LIB_API int LZ4_decompress_fast(const char* src, char* dst, int originalSize);
+    LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_continue() instead")
+        LZ4LIB_API int LZ4_decompress_fast_continue(LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize);
+    LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_usingDict() instead")
+        LZ4LIB_API int LZ4_decompress_fast_usingDict(const char* src, char* dst, int originalSize, const char* dictStart, int dictSize);
+
+    /*! LZ4_resetStream() :
+     *  An LZ4_stream_t structure must be initialized at least once.
+     *  This is done with LZ4_initStream(), or LZ4_resetStream().
+     *  Consider switching to LZ4_initStream(),
+     *  invoking LZ4_resetStream() will trigger deprecation warnings in the future.
+     */
+    LZ4LIB_API void LZ4_resetStream(LZ4_stream_t* streamPtr);
+
+
+#endif /* LZ4_H_98237428734687 */
+
+
+#if defined (__cplusplus)
+}
+#endif

inc/misc_controller.h

@@ -27,8 +27,9 @@ class MiscController : public http::HttpController<MiscController> {
   ADD_PATH("/api/getTranslateVoiceText", GetTranslateVoiceText);
   ADD_PATH("/api/openUrlByWeChat", OpenUrlByWeChat);
   ADD_PATH("/api/confirmReceipt", ConfirmReceipt);
+  ADD_PATH("/api/refuseReceipt",RefundReceipt);
   ADD_PATH("/api/downloadAttach", DownloadAttach);
-
+  ADD_PATH("/api/verifyApply", VerifyApply);
   PATHS_END
 
  public:
@@ -100,10 +101,18 @@ class MiscController : public http::HttpController<MiscController> {
   /// @param params json
   /// @return json
   static std::string ConfirmReceipt(std::string params);
+  /// @brief 拒绝收款
+  /// @param params json
+  /// @return json
+  static std::string RefundReceipt(std::string params);
   /// @brief 下载附件
   /// @param params json
   /// @return json
   static std::string DownloadAttach(std::string params);
+  /// @brief 通过好友
+  /// @param params json
+  /// @return json
+  static std::string VerifyApply(std::string params);
 };
 }  // namespace wxhelper
 

inc/offset.h

@@ -5,6 +5,8 @@ namespace wechat {
 #define V_3_9_8_25 39825
 #define V_3_9_9_43 39943
 #define V_3_9_10_19 391019
+#define V_3_9_11_19 391119
+#define V_3_9_11_25 391125
 #ifndef WECHAT_VERSION
 #error " WECHAT_VERSION not defined ."
 #endif
@@ -53,11 +55,11 @@ const uint64_t kMultiDBMgr = 0x3e00910;
 const uint64_t kPublicMsgMgr = 0x3dfe098;
 const uint64_t kFavoriteStorageMgr = 0x3e01478;
 
-const uint64_t kChatRoomMgr = 0x8e9d30;
+const uint64_t kChatRoomMgr = 0x1b83bd0;
 const uint64_t kGetChatRoomDetailInfo = 0xe73590;
 const uint64_t kNewChatRoomInfo = 0x12006b0;
 const uint64_t kFreeChatRoomInfo = 0x1200890;
-const uint64_t kDoAddMemberToChatRoom = 0xe63c70;
+const uint64_t kDoAddMemberToChatRoom = 0x2155100;
 const uint64_t kDoModChatRoomMemberNickName = 0xe6db00;
 const uint64_t kDelMemberFromChatRoom = 0xe64290;
 const uint64_t kGetMemberFromChatRoom = 0xe74de0;
@@ -349,6 +351,244 @@ const uint64_t kFreeWebViewPageConfig = 0x951520;
 const uint64_t kGetWebViewMgr = 0x9412d0;
 const uint64_t kShowWebView = 0x1d236b0;
 const uint64_t kSetUrl = 0x13dd410;
+#elif WECHAT_VERSION == V_3_9_11_19
+const uint64_t kGetAccountServiceMgr = 0x1b50d00;
+const uint64_t kSyncMsg = 0xc39680;
+const uint64_t kSyncMsgNext = 0xc39680;
+const uint64_t kGetCurrentDataPath = 0x2248ce0;
+const uint64_t kGetAppDataSavePath = 0x25dc0e0;
+const uint64_t kGetSendMessageMgr = 0x1b4f500;
+const uint64_t kSendTextMsg = 0x22c2010;
+const uint64_t kFreeChatMsg = 0x1b50d80;
+
+const uint64_t kDoAddMsg = 0x230a3e0;
+const uint64_t kSendImageMsg = 0x22b77a0;
+const uint64_t kChatMsgInstanceCounter = 0x1b59670;
+const uint64_t kSendFileMsg = 0x20cb6f0;
+const uint64_t kGetAppMsgMgr = 0x1b544a0;
+const uint64_t kGetContactMgr = 0x1b3ccd0;
+const uint64_t kGetContactList = 0x219a1c0;
+
+const uint64_t k_sqlite3_exec = 0x3a59b30;
+const uint64_t k_sqlite3_prepare = 0x3a617b0;
+const uint64_t k_sqlite3_open = 0x3a98fa0;
+const uint64_t k_sqlite3_step = 0x3a1db30;
+const uint64_t k_sqlite3_column_count = 0x3a1e350;
+const uint64_t k_sqlite3_column_name = 0x3a1ed50;
+const uint64_t k_sqlite3_column_type = 0x3a1eba0;
+const uint64_t k_sqlite3_column_blob = 0x3a1e380;
+const uint64_t k_sqlite3_column_bytes = 0x3a1e470;
+const uint64_t k_sqlite3_finalize = 0x3a1cbe0;
+
+const uint64_t kGPInstance = 0x58dd300;
+const uint64_t kMultiDBMgr = 0x593abf8;
+const uint64_t kPublicMsgMgr = 0x5938198;
+const uint64_t kFavoriteStorageMgr = 0x593b790;
+const uint64_t kHardLinkMgr = 0x593ab28;
+
+const uint64_t kChatRoomMgr = 0x1b7f100;
+const uint64_t kGetChatRoomDetailInfo = 0x2160bb0;
+const uint64_t kNewChatRoomInfo = 0x2505120;
+const uint64_t kFreeChatRoomInfo = 0x2505300;
+const uint64_t kDoAddMemberToChatRoom = 0x21505b0;
+const uint64_t kDoModChatRoomMemberNickName = 0x215a360;
+const uint64_t kDelMemberFromChatRoom = 0x2150bf0;
+const uint64_t kGetMemberFromChatRoom = 0x2162400;
+const uint64_t kNewChatRoom = 0x2502540;
+const uint64_t kFreeChatRoom = 0x2502740;
+
+const uint64_t kTopMsg = 0x1d7d160;
+const uint64_t kRemoveTopMsg = 0x2166090;
+const uint64_t kInviteMember = 0x214ff90;
+const uint64_t kHookLog = 0x1304e60;
+
+const uint64_t kCreateChatRoom = 0x214fc60;
+const uint64_t kQuitChatRoom = 0x215ac00;
+const uint64_t kForwardMsg = 0x22c1590;
+
+const uint64_t kOnSnsTimeLineSceneFinish = 0x1a73150;
+const uint64_t kSNSGetFirstPage = 0x2e1bec0;
+const uint64_t kSNSGetNextPageScene = 0x2e41a70;
+const uint64_t kSNSDataMgr = 0x21dd6b0;
+const uint64_t kSNSTimeLineMgr = 0x2dadf20;
+const uint64_t kGetMgrByPrefixLocalId = 0x213afb0;
+const uint64_t kAddFavFromMsg = 0x2930e40;
+const uint64_t kGetChatMgr = 0x1b82bf0;
+const uint64_t kGetFavoriteMgr = 0x1b57ba0;
+const uint64_t kAddFavFromImage = 0x293d0f0;
+const uint64_t kGetContact = 0x21945d0;
+const uint64_t kNewContact = 0x2519300;
+const uint64_t kFreeContact = 0x25199b0;
+const uint64_t kNewMMReaderItem = 0x8c79a0;
+const uint64_t kFreeMMReaderItem = 0x8c6da0;
+const uint64_t kForwordPublicMsg = 0xddc6c0;
+const uint64_t kParseAppMsgXml = 0x11b0a70;
+const uint64_t kNewAppMsgInfo = 0x91a550;
+const uint64_t kFreeAppMsgInfo = 0x8fd1a0;
+const uint64_t kGetPreDownLoadMgr = 0x1c0a3a0;
+const uint64_t kPushAttachTask = 0x1cda920;
+const uint64_t kGetCustomSmileyMgr = 0x1ca0320;
+const uint64_t kSendCustomEmotion = 0x21b04c0;
+const uint64_t kNewJsApiShareAppMessage = 0x26cda20;
+const uint64_t kInitJsConfig = 0x137bc00;
+const uint64_t kSendApplet = 0x13c0920;
+const uint64_t kSendAppletSecond = 0x13c1150;
+const uint64_t kGetAppInfoByWaid = 0x13c5790;
+const uint64_t kCopyShareAppMessageRequest = 0x13c0670;
+const uint64_t kNewWAUpdatableMsgInfo = 0x919ca0;
+const uint64_t kFreeWAUpdatableMsgInfo = 0x8fc230;
+const uint64_t kSendPatMsg = 0x2ca9790;
+const uint64_t kGetOCRManager = 0x999780;
+const uint64_t kDoOCRTask = 0x2c53910;
+
+const uint64_t kGetLockWechatMgr = 0x1c85010;
+const uint64_t kRequestLockWechat = 0x1c397d0;
+const uint64_t kRequestUnLockWechat = 0x1c39a70;
+
+const uint64_t kOnLoginBtnClick = 0x202bc30;
+
+const uint64_t kGetQRCodeLoginMgr = 0x201e350;
+
+const uint64_t kUpdateMsg = 0x21421a0;
+const uint64_t kGetVoiceMgr = 0x1e13320;
+const uint64_t kChatMsg2NetSceneSendMsg = 0x1b70fd0;
+const uint64_t kTranslateVoice = 0x2353d50;
+const uint64_t kNewWebViewPageConfig = 0x1b53ae0;
+const uint64_t kFreeWebViewPageConfig = 0x1b53d10;
+const uint64_t kGetWebViewMgr = 0x1b43950;
+const uint64_t kShowWebView = 0x302ed30;
+const uint64_t kSetUrl = 0x13dd410;
+
+const uint64_t kNewPayInfo = 0x1bcd930;
+const uint64_t kFreePayInfo = 0x1b92450;
+const uint64_t kTransferConfirm = 0x2f8c750;
+const uint64_t kTransferRefuse = 0x2f8d340;
+
+const uint64_t kAddFriend = 0x1f3a350;
+const uint64_t kVerifyApply = 0x1f3a940;
+const uint64_t kDoDelContact = 0x2310120;
+
+const uint64_t kGetSearchContactMgr = 0x1f9a730;
+const uint64_t kStartSearch = 0x22a4200;
+#elif WECHAT_VERSION == V_3_9_11_25
+const uint64_t kGetAccountServiceMgr = 0x1B557D0;
+const uint64_t kSyncMsg = 0xc39680;
+const uint64_t kSyncMsgNext = 0xc39680;
+const uint64_t kGetCurrentDataPath = 0x224D830;
+const uint64_t kGetAppDataSavePath = 0x25E1040;
+const uint64_t kGetSendMessageMgr = 0x1B53FD0;
+const uint64_t kSendTextMsg = 0x22C6B60;
+const uint64_t kFreeChatMsg = 0x1B55850;
+
+const uint64_t kDoAddMsg = 0x230EF30;
+const uint64_t kSendImageMsg = 0x22BC2F0;
+const uint64_t kChatMsgInstanceCounter = 0x1B5E140;
+const uint64_t kSendFileMsg = 0x20D0230;
+const uint64_t kGetAppMsgMgr = 0x1B58F70;
+const uint64_t kGetContactMgr = 0x1B417A0;
+const uint64_t kGetContactList = 0x219ed10;
+
+const uint64_t k_sqlite3_exec = 0x3a5eda0;
+const uint64_t k_sqlite3_prepare = 0x3a66a20;
+const uint64_t k_sqlite3_open = 0x3a9e210;
+const uint64_t k_sqlite3_step = 0x3a22da0;
+const uint64_t k_sqlite3_column_count = 0x3a235c0;
+const uint64_t k_sqlite3_column_name = 0x3a23fc0;
+const uint64_t k_sqlite3_column_type = 0x3a23e10;
+const uint64_t k_sqlite3_column_blob = 0x3a235f0;
+const uint64_t k_sqlite3_column_bytes = 0x3a236e0;
+const uint64_t k_sqlite3_finalize = 0x3a21e50;
+
+const uint64_t kGPInstance = 0x5902000;
+const uint64_t kMultiDBMgr = 0x595f900;
+const uint64_t kPublicMsgMgr = 0x595ce98;
+const uint64_t kFavoriteStorageMgr = 0x5960498;
+const uint64_t kHardLinkMgr = 0x593ab28;
+
+const uint64_t kChatRoomMgr = 0x1b83bd0;
+const uint64_t kGetChatRoomDetailInfo = 0x2165700;
+const uint64_t kNewChatRoomInfo = 0x2509CD0;
+const uint64_t kFreeChatRoomInfo = 0x2509EB0;
+const uint64_t kDoAddMemberToChatRoom = 0x2155100;
+const uint64_t kDoModChatRoomMemberNickName = 0x215eeb0;
+const uint64_t kDelMemberFromChatRoom = 0x2155740;
+const uint64_t kGetMemberFromChatRoom = 0x2162400;
+const uint64_t kNewChatRoom = 0x2502540;
+const uint64_t kFreeChatRoom = 0x2502740;
+
+const uint64_t kTopMsg = 0x1d7d160;
+const uint64_t kRemoveTopMsg = 0x2166090;
+const uint64_t kInviteMember = 0x2154ae0;
+const uint64_t kHookLog = 0x1304e60;
+
+const uint64_t kCreateChatRoom = 0x214fc60;
+const uint64_t kQuitChatRoom = 0x215ac00;
+const uint64_t kForwardMsg = 0x22C60E0;
+
+const uint64_t kOnSnsTimeLineSceneFinish = 0x1a73150;
+const uint64_t kSNSGetFirstPage = 0x2e212d0;
+const uint64_t kSNSGetNextPageScene = 0x2ec8970;
+const uint64_t kSNSDataMgr = 0x21e2200;
+const uint64_t kSNSTimeLineMgr = 0x2db3390;
+const uint64_t kGetMgrByPrefixLocalId = 0x213afb0;
+const uint64_t kAddFavFromMsg = 0x2930e40;
+const uint64_t kGetChatMgr = 0x1b876c0;
+const uint64_t kGetFavoriteMgr = 0x1B5C670;
+const uint64_t kAddFavFromImage = 0x293d0f0;
+const uint64_t kGetContact = 0x21945d0;
+const uint64_t kNewContact = 0x2519300;
+const uint64_t kFreeContact = 0x25199b0;
+const uint64_t kNewMMReaderItem = 0x8c79a0;
+const uint64_t kFreeMMReaderItem = 0x8c6da0;
+const uint64_t kForwordPublicMsg = 0xddc6c0;
+const uint64_t kParseAppMsgXml = 0x11b0a70;
+const uint64_t kNewAppMsgInfo = 0x91a550;
+const uint64_t kFreeAppMsgInfo = 0x8fd1a0;
+const uint64_t kGetPreDownLoadMgr = 0x1c0a3a0;
+const uint64_t kPushAttachTask = 0x1cda920;
+const uint64_t kGetCustomSmileyMgr = 0x1ca0320;
+const uint64_t kSendCustomEmotion = 0x21b04c0;
+const uint64_t kNewJsApiShareAppMessage = 0x26cda20;
+const uint64_t kInitJsConfig = 0x137bc00;
+const uint64_t kSendApplet = 0x13c0920;
+const uint64_t kSendAppletSecond = 0x13c1150;
+const uint64_t kGetAppInfoByWaid = 0x13c5790;
+const uint64_t kCopyShareAppMessageRequest = 0x13c0670;
+const uint64_t kNewWAUpdatableMsgInfo = 0x1BD27E0;
+const uint64_t kFreeWAUpdatableMsgInfo = 0x1B97590;
+const uint64_t kSendPatMsg = 0xB2BB00;
+const uint64_t kGetOCRManager = 0x999780;
+const uint64_t kDoOCRTask = 0x2c53910;
+
+const uint64_t kGetLockWechatMgr = 0x1c85010;
+const uint64_t kRequestLockWechat = 0x1c397d0;
+const uint64_t kRequestUnLockWechat = 0x1c39a70;
+
+const uint64_t kOnLoginBtnClick = 0x202bc30;
+
+const uint64_t kGetQRCodeLoginMgr = 0x201e350;
+
+const uint64_t kUpdateMsg = 0x21421a0;
+const uint64_t kGetVoiceMgr = 0x1e13320;
+const uint64_t kChatMsg2NetSceneSendMsg = 0x1b70fd0;
+const uint64_t kTranslateVoice = 0x2353d50;
+const uint64_t kNewWebViewPageConfig = 0x1b53ae0;
+const uint64_t kFreeWebViewPageConfig = 0x1b53d10;
+const uint64_t kGetWebViewMgr = 0x1b43950;
+const uint64_t kShowWebView = 0x302ed30;
+const uint64_t kSetUrl = 0x13dd410;
+
+const uint64_t kNewPayInfo = 0x1bcd930;
+const uint64_t kFreePayInfo = 0x1b92450;
+const uint64_t kTransferConfirm = 0x2f8c750;
+const uint64_t kTransferRefuse = 0x2f8d340;
+
+const uint64_t kAddFriend = 0x1f3a350;
+const uint64_t kVerifyApply = 0x1B3BBE0;
+const uint64_t kDoDelContact = 0x2310120;
+
+const uint64_t kGetSearchContactMgr = 0x1f9a730;
+const uint64_t kStartSearch = 0x22a4200;
 #else
 #ifdef WECHAT_VERSION
 #error "Unsupported WeChat version."

inc/wechat_interface.h

@@ -128,6 +128,31 @@ struct ContactProfileInner {
       : wxid(""), account(""), v3(""), nickname(""), head_image("") {}
 };
 
+struct SearchContactInner {
+  std::string big_image;
+  std::string small_image;
+  std::string city;
+  std::string nation;
+  std::string province;
+  std::string signature;
+  std::string v2;
+  std::string v3;
+  std::string nickname;
+  int32_t sex;
+  SearchContactInner()
+      : big_image(""),
+        small_image(""),
+        city(""),
+        nation(""),
+        province(""),
+        signature(""),
+        sex(-1),
+        v2(""),
+        v3(""),
+        nickname("") {}
+};
+
+
 namespace function {
 //hook
  typedef  uint64_t(*__DoAddMsg)(uint64_t, uint64_t, uint64_t);
@@ -224,6 +249,15 @@ typedef uint64_t (*__NewWebViewPageConfig)(uint64_t);
 typedef uint64_t (*__FreeWebViewPageConfig)(uint64_t);
 typedef uint64_t (*__GetWebViewMgr)();
 typedef uint64_t (*__SetUrl)(uint64_t,uint64_t,uint64_t);
+typedef uint64_t (*__NewWCPayInfo)(uint64_t);
+typedef uint64_t (*__FreeWCPayInfo)(uint64_t);
+typedef uint64_t (*__PayTransferConfirm)(uint64_t,uint64_t);
+typedef uint64_t (*__PayTransferRefuse)(uint64_t,uint64_t);
+typedef uint64_t (*__AddFriend)(uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t);
+typedef uint64_t (*__Verify)(uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t);
+typedef uint64_t (*__DelContact)(uint64_t);
+typedef uint64_t (*__GetSearchContactMgr)();
+typedef uint64_t (*__StartSearch)(uint64_t,uint64_t);
 
 }  // namespace function
 

inc/wechat_service.h

@@ -37,7 +37,7 @@ class WeChatService : public base::Singleton<WeChatService> {
   int64_t GetMemberFromChatRoom(const std::wstring& room_id,
                                 ChatRoomMemberInner& member);
   int64_t SetTopMsg(uint64_t msg_id);
-  int64_t RemoveTopMsg(const std::wstring& room_id, ULONG64 msg_id);
+  int64_t RemoveTopMsg(const std::wstring& room_id, uint64_t msg_id);
   int64_t InviteMemberToChatRoom(const std::wstring& room_id,
                                  const std::vector<std::wstring>& wxids);
   int64_t CreateChatRoom(const std::vector<std::wstring>& wxids);
@@ -54,7 +54,7 @@ class WeChatService : public base::Singleton<WeChatService> {
   std::wstring GetContactOrChatRoomNickname(const std::wstring& wxid);
   int64_t GetContactByWxid(const std::wstring& wxid,
                            ContactProfileInner& profile);
-  int64_t DoDownloadTask(uint64_t msg_id);
+  std::wstring DoDownloadTask(uint64_t msg_id);
   int64_t ForwardPublicMsg(const std::wstring& wxid, const std::wstring& title,
                            const std::wstring& url,
                            const std::wstring& thumb_url,
@@ -70,11 +70,11 @@ class WeChatService : public base::Singleton<WeChatService> {
                             const std::wstring& wxid);
   int64_t SendApplet(const std::wstring& recv_wxid,
                      const std::wstring& waid_suff, const std::wstring& waid_w,
-                     const std::string& waid_s, const std::string& wa_wxid,
-                     const std::string& json_param,
-                     const std::string& head_image,
-                     const std::string& big_image,
-                     const std::string& index_page);
+                     const std::wstring& waid_s, const std::wstring& wa_wxid,
+                     const std::wstring& json_param,
+                     const std::wstring& head_image,
+                     const std::wstring& big_image,
+                     const std::wstring& index_page);
   int64_t SendPatMsg(const std::wstring& room_id, const std::wstring& wxid);
   int64_t DoOCRTask(const std::wstring& img_path, std::string& result);
   int64_t LockWeChat();
@@ -88,6 +88,24 @@ class WeChatService : public base::Singleton<WeChatService> {
   int64_t TranslateVoice(uint64_t msg_id);
   std::string GetTranslateVoiceText(uint64_t msg_id);
   int64_t OpenUrlByWeChatBrowser(const std::wstring& url, int flag);
+  std::wstring GetChatRoomMemberNickname(const std::wstring& room_id,
+                                         const std::wstring& member_id);
+  int64_t DelContact(const std::wstring& wxid);
+
+  int64_t SearchContact(const std::wstring& keyword,
+                        wechat::SearchContactInner& contact);
+
+  int64_t AddFriendByWxid(const std::wstring& wxid, const std::wstring& msg);
+
+  int64_t VerifyApply(const std::wstring& v3, const std::wstring& v4,
+                      int32_t permission);
+  int64_t DoConfirmReceipt(const std::wstring& wxid,
+                           const std::wstring& transcationid,
+                           const std::wstring& transferid);
+
+  int64_t DoRefuseReceipt(const std::wstring& wxid,
+                          const std::wstring& transcationid,
+                          const std::wstring& transferid);
 
  private:
   uint64_t base_addr_;

inc/wxutils.h

@@ -5,6 +5,11 @@
 #include <string>
 namespace wxhelper {
 namespace wxutils {
+
+
+
+
+
 #ifdef _WIN64
 int64_t GetWeChatWinBase();
 #else
@@ -18,6 +23,7 @@ std::string ImageXor(std::string buf);
 std::wstring ReadWstring(INT64 addr);
 std::string ReadWstringThenConvert(INT64 addr);
 int DecodeImage(const wchar_t* file_path, const wchar_t* save_dir);
+ bool FindOrCreateDirectory(const std::wstring &path);
 }  // namespace wxutils
 
 }  // namespace wxhelper

injector.bat

@@ -0,0 +1,57 @@
+@echo off
+chcp 65001 >nul
+
+:: 检查是否以管理员权限运行
+openfiles >nul 2>&1
+if '%errorlevel%' NEQ 0 (
+    :: 检查是否已经在管理员模式下
+    if not "%1"=="elevated" (
+        echo 需要管理员权限来运行此脚本。正在以管理员权限重新启动...
+        powershell -Command "Start-Process cmd.exe -ArgumentList '/c %~f0 elevated' -Verb RunAs"
+        exit /b
+    )
+    echo 脚本已以管理员权限运行。
+)
+
+:: 获取wechat.exe的PID
+echo 正在获取wechat.exe进程的PID...
+for /f "tokens=2 delims=," %%i in ('wmic process where "name='wechat.exe'" get processid /format:csv') do (
+    set pid=%%i
+)
+
+:: 去掉PID前后的空白字符
+set pid=%pid: =%
+
+:: 打印PID到控制台
+echo 进程ID: %pid%
+
+:: 检查是否成功获取到PID
+if "%pid%"=="" (
+    echo 未找到wechat.exe进程
+    pause
+    exit /b 1
+)
+
+:: 获取当前脚本所在的目录
+set scriptdir=%~dp0
+
+:: 设置DLL的路径和injector.exe的路径
+set dllpath=%scriptdir%debug\wxhelper.dll
+set injectorpath=%scriptdir%injector.exe
+
+:: 打印DLL路径和injector.exe路径
+echo DLL路径: %dllpath%
+echo injector.exe路径: %injectorpath%
+
+:: 检查injector.exe是否存在
+if not exist "%injectorpath%" (
+    echo injector.exe 文件未找到: %injectorpath%
+    pause
+    exit /b 1
+)
+
+:: 执行injector.exe
+echo 正在执行 "%injectorpath%" -p %pid% -i %dllpath%
+"%injectorpath%" -p %pid% -i %dllpath%
+
+pause

resource.h

@@ -0,0 +1,14 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by wxhelper.rc
+
+// 新对象的下一组默认值
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1001
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

src/chat_controller.cc

@@ -5,6 +5,7 @@
 #include "spdlog/spdlog.h"
 #include "wechat_interface.h"
 #include "wechat_service.h"
+#include "utils.h"
 namespace jsonutils = wxhelper::jsonutils;
 namespace wxhelper {
 
@@ -20,6 +21,7 @@ std::string ChatController::SendTextMsg(std::string params) {
 }
 
 std::string ChatController::SendImageMsg(std::string params) {
+  SPDLOG_INFO("SendImageMsg params={}", params);
   nlohmann::json jp = nlohmann::json::parse(params);
   std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
   std::wstring image_path = jsonutils::GetWStringParam(jp, "imagePath");
@@ -30,6 +32,7 @@ std::string ChatController::SendImageMsg(std::string params) {
 }
 
 std::string ChatController::SendFileMsg(std::string params) {
+  SPDLOG_INFO("SendFileMsg params={}", params);
   nlohmann::json jp = nlohmann::json::parse(params);
   std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
   std::wstring file_path = jsonutils::GetWStringParam(jp, "filePath");
@@ -40,6 +43,7 @@ std::string ChatController::SendFileMsg(std::string params) {
 }
 
 std::string ChatController::SendAtText(std::string params) {
+  SPDLOG_INFO("SendAtText params={}", params);
   nlohmann::json jp = nlohmann::json::parse(params);
   std::wstring chat_room_id = jsonutils::GetWStringParam(jp, "chatRoomId");
   std::vector<std::wstring> wxids = jsonutils::GetArrayParam(jp, "wxids");
@@ -51,6 +55,7 @@ std::string ChatController::SendAtText(std::string params) {
 }
 
 std::string ChatController::SendMultiAtText(std::string params) {
+  SPDLOG_INFO("SendMultiAtText params={}", params);
   nlohmann::json jp = nlohmann::json::parse(params);
   nlohmann::json array = jp["at"];
   std::vector<std::pair<std::wstring, std::wstring>> at;
@@ -67,19 +72,39 @@ std::string ChatController::SendMultiAtText(std::string params) {
   return ret.dump();
 }
 
+
 std::string ChatController::SendCustomEmotion(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("SendCustomEmotion params={}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+  std::wstring file_path = jsonutils::GetWStringParam(jp, "filePath");
+  int64_t success =
+      wechat::WeChatService::GetInstance().SendCustomEmotion(file_path, wxid);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 
+TODO("")
 std::string ChatController::SendApplet(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("SendApplet params={}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+  std::wstring waid_concat = jsonutils::GetWStringParam(jp, "waidConcat");
+  std::wstring waid = jsonutils::GetWStringParam(jp, "waid");
+  std::wstring app_wxid = jsonutils::GetWStringParam(jp, "appletWxid");
+  std::wstring json_param = jsonutils::GetWStringParam(jp, "jsonParam");
+  std::wstring head_url = jsonutils::GetWStringParam(jp, "headImgUrl");
+  std::wstring main_img = jsonutils::GetWStringParam(jp, "mainImg");
+  std::wstring index_page = jsonutils::GetWStringParam(jp, "indexPage");
+  int64_t success = wechat::WeChatService::GetInstance().SendApplet(
+      wxid, waid_concat, waid, waid, app_wxid, json_param, head_url, main_img,
+      index_page);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 
 std::string ChatController::SendPatMsg(std::string params) {
+  SPDLOG_INFO("SendPatMsg params={}", params);
   nlohmann::json jp = nlohmann::json::parse(params);
   std::wstring room_id = jsonutils::GetWStringParam(jp, "receiver");
   std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
@@ -91,37 +116,55 @@ std::string ChatController::SendPatMsg(std::string params) {
 }
 
 std::string ChatController::ForwardMsg(std::string params) {
+  SPDLOG_INFO("ForwardMsg params={}", params);
   nlohmann::json jp = nlohmann::json::parse(params);
   std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
   int64_t msg_id = jsonutils::GetInt64Param(jp, "msgId");
   int64_t success =
       wechat::WeChatService::GetInstance().ForwardMsg(msg_id, wxid);
-  nlohmann::json ret = {
-      {"code", success}, {"data", {}}, {"msg", "Not Implemented"}};
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 
 std::string ChatController::ForwardPublicMsgByMsgId(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("ForwardPublicMsgByMsgId params={}", params);
+
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+  int64_t msg_id = jsonutils::GetInt64Param(jp, "msgId");
+  int64_t success =
+      wechat::WeChatService::GetInstance().ForwardPublicMsgByMsgId(wxid,
+                                                                   msg_id);
+
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 
 std::string ChatController::ForwardPublicMsg(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("ForwardPublicMsg params={}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+  std::wstring appname = jsonutils::GetWStringParam(jp, "appName");
+  std::wstring username = jsonutils::GetWStringParam(jp, "userName");
+  std::wstring title = jsonutils::GetWStringParam(jp, "title");
+  std::wstring url = jsonutils::GetWStringParam(jp, "url");
+  std::wstring thumburl = jsonutils::GetWStringParam(jp, "thumbUrl");
+  std::wstring digest = jsonutils::GetWStringParam(jp, "digest");
+  INT64 success = wechat::WeChatService::GetInstance().ForwardPublicMsg(
+      wxid, title, url, thumburl, username, appname, digest);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 
 std::string ChatController::GetContactOrChatRoomNickname(std::string params) {
+  SPDLOG_INFO("GetContactOrChatRoomNickname params={}", params);
   int64_t success = -1;
   nlohmann::json jp = nlohmann::json::parse(params);
   std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
   std::wstring nickname =
       wechat::WeChatService::GetInstance().GetContactOrChatRoomNickname(wxid);
-  nlohmann::json ret = {{"code", success},
-                        {"data", {"nickname", nickname}},
-                        {"msg", "Not Implemented"}};
+  nlohmann::json ret = {
+      {"code", success}, {"data", {"nickname", nickname}}, {"msg", "success"}};
 
   return ret.dump();
 }

src/chat_room_controller.cc

@@ -5,6 +5,7 @@
 #include "spdlog/spdlog.h"
 #include "wechat_interface.h"
 #include "wechat_service.h"
+#include "utils.h"
 namespace wxhelper {
 std::string ChatRoomController::GetChatRoomDetailInfo(std::string params) {
   nlohmann::json jp = nlohmann::json::parse(params);
@@ -31,7 +32,8 @@ std::string ChatRoomController::GetMemberFromChatRoom(std::string params) {
   wechat::ChatRoomMemberInner member;
   int64_t success = wechat::WeChatService::GetInstance().GetMemberFromChatRoom(
       room_id, member);
-  nlohmann::json ret_data = {{"code", success}, {"data", {}}, {"msg", "success"}};
+  nlohmann::json ret_data = {
+      {"code", success}, {"data", {}}, {"msg", "success"}};
   if (success > 0) {
     nlohmann::json member_info = {
         {"admin", member.admin},
@@ -56,8 +58,7 @@ std::string ChatRoomController::AddMemberToChatRoom(std::string params) {
   }
   int64_t success = wechat::WeChatService::GetInstance().AddMemberToChatRoom(
       room_id, wxid_list);
-  nlohmann::json ret = {
-      {"code", success}, {"data", {}}, {"msg", "success"}};
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string ChatRoomController::DelMemberFromChatRoom(std::string params) {
@@ -70,44 +71,80 @@ std::string ChatRoomController::DelMemberFromChatRoom(std::string params) {
   for (unsigned int i = 0; i < wxids.size(); i++) {
     wxid_list.push_back(wxids[i]);
   }
-  INT64 success = wechat::WeChatService::GetInstance().DelMemberFromChatRoom(
+  int64_t success = wechat::WeChatService::GetInstance().DelMemberFromChatRoom(
       room_id, wxid_list);
   nlohmann::json ret_data = {
       {"code", success}, {"msg", "success"}, {"data", {}}};
   return ret_data.dump();
 }
 std::string ChatRoomController::CreateChatRoom(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("CreateChatRoom params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::vector<std::wstring> wxids = jsonutils::GetArrayParam(jp, "memberIds");
+  int64_t success = wechat::WeChatService::GetInstance().CreateChatRoom(wxids);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string ChatRoomController::QuitChatRoom(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("QuitChatRoom params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring room_id = jsonutils::GetWStringParam(jp, "chatRoomId");
+  int64_t success = wechat::WeChatService::GetInstance().QuitChatRoom(room_id);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string ChatRoomController::InviteMemberToChatRoom(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("InviteMemberToChatRoom params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring room_id = jsonutils::GetWStringParam(jp, "chatRoomId");
+  std::vector<std::wstring> wxids = jsonutils::GetArrayParam(jp, "memberIds");
+  int64_t success = wechat::WeChatService::GetInstance().InviteMemberToChatRoom(
+      room_id, wxids);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string ChatRoomController::TopMsg(std::string params) {
-  return std::string();
+  SPDLOG_INFO("TopMsg params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  int64_t msg_id = jsonutils::GetInt64Param(jp, "msgId");
+  int64_t success = wechat::WeChatService::GetInstance().SetTopMsg(msg_id);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
+  return ret.dump();
 }
 std::string ChatRoomController::RemoveTopMsg(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("RemoveTopMsg params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring room_id = jsonutils::GetWStringParam(jp, "chatRoomId");
+  int64_t msg_id = jsonutils::GetInt64Param(jp, "msgId");
+  int64_t success =
+      wechat::WeChatService::GetInstance().RemoveTopMsg(room_id, msg_id);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string ChatRoomController::GetChatRoomMemberNickname(std::string params) {
+  SPDLOG_INFO("GetChatRoomMemberNickname params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring room_id = jsonutils::GetWStringParam(jp, "chatRoomId");
+  std::wstring member_id = jsonutils::GetWStringParam(jp, "memberId");
+  std::wstring name = wechat::WeChatService::GetInstance().GetChatRoomMemberNickname(room_id,
+                                                                     member_id);
   nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+      {"code", 1},
+      {"data", {{"nickname", base::utils::WstringToUtf8(name)}}},
+      {"msg", "success"}};
   return ret.dump();
 }
 std::string ChatRoomController::ModifyChatRoomMemberNickName(
     std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("ModifyChatRoomMemberNickName params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring room_id = jsonutils::GetWStringParam(jp, "chatRoomId");
+  std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+  std::wstring nickName = jsonutils::GetWStringParam(jp, "nickName");
+  int64_t success =
+      wechat::WeChatService::GetInstance().ModChatRoomMemberNickName(
+          room_id, wxid, nickName);
+  nlohmann::json ret = {{"code", success}, {"msg", "success"}, {"data", {}}};
   return ret.dump();
 }
 }  // namespace wxhelper

src/contacts_controller.cc

@@ -1,13 +1,14 @@
 #include "contacts_controller.h"
 
+#include "json_utils.h"
 #include "nlohmann/json.hpp"
 #include "spdlog/spdlog.h"
 #include "wechat_interface.h"
-#include "json_utils.h"
 #include "wechat_service.h"
 namespace jsonutils = wxhelper::jsonutils;
-
-std::string wxhelper::ContactsController::GetContactList(std::string params) {
+namespace wxhelper {
+std::string ContactsController::GetContactList(std::string params) {
+  SPDLOG_INFO("GetContactList params:{}", params);
   std::vector<wechat::ContactInner> vec;
   int64_t success = wechat::WeChatService::GetInstance().GetContacts(vec);
   nlohmann::json ret_data = {
@@ -34,33 +35,83 @@ std::string wxhelper::ContactsController::GetContactList(std::string params) {
   return ret_data.dump();
 }
 
-std::string wxhelper::ContactsController::GetContactProfile(
+std::string ContactsController::GetContactProfile(
     std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("GetContactProfile params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+  wechat::ContactProfileInner profile;
+  int64_t success =
+      wechat::WeChatService::GetInstance().GetContactByWxid(wxid, profile);
+  nlohmann::json ret = {{"code", success}, {"msg", "success"}, {"data", {}}};
+  if (success == 1) {
+    nlohmann::json contact_profile = {
+        {"account", profile.account},   {"headImage", profile.head_image},
+        {"nickname", profile.nickname}, {"v3", profile.v3},
+        {"wxid", profile.wxid},
+    };
+    ret["data"] = contact_profile;
+  }
+
   return ret.dump();
 }
 
-std::string wxhelper::ContactsController::DelContact(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+std::string ContactsController::DelContact(std::string params) {
+  SPDLOG_INFO("DelContact params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+  int64_t success = wechat::WeChatService::GetInstance().DelContact(wxid);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 
-std::string wxhelper::ContactsController::SearchContact(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+std::string ContactsController::SearchContact(std::string params) {
+  SPDLOG_INFO("SearchContact params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring keyword = jsonutils::GetWStringParam(jp, "keyword");
+  wechat::SearchContactInner contact;
+  int64_t success =
+      wechat::WeChatService::GetInstance().SearchContact(keyword, contact);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
+  if (success == 1) {
+    nlohmann::json info = {
+        {"bigImage", contact.big_image},
+        {"smallImage", contact.small_image},
+        {"city", contact.city},
+        {"nation", contact.nation},
+        {"nickname", contact.nickname},
+        {"province", contact.province},
+        {"sex", contact.sex},
+        {"signature", contact.signature},
+        {"v2", contact.v2},
+        {"v3", contact.v3},
+    };
+    ret["data"] = info;
+  }
+
   return ret.dump();
 }
 
-std::string wxhelper::ContactsController::AddContact(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+std::string ContactsController::AddContact(std::string params) {
+  SPDLOG_INFO("AddContact params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+  std::wstring msg = jsonutils::GetWStringParam(jp, "msg");
+  int64_t success =
+      wechat::WeChatService::GetInstance().AddFriendByWxid(wxid, msg);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 
-std::string wxhelper::ContactsController::VerifyApply(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+std::string ContactsController::VerifyApply(std::string params) {
+  SPDLOG_INFO("VerifyApply params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring v3 = jsonutils::GetWStringParam(jp, "v3");
+  std::wstring v4 = jsonutils::GetWStringParam(jp, "v4");
+  int32_t permission = jsonutils::GetIntParam(jp, "permission");
+  int64_t success =
+      wechat::WeChatService::GetInstance().VerifyApply(v3, v4, permission);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
+}

src/misc_controller.cc

@@ -1,5 +1,6 @@
 #include "misc_controller.h"
-
+#include <locale> 
+#include <codecvt> 
 #include "json_utils.h"
 #include "nlohmann/json.hpp"
 #include "spdlog/spdlog.h"
@@ -38,38 +39,65 @@ std::string MiscController::GetUserInfo(std::string params) {
   return ret.dump();
 }
 std::string MiscController::GetSNSFirstPage(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  int64_t success = wechat::WeChatService::GetInstance().GetSNSFirstPage();
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string MiscController::GetSNSNextPage(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("GetSNSNextPage params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  int64_t sns_id = jsonutils::GetInt64Param(jp, "snsId");
+  int64_t success = wechat::WeChatService::GetInstance().GetSNSNextPage(sns_id);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string MiscController::AddFavFromMsg(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("AddFavFromMsg params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  int64_t sns_id = jsonutils::GetInt64Param(jp, "msgId");
+  int64_t success = wechat::WeChatService::GetInstance().AddFavFromMsg(sns_id);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string MiscController::AddFavFromImage(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("AddFavFromImage params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+  std::wstring image_path = jsonutils::GetWStringParam(jp, "imagePath");
+  int64_t success =
+      wechat::WeChatService::GetInstance().AddFavFromImage(wxid, image_path);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string MiscController::DecodeImage(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("DecodeImage params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring file_path = jsonutils::GetWStringParam(jp, "filePath");
+  std::wstring store_dir = jsonutils::GetWStringParam(jp, "storeDir");
+  int64_t success =
+      wechat::WeChatService::GetInstance().DecodeImage(file_path, store_dir);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string MiscController::GetVoiceByMsgId(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("GetVoiceByMsgId params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  int64_t msg_id = jsonutils::GetInt64Param(jp, "msgId");
+  std::wstring store_dir = jsonutils::GetWStringParam(jp, "storeDir");
+  int64_t success =
+      wechat::WeChatService::GetInstance().GetVoiceByDB(msg_id, store_dir);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string MiscController::DoOcrTask(std::string params) {
+  SPDLOG_INFO("DoOcrTask params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring image_path = jsonutils::GetWStringParam(jp, "imagePath");
+  std::string text("");
+  int64_t success =
+      wechat::WeChatService::GetInstance().DoOCRTask(image_path, text);
   nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+      {"code", success}, {"data", {{"content", text}}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string MiscController::LockWeChat(std::string params) {
@@ -94,6 +122,7 @@ std::string MiscController::GetLoginUrl(std::string params) {
   return ret.dump();
 }
 std::string MiscController::TranslateVoice(std::string params) {
+  SPDLOG_INFO("TranslateVoice params:{}", params);
   nlohmann::json jp = nlohmann::json::parse(params);
   int64_t msg_id = jsonutils::GetInt64Param(jp, "msgId");
   int64_t success = wechat::WeChatService::GetInstance().TranslateVoice(msg_id);
@@ -110,23 +139,59 @@ std::string MiscController::GetTranslateVoiceText(std::string params) {
   return ret_data.dump();
 }
 std::string MiscController::OpenUrlByWeChat(std::string params) {
+  SPDLOG_INFO("OpenUrlByWeChat params:{}", params);
   nlohmann::json jp = nlohmann::json::parse(params);
   std::wstring url = jsonutils::GetWStringParam(jp, "url");
   int flag = jsonutils::GetIntParam(jp, "flag");
   int64_t success =
       wechat::WeChatService::GetInstance().OpenUrlByWeChatBrowser(url, flag);
-  nlohmann::json ret = {
-      {"code", success}, {"data", {}}, {"msg", "Not Implemented"}};
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
 std::string MiscController::ConfirmReceipt(std::string params) {
-  nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+  SPDLOG_INFO("ConfirmReceipt params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+  std::wstring transcationid = jsonutils::GetWStringParam(jp, "transcationId");
+  std::wstring transferid = jsonutils::GetWStringParam(jp, "transferId");
+  int64_t success = wechat::WeChatService::GetInstance().DoConfirmReceipt(
+      wxid, transcationid, transferid);
+  nlohmann::json ret = {{"code", success}, {"data", {}}, {"msg", "success"}};
   return ret.dump();
 }
+std::string MiscController::RefundReceipt(std::string params)
+{
+    SPDLOG_INFO("RefuseReceipt params:{}", params);
+    nlohmann::json jp = nlohmann::json::parse(params);
+    std::wstring wxid = jsonutils::GetWStringParam(jp, "wxid");
+    std::wstring transcationid = jsonutils::GetWStringParam(jp, "transcationId");
+    std::wstring transferid = jsonutils::GetWStringParam(jp, "transferId");
+    int64_t success = wechat::WeChatService::GetInstance().DoRefuseReceipt(
+        wxid, transcationid, transferid);
+    nlohmann::json ret = { {"code", success}, {"data", {}}, {"msg", "success"} };
+    return ret.dump();
+}
+
 std::string MiscController::DownloadAttach(std::string params) {
+  SPDLOG_INFO("DownloadAttach params:{}", params);
+  nlohmann::json jp = nlohmann::json::parse(params);
+  int64_t msg_id = jsonutils::GetInt64Param(jp, "msgId");
+  std::wstring result = wechat::WeChatService::GetInstance().DoDownloadTask(msg_id);
+  std::string result_str = std::wstring_convert<std::codecvt_utf8<wchar_t>>().to_bytes(result);
   nlohmann::json ret = {
-      {"code", 200}, {"data", {}}, {"msg", "Not Implemented"}};
+      {"code", 1}, {"data", {"result", result_str}}, {"msg", "success"} };
   return ret.dump();
 }
+std::string MiscController::VerifyApply(std::string params)
+{
+    SPDLOG_INFO("verifyApply params:{}", params);
+    nlohmann::json jp = nlohmann::json::parse(params);
+    int32_t permission = jsonutils::GetIntParam(jp, "permission");
+    std::wstring v3 = jsonutils::GetWStringParam(jp, "v3");
+    std::wstring v4 = jsonutils::GetWStringParam(jp, "v4");
+    int64_t success = wechat::WeChatService::GetInstance().VerifyApply(v3, v4, permission);
+    nlohmann::json ret = { {"code", success}, {"data", {}}, {"msg", "success"} };
+    return ret.dump();
+}
+
 }  // namespace wxhelper

src/wechat_service.cc

@@ -7,6 +7,20 @@
 #include "utils.h"
 #include "wechat_db.h"
 #include "wxutils.h"
+
+#define BUFSIZE 1024
+#define JPEG0 0xFF
+#define JPEG1 0xD8
+#define JPEG2 0xFF
+#define PNG0 0x89
+#define PNG1 0x50
+#define PNG2 0x4E
+#define BMP0 0x42
+#define BMP1 0x4D
+#define GIF0 0x47
+#define GIF1 0x49
+#define GIF2 0x46
+
 namespace offset = wechat::offset;
 namespace prototype = wechat::prototype;
 namespace func = wechat::function;
@@ -269,7 +283,7 @@ int64_t wechat::WeChatService::SendImageMsg(const std::wstring& wxid,
   uint64_t temp2 = 0;
   uint64_t temp3 = 1;
   uint64_t* flag[10] = {};
-  flag[0] =  reinterpret_cast<uint64_t*>(temp3);
+  flag[0] = reinterpret_cast<uint64_t*>(temp3);
   flag[8] = &temp1;
   flag[9] = &temp2;
   flag[1] = reinterpret_cast<uint64_t*>(p_chat_msg_temp);
@@ -385,26 +399,32 @@ int64_t wechat::WeChatService::GetContacts(std::vector<ContactInner>& vec) {
 
 int64_t wechat::WeChatService::GetChatRoomDetailInfo(
     const std::wstring& room_id, ChatRoomInfoInner& room_info) {
-   int64_t success = -1;
+  int64_t success = -1;
   prototype::WeChatString chat_room_id(room_id);
   int64_t base_addr = wxutils::GetWeChatWinBase();
   uint64_t get_chat_room_mgr_addr = base_addr + offset::kChatRoomMgr;
-  uint64_t get_chat_room_detail_addr = base_addr + offset::kGetChatRoomDetailInfo;
+  uint64_t get_chat_room_detail_addr =
+      base_addr + offset::kGetChatRoomDetailInfo;
   uint64_t create_chat_room_info_addr = base_addr + offset::kNewChatRoomInfo;
   uint64_t free_chat_room_info_addr = base_addr + offset::kFreeChatRoomInfo;
 
-
-  func::__GetChatRoomMgr get_chat_room_mgr = (func::__GetChatRoomMgr)get_chat_room_mgr_addr;
-  func::__NewChatRoomInfo new_chat_room_info = (func::__NewChatRoomInfo)create_chat_room_info_addr;
-  func::__FreeChatRoomInfo free_chat_room_info = (func::__FreeChatRoomInfo)free_chat_room_info_addr;
-  func::__GetChatRoomDetailInfo get_chat_room_detail = (func::__GetChatRoomDetailInfo)get_chat_room_detail_addr;
+  func::__GetChatRoomMgr get_chat_room_mgr =
+      (func::__GetChatRoomMgr)get_chat_room_mgr_addr;
+  func::__NewChatRoomInfo new_chat_room_info =
+      (func::__NewChatRoomInfo)create_chat_room_info_addr;
+  func::__FreeChatRoomInfo free_chat_room_info =
+      (func::__FreeChatRoomInfo)free_chat_room_info_addr;
+  func::__GetChatRoomDetailInfo get_chat_room_detail =
+      (func::__GetChatRoomDetailInfo)get_chat_room_detail_addr;
 
   char chat_room_info[0x144] = {0};
 
-  uint64_t new_room_info = new_chat_room_info(reinterpret_cast<uint64_t>(&chat_room_info));
+  uint64_t new_room_info =
+      new_chat_room_info(reinterpret_cast<uint64_t>(&chat_room_info));
 
   uint64_t mgr = get_chat_room_mgr();
-  success = get_chat_room_detail(mgr,reinterpret_cast<uint64_t>(&chat_room_id),new_room_info,1);
+  success = get_chat_room_detail(mgr, reinterpret_cast<uint64_t>(&chat_room_id),
+                                 new_room_info, 1);
 
   room_info.chat_room_id = wxutils::ReadWstringThenConvert(new_room_info + 0x8);
   room_info.notice = wxutils::ReadWstringThenConvert(new_room_info + 0x28);
@@ -425,10 +445,10 @@ int64_t wechat::WeChatService::AddMemberToChatRoom(
   func::__DoAddMemberToChatRoom add_members =
       (func::__DoAddMemberToChatRoom)add_members_addr;
 
-  prototype::WeChatString *chat_room_id = (prototype::WeChatString *)HeapAlloc(
+  prototype::WeChatString* chat_room_id = (prototype::WeChatString*)HeapAlloc(
       GetProcessHeap(), 0, sizeof(prototype::WeChatString));
-  wchar_t *p_chat_room_id =
-      (wchar_t *)HeapAlloc(GetProcessHeap(), 0, (room_id.size() + 1) * 2);
+  wchar_t* p_chat_room_id =
+      (wchar_t*)HeapAlloc(GetProcessHeap(), 0, (room_id.size() + 1) * 2);
   wmemcpy(p_chat_room_id, room_id.c_str(), room_id.size() + 1);
   chat_room_id->ptr = p_chat_room_id;
   chat_room_id->length = static_cast<int32_t>(room_id.size());
@@ -438,7 +458,7 @@ int64_t wechat::WeChatService::AddMemberToChatRoom(
 
   std::vector<prototype::WeChatString> member_list;
   uint64_t temp[2] = {0};
-  wechat::VectorInner *list = (wechat::VectorInner *)&member_list;
+  wechat::VectorInner* list = (wechat::VectorInner*)&member_list;
   int64_t members_ptr = (int64_t)&list->start;
   for (int i = 0; i < members.size(); i++) {
     prototype::WeChatString member(members[i]);
@@ -454,7 +474,18 @@ int64_t wechat::WeChatService::AddMemberToChatRoom(
 int64_t wechat::WeChatService::ModChatRoomMemberNickName(
     const std::wstring& room_id, const std::wstring& wxid,
     const std::wstring& nickname) {
-  return 0;
+  int64_t success = -1;
+  uint64_t mod_addr = base_addr_ + offset::kDoModChatRoomMemberNickName;
+  func::__DoModChatRoomMemberNickName modify =
+      (func::__DoModChatRoomMemberNickName)mod_addr;
+  const wchar_t* p = room_id.c_str();
+  prototype::WeChatString* chat_room_id = BuildWechatString(room_id);
+  prototype::WeChatString* self_id = BuildWechatString(wxid);
+  prototype::WeChatString* name = BuildWechatString(nickname);
+  success = modify(
+      reinterpret_cast<UINT64>(p), reinterpret_cast<UINT64>(chat_room_id),
+      reinterpret_cast<UINT64>(self_id), reinterpret_cast<UINT64>(name));
+  return success;
 }
 
 int64_t wechat::WeChatService::DelMemberFromChatRoom(
@@ -499,7 +530,7 @@ int64_t wechat::WeChatService::GetMemberFromChatRoom(
 
   prototype::WeChatString chat_room_id(room_id);
   char chat_room_info[0x308] = {0};
-  uint64_t addr =  new_chat_room(reinterpret_cast<uint64_t>(&chat_room_info));
+  uint64_t addr = new_chat_room(reinterpret_cast<uint64_t>(&chat_room_info));
   uint64_t mgr = get_chat_room_mgr();
   success = get_members(mgr, reinterpret_cast<uint64_t>(&chat_room_id), addr);
   member.chat_room_id = wxutils::ReadWstringThenConvert(addr + 0x10);
@@ -511,25 +542,96 @@ int64_t wechat::WeChatService::GetMemberFromChatRoom(
   return success;
 }
 
-int64_t wechat::WeChatService::SetTopMsg(uint64_t msg_id) { return 0; }
+int64_t wechat::WeChatService::SetTopMsg(uint64_t msg_id) {
+  int64_t success = -1;
+  uint64_t top_addr = base_addr_ + offset::kTopMsg;
+  func::__DoTopMsg top_msg = (func::__DoTopMsg)top_addr;
+  int64_t index = 0;
+  int64_t local_id =
+      wechat::WeChatDb::GetInstance().GetLocalIdByMsgId(msg_id, index);
+  if (local_id <= 0 || index >> 32 == 0) {
+    success = -2;
+    return success;
+  }
+  LARGE_INTEGER l;
+  l.HighPart = index >> 32;
+  l.LowPart = (DWORD)local_id;
+  uint64_t ptr = reinterpret_cast<uint64_t>(&l);
+  success = top_msg(ptr, 1);
+
+  return success;
+}
 
 int64_t wechat::WeChatService::RemoveTopMsg(const std::wstring& room_id,
-                                            ULONG64 msg_id) {
-  return 0;
+                                            uint64_t msg_id) {
+  int64_t success = -1;
+  uint64_t remove_addr = base_addr_ + offset::kRemoveTopMsg;
+  func::__RemoveTopMsg remove_top_msg = (func::__RemoveTopMsg)remove_addr;
+  prototype::WeChatString* chat_room_id = BuildWechatString(room_id);
+  const wchar_t* w_room = room_id.c_str();
+  success = remove_top_msg(reinterpret_cast<UINT64>(w_room), msg_id,
+                           reinterpret_cast<UINT64>(chat_room_id));
+  return success;
 }
-
+TODO("InviteMemberToChatRoom")
 int64_t wechat::WeChatService::InviteMemberToChatRoom(
     const std::wstring& room_id, const std::vector<std::wstring>& wxids) {
-  return 0;
+  int64_t success = -1;
+  uint64_t invite_addr = base_addr_ + offset::kInviteMember;
+  func::__InviteMemberToChatRoom invite =
+      (func::__InviteMemberToChatRoom)invite_addr;
+  const wchar_t* w_room = room_id.c_str();
+  prototype::WeChatString* chat_room_id = BuildWechatString(room_id);
+  std::vector<prototype::WeChatString> wxid_list;
+  wechat::VectorInner* list = (wechat::VectorInner*)&wxid_list;
+  int64_t head = (int64_t)&list->start;
+  for (int i = 0; i < wxids.size(); i++) {
+    prototype::WeChatString id(wxids[i]);
+    wxid_list.push_back(id);
+  }
+  uint64_t temp[2] = {0};
+  success = invite(reinterpret_cast<uint64_t>(w_room), head,
+                   reinterpret_cast<uint64_t>(chat_room_id),
+                   reinterpret_cast<uint64_t>(&temp));
+  return success;
 }
 
+TODO("CreateChatRoom")
 int64_t wechat::WeChatService::CreateChatRoom(
     const std::vector<std::wstring>& wxids) {
-  return 0;
+  int64_t success = -1;
+  uint64_t get_chat_room_mgr_addr = base_addr_ + offset::kChatRoomMgr;
+  uint64_t create_chat_room_addr = base_addr_ + offset::kCreateChatRoom;
+  func::__GetChatRoomMgr get_chat_room_mgr =
+      (func::__GetChatRoomMgr)get_chat_room_mgr_addr;
+  func::__CreateChatRoom create_chat_room =
+      (func::__CreateChatRoom)create_chat_room_addr;
+  std::vector<prototype::WeChatString> wxid_list;
+  wechat::VectorInner* list = (wechat::VectorInner*)&wxid_list;
+  int64_t head = (int64_t)&list->start;
+  for (int i = 0; i < wxids.size(); i++) {
+    prototype::WeChatString id(wxids[i]);
+    wxid_list.push_back(id);
+  }
+  int64_t end = list->end;
+  uint64_t mgr = get_chat_room_mgr();
+  success = create_chat_room(mgr, head, end);
+  return success;
 }
 
+TODO("QuitChatRoom")
 int64_t wechat::WeChatService::QuitChatRoom(const std::wstring& room_id) {
-  return 0;
+  int64_t success = -1;
+  uint64_t get_chat_room_mgr_addr = base_addr_ + offset::kChatRoomMgr;
+  uint64_t quit_chat_room_addr = base_addr_ + offset::kQuitChatRoom;
+  func::__GetChatRoomMgr get_chat_room_mgr =
+      (func::__GetChatRoomMgr)get_chat_room_mgr_addr;
+  func::__QuitChatRoom quit_chat_room =
+      (func::__QuitChatRoom)quit_chat_room_addr;
+  uint64_t mgr = get_chat_room_mgr();
+  prototype::WeChatString chat_room_id(room_id);
+  success = quit_chat_room(mgr, reinterpret_cast<uint64_t>(&chat_room_id), 0);
+  return success;
 }
 
 int64_t wechat::WeChatService::ForwardMsg(uint64_t msg_id,
@@ -553,17 +655,91 @@ int64_t wechat::WeChatService::ForwardMsg(uint64_t msg_id,
   return success;
 }
 
-int64_t wechat::WeChatService::GetSNSFirstPage() { return 0; }
+TODO("GetSNSFirstPage")
+int64_t wechat::WeChatService::GetSNSFirstPage() {
+  int64_t success = -1;
+  uint64_t sns_data_mgr_addr = base_addr_ + offset::kSNSDataMgr;
+  uint64_t sns_first_page_addr = base_addr_ + offset::kSNSGetFirstPage;
+  func::__GetSNSDataMgr sns_data_mgr = (func::__GetSNSDataMgr)sns_data_mgr_addr;
+  func::__GetSNSFirstPage sns_first_page =
+      (func::__GetSNSFirstPage)sns_first_page_addr;
+  uint64_t mgr = sns_data_mgr();
+  int64_t buff[16] = {0};
+  success = sns_first_page(mgr, reinterpret_cast<uint64_t>(&buff), 1);
+  return success;
+}
 
-int64_t wechat::WeChatService::GetSNSNextPage(uint64_t sns_id) { return 0; }
+TODO("GetSNSNextPage")
+int64_t wechat::WeChatService::GetSNSNextPage(uint64_t sns_id) {
+  int64_t success = -1;
+  uint64_t time_line_mgr_addr = base_addr_ + offset::kSNSTimeLineMgr;
+  uint64_t sns_next_page_addr = base_addr_ + offset::kSNSGetNextPageScene;
+  func::__GetSnsTimeLineMgr time_line_mgr =
+      (func::__GetSnsTimeLineMgr)time_line_mgr_addr;
+  func::__GetSNSNextPageScene sns_next_page =
+      (func::__GetSNSNextPageScene)sns_next_page_addr;
+  uint64_t mgr = time_line_mgr();
+  success = sns_next_page(mgr, sns_id);
+  return success;
+}
+
+
+int64_t wechat::WeChatService::AddFavFromMsg(uint64_t msg_id) {
+  int64_t success = -1;
+  uint64_t get_chat_mgr_addr = base_addr_ + offset::kGetChatMgr;
+  uint64_t get_by_local_id_addr = base_addr_ + offset::kGetMgrByPrefixLocalId;
+  uint64_t add_fav_addr = base_addr_ + offset::kAddFavFromMsg;
+  uint64_t get_favorite_mgr_addr = base_addr_ + offset::kGetFavoriteMgr;
+  uint64_t free_chat_msg_addr = base_addr_ + offset::kFreeChatMsg;
+  func::__GetMgrByPrefixLocalId get_by_local_id =
+      (func::__GetMgrByPrefixLocalId)get_by_local_id_addr;
+  uint64_t new_chat_msg_addr = base_addr_ + offset::kChatMsgInstanceCounter;
+
+  func::__AddFavFromMsg add_fav = (func::__AddFavFromMsg)add_fav_addr;
+  func::__GetChatMgr get_chat_mgr = (func::__GetChatMgr)get_chat_mgr_addr;
+  func::__GetFavoriteMgr get_favorite_mgr =
+      (func::__GetFavoriteMgr)get_favorite_mgr_addr;
+  func::__FreeChatMsg free_chat_msg = (func::__FreeChatMsg)free_chat_msg_addr;
+  func::__NewChatMsg new_chat_msg = (func::__NewChatMsg)new_chat_msg_addr;
+
+  int64_t index = 0;
+  int64_t local_id =
+      wechat::WeChatDb::GetInstance().GetLocalIdByMsgId(msg_id, index);
+  if (local_id <= 0 || index >> 32 == 0) {
+    success = -2;
+    return success;
+  }
+  char chat_msg[0x460] = {0};
+  LARGE_INTEGER l;
+  l.HighPart = index >> 32;
+  l.LowPart = (DWORD)local_id;
+  uint64_t p_chat_msg = new_chat_msg(reinterpret_cast<uint64_t>(&chat_msg));
+
+  get_chat_mgr();
+  get_by_local_id(l.QuadPart, p_chat_msg);
+  uint64_t mgr = get_favorite_mgr();
+  success = add_fav(mgr, p_chat_msg);
+  free_chat_msg(p_chat_msg);
+  return success;
+}
 
-int64_t wechat::WeChatService::AddFavFromMsg(uint64_t msg_id) { return 0; }
 
 int64_t wechat::WeChatService::AddFavFromImage(const std::wstring& wxid,
                                                const std::wstring& image_path) {
-  return 0;
+  int64_t success = -1;
+  uint64_t get_favorite_mgr_addr = base_addr_ + offset::kGetFavoriteMgr;
+  uint64_t add_fav_from_image_addr = base_addr_ + offset::kAddFavFromImage;
+  prototype::WeChatString* send_id = BuildWechatString(wxid);
+  prototype::WeChatString* path = BuildWechatString(image_path);
+  func::__GetFavoriteMgr get_favorite_mgr =
+      (func::__GetFavoriteMgr)get_favorite_mgr_addr;
+  func::__AddFavFromImage add_fav_from_image =
+      (func::__AddFavFromImage)add_fav_from_image_addr;
+  uint64_t mgr = get_favorite_mgr();
+  success = add_fav_from_image(mgr, reinterpret_cast<uint64_t>(path),
+                               reinterpret_cast<uint64_t>(send_id));
+  return success;
 }
-
 int64_t wechat::WeChatService::SendAtText(
     const std::wstring& room_id, const std::vector<std::wstring>& wxids,
     const std::wstring& msg) {
@@ -578,7 +754,7 @@ int64_t wechat::WeChatService::SendAtText(
     if (at_all.compare(wxids[i]) == 0) {
       nickname = L"\u6240\u6709\u4eba";
     } else {
-      // nickname = GetContactOrChatRoomNickname(wxids[i]);
+      nickname = GetContactOrChatRoomNickname(wxids[i]);
     }
     if (nickname.length() == 0) {
       continue;
@@ -612,7 +788,7 @@ int64_t wechat::WeChatService::SendAtText(
   free(reinterpret_cast<uint64_t>(&chat_msg));
   return 0;
 }
-
+TODO("GetContactOrChatRoomNickname")
 std::wstring wechat::WeChatService::GetContactOrChatRoomNickname(
     const std::wstring& wxid) {
   int64_t success = -1;
@@ -641,13 +817,176 @@ std::wstring wechat::WeChatService::GetContactOrChatRoomNickname(
   }
 }
 
+
 int64_t wechat::WeChatService::GetContactByWxid(const std::wstring& wxid,
                                                 ContactProfileInner& profile) {
-  return 0;
+  int64_t success = -1;
+  prototype::WeChatString to_user(wxid);
+  uint64_t get_contact_mgr_addr = base_addr_ + offset::kGetContactMgr;
+  uint64_t new_contact_addr = base_addr_ + offset::kNewContact;
+  uint64_t get_contact_addr = base_addr_ + offset::kGetContact;
+  uint64_t free_contact_addr = base_addr_ + offset::kFreeContact;
+  func::__GetContactMgr get_contact_mgr =
+      (func::__GetContactMgr)get_contact_mgr_addr;
+  func::__GetContact get_contact = (func::__GetContact)get_contact_addr;
+  func::__NewContact new_contact = (func::__NewContact)new_contact_addr;
+  func::__FreeContact free_contact = (func::__FreeContact)free_contact_addr;
+  char buff[0x6A9] = {0};
+  uint64_t contact = new_contact(reinterpret_cast<uint64_t>(&buff));
+  uint64_t mgr = get_contact_mgr();
+  success = get_contact(mgr, reinterpret_cast<uint64_t>(&to_user), contact);
+  profile.wxid = wxutils::ReadWstringThenConvert(contact + 0x10);
+  profile.account = wxutils::ReadWstringThenConvert(contact + 0x30);
+  profile.v3 = wxutils::ReadWstringThenConvert(contact + 0x50);
+  profile.nickname = wxutils::ReadWstringThenConvert(contact + 0xA0);
+  profile.head_image = wxutils::ReadWstringThenConvert(contact + 0x188);
+  free_contact(contact);
+  return success;
 }
 
-int64_t wechat::WeChatService::DoDownloadTask(uint64_t msg_id) { return 0; }
+std::wstring combineAndRemoveDuplicate(const std::wstring& basePath, const std::wstring& resultPath) {
+    std::wstring cleanedBasePath = basePath;
+    if (cleanedBasePath.back() == L'\\') {
+        cleanedBasePath.pop_back();
+    }
+    size_t pos = resultPath.find(cleanedBasePath);
+    if (pos != std::wstring::npos) {
+        std::wstring adjustedResultPath = resultPath.substr(pos + cleanedBasePath.length());
+        return cleanedBasePath + L'\\' + adjustedResultPath;
+    }
 
+    return basePath + L'\\' + resultPath;
+}
+TODO("DoDownloadTask")
+
+std::wstring wechat::WeChatService::DoDownloadTask(uint64_t msg_id) {
+
+  uint64_t get_by_local_id_addr = base_addr_ + offset::kGetMgrByPrefixLocalId;
+  func::__GetMgrByPrefixLocalId get_by_local_id =
+      (func::__GetMgrByPrefixLocalId)get_by_local_id_addr;
+
+  uint64_t get_chat_mgr_addr = base_addr_ + offset::kGetChatMgr;
+  func::__GetChatMgr get_chat_mgr = (func::__GetChatMgr)get_chat_mgr_addr;
+
+  uint64_t free_chat_msg_addr = base_addr_ + offset::kFreeChatMsg;
+  func::__FreeChatMsg free_chat_msg = (func::__FreeChatMsg)free_chat_msg_addr;
+
+  uint64_t new_chat_msg_addr = base_addr_ + offset::kChatMsgInstanceCounter;
+  func::__NewChatMsg new_chat_msg = (func::__NewChatMsg)new_chat_msg_addr;
+
+  uint64_t get_current_data_path_addr =
+      base_addr_ + offset::kGetCurrentDataPath;
+  func::__GetCurrentDataPath GetCurrentDataPath =
+      (func::__GetCurrentDataPath)get_current_data_path_addr;
+
+  uint64_t new_app_msg_info_addr = base_addr_ + offset::kNewAppMsgInfo;
+  func::__NewAppMsgInfo new_app_msg_info =
+      (func::__NewAppMsgInfo)new_app_msg_info_addr;
+
+  uint64_t free_app_msg_info_addr = base_addr_ + offset::kFreeAppMsgInfo;
+  func::__FreeAppMsgInfo free_app_msg_info =
+      (func::__NewAppMsgInfo)free_app_msg_info_addr;
+
+  uint64_t xml_to_app_info_addr = base_addr_ + offset::kParseAppMsgXml;
+  func::__ParseAppMsgXml xml_to_app_info =
+      (func::__ParseAppMsgXml)xml_to_app_info_addr;
+
+  uint64_t get_pre_download_mgr_addr = base_addr_ + offset::kGetPreDownLoadMgr;
+  func::__GetPreDownLoadMgr get_pre_download_mgr =
+      (func::__GetPreDownLoadMgr)get_pre_download_mgr_addr;
+
+  uint64_t push_attach_task_addr = base_addr_ + offset::kPushAttachTask;
+  func::__PushAttachTask push_attach_task =
+      (func::__PushAttachTask)push_attach_task_addr;
+
+  int64_t index = 0;
+  int64_t local_id =
+      wechat::WeChatDb::GetInstance().GetLocalIdByMsgId(msg_id, index);
+  if (local_id <= 0 || index >> 32 == 0) {
+    return L"-2";
+  }
+  char* chat_msg = base::utils::WxHeapAlloc<char>(0x460);
+  LARGE_INTEGER l;
+  l.HighPart = index >> 32;
+  l.LowPart = (DWORD)local_id;
+  uint64_t p_chat_msg = new_chat_msg(reinterpret_cast<uint64_t>(chat_msg));
+
+  get_chat_mgr();
+  get_by_local_id(l.QuadPart, p_chat_msg);
+
+  std::wstring save_path = L"";
+  std::wstring thumb_path = L"";
+
+  prototype::WeChatString current_data_path;
+  GetCurrentDataPath(reinterpret_cast<ULONG_PTR>(&current_data_path));
+
+  if (current_data_path.length > 0) {
+    save_path += current_data_path.ptr;
+  } else {
+    return L"-1";
+  }
+
+   int64_t type = *(int64_t*)(chat_msg + 0x38);
+  wchar_t* content = *(wchar_t**)(chat_msg + 0x88);
+  DWORD len = *(DWORD*)(chat_msg + 0x94);
+  std::wstring tmp_content(content, len);
+  prototype::WeChatString* we_content = BuildWechatString(tmp_content);
+
+  switch (type) {
+  case 0x3: {   
+      if (!save_path.empty() && save_path.back() == L'\\') {
+          save_path.pop_back();
+      }
+      size_t pos = save_path.find_last_of(L'\\');
+      if (pos != std::wstring::npos) {
+          save_path = save_path.substr(0, pos + 1); 
+      }
+      break;
+  }
+  case 0x3E:
+  case 0x2B: {
+      save_path += L"\\video";
+      if (!wxutils::FindOrCreateDirectory(save_path)) {
+          return L"-3" ;
+      }
+      thumb_path = save_path + L"\\" + std::to_wstring(msg_id) + L".jpg";
+      save_path = save_path + L"\\" + std::to_wstring(msg_id) + L".mp4";
+
+      break;
+  }
+  case 0x31: {
+      save_path += L"\\file";
+      if (!wxutils::FindOrCreateDirectory(save_path)) {
+          return L"-3";
+      }
+      char* p_xml_app_msg = base::utils::WxHeapAlloc<char>(0x3000);
+      uint64_t xml_msg =
+          new_app_msg_info(reinterpret_cast<uint64_t>(p_xml_app_msg));
+      uint64_t result =
+          xml_to_app_info(xml_msg, reinterpret_cast<uint64_t>(we_content), 1);
+      if (result != 1) {
+          return L"-4";
+      }
+      std::wstring file_name = wxutils::ReadWstring(xml_msg + 0x70);
+      save_path =
+          save_path + L"\\" + std::to_wstring(msg_id) + L"_" + file_name;
+      free_app_msg_info(xml_msg);
+      break;
+  }
+  default:
+      break;
+  }
+
+  int temp = 1;
+  memcpy(chat_msg + 0x40C, &temp, sizeof(temp));
+  UINT64 mgr = get_pre_download_mgr();
+  INT64 success = push_attach_task(mgr, p_chat_msg, 0, 1);  
+  std::wstring result = *(wchar_t**)(chat_msg + 0x2A0);
+  free_chat_msg(p_chat_msg);
+  return save_path + result;
+}
+
+TODO("ForwardPublicMsg")
 int64_t wechat::WeChatService::ForwardPublicMsg(const std::wstring& wxid,
                                                 const std::wstring& title,
                                                 const std::wstring& url,
@@ -658,33 +997,218 @@ int64_t wechat::WeChatService::ForwardPublicMsg(const std::wstring& wxid,
   return 0;
 }
 
+TODO("ForwardPublicMsgByMsgId")
 int64_t wechat::WeChatService::ForwardPublicMsgByMsgId(const std::wstring& wxid,
                                                        uint64_t msg_id) {
   return 0;
 }
-
+TODO("DecodeImage")
 int64_t wechat::WeChatService::DecodeImage(const std::wstring& file_path,
                                            const std::wstring& save_dir) {
-  return 0;
-}
+  if (!wxutils::FindOrCreateDirectory(save_dir)) {
+    return 0;
+  }
 
+  int64_t pos_begin = file_path.find_last_of(L"\\") + 1;
+  int64_t pos_end = file_path.find_last_of(L".");
+  std::wstring file_name = file_path.substr(pos_begin, pos_end - pos_begin);
+  HANDLE h_origin_file =
+      CreateFileW(file_path.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING,
+                  FILE_ATTRIBUTE_NORMAL, NULL);
+  char buffer[BUFSIZE] = {0};
+  DWORD bytes_read = 0;
+  DWORD bytes_write = 0;
+  unsigned char magic_head[4] = {0};
+  std::wstring suffix;
+  short key = 0;
+  if (ReadFile(h_origin_file, buffer, BUFSIZE, &bytes_read, NULL)) {
+    memcpy(magic_head, buffer, 3);
+  } else {
+    CloseHandle(h_origin_file);
+    return 0;
+  }
+  if ((magic_head[0] ^ JPEG0) == (magic_head[1] ^ JPEG1)) {
+    key = magic_head[0] ^ JPEG0;
+    suffix = L".jpg";
+  } else if ((magic_head[0] ^ PNG1) == (magic_head[1] ^ PNG2)) {
+    key = magic_head[0] ^ PNG1;
+    suffix = L".png";
+  } else if ((magic_head[0] ^ GIF0) == (magic_head[1] ^ GIF1)) {
+    key = magic_head[0] ^ GIF0;
+    suffix = L".gif";
+  } else if ((magic_head[0] ^ BMP0) == (magic_head[1] ^ BMP1)) {
+    key = magic_head[0] ^ BMP0;
+    suffix = L".bmp";
+  } else {
+    key = -1;
+    suffix = L".dat";
+  }
+  std::wstring save_img_path = save_dir + L"\\" + file_name + suffix;
+  HANDLE save_img = CreateFileW(save_img_path.c_str(), GENERIC_ALL, 0, NULL,
+                                CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+  if (save_img == INVALID_HANDLE_VALUE) {
+    return 0;
+  }
+  if (key > 0) {
+    for (unsigned int i = 0; i < bytes_read; i++) {
+      buffer[i] ^= key;
+    }
+  }
+  if (!WriteFile(save_img, (LPCVOID)buffer, bytes_read, &bytes_write, 0)) {
+    CloseHandle(h_origin_file);
+    CloseHandle(save_img);
+    return 0;
+  }
+
+  do {
+    if (ReadFile(h_origin_file, buffer, BUFSIZE, &bytes_read, NULL)) {
+      if (key > 0) {
+        for (unsigned int i = 0; i < bytes_read; i++) {
+          buffer[i] ^= key;
+        }
+      }
+      if (!WriteFile(save_img, (LPCVOID)buffer, bytes_read, &bytes_write, 0)) {
+        CloseHandle(h_origin_file);
+        CloseHandle(save_img);
+        return 0;
+      }
+    }
+  } while (bytes_read == BUFSIZE);
+  CloseHandle(h_origin_file);
+  CloseHandle(save_img);
+  return 1;
+}
+TODO("GetVoiceByDB")
 int64_t wechat::WeChatService::GetVoiceByDB(ULONG64 msg_id,
                                             const std::wstring& dir) {
   return 0;
 }
-
+TODO("SendCustomEmotion")
 int64_t wechat::WeChatService::SendCustomEmotion(const std::wstring& file_path,
                                                  const std::wstring& wxid) {
-  return 0;
+  int64_t success = -1;
+  uint64_t get_custom_smiley_mgr_addr =
+      base_addr_ + offset::kGetCustomSmileyMgr;
+  func::__GetCustomSmileyMgr get_custom_smiley_mgr =
+      (func::__GetCustomSmileyMgr)get_custom_smiley_mgr_addr;
+  uint64_t send_custom_emotion_addr = base_addr_ + offset::kSendCustomEmotion;
+  func::__SendCustomEmotion send_custom_emotion =
+      (func::__SendCustomEmotion)send_custom_emotion_addr;
+  prototype::WeChatString* path = BuildWechatString(file_path);
+  prototype::WeChatString* recv = BuildWechatString(wxid);
+  int64_t* temp = base::utils::WxHeapAlloc<int64_t>(0x20);
+  memset(temp, 0, 0x20);
+  uint64_t mgr = get_custom_smiley_mgr();
+  success = send_custom_emotion(
+      mgr, reinterpret_cast<uint64_t>(path), reinterpret_cast<uint64_t>(temp),
+      reinterpret_cast<uint64_t>(recv), 2, reinterpret_cast<uint64_t>(temp), 0,
+      reinterpret_cast<uint64_t>(temp));
+  return success;
 }
 
+TODO("SendApplet")
 int64_t wechat::WeChatService::SendApplet(
     const std::wstring& recv_wxid, const std::wstring& waid_suff,
-    const std::wstring& waid_w, const std::string& waid_s,
-    const std::string& wa_wxid, const std::string& json_param,
-    const std::string& head_image, const std::string& big_image,
-    const std::string& index_page) {
-  return 0;
+    const std::wstring& waid_w, const std::wstring& waid_s,
+    const std::wstring& wa_wxid, const std::wstring& json_param,
+    const std::wstring& head_image, const std::wstring& big_image,
+    const std::wstring& index_page) {
+  int64_t success = -1;
+  if (js_api_addr_ == 0) {
+    auto vec2 =
+        base::memory::ScanAndMatchValue(base_addr_ + 0x32D1318, 0x1000, 0x8);
+    for (int i = 0; i < vec2.size(); i++) {
+      int64_t ptr = vec2.at(i);
+      if (*(int64_t*)ptr == base_addr_ + 0x32D1318) {
+        js_api_addr_ = ptr;
+        break;
+      }
+    }
+  }
+  if (js_api_addr_ == 0) {
+    success = -2;
+    return success;
+  }
+
+  uint64_t share_app_msg_addr = base_addr_ + offset::kNewJsApiShareAppMessage;
+  func::__JsApiShareAppMessage share_app_msg =
+      (func::__JsApiShareAppMessage)share_app_msg_addr;
+
+  uint64_t init_addr = base_addr_ + offset::kInitJsConfig;
+  func::__InitJsConfig init = (func::__InitJsConfig)init_addr;
+
+  uint64_t send_applet_addr = base_addr_ + offset::kSendApplet;
+  func::__SendApplet send_applet = (func::__SendApplet)send_applet_addr;
+
+  uint64_t get_by_waid_addr = base_addr_ + offset::kGetAppInfoByWaid;
+  func::__GetAppInfoByWaid get_app_info =
+      (func::__GetAppInfoByWaid)get_by_waid_addr;
+
+  uint64_t copy_app_req_addr = base_addr_ + offset::kCopyShareAppMessageRequest;
+  func::__CopyShareAppMessageRequest copy_app_req =
+      (func::__CopyShareAppMessageRequest)copy_app_req_addr;
+
+  uint64_t new_wa_msg_addr = base_addr_ + offset::kNewWAUpdatableMsgInfo;
+  func::__NewWAUpdatableMsgInfo new_wa_msg =
+      (func::__NewWAUpdatableMsgInfo)new_wa_msg_addr;
+
+  uint64_t free_wa_msg_addr = base_addr_ + offset::kFreeWAUpdatableMsgInfo;
+  func::__FreeWAUpdatableMsgInfo free_wa_msg =
+      (func::__FreeWAUpdatableMsgInfo)free_wa_msg_addr;
+
+  std::vector<prototype::WeChatString>* temp =
+      base::utils::WxHeapAlloc<std::vector<prototype::WeChatString>>(0x20);
+  // std::vector<prototype::WeChatString>*  temp = new
+  // std::vector<prototype::WeChatString>();
+  wechat::VectorInner* list = (wechat::VectorInner*)temp;
+
+  prototype::WeChatString* member = BuildWechatString(recv_wxid);
+#ifdef _DEBUG
+  list->head = reinterpret_cast<uint64_t>(member);
+#endif
+  list->start = reinterpret_cast<uint64_t>(member);
+  list->finsh = reinterpret_cast<uint64_t>(member) + 0x20;
+  list->end = reinterpret_cast<uint64_t>(member) + 0x20;
+
+  uint64_t head = reinterpret_cast<uint64_t>(&(list->start));
+
+  prototype::WeChatString* waid_cat = BuildWechatString(waid_suff);
+  prototype::WeChatString* waid = BuildWechatString(waid_w);
+
+  prototype::WeChatString* waid_2 = BuildWechatString(waid_suff);
+
+  prototype::WeChatString* waid_str = BuildWechatString(waid_s);
+  prototype::WeChatString* app_wxid = BuildWechatString(wa_wxid);
+  prototype::WeChatString* json_str = BuildWechatString(json_param);
+  prototype::WeChatString* head_image_url = BuildWechatString(head_image);
+  prototype::WeChatString* image = BuildWechatString(big_image);
+  prototype::WeChatString* index = BuildWechatString(index_page);
+
+  uint64_t app_msg = js_api_addr_;
+
+  uint64_t data = *(uint64_t*)(app_msg + 0x8);
+  char* share_req = base::utils::WxHeapAlloc<char>(0x2000);
+
+  char* mid_ptr = base::utils::WxHeapAlloc<char>(0x18);
+  memcpy(mid_ptr, &share_req, sizeof(INT64));
+  memcpy(mid_ptr + 0x8, &share_req, sizeof(INT64));
+  memcpy(mid_ptr + 0x10, &share_req, sizeof(INT64));
+
+  memcpy((void*)data, mid_ptr, 0x18);
+
+  memcpy(share_req, (void*)(app_msg + 0x8), sizeof(uint64_t));
+  memcpy(share_req + 0x8, (void*)(app_msg + 0x8), sizeof(uint64_t));
+  memcpy(share_req + 0x10, (void*)(app_msg + 0x8), sizeof(uint64_t));
+  memcpy(share_req + 0x20, waid_2, sizeof(prototype::WeChatString));
+  memcpy(share_req + 0x48, waid_str, sizeof(prototype::WeChatStr));
+  memcpy(share_req + 0x98, app_wxid, sizeof(prototype::WeChatStr));
+  memcpy(share_req + 0xF8, json_str, sizeof(prototype::WeChatStr));
+  memcpy(share_req + 0x178, head_image_url, sizeof(prototype::WeChatStr));
+  memcpy(share_req + 0x198, image, sizeof(prototype::WeChatStr));
+  memcpy(share_req + 0x1c0, index, sizeof(prototype::WeChatStr));
+
+  success = send_applet(app_msg, reinterpret_cast<uint64_t>(waid_cat), head, 0);
+  return success;
 }
 
 int64_t wechat::WeChatService::SendPatMsg(const std::wstring& room_id,
@@ -699,9 +1223,40 @@ int64_t wechat::WeChatService::SendPatMsg(const std::wstring& room_id,
   return success;
 }
 
+TODO("DoOCRTask")
 int64_t wechat::WeChatService::DoOCRTask(const std::wstring& img_path,
                                          std::string& result) {
-  return 0;
+  int64_t success = -1;
+  uint64_t ocr_manager_addr = base_addr_ + offset::kGetOCRManager;
+  func::__GetOCRManager ocr_manager = (func::__GetOCRManager)ocr_manager_addr;
+
+  uint64_t do_ocr_task_addr = base_addr_ + offset::kDoOCRTask;
+  func::__DoOCRTask do_ocr_task = (func::__DoOCRTask)do_ocr_task_addr;
+
+  prototype::WeChatString img(img_path);
+  std::vector<INT64>* temp =
+      base::utils::WxHeapAlloc<std::vector<int64_t>>(0x20);
+  int64_t unkonwn = 0;
+  wechat::VectorInner* list = (wechat::VectorInner*)temp;
+  list->start = reinterpret_cast<INT64>(&list->start);
+  list->finsh = list->start;
+  char buff[0x28] = {0};
+  memcpy(buff, &list->start, sizeof(INT64));
+  uint64_t mgr = ocr_manager();
+  success = do_ocr_task(mgr, reinterpret_cast<uint64_t>(&img), 1,
+                        reinterpret_cast<uint64_t>(buff),
+                        reinterpret_cast<uint64_t>(&unkonwn));
+  int64_t number = *(int64_t*)(buff + 0x8);
+  if (number > 0) {
+    int64_t header = *(int64_t*)(buff);
+    for (unsigned int i = 0; i < number; i++) {
+      int64_t content = *(int64_t*)header;
+      result += wxutils::ReadWstringThenConvert(content + 0x28);
+      result += "\r\n";
+      header = content;
+    }
+  }
+  return success;
 }
 
 int64_t wechat::WeChatService::LockWeChat() {
@@ -737,10 +1292,10 @@ int64_t wechat::WeChatService::EnterWeChat() {
   uint64_t click_cb_addr = base_addr + offset::kOnLoginBtnClick;
   func::__OnLoginBtnClick cb = (func::__OnLoginBtnClick)click_cb_addr;
   auto vec =
-      base::memory::ScanAndMatchValue(base_addr + 0x34e0c18, 0x1000, 0x8);
+      base::memory::ScanAndMatchValue(base_addr + 0x4ecedf8, 0x1000, 0x8);
   for (int i = 0; i < vec.size(); i++) {
     int64_t ptr = vec.at(i);
-    if (*(int64_t*)ptr == base_addr + 0x34e0c18) {
+    if (*(int64_t*)ptr == base_addr + 0x4ecedf8) {
       int64_t login_wnd = ptr;
       success = cb(ptr);
       break;
@@ -749,6 +1304,7 @@ int64_t wechat::WeChatService::EnterWeChat() {
   return success;
 }
 
+TODO("SendMultiAtText")
 int64_t wechat::WeChatService::SendMultiAtText(
     const std::wstring& room_id,
     const std::vector<std::pair<std::wstring, std::wstring>>& at) {
@@ -805,10 +1361,15 @@ std::string wechat::WeChatService::GetLoginUrl() {
   return "http://weixin.qq.com/x/" + login_url;
 }
 
-void wechat::WeChatService::SetBaseAddr(uint64_t addr) {}
+void wechat::WeChatService::SetBaseAddr(uint64_t addr) {
+  this->base_addr_ = addr;
+}
 
-void wechat::WeChatService::SetJsApiAddr(uint64_t addr) {}
+void wechat::WeChatService::SetJsApiAddr(uint64_t addr) {
+  this->js_api_addr_ = addr;
+}
 
+TODO("TranslateVoice")
 int64_t wechat::WeChatService::TranslateVoice(uint64_t msg_id) {
   int64_t success = -1;
   uint64_t get_by_local_id_addr = base_addr_ + offset::kGetMgrByPrefixLocalId;
@@ -865,13 +1426,13 @@ int64_t wechat::WeChatService::TranslateVoice(uint64_t msg_id) {
   return success;
 }
 
+TODO("GetTranslateVoiceText")
 std::string wechat::WeChatService::GetTranslateVoiceText(uint64_t msg_id) {
   std::string content =
       wechat::WeChatDb::GetInstance().GetChatMsgStrContentByMsgId(msg_id);
   if (content.empty()) {
     return {};
   }
-
   tinyxml2::XMLDocument doc;
   if (doc.Parse(content.c_str(), content.size()) != 0) {
     SPDLOG_INFO("tinyxml2 parse error");
@@ -888,6 +1449,7 @@ std::string wechat::WeChatService::GetTranslateVoiceText(uint64_t msg_id) {
   return "";
 }
 
+TODO("OpenUrlByWeChatBrowser")
 int64_t wechat::WeChatService::OpenUrlByWeChatBrowser(const std::wstring& url,
                                                       int flag) {
   int64_t success = -1;
@@ -922,3 +1484,114 @@ int64_t wechat::WeChatService::OpenUrlByWeChatBrowser(const std::wstring& url,
   free_config(ptr);
   return success;
 }
+
+TODO("GetChatRoomMemberNickname")
+std::wstring wechat::WeChatService::GetChatRoomMemberNickname(
+    const std::wstring& room_id, const std::wstring& member_id) {
+
+  return std::wstring();
+}
+
+TODO("DelContact")
+int64_t wechat::WeChatService::DelContact(const std::wstring& wxid) {
+  int64_t success = -1;
+  uint64_t del_contcat_addr = base_addr_ + offset::kDoDelContact;
+  func::__DelContact del_contcat = (func::__DelContact)del_contcat_addr;
+
+  return success;
+}
+
+TODO("SearchContact")
+int64_t wechat::WeChatService::SearchContact(
+    const std::wstring& keyword, wechat::SearchContactInner& contact) {
+  int64_t success = -1;
+   prototype::WeChatString key(keyword);
+  uint64_t search_mgr_addr = base_addr_ + offset::kGetSearchContactMgr;
+  uint64_t search_addr = base_addr_ + offset::kStartSearch;
+
+  func::__GetSearchContactMgr get_mgr =
+      (func::__GetSearchContactMgr)search_mgr_addr;
+  func::__StartSearch search = (func::__StartSearch)search_addr;
+  uint64_t mgr = get_mgr();
+  // success = search(mgr,&key);
+
+  return success;
+}
+
+TODO("AddFriendByWxid")
+int64_t wechat::WeChatService::AddFriendByWxid(const std::wstring& wxid,
+                                               const std::wstring& msg) {
+  uint64_t add_friend_addr = base_addr_ + offset::kAddFriend;
+  func::__AddFriend add_friend = (func::__AddFriend)add_friend_addr;
+  return 0;
+}
+
+TODO("VerifyApply")
+int64_t wechat::WeChatService::VerifyApply(const std::wstring& v3,
+                                           const std::wstring& v4,
+                                           int32_t permission) {
+  uint64_t verify_addr = base_addr_ + offset::kVerifyApply;
+  func::__Verify add_friend = (func::__Verify)verify_addr;
+  return 0;
+}
+
+TODO("DoConfirmReceipt")
+int64_t wechat::WeChatService::DoConfirmReceipt(
+    const std::wstring& wxid, const std::wstring& transcationid,
+    const std::wstring& transferid) {
+  int success = -1;
+  prototype::WeChatString recv_id(wxid);
+  prototype::WeChatString transcation_id(transcationid);
+  prototype::WeChatString transfer_id(transferid);
+
+  char pay_info[0x224] = {0};
+  uint64_t new_pay_info_addr = base_addr_ + offset::kNewPayInfo;
+  uint64_t free_pay_info_addr = base_addr_ + offset::kFreePayInfo;
+  uint64_t do_confirm_addr = base_addr_ + offset::kTransferConfirm;
+
+  func::__NewWCPayInfo new_pay_info = (func::__NewWCPayInfo)new_pay_info_addr;
+  func::__FreeWCPayInfo free_pay_info =
+      (func::__FreeWCPayInfo)free_pay_info_addr;
+  func::__PayTransferConfirm do_confirm =
+      (func::__PayTransferConfirm)do_confirm_addr;
+
+  new_pay_info(reinterpret_cast<uint64_t>(&pay_info));
+  memcpy(&pay_info[0x30], &transcation_id, sizeof(transcation_id));
+  memcpy(&pay_info[0x58], &transfer_id, sizeof(transfer_id));
+  memcpy(&pay_info[0xA0], &recv_id, sizeof(recv_id));
+  success = do_confirm(reinterpret_cast<uint64_t>(&pay_info), reinterpret_cast<uint64_t>(&recv_id));
+
+  free_pay_info(reinterpret_cast<uint64_t>(&pay_info));
+
+  return success;
+}
+
+TODO("DoRefuseReceipt")
+int64_t wechat::WeChatService::DoRefuseReceipt(
+    const std::wstring& wxid, const std::wstring& transcationid,
+    const std::wstring& transferid) {
+  int success = -1;
+  prototype::WeChatString recv_id(wxid);
+  prototype::WeChatString transcation_id(transcationid);
+  prototype::WeChatString transfer_id(transferid);
+
+  char pay_info[0x224] = {0};
+  uint64_t new_pay_info_addr = base_addr_ + offset::kNewPayInfo;
+  uint64_t free_pay_info_addr = base_addr_ + offset::kFreePayInfo;
+  uint64_t do_refuse_addr = base_addr_ + offset::kTransferRefuse;
+
+  func::__NewWCPayInfo new_pay_info = (func::__NewWCPayInfo)new_pay_info_addr;
+  func::__FreeWCPayInfo free_pay_info =
+      (func::__FreeWCPayInfo)free_pay_info_addr;
+  func::__PayTransferRefuse do_refuse =
+      (func::__PayTransferRefuse)do_refuse_addr;
+
+  new_pay_info(reinterpret_cast<uint64_t>(&pay_info));
+  memcpy(&pay_info[0x30], &transcation_id, sizeof(transcation_id));
+  memcpy(&pay_info[0x58], &transfer_id, sizeof(transfer_id));
+  memcpy(&pay_info[0xA0], &recv_id, sizeof(recv_id));
+  success = do_refuse(reinterpret_cast<uint64_t>(&pay_info), reinterpret_cast<uint64_t>(&recv_id));
+
+  free_pay_info(reinterpret_cast<uint64_t>(&pay_info));
+  return success;
+}

src/wxutils.cc

@@ -105,6 +105,20 @@ int DecodeImage(const wchar_t *file_path, const wchar_t *save_dir) {
   return -1;
 }
 
+bool FindOrCreateDirectory(const std::wstring &path) {
+  WIN32_FIND_DATAW fd;
+  HANDLE found = ::FindFirstFileW(path.c_str(), &fd);
+  if (found != INVALID_HANDLE_VALUE &&
+      (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
+    FindClose(found);
+    return true;
+  }
+
+  if (!::CreateDirectoryW(path.c_str(), NULL)) {
+    return false;
+  }
+  return true;
+}
 
 }  // namespace wxutils
 }  // namespace wxhelper

wxhelper.sln

@@ -1,22 +1,25 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
-VisualStudioVersion = 17.10.34928.147
+VisualStudioVersion = 17.9.34723.18
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "wxhelper", "wxhelper.vcxproj", "{D245A0CA-D4E8-3ECD-9DEB-C610DD36E27D}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "wxhelper", "wxhelper.vcxproj", "{40818871-0BD0-4363-B5C3-198F3CEF6CC0}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{D245A0CA-D4E8-3ECD-9DEB-C610DD36E27D}.Debug|x64.ActiveCfg = Debug|x64
-		{D245A0CA-D4E8-3ECD-9DEB-C610DD36E27D}.Debug|x64.Build.0 = Debug|x64
+		{40818871-0BD0-4363-B5C3-198F3CEF6CC0}.Debug|x64.ActiveCfg = Debug|x64
+		{40818871-0BD0-4363-B5C3-198F3CEF6CC0}.Debug|x64.Build.0 = Debug|x64
+		{40818871-0BD0-4363-B5C3-198F3CEF6CC0}.Release|x64.ActiveCfg = Release|x64
+		{40818871-0BD0-4363-B5C3-198F3CEF6CC0}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {8C0C4913-BC48-3A32-B80B-ADD14470CB5C}
+		SolutionGuid = {6E2841B9-FB48-4FB4-80D0-6970D17FB19C}
 	EndGlobalSection
 EndGlobal

wxhelper.vcxproj

@@ -1,13 +1,14 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="17.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <PreferredToolArchitecture>x64</PreferredToolArchitecture>
-  </PropertyGroup>
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|x64">
       <Configuration>Debug</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\chat_controller.cc" />
@@ -23,23 +24,23 @@
     <ClCompile Include="src\http_router.cc" />
     <ClCompile Include="src\http_server.cc" />
     <ClCompile Include="src\json_utils.cc" />
+    <ClCompile Include="src\memory.cc" />
     <ClCompile Include="src\misc_controller.cc" />
     <ClCompile Include="src\sync_msg_hook.cc" />
+    <ClCompile Include="src\thread_pool.cc" />
+    <ClCompile Include="src\utils.cc" />
     <ClCompile Include="src\wechat_db.cc" />
     <ClCompile Include="src\wechat_service.cc" />
     <ClCompile Include="src\wxhelper.cc" />
     <ClCompile Include="src\wxutils.cc" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="inc\base64.h" />
-    <ClInclude Include="inc\base_config.h" />
     <ClInclude Include="inc\chat_controller.h" />
     <ClInclude Include="inc\chat_room_controller.h" />
     <ClInclude Include="inc\client_socket.h" />
     <ClInclude Include="inc\config.h" />
     <ClInclude Include="inc\contacts_controller.h" />
     <ClInclude Include="inc\db_controller.h" />
-    <ClInclude Include="inc\detours.h" />
     <ClInclude Include="inc\hook.h" />
     <ClInclude Include="inc\hook_controller.h" />
     <ClInclude Include="inc\http_client.h" />
@@ -47,93 +48,116 @@
     <ClInclude Include="inc\http_router.h" />
     <ClInclude Include="inc\http_server.h" />
     <ClInclude Include="inc\json_utils.h" />
-    <ClInclude Include="inc\memory.h" />
     <ClInclude Include="inc\misc_controller.h" />
-    <ClInclude Include="inc\mongoose.h" />
-    <ClInclude Include="inc\noncopyable.h" />
     <ClInclude Include="inc\offset.h" />
-    <ClInclude Include="inc\singleton.h" />
     <ClInclude Include="inc\sqlite_function.h" />
     <ClInclude Include="inc\sync_msg_hook.h" />
-    <ClInclude Include="inc\thread_pool.h" />
-    <ClInclude Include="inc\tinyxml2.h" />
-    <ClInclude Include="inc\utils.h" />
     <ClInclude Include="inc\wechat_db.h" />
     <ClInclude Include="inc\wechat_interface.h" />
     <ClInclude Include="inc\wechat_service.h" />
-    <ClInclude Include="inc\win_header.h" />
     <ClInclude Include="inc\wxhelper.h" />
     <ClInclude Include="inc\wxutils.h" />
+    <ClInclude Include="resource.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="wxhelper.rc" />
   </ItemGroup>
   <PropertyGroup Label="Globals">
-    <ProjectGuid>{D245A0CA-D4E8-3ECD-9DEB-C610DD36E27D}</ProjectGuid>
+    <VCProjectVersion>17.0</VCProjectVersion>
+    <ProjectName>wxhelper</ProjectName>
+    <ProjectGuid>{40818871-0BD0-4363-B5C3-198F3CEF6CC0}</ProjectGuid>
+    <RootNamespace>wxhelper</RootNamespace>
     <Keyword>Win32Proj</Keyword>
     <WindowsTargetPlatformVersion>10.0.22621.0</WindowsTargetPlatformVersion>
-    <Platform>x64</Platform>
-    <ProjectName>wxhelper</ProjectName>
-    <VCProjectUpgraderObjectName>NoUpgrade</VCProjectUpgraderObjectName>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
     <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
   </ImportGroup>
-  <ImportGroup Label="PropertySheets">
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup>
-    <_ProjectFileVersion>10.0.20506.1</_ProjectFileVersion>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">wxhelper</TargetName>
-    <TargetExt Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.dll</TargetExt>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
-    <GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</GenerateManifest>
+    <_ProjectFileVersion>17.0.34714.143</_ProjectFileVersion>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <LibraryPath>$(ProjectDir)\lib;$(LibraryPath)</LibraryPath>
-    <IncludePath>$(ProjectDir)\inc;$(IncludePath)</IncludePath>
+    <OutDir>$(SolutionDir)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <OutDir>$(SolutionDir)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\</IntDir>
+    <LinkIncremental>true</LinkIncremental>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <ExceptionHandling>Sync</ExceptionHandling>
-      <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
-      <Optimization>Disabled</Optimization>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <UseFullPaths>false</UseFullPaths>
-      <PreprocessorDefinitions>%(PreprocessorDefinitions);WIN32;_WINDOWS;WECHAT_VERSION=391019;SPDLOG_COMPILED_LIB;CMAKE_INTDIR="Debug";wxhelper_EXPORTS</PreprocessorDefinitions>
-      <ObjectFileName>$(IntDir)</ObjectFileName>
-      <LanguageStandard>Default</LanguageStandard>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>%(PreprocessorDefinitions);WIN32;_DEBUG;_WINDOWS;WECHAT_VERSION=391019;SPDLOG_COMPILED_LIB;CMAKE_INTDIR=\"Debug\";wxhelper_EXPORTS</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>\x64-windows\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-    </ResourceCompile>
     <Midl>
-      <AdditionalIncludeDirectories>\x64-windows\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <OutputDirectory>$(ProjectDir)/$(IntDir)</OutputDirectory>
-      <HeaderFileName>%(Filename).h</HeaderFileName>
-      <TypeLibraryName>%(Filename).tlb</TypeLibraryName>
-      <InterfaceIdentifierFileName>%(Filename)_i.c</InterfaceIdentifierFileName>
-      <ProxyFileName>%(Filename)_p.c</ProxyFileName>
+      <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
+    <ClCompile>
+      <PreprocessorDefinitions>WECHAT_VERSION=391125;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>false</MinimalRebuild>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <AdditionalIncludeDirectories>inc\nlohmann;inc\tinyxml2;inc\mongoose;inc\lz4;inc\Detours;inc\include;inc\base64;inc;inc\spdlog;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
     <Link>
-      <AdditionalDependencies>base.lib;base64.lib;detours.lib;lz4.lib;mongoose.lib;spdlogd.lib;tinyxml2.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;comdlg32.lib;advapi32.lib</AdditionalDependencies>
-      <AdditionalOptions>%(AdditionalOptions) /machine:x64</AdditionalOptions>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>NotSet</SubSystem>
+      <TargetMachine>MachineX64</TargetMachine>
+      <AdditionalDependencies>base64.lib;detours.lib;lz4.lib;mongoose.lib;spdlogd.lib;tinyxml2.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;comdlg32.lib;advapi32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
-      <SubSystem>Console</SubSystem>
+      <UACExecutionLevel>RequireAdministrator</UACExecutionLevel>
+      <AdditionalLibraryDirectories>lib\debug;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WECHAT_VERSION=391125;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <PrecompiledHeader />
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <AdditionalIncludeDirectories>inc\nlohmann;inc\tinyxml2;inc\mongoose;inc\lz4;inc\Detours;inc\include;inc\base64;inc;inc\spdlog;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <TargetMachine>MachineX64</TargetMachine>
+      <AdditionalDependencies>base64.lib;detours.lib;lz4.lib;mongoose.lib;spdlog.lib;tinyxml2.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;comdlg32.lib;advapi32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
+      <AdditionalLibraryDirectories>lib\release;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
     </Link>
-    <ProjectReference>
-      <LinkLibraryDependencies>false</LinkLibraryDependencies>
-    </ProjectReference>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

wxhelper.vcxproj.filters

@@ -0,0 +1,161 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\hook_controller.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\http_client.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\http_router.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\http_server.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\json_utils.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\misc_controller.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\sync_msg_hook.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\wechat_db.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\wechat_service.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\wxhelper.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\wxutils.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\chat_controller.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\chat_room_controller.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\client_socket.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\config.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\contacts_controller.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\db_controller.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\dllMain.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\hook.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\memory.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\thread_pool.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\utils.cc">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="resource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\chat_controller.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\chat_room_controller.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\client_socket.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\config.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\contacts_controller.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\db_controller.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\hook.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\hook_controller.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\http_client.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\http_controller.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\http_router.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\http_server.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\misc_controller.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\offset.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\sqlite_function.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\sync_msg_hook.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\wechat_db.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\wechat_interface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\wechat_service.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\wxhelper.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\wxutils.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\json_utils.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="wxhelper.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>