README.md

@@ -7,9 +7,6 @@
 EOSSDK-Holos is an emulation layer for the Epic Online Services (EOS) SDK. Its primary objective is to make possible true Peer-to-Peer multiplayer connectivity by intercepting and redirecting P2P traffic over a direct UDP socket.
 
 
-This patch is particulary made for Holos Hanafuda, tested on version 1.2.0 under wine
-
-
 # Build
 
 1. Place the contents of this repository into the game's plugin directory:
@@ -25,8 +22,4 @@ The project acts as a DLL proxy. To ensure the game can still access the origina
 
 Execute the build script provided in the repository to generate the proxy DLL:
 
-```bash ./build.sh```
+```bash ./build.sh```
-
-# Disclaimer and Licensing
-
-This project, EOSSDK-Holos, is an independent research initiative focused on software emulation and network engineering. Its primary objective is to enable Peer-to-Peer multiplayer connectivity by providing an emulation layer for the Epic Online Services SDK. It is important to clarify that this project does not endorse, support, or encourage piracy, copyright infringement, or the unauthorized distribution of software. To utilize this patch, users must possess a legitimate, legally obtained copy of the game, as this project does not bypass or provide game content and functions exclusively as a network compatibility layer for existing owners. The code and documentation provided herein are intended solely for educational and research purposes. All source code developed for this project is distributed under the terms of the GNU General Public License, Version 2, and users are encouraged to review the license terms to understand their rights and obligations regarding the modification and redistribution of this software.

gen_def.py

@@ -111,17 +111,6 @@ def main():
         "EOS_Lobby_ParseConnectString",
         "EOS_Platform_GetActiveCountryCode",
         "EOS_Platform_GetActiveLocaleCode",
-        "EOS_Connect_RemoveNotifyLoginStatusChanged",
-        "EOS_Connect_GetLoginStatus",
-        "EOS_Connect_AddNotifyLoginStatusChanged",
-        "EOS_Auth_GetLoginStatus",
-        "EOS_Lobby_JoinLobbyById",
-        "EOS_Logging_SetCallback",
-        "EOS_Logging_SetLogLevel",
-        "EOS_PlayerDataStorage_QueryFile",
-        "EOS_Sanctions_QueryActivePlayerSanctions",
-        "EOS_Sanctions_GetPlayerSanctionCount",
-        "EOS_Sanctions_CopyPlayerSanctionByIndex",
     ]
     
     with open('proxy.def', 'w') as out:

gen_stubs.py

@@ -109,18 +109,6 @@ def main():
         "EOS_Lobby_ParseConnectString",
         "EOS_Platform_GetActiveCountryCode",
         "EOS_Platform_GetActiveLocaleCode",
-        "EOS_Connect_RemoveNotifyLoginStatusChanged",
-        "EOS_Connect_GetLoginStatus",
-        "EOS_Connect_AddNotifyLoginStatusChanged",
-        "EOS_Auth_GetLoginStatus",
-        "EOS_Lobby_JoinLobbyById",
-        "EOS_Logging_SetCallback",
-        "EOS_Logging_SetLogLevel",
-        "EOS_PlayerDataStorage_QueryFile",
-        "EOS_Sanctions_QueryActivePlayerSanctions",
-        "EOS_Sanctions_GetPlayerSanctionCount",
-        "EOS_Sanctions_CopyPlayerSanctionByIndex",
-
     ]
 
     funcs = []

keyDumper/bundle_decryption.md

@@ -1,65 +0,0 @@
-# Bundle Decryption & Extraction
-
-## Overview
-
-Holo's Hanafuda (Unity 6000.0.25f1, IL2CPP) encrypts its 559 addressable asset bundles using a custom **AES-256-ECB** stream cipher implementation. This document outlines the encryption scheme, the discovery process, and how to use the `extract_bundles.py` script to decrypt and extract the assets.
-
-## Encryption Scheme
-
-The game implements a custom stream cipher by leveraging AES-256-ECB as a keystream generator. The encryption keys were found by developing a custom **EOSSDK** proxy DLL that dumps keys at runtime.
-
-| Property | Value |
-|---|---|
-| Cipher | AES-256-ECB, `PaddingMode.None` |
-| Key | 32 ASCII bytes: `rK7CcATuZk7LAmhqqU4iBLNmAq8QbK3s` |
-| Keystream | `AES_ECB(key, counter_block)` |
-| Counter block | `[le64(counter) \| 8 zero bytes]` (16 bytes) |
-| Counter start | `pos/16 + 1` (first block = counter 1) |
-
-### Decryption Logic
-Files are encrypted using a block-by-block XOR operation against an AES-generated keystream. To decrypt these bundles, you can use the `extract_bundles.py` script, which calculates the counter for each 16-byte block and reverses the XOR encryption.
-
-```python
-# The process is something like this:
-counter_block = struct.pack('<q', pos // 16 + 1) + b'\x00' * 8
-keystream     = AES_ECB(key, counter_block)
-plaintext[i]  = ciphertext[i] XOR keystream[i]
-
-```
-
-## Discovery & Key Extraction
-
-The encryption keys and metadata were recovered using a custom **EOSSDK** proxy DLL (`main.c`). By replacing the legitimate `EOSSDK-Win64-Shipping.dll` with this proxy, we successfully:
-
-* **Intercepted Key Derivation**: Hooked `GenerateKey` and `GenerateIV` to capture the 32-byte AES key and bundle naming patterns.
-* **Memory Scanning**: Implemented a background thread to scan process memory for UnityFS headers and key string patterns.
-* **Asset Loading Hooks**: Hooked `EncryptAssetBundleResource.LoadLocal` to map encrypted bundles to their file paths.
-
-## Extraction Process
-
-### Prerequisites
-
-Ensure you have the necessary Python libraries installed:
-
-```bash
-pip install pycryptodome UnityPy
-
-```
-
-### Script: `extract_bundles.py`
-
-This script performs a two-phase extraction:
-
-1. **Decryption**: Reads encrypted `.bundle` files from the game directory and writes decrypted `.unity3d` files to the output folder using the discovered AES key.
-2. **Asset Parsing**: Uses `UnityPy` to iterate through the decrypted bundles to extract Textures, Sprites, Meshes, and Audio.
-
-## Asset Breakdown
-
-| Type | Count | Notes |
-| --- | --- | --- |
-| AudioClip | 3149 | FSB5 format |
-| Texture2D | 1312 | Backgrounds/UI |
-| Sprite | 1298 | Atlas-sliced character art |
-| TextAsset | 71 | Dialogue/Config |
-
-*Note: The asset extraction done by the script is purely a example, to actually extract all the possible files correctly, you should use a software like AssetRipper*

keyDumper/decriptSave.py

@@ -1,22 +0,0 @@
-from Crypto.Cipher import AES
-from Crypto.Util.Padding import unpad
-import sys
-
-KEY = b"rK7CcATuZk7LAmhqqU4iBLNmAq8QbK3s"
-
-for path in ["SteamData/SaveData.sav", "SteamData/SubSaveData001001.sav"]:
-    with open(path, "rb") as f:
-        raw = f.read()
-    iv = raw[:16]
-    ct = raw[16:]
-    c = AES.new(KEY, AES.MODE_CBC, iv=iv)
-    pt = unpad(c.decrypt(ct), AES.block_size)
-    out = path.replace(".sav", "_decrypted.sav")
-    with open(out, "wb") as f:
-        f.write(pt)
-    print(f"{path}: {len(raw)} enc -> {len(pt)} dec")
-    print(f"  First 64 bytes hex:")
-    for i in range(0, min(64, len(pt)), 16):
-        hexpart = " ".join(f"{b:02X}" for b in pt[i:i+16])
-        asciipart = "".join(chr(b) if 32 <= b < 127 else "." for b in pt[i:i+16])
-        print(f"  {i:04x}: {hexpart:48s} {asciipart}")

keyDumper/extract_bundles.py

@@ -1,213 +0,0 @@
-#!/usr/bin/env python3
-import os, sys, struct, json, time
-from Crypto.Cipher import AES
-
-KEY = b"rK7CcATuZk7LAmhqqU4iBLNmAq8QbK3s"
-BUNDLES_DIR = "HolosHanafuda_Data/StreamingAssets/aa/StandaloneWindows64"
-OUT = "extracted"
-
-def decrypt(enc):
-    cipher = AES.new(KEY, AES.MODE_ECB)
-    dec = bytearray(len(enc))
-    for off in range(0, len(enc), 16):
-        ctr = off // 16 + 1
-        ks = cipher.encrypt(struct.pack('<q', ctr) + b'\x00' * 8)
-        for j, b in enumerate(enc[off:off+16]):
-            dec[off+j] = b ^ ks[j]
-    return dec
-
-def extract_audio(env, dest_dir):
-    audio_dirs = {}
-    count = 0
-    files = getattr(env.file, 'files', {})
-    if not files:
-        return count
-    for obj in env.objects:
-        if obj.type.name != 'AudioClip':
-            continue
-        try:
-            data = obj.read()
-            res = data.m_Resource
-            if not res or res.m_Size == 0:
-                continue
-            src = res.m_Source.replace('archive:/', '')
-            parts = src.split('/')
-            res_name = parts[-1] if len(parts) > 1 else parts[0]
-            if res_name not in files:
-                continue
-            reader = files[res_name]
-            reader.Position = res.m_Offset
-            raw = reader.read(res.m_Size)
-            if not raw:
-                continue
-            # Detect format
-            ext = '.fsb'
-            if raw[:4] == b'OggS':
-                ext = '.ogg'
-            elif raw[:4] == b'RIFF':
-                ext = '.wav'
-            elif raw[:3] == b'FSB' or raw[:4] == b'FSB5':
-                ext = '.fsb'
-            dest = os.path.join(dest_dir, data.m_Name + ext)
-            with open(dest, 'wb') as f:
-                f.write(raw)
-            count += 1
-        except Exception as e:
-            pass
-    return count
-
-def extract_texture(obj, dest_dir):
-    try:
-        data = obj.read()
-        tname = data.m_Name
-        if not tname:
-            return None
-        data.image.save(os.path.join(dest_dir, tname + '.png'))
-        return {'name': tname, 'type': 'Texture2D'}
-    except:
-        return None
-
-def extract_sprite(obj, dest_dir):
-    try:
-        data = obj.read()
-        tname = data.m_Name
-        if not tname:
-            return None
-        data.image.save(os.path.join(dest_dir, tname + '.png'))
-        return {'name': tname, 'type': 'Sprite'}
-    except:
-        return None
-
-def extract_mesh(obj, dest_dir):
-    try:
-        data = obj.read()
-        tname = data.m_Name
-        if not tname:
-            return None
-        with open(os.path.join(dest_dir, tname + '.obj'), 'w') as f:
-            f.write(data.export())
-        return {'name': tname, 'type': 'Mesh'}
-    except:
-        return None
-
-def main():
-    os.makedirs(f"{OUT}/bundles", exist_ok=True)
-    os.makedirs(f"{OUT}/assets", exist_ok=True)
-    os.makedirs(f"{OUT}/audio", exist_ok=True)
-
-    files = sorted(f for f in os.listdir(BUNDLES_DIR) if f.endswith('.bundle'))
-    print(f"Found {len(files)} encrypted bundles\n")
-
-    # decrypt all
-    print("Decrypting bundles...")
-    ok = errs = 0
-    for idx, fname in enumerate(files, 1):
-        fpath = os.path.join(BUNDLES_DIR, fname)
-        try:
-            with open(fpath, 'rb') as f:
-                enc = f.read()
-            dec = decrypt(enc)
-        except Exception as e:
-            print(f"  [{idx}/{len(files)}] ERROR {fname}: {e}")
-            errs += 1
-            continue
-        base = fname.removesuffix('.bundle')
-        with open(f"{OUT}/bundles/{base}.unity3d", 'wb') as f:
-            f.write(dec)
-        ok += 1
-        if ok % 100 == 0 or ok == len(files):
-            print(f"  [{idx}/{len(files)}] {fname}")
-    print(f"\nDecryption: {ok} OK, {errs} errors\n")
-
-    # extract everything with UnityPy
-    print("Extracting assets...")
-    try:
-        import UnityPy
-    except ImportError:
-        print("  Missing UnityPy - pip install UnityPy")
-        return
-
-    decrypted = sorted(f for f in os.listdir(f"{OUT}/bundles") if f.endswith('.unity3d'))
-    type_counts = {}
-    asset_index = []
-    total_audio = 0
-    total_textures = 0
-    total_sprites = 0
-    total_meshes = 0
-
-    for idx, fname in enumerate(decrypted, 1):
-        fpath = os.path.join(f"{OUT}/bundles", fname)
-        try:
-            env = UnityPy.load(fpath)
-        except Exception as e:
-            print(f"  [{idx}/{len(decrypted)}] PARSE ERROR {fname}: {e}")
-            continue
-
-        # Extract audio from .resource blobs
-        audio_count = extract_audio(env, f"{OUT}/audio")
-        total_audio += audio_count
-
-        # Extract all container objects
-        for path, obj in env.container.items():
-            try:
-                ttype = obj.type.name
-                type_counts[ttype] = type_counts.get(ttype, 0) + 1
-
-                if ttype == 'Texture2D':
-                    r = extract_texture(obj, f"{OUT}/assets")
-                    if r:
-                        total_textures += 1
-                        r['bundle'] = fname
-                        asset_index.append(r)
-                elif ttype == 'Sprite':
-                    r = extract_sprite(obj, f"{OUT}/assets")
-                    if r:
-                        total_sprites += 1
-                        r['bundle'] = fname
-                        asset_index.append(r)
-                elif ttype == 'Mesh':
-                    r = extract_mesh(obj, f"{OUT}/assets")
-                    if r:
-                        total_meshes += 1
-                        r['bundle'] = fname
-                        asset_index.append(r)
-                elif ttype in ('MonoBehaviour', 'TextAsset', 'Shader', 'Material',
-                               'AnimatorController', 'VideoClip'):
-                    data = obj.read()
-                    tname = data.m_Name if hasattr(data, 'm_Name') else path
-                    asset_index.append({'name': tname, 'type': ttype, 'bundle': fname})
-                elif ttype == 'AudioClip':
-                    asset_index.append({'name': ttype, 'type': ttype, 'bundle': fname})
-            except Exception as e:
-                if idx <= 3:
-                    print(f"    SKIP {obj.type.name}: {e}")
-
-        if idx % 200 == 0:
-            print(f"  [{idx}/{len(decrypted)}]")
-    print(f"  [{len(decrypted)}/{len(decrypted)}] done")
-
-    print(f"\nExtraction Summary")
-    print(f"Bundles decrypted: {ok}")
-    print(f"Audio clips:        {total_audio} (.fsb/.ogg/.wav)")
-    print(f"Textures extracted: {total_textures}")
-    print(f"Sprites extracted:  {total_sprites}")
-    print(f"Meshes extracted:   {total_meshes}")
-    print(f"Asset types found:")
-    for t, c in sorted(type_counts.items(), key=lambda x: -x[1]):
-        print(f"  {t}: {c}")
-
-    with open(f"{OUT}/asset_index.json", 'w') as f:
-        json.dump({'bundles': ok, 'audio': total_audio,
-                    'textures': total_textures,
-                    'types': type_counts,
-                    'assets': asset_index}, f, indent=2)
-    print(f"\nIndex:     {OUT}/asset_index.json")
-    print(f"Bundles:   {OUT}/bundles/")
-    print(f"Images:    {OUT}/assets/")
-    print(f"Audio:     {OUT}/audio/")
-    print(f"This script extracts the files as a example, for a reliable extraction use something like AssetRipper")
-
-if __name__ == '__main__':
-    t0 = time.time()
-    main()
-    print(f"\nTotal: {time.time()-t0:.1f}s")

keyDumper/save_decription.md

@@ -1,22 +0,0 @@
-# Save File Decryption
-
-## Overview
-Game save files (`SaveData.sav` and `SubSaveData001001.sav`) are protected using **AES-256-CBC** encryption. Decryption requires the 32-byte master key (shared with the asset bundle encryption) and a valid Initialization Vector (IV) extracted from the file header.
-
-## Encryption Scheme
-
-| Property | Value |
-|---|---|
-| Cipher | AES-256-CBC |
-| Key | 32 ASCII bytes: `rK7CcATuZk7LAmhqqU4iBLNmAq8QbK3s` |
-| IV Source | First 16 bytes of the encrypted save file |
-| Padding | PKCS7 |
-
-## Decryption Process
-
-To decrypt the files, you must isolate the IV from the beginning of the file and pass the remaining data through an AES-CBC cipher. There is a script that automates this process by testing various IV configurations, confirming that the first 16 bytes serve as the IV.
-
-
-### Understanding AES-CBC Mode
-
-In CBC (Cipher Block Chaining) mode, each block of ciphertext is XORed with the previous ciphertext block after decryption. The first block requires the Initialization Vector (IV) to perform this operation. Using the first 16 bytes of the file as the IV is a common standard in Unity-based save systems.

keyDumper/src/build.sh

@@ -1,6 +0,0 @@
-# Build main.c with minhook hooking library
-x86_64-w64-mingw32-gcc -static-libgcc -fPIC -shared -O2 \
-  -I include -I src \
-  main.c src/hook.c src/buffer.c src/trampoline.c src/hde/hde64.c src/hde/hde32.c \
-  proxy_fwd.def \
-  -o EOSSDK-Win64-Shipping.dll

keyDumper/src/gen_def.py

