1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

┌─────────────────────────────────────────────────────────────────────┐
│                    Unity 脚本后端对比                                │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   C# 源代码 (.cs)                                                   │
│        │                                                            │
│        ├──────────────────────┬──────────────────────┐              │
│        ▼                     ▼                       │              │
│   ┌─────────┐          ┌──────────┐                  │              │
│   │  Mono   │          │  IL2CPP  │                  │              │
│   │  后端    │          │  后端    │                  │              │
│   └────┬────┘          └─────┬────┘                  │              │
│        │                     │                       │              │
│        ▼                     ▼                       │              │
│   C# --> IL (.dll)      C# --> IL --> C++ --> .so    │              │
│        │                     │                       │              │
│        ▼                     ▼                       │              │
│   Mono VM 解释执行      Native 机器码直接执行         │              │
│        │                     │                       │              │
│        ▼                     ▼                       │              │
│   Assembly-CSharp.dll   libil2cpp.so                 │              │
│   (可直接反编译)         + global-metadata.dat        │              │
│                          (需要 Dump 还原符号)         │              │
│                                                      │              │
└─────────────────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│  C# 源代码    │────>│  IL 字节码    │────>│  C++ 源代码   │
│  (.cs 文件)   │     │  (.dll 文件)  │     │  (.cpp 文件)  │
└──────────────┘     └──────────────┘     └──────┬───────┘
                      Roslyn 编译器               │ il2cpp.exe 转换
                                                  ▼
┌──────────────┐     ┌──────────────────┐  ┌──────────────┐
│ 最终 APK/AAB  │<───│ libil2cpp.so     │<─│  .o 目标文件  │
│              │     │ (stripped, 无符号) │  │              │
│              │     ├──────────────────┤  └──────────────┘
│              │     │ global-metadata  │        NDK 编译
│              │     │ .dat (元数据)     │
│              │     └──────────────────┘
└──────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

game.apk (解压后)
├── lib/
│   ├── armeabi-v7a/                    # 32 位 ARM
│   │   ├── libil2cpp.so                # ★ 核心游戏逻辑 (50-200MB)
│   │   ├── libmain.so                  # Unity 启动入口
│   │   └── libunity.so                 # Unity 引擎运行时
│   └── arm64-v8a/                      # 64 位 ARM
│       ├── libil2cpp.so                # ★ 优先分析这个
│       ├── libmain.so
│       └── libunity.so
├── assets/
│   └── bin/
│       └── Data/
│           ├── Managed/
│           │   ├── Metadata/
│           │   │   └── global-metadata.dat  # ★ 元数据 (5-30MB)
│           │   └── Resources/
│           ├── data.unity3d              # 资源包
│           ├── level0                    # 场景文件
│           ├── sharedassets0.assets      # 共享资源
│           └── boot.config               # 启动配置
├── classes.dex                           # Java 层 (通常很薄)
├── AndroidManifest.xml
└── META-INF/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 解压 APK
unzip -o target.apk -d target_apk/

# 方法 1: 检查 SO 库
ls target_apk/lib/arm64-v8a/
# Unity 特征: 同时存在 libil2cpp.so, libunity.so, libmain.so

# 方法 2: 检查 metadata
ls target_apk/assets/bin/Data/Managed/Metadata/
# 存在 global-metadata.dat

# 方法 3: 检查启动配置
cat target_apk/assets/bin/Data/boot.config
# 内容类似:
# scripting-backend=il2cpp
# player-connection-mode=Listen

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#!/bin/bash
# unity_detect.sh - 快速识别 Unity 游戏类型

APK=$1
TMPDIR=$(mktemp -d)

unzip -q "$APK" -d "$TMPDIR" 2>/dev/null

echo "=== Unity 游戏检测 ==="

# 检测 Unity 引擎
if [ -f "$TMPDIR/lib/arm64-v8a/libunity.so" ] || \
   [ -f "$TMPDIR/lib/armeabi-v7a/libunity.so" ]; then
    echo "[+] 检测到 Unity 引擎"

    # 判断后端类型
    if [ -f "$TMPDIR/lib/arm64-v8a/libil2cpp.so" ]; then
        echo "[+] 脚本后端: IL2CPP (64-bit)"
        SO_SIZE=$(stat -f%z "$TMPDIR/lib/arm64-v8a/libil2cpp.so" 2>/dev/null || \
                  stat -c%s "$TMPDIR/lib/arm64-v8a/libil2cpp.so" 2>/dev/null)
        echo "    libil2cpp.so 大小: $(echo "scale=2; $SO_SIZE/1048576" | bc) MB"
    elif [ -f "$TMPDIR/lib/armeabi-v7a/libil2cpp.so" ]; then
        echo "[+] 脚本后端: IL2CPP (32-bit only)"
    fi

    if [ -d "$TMPDIR/assets/bin/Data/Managed" ]; then
        DLL_COUNT=$(find "$TMPDIR/assets/bin/Data/Managed" -name "*.dll" 2>/dev/null | wc -l)
        if [ "$DLL_COUNT" -gt 0 ]; then
            echo "[+] 脚本后端: Mono (找到 $DLL_COUNT 个 DLL)"
        fi
    fi

    # 检测 metadata
    if [ -f "$TMPDIR/assets/bin/Data/Managed/Metadata/global-metadata.dat" ]; then
        META_SIZE=$(stat -f%z "$TMPDIR/assets/bin/Data/Managed/Metadata/global-metadata.dat" \
                    2>/dev/null || stat -c%s \
                    "$TMPDIR/assets/bin/Data/Managed/Metadata/global-metadata.dat" 2>/dev/null)
        echo "[+] global-metadata.dat 大小: $(echo "scale=2; $META_SIZE/1048576" | bc) MB"

        # 检查 magic number
        MAGIC=$(xxd -l 4 "$TMPDIR/assets/bin/Data/Managed/Metadata/global-metadata.dat" | \
                awk '{print $2$3}')
        if [ "$MAGIC" = "af1b b1fa" ] || [ "$MAGIC" = "AF1BB1FA" ]; then
            echo "[+] metadata 未加密 (magic: AF1BB1FA)"
        else
            echo "[!] metadata 可能已加密 (magic: $MAGIC)"
        fi
    fi

    # Unity 版本
    if [ -f "$TMPDIR/assets/bin/Data/boot.config" ]; then
        echo "[+] boot.config 内容:"
        cat "$TMPDIR/assets/bin/Data/boot.config" | sed 's/^/    /'
    fi
