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

┌─────────────────────────────────────────────────────────────────────┐
│                    社交 App 安全防护架构                              │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  客户端层                                                            │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐                 │
│  │  环境检测   │  │  设备指纹   │  │  请求签名   │                 │
│  │ Root/Frida  │  │  采集上报   │  │  算法生成   │                 │
│  │ 模拟器检测  │  │  唯一标识   │  │  参数加密   │                 │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘                 │
│         │                │                │                         │
│  ┌──────┴────────────────┴────────────────┴──────┐                 │
│  │              Native SO 安全核心                │                 │
│  │     (OLLVM / VMP / 自定义虚拟机保护)           │                 │
│  └───────────────────────┬───────────────────────┘                 │
│                          │                                          │
│  ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─   │
│                          │                                          │
│  服务端层                │                                          │
│  ┌─────────────┐  ┌─────┴───────┐  ┌─────────────┐                │
│  │  签名验证   │  │  风控引擎   │  │  行为分析   │                │
│  │  时效校验   │  │  规则匹配   │  │  异常检测   │                │
│  │  防重放     │  │  设备画像   │  │  机器学习   │                │
│  └─────────────┘  └─────────────┘  └─────────────┘                │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

 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

// monitor_fingerprint.js - 监控设备指纹采集行为
Java.perform(function () {
    // 1. 监控 Build 类的字段访问（最常见的指纹来源）
    var Build = Java.use("android.os.Build");
    var fields = ["MODEL", "MANUFACTURER", "BRAND", "DEVICE",
                  "PRODUCT", "HARDWARE", "BOARD", "FINGERPRINT"];

    fields.forEach(function (field) {
        // Build 类的字段是 static final，无法直接 Hook
        // 但可以通过 Hook 使用它们的代码间接发现
        console.log("[Build] " + field + " = " + Build[field].value);
    });

    // 2. 监控 Settings.Secure（获取 Android ID 等）
    var Secure = Java.use("android.provider.Settings$Secure");
    Secure.getString.overload(
        "android.content.ContentResolver", "java.lang.String"
    ).implementation = function (resolver, name) {
        var result = this.getString(resolver, name);
        if (name === "android_id" || name === "bluetooth_address") {
            console.log("[Settings.Secure] " + name + " = " + result);
            printStack();
        }
        return result;
    };

    // 3. 监控 TelephonyManager（获取 IMEI、IMSI 等）
    var TelephonyManager = Java.use("android.telephony.TelephonyManager");
    TelephonyManager.getDeviceId.overload().implementation = function () {
        var result = this.getDeviceId();
        console.log("[TelephonyManager] getDeviceId = " + result);
        printStack();
        return result;
    };

    // 4. 监控 WifiManager（获取 MAC 地址）
    var WifiInfo = Java.use("android.net.wifi.WifiInfo");
    WifiInfo.getMacAddress.implementation = function () {
        var result = this.getMacAddress();
        console.log("[WifiInfo] getMacAddress = " + result);
        printStack();
        return result;
    };

    // 5. 监控 SensorManager（传感器列表常用于模拟器检测）
    var SensorManager = Java.use("android.hardware.SensorManager");
    SensorManager.getSensorList.implementation = function (type) {
        var result = this.getSensorList(type);
        console.log("[SensorManager] getSensorList type=" + type
                    + " count=" + result.size());
        return result;
    };

    // 6. 监控文件读取（/proc/cpuinfo, /sys/ 等）
    var FileInputStream = Java.use("java.io.FileInputStream");
    FileInputStream.$init.overload("java.lang.String").implementation =
        function (path) {
            if (path.indexOf("/proc/") !== -1 ||
                path.indexOf("/sys/") !== -1) {
                console.log("[FileRead] " + path);
            }
            return this.$init(path);
        };

    function printStack() {
        console.log(Java.use("android.util.Log").getStackTraceString(
            Java.use("java.lang.Exception").$new()
        ));
    }
});

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

┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│  采集原始数据 │───>│  数据规范化   │───>│  哈希计算     │
│  Build 信息   │    │  去除空值     │    │  MD5/SHA256  │
│  Android ID   │    │  统一编码     │    │  生成 device │
│  MAC/IMEI     │    │  排序拼接     │    │  _id         │
│  传感器列表   │    │              │    │              │
└──────────────┘    └──────────────┘    └──────┬───────┘
                                               │
                                        ┌──────┴───────┐
                                        │  加密上报     │
                                        │  存入本地     │
                                        │  SharedPrefs  │
                                        └──────────────┘

 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