@@ -1,147 +0,0 @@
-import re
-import sys
-
-def main():
-    with open('dump.txt', 'r', encoding='utf-8', errors='ignore') as f:
-        content = f.read()
-    
-    # Find the [Ordinal/Name Pointer] Table
-    match = re.search(r'\[Ordinal/Name Pointer\] Table.*?\n(.*?)(\n\n|\Z)', content, re.DOTALL)
-    if not match:
-        print("Could not find Name Pointer Table in dump.txt")
-        return
-        
-    lines = match.group(1).split('\n')
-    
-    hooks = [
-        "EOS_P2P_SendPacket",
-        "EOS_P2P_GetNextReceivedPacketSize",
-        "EOS_P2P_ReceivePacket",
-        "EOS_P2P_AcceptConnection",
-        "EOS_P2P_CloseConnection",
-        "EOS_P2P_CloseConnections",
-        "EOS_P2P_QueryNATType",
-        "EOS_P2P_GetNATType",
-        "EOS_P2P_SetRelayControl",
-        "EOS_P2P_GetRelayControl",
-        "EOS_P2P_SetPortRange",
-        "EOS_P2P_GetPortRange",
-        "EOS_P2P_AddNotifyPeerConnectionRequest",
-        "EOS_P2P_RemoveNotifyPeerConnectionRequest",
-        "EOS_P2P_AddNotifyPeerConnectionClosed",
-        "EOS_P2P_RemoveNotifyPeerConnectionClosed",
-        "EOS_P2P_AddNotifyPeerConnectionEstablished",
-        "EOS_P2P_RemoveNotifyPeerConnectionEstablished",
-        "EOS_P2P_AddNotifyPeerConnectionInterrupted",
-        "EOS_P2P_RemoveNotifyPeerConnectionInterrupted",
-        "EOS_P2P_AddNotifyIncomingPacketQueueFull",
-        "EOS_P2P_RemoveNotifyIncomingPacketQueueFull",
-        "EOS_P2P_ClearPacketQueue",
-        "EOS_P2P_GetPacketQueueInfo",
-        "EOS_P2P_SetPacketQueueSize",
-        "EOS_Auth_Login",
-        "EOS_Connect_Login",
-        "EOS_Connect_CreateUser",
-        "EOS_EpicAccountId_FromString",
-        "EOS_ProductUserId_FromString",
-        "EOS_EpicAccountId_IsValid",
-        "EOS_ProductUserId_IsValid",
-        "EOS_ProductUserId_ToString",
-        "EOS_Connect_AddNotifyAuthExpiration",
-        "EOS_Lobby_CreateLobby",
-        "EOS_Lobby_JoinLobby",
-        "EOS_Lobby_CreateLobbySearch",
-        "EOS_LobbySearch_Find",
-        "EOS_LobbySearch_GetSearchResultCount",
-        "EOS_LobbySearch_CopySearchResultByIndex",
-        "EOS_LobbyDetails_CopyInfo",
-        "EOS_LobbyDetails_GetLobbyOwner",
-        "EOS_LobbyDetails_Release",
-        "EOS_LobbySearch_Release",
-        "EOS_Lobby_AddNotifyLobbyUpdateReceived",
-        "EOS_Lobby_RemoveNotifyLobbyUpdateReceived",
-        "EOS_LobbySearch_RemoveParameter",
-        "EOS_LobbySearch_SetLobbyId",
-        "EOS_LobbySearch_SetMaxResults",
-        "EOS_LobbySearch_SetParameter",
-        "EOS_LobbySearch_SetTargetUserId",
-        "EOS_LobbyModification_AddAttribute",
-        "EOS_LobbyModification_AddMemberAttribute",
-        "EOS_LobbyModification_Release",
-        "EOS_LobbyModification_RemoveAttribute",
-        "EOS_LobbyModification_RemoveMemberAttribute",
-        "EOS_LobbyModification_SetAllowedPlatformIds",
-        "EOS_LobbyModification_SetBucketId",
-        "EOS_LobbyModification_SetInvitesAllowed",
-        "EOS_LobbyModification_SetMaxMembers",
-        "EOS_LobbyModification_SetPermissionLevel",
-        "EOS_Lobby_UpdateLobbyModification",
-        "EOS_LobbyDetails_CopyAttributeByIndex",
-        "EOS_LobbyDetails_CopyAttributeByKey",
-        "EOS_LobbyDetails_CopyMemberAttributeByIndex",
-        "EOS_LobbyDetails_CopyMemberAttributeByKey",
-        "EOS_LobbyDetails_CopyMemberInfo",
-        "EOS_LobbyDetails_GetAttributeCount",
-        "EOS_LobbyDetails_GetMemberAttributeCount",
-        "EOS_LobbyDetails_GetMemberByIndex",
-        "EOS_LobbyDetails_GetMemberCount",
-        "EOS_LobbyDetails_Info_Release",
-        "EOS_LobbyDetails_MemberInfo_Release",
-        "EOS_Lobby_CopyLobbyDetailsHandle",
-        "EOS_Lobby_CopyLobbyDetailsHandleByInviteId",
-        "EOS_Lobby_CopyLobbyDetailsHandleByUiEventId",
-        "EOS_Lobby_UpdateLobby",
-        "EOS_Lobby_DestroyLobby",
-        "EOS_Lobby_LeaveLobby",
-        "EOS_Lobby_AddNotifyLobbyMemberStatusReceived",
-        "EOS_Lobby_RemoveNotifyLobbyMemberStatusReceived",
-        "EOS_Lobby_AddNotifyLobbyMemberUpdateReceived",
-        "EOS_Lobby_RemoveNotifyLobbyMemberUpdateReceived",
-        "EOS_Lobby_IsRTCRoomConnected",
-        "EOS_Lobby_GetRTCRoomName",
-        "EOS_Lobby_Attribute_Release",
-        "EOS_Connect_CopyIdToken",
-        "EOS_Connect_IdToken_Release",
-        "EOS_Connect_VerifyIdToken",
-        "EOS_Platform_Tick",
-        "EOS_Lobby_IsLobbyOwner",
-        "EOS_Lobby_GetInviteCount",
-        "EOS_Lobby_CopyInviteIdByIndex",
-        "EOS_Lobby_GetConnectString",
-        "EOS_Lobby_ParseConnectString",
-        "EOS_Platform_GetActiveCountryCode",
-        "EOS_Platform_GetActiveLocaleCode",
-        "EOS_Connect_RemoveNotifyLoginStatusChanged",
-        "EOS_Connect_GetLoginStatus",
-        "EOS_Connect_AddNotifyLoginStatusChanged",
-        "EOS_Auth_GetLoginStatus",
-        "EOS_Lobby_JoinLobbyById",
-        "EOS_Logging_SetCallback",
-        "EOS_Logging_SetLogLevel",
-        "EOS_PlayerDataStorage_QueryFile",
-        "EOS_Sanctions_QueryActivePlayerSanctions",
-        "EOS_Sanctions_GetPlayerSanctionCount",
-        "EOS_Sanctions_CopyPlayerSanctionByIndex",
-    ]
-    
-    with open('proxy.def', 'w') as out:
-        out.write('LIBRARY "EOSSDK-Win64-Shipping.dll"\n')
-        out.write('EXPORTS\n')
-        for line in lines:
-            line = line.strip()
-            if not line: continue
-            # Parse line: [   0] +base[   1]  0000 EOS_Achievements_AddNotifyAchievementsUnlocked
-            parts = line.split()
-            if len(parts) >= 4:
-                func_name = parts[-1]
-                if func_name in hooks:
-                    # Export our hook directly
-                    out.write(f'    {func_name}\n')
-                else:
-                    # Forward to the original dll
-                    out.write(f'    {func_name}=EOSSDK-Win64-Shipping_orig.{func_name}\n')
-                    
-    print("proxy.def generated successfully.")
-
-if __name__ == "__main__":
-    main()

keyDumper/src/gen_stubs.py

@@ -1,161 +0,0 @@
-import re
-
-def main():
-    with open('dump.txt', 'r', encoding='utf-8', errors='ignore') as f:
-        content = f.read()
-    
-    match = re.search(r'\[Ordinal/Name Pointer\] Table.*?\n(.*?)(\n\n|\Z)', content, re.DOTALL)
-    if not match:
-        print("Could not find Name Pointer Table in dump.txt")
-        return
-        
-    lines = match.group(1).split('\n')
-    
-    hooks = [
-        "EOS_P2P_SendPacket",
-        "EOS_P2P_GetNextReceivedPacketSize",
-        "EOS_P2P_ReceivePacket",
-        "EOS_P2P_AcceptConnection",
-        "EOS_P2P_CloseConnection",
-        "EOS_P2P_CloseConnections",
-        "EOS_P2P_QueryNATType",
-        "EOS_P2P_GetNATType",
-        "EOS_P2P_SetRelayControl",
-        "EOS_P2P_GetRelayControl",
-        "EOS_P2P_SetPortRange",
-        "EOS_P2P_GetPortRange",
-        "EOS_P2P_AddNotifyPeerConnectionRequest",
-        "EOS_P2P_RemoveNotifyPeerConnectionRequest",
-        "EOS_P2P_AddNotifyPeerConnectionClosed",
-        "EOS_P2P_RemoveNotifyPeerConnectionClosed",
-        "EOS_P2P_AddNotifyPeerConnectionEstablished",
-        "EOS_P2P_RemoveNotifyPeerConnectionEstablished",
-        "EOS_P2P_AddNotifyPeerConnectionInterrupted",
-        "EOS_P2P_RemoveNotifyPeerConnectionInterrupted",
-        "EOS_P2P_AddNotifyIncomingPacketQueueFull",
-        "EOS_P2P_RemoveNotifyIncomingPacketQueueFull",
-        "EOS_P2P_ClearPacketQueue",
-        "EOS_P2P_GetPacketQueueInfo",
-        "EOS_P2P_SetPacketQueueSize",
-        "EOS_Auth_Login",
-        "EOS_Connect_Login",
-        "EOS_Connect_CreateUser",
-        "EOS_EpicAccountId_FromString",
-        "EOS_ProductUserId_FromString",
-        "EOS_EpicAccountId_IsValid",
-        "EOS_ProductUserId_IsValid",
-        "EOS_ProductUserId_ToString",
-        "EOS_Connect_AddNotifyAuthExpiration",
-        "EOS_Lobby_CreateLobby",
-        "EOS_Lobby_JoinLobby",
-        "EOS_Lobby_CreateLobbySearch",
-        "EOS_LobbySearch_Find",
-        "EOS_LobbySearch_GetSearchResultCount",
-        "EOS_LobbySearch_CopySearchResultByIndex",
-        "EOS_LobbyDetails_CopyInfo",
-        "EOS_LobbyDetails_GetLobbyOwner",
-        "EOS_LobbyDetails_Release",
-        "EOS_LobbySearch_Release",
-        "EOS_Lobby_AddNotifyLobbyUpdateReceived",
-        "EOS_Lobby_RemoveNotifyLobbyUpdateReceived",
-        "EOS_LobbySearch_RemoveParameter",
-        "EOS_LobbySearch_SetLobbyId",
-        "EOS_LobbySearch_SetMaxResults",
-        "EOS_LobbySearch_SetParameter",
-        "EOS_LobbySearch_SetTargetUserId",
-        "EOS_LobbyModification_AddAttribute",
-        "EOS_LobbyModification_AddMemberAttribute",
-        "EOS_LobbyModification_Release",
-        "EOS_LobbyModification_RemoveAttribute",
-        "EOS_LobbyModification_RemoveMemberAttribute",
-        "EOS_LobbyModification_SetAllowedPlatformIds",
-        "EOS_LobbyModification_SetBucketId",
-        "EOS_LobbyModification_SetInvitesAllowed",
-        "EOS_LobbyModification_SetMaxMembers",
-        "EOS_LobbyModification_SetPermissionLevel",
-        "EOS_Lobby_UpdateLobbyModification",
-        "EOS_LobbyDetails_CopyAttributeByIndex",
-        "EOS_LobbyDetails_CopyAttributeByKey",
-        "EOS_LobbyDetails_CopyMemberAttributeByIndex",
-        "EOS_LobbyDetails_CopyMemberAttributeByKey",
-        "EOS_LobbyDetails_CopyMemberInfo",
-        "EOS_LobbyDetails_GetAttributeCount",
-        "EOS_LobbyDetails_GetMemberAttributeCount",
-        "EOS_LobbyDetails_GetMemberByIndex",
-        "EOS_LobbyDetails_GetMemberCount",
-        "EOS_LobbyDetails_Info_Release",
-        "EOS_LobbyDetails_MemberInfo_Release",
-        "EOS_Lobby_CopyLobbyDetailsHandle",
-        "EOS_Lobby_CopyLobbyDetailsHandleByInviteId",
-        "EOS_Lobby_CopyLobbyDetailsHandleByUiEventId",
-        "EOS_Lobby_UpdateLobby",
-        "EOS_Lobby_DestroyLobby",
-        "EOS_Lobby_LeaveLobby",
-        "EOS_Lobby_AddNotifyLobbyMemberStatusReceived",
-        "EOS_Lobby_RemoveNotifyLobbyMemberStatusReceived",
-        "EOS_Lobby_AddNotifyLobbyMemberUpdateReceived",
-        "EOS_Lobby_RemoveNotifyLobbyMemberUpdateReceived",
-        "EOS_Lobby_IsRTCRoomConnected",
-        "EOS_Lobby_GetRTCRoomName",
-        "EOS_Lobby_Attribute_Release",
-        "EOS_Connect_CopyIdToken",
-        "EOS_Connect_IdToken_Release",
-        "EOS_Connect_VerifyIdToken",
-        "EOS_Platform_Tick",
-        "EOS_Lobby_IsLobbyOwner",
-        "EOS_Lobby_GetInviteCount",
-        "EOS_Lobby_CopyInviteIdByIndex",
-        "EOS_Lobby_GetConnectString",
-        "EOS_Lobby_ParseConnectString",
-        "EOS_Platform_GetActiveCountryCode",
-        "EOS_Platform_GetActiveLocaleCode",
-        "EOS_Connect_RemoveNotifyLoginStatusChanged",
-        "EOS_Connect_GetLoginStatus",
-        "EOS_Connect_AddNotifyLoginStatusChanged",
-        "EOS_Auth_GetLoginStatus",
-        "EOS_Lobby_JoinLobbyById",
-        "EOS_Logging_SetCallback",
-        "EOS_Logging_SetLogLevel",
-        "EOS_PlayerDataStorage_QueryFile",
-        "EOS_Sanctions_QueryActivePlayerSanctions",
-        "EOS_Sanctions_GetPlayerSanctionCount",
-        "EOS_Sanctions_CopyPlayerSanctionByIndex",
-
-    ]
-
-    funcs = []
-    for line in lines:
-        line = line.strip()
-        if not line: continue
-        parts = line.split()
-        if len(parts) >= 4:
-            funcs.append(parts[-1])
-            
-    with open('proxy_asm.s', 'w') as asm:
-        asm.write('.text\n')
-        for f in funcs:
-            if f not in hooks:
-                asm.write(f'.globl {f}\n')
-                asm.write(f'{f}:\n')
-                asm.write(f'    jmp *orig_{f}(%rip)\n\n')
-
-    with open('proxy_pointers.h', 'w') as hdr:
-        hdr.write('extern "C" {\n')
-        for f in funcs:
-            if f not in hooks:
-                hdr.write(f'    void* orig_{f} = nullptr;\n')
-        hdr.write('}\n\n')
-        hdr.write('void LoadOriginalFunctions(HMODULE hMod) {\n')
-        for f in funcs:
-            if f not in hooks:
-                hdr.write(f'    orig_{f} = (void*)GetProcAddress(hMod, "{f}");\n')
-        hdr.write('}\n')
-
-    with open('proxy.def', 'w') as out:
-        out.write('LIBRARY "EOSSDK-Win64-Shipping.dll"\n')
-        out.write('EXPORTS\n')
-        for f in funcs:
-            out.write(f'    {f}\n')
-
-if __name__ == "__main__":
-    main()

keyDumper/src/include/MinHook.h

@@ -1,185 +0,0 @@
-/*
- *  MinHook - The Minimalistic API Hooking Library for x64/x86
- *  Copyright (C) 2009-2017 Tsuda Kageyu.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *   2. 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 HOLDER
- *  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.
- */
-
-#pragma once
-
-#if !(defined _M_IX86) && !(defined _M_X64) && !(defined __i386__) && !(defined __x86_64__)
-    #error MinHook supports only x86 and x64 systems.
-#endif
-
-#include <windows.h>
-
-// MinHook Error Codes.
-typedef enum MH_STATUS
-{
-    // Unknown error. Should not be returned.
-    MH_UNKNOWN = -1,
-
-    // Successful.
-    MH_OK = 0,
-
-    // MinHook is already initialized.
-    MH_ERROR_ALREADY_INITIALIZED,
-
-    // MinHook is not initialized yet, or already uninitialized.
-    MH_ERROR_NOT_INITIALIZED,
-
-    // The hook for the specified target function is already created.
-    MH_ERROR_ALREADY_CREATED,
-
-    // The hook for the specified target function is not created yet.
-    MH_ERROR_NOT_CREATED,
-
-    // The hook for the specified target function is already enabled.
-    MH_ERROR_ENABLED,
-
-    // The hook for the specified target function is not enabled yet, or already
-    // disabled.
-    MH_ERROR_DISABLED,
-
-    // The specified pointer is invalid. It points the address of non-allocated
-    // and/or non-executable region.
-    MH_ERROR_NOT_EXECUTABLE,
-
-    // The specified target function cannot be hooked.
-    MH_ERROR_UNSUPPORTED_FUNCTION,
-
-    // Failed to allocate memory.
-    MH_ERROR_MEMORY_ALLOC,
-
-    // Failed to change the memory protection.
-    MH_ERROR_MEMORY_PROTECT,
-
-    // The specified module is not loaded.
-    MH_ERROR_MODULE_NOT_FOUND,
-
-    // The specified function is not found.
-    MH_ERROR_FUNCTION_NOT_FOUND
-}
-MH_STATUS;
-
-// Can be passed as a parameter to MH_EnableHook, MH_DisableHook,
-// MH_QueueEnableHook or MH_QueueDisableHook.
-#define MH_ALL_HOOKS NULL
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-    // Initialize the MinHook library. You must call this function EXACTLY ONCE
-    // at the beginning of your program.
-    MH_STATUS WINAPI MH_Initialize(VOID);
-
-    // Uninitialize the MinHook library. You must call this function EXACTLY
-    // ONCE at the end of your program.
-    MH_STATUS WINAPI MH_Uninitialize(VOID);
-
-    // Creates a hook for the specified target function, in disabled state.
-    // Parameters:
-    //   pTarget     [in]  A pointer to the target function, which will be
-    //                     overridden by the detour function.
-    //   pDetour     [in]  A pointer to the detour function, which will override
-    //                     the target function.
-    //   ppOriginal  [out] A pointer to the trampoline function, which will be
-    //                     used to call the original target function.
-    //                     This parameter can be NULL.
-    MH_STATUS WINAPI MH_CreateHook(LPVOID pTarget, LPVOID pDetour, LPVOID *ppOriginal);
-
-    // Creates a hook for the specified API function, in disabled state.
-    // Parameters:
-    //   pszModule   [in]  A pointer to the loaded module name which contains the
-    //                     target function.
-    //   pszProcName [in]  A pointer to the target function name, which will be
-    //                     overridden by the detour function.
-    //   pDetour     [in]  A pointer to the detour function, which will override
-    //                     the target function.
-    //   ppOriginal  [out] A pointer to the trampoline function, which will be
-    //                     used to call the original target function.
-    //                     This parameter can be NULL.
-    MH_STATUS WINAPI MH_CreateHookApi(
-        LPCWSTR pszModule, LPCSTR pszProcName, LPVOID pDetour, LPVOID *ppOriginal);
-
-    // Creates a hook for the specified API function, in disabled state.
-    // Parameters:
-    //   pszModule   [in]  A pointer to the loaded module name which contains the
-    //                     target function.
-    //   pszProcName [in]  A pointer to the target function name, which will be
-    //                     overridden by the detour function.
-    //   pDetour     [in]  A pointer to the detour function, which will override
-    //                     the target function.
-    //   ppOriginal  [out] A pointer to the trampoline function, which will be
-    //                     used to call the original target function.
-    //                     This parameter can be NULL.
-    //   ppTarget    [out] A pointer to the target function, which will be used
-    //                     with other functions.
-    //                     This parameter can be NULL.
-    MH_STATUS WINAPI MH_CreateHookApiEx(
-        LPCWSTR pszModule, LPCSTR pszProcName, LPVOID pDetour, LPVOID *ppOriginal, LPVOID *ppTarget);
-
-    // Removes an already created hook.
-    // Parameters:
-    //   pTarget [in] A pointer to the target function.
-    MH_STATUS WINAPI MH_RemoveHook(LPVOID pTarget);
-
-    // Enables an already created hook.
-    // Parameters:
-    //   pTarget [in] A pointer to the target function.
-    //                If this parameter is MH_ALL_HOOKS, all created hooks are
-    //                enabled in one go.
-    MH_STATUS WINAPI MH_EnableHook(LPVOID pTarget);
-
-    // Disables an already created hook.
-    // Parameters:
-    //   pTarget [in] A pointer to the target function.
-    //                If this parameter is MH_ALL_HOOKS, all created hooks are
-    //                disabled in one go.
-    MH_STATUS WINAPI MH_DisableHook(LPVOID pTarget);
-
-    // Queues to enable an already created hook.
-    // Parameters:
-    //   pTarget [in] A pointer to the target function.
-    //                If this parameter is MH_ALL_HOOKS, all created hooks are
-    //                queued to be enabled.
-    MH_STATUS WINAPI MH_QueueEnableHook(LPVOID pTarget);
-
-    // Queues to disable an already created hook.
-    // Parameters:
-    //   pTarget [in] A pointer to the target function.
-    //                If this parameter is MH_ALL_HOOKS, all created hooks are
-    //                queued to be disabled.
-    MH_STATUS WINAPI MH_QueueDisableHook(LPVOID pTarget);
-
-    // Applies all queued changes in one go.
-    MH_STATUS WINAPI MH_ApplyQueued(VOID);
-
-    // Translates the MH_STATUS to its name as a string.
-    const char * WINAPI MH_StatusToString(MH_STATUS status);
-
-#ifdef __cplusplus
-}
-#endif

keyDumper/src/main.c