else
    echo "[-] 非 Unity 游戏"
fi

rm -rf "$TMPDIR"

1
2
3
4

# IDA 中看到的 stripped libil2cpp.so
.text:00123456  sub_123456    # 这是什么函数？不知道
.text:00123500  sub_123500    # 是 AddCoin? TakeDamage? 完全不清楚
.text:00123600  sub_123600    # 上万个无名函数...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

┌─────────────────────────────────┐    ┌─────────────────────────────┐
│        libil2cpp.so             │    │    global-metadata.dat      │
│  (stripped, 无符号信息)          │    │    (类/方法/字段名映射)       │
├─────────────────────────────────┤    ├─────────────────────────────┤
│                                 │    │                             │
│  sub_123456:                    │◄──►│  PlayerData.AddCoin()       │
│    push {r4, r5, lr}           │    │    offset: 0x123456         │
│    ldr r4, [r0, #0x10]        │    │    params: (int amount)     │
│    add r4, r4, r1             │    │                             │
│    str r4, [r0, #0x10]        │    │  PlayerData.coin            │
│    pop {r4, r5, pc}           │    │    field_offset: 0x10       │
│                                 │    │    type: System.Int32       │
│  sub_123500:                    │◄──►│  BattleManager.TakeDamage() │
│    ...                          │    │    offset: 0x123500         │
│                                 │    │                             │
└─────────────────────────────────┘    └─────────────────────────────┘
         ▲                                        ▲
         │                                        │
         └──────── Il2CppDumper 建立映射 ──────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// Il2CppClass - 表示一个 C# 类
typedef struct Il2CppClass {
    Il2CppImage* image;              // 所属的程序集镜像
    void* gc_desc;
    const char* name;                // 类名 (如 "PlayerData")
    const char* namespaze;           // 命名空间 (如 "Game.Logic")
    Il2CppType byval_arg;
    Il2CppType this_arg;
    Il2CppClass* element_class;
    Il2CppClass* parent;             // 父类
    Il2CppGenericClass* generic_class;
    // ...
    FieldInfo* fields;               // 字段数组
    const MethodInfo** methods;      // 方法数组
    uint16_t field_count;
    uint16_t method_count;
    // ...
    uint32_t instance_size;          // 实例大小
    // ...
} Il2CppClass;

// MethodInfo - 表示一个 C# 方法
typedef struct MethodInfo {
    Il2CppMethodPointer methodPointer;  // ★ 函数指针 (可用于 Hook)
    const char* name;                    // 方法名 (如 "AddCoin")
    Il2CppClass* klass;                  // 所属的类
    const Il2CppType* return_type;       // 返回类型
    const ParameterInfo* parameters;     // 参数信息
    uint8_t parameters_count;            // 参数数量
    // ...
} MethodInfo;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

C# 原始方法:
    public class Player {
        public int AddCoin(int amount) { ... }
    }

IL2CPP 转换后:
    int32_t Player_AddCoin(Player* __this, int32_t amount, MethodInfo* method)
                           ─────────────  ──────────────  ─────────────────
                           第一个参数       第二个参数       隐含的方法信息
                           是 this 指针     是原始参数       (通常可忽略)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

typedef struct Il2CppGlobalMetadataHeader {
    int32_t sanity;              // 魔数: 0xFAB11BAF
    int32_t version;             // 版本号 (如 29 for Unity 2021+)
    int32_t stringLiteralOffset;
    int32_t stringLiteralSize;
    int32_t stringLiteralDataOffset;
    int32_t stringLiteralDataSize;
    int32_t stringOffset;        // 字符串表偏移
    int32_t stringSize;          // 字符串表大小
    int32_t eventsOffset;
    int32_t eventsSize;
    int32_t propertiesOffset;
    int32_t propertiesSize;
    int32_t methodsOffset;       // 方法定义表偏移
    int32_t methodsSize;
    int32_t fieldDefaultValuesOffset;
    int32_t fieldDefaultValuesSize;
    int32_t imagesOffset;        // 程序集镜像表偏移
    int32_t imagesSize;
    int32_t assembliesOffset;    // 程序集表偏移
    int32_t assembliesSize;
    // ... (更多表的偏移和大小)
} Il2CppGlobalMetadataHeader;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

偏移        内容                      大小
─────────────────────────────────────────────────
0x0000      Header (魔数 + 版本 + 表指针)    ~300 字节
0x0130      String Literal Table            可变
0x????      String Table (类名/方法名)       可变
0x????      Type Definitions                可变
0x????      Method Definitions              可变
0x????      Field Definitions               可变
0x????      Image Definitions               可变
0x????      Assembly Definitions            可变
...         (其余元数据表)
EOF

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 方法 1: 检查魔数 (正常应该是 AF 1B B1 FA)
xxd -l 16 global-metadata.dat
# 正常输出: af1b b1fa 1d00 0000 ...  (1d = version 29)
# 加密输出: 随机字节 或 全零 或 其他固定值

# 方法 2: 搜索明文字符串 (正常的 metadata 包含大量可读字符串)
strings global-metadata.dat | head -20
# 正常: 能看到 System.Object, UnityEngine, MonoBehaviour 等
# 加密: 几乎没有可读字符串

# 方法 3: 检查熵值 (加密数据熵值接近 8.0)
python3 -c "
import math, sys
data = open(sys.argv[1], 'rb').read()
freq = [0] * 256
for b in data: freq[b] += 1
entropy = -sum(f/len(data) * math.log2(f/len(data)) for f in freq if f > 0)
print(f'Entropy: {entropy:.4f}')
print('加密可能性: ' + ('高' if entropy > 7.5 else '低'))
" global-metadata.dat

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# xor_decrypt_metadata.py
# 利用已知的 magic number 推断 XOR key

import struct

with open("global-metadata.dat", "rb") as f:
    data = bytearray(f.read())

# global-metadata.dat 的 magic number 应该是 0xFAB11BAF
EXPECTED_MAGIC = struct.pack("<I", 0xFAB11BAF)  # AF 1B B1 FA
actual_magic = data[:4]

# 推断 XOR key
key = bytes([a ^ b for a, b in zip(actual_magic, EXPECTED_MAGIC)])
print(f"推断的 XOR key: {key.hex()}")

# 尝试解密
key_len = len(key)
decrypted = bytearray(len(data))
for i in range(len(data)):
    decrypted[i] = data[i] ^ key[i % key_len]

# 验证
dec_magic = struct.unpack("<I", decrypted[:4])[0]
dec_version = struct.unpack("<i", decrypted[4:8])[0]
print(f"解密后 magic: 0x{dec_magic:08X} (期望: 0xFAB11BAF)")
print(f"解密后 version: {dec_version} (合理范围: 24-31)")

if dec_magic == 0xFAB11BAF and 20 <= dec_version <= 35:
    with open("global-metadata-decrypted.dat", "wb") as f:
        f.write(decrypted)
    print("[+] 解密成功!")
else:
    print("[-] XOR 解密失败，可能是更复杂的加密方案")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// frida_dump_metadata.js
// Hook metadata 加载函数，Dump 解密后的 metadata

Java.perform(function() {
    var il2cpp = Module.findBaseAddress("libil2cpp.so");
    if (!il2cpp) {
        console.log("[-] libil2cpp.so not loaded yet");
        return;
    }

    // 方法 1: Hook il2cpp_init
    // metadata 通常在 il2cpp 初始化时加载
    var il2cpp_init = Module.findExportByName("libil2cpp.so", "il2cpp_init");
    if (il2cpp_init) {
        Interceptor.attach(il2cpp_init, {
            onEnter: function(args) {
                console.log("[*] il2cpp_init called");
            },
            onLeave: function(retval) {
                console.log("[*] il2cpp_init returned, scanning memory...");
                scanForMetadata();
            }
        });
    }

    // 方法 2: 扫描内存中的 metadata magic
    function scanForMetadata() {
        var ranges = Process.enumerateRanges("r--");
        for (var i = 0; i < ranges.length; i++) {
            var range = ranges[i];
            if (range.size < 1024) continue;

            try {
                var results = Memory.scanSync(range.base, range.size, "AF 1B B1 FA");
                for (var j = 0; j < results.length; j++) {
                    var addr = results[j].address;
                    var version = addr.add(4).readS32();

                    if (version >= 20 && version <= 35) {
                        console.log("[+] Found metadata at: " + addr +
                                    " version: " + version);

                        // 推测大小 (读取 header 中的最大偏移 + 大小)
                        var metaSize = estimateMetadataSize(addr);
                        console.log("[+] Estimated size: " + metaSize);

                        // Dump 到文件
                        var file = new File("/data/local/tmp/global-metadata-dumped.dat", "wb");
                        file.write(addr.readByteArray(metaSize));
                        file.close();
                        console.log("[+] Dumped to /data/local/tmp/global-metadata-dumped.dat");
                    }
                }
            } catch(e) {}
        }
    }

    function estimateMetadataSize(base) {
        // 遍历 header 中的 (offset, size) 对，找到最大的 offset+size
        var maxEnd = 0;
        for (var i = 2; i < 60; i += 2) {  // header 中的表偏移
            var offset = base.add(i * 4).readS32();
            var size = base.add((i + 1) * 4).readS32();
            if (offset > 0 && size > 0 && (offset + size) > maxEnd) {
                maxEnd = offset + size;
            }
        }
        return maxEnd > 0 ? maxEnd : 0x1000000;  // 默认 16MB
    }
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 下载 Il2CppDumper (推荐 v6.7.x+)
# https://github.com/Perfare/Il2CppDumper/releases

# 解压 APK
mkdir -p ~/unity_re/target
cd ~/unity_re/target
unzip -o game.apk

# 提取关键文件
cp lib/arm64-v8a/libil2cpp.so ~/unity_re/
cp assets/bin/Data/Managed/Metadata/global-metadata.dat ~/unity_re/

1
2
3
4
5
6
7

cd ~/unity_re

# 方式 1: 命令行模式 (推荐)
Il2CppDumper libil2cpp.so global-metadata.dat output/

# 方式 2: GUI 模式 (Windows)
# 运行 Il2CppDumper.exe，依次选择 libil2cpp.so 和 global-metadata.dat

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

output/
├── dump.cs              # ★ 还原的 C# 伪代码 (最重要)
├── script.py            # IDA Pro 重命名脚本
├── ghidra.py            # Ghidra 重命名脚本 (Ghidra 11 可用)
├── il2cpp.h             # C 头文件 (IDA 可导入)
├── stringliteral.json   # 字符串字面量表
├── DummyDll/            # ★ 空壳 DLL (可用 dnSpy 打开)
│   ├── Assembly-CSharp.dll
│   ├── Assembly-CSharp-firstpass.dll
│   ├── UnityEngine.dll
│   ├── UnityEngine.CoreModule.dll
│   ├── mscorlib.dll
│   └── ...
└── il2cpp_types.json    # 类型信息 JSON

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// dump.cs 示例内容

// Namespace: Game.Logic
public class PlayerData // TypeDefIndex: 3456
{
    // Fields
    public int coin; // 0x10
    public int gem; // 0x14
    public int level; // 0x18
    public float hp; // 0x1C
    public float maxHp; // 0x20
    public string playerName; // 0x28
    public List<ItemData> inventory; // 0x30

    // Methods
    // RVA: 0x1A2B3C Offset: 0x1A2B3C VA: 0x1A2B3C
    public void AddCoin(int amount) { }

    // RVA: 0x1A2B80 Offset: 0x1A2B80 VA: 0x1A2B80
    public void SubCoin(int amount) { }

    // RVA: 0x1A2BC0 Offset: 0x1A2BC0 VA: 0x1A2BC0
    public int GetCoin() { }

    // RVA: 0x1A2C00 Offset: 0x1A2C00 VA: 0x1A2C00
    public void TakeDamage(float damage) { }

    // RVA: 0x1A2C80 Offset: 0x1A2C80 VA: 0x1A2C80
    public void Heal(float amount) { }

    // RVA: 0x1A2D00 Offset: 0x1A2D00 VA: 0x1A2D00
    public static PlayerData get_Instance() { }
}

// Namespace: Game.Battle
public class BattleManager : MonoBehaviour // TypeDefIndex: 3500
{
    // Fields
    public static BattleManager instance; // 0x0
    public float damageMultiplier; // 0x18
    public bool isInvincible; // 0x1C

    // Methods
    // RVA: 0x1B0000 Offset: 0x1B0000 VA: 0x1B0000
    public void CalculateDamage(PlayerData attacker, PlayerData target, float baseDmg) { }

    // RVA: 0x1B0100 Offset: 0x1B0100 VA: 0x1B0100
    public void OnBattleEnd(bool isWin) { }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

步骤:
1. 打开 dnSpy (https://github.com/dnSpy/dnSpy)
2. File -> Open -> 选择 output/DummyDll/Assembly-CSharp.dll
3. 在左侧类树中浏览所有类和方法
4. 虽然方法体是空的，但可以看到完整的类继承、接口实现、枚举定义等

优势:
- 树状浏览比 dump.cs 的平面文本更直观
- 支持搜索类名、方法名、字段名
- 可以看到泛型参数、特性 (Attribute) 等详细信息

1
2
3
4
5
6
7

1. 用 IDA 打开 libil2cpp.so (选择 ARM 64-bit 或 ARM 32-bit)
2. 等待自动分析完成 (可能需要 10-30 分钟)
3. File -> Script file -> 选择 output/script.py
4. 脚本执行后，所有函数会被重命名:
   sub_1A2B3C  -->  PlayerData$$AddCoin
   sub_1A2B80  -->  PlayerData$$SubCoin
   sub_1B0000  -->  BattleManager$$CalculateDamage

1
2
3
4

1. 创建新项目，导入 libil2cpp.so
2. 分析完成后，Window -> Script Manager
3. 运行 output/ghidra.py
4. 函数名和类型信息将被自动恢复

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104

// hook_il2cpp_basic.js
// 基础 IL2CPP Hook 模板

"use strict";

function hookIl2Cpp() {
    var soName = "libil2cpp.so";
    var baseAddr = Module.findBaseAddress(soName);

    if (!baseAddr) {
        console.log("[-] " + soName + " not loaded, retrying...");
        setTimeout(hookIl2Cpp, 1000);
        return;
    }

    console.log("[+] " + soName + " base: " + baseAddr);

    // ========================================
    // Hook PlayerData.AddCoin (RVA: 0x1A2B3C)
    // ========================================
    // 原型: void AddCoin(PlayerData* this, int amount, MethodInfo* method)
    var addCoinAddr = baseAddr.add(0x1A2B3C);
    Interceptor.attach(addCoinAddr, {
        onEnter: function(args) {
            // args[0] = this (PlayerData*)
            // args[1] = amount (int)
            // args[2] = MethodInfo*
            var thisPtr = args[0];
            var amount = args[1].toInt32();

            console.log("[*] AddCoin called, amount: " + amount);

            // 读取当前 coin 值 (字段偏移 0x10)
            var currentCoin = thisPtr.add(0x10).readS32();
            console.log("    Current coin: " + currentCoin);

            // 修改参数: 将增加量改为 99999
            args[1] = ptr(99999);
            console.log("    Modified amount to: 99999");
        },
        onLeave: function(retval) {
            console.log("[*] AddCoin finished");
        }
    });

    // ========================================
    // Hook PlayerData.TakeDamage (RVA: 0x1A2C00)
    // ========================================
    // 原型: void TakeDamage(PlayerData* this, float damage, MethodInfo* method)
    var takeDamageAddr = baseAddr.add(0x1A2C00);
    Interceptor.attach(takeDamageAddr, {
        onEnter: function(args) {
            var thisPtr = args[0];
            // 浮点参数在 ARM64 上通过 NEON 寄存器传递
            // 但 IL2CPP 有时会将 float 通过通用寄存器传递
            // 需要根据实际情况判断

            // 方法 1: 直接设置伤害为 0 (无敌)
            // 修改 float 参数
            var damagePtr = Memory.alloc(4);
            damagePtr.writeFloat(0.0);
            args[1] = damagePtr.readPointer();

            console.log("[*] TakeDamage -> damage set to 0 (god mode)");
        }
    });

    // ========================================
    // 直接修改内存中的字段值
    // ========================================
    // 如果能拿到 PlayerData 的实例指针，可以直接读写字段
    var getInstanceAddr = baseAddr.add(0x1A2D00); // PlayerData.get_Instance()
    Interceptor.attach(getInstanceAddr, {
        onLeave: function(retval) {
            if (!retval.isNull()) {
                var instance = retval;
                console.log("[*] PlayerData instance: " + instance);

                // 读取所有字段
                var coin  = instance.add(0x10).readS32();
                var gem   = instance.add(0x14).readS32();
                var level = instance.add(0x18).readS32();
                var hp    = instance.add(0x1C).readFloat();
                var maxHp = instance.add(0x20).readFloat();

                console.log("    Coin:  " + coin);
                console.log("    Gem:   " + gem);
                console.log("    Level: " + level);
                console.log("    HP:    " + hp.toFixed(1) + " / " + maxHp.toFixed(1));

                // 修改字段值
                instance.add(0x10).writeS32(999999);     // coin = 999999
                instance.add(0x14).writeS32(999999);     // gem = 999999
                instance.add(0x1C).writeFloat(99999.0);  // hp = 99999
                instance.add(0x20).writeFloat(99999.0);  // maxHp = 99999

                console.log("[+] Values modified!");
            }
        }
    });
}

// 等待 libil2cpp.so 加载
setTimeout(hookIl2Cpp, 3000);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

// hook_il2cpp_bridge.js
// 使用 frida-il2cpp-bridge 进行更优雅的 Hook

import "frida-il2cpp-bridge";

Il2Cpp.perform(() => {
    // 1. 获取程序集
    const assembly = Il2Cpp.domain.assembly("Assembly-CSharp");
    const image = assembly.image;

    console.log("[+] Assembly-CSharp loaded");
    console.log("    Classes count: " + image.classCount);

    // ========================================
    // 2. 查找并 Hook 类方法
    // ========================================
    const PlayerData = image.class("Game.Logic.PlayerData");
    console.log("[+] PlayerData found: " + PlayerData);

    // 列出所有方法
    for (const method of PlayerData.methods) {
        console.log("    Method: " + method.name +
                    " | Params: " + method.parameterCount +
                    " | Offset: " + method.relativeVirtualAddress);
    }

    // 列出所有字段
    for (const field of PlayerData.fields) {
        console.log("    Field: " + field.name +
                    " | Type: " + field.type.name +
                    " | Offset: " + field.offset);
    }

    // ========================================
    // 3. Hook AddCoin - 修改增加量
    // ========================================
    PlayerData.method("AddCoin").implementation = function(amount) {
        console.log("[*] AddCoin called, original amount: " + amount);

        // 调用原始方法，但传入修改后的参数
        this.method("AddCoin").invoke(99999);

        console.log("[+] AddCoin modified to 99999");
    };

    // ========================================
    // 4. Hook TakeDamage - 实现无敌
    // ========================================
    PlayerData.method("TakeDamage").implementation = function(damage) {
        console.log("[*] TakeDamage blocked! Original damage: " + damage);
        // 不调用原始方法 = 不受伤
        return;
    };

    // ========================================
    // 5. Hook SubCoin - 阻止扣币
    // ========================================
    PlayerData.method("SubCoin").implementation = function(amount) {
        console.log("[*] SubCoin blocked! Tried to deduct: " + amount);
        // 不执行原始扣币逻辑
        return;
    };

    // ========================================
    // 6. 读写实例字段
    // ========================================
    const getInstance = PlayerData.method("get_Instance");
    const instance = getInstance.invoke();

    if (!instance.isNull()) {
        console.log("[+] Got PlayerData instance");
        console.log("    coin:  " + instance.field("coin").value);
        console.log("    gem:   " + instance.field("gem").value);
        console.log("    hp:    " + instance.field("hp").value);

        // 直接修改字段
        instance.field("coin").value = 999999;
        instance.field("gem").value = 999999;
        console.log("[+] Fields modified!");
    }

    // ========================================
    // 7. 追踪整个类的方法调用
    // ========================================
    const BattleManager = image.class("Game.Battle.BattleManager");
    Il2Cpp.trace()
        .classes(BattleManager)
        .and()
        .attach();

    console.log("[+] BattleManager trace enabled");
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

// find_method_offset.js
// 在运行时搜索方法偏移

"use strict";

// 方法 1: Pattern Scanning (特征码搜索)
function findByPattern() {
    var module = Process.findModuleByName("libil2cpp.so");
    if (!module) return;

    // 例: 搜索 AddCoin 函数的开头字节 (需要先从 IDA 获取)
    // ARM64 函数通常以 STP X29, X30, [SP, #-0x??]! 开头
    var pattern = "FD 7B BE A9 FD 03 00 91";  // 示例 pattern
    var results = Memory.scanSync(module.base, module.size, pattern);

    console.log("Found " + results.length + " matches");
    results.forEach(function(match) {
        var rva = match.address.sub(module.base);
        console.log("  RVA: 0x" + rva.toString(16) + " VA: " + match.address);
    });
}

// 方法 2: 通过字符串引用定位
function findByStringRef() {
    var module = Process.findModuleByName("libil2cpp.so");
    if (!module) return;

    // 搜索游戏中的特征字符串
    var pattern = "00";  // 搜索 "AddCoin" 字符串
    var target = "AddCoin";
    var results = Memory.scanSync(module.base, module.size,
        stringToHexPattern(target));

    results.forEach(function(match) {
        console.log("[*] String '" + target + "' found at: " + match.address);

        // 搜索对这个字符串的交叉引用
        var strAddr = match.address;
        // 在代码段中搜索加载这个地址的指令
        // (需要根据 ARM64 指令格式计算)
    });
}

function stringToHexPattern(str) {
    var hex = "";
    for (var i = 0; i < str.length; i++) {
        hex += str.charCodeAt(i).toString(16).padStart(2, "0") + " ";
    }
    return hex.trim();
}

// 方法 3: 通过 IL2CPP API 获取运行时地址
function findByIl2CppApi() {
    // il2cpp_class_from_name 和 il2cpp_class_get_method_from_name
    // 是 libil2cpp.so 导出的 API

    var il2cpp_domain_get = new NativeFunction(
        Module.findExportByName("libil2cpp.so", "il2cpp_domain_get"),
        "pointer", []);

    var il2cpp_domain_get_assemblies = new NativeFunction(
        Module.findExportByName("libil2cpp.so", "il2cpp_domain_get_assemblies"),
        "pointer", ["pointer", "pointer"]);

    var il2cpp_class_from_name = new NativeFunction(
        Module.findExportByName("libil2cpp.so", "il2cpp_class_from_name"),
        "pointer", ["pointer", "pointer", "pointer"]);

    var il2cpp_class_get_method_from_name = new NativeFunction(
        Module.findExportByName("libil2cpp.so", "il2cpp_class_get_method_from_name"),
        "pointer", ["pointer", "pointer", "int"]);

    // 获取 domain
    var domain = il2cpp_domain_get();
    console.log("[*] Domain: " + domain);

    // 这种方法可以获取方法的 MethodInfo*
    // 从 MethodInfo 中读取 methodPointer 即可得到函数地址
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

// common_hook_patterns.js
// Unity 游戏 Hook 常用模式合集

"use strict";

var il2cpp = Module.findBaseAddress("libil2cpp.so");

// ==============================
// 模式 1: 替换方法返回值
// ==============================
// 让 IsVIP() 永远返回 true
function hookIsVIP(offset) {
    Interceptor.attach(il2cpp.add(offset), {
        onLeave: function(retval) {
            retval.replace(ptr(1));  // true
        }
    });
}

// ==============================
// 模式 2: NOP 掉整个方法
// ==============================
// 让 ShowAd() 什么都不做 (ARM64)
function nopMethod(offset) {
    // ARM64: RET = 0xD65F03C0
    Memory.protect(il2cpp.add(offset), 4, "rwx");
    il2cpp.add(offset).writeU32(0xD65F03C0);
}

// ==============================
// 模式 3: Hook 构造函数追踪实例
// ==============================
var playerInstances = [];
function trackPlayerInstances(ctorOffset) {
    Interceptor.attach(il2cpp.add(ctorOffset), {
        onEnter: function(args) {
            playerInstances.push(args[0]);
            console.log("[+] New Player instance: " + args[0] +
                       " (total: " + playerInstances.length + ")");
        }
    });
}

// ==============================
// 模式 4: Hook Update 做持续修改
// ==============================
// Unity 的 Update() 每帧调用一次
function hookUpdate(offset, hpOffset, maxHpOffset) {
    var count = 0;
    Interceptor.attach(il2cpp.add(offset), {
        onEnter: function(args) {
            var self = args[0];
            // 每帧将 HP 设置为最大值
            var maxHp = self.add(maxHpOffset).readFloat();
            self.add(hpOffset).writeFloat(maxHp);

            // 每 300 帧打印一次 (大约 5 秒)
            if (count++ % 300 === 0) {
                console.log("[*] HP maintained at: " + maxHp);
            }
        }
    });
}

// ==============================
// 模式 5: Hook 网络请求修改数据
// ==============================
function hookNetworkResponse(parseOffset) {
    Interceptor.attach(il2cpp.add(parseOffset), {
        onEnter: function(args) {
            // args[1] 通常是 JSON 字符串或 protobuf 数据
            // 需要根据具体游戏的协议来修改
            console.log("[*] Network response received");
        }
    });
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

┌─────────────────────────────────────────────────────┐
│               GameGuardian 工作原理                   │
├─────────────────────────────────────────────────────┤
│                                                     │
│  GameGuardian App (Root 权限)                        │
│       │                                             │
│       │ ptrace / /proc/<pid>/mem                    │
│       ▼                                             │
│  ┌─────────────────────────────────────┐            │
│  │        目标游戏进程内存空间            │            │
│  ├─────────────────────────────────────┤            │
│  │  代码段 (.text)  [r-x]              │            │
│  │  ├── libil2cpp.so                   │            │
│  │  └── libunity.so                    │            │
│  ├─────────────────────────────────────┤            │
│  │  数据段 (.data/.bss)  [rw-]         │            │
│  │  ├── 全局变量                        │            │
│  │  └── 静态字段                        │            │
│  ├─────────────────────────────────────┤            │
│  │  堆 (Heap)  [rw-]                   │            │
│  │  ├── 游戏对象实例  ◄── 搜索目标      │            │
│  │  │   ├── PlayerData.coin = 1000     │            │
│  │  │   ├── PlayerData.gem = 50        │            │
│  │  │   └── PlayerData.hp = 100.0      │            │
│  │  └── IL2CPP 管理的对象               │            │
│  ├─────────────────────────────────────┤            │
│  │  栈 (Stack)  [rw-]                  │            │
│  └─────────────────────────────────────┘            │
│                                                     │
│  搜索流程:                                           │
│  1. 搜索当前值 (如 coin=1000)                        │
│  2. 改变游戏中的值 (花掉一些 coin)                    │
│  3. 搜索新值 (如 coin=900)                           │
│  4. 重复缩小范围直到找到唯一地址                       │
│  5. 修改该地址的值                                    │
│                                                     │
└─────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

场景: 游戏中显示 金币 = 1500

GG 操作:
  1. 打开 GG 悬浮窗
  2. 选择目标进程 (游戏)
  3. 搜索 -> 输入 1500
  4. 类型选择: DWORD (4字节整数)
  5. 搜索范围: 全部 (或 C++ Heap)
  6. 结果: 找到 5000+ 个地址 (太多)

缩小范围:
  7. 回到游戏，花费 200 金币 (剩余 1300)
  8. GG -> 继续搜索 -> 输入 1300
  9. 结果: 3 个地址

  10. 再次花费 100 金币 (剩余 1200)
  11. GG -> 继续搜索 -> 输入 1200
  12. 结果: 1 个地址 -> 这就是 coin 的内存地址!

修改:
  13. 选中该地址 -> 修改值为 999999
  14. 可选: 冻结该地址 (防止游戏更新值)

1
2
3
4
5
6
7
8
9

场景: 游戏中 HP 显示为血条图形，不知道具体数值

GG 操作:
  1. 搜索 -> 未知值搜索
  2. 受到伤害后 -> 搜索 "减少的值"
  3. 吃血药后 -> 搜索 "增加的值"
  4. HP 未变化 -> 搜索 "未变化的值"
  5. 重复 3-5 次，缩小到几个地址
  6. 逐个修改测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

原理:
  Unity 游戏的 Time.deltaTime 依赖系统时钟
  加速器修改 clock_gettime / gettimeofday 的返回值
  使游戏认为时间流逝更快或更慢

效果:
  2x 加速 -> 游戏运行速度翻倍 (动画、移动、冷却都加速)
  0.5x 减速 -> 慢动作 (适用于需要精确操作的场景)

限制:
  - 服务端会检测客户端时间与服务器时间的差异
  - 许多游戏会检测 clock_gettime 是否被 Hook
  - Unity 的 Time.unscaledTime 可能不受影响

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

// memory_scanner.js
// 用 Frida 实现 GameGuardian 风格的内存搜索

"use strict";

var searchResults = [];

// 搜索指定整数值
function searchInt32(value) {
    searchResults = [];
    var pattern = intToHexPattern(value);
    var module = Process.findModuleByName("libil2cpp.so");

    // 在可写内存区域搜索 (堆、数据段)
    var ranges = Process.enumerateRanges("rw-");
    var total = 0;

    for (var i = 0; i < ranges.length; i++) {
        var range = ranges[i];
        if (range.size > 100 * 1024 * 1024) continue;  // 跳过超大区域

        try {
            var results = Memory.scanSync(range.base, range.size, pattern);
            for (var j = 0; j < results.length; j++) {
                searchResults.push(results[j].address);
                total++;
            }
        } catch(e) {}
    }

    console.log("[*] Found " + total + " addresses with value " + value);
    return total;
}

// 在已有结果中筛选
function refinSearch(newValue) {
    var pattern = intToHexPattern(newValue);
    var refined = [];

    for (var i = 0; i < searchResults.length; i++) {
        try {
            var current = searchResults[i].readS32();
            if (current === newValue) {
                refined.push(searchResults[i]);
            }
        } catch(e) {}
    }

    searchResults = refined;
    console.log("[*] Refined to " + refined.length + " addresses");

    if (refined.length <= 10) {
        for (var k = 0; k < refined.length; k++) {
            console.log("    [" + k + "] " + refined[k] +
                        " = " + refined[k].readS32());
        }
    }

    return refined.length;
}

// 修改指定索引的值
function modifyValue(index, newValue) {
    if (index < 0 || index >= searchResults.length) {
        console.log("[-] Invalid index");
        return;
    }
    var addr = searchResults[index];
    addr.writeS32(newValue);
    console.log("[+] " + addr + " set to " + newValue);
}

function intToHexPattern(value) {
    var buf = Memory.alloc(4);
    buf.writeS32(value);
    var bytes = buf.readByteArray(4);
    var arr = new Uint8Array(bytes);
    var hex = "";
    for (var i = 0; i < arr.length; i++) {
        hex += arr[i].toString(16).padStart(2, "0") + " ";
    }
    return hex.trim();
}

// 导出 RPC 接口供外部调用
rpc.exports = {
    search: searchInt32,
    refine: refinSearch,
    modify: modifyValue,
    count: function() { return searchResults.length; }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

┌─────────────────────────────────────────────────────────────────┐
│                    Unity 游戏反作弊体系                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────┐      │
│  │  客户端检测   │  │  服务端验证   │  │  第三方反作弊 SDK  │      │
│  ├──────────────┤  ├──────────────┤  ├──────────────────┤      │
│  │ 内存完整性    │  │ 数值合理性    │  │ ACE (腾讯)       │      │
│  │ 速度检测      │  │ 时间戳校验    │  │ NetEase 安全 SDK │      │
│  │ 代码校验      │  │ 行为分析      │  │ EasyAntiCheat   │      │
│  │ Hook 检测     │  │ 重放攻击防护  │  │ BattlEye        │      │
│  │ Root 检测     │  │ 服务端结算    │  │ GameGuard       │      │
│  │ 模拟器检测    │  │ 操作频率限制  │  │ 梆梆安全         │      │
│  └──────────────┘  └──────────────┘  └──────────────────┘      │
│                                                                 │
│  ┌──────────────────────────────────────────────────────┐      │
│  │                  混合防护策略                          │      │
│  │                                                      │      │
│  │  客户端: 提高作弊门槛、检测异常环境                     │      │
│  │  服务端: 最终仲裁者、验证所有关键操作                   │      │
│  │  行为分析: 大数据识别异常玩家                          │      │
│  │                                                      │      │
│  └──────────────────────────────────────────────────────┘      │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

客户端-服务端交互模型:

  ┌──────────┐                        ┌──────────┐
  │  客户端   │  ---购买请求(商品ID)--->  │  服务器   │
  │          │                        │          │
  │          │  <---扣款结果(新余额)---  │  验证:    │
  │  显示结果 │                        │  1. 余额够?│
  │          │                        │  2. 商品存在?│
  └──────────┘                        │  3. 价格对?│
                                      └──────────┘

  修改客户端 coin 显示 = 无效 (服务器不认)
  修改客户端购买请求中的价格 = 可能有效 (如果服务器不校验)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 分析服务端验证: Hook 网络请求
// 检查哪些操作是服务端验证的、哪些是纯客户端的

Il2Cpp.perform(() => {
    const NetworkManager = Il2Cpp.domain
        .assembly("Assembly-CSharp").image
        .class("Network.NetworkManager");

    // Hook 发送请求方法
    NetworkManager.method("SendRequest").implementation = function(url, data) {
        console.log("[NET] Request: " + url);
        console.log("      Data: " + data);
        // 分析: 如果某个操作不发送网络请求，说明是纯客户端逻辑
        this.method("SendRequest").invoke(url, data);
    };

    // Hook 接收响应方法
    NetworkManager.method("OnResponse").implementation = function(response) {
        console.log("[NET] Response: " + response);
        this.method("OnResponse").invoke(response);
    };
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 典型的内存完整性检测 (伪代码)
void IntegrityCheck() {
    // 方式 1: CRC 校验关键代码段
    uint32_t crc = CalculateCRC32(codeStart, codeSize);
    if (crc != expectedCRC) {
        // 代码被篡改!
        ReportCheat();
        exit(0);
    }

    // 方式 2: 关键值哨兵
    // 在 coin 值旁边存储一个校验值
    if (coin != (coinChecksum ^ MAGIC_KEY)) {
        // coin 被外部修改!
        ReportCheat();
    }

    // 方式 3: 多副本对比
    // 同一个值存储在多个位置，定期对比
    if (coin_copy1 != coin_copy2 || coin_copy2 != coin_copy3) {
        ReportCheat();
    }
}