// fake_device.js - 伪造设备指纹
Java.perform(function () {
    // 修改 Build 类的静态字段
    var Build = Java.use("android.os.Build");
    Build.MODEL.value = "Pixel 7 Pro";
    Build.MANUFACTURER.value = "Google";
    Build.BRAND.value = "google";
    Build.PRODUCT.value = "cheetah";
    Build.DEVICE.value = "cheetah";
    Build.HARDWARE.value = "tensor";
    Build.FINGERPRINT.value =
        "google/cheetah/cheetah:14/AP2A.240305.019.A1/" +
        "11373996:user/release-keys";

    // 修改 Build.VERSION 相关
    var Version = Java.use("android.os.Build$VERSION");
    Version.SDK_INT.value = 34;
    Version.RELEASE.value = "14";

    // 伪造 Android ID
    var Secure = Java.use("android.provider.Settings$Secure");
    Secure.getString.overload(
        "android.content.ContentResolver", "java.lang.String"
    ).implementation = function (resolver, name) {
        if (name === "android_id") {
            return generateRandomHex(16);
        }
        return this.getString(resolver, name);
    };

    function generateRandomHex(length) {
        var chars = "0123456789abcdef";
        var result = "";
        for (var i = 0; i < length; i++) {
            result += chars.charAt(Math.floor(Math.random() * 16));
        }
        return result;
    }
});

1
2
3
4
5

X-Gorgon:  0404b0d20000e3c70e15e5b91a7c9f35c7828beb8bc99b056770
X-Khronos: 1709123456
X-Argus:   vFYJBRsBIgoIa0MVF18yKC8HAQovHgkhCgRgJxUu...（Base64 编码）
X-Ladon:   z/5OBQACDwIOCQ0LBw...（Base64 编码）
X-Tyhon:   （较新版本出现的参数）

 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

┌───────────────────────────────────────────────────┐
│                 签名生成流程                        │
│                                                    │
│  1. 收集输入                                       │
│  ┌──────────────────────────────────────────────┐  │
│  │  URL Path + Query String (排序后)             │  │
│  │  POST Body (如果有)                           │  │
│  │  Cookie 值                                    │  │
│  │  当前时间戳                                   │  │
│  └──────────────────┬───────────────────────────┘  │
│                     │                               │
│  2. 预处理          ▼                               │
│  ┌──────────────────────────────────────────────┐  │
│  │  对各输入分别计算 MD5                          │  │
│  │  url_md5  = MD5(sorted_query_string)          │  │
│  │  body_md5 = MD5(post_body)                    │  │
│  │  cookie_md5 = MD5(cookie_str)                 │  │
│  └──────────────────┬───────────────────────────┘  │
│                     │                               │
│  3. 组装输入        ▼                               │
│  ┌──────────────────────────────────────────────┐  │
│  │  合并为固定格式的字节数组:                      │  │
│  │  [magic_bytes][timestamp][url_md5]            │  │
│  │  [body_md5][cookie_md5][session_key]          │  │
│  └──────────────────┬───────────────────────────┘  │
│                     │                               │
│  4. Native 加密     ▼                               │
│  ┌──────────────────────────────────────────────┐  │
│  │  调用 SO 中的核心签名函数                      │  │
│  │  多轮异或 + 查表 + 自定义变换                  │  │
│  │  生成最终签名字节                              │  │
│  └──────────────────┬───────────────────────────┘  │
│                     │                               │
│  5. 输出            ▼                               │
│  ┌──────────────────────────────────────────────┐  │
│  │  X-Gorgon = hex(签名字节)                     │  │
│  │  X-Khronos = timestamp                        │  │
│  └──────────────────────────────────────────────┘  │
└───────────────────────────────────────────────────┘

 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

// hook_jni_sign.js - Hook JNI 签名函数，获取输入输出
Java.perform(function () {
    // 方法 1: 从 Java 层 Hook
    var NativeHelper = Java.use("com.example.app.NativeHelper");
    NativeHelper.generateSign.implementation = function (input) {
        console.log("=== generateSign called ===");
        console.log("Input (hex): " + bytesToHex(input));
        console.log("Input (utf8): " + bytesToString(input));

        var result = this.generateSign(input);

        console.log("Output (hex): " + bytesToHex(result));
        return result;
    };

    // 方法 2: 直接 Hook SO 中的函数地址
    var baseAddr = Module.findBaseAddress("libsecurity.so");
    if (baseAddr) {
        // 假设通过 IDA 分析已知偏移为 0x12340
        var signFunc = baseAddr.add(0x12340);
        Interceptor.attach(signFunc, {
            onEnter: function (args) {
                console.log("=== Native sign function ===");
                // arg0 通常是 JNIEnv*
                // arg1 通常是 jclass 或 jobject
                // arg2 开始是实际参数
                this.inputPtr = args[2];
                this.inputLen = args[3].toInt32();
                console.log("Input buffer: " +
                    hexdump(this.inputPtr, {
                        length: this.inputLen
                    }));
            },
            onLeave: function (retval) {
                console.log("Return value: " + retval);
            }
        });
    }

    function bytesToHex(bytes) {
        var hex = [];
        for (var i = 0; i < bytes.length; i++) {
            hex.push(("0" + (bytes[i] & 0xff).toString(16)).slice(-2));
        }
        return hex.join("");
    }

    function bytesToString(bytes) {
        var result = "";
        for (var i = 0; i < bytes.length; i++) {
            result += String.fromCharCode(bytes[i] & 0xff);
        }
        return result;
    }
});

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