@@ -1,538 +0,0 @@
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>
-#include <windows.h>
-#include "MinHook.h"
-
-static inline LONG AtomicRead(LONG *v) { return InterlockedCompareExchange(v, 0, 0); }
-static inline void AtomicWrite(LONG *v, LONG n) { InterlockedExchange(v, n); }
-
-FILE *logFile = NULL;
-char g_outDir[MAX_PATH] = {0};
-
-void Log(const char *fmt, ...) {
-    if (!logFile) return;
-    va_list ap; va_start(ap, fmt);
-    SYSTEMTIME st; GetLocalTime(&st);
-    fprintf(logFile, "[%02u:%02u:%02u.%03u] ", st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
-    vfprintf(logFile, fmt, ap); fprintf(logFile, "\n");
-    fflush(logFile);
-    va_end(ap);
-}
-
-void InitLogFiles(void) {
-    char p[MAX_PATH];
-    GetModuleFileNameA(NULL, p, MAX_PATH);
-    char *s = strrchr(p, '\\'); if (!s) s = strrchr(p, '/');
-    if (s) *(s+1) = '\0'; else p[0] = '\0';
-    strcpy(g_outDir, p);
-    strcat(p, "proxy_p2p.log");
-    logFile = fopen(p, "a");
-    if (logFile) {
-        setvbuf(logFile, NULL, _IOFBF, 1 << 16);
-        SYSTEMTIME st; GetLocalTime(&st);
-        fprintf(logFile, "\n===== Proxy (key-capture + scanner) %02u:%02u:%02u =====\n", st.wHour, st.wMinute, st.wSecond);
-        fflush(logFile);
-    }
-}
-
-void CloseLogFiles(void) {
-    if (logFile) { fclose(logFile); logFile = NULL; }
-}
-
-void ProxySdkLogCallback(const void *msg) {
-    Log("[SDK] log callback");
-    (void)msg;
-}
-
-typedef int32_t EOS_EResult;
-#define EOS_Success 0
-typedef void *EOS_ProductUserId;
-
-typedef void (*TickFn)(void*);
-typedef EOS_EResult (*SetLogCbFn)(void*);
-typedef EOS_EResult (*SetLogLvlFn)(int32_t, int32_t);
-
-static TickFn origTick = NULL;
-static SetLogCbFn origSetLogCb = NULL;
-static SetLogLvlFn origSetLogLvl = NULL;
-
-struct AuthLoginCbInfo {
-    int32_t rc; void *cd; void *lu; void *p1; void *p2; void *p3; void *sa;
-};
-typedef void (*AuthLoginCb)(const struct AuthLoginCbInfo *);
-
-struct ConnectLoginCbInfo {
-    int32_t rc; void *cd; void *lu; void *ct;
-};
-typedef void (*ConnectLoginCb)(const struct ConnectLoginCbInfo *);
-
-// Key capture GenerateKey (RVA 0x25F8650)
-// IL2CPP byte[] layout: klass(8) + monitor(8) + length(8) + data
-#define GENKEY_RVA       0x25F8650ULL
-#define BYTE_LEN(p)      (*(int32_t *)((uint8_t *)(p) + 0x18))
-#define BYTE_DATA(p)     ((uint8_t *)(p) + 0x20)
-
-// RVA definitions for hooks
-#define GENERATEIV_RVA       0x25F8720ULL
-#define GENERATEKEY_STR_RVA  0x25F86E0ULL
-#define LOADLOCAL_RVA        0x25E93C0ULL
-
-// IL2CPP string layout: klass(8) + monitor(8) + length(int32_t@+0x10) + chars(utf-16@+0x14)
-#define STR_LEN(p)    (*(int32_t*)((uint8_t*)(p) + 0x10))
-#define STR_CHARS(p)  ((uint16_t*)((uint8_t*)(p) + 0x14))
-
-static LONG g_keyDone = 0, g_claimed = 0;
-static LONG g_genKeyCallCount = 0;
-typedef uint8_t *(*GenKeyFn)(void*);
-
-static void WriteKeyRaw(const uint8_t *d, uint32_t len, const char *suffix) {
-    char p[MAX_PATH];
-    snprintf(p, sizeof(p), "%saes_key_%s.bin", g_outDir, suffix);
-    FILE *f = fopen(p, "wb");
-    if (f) { uint32_t n = len < 64 ? len : 64; fwrite(d, 1, n, f); fclose(f); }
-    Log("[Key] Wrote %u bytes to %s", len < 64 ? len : 64, p);
-}
-
-static void LogHex(const uint8_t *d, uint32_t len, const char *label) {
-    char hex[256] = {0};
-    for (uint32_t i = 0; i < len && i < 32; i++)
-        sprintf(hex + i*3, "%02X ", d[i]);
-    Log("[Key] %s (%u bytes): %s", label, len, hex);
-}
-
-static void CaptureGenerateKey(void) {
-    HMODULE ga = GetModuleHandleA("GameAssembly.dll");
-    if (!ga) { Log("[Key] GameAssembly.dll not loaded yet"); return; }
-    GenKeyFn fn = (GenKeyFn)((uint8_t*)ga + GENKEY_RVA);
-    uint32_t callNum = (uint32_t)InterlockedIncrement(&g_genKeyCallCount);
-    Log("[Key] Calling GenerateKey (call #%u) at %p", callNum, (void*)fn);
-    uint8_t *r = fn(NULL);
-    if (!r) { Log("[Key] GenerateKey returned NULL"); return; }
-    int32_t len = BYTE_LEN(r);
-    uint8_t *d = BYTE_DATA(r);
-    Log("[Key] GenerateKey #%u: %d bytes", callNum, len);
-    if (len > 0 && len <= 256) {
-        LogHex(d, (uint32_t)len, "GenerateKey result");
-        char suffix[32];
-        snprintf(suffix, sizeof(suffix), "genkey_%u", callNum);
-        WriteKeyRaw(d, (uint32_t)len, suffix);
-        if (!AtomicRead(&g_keyDone)) {
-            WriteKeyRaw(d, (uint32_t)len, "raw");
-            AtomicWrite(&g_keyDone, 1);
-            Log("[Key] *** Primary key captured! ***");
-        }
-    }
-}
-
-static void TryCaptureKeys(void) {
-    if (AtomicRead(&g_keyDone)) return;
-    if (InterlockedCompareExchange(&g_claimed, 1, 0)) return;
-    CaptureGenerateKey();
-    if (!AtomicRead(&g_keyDone)) AtomicWrite(&g_claimed, 0);
-}
-
-// Hooks for GenerateKey(), GenerateIV, GenerateKey(string), LoadLocal
-static void *g_original_GenerateKey = NULL;
-static void *g_original_GenerateIV = NULL;
-static void *g_original_GenerateKey_str = NULL;
-static void *g_original_LoadLocal = NULL;
-
-static LONG g_generateKey_count = 0;
-static LONG g_generateIV_count = 0;
-static LONG g_generateKey_str_count = 0;
-static LONG g_loadLocal_count = 0;
-
-static void WriteStringToFile(const char *filename, const uint16_t *chars, int32_t len) {
-    char p[MAX_PATH];
-    snprintf(p, sizeof(p), "%s%s", g_outDir, filename);
-    FILE *f = fopen(p, "w"); if (!f) return;
-    for (int i = 0; i < len; i++) fputc((char)(chars[i] < 128 ? chars[i] : '?'), f);
-    fclose(f);
-    Log("[Hook] Wrote %s", filename);
-}
-
-static void* GenerateIV_hook(void *ivSource, void *method) {
-    uint32_t callNum = (uint32_t)InterlockedIncrement(&g_generateIV_count);
-    if (ivSource) {
-        int32_t len = STR_LEN(ivSource);
-        uint16_t *chars = STR_CHARS(ivSource);
-        char buf[512] = {0};
-        for (int i = 0; i < len && i < 255; i++)
-            buf[i] = (char)(chars[i] < 128 ? chars[i] : '?');
-        Log("[Hook] GenerateIV #%u: \"%s\" (len=%d chars)", callNum, buf, len);
-        if (callNum == 1) WriteStringToFile("iv_source.txt", chars, len);
-    } else {
-        Log("[Hook] GenerateIV #%u: NULL", callNum);
-    }
-    return ((void* (*)(void*, void*))g_original_GenerateIV)(ivSource, method);
-}
-
-static void* GenerateKey_str_hook(void *keySource, void *method) {
-    uint32_t callNum = (uint32_t)InterlockedIncrement(&g_generateKey_str_count);
-    if (keySource) {
-        int32_t len = STR_LEN(keySource);
-        uint16_t *chars = STR_CHARS(keySource);
-        char buf[512] = {0};
-        for (int i = 0; i < len && i < 255; i++)
-            buf[i] = (char)(chars[i] < 128 ? chars[i] : '?');
-        Log("[Hook] GenerateKey(string) #%u: \"%s\" (len=%d chars)", callNum, buf, len);
-        if (callNum == 1) WriteStringToFile("key_source.txt", chars, len);
-    } else {
-        Log("[Hook] GenerateKey(string) #%u: NULL", callNum);
-    }
-    return ((void* (*)(void*, void*))g_original_GenerateKey_str)(keySource, method);
-}
-
-// Hook for GenerateKey() no-arg (RVA 0x25F8650) - logs when bundle loading triggers key derivation
-static void* GenerateKey_noarg_hook(void *method) {
-    uint32_t callNum = (uint32_t)InterlockedIncrement(&g_generateKey_count);
-    void *result = ((void* (*)(void*))g_original_GenerateKey)(method);
-    if (result) {
-        int32_t len = BYTE_LEN(result);
-        Log("[Hook] GenerateKey() #%u: %d bytes", callNum, len);
-        LogHex(BYTE_DATA(result), (uint32_t)(len > 32 ? 32 : len), "GenerateKey() result");
-        if (callNum == 1) {
-            WriteKeyRaw(BYTE_DATA(result), (uint32_t)len, "genkey_hook_1");
-        }
-    }
-    return result;
-}
-
-// Hook for EncryptAssetBundleResource.LoadLocal (RVA 0x25E93C0)
-static void LoadLocal_hook(void *this_ptr, void *method) {
-    uint32_t callNum = (uint32_t)InterlockedIncrement(&g_loadLocal_count);
-    Log("[Hook] EncryptAssetBundleResource.LoadLocal #%u called (this=%p)", callNum, this_ptr);
-    if (this_ptr) {
-        // path field at offset +0x48 (Il2CppString*)
-        void *pathStr = *(void**)((uint8_t*)this_ptr + 0x48);
-        if (pathStr) {
-            int32_t len = STR_LEN(pathStr);
-            uint16_t *chars = STR_CHARS(pathStr);
-            char buf[512] = {0};
-            for (int i = 0; i < len && i < 255; i++)
-                buf[i] = (char)(chars[i] < 128 ? chars[i] : '?');
-            Log("[Hook]   Bundle path: \"%s\" (len=%d chars)", buf, len);
-        }
-    }
-    ((void (*)(void*, void*))g_original_LoadLocal)(this_ptr, method);
-}
-
-static LONG g_hooksInstalled = 0;
-
-static void InstallHooks(void) {
-    if (InterlockedCompareExchange(&g_hooksInstalled, 1, 0)) return;
-    HMODULE ga = GetModuleHandleA("GameAssembly.dll");
-    if (!ga) { AtomicWrite(&g_hooksInstalled, 0); return; }
-
-    if (MH_Initialize() != MH_OK) {
-        Log("[Hook] MH_Initialize FAILED"); AtomicWrite(&g_hooksInstalled, 0); return;
-    }
-    Log("[Hook] GameAssembly @ %p, installing hooks...", (void*)ga);
-
-    MH_STATUS s;
-    #define HOOK(RVA, handler, orig) do { \
-        s = MH_CreateHook((uint8_t*)ga + (RVA), (handler), (void**)&(orig)); \
-        if (s == MH_OK) { MH_EnableHook((uint8_t*)ga + (RVA)); Log("[Hook] OK " #handler); } \
-        else Log("[Hook] FAIL " #handler " (%d)", s); \
-    } while(0)
-
-    HOOK(GENKEY_RVA,          GenerateKey_noarg_hook,      g_original_GenerateKey);
-    HOOK(GENERATEIV_RVA,      GenerateIV_hook,             g_original_GenerateIV);
-    HOOK(GENERATEKEY_STR_RVA, GenerateKey_str_hook,        g_original_GenerateKey_str);
-    HOOK(LOADLOCAL_RVA,       LoadLocal_hook,              g_original_LoadLocal);
-    #undef HOOK
-    Log("[Hook] All hooks installed");
-}
-
-// Memory scanner for UnityFS bundles + key search
-#define SCAN_DELAY_MS 30000
-#define MAX_BUNDLES 2000
-
-static LONG g_scanStarted = 0;
-static LONG g_scanDone = 0;
-static int g_bundleCount = 0;
-
-// The known save key in UTF-8 and UTF-16
-static const uint8_t kSaveKeyUTF8[]  = "rK7CcATuZk7LAmhqqU4iBLNmAq8QbK3s";
-// UTF-16LE: alternating bytes with 0x00
-static const uint8_t kSaveKeyUTF16[] = {
-    'r',0,'K',0,'7',0,'C',0,'c',0,'A',0,'T',0,'u',0,
-    'Z',0,'k',0,'7',0,'L',0,'A',0,'m',0,'h',0,'q',0,
-    'q',0,'U',0,'4',0,'i',0,'B',0,'L',0,'N',0,'m',0,
-    'A',0,'q',0,'8',0,'Q',0,'b',0,'K',0,'3',0,'s',0
-};
-#define SAVEKEY_UTF8_LEN  32
-#define SAVEKEY_UTF16_LEN 64
-
-static void DumpBundleSafe(const void *addr, size_t avail) {
-    char dir[MAX_PATH];
-    snprintf(dir, sizeof(dir), "%sBundles", g_outDir);
-    CreateDirectoryA(dir, NULL);
-
-    size_t dumpSize = avail > (50 * 1024 * 1024) ? (50 * 1024 * 1024) : avail;
-    uint8_t *buf = (uint8_t*)malloc(dumpSize);
-    if (!buf) { Log("[Scan] OOM for bundle %d", g_bundleCount); return; }
-
-    SIZE_T read = 0;
-    if (!ReadProcessMemory(GetCurrentProcess(), addr, buf, dumpSize, &read) || read == 0) {
-        Log("[Scan] ReadProcessMemory failed for bundle %d", g_bundleCount);
-        free(buf);
-        return;
-    }
-
-    char path[MAX_PATH];
-    snprintf(path, sizeof(path), "%s\\bundle_%04d.unity3d", dir, g_bundleCount);
-
-    FILE *f = fopen(path, "wb");
-    if (!f) { Log("[Scan] FAILED to create %s", path); free(buf); return; }
-
-    fwrite(buf, 1, read, f);
-    fclose(f);
-    Log("[Scan] Dumped bundle %d: %zu bytes -> %s", g_bundleCount, read, path);
-    g_bundleCount++;
-    free(buf);
-}
-
-// Scan around an address for potential key strings (32-byte printable)
-static void ScanForKeysNear(const uint8_t *addr, size_t region_size) {
-    // Search for 32+ contiguous printable ASCII bytes
-    for (size_t i = 0; i < region_size - 32; i++) {
-        int is_printable = 1;
-        for (int j = 0; j < 32; j++) {
-            if (addr[i+j] < 0x20 || addr[i+j] > 0x7E) { is_printable = 0; break; }
-        }
-        if (is_printable) {
-            char buf[64] = {0};
-            memcpy(buf, addr + i, 32);
-            // Skip if it's the known save key
-            if (memcmp(buf, kSaveKeyUTF8, 32) == 0) continue;
-            Log("[KeyScan] Found 32-byte printable at region+0x%zX: \"%s\"", i, buf);
-            i += 31; // skip past it
-        }
-    }
-}
-
-// Try to find the save key string in memory (in IL2CPP UTF-16 format)
-// and dump context around it to find adjacent key source strings
-static void FindKeyStringInMemory(const uint8_t *start, size_t size, const char *region_tag) {
-    // Search for the save key in UTF-16LE
-    for (size_t i = 0; i < size - SAVEKEY_UTF16_LEN; i++) {
-        if (memcmp(start + i, kSaveKeyUTF16, SAVEKEY_UTF16_LEN) == 0) {
-            Log("[KeyScan] Found save key (UTF-16) at %s+0x%zX", region_tag, i);
-            // Dump 256 bytes before and after for analysis
-            size_t dump_start = (i >= 128) ? (i - 128) : 0;
-            size_t dump_end = (i + SAVEKEY_UTF16_LEN + 128 < size) ? (i + SAVEKEY_UTF16_LEN + 128) : size;
-            size_t dump_len = dump_end - dump_start;
-
-            // Search for other UTF-16 strings nearby (potential bundle key)
-            for (size_t j = dump_start; j < dump_end - 4; j++) {
-                // Check if this starts a reasonable UTF-16 string (all ASCII chars)
-                int utf16_str_len = 0;
-                for (int k = 0; j + k*2 + 1 < dump_end; k++) {
-                    uint8_t c = start[j + k*2];
-                    uint8_t z = start[j + k*2 + 1];
-                    if (c >= 0x20 && c <= 0x7E && z == 0) utf16_str_len++;
-                    else break;
-                }
-                if (utf16_str_len >= 8 && utf16_str_len <= 64) {
-                    // Skip if it's the save key itself
-                    if (j >= i - 4 && j <= i + 4) continue;
-                    char str[128] = {0};
-                    for (int k = 0; k < utf16_str_len && k < 64; k++)
-                        str[k] = start[j + k*2];
-                    Log("[KeyScan]   Nearby UTF-16 string at +0x%zX (len=%d): \"%s\"",
-                        j - dump_start, utf16_str_len, str);
-                    j += utf16_str_len * 2 - 1;
-                }
-            }
-
-            // Also dump raw hex of the area for later analysis
-            char hex[2048] = {0};
-            uint32_t hex_show = dump_len > 200 ? 200 : (uint32_t)dump_len;
-            for (uint32_t k = 0; k < hex_show && k*3 < 2044; k++)
-                sprintf(hex + k*3, "%02X ", start[dump_start + k]);
-            Log("[KeyScan]   Context hex (%u bytes): %s", hex_show, hex);
-        }
-    }
-}
-
-#define SCAN_CHUNK (1024 * 1024) // 1 MB chunks
-
-static int ScanChunk(const uint8_t *addr, size_t size, int region_idx) {
-    // Read memory safely using ReadProcessMemory
-    uint8_t *buf = (uint8_t*)malloc(size);
-    if (!buf) return 0;
-    SIZE_T read = 0;
-    BOOL ok = ReadProcessMemory(GetCurrentProcess(), addr, buf, size, &read);
-    if (!ok || read != size) { free(buf); return 0; }
-
-    // Scan for UnityFS
-    uint8_t *p = buf;
-    uint8_t *end = buf + read;
-    while (p < end - 7) {
-        p = (uint8_t*)memchr(p, 'U', end - p - 7);
-        if (!p) break;
-        if (p[1]=='n' && p[2]=='i' && p[3]=='t' && p[4]=='y' && p[5]=='F' && p[6]=='S') {
-            size_t offset = p - buf;
-            size_t remaining = read - offset;
-            Log("[Scan] Found UnityFS in region %d at offset 0x%zX, dumping %zu bytes",
-                region_idx, offset, remaining);
-            // Dump using the original address, not the buffer
-            DumpBundleSafe(addr + offset, remaining);
-            p += 16;
-            free(buf);
-            return 1; // found one, caller handles counting
-        } else {
-            p++;
-        }
-    }
-
-    // Search for save key
-    FindKeyStringInMemory(buf, read, "chunk");
-
-    free(buf);
-    return 0;
-}
-
-DWORD WINAPI MemoryScanThread(LPVOID param) {
-    (void)param;
-    Log("[Scan] Thread started, sleeping %u ms...", SCAN_DELAY_MS);
-    Sleep(SCAN_DELAY_MS);
-    Log("[Scan] Waking up, starting comprehensive memory scan...");
-
-    SYSTEM_INFO si;
-    GetSystemInfo(&si);
-
-    MEMORY_BASIC_INFORMATION mbi;
-    LPVOID addr = si.lpMinimumApplicationAddress;
-    uint64_t totalScanned = 0;
-    uint64_t maxScan = 6ULL * 1024 * 1024 * 1024;
-    int scannedRegions = 0;
-
-    while (addr < si.lpMaximumApplicationAddress && totalScanned < maxScan) {
-        if (!VirtualQuery(addr, &mbi, sizeof(mbi))) {
-            addr = (uint8_t*)addr + 0x10000;
-            continue;
-        }
-
-        if (mbi.State == MEM_COMMIT && mbi.RegionSize > 0 && mbi.RegionSize < 200*1024*1024) {
-            uint8_t *region_start = (uint8_t*)mbi.BaseAddress;
-            size_t rsize = mbi.RegionSize;
-            totalScanned += rsize;
-            scannedRegions++;
-
-            // Scan this region in chunks to avoid large allocations
-            for (size_t off = 0; off < rsize && g_bundleCount < MAX_BUNDLES; off += SCAN_CHUNK) {
-                size_t chunk = (rsize - off) > SCAN_CHUNK ? SCAN_CHUNK : (rsize - off);
-                int found = ScanChunk(region_start + off, chunk, scannedRegions);
-                if (found) {
-                    Log("[Scan] Bundle found in region %d chunk 0x%zX", scannedRegions, off);
-                }
-            }
-        }
-
-        addr = (uint8_t*)mbi.BaseAddress + mbi.RegionSize;
-    }
-
-    Log("[Scan] Scan complete: scanned %llu bytes in %d regions, found %d bundles",
-        totalScanned, scannedRegions, g_bundleCount);
-    AtomicWrite(&g_scanDone, 1);
-    return 0;
-}
-
-static void TryStartScanThread(void) {
-    if (AtomicRead(&g_scanStarted)) return;
-    if (InterlockedCompareExchange(&g_scanStarted, 1, 0)) return;
-    Log("[Scan] Creating memory scan thread...");
-    HANDLE hThread = CreateThread(NULL, 0, MemoryScanThread, NULL, 0, NULL);
-    if (hThread) {
-        CloseHandle(hThread);
-        Log("[Scan] Thread created successfully");
-    } else {
-        Log("[Scan] Failed to create thread (err=%lu)", GetLastError());
-        AtomicWrite(&g_scanStarted, 0);
-    }
-}
-
-// Custom exports (not forwarded to original SDK)
-__declspec(dllexport) void EOS_Platform_Tick(void *h) {
-    if (origTick) origTick(h);
-    TryCaptureKeys();
-    InstallHooks();
-    TryStartScanThread();
-}
-
-__declspec(dllexport) EOS_EResult EOS_Logging_SetCallback(void *cb) {
-    return origSetLogCb ? origSetLogCb(cb) : EOS_Success;
-}
-
-__declspec(dllexport) EOS_EResult EOS_Logging_SetLogLevel(int32_t cat, int32_t lvl) {
-    return origSetLogLvl ? origSetLogLvl(cat, lvl) : EOS_Success;
-}
-
-__declspec(dllexport) void EOS_Auth_Login(void *h, const void *o, void *cd, AuthLoginCb cb) {
-    Log("[Auth] EOS_Auth_Login called");
-    if (cb) { struct AuthLoginCbInfo i = {EOS_Success,cd,(void*)1,0,0,0,(void*)1}; cb(&i); }
-}
-
-__declspec(dllexport) int32_t EOS_Auth_GetLoginStatus(void *h, void *u) { (void)h; (void)u; return 2; }
-
-__declspec(dllexport) void EOS_Connect_Login(void *h, const void *o, void *cd, ConnectLoginCb cb) {
-    Log("[Connect] EOS_Connect_Login called");
-    if (cb) { struct ConnectLoginCbInfo i = {EOS_Success,cd,(void*)1,0}; cb(&i); }
-}
-
-__declspec(dllexport) int32_t EOS_Connect_GetLoginStatus(void *h, void *u) { (void)h; (void)u; return 2; }
-
-__declspec(dllexport) void *EOS_EpicAccountId_FromString(const char *s) { (void)s; return (void*)1; }
-__declspec(dllexport) int32_t EOS_EpicAccountId_IsValid(void *u) { (void)u; return 1; }
-__declspec(dllexport) void *EOS_ProductUserId_FromString(const char *s) { (void)s; return (void*)1; }
-__declspec(dllexport) int32_t EOS_ProductUserId_IsValid(void *u) { (void)u; return 1; }
-
-__declspec(dllexport) EOS_EResult EOS_ProductUserId_ToString(void *u, char *b, int32_t *l) {
-    (void)u; if (!b || !l) return 4;
-    const char *v = "DIRECTIP_PUID";
-    int32_t n = (int32_t)strlen(v)+1;
-    if (*l < n) { *l = n; return 4; }
-    memcpy(b, v, n); *l = n; return 0;
-}
-
-BOOL APIENTRY DllMain(HMODULE m, DWORD reason, LPVOID r) {
-    (void)r;
-    if (reason == DLL_PROCESS_ATTACH) {
-        DisableThreadLibraryCalls(m);
-        InitLogFiles();
-        Log("[Dll] Key-capture+scan proxy loaded. PID=%lu", GetCurrentProcessId());
-        char p[MAX_PATH];
-        GetModuleFileNameA(m, p, MAX_PATH);
-        char *s = strrchr(p, '\\'); if (!s) s = strrchr(p, '/');
-        if (s) *(s+1) = '\0'; else p[0] = '\0';
-        strcat(p, "EOSSDK-Win64-Shipping_orig.dll");
-        HMODULE o = LoadLibraryA(p);
-        if (o) {
-            origTick = (TickFn)GetProcAddress(o, "EOS_Platform_Tick");
-            origSetLogCb = (SetLogCbFn)GetProcAddress(o, "EOS_Logging_SetCallback");
-            origSetLogLvl = (SetLogLvlFn)GetProcAddress(o, "EOS_Logging_SetLogLevel");
-            Log("[Dll] Orig SDK loaded. Tick=%p LogCb=%p LogLvl=%p",
-                (void*)origTick, (void*)origSetLogCb, (void*)origSetLogLvl);
-            if (origSetLogCb) {
-                origSetLogCb(ProxySdkLogCallback);
-                if (origSetLogLvl) origSetLogLvl(0x7FFFFFFF, 6);
-            }
-        } else Log("[Dll] Failed to load orig SDK (err=%lu)", GetLastError());
-
-        // Create output directories
-        char dir[MAX_PATH];
-        snprintf(dir, sizeof(dir), "%sBundles", g_outDir);
-        CreateDirectoryA(dir, NULL);
-        Log("[Dll] Proxy ready / key capture + memory scanner armed");
-    } else if (reason == DLL_PROCESS_DETACH) {
-        if (AtomicRead(&g_scanStarted) && !AtomicRead(&g_scanDone)) {
-            Log("[Dll] Process detach but scan thread still running!");
-        }
-        CloseLogFiles();
-    }
-    return TRUE;
-}

keyDumper/src/src/buffer.c

@@ -1,312 +0,0 @@
-/*
- *  MinHook - The Minimalistic API Hooking Library for x64/x86
- *  Copyright (C) 2009-2017 Tsuda Kageyu.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *   2. 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 HOLDER
- *  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.
- */
-
-#include <windows.h>
-#include "buffer.h"
-
-// Size of each memory block. (= page size of VirtualAlloc)
-#define MEMORY_BLOCK_SIZE 0x1000
-
-// Max range for seeking a memory block. (= 1024MB)
-#define MAX_MEMORY_RANGE 0x40000000
-
-// Memory protection flags to check the executable address.
-#define PAGE_EXECUTE_FLAGS \
-    (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)
-
-// Memory slot.
-typedef struct _MEMORY_SLOT
-{
-    union
-    {
-        struct _MEMORY_SLOT *pNext;
-        UINT8 buffer[MEMORY_SLOT_SIZE];
-    };
-} MEMORY_SLOT, *PMEMORY_SLOT;
-
-// Memory block info. Placed at the head of each block.
-typedef struct _MEMORY_BLOCK
-{
-    struct _MEMORY_BLOCK *pNext;
-    PMEMORY_SLOT pFree;         // First element of the free slot list.
-    UINT usedCount;
-} MEMORY_BLOCK, *PMEMORY_BLOCK;
-
-//-------------------------------------------------------------------------
-// Global Variables:
-//-------------------------------------------------------------------------
-
-// First element of the memory block list.
-PMEMORY_BLOCK g_pMemoryBlocks;
-
-//-------------------------------------------------------------------------
-VOID InitializeBuffer(VOID)
-{
-    // Nothing to do for now.
-}
-
-//-------------------------------------------------------------------------
-VOID UninitializeBuffer(VOID)
-{
-    PMEMORY_BLOCK pBlock = g_pMemoryBlocks;
-    g_pMemoryBlocks = NULL;
-
-    while (pBlock)
-    {
-        PMEMORY_BLOCK pNext = pBlock->pNext;
-        VirtualFree(pBlock, 0, MEM_RELEASE);
-        pBlock = pNext;
-    }
-}
-
-//-------------------------------------------------------------------------
-#if defined(_M_X64) || defined(__x86_64__)
-static LPVOID FindPrevFreeRegion(LPVOID pAddress, LPVOID pMinAddr, DWORD dwAllocationGranularity)
-{
-    ULONG_PTR tryAddr = (ULONG_PTR)pAddress;
-
-    // Round down to the allocation granularity.
-    tryAddr -= tryAddr % dwAllocationGranularity;
-
-    // Start from the previous allocation granularity multiply.
-    tryAddr -= dwAllocationGranularity;
-
-    while (tryAddr >= (ULONG_PTR)pMinAddr)
-    {
-        MEMORY_BASIC_INFORMATION mbi;
-        if (VirtualQuery((LPVOID)tryAddr, &mbi, sizeof(mbi)) == 0)
-            break;
-
-        if (mbi.State == MEM_FREE)
-            return (LPVOID)tryAddr;
-
-        if ((ULONG_PTR)mbi.AllocationBase < dwAllocationGranularity)
-            break;
-
-        tryAddr = (ULONG_PTR)mbi.AllocationBase - dwAllocationGranularity;
-    }
-
-    return NULL;
-}
-#endif
-
-//-------------------------------------------------------------------------
-#if defined(_M_X64) || defined(__x86_64__)
-static LPVOID FindNextFreeRegion(LPVOID pAddress, LPVOID pMaxAddr, DWORD dwAllocationGranularity)
-{
-    ULONG_PTR tryAddr = (ULONG_PTR)pAddress;
-
-    // Round down to the allocation granularity.
-    tryAddr -= tryAddr % dwAllocationGranularity;
-
-    // Start from the next allocation granularity multiply.
-    tryAddr += dwAllocationGranularity;
-
-    while (tryAddr <= (ULONG_PTR)pMaxAddr)
-    {
-        MEMORY_BASIC_INFORMATION mbi;
-        if (VirtualQuery((LPVOID)tryAddr, &mbi, sizeof(mbi)) == 0)
-            break;
-
-        if (mbi.State == MEM_FREE)
-            return (LPVOID)tryAddr;
-
-        tryAddr = (ULONG_PTR)mbi.BaseAddress + mbi.RegionSize;
-
-        // Round up to the next allocation granularity.
-        tryAddr += dwAllocationGranularity - 1;
-        tryAddr -= tryAddr % dwAllocationGranularity;
-    }
-
-    return NULL;
-}
-#endif
-
-//-------------------------------------------------------------------------
-static PMEMORY_BLOCK GetMemoryBlock(LPVOID pOrigin)
-{
-    PMEMORY_BLOCK pBlock;
-#if defined(_M_X64) || defined(__x86_64__)
-    ULONG_PTR minAddr;
-    ULONG_PTR maxAddr;
-
-    SYSTEM_INFO si;
-    GetSystemInfo(&si);
-    minAddr = (ULONG_PTR)si.lpMinimumApplicationAddress;
-    maxAddr = (ULONG_PTR)si.lpMaximumApplicationAddress;
-
-    // pOrigin ± 512MB
-    if ((ULONG_PTR)pOrigin > MAX_MEMORY_RANGE && minAddr < (ULONG_PTR)pOrigin - MAX_MEMORY_RANGE)
-        minAddr = (ULONG_PTR)pOrigin - MAX_MEMORY_RANGE;
-
-    if (maxAddr > (ULONG_PTR)pOrigin + MAX_MEMORY_RANGE)
-        maxAddr = (ULONG_PTR)pOrigin + MAX_MEMORY_RANGE;
-
-    // Make room for MEMORY_BLOCK_SIZE bytes.
-    maxAddr -= MEMORY_BLOCK_SIZE - 1;
-#endif
-
-    // Look the registered blocks for a reachable one.
-    for (pBlock = g_pMemoryBlocks; pBlock != NULL; pBlock = pBlock->pNext)
-    {
-#if defined(_M_X64) || defined(__x86_64__)
-        // Ignore the blocks too far.
-        if ((ULONG_PTR)pBlock < minAddr || (ULONG_PTR)pBlock >= maxAddr)
-            continue;
-#endif
-        // The block has at least one unused slot.
-        if (pBlock->pFree != NULL)
-            return pBlock;
-    }
-
-#if defined(_M_X64) || defined(__x86_64__)
-    // Alloc a new block above if not found.
-    {
-        LPVOID pAlloc = pOrigin;
-        while ((ULONG_PTR)pAlloc >= minAddr)
-        {
-            pAlloc = FindPrevFreeRegion(pAlloc, (LPVOID)minAddr, si.dwAllocationGranularity);
-            if (pAlloc == NULL)
-                break;
-
-            pBlock = (PMEMORY_BLOCK)VirtualAlloc(
-                pAlloc, MEMORY_BLOCK_SIZE, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
-            if (pBlock != NULL)
-                break;
-        }
-    }
-
-    // Alloc a new block below if not found.
-    if (pBlock == NULL)
-    {
-        LPVOID pAlloc = pOrigin;
-        while ((ULONG_PTR)pAlloc <= maxAddr)
-        {
-            pAlloc = FindNextFreeRegion(pAlloc, (LPVOID)maxAddr, si.dwAllocationGranularity);
-            if (pAlloc == NULL)
-                break;
-
-            pBlock = (PMEMORY_BLOCK)VirtualAlloc(
-                pAlloc, MEMORY_BLOCK_SIZE, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
-            if (pBlock != NULL)
-                break;
-        }
-    }
-#else
-    // In x86 mode, a memory block can be placed anywhere.
-    pBlock = (PMEMORY_BLOCK)VirtualAlloc(
-        NULL, MEMORY_BLOCK_SIZE, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
-#endif
-
-    if (pBlock != NULL)
-    {
-        // Build a linked list of all the slots.
-        PMEMORY_SLOT pSlot = (PMEMORY_SLOT)pBlock + 1;
-        pBlock->pFree = NULL;
-        pBlock->usedCount = 0;
-        do
-        {
-            pSlot->pNext = pBlock->pFree;
-            pBlock->pFree = pSlot;
-            pSlot++;
-        } while ((ULONG_PTR)pSlot - (ULONG_PTR)pBlock <= MEMORY_BLOCK_SIZE - MEMORY_SLOT_SIZE);
-
-        pBlock->pNext = g_pMemoryBlocks;
-        g_pMemoryBlocks = pBlock;
-    }
-
-    return pBlock;
-}
-
-//-------------------------------------------------------------------------
-LPVOID AllocateBuffer(LPVOID pOrigin)
-{
-    PMEMORY_SLOT  pSlot;
-    PMEMORY_BLOCK pBlock = GetMemoryBlock(pOrigin);
-    if (pBlock == NULL)
-        return NULL;
-
-    // Remove an unused slot from the list.
-    pSlot = pBlock->pFree;
-    pBlock->pFree = pSlot->pNext;
-    pBlock->usedCount++;
-#ifdef _DEBUG
-    // Fill the slot with INT3 for debugging.
-    memset(pSlot, 0xCC, sizeof(MEMORY_SLOT));
-#endif
-    return pSlot;
-}
-
-//-------------------------------------------------------------------------
-VOID FreeBuffer(LPVOID pBuffer)
-{
-    PMEMORY_BLOCK pBlock = g_pMemoryBlocks;
-    PMEMORY_BLOCK pPrev = NULL;
-    ULONG_PTR pTargetBlock = ((ULONG_PTR)pBuffer / MEMORY_BLOCK_SIZE) * MEMORY_BLOCK_SIZE;
-
-    while (pBlock != NULL)
-    {
-        if ((ULONG_PTR)pBlock == pTargetBlock)
-        {
-            PMEMORY_SLOT pSlot = (PMEMORY_SLOT)pBuffer;
-#ifdef _DEBUG
-            // Clear the released slot for debugging.
-            memset(pSlot, 0x00, sizeof(MEMORY_SLOT));
-#endif
-            // Restore the released slot to the list.
-            pSlot->pNext = pBlock->pFree;
-            pBlock->pFree = pSlot;
-            pBlock->usedCount--;
-
-            // Free if unused.
-            if (pBlock->usedCount == 0)
-            {
-                if (pPrev)
-                    pPrev->pNext = pBlock->pNext;
-                else
-                    g_pMemoryBlocks = pBlock->pNext;
-
-                VirtualFree(pBlock, 0, MEM_RELEASE);
-            }
-
-            break;
-        }
-
-        pPrev = pBlock;
-        pBlock = pBlock->pNext;
-    }
-}
-
-//-------------------------------------------------------------------------
-BOOL IsExecutableAddress(LPVOID pAddress)
-{
-    MEMORY_BASIC_INFORMATION mi;
-    VirtualQuery(pAddress, &mi, sizeof(mi));
-
-    return (mi.State == MEM_COMMIT && (mi.Protect & PAGE_EXECUTE_FLAGS));
-}

keyDumper/src/src/buffer.h

@@ -1,42 +0,0 @@
-/*
- *  MinHook - The Minimalistic API Hooking Library for x64/x86
- *  Copyright (C) 2009-2017 Tsuda Kageyu.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *   2. 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 HOLDER
- *  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.
- */
-
-#pragma once
-
-// Size of each memory slot.
-#if defined(_M_X64) || defined(__x86_64__)
-    #define MEMORY_SLOT_SIZE 64
-#else
-    #define MEMORY_SLOT_SIZE 32
-#endif
-
-VOID   InitializeBuffer(VOID);
-VOID   UninitializeBuffer(VOID);
-LPVOID AllocateBuffer(LPVOID pOrigin);
-VOID   FreeBuffer(LPVOID pBuffer);
-BOOL   IsExecutableAddress(LPVOID pAddress);

keyDumper/src/src/hde/hde32.c

@@ -1,324 +0,0 @@
-/*
- * Hacker Disassembler Engine 32 C
- * Copyright (c) 2008-2009, Vyacheslav Patkov.
- * All rights reserved.
- *
- */
-
-#if defined(_M_IX86) || defined(__i386__)
-
-#include <string.h>
-#include "hde32.h"
-#include "table32.h"
-
-unsigned int hde32_disasm(const void *code, hde32s *hs)
-{
-    uint8_t x, c, *p = (uint8_t *)code, cflags, opcode, pref = 0;
-    uint8_t *ht = hde32_table, m_mod, m_reg, m_rm, disp_size = 0;
-
-    memset(hs, 0, sizeof(hde32s));
-
-    for (x = 16; x; x--)
-        switch (c = *p++) {
-            case 0xf3:
-                hs->p_rep = c;
-                pref |= PRE_F3;
-                break;
-            case 0xf2:
-                hs->p_rep = c;
-                pref |= PRE_F2;
-                break;
-            case 0xf0:
-                hs->p_lock = c;
-                pref |= PRE_LOCK;
-                break;
-            case 0x26: case 0x2e: case 0x36:
-            case 0x3e: case 0x64: case 0x65:
-                hs->p_seg = c;
-                pref |= PRE_SEG;
-                break;
-            case 0x66:
-                hs->p_66 = c;
-                pref |= PRE_66;
-                break;
-            case 0x67:
-                hs->p_67 = c;
-                pref |= PRE_67;
-                break;
-            default:
-                goto pref_done;
-        }
-  pref_done:
-
-    hs->flags = (uint32_t)pref << 23;
-
-    if (!pref)
-        pref |= PRE_NONE;
-
-    if ((hs->opcode = c) == 0x0f) {
-        hs->opcode2 = c = *p++;
-        ht += DELTA_OPCODES;
-    } else if (c >= 0xa0 && c <= 0xa3) {
-        if (pref & PRE_67)
-            pref |= PRE_66;
-        else
-            pref &= ~PRE_66;
-    }
-
-    opcode = c;
-    cflags = ht[ht[opcode / 4] + (opcode % 4)];
-
-    if (cflags == C_ERROR) {
-        hs->flags |= F_ERROR | F_ERROR_OPCODE;
-        cflags = 0;
-        if ((opcode & -3) == 0x24)
-            cflags++;
-    }
-
-    x = 0;
-    if (cflags & C_GROUP) {
-        uint16_t t;
-        t = *(uint16_t *)(ht + (cflags & 0x7f));
-        cflags = (uint8_t)t;
-        x = (uint8_t)(t >> 8);
-    }
-
-    if (hs->opcode2) {
-        ht = hde32_table + DELTA_PREFIXES;
-        if (ht[ht[opcode / 4] + (opcode % 4)] & pref)
-            hs->flags |= F_ERROR | F_ERROR_OPCODE;
-    }
-
-    if (cflags & C_MODRM) {
-        hs->flags |= F_MODRM;
-        hs->modrm = c = *p++;
-        hs->modrm_mod = m_mod = c >> 6;
-        hs->modrm_rm = m_rm = c & 7;
-        hs->modrm_reg = m_reg = (c & 0x3f) >> 3;
-
-        if (x && ((x << m_reg) & 0x80))
-            hs->flags |= F_ERROR | F_ERROR_OPCODE;
-
-        if (!hs->opcode2 && opcode >= 0xd9 && opcode <= 0xdf) {
-            uint8_t t = opcode - 0xd9;
-            if (m_mod == 3) {
-                ht = hde32_table + DELTA_FPU_MODRM + t*8;
-                t = ht[m_reg] << m_rm;
-            } else {
-                ht = hde32_table + DELTA_FPU_REG;
-                t = ht[t] << m_reg;
-            }
-            if (t & 0x80)
-                hs->flags |= F_ERROR | F_ERROR_OPCODE;
-        }
-
-        if (pref & PRE_LOCK) {
-            if (m_mod == 3) {
-                hs->flags |= F_ERROR | F_ERROR_LOCK;
-            } else {
-                uint8_t *table_end, op = opcode;
-                if (hs->opcode2) {
-                    ht = hde32_table + DELTA_OP2_LOCK_OK;
-                    table_end = ht + DELTA_OP_ONLY_MEM - DELTA_OP2_LOCK_OK;
-                } else {
-                    ht = hde32_table + DELTA_OP_LOCK_OK;
-                    table_end = ht + DELTA_OP2_LOCK_OK - DELTA_OP_LOCK_OK;
-                    op &= -2;
-                }
-                for (; ht != table_end; ht++)
-                    if (*ht++ == op) {
-                        if (!((*ht << m_reg) & 0x80))
-                            goto no_lock_error;
-                        else
-                            break;
-                    }
-                hs->flags |= F_ERROR | F_ERROR_LOCK;
-              no_lock_error:
-                ;
-            }
-        }
-
-        if (hs->opcode2) {
-            switch (opcode) {
-                case 0x20: case 0x22:
-                    m_mod = 3;
-                    if (m_reg > 4 || m_reg == 1)
-                        goto error_operand;
-                    else
-                        goto no_error_operand;
-                case 0x21: case 0x23:
-                    m_mod = 3;
-                    if (m_reg == 4 || m_reg == 5)
-                        goto error_operand;
-                    else
-                        goto no_error_operand;
-            }
-        } else {
-            switch (opcode) {
-                case 0x8c:
-                    if (m_reg > 5)
-                        goto error_operand;
-                    else
-                        goto no_error_operand;
-                case 0x8e:
-                    if (m_reg == 1 || m_reg > 5)
-                        goto error_operand;
-                    else
-                        goto no_error_operand;
-            }
-        }
-
-        if (m_mod == 3) {
-            uint8_t *table_end;
-            if (hs->opcode2) {
-                ht = hde32_table + DELTA_OP2_ONLY_MEM;
-                table_end = ht + sizeof(hde32_table) - DELTA_OP2_ONLY_MEM;
-            } else {
-                ht = hde32_table + DELTA_OP_ONLY_MEM;
-                table_end = ht + DELTA_OP2_ONLY_MEM - DELTA_OP_ONLY_MEM;
-            }
-            for (; ht != table_end; ht += 2)
-                if (*ht++ == opcode) {
-                    if ((*ht++ & pref) && !((*ht << m_reg) & 0x80))
-                        goto error_operand;
-                    else
-                        break;
-                }
-            goto no_error_operand;
-        } else if (hs->opcode2) {
-            switch (opcode) {
-                case 0x50: case 0xd7: case 0xf7:
-                    if (pref & (PRE_NONE | PRE_66))
-                        goto error_operand;
-                    break;
-                case 0xd6:
-                    if (pref & (PRE_F2 | PRE_F3))
-                        goto error_operand;
-                    break;
-                case 0xc5:
-                    goto error_operand;
-            }
-            goto no_error_operand;
-        } else
-            goto no_error_operand;
-
-      error_operand:
-        hs->flags |= F_ERROR | F_ERROR_OPERAND;
-      no_error_operand:
-
-        c = *p++;
-        if (m_reg <= 1) {
-            if (opcode == 0xf6)
-                cflags |= C_IMM8;
-            else if (opcode == 0xf7)
-                cflags |= C_IMM_P66;
-        }
-
-        switch (m_mod) {
-            case 0:
-                if (pref & PRE_67) {
-                    if (m_rm == 6)
-                        disp_size = 2;
-                } else
-                    if (m_rm == 5)
-                        disp_size = 4;
-                break;
-            case 1:
-                disp_size = 1;
-                break;
-            case 2:
-                disp_size = 2;
-                if (!(pref & PRE_67))
-                    disp_size <<= 1;
-                break;
-        }
-
-        if (m_mod != 3 && m_rm == 4 && !(pref & PRE_67)) {
-            hs->flags |= F_SIB;
-            p++;
-            hs->sib = c;
-            hs->sib_scale = c >> 6;
-            hs->sib_index = (c & 0x3f) >> 3;
-            if ((hs->sib_base = c & 7) == 5 && !(m_mod & 1))
-                disp_size = 4;
-        }
-
-        p--;
-        switch (disp_size) {
-            case 1:
-                hs->flags |= F_DISP8;
-                hs->disp.disp8 = *p;
-                break;
-            case 2:
-                hs->flags |= F_DISP16;
-                hs->disp.disp16 = *(uint16_t *)p;
-                break;
-            case 4:
-                hs->flags |= F_DISP32;
-                hs->disp.disp32 = *(uint32_t *)p;
-                break;
-        }
-        p += disp_size;
-    } else if (pref & PRE_LOCK)
-        hs->flags |= F_ERROR | F_ERROR_LOCK;
-
-    if (cflags & C_IMM_P66) {
-        if (cflags & C_REL32) {
-            if (pref & PRE_66) {
-                hs->flags |= F_IMM16 | F_RELATIVE;
-                hs->imm.imm16 = *(uint16_t *)p;
-                p += 2;
-                goto disasm_done;
-            }
-            goto rel32_ok;
-        }
-        if (pref & PRE_66) {
-            hs->flags |= F_IMM16;
-            hs->imm.imm16 = *(uint16_t *)p;
-            p += 2;
-        } else {
-            hs->flags |= F_IMM32;
-            hs->imm.imm32 = *(uint32_t *)p;
-            p += 4;
-        }
-    }
-
-    if (cflags & C_IMM16) {
-        if (hs->flags & F_IMM32) {
-            hs->flags |= F_IMM16;
-            hs->disp.disp16 = *(uint16_t *)p;
-        } else if (hs->flags & F_IMM16) {
-            hs->flags |= F_2IMM16;
-            hs->disp.disp16 = *(uint16_t *)p;
-        } else {
-            hs->flags |= F_IMM16;
-            hs->imm.imm16 = *(uint16_t *)p;
-        }
-        p += 2;
-    }
-    if (cflags & C_IMM8) {
-        hs->flags |= F_IMM8;
-        hs->imm.imm8 = *p++;
-    }
-
-    if (cflags & C_REL32) {
-      rel32_ok:
-        hs->flags |= F_IMM32 | F_RELATIVE;
-        hs->imm.imm32 = *(uint32_t *)p;
-        p += 4;
-    } else if (cflags & C_REL8) {
-        hs->flags |= F_IMM8 | F_RELATIVE;
-        hs->imm.imm8 = *p++;
-    }
-
-  disasm_done:
-
-    if ((hs->len = (uint8_t)(p-(uint8_t *)code)) > 15) {
-        hs->flags |= F_ERROR | F_ERROR_LENGTH;
-        hs->len = 15;
-    }
-
-    return (unsigned int)hs->len;
-}
-
-#endif // defined(_M_IX86) || defined(__i386__)

keyDumper/src/src/hde/hde32.h

@@ -1,105 +0,0 @@
-/*
- * Hacker Disassembler Engine 32
- * Copyright (c) 2006-2009, Vyacheslav Patkov.
- * All rights reserved.
- *
- * hde32.h: C/C++ header file
- *
- */
-
-#ifndef _HDE32_H_
-#define _HDE32_H_
-
-/* stdint.h - C99 standard header
- * http://en.wikipedia.org/wiki/stdint.h
- *
- * if your compiler doesn't contain "stdint.h" header (for
- * example, Microsoft Visual C++), you can download file:
- *   http://www.azillionmonkeys.com/qed/pstdint.h
- * and change next line to:
- *   #include "pstdint.h"
- */
-#include "pstdint.h"
-
-#define F_MODRM         0x00000001
-#define F_SIB           0x00000002
-#define F_IMM8          0x00000004
-#define F_IMM16         0x00000008
-#define F_IMM32         0x00000010
-#define F_DISP8         0x00000020
-#define F_DISP16        0x00000040
-#define F_DISP32        0x00000080
-#define F_RELATIVE      0x00000100
-#define F_2IMM16        0x00000800
-#define F_ERROR         0x00001000
-#define F_ERROR_OPCODE  0x00002000
-#define F_ERROR_LENGTH  0x00004000
-#define F_ERROR_LOCK    0x00008000
-#define F_ERROR_OPERAND 0x00010000
-#define F_PREFIX_REPNZ  0x01000000
-#define F_PREFIX_REPX   0x02000000
-#define F_PREFIX_REP    0x03000000
-#define F_PREFIX_66     0x04000000
-#define F_PREFIX_67     0x08000000
-#define F_PREFIX_LOCK   0x10000000
-#define F_PREFIX_SEG    0x20000000
-#define F_PREFIX_ANY    0x3f000000
-
-#define PREFIX_SEGMENT_CS   0x2e
-#define PREFIX_SEGMENT_SS   0x36
-#define PREFIX_SEGMENT_DS   0x3e
-#define PREFIX_SEGMENT_ES   0x26
-#define PREFIX_SEGMENT_FS   0x64
-#define PREFIX_SEGMENT_GS   0x65
-#define PREFIX_LOCK         0xf0
-#define PREFIX_REPNZ        0xf2
-#define PREFIX_REPX         0xf3
-#define PREFIX_OPERAND_SIZE 0x66
-#define PREFIX_ADDRESS_SIZE 0x67
-
-#pragma pack(push,1)
-
-typedef struct {
-    uint8_t len;
-    uint8_t p_rep;
-    uint8_t p_lock;
-    uint8_t p_seg;
-    uint8_t p_66;
-    uint8_t p_67;
-    uint8_t opcode;
-    uint8_t opcode2;
-    uint8_t modrm;
-    uint8_t modrm_mod;
-    uint8_t modrm_reg;
-    uint8_t modrm_rm;
-    uint8_t sib;
-    uint8_t sib_scale;
-    uint8_t sib_index;
-    uint8_t sib_base;
-    union {
-        uint8_t imm8;
-        uint16_t imm16;
-        uint32_t imm32;
-    } imm;
-    union {
-        uint8_t disp8;
-        uint16_t disp16;
-        uint32_t disp32;
-    } disp;
-    uint32_t flags;
-} hde32s;
-
-#pragma pack(pop)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* __cdecl */
-unsigned int hde32_disasm(const void *code, hde32s *hs);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _HDE32_H_ */

keyDumper/src/src/hde/hde64.c

@@ -1,335 +0,0 @@
-/*
- * Hacker Disassembler Engine 64 C
- * Copyright (c) 2008-2009, Vyacheslav Patkov.
- * All rights reserved.
- *
- */
-
-#if defined(_M_X64) || defined(__x86_64__)
-
-#include <string.h>
-#include "hde64.h"
-#include "table64.h"
-
-unsigned int hde64_disasm(const void *code, hde64s *hs)
-{
-    uint8_t x, c, *p = (uint8_t *)code, cflags, opcode, pref = 0;
-    uint8_t *ht = hde64_table, m_mod, m_reg, m_rm, disp_size = 0;
-    uint8_t op64 = 0;
-
-    memset(hs, 0, sizeof(hde64s));
-
-    for (x = 16; x; x--)
-        switch (c = *p++) {
-            case 0xf3:
-                hs->p_rep = c;
-                pref |= PRE_F3;
-                break;
-            case 0xf2:
-                hs->p_rep = c;
-                pref |= PRE_F2;
-                break;
-            case 0xf0:
-                hs->p_lock = c;
-                pref |= PRE_LOCK;
-                break;
-            case 0x26: case 0x2e: case 0x36:
-            case 0x3e: case 0x64: case 0x65:
-                hs->p_seg = c;
-                pref |= PRE_SEG;
-                break;
-            case 0x66:
-                hs->p_66 = c;
-                pref |= PRE_66;
-                break;
-            case 0x67:
-                hs->p_67 = c;
-                pref |= PRE_67;
-                break;
-            default:
-                goto pref_done;
-        }
-  pref_done:
-
-    hs->flags = (uint32_t)pref << 23;
-
-    if (!pref)
-        pref |= PRE_NONE;
-
-    if ((c & 0xf0) == 0x40) {
-        hs->flags |= F_PREFIX_REX;
-        if ((hs->rex_w = (c & 0xf) >> 3) && (*p & 0xf8) == 0xb8)
-            op64++;
-        hs->rex_r = (c & 7) >> 2;
-        hs->rex_x = (c & 3) >> 1;
-        hs->rex_b = c & 1;
-        if (((c = *p++) & 0xf0) == 0x40) {
-            opcode = c;
-            goto error_opcode;
-        }
-    }
-
-    if ((hs->opcode = c) == 0x0f) {
-        hs->opcode2 = c = *p++;
-        ht += DELTA_OPCODES;
-    } else if (c >= 0xa0 && c <= 0xa3) {
-        op64++;
-        if (pref & PRE_67)
-            pref |= PRE_66;
-        else
-            pref &= ~PRE_66;
-    }
-
-    opcode = c;
-    cflags = ht[ht[opcode / 4] + (opcode % 4)];
-
-    if (cflags == C_ERROR) {
-      error_opcode:
-        hs->flags |= F_ERROR | F_ERROR_OPCODE;
-        cflags = 0;
-        if ((opcode & -3) == 0x24)
-            cflags++;
-    }
-
-    x = 0;
-    if (cflags & C_GROUP) {
-        uint16_t t;
-        t = *(uint16_t *)(ht + (cflags & 0x7f));
-        cflags = (uint8_t)t;
-        x = (uint8_t)(t >> 8);
-    }
-
-    if (hs->opcode2) {
-        ht = hde64_table + DELTA_PREFIXES;
-        if (ht[ht[opcode / 4] + (opcode % 4)] & pref)
-            hs->flags |= F_ERROR | F_ERROR_OPCODE;
-    }
-
-    if (cflags & C_MODRM) {
-        hs->flags |= F_MODRM;
-        hs->modrm = c = *p++;
-        hs->modrm_mod = m_mod = c >> 6;
-        hs->modrm_rm = m_rm = c & 7;
-        hs->modrm_reg = m_reg = (c & 0x3f) >> 3;
-
-        if (x && ((x << m_reg) & 0x80))
-            hs->flags |= F_ERROR | F_ERROR_OPCODE;
-
-        if (!hs->opcode2 && opcode >= 0xd9 && opcode <= 0xdf) {
-            uint8_t t = opcode - 0xd9;
-            if (m_mod == 3) {
-                ht = hde64_table + DELTA_FPU_MODRM + t*8;
-                t = ht[m_reg] << m_rm;
-            } else {
-                ht = hde64_table + DELTA_FPU_REG;
-                t = ht[t] << m_reg;
-            }
-            if (t & 0x80)
-                hs->flags |= F_ERROR | F_ERROR_OPCODE;
-        }
-
-        if (pref & PRE_LOCK) {
-            if (m_mod == 3) {
-                hs->flags |= F_ERROR | F_ERROR_LOCK;
-            } else {
-                uint8_t *table_end, op = opcode;
-                if (hs->opcode2) {
-                    ht = hde64_table + DELTA_OP2_LOCK_OK;
-                    table_end = ht + DELTA_OP_ONLY_MEM - DELTA_OP2_LOCK_OK;
-                } else {
-                    ht = hde64_table + DELTA_OP_LOCK_OK;
-                    table_end = ht + DELTA_OP2_LOCK_OK - DELTA_OP_LOCK_OK;
-                    op &= -2;
-                }
-                for (; ht != table_end; ht++)
-                    if (*ht++ == op) {
-                        if (!((*ht << m_reg) & 0x80))
-                            goto no_lock_error;
-                        else
-                            break;
-                    }
-                hs->flags |= F_ERROR | F_ERROR_LOCK;
-              no_lock_error:
-                ;
-            }
-        }
-
-        if (hs->opcode2) {
-            switch (opcode) {
-                case 0x20: case 0x22:
-                    m_mod = 3;
-                    if (m_reg > 4 || m_reg == 1)
-                        goto error_operand;
-                    else
-                        goto no_error_operand;
-                case 0x21: case 0x23:
-                    m_mod = 3;
-                    if (m_reg == 4 || m_reg == 5)
-                        goto error_operand;
-                    else
-                        goto no_error_operand;
-            }
-        } else {
-            switch (opcode) {
-                case 0x8c:
-                    if (m_reg > 5)
-                        goto error_operand;
-                    else
-                        goto no_error_operand;
-                case 0x8e:
-                    if (m_reg == 1 || m_reg > 5)
-                        goto error_operand;
-                    else
-                        goto no_error_operand;
-            }
-        }
-
-        if (m_mod == 3) {
-            uint8_t *table_end;
-            if (hs->opcode2) {
-                ht = hde64_table + DELTA_OP2_ONLY_MEM;
-                table_end = ht + sizeof(hde64_table) - DELTA_OP2_ONLY_MEM;
-            } else {
-                ht = hde64_table + DELTA_OP_ONLY_MEM;
-                table_end = ht + DELTA_OP2_ONLY_MEM - DELTA_OP_ONLY_MEM;
-            }
-            for (; ht != table_end; ht += 2)
-                if (*ht++ == opcode) {
-                    if ((*ht++ & pref) && !((*ht << m_reg) & 0x80))
-                        goto error_operand;
-                    else
-                        break;
-                }
-            goto no_error_operand;
-        } else if (hs->opcode2) {
-            switch (opcode) {
-                case 0x50: case 0xd7: case 0xf7:
-                    if (pref & (PRE_NONE | PRE_66))
-                        goto error_operand;
-                    break;
-                case 0xd6:
-                    if (pref & (PRE_F2 | PRE_F3))
-                        goto error_operand;
-                    break;
-                case 0xc5:
-                    goto error_operand;
-            }
-            goto no_error_operand;
-        } else
-            goto no_error_operand;
-
-      error_operand:
-        hs->flags |= F_ERROR | F_ERROR_OPERAND;
-      no_error_operand:
-
-        c = *p++;
-        if (m_reg <= 1) {
-            if (opcode == 0xf6)
-                cflags |= C_IMM8;
-            else if (opcode == 0xf7)
-                cflags |= C_IMM_P66;
-        }
-
-        switch (m_mod) {
-            case 0:
-                if (pref & PRE_67) {
-                    if (m_rm == 6)
-                        disp_size = 2;
-                } else
-                    if (m_rm == 5)
-                        disp_size = 4;
-                break;
-            case 1:
-                disp_size = 1;
-                break;
-            case 2:
-                disp_size = 2;
-                if (!(pref & PRE_67))
-                    disp_size <<= 1;
-                break;
-        }
-
-        if (m_mod != 3 && m_rm == 4) {
-            hs->flags |= F_SIB;
-            p++;
-            hs->sib = c;
-            hs->sib_scale = c >> 6;
-            hs->sib_index = (c & 0x3f) >> 3;
-            if ((hs->sib_base = c & 7) == 5 && !(m_mod & 1))
-                disp_size = 4;
-        }
-
-        p--;
-        switch (disp_size) {
-            case 1:
-                hs->flags |= F_DISP8;
-                hs->disp.disp8 = *p;
-                break;
-            case 2:
-                hs->flags |= F_DISP16;
-                hs->disp.disp16 = *(uint16_t *)p;
-                break;
-            case 4:
-                hs->flags |= F_DISP32;
-                hs->disp.disp32 = *(uint32_t *)p;
-                break;
-        }
-        p += disp_size;
-    } else if (pref & PRE_LOCK)
-        hs->flags |= F_ERROR | F_ERROR_LOCK;
-
-    if (cflags & C_IMM_P66) {
-        if (cflags & C_REL32) {
-            if (pref & PRE_66) {
-                hs->flags |= F_IMM16 | F_RELATIVE;
-                hs->imm.imm16 = *(uint16_t *)p;
-                p += 2;
-                goto disasm_done;
-            }
-            goto rel32_ok;
-        }
-        if (op64) {
-            hs->flags |= F_IMM64;
-            hs->imm.imm64 = *(uint64_t *)p;
-            p += 8;
-        } else if (!(pref & PRE_66)) {
-            hs->flags |= F_IMM32;
-            hs->imm.imm32 = *(uint32_t *)p;
-            p += 4;
-        } else
-            goto imm16_ok;
-    }
-
-
-    if (cflags & C_IMM16) {
-      imm16_ok:
-        hs->flags |= F_IMM16;
-        hs->imm.imm16 = *(uint16_t *)p;
-        p += 2;
-    }
-    if (cflags & C_IMM8) {
-        hs->flags |= F_IMM8;
-        hs->imm.imm8 = *p++;
-    }
-
-    if (cflags & C_REL32) {
-      rel32_ok:
-        hs->flags |= F_IMM32 | F_RELATIVE;
-        hs->imm.imm32 = *(uint32_t *)p;
-        p += 4;
-    } else if (cflags & C_REL8) {
-        hs->flags |= F_IMM8 | F_RELATIVE;
-        hs->imm.imm8 = *p++;
-    }
-
-  disasm_done:
-
-    if ((hs->len = (uint8_t)(p-(uint8_t *)code)) > 15) {
-        hs->flags |= F_ERROR | F_ERROR_LENGTH;
-        hs->len = 15;
-    }
-
-    return (unsigned int)hs->len;
-}
-
-#endif // defined(_M_X64) || defined(__x86_64__)

keyDumper/src/src/hde/hde64.h

@@ -1,112 +0,0 @@
-/*
- * Hacker Disassembler Engine 64
- * Copyright (c) 2008-2009, Vyacheslav Patkov.
- * All rights reserved.
- *
- * hde64.h: C/C++ header file
- *
- */
-
-#ifndef _HDE64_H_
-#define _HDE64_H_
-
-/* stdint.h - C99 standard header
- * http://en.wikipedia.org/wiki/stdint.h
- *
- * if your compiler doesn't contain "stdint.h" header (for
- * example, Microsoft Visual C++), you can download file:
- *   http://www.azillionmonkeys.com/qed/pstdint.h
- * and change next line to:
- *   #include "pstdint.h"
- */
-#include "pstdint.h"
-
-#define F_MODRM         0x00000001
-#define F_SIB           0x00000002
-#define F_IMM8          0x00000004
-#define F_IMM16         0x00000008
-#define F_IMM32         0x00000010
-#define F_IMM64         0x00000020
-#define F_DISP8         0x00000040
-#define F_DISP16        0x00000080
-#define F_DISP32        0x00000100
-#define F_RELATIVE      0x00000200
-#define F_ERROR         0x00001000
-#define F_ERROR_OPCODE  0x00002000
-#define F_ERROR_LENGTH  0x00004000
-#define F_ERROR_LOCK    0x00008000
-#define F_ERROR_OPERAND 0x00010000
-#define F_PREFIX_REPNZ  0x01000000
-#define F_PREFIX_REPX   0x02000000
-#define F_PREFIX_REP    0x03000000
-#define F_PREFIX_66     0x04000000
-#define F_PREFIX_67     0x08000000
-#define F_PREFIX_LOCK   0x10000000
-#define F_PREFIX_SEG    0x20000000
-#define F_PREFIX_REX    0x40000000
-#define F_PREFIX_ANY    0x7f000000
-
-#define PREFIX_SEGMENT_CS   0x2e
-#define PREFIX_SEGMENT_SS   0x36
-#define PREFIX_SEGMENT_DS   0x3e
-#define PREFIX_SEGMENT_ES   0x26
-#define PREFIX_SEGMENT_FS   0x64
-#define PREFIX_SEGMENT_GS   0x65
-#define PREFIX_LOCK         0xf0
-#define PREFIX_REPNZ        0xf2
-#define PREFIX_REPX         0xf3
-#define PREFIX_OPERAND_SIZE 0x66
-#define PREFIX_ADDRESS_SIZE 0x67
-
-#pragma pack(push,1)
-
-typedef struct {
-    uint8_t len;
-    uint8_t p_rep;
-    uint8_t p_lock;
-    uint8_t p_seg;
-    uint8_t p_66;
-    uint8_t p_67;
-    uint8_t rex;
-    uint8_t rex_w;
-    uint8_t rex_r;
-    uint8_t rex_x;
-    uint8_t rex_b;
-    uint8_t opcode;
-    uint8_t opcode2;
-    uint8_t modrm;
-    uint8_t modrm_mod;
-    uint8_t modrm_reg;
-    uint8_t modrm_rm;
-    uint8_t sib;
-    uint8_t sib_scale;
-    uint8_t sib_index;
-    uint8_t sib_base;
-    union {
-        uint8_t imm8;
-        uint16_t imm16;
-        uint32_t imm32;
-        uint64_t imm64;
-    } imm;
-    union {
-        uint8_t disp8;
-        uint16_t disp16;
-        uint32_t disp32;
-    } disp;
-    uint32_t flags;
-} hde64s;
-
-#pragma pack(pop)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* __cdecl */
-unsigned int hde64_disasm(const void *code, hde64s *hs);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _HDE64_H_ */

keyDumper/src/src/hde/pstdint.h

@@ -1,39 +0,0 @@
-/*
- *  MinHook - The Minimalistic API Hooking Library for x64/x86
- *  Copyright (C) 2009-2017 Tsuda Kageyu. All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *  1. Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *  2. 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 AUTHOR "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 AUTHOR 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.
- */
-
-#pragma once
-
-#include <windows.h>
-
-// Integer types for HDE.
-typedef INT8   int8_t;
-typedef INT16  int16_t;
-typedef INT32  int32_t;
-typedef INT64  int64_t;
-typedef UINT8  uint8_t;
-typedef UINT16 uint16_t;
-typedef UINT32 uint32_t;
-typedef UINT64 uint64_t;

keyDumper/src/src/hde/table32.h

@@ -1,73 +0,0 @@
-/*
- * Hacker Disassembler Engine 32 C
- * Copyright (c) 2008-2009, Vyacheslav Patkov.
- * All rights reserved.
- *
- */
-
-#define C_NONE    0x00
-#define C_MODRM   0x01
-#define C_IMM8    0x02
-#define C_IMM16   0x04
-#define C_IMM_P66 0x10
-#define C_REL8    0x20
-#define C_REL32   0x40
-#define C_GROUP   0x80
-#define C_ERROR   0xff
-
-#define PRE_ANY  0x00
-#define PRE_NONE 0x01
-#define PRE_F2   0x02
-#define PRE_F3   0x04
-#define PRE_66   0x08
-#define PRE_67   0x10
-#define PRE_LOCK 0x20
-#define PRE_SEG  0x40
-#define PRE_ALL  0xff
-
-#define DELTA_OPCODES      0x4a
-#define DELTA_FPU_REG      0xf1
-#define DELTA_FPU_MODRM    0xf8
-#define DELTA_PREFIXES     0x130
-#define DELTA_OP_LOCK_OK   0x1a1
-#define DELTA_OP2_LOCK_OK  0x1b9
-#define DELTA_OP_ONLY_MEM  0x1cb
-#define DELTA_OP2_ONLY_MEM 0x1da
-
-unsigned char hde32_table[] = {
-  0xa3,0xa8,0xa3,0xa8,0xa3,0xa8,0xa3,0xa8,0xa3,0xa8,0xa3,0xa8,0xa3,0xa8,0xa3,
-  0xa8,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xac,0xaa,0xb2,0xaa,0x9f,0x9f,
-  0x9f,0x9f,0xb5,0xa3,0xa3,0xa4,0xaa,0xaa,0xba,0xaa,0x96,0xaa,0xa8,0xaa,0xc3,
-  0xc3,0x96,0x96,0xb7,0xae,0xd6,0xbd,0xa3,0xc5,0xa3,0xa3,0x9f,0xc3,0x9c,0xaa,
-  0xaa,0xac,0xaa,0xbf,0x03,0x7f,0x11,0x7f,0x01,0x7f,0x01,0x3f,0x01,0x01,0x90,
-  0x82,0x7d,0x97,0x59,0x59,0x59,0x59,0x59,0x7f,0x59,0x59,0x60,0x7d,0x7f,0x7f,
-  0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x9a,0x88,0x7d,
-  0x59,0x50,0x50,0x50,0x50,0x59,0x59,0x59,0x59,0x61,0x94,0x61,0x9e,0x59,0x59,
-  0x85,0x59,0x92,0xa3,0x60,0x60,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,0x59,
-  0x59,0x59,0x9f,0x01,0x03,0x01,0x04,0x03,0xd5,0x03,0xcc,0x01,0xbc,0x03,0xf0,
-  0x10,0x10,0x10,0x10,0x50,0x50,0x50,0x50,0x14,0x20,0x20,0x20,0x20,0x01,0x01,
-  0x01,0x01,0xc4,0x02,0x10,0x00,0x00,0x00,0x00,0x01,0x01,0xc0,0xc2,0x10,0x11,
-  0x02,0x03,0x11,0x03,0x03,0x04,0x00,0x00,0x14,0x00,0x02,0x00,0x00,0xc6,0xc8,
-  0x02,0x02,0x02,0x02,0x00,0x00,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0xff,0xca,
-  0x01,0x01,0x01,0x00,0x06,0x00,0x04,0x00,0xc0,0xc2,0x01,0x01,0x03,0x01,0xff,
-  0xff,0x01,0x00,0x03,0xc4,0xc4,0xc6,0x03,0x01,0x01,0x01,0xff,0x03,0x03,0x03,
-  0xc8,0x40,0x00,0x0a,0x00,0x04,0x00,0x00,0x00,0x00,0x7f,0x00,0x33,0x01,0x00,
-  0x00,0x00,0x00,0x00,0x00,0xff,0xbf,0xff,0xff,0x00,0x00,0x00,0x00,0x07,0x00,
-  0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-  0x00,0xff,0xff,0x00,0x00,0x00,0xbf,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-  0x7f,0x00,0x00,0xff,0x4a,0x4a,0x4a,0x4a,0x4b,0x52,0x4a,0x4a,0x4a,0x4a,0x4f,
-  0x4c,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x55,0x45,0x40,0x4a,0x4a,0x4a,
-  0x45,0x59,0x4d,0x46,0x4a,0x5d,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,0x4a,
-  0x4a,0x4a,0x4a,0x4a,0x4a,0x61,0x63,0x67,0x4e,0x4a,0x4a,0x6b,0x6d,0x4a,0x4a,
-  0x45,0x6d,0x4a,0x4a,0x44,0x45,0x4a,0x4a,0x00,0x00,0x00,0x02,0x0d,0x06,0x06,
-  0x06,0x06,0x0e,0x00,0x00,0x00,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x02,0x06,
-  0x00,0x0a,0x0a,0x07,0x07,0x06,0x02,0x05,0x05,0x02,0x02,0x00,0x00,0x04,0x04,
-  0x04,0x04,0x00,0x00,0x00,0x0e,0x05,0x06,0x06,0x06,0x01,0x06,0x00,0x00,0x08,
-  0x00,0x10,0x00,0x18,0x00,0x20,0x00,0x28,0x00,0x30,0x00,0x80,0x01,0x82,0x01,
-  0x86,0x00,0xf6,0xcf,0xfe,0x3f,0xab,0x00,0xb0,0x00,0xb1,0x00,0xb3,0x00,0xba,
-  0xf8,0xbb,0x00,0xc0,0x00,0xc1,0x00,0xc7,0xbf,0x62,0xff,0x00,0x8d,0xff,0x00,
-  0xc4,0xff,0x00,0xc5,0xff,0x00,0xff,0xff,0xeb,0x01,0xff,0x0e,0x12,0x08,0x00,
-  0x13,0x09,0x00,0x16,0x08,0x00,0x17,0x09,0x00,0x2b,0x09,0x00,0xae,0xff,0x07,
-  0xb2,0xff,0x00,0xb4,0xff,0x00,0xb5,0xff,0x00,0xc3,0x01,0x00,0xc7,0xff,0xbf,
-  0xe7,0x08,0x00,0xf0,0x02,0x00
-};

keyDumper/src/src/hde/table64.h

@@ -1,74 +0,0 @@
-/*
- * Hacker Disassembler Engine 64 C
- * Copyright (c) 2008-2009, Vyacheslav Patkov.
- * All rights reserved.
- *
- */
-
-#define C_NONE    0x00
-#define C_MODRM   0x01
-#define C_IMM8    0x02
-#define C_IMM16   0x04
-#define C_IMM_P66 0x10
-#define C_REL8    0x20
-#define C_REL32   0x40
-#define C_GROUP   0x80
-#define C_ERROR   0xff
-
-#define PRE_ANY  0x00
-#define PRE_NONE 0x01
-#define PRE_F2   0x02
-#define PRE_F3   0x04
-#define PRE_66   0x08
-#define PRE_67   0x10
-#define PRE_LOCK 0x20
-#define PRE_SEG  0x40
-#define PRE_ALL  0xff
-
-#define DELTA_OPCODES      0x4a
-#define DELTA_FPU_REG      0xfd
-#define DELTA_FPU_MODRM    0x104
-#define DELTA_PREFIXES     0x13c
-#define DELTA_OP_LOCK_OK   0x1ae
-#define DELTA_OP2_LOCK_OK  0x1c6
-#define DELTA_OP_ONLY_MEM  0x1d8
-#define DELTA_OP2_ONLY_MEM 0x1e7
-
-unsigned char hde64_table[] = {
-  0xa5,0xaa,0xa5,0xb8,0xa5,0xaa,0xa5,0xaa,0xa5,0xb8,0xa5,0xb8,0xa5,0xb8,0xa5,
-  0xb8,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xac,0xc0,0xcc,0xc0,0xa1,0xa1,
-  0xa1,0xa1,0xb1,0xa5,0xa5,0xa6,0xc0,0xc0,0xd7,0xda,0xe0,0xc0,0xe4,0xc0,0xea,
-  0xea,0xe0,0xe0,0x98,0xc8,0xee,0xf1,0xa5,0xd3,0xa5,0xa5,0xa1,0xea,0x9e,0xc0,
-  0xc0,0xc2,0xc0,0xe6,0x03,0x7f,0x11,0x7f,0x01,0x7f,0x01,0x3f,0x01,0x01,0xab,
-  0x8b,0x90,0x64,0x5b,0x5b,0x5b,0x5b,0x5b,0x92,0x5b,0x5b,0x76,0x90,0x92,0x92,
-  0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x6a,0x73,0x90,
-  0x5b,0x52,0x52,0x52,0x52,0x5b,0x5b,0x5b,0x5b,0x77,0x7c,0x77,0x85,0x5b,0x5b,
-  0x70,0x5b,0x7a,0xaf,0x76,0x76,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,0x5b,
-  0x5b,0x5b,0x86,0x01,0x03,0x01,0x04,0x03,0xd5,0x03,0xd5,0x03,0xcc,0x01,0xbc,
-  0x03,0xf0,0x03,0x03,0x04,0x00,0x50,0x50,0x50,0x50,0xff,0x20,0x20,0x20,0x20,
-  0x01,0x01,0x01,0x01,0xc4,0x02,0x10,0xff,0xff,0xff,0x01,0x00,0x03,0x11,0xff,
-  0x03,0xc4,0xc6,0xc8,0x02,0x10,0x00,0xff,0xcc,0x01,0x01,0x01,0x00,0x00,0x00,
-  0x00,0x01,0x01,0x03,0x01,0xff,0xff,0xc0,0xc2,0x10,0x11,0x02,0x03,0x01,0x01,
-  0x01,0xff,0xff,0xff,0x00,0x00,0x00,0xff,0x00,0x00,0xff,0xff,0xff,0xff,0x10,
-  0x10,0x10,0x10,0x02,0x10,0x00,0x00,0xc6,0xc8,0x02,0x02,0x02,0x02,0x06,0x00,
-  0x04,0x00,0x02,0xff,0x00,0xc0,0xc2,0x01,0x01,0x03,0x03,0x03,0xca,0x40,0x00,
-  0x0a,0x00,0x04,0x00,0x00,0x00,0x00,0x7f,0x00,0x33,0x01,0x00,0x00,0x00,0x00,
-  0x00,0x00,0xff,0xbf,0xff,0xff,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0xff,0x00,
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,
-  0x00,0x00,0x00,0xbf,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7f,0x00,0x00,
-  0xff,0x40,0x40,0x40,0x40,0x41,0x49,0x40,0x40,0x40,0x40,0x4c,0x42,0x40,0x40,
-  0x40,0x40,0x40,0x40,0x40,0x40,0x4f,0x44,0x53,0x40,0x40,0x40,0x44,0x57,0x43,
-  0x5c,0x40,0x60,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
-  0x40,0x40,0x64,0x66,0x6e,0x6b,0x40,0x40,0x6a,0x46,0x40,0x40,0x44,0x46,0x40,
-  0x40,0x5b,0x44,0x40,0x40,0x00,0x00,0x00,0x00,0x06,0x06,0x06,0x06,0x01,0x06,
-  0x06,0x02,0x06,0x06,0x00,0x06,0x00,0x0a,0x0a,0x00,0x00,0x00,0x02,0x07,0x07,
-  0x06,0x02,0x0d,0x06,0x06,0x06,0x0e,0x05,0x05,0x02,0x02,0x00,0x00,0x04,0x04,
-  0x04,0x04,0x05,0x06,0x06,0x06,0x00,0x00,0x00,0x0e,0x00,0x00,0x08,0x00,0x10,
-  0x00,0x18,0x00,0x20,0x00,0x28,0x00,0x30,0x00,0x80,0x01,0x82,0x01,0x86,0x00,
-  0xf6,0xcf,0xfe,0x3f,0xab,0x00,0xb0,0x00,0xb1,0x00,0xb3,0x00,0xba,0xf8,0xbb,
-  0x00,0xc0,0x00,0xc1,0x00,0xc7,0xbf,0x62,0xff,0x00,0x8d,0xff,0x00,0xc4,0xff,
-  0x00,0xc5,0xff,0x00,0xff,0xff,0xeb,0x01,0xff,0x0e,0x12,0x08,0x00,0x13,0x09,
-  0x00,0x16,0x08,0x00,0x17,0x09,0x00,0x2b,0x09,0x00,0xae,0xff,0x07,0xb2,0xff,
-  0x00,0xb4,0xff,0x00,0xb5,0xff,0x00,0xc3,0x01,0x00,0xc7,0xff,0xbf,0xe7,0x08,
-  0x00,0xf0,0x02,0x00
-};

keyDumper/src/src/hook.c

@@ -1,939 +0,0 @@
-/*
- *  MinHook - The Minimalistic API Hooking Library for x64/x86
- *  Copyright (C) 2009-2017 Tsuda Kageyu.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *   2. 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 HOLDER
- *  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.
- */
-
-#include <windows.h>
-#include <tlhelp32.h>
-#include <limits.h>
-
-#include "../include/MinHook.h"
-#include "buffer.h"
-#include "trampoline.h"
-
-#ifndef ARRAYSIZE
-    #define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))
-#endif
-
-// Initial capacity of the HOOK_ENTRY buffer.
-#define INITIAL_HOOK_CAPACITY   32
-
-// Initial capacity of the thread IDs buffer.
-#define INITIAL_THREAD_CAPACITY 128
-
-// Special hook position values.
-#define INVALID_HOOK_POS UINT_MAX
-#define ALL_HOOKS_POS    UINT_MAX
-
-// Freeze() action argument defines.
-#define ACTION_DISABLE      0
-#define ACTION_ENABLE       1
-#define ACTION_APPLY_QUEUED 2
-
-// Thread access rights for suspending/resuming threads.
-#define THREAD_ACCESS \
-    (THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION | THREAD_SET_CONTEXT)
-
-// Hook information.
-typedef struct _HOOK_ENTRY
-{
-    LPVOID pTarget;             // Address of the target function.
-    LPVOID pDetour;             // Address of the detour or relay function.
-    LPVOID pTrampoline;         // Address of the trampoline function.
-    UINT8  backup[8];           // Original prologue of the target function.
-
-    UINT8  patchAbove  : 1;     // Uses the hot patch area.
-    UINT8  isEnabled   : 1;     // Enabled.
-    UINT8  queueEnable : 1;     // Queued for enabling/disabling when != isEnabled.
-
-    UINT   nIP : 4;             // Count of the instruction boundaries.
-    UINT8  oldIPs[8];           // Instruction boundaries of the target function.
-    UINT8  newIPs[8];           // Instruction boundaries of the trampoline function.
-} HOOK_ENTRY, *PHOOK_ENTRY;
-
-// Suspended threads for Freeze()/Unfreeze().
-typedef struct _FROZEN_THREADS
-{
-    LPDWORD pItems;         // Data heap
-    UINT    capacity;       // Size of allocated data heap, items
-    UINT    size;           // Actual number of data items
-} FROZEN_THREADS, *PFROZEN_THREADS;
-
-//-------------------------------------------------------------------------
-// Global Variables:
-//-------------------------------------------------------------------------
-
-// Spin lock flag for EnterSpinLock()/LeaveSpinLock().
-volatile LONG g_isLocked = FALSE;
-
-// Private heap handle. If not NULL, this library is initialized.
-HANDLE g_hHeap = NULL;
-
-// Hook entries.
-struct
-{
-    PHOOK_ENTRY pItems;     // Data heap
-    UINT        capacity;   // Size of allocated data heap, items
-    UINT        size;       // Actual number of data items
-} g_hooks;
-
-//-------------------------------------------------------------------------
-// Returns INVALID_HOOK_POS if not found.
-static UINT FindHookEntry(LPVOID pTarget)
-{
-    UINT i;
-    for (i = 0; i < g_hooks.size; ++i)
-    {
-        if ((ULONG_PTR)pTarget == (ULONG_PTR)g_hooks.pItems[i].pTarget)
-            return i;
-    }
-
-    return INVALID_HOOK_POS;
-}
-
-//-------------------------------------------------------------------------
-static PHOOK_ENTRY AddHookEntry()
-{
-    if (g_hooks.pItems == NULL)
-    {
-        g_hooks.capacity = INITIAL_HOOK_CAPACITY;
-        g_hooks.pItems = (PHOOK_ENTRY)HeapAlloc(
-            g_hHeap, 0, g_hooks.capacity * sizeof(HOOK_ENTRY));
-        if (g_hooks.pItems == NULL)
-            return NULL;
-    }
-    else if (g_hooks.size >= g_hooks.capacity)
-    {
-        PHOOK_ENTRY p = (PHOOK_ENTRY)HeapReAlloc(
-            g_hHeap, 0, g_hooks.pItems, (g_hooks.capacity * 2) * sizeof(HOOK_ENTRY));
-        if (p == NULL)
-            return NULL;
-
-        g_hooks.capacity *= 2;
-        g_hooks.pItems = p;
-    }
-
-    return &g_hooks.pItems[g_hooks.size++];
-}
-
-//-------------------------------------------------------------------------
-static VOID DeleteHookEntry(UINT pos)
-{
-    if (pos < g_hooks.size - 1)
-        g_hooks.pItems[pos] = g_hooks.pItems[g_hooks.size - 1];
-
-    g_hooks.size--;
-
-    if (g_hooks.capacity / 2 >= INITIAL_HOOK_CAPACITY && g_hooks.capacity / 2 >= g_hooks.size)
-    {
-        PHOOK_ENTRY p = (PHOOK_ENTRY)HeapReAlloc(
-            g_hHeap, 0, g_hooks.pItems, (g_hooks.capacity / 2) * sizeof(HOOK_ENTRY));
-        if (p == NULL)
-            return;
-
-        g_hooks.capacity /= 2;
-        g_hooks.pItems = p;
-    }
-}
-
-//-------------------------------------------------------------------------
-static DWORD_PTR FindOldIP(PHOOK_ENTRY pHook, DWORD_PTR ip)
-{
-    UINT i;
-
-    if (pHook->patchAbove && ip == ((DWORD_PTR)pHook->pTarget - sizeof(JMP_REL)))
-        return (DWORD_PTR)pHook->pTarget;
-
-    for (i = 0; i < pHook->nIP; ++i)
-    {
-        if (ip == ((DWORD_PTR)pHook->pTrampoline + pHook->newIPs[i]))
-            return (DWORD_PTR)pHook->pTarget + pHook->oldIPs[i];
-    }
-
-#if defined(_M_X64) || defined(__x86_64__)
-    // Check relay function.
-    if (ip == (DWORD_PTR)pHook->pDetour)
-        return (DWORD_PTR)pHook->pTarget;
-#endif
-
-    return 0;
-}
-
-//-------------------------------------------------------------------------
-static DWORD_PTR FindNewIP(PHOOK_ENTRY pHook, DWORD_PTR ip)
-{
-    UINT i;
-    for (i = 0; i < pHook->nIP; ++i)
-    {
-        if (ip == ((DWORD_PTR)pHook->pTarget + pHook->oldIPs[i]))
-            return (DWORD_PTR)pHook->pTrampoline + pHook->newIPs[i];
-    }
-
-    return 0;
-}
-
-//-------------------------------------------------------------------------
-static VOID ProcessThreadIPs(HANDLE hThread, UINT pos, UINT action)
-{
-    // If the thread suspended in the overwritten area,
-    // move IP to the proper address.
-
-    CONTEXT c;
-#if defined(_M_X64) || defined(__x86_64__)
-    DWORD64 *pIP = &c.Rip;
-#else
-    DWORD   *pIP = &c.Eip;
-#endif
-    UINT count;
-
-    c.ContextFlags = CONTEXT_CONTROL;
-    if (!GetThreadContext(hThread, &c))
-        return;
-
-    if (pos == ALL_HOOKS_POS)
-    {
-        pos = 0;
-        count = g_hooks.size;
-    }
-    else
-    {
-        count = pos + 1;
-    }
-
-    for (; pos < count; ++pos)
-    {
-        PHOOK_ENTRY pHook = &g_hooks.pItems[pos];
-        BOOL        enable;
-        DWORD_PTR   ip;
-
-        switch (action)
-        {
-        case ACTION_DISABLE:
-            enable = FALSE;
-            break;
-
-        case ACTION_ENABLE:
-            enable = TRUE;
-            break;
-
-        default: // ACTION_APPLY_QUEUED
-            enable = pHook->queueEnable;
-            break;
-        }
-        if (pHook->isEnabled == enable)
-            continue;
-
-        if (enable)
-            ip = FindNewIP(pHook, *pIP);
-        else
-            ip = FindOldIP(pHook, *pIP);
-
-        if (ip != 0)
-        {
-            *pIP = ip;
-            SetThreadContext(hThread, &c);
-        }
-    }
-}
-
-//-------------------------------------------------------------------------
-static BOOL EnumerateThreads(PFROZEN_THREADS pThreads)
-{
-    BOOL succeeded = FALSE;
-
-    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
-    if (hSnapshot != INVALID_HANDLE_VALUE)
-    {
-        THREADENTRY32 te;
-        te.dwSize = sizeof(THREADENTRY32);
-        if (Thread32First(hSnapshot, &te))
-        {
-            succeeded = TRUE;
-            do
-            {
-                if (te.dwSize >= (FIELD_OFFSET(THREADENTRY32, th32OwnerProcessID) + sizeof(DWORD))
-                    && te.th32OwnerProcessID == GetCurrentProcessId()
-                    && te.th32ThreadID != GetCurrentThreadId())
-                {
-                    if (pThreads->pItems == NULL)
-                    {
-                        pThreads->capacity = INITIAL_THREAD_CAPACITY;
-                        pThreads->pItems
-                            = (LPDWORD)HeapAlloc(g_hHeap, 0, pThreads->capacity * sizeof(DWORD));
-                        if (pThreads->pItems == NULL)
-                        {
-                            succeeded = FALSE;
-                            break;
-                        }
-                    }
-                    else if (pThreads->size >= pThreads->capacity)
-                    {
-                        LPDWORD p;
-                        pThreads->capacity *= 2;
-                        p = (LPDWORD)HeapReAlloc(
-                            g_hHeap, 0, pThreads->pItems, pThreads->capacity * sizeof(DWORD));
-                        if (p == NULL)
-                        {
-                            succeeded = FALSE;
-                            break;
-                        }
-
-                        pThreads->pItems = p;
-                    }
-                    pThreads->pItems[pThreads->size++] = te.th32ThreadID;
-                }
-
-                te.dwSize = sizeof(THREADENTRY32);
-            } while (Thread32Next(hSnapshot, &te));
-
-            if (succeeded && GetLastError() != ERROR_NO_MORE_FILES)
-                succeeded = FALSE;
-
-            if (!succeeded && pThreads->pItems != NULL)
-            {
-                HeapFree(g_hHeap, 0, pThreads->pItems);
-                pThreads->pItems = NULL;
-            }
-        }
-        CloseHandle(hSnapshot);
-    }
-
-    return succeeded;
-}
-
-//-------------------------------------------------------------------------
-static MH_STATUS Freeze(PFROZEN_THREADS pThreads, UINT pos, UINT action)
-{
-    MH_STATUS status = MH_OK;
-
-    pThreads->pItems   = NULL;
-    pThreads->capacity = 0;
-    pThreads->size     = 0;
-    if (!EnumerateThreads(pThreads))
-    {
-        status = MH_ERROR_MEMORY_ALLOC;
-    }
-    else if (pThreads->pItems != NULL)
-    {
-        UINT i;
-        for (i = 0; i < pThreads->size; ++i)
-        {
-            HANDLE hThread = OpenThread(THREAD_ACCESS, FALSE, pThreads->pItems[i]);
-            BOOL suspended = FALSE;
-            if (hThread != NULL)
-            {
-                DWORD result = SuspendThread(hThread);
-                if (result != 0xFFFFFFFF)
-                {
-                    suspended = TRUE;
-                    ProcessThreadIPs(hThread, pos, action);
-                }
-                CloseHandle(hThread);
-            }
-
-            if (!suspended)
-            {
-                // Mark thread as not suspended, so it's not resumed later on.
-                pThreads->pItems[i] = 0;
-            }
-        }
-    }
-
-    return status;
-}
-
-//-------------------------------------------------------------------------
-static VOID Unfreeze(PFROZEN_THREADS pThreads)
-{
-    if (pThreads->pItems != NULL)
-    {
-        UINT i;
-        for (i = 0; i < pThreads->size; ++i)
-        {
-            DWORD threadId = pThreads->pItems[i];
-            if (threadId != 0)
-            {
-                HANDLE hThread = OpenThread(THREAD_ACCESS, FALSE, threadId);
-                if (hThread != NULL)
-                {
-                    ResumeThread(hThread);
-                    CloseHandle(hThread);
-                }
-            }
-        }
-
-        HeapFree(g_hHeap, 0, pThreads->pItems);
-    }
-}
-
-//-------------------------------------------------------------------------
-static MH_STATUS EnableHookLL(UINT pos, BOOL enable)
-{
-    PHOOK_ENTRY pHook = &g_hooks.pItems[pos];
-    DWORD  oldProtect;
-    SIZE_T patchSize    = sizeof(JMP_REL);
-    LPBYTE pPatchTarget = (LPBYTE)pHook->pTarget;
-
-    if (pHook->patchAbove)
-    {
-        pPatchTarget -= sizeof(JMP_REL);
-        patchSize    += sizeof(JMP_REL_SHORT);
-    }
-
-    if (!VirtualProtect(pPatchTarget, patchSize, PAGE_EXECUTE_READWRITE, &oldProtect))
-        return MH_ERROR_MEMORY_PROTECT;
-
-    if (enable)
-    {
-        PJMP_REL pJmp = (PJMP_REL)pPatchTarget;
-        pJmp->opcode = 0xE9;
-        pJmp->operand = (UINT32)((LPBYTE)pHook->pDetour - (pPatchTarget + sizeof(JMP_REL)));
-
-        if (pHook->patchAbove)
-        {
-            PJMP_REL_SHORT pShortJmp = (PJMP_REL_SHORT)pHook->pTarget;
-            pShortJmp->opcode = 0xEB;
-            pShortJmp->operand = (UINT8)(0 - (sizeof(JMP_REL_SHORT) + sizeof(JMP_REL)));
-        }
-    }
-    else
-    {
-        if (pHook->patchAbove)
-            memcpy(pPatchTarget, pHook->backup, sizeof(JMP_REL) + sizeof(JMP_REL_SHORT));
-        else
-            memcpy(pPatchTarget, pHook->backup, sizeof(JMP_REL));
-    }
-
-    VirtualProtect(pPatchTarget, patchSize, oldProtect, &oldProtect);
-
-    // Just-in-case measure.
-    FlushInstructionCache(GetCurrentProcess(), pPatchTarget, patchSize);
-
-    pHook->isEnabled   = enable;
-    pHook->queueEnable = enable;
-
-    return MH_OK;
-}
-
-//-------------------------------------------------------------------------
-static MH_STATUS EnableAllHooksLL(BOOL enable)
-{
-    MH_STATUS status = MH_OK;
-    UINT i, first = INVALID_HOOK_POS;
-
-    for (i = 0; i < g_hooks.size; ++i)
-    {
-        if (g_hooks.pItems[i].isEnabled != enable)
-        {
-            first = i;
-            break;
-        }
-    }
-
-    if (first != INVALID_HOOK_POS)
-    {
-        FROZEN_THREADS threads;
-        status = Freeze(&threads, ALL_HOOKS_POS, enable ? ACTION_ENABLE : ACTION_DISABLE);
-        if (status == MH_OK)
-        {
-            for (i = first; i < g_hooks.size; ++i)
-            {
-                if (g_hooks.pItems[i].isEnabled != enable)
-                {
-                    status = EnableHookLL(i, enable);
-                    if (status != MH_OK)
-                        break;
-                }
-            }
-
-            Unfreeze(&threads);
-        }
-    }
-
-    return status;
-}
-
-//-------------------------------------------------------------------------
-static VOID EnterSpinLock(VOID)
-{
-    SIZE_T spinCount = 0;
-
-    // Wait until the flag is FALSE.
-    while (InterlockedCompareExchange(&g_isLocked, TRUE, FALSE) != FALSE)
-    {
-        // No need to generate a memory barrier here, since InterlockedCompareExchange()
-        // generates a full memory barrier itself.
-
-        // Prevent the loop from being too busy.
-        if (spinCount < 32)
-            Sleep(0);
-        else
-            Sleep(1);
-
-        spinCount++;
-    }
-}
-
-//-------------------------------------------------------------------------
-static VOID LeaveSpinLock(VOID)
-{
-    // No need to generate a memory barrier here, since InterlockedExchange()
-    // generates a full memory barrier itself.
-
-    InterlockedExchange(&g_isLocked, FALSE);
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_Initialize(VOID)
-{
-    MH_STATUS status = MH_OK;
-
-    EnterSpinLock();
-
-    if (g_hHeap == NULL)
-    {
-        g_hHeap = HeapCreate(0, 0, 0);
-        if (g_hHeap != NULL)
-        {
-            // Initialize the internal function buffer.
-            InitializeBuffer();
-        }
-        else
-        {
-            status = MH_ERROR_MEMORY_ALLOC;
-        }
-    }
-    else
-    {
-        status = MH_ERROR_ALREADY_INITIALIZED;
-    }
-
-    LeaveSpinLock();
-
-    return status;
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_Uninitialize(VOID)
-{
-    MH_STATUS status = MH_OK;
-
-    EnterSpinLock();
-
-    if (g_hHeap != NULL)
-    {
-        status = EnableAllHooksLL(FALSE);
-        if (status == MH_OK)
-        {
-            // Free the internal function buffer.
-
-            // HeapFree is actually not required, but some tools detect a false
-            // memory leak without HeapFree.
-
-            UninitializeBuffer();
-
-            HeapFree(g_hHeap, 0, g_hooks.pItems);
-            HeapDestroy(g_hHeap);
-
-            g_hHeap = NULL;
-
-            g_hooks.pItems   = NULL;
-            g_hooks.capacity = 0;
-            g_hooks.size     = 0;
-        }
-    }
-    else
-    {
-        status = MH_ERROR_NOT_INITIALIZED;
-    }
-
-    LeaveSpinLock();
-
-    return status;
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_CreateHook(LPVOID pTarget, LPVOID pDetour, LPVOID *ppOriginal)
-{
-    MH_STATUS status = MH_OK;
-
-    EnterSpinLock();
-
-    if (g_hHeap != NULL)
-    {
-        if (IsExecutableAddress(pTarget) && IsExecutableAddress(pDetour))
-        {
-            UINT pos = FindHookEntry(pTarget);
-            if (pos == INVALID_HOOK_POS)
-            {
-                LPVOID pBuffer = AllocateBuffer(pTarget);
-                if (pBuffer != NULL)
-                {
-                    TRAMPOLINE ct;
-
-                    ct.pTarget     = pTarget;
-                    ct.pDetour     = pDetour;
-                    ct.pTrampoline = pBuffer;
-                    if (CreateTrampolineFunction(&ct))
-                    {
-                        PHOOK_ENTRY pHook = AddHookEntry();
-                        if (pHook != NULL)
-                        {
-                            pHook->pTarget     = ct.pTarget;
-#if defined(_M_X64) || defined(__x86_64__)
-                            pHook->pDetour     = ct.pRelay;
-#else
-                            pHook->pDetour     = ct.pDetour;
-#endif
-                            pHook->pTrampoline = ct.pTrampoline;
-                            pHook->patchAbove  = ct.patchAbove;
-                            pHook->isEnabled   = FALSE;
-                            pHook->queueEnable = FALSE;
-                            pHook->nIP         = ct.nIP;
-                            memcpy(pHook->oldIPs, ct.oldIPs, ARRAYSIZE(ct.oldIPs));
-                            memcpy(pHook->newIPs, ct.newIPs, ARRAYSIZE(ct.newIPs));
-
-                            // Back up the target function.
-
-                            if (ct.patchAbove)
-                            {
-                                memcpy(
-                                    pHook->backup,
-                                    (LPBYTE)pTarget - sizeof(JMP_REL),
-                                    sizeof(JMP_REL) + sizeof(JMP_REL_SHORT));
-                            }
-                            else
-                            {
-                                memcpy(pHook->backup, pTarget, sizeof(JMP_REL));
-                            }
-
-                            if (ppOriginal != NULL)
-                                *ppOriginal = pHook->pTrampoline;
-                        }
-                        else
-                        {
-                            status = MH_ERROR_MEMORY_ALLOC;
-                        }
-                    }
-                    else
-                    {
-                        status = MH_ERROR_UNSUPPORTED_FUNCTION;
-                    }
-
-                    if (status != MH_OK)
-                    {
-                        FreeBuffer(pBuffer);
-                    }
-                }
-                else
-                {
-                    status = MH_ERROR_MEMORY_ALLOC;
-                }
-            }
-            else
-            {
-                status = MH_ERROR_ALREADY_CREATED;
-            }
-        }
-        else
-        {
-            status = MH_ERROR_NOT_EXECUTABLE;
-        }
-    }
-    else
-    {
-        status = MH_ERROR_NOT_INITIALIZED;
-    }
-
-    LeaveSpinLock();
-
-    return status;
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_RemoveHook(LPVOID pTarget)
-{
-    MH_STATUS status = MH_OK;
-
-    EnterSpinLock();
-
-    if (g_hHeap != NULL)
-    {
-        UINT pos = FindHookEntry(pTarget);
-        if (pos != INVALID_HOOK_POS)
-        {
-            if (g_hooks.pItems[pos].isEnabled)
-            {
-                FROZEN_THREADS threads;
-                status = Freeze(&threads, pos, ACTION_DISABLE);
-                if (status == MH_OK)
-                {
-                    status = EnableHookLL(pos, FALSE);
-
-                    Unfreeze(&threads);
-                }
-            }
-
-            if (status == MH_OK)
-            {
-                FreeBuffer(g_hooks.pItems[pos].pTrampoline);
-                DeleteHookEntry(pos);
-            }
-        }
-        else
-        {
-            status = MH_ERROR_NOT_CREATED;
-        }
-    }
-    else
-    {
-        status = MH_ERROR_NOT_INITIALIZED;
-    }
-
-    LeaveSpinLock();
-
-    return status;
-}
-
-//-------------------------------------------------------------------------
-static MH_STATUS EnableHook(LPVOID pTarget, BOOL enable)
-{
-    MH_STATUS status = MH_OK;
-
-    EnterSpinLock();
-
-    if (g_hHeap != NULL)
-    {
-        if (pTarget == MH_ALL_HOOKS)
-        {
-            status = EnableAllHooksLL(enable);
-        }
-        else
-        {
-            UINT pos = FindHookEntry(pTarget);
-            if (pos != INVALID_HOOK_POS)
-            {
-                if (g_hooks.pItems[pos].isEnabled != enable)
-                {
-                    FROZEN_THREADS threads;
-                    status = Freeze(&threads, pos, ACTION_ENABLE);
-                    if (status == MH_OK)
-                    {
-                        status = EnableHookLL(pos, enable);
-
-                        Unfreeze(&threads);
-                    }
-                }
-                else
-                {
-                    status = enable ? MH_ERROR_ENABLED : MH_ERROR_DISABLED;
-                }
-            }
-            else
-            {
-                status = MH_ERROR_NOT_CREATED;
-            }
-        }
-    }
-    else
-    {
-        status = MH_ERROR_NOT_INITIALIZED;
-    }
-
-    LeaveSpinLock();
-
-    return status;
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_EnableHook(LPVOID pTarget)
-{
-    return EnableHook(pTarget, TRUE);
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_DisableHook(LPVOID pTarget)
-{
-    return EnableHook(pTarget, FALSE);
-}
-
-//-------------------------------------------------------------------------
-static MH_STATUS QueueHook(LPVOID pTarget, BOOL queueEnable)
-{
-    MH_STATUS status = MH_OK;
-
-    EnterSpinLock();
-
-    if (g_hHeap != NULL)
-    {
-        if (pTarget == MH_ALL_HOOKS)
-        {
-            UINT i;
-            for (i = 0; i < g_hooks.size; ++i)
-                g_hooks.pItems[i].queueEnable = queueEnable;
-        }
-        else
-        {
-            UINT pos = FindHookEntry(pTarget);
-            if (pos != INVALID_HOOK_POS)
-            {
-                g_hooks.pItems[pos].queueEnable = queueEnable;
-            }
-            else
-            {
-                status = MH_ERROR_NOT_CREATED;
-            }
-        }
-    }
-    else
-    {
-        status = MH_ERROR_NOT_INITIALIZED;
-    }
-
-    LeaveSpinLock();
-
-    return status;
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_QueueEnableHook(LPVOID pTarget)
-{
-    return QueueHook(pTarget, TRUE);
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_QueueDisableHook(LPVOID pTarget)
-{
-    return QueueHook(pTarget, FALSE);
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_ApplyQueued(VOID)
-{
-    MH_STATUS status = MH_OK;
-    UINT i, first = INVALID_HOOK_POS;
-
-    EnterSpinLock();
-
-    if (g_hHeap != NULL)
-    {
-        for (i = 0; i < g_hooks.size; ++i)
-        {
-            if (g_hooks.pItems[i].isEnabled != g_hooks.pItems[i].queueEnable)
-            {
-                first = i;
-                break;
-            }
-        }
-
-        if (first != INVALID_HOOK_POS)
-        {
-            FROZEN_THREADS threads;
-            status = Freeze(&threads, ALL_HOOKS_POS, ACTION_APPLY_QUEUED);
-            if (status == MH_OK)
-            {
-                for (i = first; i < g_hooks.size; ++i)
-                {
-                    PHOOK_ENTRY pHook = &g_hooks.pItems[i];
-                    if (pHook->isEnabled != pHook->queueEnable)
-                    {
-                        status = EnableHookLL(i, pHook->queueEnable);
-                        if (status != MH_OK)
-                            break;
-                    }
-                }
-
-                Unfreeze(&threads);
-            }
-        }
-    }
-    else
-    {
-        status = MH_ERROR_NOT_INITIALIZED;
-    }
-
-    LeaveSpinLock();
-
-    return status;
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_CreateHookApiEx(
-    LPCWSTR pszModule, LPCSTR pszProcName, LPVOID pDetour,
-    LPVOID *ppOriginal, LPVOID *ppTarget)
-{
-    HMODULE hModule;
-    LPVOID  pTarget;
-
-    hModule = GetModuleHandleW(pszModule);
-    if (hModule == NULL)
-        return MH_ERROR_MODULE_NOT_FOUND;
-
-    pTarget = (LPVOID)GetProcAddress(hModule, pszProcName);
-    if (pTarget == NULL)
-        return MH_ERROR_FUNCTION_NOT_FOUND;
-
-    if (ppTarget != NULL)
-        *ppTarget = pTarget;
-
-    return MH_CreateHook(pTarget, pDetour, ppOriginal);
-}
-
-//-------------------------------------------------------------------------
-MH_STATUS WINAPI MH_CreateHookApi(
-    LPCWSTR pszModule, LPCSTR pszProcName, LPVOID pDetour, LPVOID *ppOriginal)
-{
-    return MH_CreateHookApiEx(pszModule, pszProcName, pDetour, ppOriginal, NULL);
-}
-
-//-------------------------------------------------------------------------
-const char *WINAPI MH_StatusToString(MH_STATUS status)
-{
-#define MH_ST2STR(x)    \
-    case x:             \
-        return #x;
-
-    switch (status) {
-        MH_ST2STR(MH_UNKNOWN)
-        MH_ST2STR(MH_OK)
-        MH_ST2STR(MH_ERROR_ALREADY_INITIALIZED)
-        MH_ST2STR(MH_ERROR_NOT_INITIALIZED)
-        MH_ST2STR(MH_ERROR_ALREADY_CREATED)
-        MH_ST2STR(MH_ERROR_NOT_CREATED)
-        MH_ST2STR(MH_ERROR_ENABLED)
-        MH_ST2STR(MH_ERROR_DISABLED)
-        MH_ST2STR(MH_ERROR_NOT_EXECUTABLE)
-        MH_ST2STR(MH_ERROR_UNSUPPORTED_FUNCTION)
-        MH_ST2STR(MH_ERROR_MEMORY_ALLOC)
-        MH_ST2STR(MH_ERROR_MEMORY_PROTECT)
-        MH_ST2STR(MH_ERROR_MODULE_NOT_FOUND)
-        MH_ST2STR(MH_ERROR_FUNCTION_NOT_FOUND)
-    }
-
-#undef MH_ST2STR
-
-    return "(unknown)";
-}

keyDumper/src/src/trampoline.c

@@ -1,320 +0,0 @@
-/*
- *  MinHook - The Minimalistic API Hooking Library for x64/x86
- *  Copyright (C) 2009-2017 Tsuda Kageyu.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *   2. 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 HOLDER
- *  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.
- */
-
-#include <windows.h>
-
-#if defined(_MSC_VER) && !defined(MINHOOK_DISABLE_INTRINSICS)
-    #define ALLOW_INTRINSICS
-    #include <intrin.h>
-#endif
-
-#ifndef ARRAYSIZE
-    #define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))
-#endif
-
-#if defined(_M_X64) || defined(__x86_64__)
-    #include "./hde/hde64.h"
-    typedef hde64s HDE;
-    #define HDE_DISASM(code, hs) hde64_disasm(code, hs)
-#else
-    #include "./hde/hde32.h"
-    typedef hde32s HDE;
-    #define HDE_DISASM(code, hs) hde32_disasm(code, hs)
-#endif
-
-#include "trampoline.h"
-#include "buffer.h"
-
-// Maximum size of a trampoline function.
-#if defined(_M_X64) || defined(__x86_64__)
-    #define TRAMPOLINE_MAX_SIZE (MEMORY_SLOT_SIZE - sizeof(JMP_ABS))
-#else
-    #define TRAMPOLINE_MAX_SIZE MEMORY_SLOT_SIZE
-#endif
-
-//-------------------------------------------------------------------------
-static BOOL IsCodePadding(LPBYTE pInst, UINT size)
-{
-    UINT i;
-
-    if (pInst[0] != 0x00 && pInst[0] != 0x90 && pInst[0] != 0xCC)
-        return FALSE;
-
-    for (i = 1; i < size; ++i)
-    {
-        if (pInst[i] != pInst[0])
-            return FALSE;
-    }
-    return TRUE;
-}
-
-//-------------------------------------------------------------------------
-BOOL CreateTrampolineFunction(PTRAMPOLINE ct)
-{
-#if defined(_M_X64) || defined(__x86_64__)
-    CALL_ABS call = {
-        0xFF, 0x15, 0x00000002, // FF15 00000002: CALL [RIP+8]
-        0xEB, 0x08,             // EB 08:         JMP +10
-        0x0000000000000000ULL   // Absolute destination address
-    };
-    JMP_ABS jmp = {
-        0xFF, 0x25, 0x00000000, // FF25 00000000: JMP [RIP+6]
-        0x0000000000000000ULL   // Absolute destination address
-    };
-    JCC_ABS jcc = {
-        0x70, 0x0E,             // 7* 0E:         J** +16
-        0xFF, 0x25, 0x00000000, // FF25 00000000: JMP [RIP+6]
-        0x0000000000000000ULL   // Absolute destination address
-    };
-#else
-    CALL_REL call = {
-        0xE8,                   // E8 xxxxxxxx: CALL +5+xxxxxxxx
-        0x00000000              // Relative destination address
-    };
-    JMP_REL jmp = {
-        0xE9,                   // E9 xxxxxxxx: JMP +5+xxxxxxxx
-        0x00000000              // Relative destination address
-    };
-    JCC_REL jcc = {
-        0x0F, 0x80,             // 0F8* xxxxxxxx: J** +6+xxxxxxxx
-        0x00000000              // Relative destination address
-    };
-#endif
-
-    UINT8     oldPos   = 0;
-    UINT8     newPos   = 0;
-    ULONG_PTR jmpDest  = 0;     // Destination address of an internal jump.
-    BOOL      finished = FALSE; // Is the function completed?
-#if defined(_M_X64) || defined(__x86_64__)
-    UINT8     instBuf[16];
-#endif
-
-    ct->patchAbove = FALSE;
-    ct->nIP        = 0;
-
-    do
-    {
-        HDE       hs;
-        UINT      copySize;
-        LPVOID    pCopySrc;
-        ULONG_PTR pOldInst = (ULONG_PTR)ct->pTarget     + oldPos;
-        ULONG_PTR pNewInst = (ULONG_PTR)ct->pTrampoline + newPos;
-
-        copySize = HDE_DISASM((LPVOID)pOldInst, &hs);
-        if (hs.flags & F_ERROR)
-            return FALSE;
-
-        pCopySrc = (LPVOID)pOldInst;
-        if (oldPos >= sizeof(JMP_REL))
-        {
-            // The trampoline function is long enough.
-            // Complete the function with the jump to the target function.
-#if defined(_M_X64) || defined(__x86_64__)
-            jmp.address = pOldInst;
-#else
-            jmp.operand = (UINT32)(pOldInst - (pNewInst + sizeof(jmp)));
-#endif
-            pCopySrc = &jmp;
-            copySize = sizeof(jmp);
-
-            finished = TRUE;
-        }
-#if defined(_M_X64) || defined(__x86_64__)
-        else if ((hs.modrm & 0xC7) == 0x05)
-        {
-            // Instructions using RIP relative addressing. (ModR/M = 00???101B)
-
-            // Modify the RIP relative address.
-            PUINT32 pRelAddr;
-
-            // Avoid using memcpy to reduce the footprint.
-#ifndef ALLOW_INTRINSICS
-            memcpy(instBuf, (LPBYTE)pOldInst, copySize);
-#else
-            __movsb(instBuf, (LPBYTE)pOldInst, copySize);
-#endif
-            pCopySrc = instBuf;
-
-            // Relative address is stored at (instruction length - immediate value length - 4).
-            pRelAddr = (PUINT32)(instBuf + hs.len - ((hs.flags & 0x3C) >> 2) - 4);
-            *pRelAddr
-                = (UINT32)((pOldInst + hs.len + (INT32)hs.disp.disp32) - (pNewInst + hs.len));
-
-            // Complete the function if JMP (FF /4).
-            if (hs.opcode == 0xFF && hs.modrm_reg == 4)
-                finished = TRUE;
-        }
-#endif
-        else if (hs.opcode == 0xE8)
-        {
-            // Direct relative CALL
-            ULONG_PTR dest = pOldInst + hs.len + (INT32)hs.imm.imm32;
-#if defined(_M_X64) || defined(__x86_64__)
-            call.address = dest;
-#else
-            call.operand = (UINT32)(dest - (pNewInst + sizeof(call)));
-#endif
-            pCopySrc = &call;
-            copySize = sizeof(call);
-        }
-        else if ((hs.opcode & 0xFD) == 0xE9)
-        {
-            // Direct relative JMP (EB or E9)
-            ULONG_PTR dest = pOldInst + hs.len;
-
-            if (hs.opcode == 0xEB) // isShort jmp
-                dest += (INT8)hs.imm.imm8;
-            else
-                dest += (INT32)hs.imm.imm32;
-
-            // Simply copy an internal jump.
-            if ((ULONG_PTR)ct->pTarget <= dest
-                && dest < ((ULONG_PTR)ct->pTarget + sizeof(JMP_REL)))
-            {
-                if (jmpDest < dest)
-                    jmpDest = dest;
-            }
-            else
-            {
-#if defined(_M_X64) || defined(__x86_64__)
-                jmp.address = dest;
-#else
-                jmp.operand = (UINT32)(dest - (pNewInst + sizeof(jmp)));
-#endif
-                pCopySrc = &jmp;
-                copySize = sizeof(jmp);
-
-                // Exit the function if it is not in the branch.
-                finished = (pOldInst >= jmpDest);
-            }
-        }
-        else if ((hs.opcode & 0xF0) == 0x70
-            || (hs.opcode & 0xFC) == 0xE0
-            || (hs.opcode2 & 0xF0) == 0x80)
-        {
-            // Direct relative Jcc
-            ULONG_PTR dest = pOldInst + hs.len;
-
-            if ((hs.opcode & 0xF0) == 0x70      // Jcc
-                || (hs.opcode & 0xFC) == 0xE0)  // LOOPNZ/LOOPZ/LOOP/JECXZ
-                dest += (INT8)hs.imm.imm8;
-            else
-                dest += (INT32)hs.imm.imm32;
-
-            // Simply copy an internal jump.
-            if ((ULONG_PTR)ct->pTarget <= dest
-                && dest < ((ULONG_PTR)ct->pTarget + sizeof(JMP_REL)))
-            {
-                if (jmpDest < dest)
-                    jmpDest = dest;
-            }
-            else if ((hs.opcode & 0xFC) == 0xE0)
-            {
-                // LOOPNZ/LOOPZ/LOOP/JCXZ/JECXZ to the outside are not supported.
-                return FALSE;
-            }
-            else
-            {
-                UINT8 cond = ((hs.opcode != 0x0F ? hs.opcode : hs.opcode2) & 0x0F);
-#if defined(_M_X64) || defined(__x86_64__)
-                // Invert the condition in x64 mode to simplify the conditional jump logic.
-                jcc.opcode  = 0x71 ^ cond;
-                jcc.address = dest;
-#else
-                jcc.opcode1 = 0x80 | cond;
-                jcc.operand = (UINT32)(dest - (pNewInst + sizeof(jcc)));
-#endif
-                pCopySrc = &jcc;
-                copySize = sizeof(jcc);
-            }
-        }
-        else if ((hs.opcode & 0xFE) == 0xC2)
-        {
-            // RET (C2 or C3)
-
-            // Complete the function if not in a branch.
-            finished = (pOldInst >= jmpDest);
-        }
-
-        // Can't alter the instruction length in a branch.
-        if (pOldInst < jmpDest && copySize != hs.len)
-            return FALSE;
-
-        // Trampoline function is too large.
-        if ((newPos + copySize) > TRAMPOLINE_MAX_SIZE)
-            return FALSE;
-
-        // Trampoline function has too many instructions.
-        if (ct->nIP >= ARRAYSIZE(ct->oldIPs))
-            return FALSE;
-
-        ct->oldIPs[ct->nIP] = oldPos;
-        ct->newIPs[ct->nIP] = newPos;
-        ct->nIP++;
-
-        // Avoid using memcpy to reduce the footprint.
-#ifndef ALLOW_INTRINSICS
-        memcpy((LPBYTE)ct->pTrampoline + newPos, pCopySrc, copySize);
-#else
-        __movsb((LPBYTE)ct->pTrampoline + newPos, (LPBYTE)pCopySrc, copySize);
-#endif
-        newPos += copySize;
-        oldPos += hs.len;
-    } while (!finished);
-
-    // Is there enough place for a long jump?
-    if (oldPos < sizeof(JMP_REL)
-        && !IsCodePadding((LPBYTE)ct->pTarget + oldPos, sizeof(JMP_REL) - oldPos))
-    {
-        // Is there enough place for a short jump?
-        if (oldPos < sizeof(JMP_REL_SHORT)
-            && !IsCodePadding((LPBYTE)ct->pTarget + oldPos, sizeof(JMP_REL_SHORT) - oldPos))
-        {
-            return FALSE;
-        }
-
-        // Can we place the long jump above the function?
-        if (!IsExecutableAddress((LPBYTE)ct->pTarget - sizeof(JMP_REL)))
-            return FALSE;
-
-        if (!IsCodePadding((LPBYTE)ct->pTarget - sizeof(JMP_REL), sizeof(JMP_REL)))
-            return FALSE;
-
-        ct->patchAbove = TRUE;
-    }
-
-#if defined(_M_X64) || defined(__x86_64__)
-    // Create a relay function.
-    jmp.address = (ULONG_PTR)ct->pDetour;
-
-    ct->pRelay = (LPBYTE)ct->pTrampoline + newPos;
-    memcpy(ct->pRelay, &jmp, sizeof(jmp));
-#endif
-
-    return TRUE;
-}

keyDumper/src/src/trampoline.h

@@ -1,105 +0,0 @@
-/*
- *  MinHook - The Minimalistic API Hooking Library for x64/x86
- *  Copyright (C) 2009-2017 Tsuda Kageyu.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *   2. 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 HOLDER
- *  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.
- */
-
-#pragma once
-
-#pragma pack(push, 1)
-
-// Structs for writing x86/x64 instructions.
-
-// 8-bit relative jump.
-typedef struct _JMP_REL_SHORT
-{
-    UINT8  opcode;      // EB xx: JMP +2+xx
-    UINT8  operand;
-} JMP_REL_SHORT, *PJMP_REL_SHORT;
-
-// 32-bit direct relative jump/call.
-typedef struct _JMP_REL
-{
-    UINT8  opcode;      // E9/E8 xxxxxxxx: JMP/CALL +5+xxxxxxxx
-    UINT32 operand;     // Relative destination address
-} JMP_REL, *PJMP_REL, CALL_REL;
-
-// 64-bit indirect absolute jump.
-typedef struct _JMP_ABS
-{
-    UINT8  opcode0;     // FF25 00000000: JMP [+6]
-    UINT8  opcode1;
-    UINT32 dummy;
-    UINT64 address;     // Absolute destination address
-} JMP_ABS, *PJMP_ABS;
-
-// 64-bit indirect absolute call.
-typedef struct _CALL_ABS
-{
-    UINT8  opcode0;     // FF15 00000002: CALL [+6]
-    UINT8  opcode1;
-    UINT32 dummy0;
-    UINT8  dummy1;      // EB 08:         JMP +10
-    UINT8  dummy2;
-    UINT64 address;     // Absolute destination address
-} CALL_ABS;
-
-// 32-bit direct relative conditional jumps.
-typedef struct _JCC_REL
-{
-    UINT8  opcode0;     // 0F8* xxxxxxxx: J** +6+xxxxxxxx
-    UINT8  opcode1;
-    UINT32 operand;     // Relative destination address
-} JCC_REL;
-
-// 64bit indirect absolute conditional jumps that x64 lacks.
-typedef struct _JCC_ABS
-{
-    UINT8  opcode;      // 7* 0E:         J** +16
-    UINT8  dummy0;
-    UINT8  dummy1;      // FF25 00000000: JMP [+6]
-    UINT8  dummy2;
-    UINT32 dummy3;
-    UINT64 address;     // Absolute destination address
-} JCC_ABS;
-
-#pragma pack(pop)
-
-typedef struct _TRAMPOLINE
-{
-    LPVOID pTarget;         // [In] Address of the target function.
-    LPVOID pDetour;         // [In] Address of the detour function.
-    LPVOID pTrampoline;     // [In] Buffer address for the trampoline and relay function.
-
-#if defined(_M_X64) || defined(__x86_64__)
-    LPVOID pRelay;          // [Out] Address of the relay function.
-#endif
-    BOOL   patchAbove;      // [Out] Should use the hot patch area?
-    UINT   nIP;             // [Out] Number of the instruction boundaries.
-    UINT8  oldIPs[8];       // [Out] Instruction boundaries of the target function.
-    UINT8  newIPs[8];       // [Out] Instruction boundaries of the trampoline function.
-} TRAMPOLINE, *PTRAMPOLINE;
-
-BOOL CreateTrampolineFunction(PTRAMPOLINE ct);