┌────────────────────────────────────────────────────────────────┐
│                    服务端风控引擎                                │
├────────────────────────────────────────────────────────────────┤
│                                                                │
│  实时检测层                                                     │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐  │
│  │ 频率限制   │ │ 签名验证   │ │ 时效检查   │ │ 重放检测   │  │
│  │ Rate Limit │ │ Sign Check │ │ Timestamp  │ │ Nonce      │  │
│  └────────────┘ └────────────┘ └────────────┘ └────────────┘  │
│                                                                │
│  行为分析层                                                     │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐  │
│  │ 访问模式   │ │ 操作序列   │ │ 时间分布   │ │ 内容偏好   │  │
│  │ Pattern    │ │ Sequence   │ │ TimeGap    │ │ Interest   │  │
│  └────────────┘ └────────────┘ └────────────┘ └────────────┘  │
│                                                                │
│  设备画像层                                                     │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐  │
│  │ 设备信誉   │ │ IP 信誉    │ │ 账号画像   │ │ 关联分析   │  │
│  │ DeviceRisk │ │ IPRisk     │ │ AccountAge │ │ Graph      │  │
│  └────────────┘ └────────────┘ └────────────┘ └────────────┘  │
│                                                                │
└────────────────────────────────────────────────────────────────┘

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

# 频率限制的典型表现和应对
"""
常见的频率限制策略：

1. 固定窗口限制:
   - 每个 device_id 每分钟最多 30 次请求
   - 超出后返回 429 或空数据

2. 滑动窗口限制:
   - 统计最近 60 秒内的请求数
   - 动态调整限制阈值

3. 令牌桶策略:
   - 每秒恢复 N 个令牌
   - 允许突发但限制持续高频

4. 渐进式惩罚:
   - 第 1 次超限: 降低数据质量（返回部分字段）
   - 第 2 次超限: 触发验证码
   - 第 3 次超限: 临时封禁 device_id
   - 持续违规:  永久封禁 + 关联封禁
"""

 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

// identify_risk_sdk.js - 识别风控 SDK
Java.perform(function () {
    // 列出加载的所有 SO 文件
    Process.enumerateModules({
        onMatch: function (module) {
            var name = module.name.toLowerCase();
            // 常见风控 SDK 的 SO 文件特征
            var riskSdks = {
                "libmsaoaidsec": "阿里系风控 (EMAS)",
                "libsecuritybodybridge": "字节系风控",
                "libtnet": "阿里网络安全库",
                "libsgmain": "阿里安全组件",
                "libBugly": "腾讯 Bugly",
                "libwbsafeedit": "微博安全",
                "libDexHelper": "风控辅助",
            };

            for (var key in riskSdks) {
                if (name.indexOf(key.toLowerCase()) !== -1) {
                    console.log("[Risk SDK] " + riskSdks[key]
                                + " -> " + module.name
                                + " @ " + module.base);
                }
            }
        },
        onComplete: function () {
            console.log("[*] Module scan complete.");
        }
    });

    // 列出与风控相关的 Java 类
    Java.enumerateLoadedClasses({
        onMatch: function (className) {
            var patterns = [
                "com.bytedance.frameworks.encryptor",
                "com.ss.android.deviceregister",
                "com.alibaba.wireless.security",
                "com.tencent.tp.",
                "com.netease.nis.sdkwrapper",
            ];
            for (var i = 0; i < patterns.length; i++) {
                if (className.indexOf(patterns[i]) === 0) {
                    console.log("[Risk Class] " + className);
                    break;
                }
            }
        },
        onComplete: function () {}
    });
});

  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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

// hook_full_sign.js - 完整的签名 Hook 框架
Java.perform(function () {
    console.log("[*] Starting full signature hook...");

    // ====== 第 1 层: Hook OkHttp 请求构建 ======
    try {
        var OkHttpClient = Java.use("okhttp3.OkHttpClient");
        var Request = Java.use("okhttp3.Request");
        var RequestBuilder = Java.use("okhttp3.Request$Builder");
        var RequestBody = Java.use("okhttp3.RequestBody");
        var Buffer = Java.use("okio.Buffer");

        // 拦截最终发出的请求
        RequestBuilder.build.implementation = function () {
            var request = this.build();
            var url = request.url().toString();
            var method = request.method();
            var headers = request.headers();

            console.log("\n========== Request ==========");
            console.log("[URL] " + method + " " + url);

            // 打印所有自定义头
            for (var i = 0; i < headers.size(); i++) {
                var name = headers.name(i);
                if (name.indexOf("X-") === 0 ||
                    name.indexOf("x-") === 0) {
                    console.log("[Header] " + name + ": "
                                + headers.value(i));
                }
            }

            // 打印请求体
            var body = request.body();
            if (body !== null) {
                var buffer = Buffer.$new();
                body.writeTo(buffer);
                var bodyStr = buffer.readUtf8();
                if (bodyStr.length < 2000) {
                    console.log("[Body] " + bodyStr);
                } else {
                    console.log("[Body] (length=" + bodyStr.length
                                + ") " + bodyStr.substring(0, 200)
                                + "...");
                }
            }
            console.log("==============================\n");
            return request;
        };
    } catch (e) {
        console.log("[-] OkHttp hook failed: " + e);
    }

    // ====== 第 2 层: Hook 签名生成函数 ======
    // 需要根据实际 App 调整类名和方法名
    try {
        var SignHelper = Java.use("com.example.app.security.SignHelper");

        // Hook 主签名方法
        SignHelper.getSign.overload(
            "java.util.Map", "java.lang.String"
        ).implementation = function (params, body) {
            console.log("\n===== SignHelper.getSign =====");

            // 打印参与签名的所有参数
            var iterator = params.entrySet().iterator();
            while (iterator.hasNext()) {
                var entry = iterator.next();
                console.log("  " + entry.getKey() + " = "
                            + entry.getValue());
            }

            if (body !== null) {
                console.log("[Body for sign] "
                            + body.substring(0, 200));
            }

            var result = this.getSign(params, body);
            console.log("[Sign Result] " + result);
            console.log("==============================\n");
            return result;
        };
    } catch (e) {
        console.log("[-] SignHelper hook failed: " + e);
    }

    // ====== 第 3 层: Hook Native 层 ======
    var soName = "libsecurity.so";
    var baseAddr = Module.findBaseAddress(soName);
    if (baseAddr) {
        console.log("[+] " + soName + " base: " + baseAddr);

        // Hook JNI_OnLoad 查看初始化逻辑
        var jniOnLoad = Module.findExportByName(
            soName, "JNI_OnLoad"
        );
        if (jniOnLoad) {
            Interceptor.attach(jniOnLoad, {
                onEnter: function (args) {
                    console.log("[+] JNI_OnLoad called");
                },
                onLeave: function (retval) {
                    console.log("[+] JNI_OnLoad returned: "
                                + retval);
                }
            });
        }

        // Hook 导出的签名函数
        var exports = Module.enumerateExports(soName);
        exports.forEach(function (exp) {
            if (exp.name.indexOf("sign") !== -1 ||
                exp.name.indexOf("Sign") !== -1 ||
                exp.name.indexOf("encrypt") !== -1) {
                console.log("[Export] " + exp.name
                            + " @ " + exp.address);
            }
        });
    }
});

  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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

#!/usr/bin/env python3
"""
sign_replay.py - 配合 Frida Hook 数据复现签名算法

使用方式:
1. 先用 Frida Hook 脚本收集签名的输入输出样本
2. 根据收集到的数据分析签名逻辑
3. 用本脚本复现签名并验证
"""
import hashlib
import hmac
import struct
import time
import requests


class SignGenerator:
    """签名生成器 - 根据逆向结果实现"""

    def __init__(self, device_id, install_id, session_key=None):
        self.device_id = device_id
        self.install_id = install_id
        self.session_key = session_key or b""

    def generate_sign(self, url_path, query_params, body=None,
                      cookies=None):
        """
        生成 API 请求签名

        参数:
            url_path: 请求路径，如 "/api/v2/feed"
            query_params: dict, URL 查询参数
            body: bytes, POST 请求体（可选）
            cookies: str, Cookie 字符串（可选）

        返回:
            dict, 包含 X-Gorgon 和 X-Khronos
        """
        timestamp = int(time.time())

        # 第 1 步: 对查询参数排序并拼接
        sorted_params = sorted(query_params.items())
        query_string = "&".join(
            f"{k}={v}" for k, v in sorted_params
        )

        # 第 2 步: 分别计算 MD5
        url_md5 = hashlib.md5(
            query_string.encode()
        ).digest()

        body_md5 = hashlib.md5(
            body if body else b""
        ).digest()

        cookie_md5 = hashlib.md5(
            cookies.encode() if cookies else b""
        ).digest()

        # 第 3 步: 组装签名输入
        sign_input = bytearray()
        # magic header (4 bytes)
        sign_input.extend(b"\x04\x04")
        sign_input.extend(struct.pack("<H", 0))
        # timestamp (4 bytes, little-endian)
        sign_input.extend(struct.pack("<I", timestamp))
        # url md5, body md5, cookie md5 (各 16 bytes)
        sign_input.extend(url_md5)
        sign_input.extend(body_md5)
        sign_input.extend(cookie_md5)
        # session key
        sign_input.extend(self.session_key)

        # 第 4 步: 核心签名计算
        # （此处为简化示例，实际算法需根据逆向结果实现）
        signature = self._core_sign(bytes(sign_input))

        return {
            "X-Gorgon": signature.hex(),
            "X-Khronos": str(timestamp),
        }

    def _core_sign(self, data):
        """
        核心签名算法 - 需要根据 SO 逆向结果实现
        这里仅展示框架，实际算法会更复杂
        """
        # 示例: 多轮异或 + 查表
        # 实际需要从 SO 中提取 S-Box 和变换逻辑
        s_box = self._get_s_box()
        result = bytearray(20)
        for i in range(len(data)):
            result[i % 20] ^= s_box[data[i]]
        return bytes(result)

    @staticmethod
    def _get_s_box():
        """从 SO 中提取的 S-Box 查找表（256 字节）"""
        # 实际值需要从 Frida dump 或 IDA 分析中获取
        return bytes(range(256))


def make_api_request(sign_gen, endpoint, params, body=None):
    """发起带签名的 API 请求"""
    base_url = "https://api.example.com"

    # 添加设备参数
    params.update({
        "device_id": sign_gen.device_id,
        "iid": sign_gen.install_id,
        "os_version": "14",
        "device_type": "Pixel 7 Pro",
    })

    # 生成签名
    headers = sign_gen.generate_sign(
        endpoint, params, body
    )
    headers["User-Agent"] = (
        "com.example.app/30.0.0 "
        "(Linux; U; Android 14; zh_CN; Pixel 7 Pro; "
        "Build/AP2A.240305.019)"
    )

    # 发起请求
    url = f"{base_url}{endpoint}"
    if body:
        resp = requests.post(
            url, params=params, data=body, headers=headers
        )
    else:
        resp = requests.get(url, params=params, headers=headers)

    return resp.json()


# 使用示例
if __name__ == "__main__":
    signer = SignGenerator(
        device_id="7012345678901234567",
        install_id="7098765432109876543",
    )

    result = make_api_request(
        signer,
        "/api/v2/feed",
        {"count": "20", "cursor": "0"},
    )
    print(result)

 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

// bypass_device_check.js - 绕过设备合法性检查
Java.perform(function () {
    // 1. 绕过 Google Play Services 检查
    try {
        var GoogleApiAvailability = Java.use(
            "com.google.android.gms.common.GoogleApiAvailability"
        );
        GoogleApiAvailability.isGooglePlayServicesAvailable
            .implementation = function (context) {
                console.log("[*] Bypassing Google Play check");
                return 0; // SUCCESS
            };
    } catch (e) {}

    // 2. 绕过 SafetyNet/Play Integrity 检测
    try {
        var SafetyNet = Java.use(
            "com.google.android.gms.safetynet.SafetyNetClient"
        );
        SafetyNet.attest.implementation = function (nonce, apiKey) {
            console.log("[*] SafetyNet attest intercepted");
            // 返回预先构造的合法 response
            return this.attest(nonce, apiKey);
        };
    } catch (e) {}

    // 3. 绕过设备注册校验
    //    许多 App 在首次启动时会向服务器注册设备
    //    返回一个 device_token，后续请求需要携带
    try {
        var DeviceRegister = Java.use(
            "com.example.app.device.DeviceRegister"
        );
        DeviceRegister.register.implementation = function () {
            console.log("[*] Device registration intercepted");
            var result = this.register();
            console.log("[*] device_token: " + result);
            return result;
        };
    } catch (e) {}

    // 4. 伪造设备注册响应
    //    如果服务器拒绝注册（检测到异常设备），可以直接
    //    Hook 返回值，注入一个预先获取的合法 token
    try {
        var SharedPrefs = Java.use(
            "android.app.SharedPreferencesImpl$EditorImpl"
        );
        SharedPrefs.putString.implementation = function (key, value) {
            if (key === "device_token" || key === "install_id") {
                console.log("[SharedPrefs] " + key + " = " + value);
            }
            return this.putString(key, value);
        };
    } catch (e) {}
});

 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

// bypass_root.js - Root 检测绕过
Java.perform(function () {
    // 方法 1: Hook 文件存在性检查
    var File = Java.use("java.io.File");
    File.exists.implementation = function () {
        var path = this.getAbsolutePath();
        var blacklist = [
            "/system/bin/su",
            "/system/xbin/su",
            "/sbin/su",
            "/su/bin/su",
            "/data/local/su",
            "/data/local/bin/su",
            "/system/app/Superuser.apk",
            "/system/app/SuperSU",
            "/system/app/Magisk",
            "/data/adb/magisk",
        ];
        for (var i = 0; i < blacklist.length; i++) {
            if (path === blacklist[i]) {
                console.log("[Root] Hiding: " + path);
                return false;
            }
        }
        return this.exists();
    };

    // 方法 2: Hook Runtime.exec（检测 su 命令是否可执行）
    var Runtime = Java.use("java.lang.Runtime");
    Runtime.exec.overload("java.lang.String").implementation =
        function (cmd) {
            if (cmd.indexOf("su") !== -1 ||
                cmd.indexOf("which") !== -1) {
                console.log("[Root] Blocking exec: " + cmd);
                throw Java.use("java.io.IOException")
                    .$new("Permission denied");
            }
            return this.exec(cmd);
        };

    // 方法 3: Hook System.getProperty
    var System = Java.use("java.lang.System");
    System.getProperty.overload("java.lang.String").implementation =
        function (key) {
            if (key === "ro.build.tags") {
                return "release-keys"; // 隐藏 test-keys 标志
            }
            return this.getProperty(key);
        };

    // 方法 4: Hook PackageManager（隐藏 Magisk 等 App）
    var PM = Java.use(
        "android.app.ApplicationPackageManager"
    );
    PM.getInstalledPackages.implementation = function (flags) {
        var packages = this.getInstalledPackages(flags);
        var hideList = [
            "com.topjohnwu.magisk",
            "eu.chainfire.supersu",
            "com.koushikdutta.superuser",
            "com.noshufou.android.su",
            "com.thirdparty.superuser",
        ];
        var iterator = packages.iterator();
        while (iterator.hasNext()) {
            var pkg = iterator.next();
            var pkgName = pkg.packageName.value;
            for (var i = 0; i < hideList.length; i++) {
                if (pkgName === hideList[i]) {
                    console.log("[Root] Hiding package: "
                                + pkgName);
                    iterator.remove();
                    break;
                }
            }
        }
        return packages;
    };

    console.log("[+] Root detection bypass loaded.");
});

 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

// bypass_frida_detect.js - Frida 反检测
// 注意: 需要在 App 的反检测代码执行之前加载

// 1. Hook libc 的 open 函数，过滤 /proc/self/maps 中的 frida 痕迹
Interceptor.attach(Module.findExportByName("libc.so", "open"), {
    onEnter: function (args) {
        var path = args[0].readUtf8String();
        this.isMaps = (path && path.indexOf("/proc/") !== -1 &&
                       path.indexOf("/maps") !== -1);
    },
    onLeave: function (retval) {
        if (this.isMaps) {
            // 这里不直接修改 open 的返回值
            // 而是后续 Hook read 来过滤内容
        }
    }
});

// 2. Hook strstr，防止检测 frida 关键字
Interceptor.attach(Module.findExportByName("libc.so", "strstr"), {
    onEnter: function (args) {
        this.haystack = args[0];
        this.needle = args[1].readUtf8String();
    },
    onLeave: function (retval) {
        if (this.needle !== null) {
            var keywords = [
                "frida", "FRIDA", "gum-js-loop",
                "gmain", "gdbus", "linjector"
            ];
            for (var i = 0; i < keywords.length; i++) {
                if (this.needle.indexOf(keywords[i]) !== -1) {
                    retval.replace(ptr(0));
                    break;
                }
            }
        }
    }
});

// 3. Hook pthread_create，过滤 frida 相关线程
Interceptor.attach(
    Module.findExportByName("libc.so", "pthread_create"),
    {
        onEnter: function (args) {
            // args[2] 是线程函数地址
            // 某些检测会创建专门的检测线程
        },
        onLeave: function (retval) {}
    }
);

// 4. 修改 Frida 默认端口
// 在启动时使用: frida -H 0.0.0.0:8888
// 或者: frida-server -l 0.0.0.0:12345

console.log("[+] Frida anti-detection bypass loaded.");

 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

// bypass_emulator.js - 模拟器检测绕过
Java.perform(function () {
    // 1. 修改可疑的系统属性
    var SystemProperties = Java.use("android.os.SystemProperties");
    SystemProperties.get.overload(
        "java.lang.String", "java.lang.String"
    ).implementation = function (key, def) {
        var fakeProps = {
            "ro.hardware": "cheetah",
            "ro.product.model": "Pixel 7 Pro",
            "ro.kernel.qemu": "0",
            "ro.boot.qemu": "0",
            "ro.hardware.chipname": "tensor",
            "gsm.version.baseband": "g5300q-230913-231003-B-11397125",
            "init.svc.qemu-props": "",
            "init.svc.qemud": "",
        };
        if (key in fakeProps) {
            console.log("[Emu] Faking prop: " + key);
            return fakeProps[key];
        }
        return this.get(key, def);
    };

    // 2. 隐藏模拟器特征文件
    var File = Java.use("java.io.File");
    var origExists = File.exists;
    File.exists.implementation = function () {
        var path = this.getAbsolutePath();
        var emuFiles = [
            "/dev/socket/qemud",
            "/dev/qemu_pipe",
            "/system/bin/nox-prop",
            "/system/bin/microvirtd",
            "/system/bin/nox",
            "/system/lib/libc_malloc_debug_qemu.so",
            "/dev/goldfish_pipe",
        ];
        for (var i = 0; i < emuFiles.length; i++) {
            if (path === emuFiles[i]) {
                console.log("[Emu] Hiding file: " + path);
                return false;
            }
        }
        return origExists.call(this);
    };

    // 3. 伪造传感器数据（模拟器通常缺少真实传感器）
    var SensorManager = Java.use("android.hardware.SensorManager");
    SensorManager.getSensorList.implementation = function (type) {
        var list = this.getSensorList(type);
        // 模拟器通常传感器数量极少
        // 如果传感器数量不足，风控会标记为可疑
        console.log("[Emu] getSensorList type=" + type
                    + " count=" + list.size());
        return list;
    };

    // 4. 伪造电池信息（模拟器电池状态固定）
    var BatteryManager = Java.use("android.os.BatteryManager");
    BatteryManager.getIntProperty.implementation = function (id) {
        if (id === 4) { // BATTERY_PROPERTY_CAPACITY
            return 73; // 返回一个看起来真实的电量
        }
        return this.getIntProperty(id);
    };

    console.log("[+] Emulator detection bypass loaded.");
});

 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

// anti_detect_framework.js - 综合反检测框架
// 启动命令: frida -U -f com.target.app -l anti_detect_framework.js
//           --no-pause -o output.log

var config = {
    hideRoot: true,
    hideFrida: true,
    hideEmulator: true,
    fakeDevice: true,
    logLevel: "info",  // "debug" | "info" | "warn"
};

function log(level, tag, msg) {
    var levels = { debug: 0, info: 1, warn: 2 };
    if (levels[level] >= levels[config.logLevel]) {
        console.log("[" + level.toUpperCase() + "][" + tag + "] "
                    + msg);
    }
}

// 按顺序加载各模块
if (config.hideFrida) {
    // 最先加载 - 必须在 App 检测代码运行前
    log("info", "Init", "Loading Frida bypass...");
    // ... (加载 bypass_frida_detect.js 的内容)
}

if (config.hideRoot) {
    log("info", "Init", "Loading Root bypass...");
    // ... (加载 bypass_root.js 的内容)
}

if (config.hideEmulator) {
    log("info", "Init", "Loading Emulator bypass...");
    // ... (加载 bypass_emulator.js 的内容)
}

if (config.fakeDevice) {
    log("info", "Init", "Loading device spoofing...");
    // ... (加载 fake_device.js 的内容)
}

log("info", "Init", "Anti-detection framework loaded.");

 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

┌────────────────────────────────────────────────────────────────────┐
│                    数据采集系统架构                                  │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│  任务调度层                                                         │
│  ┌──────────────────────────────────────────────────────────┐      │
│  │  Redis / RabbitMQ 任务队列                                │      │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐               │      │
│  │  │ 用户列表  │  │ 帖子列表  │  │ 评论列表  │               │      │
│  │  │ 采集任务  │  │ 采集任务  │  │ 采集任务  │               │      │
│  │  └──────────┘  └──────────┘  └──────────┘               │      │
│  └──────────────────────┬──────────────────────────────────┘      │
│                         │                                          │
│  执行引擎层             ▼                                          │
│  ┌──────────────────────────────────────────────────────────┐      │
│  │  Worker 集群 (Python / Go)                                │      │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐               │      │
│  │  │ Worker 1 │  │ Worker 2 │  │ Worker N │               │      │
│  │  │ 签名模块 │  │ 签名模块 │  │ 签名模块 │               │      │
│  │  │ 账号池   │  │ 账号池   │  │ 账号池   │               │      │
│  │  └─────┬────┘  └─────┬────┘  └─────┬────┘               │      │
│  └────────┼─────────────┼─────────────┼────────────────────┘      │
│           │             │             │                            │
│  代理层   ▼             ▼             ▼                            │
│  ┌──────────────────────────────────────────────────────────┐      │
│  │  代理池管理器                                             │      │
│  │  住宅代理 / 机房代理 / 4G 代理                            │      │
│  │  自动轮换 / 健康检查 / 地域分配                            │      │
│  └──────────────────────┬──────────────────────────────────┘      │
│                         │                                          │
│  存储层                 ▼                                          │
│  ┌──────────────────────────────────────────────────────────┐      │
│  │  MongoDB / PostgreSQL + S3 / MinIO                        │      │
│  │  结构化数据 + 媒体文件存储                                 │      │
│  └──────────────────────────────────────────────────────────┘      │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

  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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#!/usr/bin/env python3
"""
sign_server.py - 签名服务 (基于 Flask)

两种模式:
1. 纯 Python 复现模式 - 适用于已完全逆向的简单算法
2. RPC 桥接模式 - 通过 Frida RPC 调用真机上的签名函数
"""
from flask import Flask, request, jsonify
import frida
import json
import threading
import time

app = Flask(__name__)


class FridaSignBridge:
    """通过 Frida RPC 调用真机签名函数"""

    def __init__(self, device_id=None, package_name=None):
        self.package_name = package_name or "com.target.app"
        self.device = None
        self.session = None
        self.script = None
        self.rpc = None
        self.lock = threading.Lock()
        self._connect(device_id)

    def _connect(self, device_id):
        """连接到 Frida 设备"""
        if device_id:
            self.device = frida.get_device(device_id)
        else:
            self.device = frida.get_usb_device()

        self.session = self.device.attach(self.package_name)

        # 注入签名导出脚本
        js_code = """
        rpc.exports = {
            sign: function(url, params, body) {
                // 调用 App 内部的签名函数
                var result = {};
                Java.perform(function() {
                    var SignHelper = Java.use(
                        "com.target.app.security.SignHelper"
                    );
                    var HashMap = Java.use("java.util.HashMap");
                    var map = HashMap.$new();

                    var paramObj = JSON.parse(params);
                    for (var key in paramObj) {
                        map.put(key, paramObj[key]);
                    }

                    var signResult = SignHelper.getSign(map, body);
                    result = JSON.parse(signResult.toString());
                });
                return result;
            },

            getDeviceInfo: function() {
                var info = {};
                Java.perform(function() {
                    var Build = Java.use("android.os.Build");
                    info.model = Build.MODEL.value;
                    info.brand = Build.BRAND.value;
                    info.device = Build.DEVICE.value;
                });
                return info;
            }
        };
        """
        self.script = self.session.create_script(js_code)
        self.script.load()
        self.rpc = self.script.exports_sync

    def get_sign(self, url, params, body=""):
        """线程安全地获取签名"""
        with self.lock:
            return self.rpc.sign(
                url, json.dumps(params), body
            )


# 初始化签名桥接
bridge = None


@app.route("/sign", methods=["POST"])
def generate_sign():
    """
    签名接口

    请求体:
    {
        "url": "/api/v2/feed",
        "params": {"count": "20", "cursor": "0"},
        "body": ""
    }
    """
    data = request.json
    try:
        result = bridge.get_sign(
            data["url"],
            data["params"],
            data.get("body", ""),
        )
        return jsonify({"code": 0, "data": result})
    except Exception as e:
        return jsonify({"code": -1, "error": str(e)}), 500


@app.route("/health", methods=["GET"])
def health_check():
    return jsonify({"status": "ok", "timestamp": int(time.time())})


if __name__ == "__main__":
    bridge = FridaSignBridge(package_name="com.target.app")
    app.run(host="0.0.0.0", port=5000, threaded=True)