梵殇-fanshanng

Hunter 设备指纹与 Hook 检测逆向学习实录

Wed, 11 Mar 2026 14:39:20 +0800

0x00 写在前面

本文记录了一次完整的 Hunter 设备指纹与 Hook 检测逆向实践。为避免分析发散，我先把目标拆成三个可验证问题，并围绕它们逐步推进：

Hunter 具体采集了哪些设备信号与环境特征？
这些采集到的信号如何映射到页面展示的指纹字段中？
其风险判定逻辑是单点触发，还是多信号融合决策？

0x01 研究对象与初始现象

通过对指纹页面的初步分析，可以看到三个核心区域：

DeviceBaseInfo（设备基础信息）
JavaDeviceFingerprint（Java 层设备指纹）
NativeDeviceFingerprint（Native 层设备指纹）

其中 NativeDeviceFingerprint 区域呈现出特征性内容：
- oaid_xxx：开放设备标识符（OAID），用于替代 IMEI 的非敏感设备标识
- ifaa_error_Bind service failed：IFAA（互联网金融身份认证联盟）服务绑定失败，是一个错误日志
- soter_xxx：腾讯 Soter 安全组件生成的密钥标识
- 后面的 a_/b_/c_/e_/f_ 开头字符串：是 Native 层采集的各类硬件 / 系统特征值，用于生成更稳定的设备指纹

0x02 动态分析迭代路线

0x02.1 第一阶段：定位核心采集入口

根据上面页面字段先做了一轮关键词反推（如 ro.secure、ro.debuggable、ifaa、soter、biometric），可以先确定两类最可能的入口，再进入后续 Hook：

android.os.SystemProperties.get 用来验证基础系统属性的读取来源。页面里的构建标签、安全状态、调试开关这类信息，通常都会经过这里。
android.app.ContextImpl.getSystemService 用来验证系统能力探测入口。像 IFAA、生物识别、指纹、Keyguard 这类能力查询，常见都会从这个 API 往下走。

这样做的目的，是先把“谁在采集什么”这条主线跑通，再决定下一步补 bindService、业务方法还是 JNI 路线，避免一开始就大面积 Hook 导致噪音失控。

点击展开：完整代码（v1）

Java.perform(function () {
    var TARGET_PKG = "com.zhenxi.hunter";

    function getFirstBizFrame() {
        try {
            var Exception = Java.use("java.lang.Exception");
            var Log = Java.use("android.util.Log");
            var stack = Log.getStackTraceString(Exception.$new());
            if (!stack) return "";
    
            var lines = stack.split("\n");
            for (var i = 0; i < lines.length; i++) {
                var line = lines[i].trim();
                if (line.indexOf(TARGET_PKG) !== -1) return line;
            }
        } catch (e) {}
        return "";
    }
    
    function logHit(api, key, value) {
        var frame = getFirstBizFrame();
        var tag = frame ? "[HIT]" : "[HIT_EARLY]";
        var showFrame = frame ? frame : "<no-biz-frame>";
        console.log(tag + " " + api + " | key=" + key + " | ret=" + value + " | frame=" + showFrame);
    }
    
    function hookSystemProperties() {
        var SP = Java.use("android.os.SystemProperties");
    
        var get1 = SP.get.overload("java.lang.String");
        get1.implementation = function (key) {
            var ret = get1.call(this, key);
            var k = (key || "").toLowerCase();
            if (k.indexOf("ro.") === 0) {
                logHit("SystemProperties.get(String)", key, ret);
            }
            return ret;
        };
    
        var get2 = SP.get.overload("java.lang.String", "java.lang.String");
        get2.implementation = function (key, defValue) {
            var ret = get2.call(this, key, defValue);
            var k = (key || "").toLowerCase();
            if (k.indexOf("ro.") === 0) {
                logHit("SystemProperties.get(String,String)", key, ret);
            }
            return ret;
        };
    }
    
    function hookGetSystemService() {
        var Ctx = Java.use("android.app.ContextImpl");
        var getSvc = Ctx.getSystemService.overload("java.lang.String");
    
        getSvc.implementation = function (name) {
            var ret = getSvc.call(this, name);
            var n = (name || "").toLowerCase();
            if (n.indexOf("ifaa") !== -1 || n.indexOf("finger") !== -1 || n.indexOf("biometric") !== -1 || n.indexOf("keyguard") !== -1) {
                logHit("Context.getSystemService", name, ret);
            }
            return ret;
        };
    }
    
    hookSystemProperties();
    hookGetSystemService();
    console.log("[*] hookhunter v1 installed");
});

这段代码的价值很明确：

先做观测，不篡改返回值。
先建立“调用来源地图”，再谈下一步。

阶段结果（实测）：

启动期稳定观测到属性读取（如 ro.miui.notch）。
观测到 biometric、keyguard 等系统能力查询。
首个业务栈帧可回溯到 MainActivity.onCreate，验证入口归因可用。

日志说明：下面这组日志证明了 v1 入口观察已生效，且能看到属性读取与系统能力查询。

点击展开：日志输出

[+] hook SystemProperties.get(String) [+] hook SystemProperties.get(String,String) [+] hook ContextImpl.getSystemService(String) [*] hookhunter v1 installed [HIT] SystemProperties.get(String,String) | key=ro.miui.notch | ret=1 | frame=at com.zhenxi.hunter.MainActivity.onCreate(Unknown Source:203) [HIT_EARLY] Context.getSystemService | key=biometric | ret=android.hardware.biometrics.BiometricManager@245b6fa | frame= [HIT_EARLY] Context.getSystemService | key=keyguard | ret=android.app.KeyguardManager@bc6e0d6 | frame=

0x02.2 第二阶段：验证 IFAA/Soter 服务绑定链路

新增重点：ContextWrapper.bindService(Intent, ServiceConnection, int)

点击展开：完整代码（v1.2）

Java.perform(function () {
    var TARGET_PKG = "com.zhenxi.hunter";

    function getFirstBizFrame() {
        try {
            var Exception = Java.use("java.lang.Exception");
            var Log = Java.use("android.util.Log");
            var stack = Log.getStackTraceString(Exception.$new());
            if (!stack) return "";

            var lines = stack.split("\n");
            for (var i = 0; i < lines.length; i++) {
                var line = lines[i].trim();
                if (line.indexOf(TARGET_PKG) !== -1) return line;
            }
        } catch (e) {}
        return "";
    }

    function logHit(api, key, value) {
        var frame = getFirstBizFrame();
        var tag = frame ? "[HIT]" : "[HIT_EARLY]";
        var showFrame = frame ? frame : "<no-biz-frame>";
        console.log(tag + " " + api + " | key=" + key + " | ret=" + value + " | frame=" + showFrame);
    }

    function containsKeyword(s) {
        var text = (s || "").toLowerCase();
        return (
            text.indexOf("ifaa") !== -1 ||
            text.indexOf("soter") !== -1 ||
            text.indexOf("bind service failed") !== -1 ||
            text.indexOf("biometric") !== -1 ||
            text.indexOf("finger") !== -1
        );
    }

    function hookSystemProperties() {
        var SP = Java.use("android.os.SystemProperties");

        var get1 = SP.get.overload("java.lang.String");
        get1.implementation = function (key) {
            var ret = get1.call(this, key);
            var k = (key || "").toLowerCase();
            if (k.indexOf("ro.") === 0) logHit("SystemProperties.get(String)", key, ret);
            return ret;
        };

        var get2 = SP.get.overload("java.lang.String", "java.lang.String");
        get2.implementation = function (key, defValue) {
            var ret = get2.call(this, key, defValue);
            var k = (key || "").toLowerCase();
            if (k.indexOf("ro.") === 0) logHit("SystemProperties.get(String,String)", key, ret);
            return ret;
        };
    }

    function hookGetSystemService() {
        var Ctx = Java.use("android.app.ContextImpl");
        var getSvc = Ctx.getSystemService.overload("java.lang.String");
        getSvc.implementation = function (name) {
            var ret = getSvc.call(this, name);
            var n = (name || "").toLowerCase();
            if (n.indexOf("ifaa") !== -1 || n.indexOf("finger") !== -1 || n.indexOf("biometric") !== -1 || n.indexOf("keyguard") !== -1) {
                logHit("Context.getSystemService", name, ret);
            }
            return ret;
        };
    }

    function hookBindService() {
        var CtxWrapper = Java.use("android.content.ContextWrapper");
        function intentSummary(intentObj) {
            try {
                if (!intentObj) return "intent=<null>";
                var action = intentObj.getAction();
                var comp = intentObj.getComponent();
                var pkg = intentObj.getPackage();
                return "action=" + action + ", pkg=" + pkg + ", comp=" + comp;
            } catch (e) {
                return "intent=<error:" + e + ">";
            }
        }

        var b1 = CtxWrapper.bindService.overload("android.content.Intent", "android.content.ServiceConnection", "int");
        b1.implementation = function (intent, conn, flags) {
            var ret = b1.call(this, intent, conn, flags);
            var summary = intentSummary(intent);
            if (containsKeyword(summary)) logHit("ContextWrapper.bindService", summary + ", flags=" + flags, ret);
            return ret;
        };
    }

    function hookAndroidLog() {
        var ALog = Java.use("android.util.Log");

        var e2 = ALog.e.overload("java.lang.String", "java.lang.String");
        e2.implementation = function (tag, msg) {
            var ret = e2.call(this, tag, msg);
            var content = "tag=" + tag + ", msg=" + msg;
            if (containsKeyword(content)) logHit("Log.e(String,String)", content, ret);
            return ret;
        };

        var e3 = ALog.e.overload("java.lang.String", "java.lang.String", "java.lang.Throwable");
        e3.implementation = function (tag, msg, tr) {
            var ret = e3.call(this, tag, msg, tr);
            var content = "tag=" + tag + ", msg=" + msg + ", tr=" + tr;
            if (containsKeyword(content)) logHit("Log.e(String,String,Throwable)", content, ret);
            return ret;
        };

        var w2 = ALog.w.overload("java.lang.String", "java.lang.String");
        w2.implementation = function (tag, msg) {
            var ret = w2.call(this, tag, msg);
            var content = "tag=" + tag + ", msg=" + msg;
            if (containsKeyword(content)) logHit("Log.w(String,String)", content, ret);
            return ret;
        };

        var i2 = ALog.i.overload("java.lang.String", "java.lang.String");
        i2.implementation = function (tag, msg) {
            var ret = i2.call(this, tag, msg);
            var content = "tag=" + tag + ", msg=" + msg;
            if (containsKeyword(content)) logHit("Log.i(String,String)", content, ret);
            return ret;
        };
    }

    hookSystemProperties();
    hookGetSystemService();
    hookBindService();
    hookAndroidLog();
    console.log("[*] hookhunter v1.2 installed");
});

关键结论：日志可稳定复现以下结果，且与页面字段高度一致：
1. IFAA 服务绑定返回 false → 对应页面 ifaa_error_Bind service failed；
2. Soter 服务绑定返回 true → 对应页面 soter_xxx 标识存在。

日志说明：下面这组日志直接坐实了 IFAA 失败、Soter 成功两条分支。

点击展开：日志输出

[+] hook SystemProperties.get(String) [+] hook SystemProperties.get(String,String) [+] hook ContextImpl.getSystemService(String) [+] hook ContextWrapper.bindService(Intent,ServiceConnection,int) [+] hook android.util.Log e/w/i [*] hookhunter v1.2 installed [HIT] SystemProperties.get(String,String) | key=ro.miui.notch | ret=1 | frame=at com.zhenxi.hunter.MainActivity.onCreate(Unknown Source:203) [HIT] ContextWrapper.bindService | key=action=org.ifaa.aidl.manager.IfaaManagerService, pkg=org.ifaa.aidl.manager, comp=null, flags=1 | ret=false | frame=at com.zhenxi.hunter.MainActivity.v(SourceFile:0) [HIT] ContextWrapper.bindService | key=action=null, pkg=null, comp=ComponentInfo{com.tencent.soter.soterserver/com.tencent.soter.soterserver.SoterService}, flags=1 | ret=true | frame=at com.zhenxi.hunter.MainActivity.v(SourceFile:0) [HIT_EARLY] Context.getSystemService | key=biometric | ret=android.hardware.biometrics.BiometricManager@4f78087 | frame= [HIT_EARLY] Context.getSystemService | key=keyguard | ret=android.app.KeyguardManager@bbc2ee5 | frame=

0x02.3 第三阶段：一次失败的全局热点 Hook

尝试：全局 Hook 高频基础类方法 StringBuilder.toString + ArrayList.add，试图捕获聚合指纹生成过程

点击展开：完整代码（v1.3，失败样本）

Java.perform(function () {
    var TARGET_PKG = "com.zhenxi.hunter";

    function getFirstBizFrame() {
        try {
            var Exception = Java.use("java.lang.Exception");
            var Log = Java.use("android.util.Log");
            var stack = Log.getStackTraceString(Exception.$new());
            if (!stack) return "";
            var lines = stack.split("\n");
            for (var i = 0; i < lines.length; i++) {
                var line = lines[i].trim();
                if (line.indexOf(TARGET_PKG) !== -1) return line;
            }
        } catch (e) {}
        return "";
    }

    function logHit(api, key, value) {
        var frame = getFirstBizFrame();
        var tag = frame ? "[HIT]" : "[HIT_EARLY]";
        var showFrame = frame ? frame : "<no-biz-frame>";
        console.log(tag + " " + api + " | key=" + key + " | ret=" + value + " | frame=" + showFrame);
    }

    function containsKeyword(s) {
        var text = (s || "").toLowerCase();
        return (
            text.indexOf("ifaa") !== -1 ||
            text.indexOf("soter") !== -1 ||
            text.indexOf("oaid") !== -1 ||
            text.indexOf("bind service failed") !== -1 ||
            text.indexOf("error_") !== -1 ||
            text.indexOf("ifaa_error") !== -1
        );
    }

    function hookStringBuilders() {
        var SB = Java.use("java.lang.StringBuilder");
        var sbToString = SB.toString.overload();
        sbToString.implementation = function () {
            var ret = sbToString.call(this);
            if (containsKeyword(ret)) {
                logHit("StringBuilder.toString", "builder", ret);
            }
            return ret;
        };

        var SBuf = Java.use("java.lang.StringBuffer");
        var sbufToString = SBuf.toString.overload();
        sbufToString.implementation = function () {
            var ret = sbufToString.call(this);
            if (containsKeyword(ret)) {
                logHit("StringBuffer.toString", "buffer", ret);
            }
            return ret;
        };
    }

    function hookArrayListAdd() {
        var AL = Java.use("java.util.ArrayList");
        var addObj = AL.add.overload("java.lang.Object");
        addObj.implementation = function (obj) {
            var ret = addObj.call(this, obj);
            try {
                var text = obj ? obj.toString() : "<null>";
                if (containsKeyword(text)) {
                    logHit("ArrayList.add(Object)", "size=" + this.size(), text);
                }
            } catch (e) {}
            return ret;
        };
    }

    hookStringBuilders();
    hookArrayListAdd();
    console.log("[*] hookhunter v1.3 installed");
});

执行结果

日志噪音极高，有效信息被海量无效调用淹没；
触发应用进程异常中止。

核心经验：

高频基础类方法不适合作为全局主路径 Hook 目标；
逆向分析应回归“业务方法 + 关键 API”，避免无差别全局 Hook。

日志说明：下面这组日志说明全局热点 Hook 的噪音和性能问题都很严重。

点击展开：日志输出

[+] hook StringBuilder/StringBuffer.toString [+] hook ArrayList.add(Object) [*] hookhunter v1.3 installed [HIT_EARLY] StringBuilder.toString | key=builder | ret=google/rpc/error_details.proto | frame= Process terminated

0x02.4 第四阶段：回到可控策略

调整：

移除高频基础类的全局 Hook；
聚焦 MainActivity 的核心方法（v / onCreate）。

点击展开：完整代码（v1.3_safe）

Java.perform(function () {
    var TARGET_PKG = "com.zhenxi.hunter";

    function getFirstBizFrame() {
        try {
            var Exception = Java.use("java.lang.Exception");
            var Log = Java.use("android.util.Log");
            var stack = Log.getStackTraceString(Exception.$new());
            if (!stack) return "";
            var lines = stack.split("\n");
            for (var i = 0; i < lines.length; i++) {
                var line = lines[i].trim();
                if (line.indexOf(TARGET_PKG) !== -1) return line;
            }
        } catch (e) {}
        return "";
    }

    function logHit(api, key, value) {
        var frame = getFirstBizFrame();
        var tag = frame ? "[HIT]" : "[HIT_EARLY]";
        var showFrame = frame ? frame : "<no-biz-frame>";
        console.log(tag + " " + api + " | key=" + key + " | ret=" + value + " | frame=" + showFrame);
    }

    function containsKeyword(s) {
        var text = (s || "").toLowerCase();
        return (
            text.indexOf("ifaa") !== -1 ||
            text.indexOf("soter") !== -1 ||
            text.indexOf("oaid") !== -1 ||
            text.indexOf("bind service failed") !== -1 ||
            text.indexOf("ifaa_error") !== -1 ||
            text.indexOf("error_") !== -1
        );
    }

    function safeToText(v) {
        try {
            if (v === null || v === undefined) return "<null>";
            return String(v);
        } catch (e) {
            return "<toString_error:" + e + ">";
        }
    }

    function argsToText(args) {
        var out = [];
        for (var i = 0; i < args.length; i++) out.push("a" + i + "=" + safeToText(args[i]));
        return out.join(", ");
    }

    function hookMainActivityFocus() {
        try {
            var Main = Java.use("com.zhenxi.hunter.MainActivity");
            var methodNames = {};
            var declared = Main.class.getDeclaredMethods();
            for (var i = 0; i < declared.length; i++) {
                try { methodNames[declared[i].getName()] = true; } catch (e) {}
            }

            var focus = ["v", "onCreate"];
            for (var j = 0; j < focus.length; j++) {
                var name = focus[j];
                if (!methodNames[name] || !Main[name]) continue;

                var overloads = Main[name].overloads;
                for (var k = 0; k < overloads.length; k++) {
                    (function (mName, ov) {
                        ov.implementation = function () {
                            var argText = argsToText(arguments);
                            var ret;
                            try { ret = ov.apply(this, arguments); }
                            catch (err) {
                                logHit("MainActivity." + mName + "(throw)", argText, err);
                                throw err;
                            }
                            var retText = safeToText(ret);
                            if (mName === "v" || containsKeyword(argText) || containsKeyword(retText)) {
                                logHit("MainActivity." + mName, argText, retText);
                            }
                            return ret;
                        };
                    })(name, overloads[k]);
                }
                console.log("[+] hook MainActivity." + name + " overloads=" + overloads.length);
            }
        } catch (e) {
            console.log("[-] hook MainActivity focus failed: " + e);
        }
    }

    hookMainActivityFocus();
    console.log("[*] hookhunter v1.3_safe installed");
});

关键发现：

MainActivity.v 的栈帧出现 Native Method，可作为“调用链经过 native/桥接边界”的强信号。
但该信号不单独等价于“MainActivity.v 方法声明为 native”；最终应以 JADX/smali 与 JNI 符号映射交叉验证。
后续静态 JNI 导出命中 NativeEngine.getZhenxiInfo*，才是核心链路下沉到 native 的硬证据。

日志说明：下面这组日志用于证明 MainActivity.v 是关键调度入口，并出现 native 边界信号。

点击展开：日志输出

[+] hook MainActivity.v overloads=1 [+] hook MainActivity.onCreate overloads=1 [HIT] ContextWrapper.bindService | key=action=org.ifaa.aidl.manager.IfaaManagerService, pkg=org.ifaa.aidl.manager, comp=null, flags=1 | ret=false | frame=at com.zhenxi.hunter.MainActivity.v(SourceFile:0) [HIT] ContextWrapper.bindService | key=action=null, pkg=null, comp=ComponentInfo{com.tencent.soter.soterserver/com.tencent.soter.soterserver.SoterService}, flags=1 | ret=true | frame=at com.zhenxi.hunter.MainActivity.v(SourceFile:0) [HIT] MainActivity.v | key=a0= | ret= | frame=at com.zhenxi.hunter.MainActivity.v(Native Method) [HIT] MainActivity.v | key=a0=[object Object] | ret= | frame=at com.zhenxi.hunter.MainActivity.v(Native Method)

0x02.5 第五阶段：动态注册 JNI 路线验证

尝试 Hook RegisterNatives 和 CheckJNI 相关方法，验证动态注册 JNI 路线

点击展开：完整代码（v1.4c）

'use strict';

if (globalThis.__hunter_v14c_installed) {
    console.log('[*] v1.4c already installed, skip duplicate install');
} else {
    globalThis.__hunter_v14c_installed = true;
    var MAX_PRINT_CALLS = 120;
    var printedCalls = 0;

    function getClassNameSafe(jclassObj) {
        try {
            if (!Java.available) return '<java-unavailable>';
            var env = Java.vm.tryGetEnv();
            if (!env) return '<env-unavailable>';
            return env.getClassName(jclassObj) || '<unknown-class>';
        } catch (e) {
            return '<class-resolve-failed:' + e + '>';
        }
    }

    function hookOneAddress(symbolName, addr) {
        Interceptor.attach(addr, {
            onEnter: function (args) {
                this.shouldPrint = false;
                if (printedCalls >= MAX_PRINT_CALLS) return;
                var jclassObj = args[1];
                var methods = args[2];
                var count = args[3].toInt32();
                var className = getClassNameSafe(jclassObj);
                var lower = String(className).toLowerCase();
                var suspicious = lower.indexOf('zhenxi') !== -1 || lower.indexOf('hunter') !== -1 || lower.indexOf('mainactivity') !== -1;
                if (!(suspicious || count <= 6)) return;
                this.shouldPrint = true;
            }
        });
        console.log('[+] hook ' + symbolName + ' @ ' + addr);
    }

    function installHooks() {
        try {
            var art = Process.getModuleByName('libart.so');
            var symbols = art.enumerateSymbols();
            var hooked = {};
            var countHooks = 0;
            for (var i = 0; i < symbols.length; i++) {
                var n = symbols[i].name;
                if (n.indexOf('RegisterNatives') === -1) continue;
                if (n.indexOf('JNI') === -1 && n.indexOf('CheckJNI') === -1) continue;
                var addr = symbols[i].address;
                var key = addr.toString();
                if (hooked[key]) continue;
                hooked[key] = true;
                hookOneAddress(n, addr);
                countHooks++;
            }
            console.log('[*] v1.4c installed, hooked symbols=' + countHooks);
        } catch (e) {
            console.log('[-] installHooks failed: ' + e);
        }
    }

    installHooks();
}

执行现象：Hook 可成功安装，但有效命中次数极少。

日志说明：下面这组日志证明 Hook 安装成功，但没有有效 RegisterNatives 命中。

点击展开：日志输出

[+] hook _ZN3art12_GLOBAL__N_18CheckJNI15RegisterNativesEP7_JNIEnvP7_jclassPK15JNINativeMethodi @ 0x… [+] hook _ZN3art3JNI15RegisterNativesEP7_JNIEnvP7_jclassPK15JNINativeMethodi @ 0x… [*] v1.4c installed, hooked symbols=2 Spawned com.zhenxi.hunter. Resuming main thread!

关键推断：Hunter 的核心 JNI 逻辑并非以动态注册为主，更可能采用静态 JNI 导出方式。

0x02.6 第六阶段：静态 JNI 路线突破

在 dlopen/android_dlopen_ext 命中目标 so 后，定向扫描导出。

点击展开：完整代码（v1.5_safe）

'use strict';

var scannedModules = {};
var hookedFns = {};

function getExport(name) {
    try {
        if (Module.findGlobalExportByName) {
            var p = Module.findGlobalExportByName(name);
            if (p) return p;
        }
    } catch (e) {}
    try {
        if (Module.findExportByName) return Module.findExportByName(null, name);
    } catch (e2) {}
    return null;
}

function shouldTrackSymbol(name) {
    var n = (name || '').toLowerCase();
    return n.indexOf('java_com_zhenxi_hunter_') !== -1 || (n.indexOf('java_') === 0 && n.indexOf('mainactivity') !== -1) || (n.indexOf('java_') === 0 && n.indexOf('hunter') !== -1 && n.indexOf('_v') !== -1);
}

function attachJni(address, name, modName) {
    var key = address.toString();
    if (hookedFns[key]) return;
    hookedFns[key] = true;
    Interceptor.attach(address, {
        onEnter: function () { console.log('[JNI_STATIC_ENTER] ' + name + ' @ ' + address + ' (' + modName + ')'); },
        onLeave: function (retval) { console.log('[JNI_STATIC_LEAVE] ' + name + ' ret=' + retval); }
    });
    console.log('[+] attach static JNI => ' + name + ' @ ' + address + ' (' + modName + ')');
}

function scanOneModule(mod) {
    if (!mod) return;
    var mk = mod.name + '@' + mod.base;
    if (scannedModules[mk]) return;
    scannedModules[mk] = true;
    var exports;
    try { exports = mod.enumerateExports(); } catch (e) { return; }
    for (var i = 0; i < exports.length; i++) {
        var ex = exports[i];
        if (ex.type !== 'function') continue;
        var name = ex.name || '';
        if (!shouldTrackSymbol(name)) continue;
        console.log('[JNI_STATIC_EXPORT] ' + mod.name + ' :: ' + name + ' @ ' + ex.address);
        attachJni(ex.address, name, mod.name);
    }
}

function hookDlopen() {
    function hookOne(sym) {
        var fn = getExport(sym);
        if (!fn) return;
        Interceptor.attach(fn, {
            onEnter: function (args) {
                this.path = '';
                try { if (args[0]) this.path = args[0].readCString() || ''; } catch (e) {}
            },
            onLeave: function (retval) {
                if (retval.isNull()) return;
                if (!this.path || this.path.toLowerCase().indexOf('hunter') === -1) return;
                console.log('[dlopen-hit] ' + sym + ' => ' + this.path);
                var mods = Process.enumerateModules();
                for (var i = 0; i < mods.length; i++) {
                    var m = mods[i];
                    if (m.path === this.path || m.path.indexOf(this.path) !== -1 || this.path.indexOf(m.path) !== -1) {
                        scanOneModule(m);
                    }
                }
            }
        });
        console.log('[+] hook ' + sym + ' @ ' + fn);
    }

    hookOne('dlopen');
    hookOne('android_dlopen_ext');
}

setImmediate(function () {
    hookDlopen();
    console.log('[*] hookhunter v1.5_safe installed');
});

关键发现：定位到核心 JNI 入口符号

Java_com_zhenxi_hunter_NativeEngine_getZhenxiInfoMethodCode
Java_com_zhenxi_hunter_NativeEngine_getZhenxiInfoReleaseNative

核心意义：将 JNI 入口从“猜测”转化为“可精准定位的符号”，为后续 Native 层分析奠定基础。

日志说明：下面这组日志是静态 JNI 路线的关键突破证据。

点击展开：日志输出

[dlopen-hit] android_dlopen_ext => …/lib/arm64/libhunter.so [JNI_STATIC_EXPORT] libhunter.so :: Java_com_zhenxi_hunter_NativeEngine_getZhenxiInfoMethodCode @ 0x780ebd1e24 [+] attach static JNI => Java_com_zhenxi_hunter_NativeEngine_getZhenxiInfoMethodCode @ 0x780ebd1e24 (libhunter.so) [JNI_STATIC_EXPORT] libhunter.so :: Java_com_zhenxi_hunter_NativeEngine_getZhenxiInfoReleaseNative @ 0x780ebd1d5c [+] attach static JNI => Java_com_zhenxi_hunter_NativeEngine_getZhenxiInfoReleaseNative @ 0x780ebd1d5c (libhunter.so) [*] module scan done: libhunter.so, hits=2

0x02.7 第七阶段：NativeEngine 全量映射

批量 Hook NativeEngine.getZhenxiInfo* 系列方法，建立 “方法 - 返回值” 映射关系

点击展开：完整代码（v1.6）

'use strict';

(function () {
    function hookJavaNativeEngine() {
        if (!Java.available) return;
        Java.perform(function () {
            try {
                var NE = Java.use('com.zhenxi.hunter.NativeEngine');
                var clsMethods = NE.class.getDeclaredMethods();
                var seen = {};
                for (var i = 0; i < clsMethods.length; i++) {
                    var name = '';
                    try { name = clsMethods[i].getName(); } catch (e0) { continue; }
                    if (seen[name]) continue;
                    seen[name] = true;
                    if (name.indexOf('getZhenxiInfo') === -1) continue;
                    if (!NE[name]) continue;
                    var ovs = NE[name].overloads;
                    for (var k = 0; k < ovs.length; k++) {
                        (function (mName, ov) {
                            ov.implementation = function () {
                                var argsText = [];
                                for (var a = 0; a < arguments.length; a++) {
                                    try { argsText.push('a' + a + '=' + String(arguments[a])); }
                                    catch (e1) { argsText.push('a' + a + '=<err>'); }
                                }
                                var ret = ov.apply(this, arguments);
                                var retText = '<null>';
                                try { retText = String(ret); } catch (e2) {}
                                console.log('[JAVA_NE] ' + mName + '(' + argsText.join(', ') + ') => ' + retText);
                                return ret;
                            };
                        })(name, ovs[k]);
                    }
                    console.log('[+] hook NativeEngine.' + name + ' overloads=' + ovs.length);
                }
            } catch (e) {
                console.log('[-] hook NativeEngine failed: ' + e);
            }
        });
    }

    hookJavaNativeEngine();
    console.log('[*] hookhunter v1.6 nativeengine focus installed');
})();

高频方法（按调用次数）：

getZhenxiInfoH（21 次）

典型输入：ro.build.display.id、ro.boot.verifiedbootstate、ro.secure。
说明：系统属性读取主通道（对应 DeviceBaseInfo/环境基础特征）。

getZhenxiInfoZ（13 次）

与 H 类似，用于补充读取属性值（含空值键探测）。

getZhenxiInfoK（6 次）

典型输入：/proc/mounts、/proc/self/mountstats、/proc/self/mountinfo。
说明：容器/挂载环境探测（docker/lxc 关键词）。

稳定输出方法（2 次，双日志一致）：

getZhenxiInfo1 => a_/b_/c_/e_/f_ 聚合串
getZhenxiInfo3 => Check Find Root File 风险项
getZhenxiInfo4 => 进程风险项（另一个样本中出现 sh 进程）
getZhenxiInfoOFLI => 文件描述符清单
getZhenxiInfoLLLI => 已加载 so/镜像清单结论：设备属性读取与环境风险探测是 Hunter 的核心主干流量。

0x02.8 第八阶段：核心方法精准追踪

聚焦 9 个核心方法：

getZhenxiInfo1
getZhenxiInfo3
getZhenxiInfo4
getZhenxiInfoF
getZhenxiInfoH
getZhenxiInfoZ
getZhenxiInfoK
getZhenxiInfoOFLI
getZhenxiInfoLLLI

并对超长返回做摘要处理，解决日志爆炸问题。

阶段结果（实测）：

getZhenxiInfo1 输出 a_/b_/c_/e_/f_ 聚合串。
getZhenxiInfo3 命中 zygisk/su/magisk 痕迹。
getZhenxiInfo4 命中 sh 进程。
getZhenxiInfoF 命中 Hook/完整性风险。

点击展开：完整代码（v1.7）

Java.perform(function () {
    var TARGET_CLASS = 'com.zhenxi.hunter.NativeEngine';
    var FOCUS = {
        getZhenxiInfo1: true,
        getZhenxiInfo3: true,
        getZhenxiInfo4: true,
        getZhenxiInfoF: true,
        getZhenxiInfoH: true,
        getZhenxiInfoZ: true,
        getZhenxiInfoK: true,
        getZhenxiInfoOFLI: true,
        getZhenxiInfoLLLI: true
    };

    var KEY_RO = {
        'ro.secure': true,
        'ro.debuggable': true,
        'ro.build.display.id': true,
        'ro.boot.verifiedbootstate': true,
        'ro.build.tags': true
    };

    function now() { try { return Date.now(); } catch (e) { return 0; } }
    function safeStr(v) {
        try {
            if (v === null || v === undefined) return '<null>';
            return String(v);
        } catch (e) {
            return '<toString_error:' + e + '>';
        }
    }

    function shrink(text, maxLen) {
        if (!text) return text;
        if (text.length <= maxLen) return text;
        return text.substring(0, maxLen) + '...<len=' + text.length + '>';
    }

    function summarizeRet(name, retText) {
        if (name === 'getZhenxiInfoOFLI' || name === 'getZhenxiInfoLLLI') return shrink(retText, 260);
        if (name === 'getZhenxiInfo3' || name === 'getZhenxiInfo4' || name === 'getZhenxiInfoF') return shrink(retText, 320);
        return shrink(retText, 180);
    }

    function shouldPrint(name, argsArr) {
        if (name === 'getZhenxiInfoH' || name === 'getZhenxiInfoZ') {
            var k = argsArr.length > 0 ? safeStr(argsArr[0]) : '';
            return !!KEY_RO[k];
        }
        return true;
    }

    function hookNativeEngine() {
        var NE = Java.use(TARGET_CLASS);
        var methods = NE.class.getDeclaredMethods();
        var seen = {};
        for (var i = 0; i < methods.length; i++) {
            var mName;
            try { mName = methods[i].getName(); } catch (e0) { continue; }
            if (seen[mName]) continue;
            seen[mName] = true;
            if (!FOCUS[mName]) continue;
            if (!NE[mName]) continue;
            var ovs = NE[mName].overloads;
            for (var j = 0; j < ovs.length; j++) {
                (function (name, ov) {
                    ov.implementation = function () {
                        var t0 = now();
                        var argsArr = [];
                        for (var a = 0; a < arguments.length; a++) argsArr.push(arguments[a]);
                        var ret = ov.apply(this, arguments);
                        if (!shouldPrint(name, argsArr)) return ret;
                        var argText = [];
                        for (var k = 0; k < argsArr.length; k++) argText.push('a' + k + '=' + safeStr(argsArr[k]));
                        var retText = summarizeRet(name, safeStr(ret));
                        var cost = now() - t0;
                        console.log('[V1.7] ' + name + '(' + argText.join(', ') + ') => ' + retText + ' | costMs=' + cost);
                        return ret;
                    };
                })(mName, ovs[j]);
            }
            console.log('[+] hook focus method: ' + mName + ' overloads=' + ovs.length);
        }
    }

    try {
        hookNativeEngine();
        console.log('[*] hookhunter v1.7 focus installed');
    } catch (e) {
        console.log('[-] v1.7 hook failed: ' + e);
    }
});

日志说明：下面这组日志体现了最终高价值方法追踪的核心命中结果。

点击展开：日志输出

[V1.7] getZhenxiInfoH(a0=ro.build.display.id) => QKQ1.190828.002 test-keys | costMs=11 [V1.7] getZhenxiInfo3() => {title=Check Find Root File risk=[com.zhenxi.hunter:hunter_main_process, /system/lib64/libzygisk.so, /sbin/su, /sbin/.magisk]} | costMs=3 [V1.7] getZhenxiInfo1() => a_NSw6KjQ+MS,b_NTA5MUM8RT,c_29048414,e_ehwrEnRaXE,f_MzowNTQxMj | costMs=86 [V1.7] getZhenxiInfoF() => {title=检测到libart.so被修改 risk=[检测当前程序被Hook,当前手机存在hook框架]} | costMs=674

0x03 核心证据（节选）

0x03.1 最终脚本实跑结果

最终版本脚本采用“中文结构化输出”，每次命中都会直接打印方法用途、参数、返回值、耗时和提炼后的关键点。

点击展开：最终脚本完整代码（较长）

/*
 * Hunter 最终学习版脚本（中文输出 + 详细注释）
 *
 * 适用目标：com.zhenxi.hunter
 * 设计目标：
 * 1) 用最小必要 Hook 点覆盖“指纹采集 + 风险判断”的关键路径。
 * 2) 输出尽量中文化，便于直接作为博客素材。
 * 3) 对超长返回做摘要，避免日志被列表淹没。
 * 4) 不篡改返回值，只做观测，保证结果可重复、可解释。
 *
 * 推荐命令：
 * frida -U -f com.zhenxi.hunter -l D:\Desktop\练手\hunter\hookhunter_final_cn_blog.js -q
 */

Java.perform(function () {
    'use strict';

    // ========== 一、可调参数区域 ==========

    // 目标类：已在前序分析中确认 NativeEngine 是核心入口。
    var TARGET_CLASS = 'com.zhenxi.hunter.NativeEngine';

    // 仅追踪高价值方法，减少无关噪音。
    var FOCUS_METHODS = {
        getZhenxiInfo1: true,     // 核心聚合 a_/b_/c_/e_/f_
        getZhenxiInfo3: true,     // Root 文件/路径风险
        getZhenxiInfo4: true,     // 进程风险
        getZhenxiInfoF: true,     // Hook/完整性风险（libart）
        getZhenxiInfoH: true,     // 高频属性读取
        getZhenxiInfoZ: true,     // 属性补充读取
        getZhenxiInfoK: true,     // 容器环境探测
        getZhenxiInfoOFLI: true,  // 文件描述符枚举
        getZhenxiInfoLLLI: true   // so/oat 枚举
    };

    // H/Z 为高频属性读取，按关键键值过滤，避免刷屏。
    var KEY_RO = {
        'ro.secure': true,
        'ro.debuggable': true,
        'ro.build.display.id': true,
        'ro.boot.verifiedbootstate': true,
        'ro.build.tags': true
    };

    // ========== 二、通用工具函数 ==========

    function nowMs() {
        try { return Date.now(); } catch (e) { return 0; }
    }

    function safeStr(v) {
        try {
            if (v === null || v === undefined) return '<null>';
            return String(v);
        } catch (e) {
            return '<toString_error:' + e + '>';
        }
    }

    function shrink(text, maxLen) {
        if (!text) return text;
        if (text.length <= maxLen) return text;
        return text.substring(0, maxLen) + '...<len=' + text.length + '>';
    }

    // 按方法类型设置不同摘要长度，平衡信息量与可读性。
    function summarizeReturn(methodName, retText) {
        if (methodName === 'getZhenxiInfoOFLI' || methodName === 'getZhenxiInfoLLLI') {
            return shrink(retText, 320);
        }
        if (methodName === 'getZhenxiInfo3' || methodName === 'getZhenxiInfo4' || methodName === 'getZhenxiInfoF') {
            return shrink(retText, 420);
        }
        return shrink(retText, 220);
    }

    function shouldPrint(methodName, argsArr) {
        // 高频属性通道做键过滤，保留关键安全属性即可。
        if (methodName === 'getZhenxiInfoH' || methodName === 'getZhenxiInfoZ') {
            var key = argsArr.length > 0 ? safeStr(argsArr[0]) : '';
            return !!KEY_RO[key];
        }
        return true;
    }

    function methodDesc(methodName) {
        var desc = {
            getZhenxiInfo1: '设备指纹聚合（a_/b_/c_/e_/f_）',
            getZhenxiInfo3: 'Root 文件/路径风险检测',
            getZhenxiInfo4: '可疑进程检测',
            getZhenxiInfoF: 'Hook/完整性检测（libart）',
            getZhenxiInfoH: '系统属性主通道',
            getZhenxiInfoZ: '系统属性补充通道',
            getZhenxiInfoK: '容器环境检测（docker/lxc）',
            getZhenxiInfoOFLI: '文件描述符枚举',
            getZhenxiInfoLLLI: '加载库枚举'
        };
        return desc[methodName] || '未知用途';
    }

    // 从返回值里提取“可直接读懂的重点”。
    function extractHighlights(methodName, retText, argsArr) {
        var out = [];
        var lower = (retText || '').toLowerCase();

        if (methodName === 'getZhenxiInfo1') {
            if (retText.indexOf('a_') !== -1 || retText.indexOf('b_') !== -1) {
                out.push('命中 a_/b_/c_/e_/f_ 聚合字段，疑似 Native 指纹核心输出');
            }
        }

        if (methodName === 'getZhenxiInfo3') {
            if (lower.indexOf('zygisk') !== -1) out.push('命中 zygisk 相关路径');
            if (lower.indexOf('/sbin/su') !== -1) out.push('命中 su 路径');
            if (lower.indexOf('magisk') !== -1) out.push('命中 magisk 痕迹');
        }

        if (methodName === 'getZhenxiInfo4') {
            if (lower.indexOf('pid name: sh') !== -1) out.push('命中 sh 进程');
            if (lower.indexOf('pid name: grep') !== -1) out.push('命中 grep 进程');
            if (lower.indexOf('pid name: logcat') !== -1) out.push('命中 logcat 进程');
        }

        if (methodName === 'getZhenxiInfoF') {
            if (retText.indexOf('libart') !== -1) out.push('命中 libart 完整性风险');
            if (retText.indexOf('Hook') !== -1 || retText.indexOf('hook') !== -1) out.push('命中 Hook 框架风险提示');
        }

        if (methodName === 'getZhenxiInfoK') {
            var path = argsArr.length > 0 ? safeStr(argsArr[0]) : '';
            if (retText === '<null>' || retText === 'null') {
                out.push('路径 ' + path + ' 未命中容器关键词');
            } else {
                out.push('路径 ' + path + ' 存在容器相关命中');
            }
        }

        if (methodName === 'getZhenxiInfoH' || methodName === 'getZhenxiInfoZ') {
            var key = argsArr.length > 0 ? safeStr(argsArr[0]) : '';
            out.push('属性读取：' + key + ' = ' + retText);
        }

        if (methodName === 'getZhenxiInfoOFLI') {
            out.push('返回 fd 列表，用于观察可疑句柄/映射关系');
        }

        if (methodName === 'getZhenxiInfoLLLI') {
            out.push('返回 so/oat 列表，可用于识别注入/异常模块');
            if (lower.indexOf('frida-agent') !== -1) {
                out.push('列表中出现 frida-agent 相关痕迹');
            }
        }

        return out;
    }

    // ========== 三、关键 Hook：NativeEngine 方法级追踪 ==========

    function hookNativeEngineFocus() {
        var NE = Java.use(TARGET_CLASS);
        var methods = NE.class.getDeclaredMethods();
        var installed = {};

        for (var i = 0; i < methods.length; i++) {
            var mName = '';
            try { mName = methods[i].getName(); } catch (e0) { continue; }

            if (installed[mName]) continue;
            installed[mName] = true;

            if (!FOCUS_METHODS[mName]) continue;
            if (!NE[mName]) continue;

            var overloads = NE[mName].overloads;

            for (var j = 0; j < overloads.length; j++) {
                (function (methodName, ov) {
                    ov.implementation = function () {
                        var t0 = nowMs();

                        // 先保存参数，避免调用后对象状态变化导致打印失真。
                        var argsArr = [];
                        for (var a = 0; a < arguments.length; a++) {
                            argsArr.push(arguments[a]);
                        }

                        // 只观测，不修改返回值。
                        var ret = ov.apply(this, arguments);

                        // 高频属性方法做过滤，减少重复噪音。
                        if (!shouldPrint(methodName, argsArr)) {
                            return ret;
                        }

                        var cost = nowMs() - t0;

                        var argText = [];
                        for (var k = 0; k < argsArr.length; k++) {
                            argText.push('a' + k + '=' + safeStr(argsArr[k]));
                        }

                        var rawRet = safeStr(ret);
                        var retText = summarizeReturn(methodName, rawRet);

                        // 主日志：结构化 + 中文语义
                        console.log('');
                        console.log('【核心命中】' + methodName + '（' + methodDesc(methodName) + '）');
                        console.log('  参数: ' + (argText.length > 0 ? argText.join(', ') : '<无参数>'));
                        console.log('  返回: ' + retText);
                        console.log('  耗时: ' + cost + ' ms');

                        // 附加重点：从返回里抽“可读结论”。
                        var points = extractHighlights(methodName, rawRet, argsArr);
                        for (var p = 0; p < points.length; p++) {
                            console.log('  关键点: ' + points[p]);
                        }

                        return ret;
                    };
                })(mName, overloads[j]);
            }

            console.log('已安装 Hook -> ' + mName + '，重载数=' + overloads.length + '，用途=' + methodDesc(mName));
        }
    }

    // ========== 四、辅助 Hook：IFAA/Soter 绑定观测 ==========

    // 这个辅助点用于把早期结论串起来：IFAA bind 失败，Soter bind 成功。
    function hookBindServiceLite() {
        try {
            var CtxWrapper = Java.use('android.content.ContextWrapper');
            var bind3 = CtxWrapper.bindService.overload('android.content.Intent', 'android.content.ServiceConnection', 'int');

            bind3.implementation = function (intent, conn, flags) {
                var ret = bind3.call(this, intent, conn, flags);

                var action = '';
                var pkg = '';
                var comp = '';
                try { action = safeStr(intent ? intent.getAction() : null); } catch (e1) {}
                try { pkg = safeStr(intent ? intent.getPackage() : null); } catch (e2) {}
                try { comp = safeStr(intent ? intent.getComponent() : null); } catch (e3) {}

                var s = (action + ' ' + pkg + ' ' + comp).toLowerCase();
                if (s.indexOf('ifaa') !== -1 || s.indexOf('soter') !== -1 || s.indexOf('biometric') !== -1 || s.indexOf('finger') !== -1) {
                    console.log('');
                    console.log('【服务绑定】bindService 观测');
                    console.log('  action=' + action);
                    console.log('  pkg=' + pkg);
                    console.log('  comp=' + comp);
                    console.log('  flags=' + flags + ', ret=' + ret);
                }

                return ret;
            };

            console.log('已安装 Hook -> ContextWrapper.bindService（轻量观测）');
        } catch (e) {
            console.log('安装 bindService 观测失败: ' + e);
        }
    }

    // ========== 五、启动入口 ==========

    try {
        console.log('目标类: ' + TARGET_CLASS);
        console.log('策略: 高价值方法追踪 + 中文结构化输出 + 只观测不篡改');

        hookNativeEngineFocus();
        hookBindServiceLite();

        console.log('========== Hook 安装完成，等待目标方法触发 ==========' );
    } catch (e) {
        console.log('脚本初始化失败: ' + e);
    }
});

点击展开：完整实跑终端输出（较长）

(venv38) PS E:\code\vscode\venv38> frida -U -f com.zhenxi.hunter -l D:\Desktop\练手\hunter\hookhunter_final.js

/ _ | Frida 17.3.2 - A world-class dynamic instrumentation toolkit | (| | > _ | Commands: // || help -> Displays the help system . . . . object? -> Display information about ‘object’ . . . . exit/quit -> Exit . . . . . . . . More info at https://frida.re/docs/home/ . . . . . . . . Connected to MI 8 (id=6ca0abb6) Spawned com.zhenxi.hunter. Resuming main thread! [MI 8::com.zhenxi.hunter ]-> 目标类: com.zhenxi.hunter.NativeEngine 已安装 Hook -> getZhenxiInfo1，重载数=1，用途=设备指纹聚合（a/b_/c_/e_/f_）已安装 Hook -> getZhenxiInfo3，重载数=1，用途=Root 文件/路径风险检测已安装 Hook -> getZhenxiInfo4，重载数=1，用途=可疑进程检测已安装 Hook -> getZhenxiInfoF，重载数=1，用途=Hook/完整性检测（libart）已安装 Hook -> getZhenxiInfoH，重载数=1，用途=系统属性主通道已安装 Hook -> getZhenxiInfoK，重载数=1，用途=容器环境检测（docker/lxc）已安装 Hook -> getZhenxiInfoLLLI，重载数=1，用途=加载库枚举已安装 Hook -> getZhenxiInfoOFLI，重载数=1，用途=文件描述符枚举已安装 Hook -> getZhenxiInfoZ，重载数=1，用途=系统属性补充通道已安装 Hook -> ContextWrapper.bindService（轻量观测） ========== Hook 安装完成，等待目标方法触发 ==========

【核心命中】getZhenxiInfoH（系统属性主通道）参数: a0=ro.build.display.id 返回: QKQ1.190828.002 test-keys 耗时: 11 ms 关键点: 属性读取：ro.build.display.id = QKQ1.190828.002 test-keys

【服务绑定】bindService 观测 action=org.ifaa.aidl.manager.IfaaManagerService pkg=org.ifaa.aidl.manager comp= flags=1, ret=false

【服务绑定】bindService 观测 action= pkg= comp=ComponentInfo{com.tencent.soter.soterserver/com.tencent.soter.soterserver.SoterService} flags=1, ret=true

【核心命中】getZhenxiInfo3（Root 文件/路径风险检测）参数: <无参数> 返回: {title=Check Find Root File risk=[com.zhenxi.hunter:hunter_main_process, /system/lib64/libzygisk.so, /sbin/su, /sbin/.magisk] com.zhenxi.hunter:hunter_main_process /system/lib64/libzygisk.so /sbin/su /sbin/.magisk }

耗时: 44 ms 关键点: 命中 zygisk 相关路径关键点: 命中 su 路径关键点: 命中 magisk 痕迹

【核心命中】getZhenxiInfo1（设备指纹聚合（a_/b_/c_/e_/f_））参数: <无参数> 返回: a_NSw6KjQ+MS,b_NTA5MUM8RT,c_29048414,e_ehwrEnRaXE,f_MzowNTQxMj 耗时: 86 ms 关键点: 命中 a_/b_/c_/e_/f_ 聚合字段，疑似 Native 指纹核心输出

【核心命中】getZhenxiInfo4（可疑进程检测）参数: a0=YouAreLoser.ug@c56afde 返回: {title=Find Others Processmay be risks main pid (7087) risk=[other pid -> 7427(pid name: ls), other pid -> 7432(pid name: sh)] other pid -> 7427(pid name: ls) other pid -> 7432(pid name: sh) }

耗时: 8 ms 关键点: 命中 sh 进程

【核心命中】getZhenxiInfoLLLI（加载库枚举）参数: <无参数> 返回: [/system/bin/linker64, /system/bin/app_process64, [vdso], /system/lib64/libandroid_runtime.so, /system/lib64/libbase.so, /system/lib64/libbinder.so, /system/lib64/libcutils.so, /system/lib64/libhidlbase.so, /system/lib64/liblog.so, /apex/com.android.runtime/lib64/libnativeloader.so, /system/lib64/libutils.so, /system/l…<len=10999> 耗时: 2 ms 关键点: 返回 so/oat 列表，可用于识别注入/异常模块关键点: 列表中出现 frida-agent 相关痕迹

【核心命中】getZhenxiInfoOFLI（文件描述符枚举）参数: <无参数> 返回: [1//dev/null/character device/8630/1/0/0/0, 2//dev/null/character device/8630/1/0/0/0, 3/socket:[2096764]/socket/49663/1/10277/10277/0, 4//dev/pmsg0/, 5//sys/kernel/debug/tracing/trace_marker/, 6//dev/null/character device/8630/1/0/0/0, 7//dev/null/character device/8630/1/0/0/0, 8//dev/null/character device/8630/1/0/0/…<len=6268> 耗时: 9 ms 关键点: 返回 fd 列表，用于观察可疑句柄/映射关系关键点: 路径 /proc/mounts 未命中容器关键词

【核心命中】getZhenxiInfoK（容器环境检测（docker/lxc））参数: a0=/proc/self/mountstats, a1=docker,lxc_volumns 返回: 耗时: 0 ms 关键点: 路径 /proc/self/mountstats 未命中容器关键词

【核心命中】getZhenxiInfoK（容器环境检测（docker/lxc））参数: a0=/proc/self/mountinfo, a1=docker,lxc_volumns 返回: 耗时: 364 ms 关键点: 路径 /proc/self/mountinfo 未命中容器关键词

【核心命中】getZhenxiInfoH（系统属性主通道）参数: a0=ro.boot.verifiedbootstate 返回: green 耗时: 32 ms 关键点: 属性读取：ro.boot.verifiedbootstate = green [节选说明] 中间存在多轮 getZhenxiInfoH/Z 对 ro.build.display.id、ro.debuggable、ro.secure 的重复轮询日志，这里不再全文贴出。

【核心命中】getZhenxiInfoF（Hook/完整性检测（libart））参数: <无参数> 返回: {title=检测到libart.so被修改 risk=[检测当前程序被Hook,当前手机存在hook框架]} 耗时: 433 ms 关键点: 命中 libart 完整性风险

getZhenxiInfo1()

日志说明：该返回值用于证明 a_/b_/c_/e_/f_ 聚合字段已经被命中。

a_NSw6KjQ+MS,b_NTA5MUM8RT,c_29048414,e_ehwrEnRaXE,f_MzowNTQxMj

该返回与 NativeDeviceFingerprint 中的 a_/b_/c_/e_/f_ 聚合字段高度对应。

getZhenxiInfo3()

日志说明：该风险列表用于证明 root/hook 路径检测命中。

risk=[com.zhenxi.hunter:hunter_main_process, /system/lib64/libzygisk.so, /sbin/su, /sbin/.magisk]

说明 root/hook 相关痕迹可通过文件与路径信号直接采集。

getZhenxiInfo4(...)

日志说明：该输出用于证明存在进程维度的风险画像。

risk=[other pid -> … (pid name: sh/cat/grep/ls/logcat)…]

说明存在进程维度的实时风险画像能力。

getZhenxiInfoH/Z

日志说明：该组日志用于证明关键系统属性被持续读取并参与判断。

ro.build.display.id => QKQ1.190828.002 test-keys ro.boot.verifiedbootstate => green ro.debuggable => 0 ro.secure => 1

说明基础系统属性属于高频输入，且存在重复校验行为。

getZhenxiInfoK(...)

日志说明：该结果用于证明当前样本环境未触发容器特征命中。

/proc/mounts + docker,lxc_volumns => /proc/self/mountstats + docker,lxc_volumns => /proc/self/mountinfo + docker,lxc_volumns =>

该样本环境下容器特征未命中。

getZhenxiInfoF()

日志说明：该输出用于证明链路内置了完整性与 Hook 框架检测。

{title=检测到libart.so被修改 risk=[检测当前程序被Hook,当前手机存在hook框架]}

这是最关键的一条：采集链路内置完整性与 Hook 框架检测。

0x04 最终映射表（方法 -> 字段 -> 风险意义）

方法	主要输入	输出形态	对应字段/语义	风险意义
getZhenxiInfo1	无	`a_/b_/c_/e_/f_` 聚合串	NativeDeviceFingerprint 关键聚合值	高
getZhenxiInfo3	无	root 风险列表	root 文件/路径痕迹	高
getZhenxiInfo4	进程上下文	进程风险列表	可疑进程态势	高
getZhenxiInfoF	无	完整性风险 map	libart/hook 框架检测	极高
getZhenxiInfoH/Z	ro.* 属性键	属性值	DeviceBaseInfo 与安全属性	中高
getZhenxiInfoK	/proc/* + docker,lxc	null/命中项	容器环境检测	中
getZhenxiInfoOFLI	无	fd 列表	打开文件/句柄画像	中
getZhenxiInfoLLLI	无	so/oat 列表	运行时加载画像	中

0x05 关键结论（经日志支持）

Hunter 并非单点 root 检测，而是多信号融合判断。
指纹采集与安全检测在同一链路并行执行，而非“先采集后检测”的串行模型。
仅隐藏单个信号（如 su）意义有限，进程、加载库、完整性校验仍会补充风险证据。
从工程实践看，“先宽后窄”的脚本迭代策略显著提升了定位效率与可解释性。

0x06 学习总结

1. 逆向分析方法论

本次 Hunter 设备指纹逆向遵循由浅入深、由 Java 到 Native、由观测到验证的主线：

初始阶段：通过页面特征反推关键 API，优先 Hook 系统级 API（SystemProperties.get/Context.getSystemService）建立观测基线。
迭代阶段：逐步收敛 Hook 范围，从全局 Hook 转向业务方法（MainActivity.v），再下钻到 JNI 层。
突破阶段：通过静态 JNI 导出符号扫描定位核心 Native 方法，最终还原指纹生成链路。

2. 结论修正记录（学习过程）

早期我曾根据栈帧 MainActivity.v(Native Method)，把 MainActivity.v 直接定性为 native 方法。看到frame=at com.zhenxi.hunter.MainActivity.v(Native Method)。为什么会被显示成 Native Method（即使我在 JADX 看到方法体）：
1. 栈里经过了 JNI 或桥接层，运行时把该帧标成 Native Method。
2. Frida Hook 后调用路径有 native trampoline，栈展示可能偏向桥接实现。
3. 混淆/优化导致行号信息不完整，也会出现 SourceFile:0 或 Native Method 这类显示。
后续复核 JADX/smali 后修正为：MainActivity.v 更适合作为 Java 调度入口；Native Method 栈帧应视为调用链经过 native/桥接边界的强信号，而非单独定性依据。
最终定性以多源证据交叉为准：JADX/smali + JNI 符号映射。核心 native 计算链路仍落在 NativeEngine.getZhenxiInfo*。

3. 关键技术点总结

阶段	核心技术	解决的问题	核心经验
Java 层观测	Frida Java API Hook	定位数据采集入口	先观测不篡改，建立调用链路地图
系统服务探测	bindService Hook/Logcat 监控	验证 IFAA/Soter 服务状态	结合日志上下文分析错误码含义
JNI 层定位	dlopen Hook + 导出符号扫描	找到 Native 层核心入口	静态 JNI 导出比动态注册更常见
Native 层分析	指令级 Hook / 系统调用追踪	还原指纹生成算法	关注哈希函数、字符串拼接操作
对抗绕过	Anti-Anti-Debug	突破调试 / 检测限制	优先修复核心校验点而非全量绕过

4. 避坑指南

避免无差别全局 Hook：高频基础类（StringBuilder/ArrayList）Hook 会产生海量噪音，甚至导致进程崩溃。
JNI 层分析优先静态符号：动态注册 JNI 的检测成本更高，很多商业应用更偏向静态导出。
日志输出需做摘要：超长返回值（如完整指纹串）应截断，避免日志爆炸。
坚持分层分析：Java 层链路未理清前，不要急于深入 Native，避免方向失控。

5. Frida 逆向基础

Java 层 Hook 核心 API：
- Java.use()：获取类的引用；
- overload()：指定方法重载版本；
- implementation：替换方法实现；
- Java.perform()：在 Java 虚拟机上下文执行代码。
Native 层 Hook 核心 API：
- Interceptor.attach()：附加到函数地址；
- Module.findExportByName()：查找导出符号；
- Thread.backtrace()：获取调用栈；
- NativeCallback/NativeFunction：Native 函数封装。

6. Android 设备指纹核心维度

维度	采集内容	技术实现
基础硬件	CPU / 内存 / 屏幕 / 传感器	读取`/sys`/`/proc`文件、系统属性
系统信息	系统版本 / ROM / 安全补丁	`ro.build.*`系列属性
唯一标识	OAID/IMEI/ 序列号	系统服务调用（TelephonyManager）
环境安全	Root/Hook/ 调试状态	进程扫描、文件检测、指令校验
服务能力	IFAA/Soter/ 生物识别	`bindService`/`getSystemService`

7. Native 层逆向关键技巧

符号命名规律：JNI 静态导出符号遵循Java_包名_类名_方法名规则；
指令特征：哈希计算（MD5/SHA）会出现固定的指令序列；
数据流转：通过read/write系统调用追踪数据读取与输出；
对抗检测：关注ptrace/seccomp/mmap等系统调用的异常使用。

0x07 延伸阅读

Hunter Root 检测点分析与绕过

Wed, 11 Mar 2026 13:26:59 +0800

这篇文章记录一次对 Hunter Root 环境检测的处理过程。实际碰到的点主要有两个：

硬件级完整性检测：TEE / Verified Boot。
日志侧信道检测：通过系统审计日志反推设备存在 Root 痕迹。

这两个点一个偏“设备状态伪装”，一个偏“痕迹清理与权限隔离”，思路并不一样，分开处理会更清晰。

0x00 结论先看

TEE / Verified Boot 检测可通过 TrickyStore 处理。
日志嗅探检测的关键不是隐藏文件本身，而是阻止目标 App 读取 logcat 中的审计日志。
处理完成后，Hunter 检测页恢复绿色。

0x01 硬件级检测：TEE & Verified Boot

处理方法

部署 TrickyStore 模块，并在 /data/adb/tricky_store/ 中配置 target.txt，将 Hunter 的目标包名加入处理列表。

如果系统里同时还用了其他隐藏类模块，建议先确认模块职责不要重叠，否则排查时很容易混淆到底是谁生效。

原理分析

这一类检测关注的不是普通文件路径，而是更底层的设备完整性状态，例如 Verified Boot、Key Attestation 或 TEE 相关字段。即使常规的 Root 隐藏已经处理过，应用依旧可以通过这些硬件或系统级信号判断设备是否“可信”。

TrickyStore 的思路，本质上是对目标应用可见的完整性信息做定向伪装，让应用在读取这些状态时拿到“看起来正常”的结果。

0x02 日志嗅探检测：Find Root File In Sniff

问题定位

我最初根据日志里的路径，怀疑它是在探测 APatch 相关目录；但后面复查设备环境时，发现当前系统里并没有 /data/adb/ap/log，也没有安装 APatch。

因此，更稳妥的结论应该是：Hunter 命中的并不是“当前目录一定存在”这个事实，而是它从系统日志里读到了与 Root 环境相关的审计记录。这个记录可能来自历史残留、之前装过的组件、其他模块留下的兼容路径，或者单纯是一次失败访问触发的 avc: denied 日志。

只要目标 App 能读到这类日志，它就可以不依赖目录是否真实存在，直接利用审计信息完成环境判定。

换句话说，它并不是直接“看见了 Root 文件”，而是通过“访问失败后留下的系统日志”完成了侧信道检测。

处理方法

先清理旧日志，再剥夺 Hunter 读取日志的能力：

1
2
3

logcat -c
appops set com.zhenxi.hunter 43 ignore
pm revoke com.zhenxi.hunter android.permission.READ_LOGS

其中：

logcat -c 用于清理历史日志，避免旧的 avc 记录继续干扰检测结果。
appops set com.zhenxi.hunter 43 ignore 用于在 AppOps 层面对 READ_LOGS 做拦截，这里的 43 对应 READ_LOGS。
pm revoke com.zhenxi.hunter android.permission.READ_LOGS 用于从权限层进一步收紧日志读取能力。

原理分析

核心思路不是删除某个特定模块的痕迹，而是切断“日志回显”这条检测链。只要目标 App 无法读取 logcat，它就拿不到 SELinux 拒绝访问后产生的审计记录，自然也就无法利用这条侧信道做环境判定。

0x03 验证结果

重新打开 Hunter 后，检测页面已经恢复为绿色，说明这检测点都已经被处理掉。

0x04 小结

这次处理比较有代表性的一点在于：Root 检测未必都是“扫文件”和“扫包名”这么直接。

Hunter 这里至少包含两种不同思路：

通过 TEE / Verified Boot 判断设备完整性。
通过 logcat 读取 avc: denied 审计日志，利用系统日志做侧信道取证，而不必依赖目标路径当前真实存在。

因此，绕过时也不能只盯着“隐藏 su、隐藏 Magisk”这一类老思路。很多时候真正暴露环境的，不是目标文件本身，而是系统在访问、拒绝、审计过程中留下的附带信息。日志里出现的路径，也不应该直接等价为“当前设备上一定存在这个模块或这个目录”。

绕过某邦企业壳 Root/Frida 检测

Tue, 10 Mar 2026 18:14:49 +0800

本文基于 xiaoeeyu 的文章做了一次复现，主要记录我自己的分析过程和实践结果。

0x00 环境

设备: Xiaomi MI 8（Android 10，已 Root）
工具: Frida 17.3.2
App 版本: v5.12.0

0x01 查壳与威胁建模

使用 ApkCheckPack 对目标 APK 进行全面扫描，结果如下：

APK检测工具 - 扫描配置:
- 检测类型: ROOT(true) 模拟器(true) 反调试(true) 代理(true) SDK(true) ...
...
- 加固特征扫描结果
    - Soname  梆梆安全（定制版） -> lib/arm64-v8a/libDexHelper.so
    - Soname  梆梆安全（企业版） -> lib/arm64-v8a/libDexHelper.so
    
- 安全检测特征扫描结果
    - ROOT检测特征: 检测 su 文件 (/sbin/su, /system/xbin/su...), Magisk, SuperSU 等
    - 模拟器检测特征: 检测 qemu_pipe, goldfish 内核, 默认 IMEI 等
    - 反调试检测特征: 检测 TracerPid, ro.debuggable, Frida-gadget, XposedBridge 等

分析结论：

加固厂商：确认为 梆梆安全 (BangBang) 企业定制版。核心逻辑在 libDexHelper.so 中。
防御机制：
- Root 检测：覆盖了文件路径、包名和属性检测。这也是需要 Shamiko 的主要原因。
- 环境检测：包含模拟器和反调试检测。
- 第三方 SDK：集成了腾讯云、阿里实人认证等 SDK，这些 SDK 本身也可能带有一定的安全校验，增加逆向干扰。

0x02 初步分析

打开应用后，很明显出现了 Root 检测提示。

采用隐藏 Magisk + Shamiko 的方式来绕过 Root 检测：隐藏 Magisk，刷入 Shamiko 模块，并在重启后配置排除列表。

处理完成后，打开 App，Root 检测提示消失。但我并没有遇到原文作者提到的“frida-server 运行即闪退”情况，不管点击注册还是登录都未触发闪退。

并且我使用的确实是默认端口。

考虑到可能是 App 版本差异，我没有继续深究这个现象，先尝试简单 Hook 检测逻辑。

可以看到它会检测 Frida 的核心组件（frida-agent）并阻止注入。

0x03 Hook `pthread_create`

Hook 思路和原理分析

pthread_create 是 Android/Linux 开发中最常用的创建线程的 API。在加固或者反调试的场景中，壳通常会创建一些可以在后台偷偷运行的线程，即“检测线程”。

1
2
3
4
int pthread_create(pthread_t *thread,
                  const pthread_attr_t *attr,
                  void *(*start_routine)(void *),
                  void *arg);
thread: 返回创建的线程 ID。

attr: 线程属性（可以为 NULL）。

start_routine: 线程执行函数。

arg: 传入线程函数的参数。

这些线程的任务通常包括：

轮询文件系统：检查 /proc/self/maps 是否有 Frida 相关 so，或者 /sys/class/ 下是否有痕迹。
端口扫描：检查本地 27042 (frida-server 默认端口)。
完整性校验：检查特定函数（如 open, read）的头部字节是否被修改（Inline Hook 检测）。

因此，逆向分析的第一步通常是先记录线程入口地址。如果某个线程入口位于壳的 SO（如 libDexHelper.so）范围内，这个线程就值得重点关注。

第一次尝试

根据上述思路，我们首先尝试 Hook libc.so 的 pthread_create 函数，以此来定位检测线程的入口。

var pth = Module.findExportByName("libc.so", "pthread_create");
Interceptor.attach(pth, {
    onEnter: function(args) {
        var entry = args[2]; // 线程函数入口
        var module = Process.findModuleByAddress(entry);
        if (module) console.log("Thread from: " + module.name);
    }
});

结果：Process terminated App 启动即崩溃 (Crash)。

企业级加固壳（如梆梆）常会检查 pthread_create 前几个字节是否被改写。如果检测到 Inline Hook，通常会触发崩溃或退出。因此，直接 Hook 这类敏感 libc 函数风险较高。

0x04 Hook `clone`

既然 pthread_create 被检测，那我们向下深入一层。在 Linux/Android 中，线程创建最终是通过 clone 系统调用实现的。

pthread_create 的调用流程

pthread_create()
↓
分配线程控制块（TCB）、栈空间等
↓
设置调度策略/属性（可选）
↓
调用 clone()
↓
内核创建 task_struct（共享 mm、fs、files、sighand 等）
↓
新线程执行 start_routine(arg)

策略：Hook libc.so 中的 clone 函数。

过程：

定位调用栈：首先 Hook clone 并打印堆栈，发现 clone 是被 libc.so 中的 pthread_create 调用的。
静态分析 libc：将手机中的 /system/lib64/libc.so 拉取出来，使用 IDA 反编译 pthread_create 函数。

寻找赋值点：在 pthread_create 的伪代码中，我们可以看到在调用 clone 之前，有一行关键的代码：

  *(_QWORD *)(v28 + 96) = v51;
  *(_QWORD *)(v28 + 104) = v52;
  *(_DWORD *)(v28 + 20) = getpid(inited);
  if ( (unsigned int)clone(__pthread_start, v17, 4001536, v28, v28 + 16, v21 + 8, v28 + 16) == -1 )

结论：pthread_create 会把线程入口函数写入结构体的 +96 偏移，并把该结构体指针传给 clone。因此在 Hook clone 时，读取 args[3] 指针的 +96 偏移，即可拿到真实线程入口。

注意：

在第一次反编译手机的 libc.so 时，我看到偏移量是 48 (0x30) 而不是 96。这是因为我分析的是 32位 (ARM) 的库 (/system/lib/libc.so)。而目标 App 运行在 64位 (ARM64) 环境下，所以需要分析 /system/lib64/libc.so，才能得到对应的 96 (0x60) 偏移。

验证脚本 (trace_clone.js)：

为了增强脚本的兼容性（应对部分 Frida 版本在 Spawn 早期 Module.findExportByName 找不到符号的问题），我们在实际脚本中增加了一个 get_export 的封装。

/* trace_clone.js */
console.log("[*] 开始 Hook clone 以定位检测线程...");

// 兼容性封装：在不同 Frida 版本中查找导出符号
function get_export(name) {
    if (Module.findGlobalExportByName) return Module.findGlobalExportByName(name);
    if (Module.getGlobalExportByName) return Module.getGlobalExportByName(name);
    if (Module.findExportByName) return Module.findExportByName(null, name);
    try {
        var libc = Process.getModuleByName("libc.so");
        if (libc) return libc.findExportByName(name);
    } catch(e) {}
    return null;
}

var clone = get_export("clone");
if (clone) {
    Interceptor.attach(clone, {
        onEnter: function(args) {
            try {
                // clone 的参数 args[3] 是 pthread_internal_t 指针
                // 在 Android 中，偏移 96 处存储了线程入口函数 (start_routine)
                var struct_ptr = args[3];
                if (!struct_ptr.isNull()) {
                    var start_routine = struct_ptr.add(96).readPointer();
                    
                    // 检查入口函数是否属于加固壳的 SO (libDexHelper.so)
                    var module = Process.findModuleByAddress(start_routine);
                    if (module && module.name.indexOf("libDexHelper") !== -1) {
                         var offset = start_routine.sub(module.base);
                         console.log("[+] 发现可疑线程 | 模块: " + module.name + " | 基址: " + module.base + " | 入口: " + start_routine + " | 偏移: " + offset);
                    }
                }
            } catch(e) {}
        }
    });
} else {
    console.log("[-] 未找到 clone 函数");
}

结果：成功输出了检测线程的偏移地址，随后 App 依然崩溃（因为我们只是观测，没阻止检测）。

[MI 8::com.bybit.app ]-> [+] 发现可疑线程 | 模块: libDexHelper.so | 基址: 0x77a4306000 | 入口: 0x77a435a814 | 偏移: 0x54814
[+] 发现可疑线程 | 模块: libDexHelper.so | 基址: 0x77a4306000 | 入口: 0x77a4357304 | 偏移: 0x51304
[+] 发现可疑线程 | 模块: libDexHelper.so | 基址: 0x77a4306000 | 入口: 0x77a4362034 | 偏移: 0x5c034
[+] 发现可疑线程 | 模块: libDexHelper.so | 基址: 0x77a4306000 | 入口: 0x77a436256c | 偏移: 0x5c56c
[+] 发现可疑线程 | 模块: libDexHelper.so | 基址: 0x77a4306000 | 入口: 0x77a43688c8 | 偏移: 0x628c8
Process terminated

我们捕获到了以下关键偏移 (基于 libDexHelper.so)：

0x54814
0x51304
0x5C034
0x5C56C
0x628C8

0x05 Hook `dlopen`

我们需要在 libDexHelper.so 加载后、检测线程启动前尽快 Hook android_dlopen_ext 并完成 Patch。

Patch 策略：将上述 5 个偏移处的函数代码，修改为直接返回 (RET)。
指令选择：
- RET (Return): 0xC0 03 5F D6 (ARM64)

完整脚本 (`hook_dlopen.js`)

var OFFSETS = [
    0x54814, 0x51304, 0x5C034, 0x5C56C, 0x628C8
];

function patch_ret(base, offset) {
    var target = base.add(offset);
    try {
        Memory.patchCode(target, 4, function(code) {
           // ARM64: RET (直接返回) -> C0 03 5F D6
           code.writeByteArray([0xC0, 0x03, 0x5F, 0xD6]);
        });
        console.log("[+] 已Patch检测线程: " + target + " (Offset: " + offset.toString(16) + ")");
    } catch (e) {
        console.log("[-] Patch失败: " + e);
    }
}

// 兼容性封装：在不同 Frida 版本中查找导出符号
function get_export(name) {
    if (Module.findGlobalExportByName) return Module.findGlobalExportByName(name);
    if (Module.getGlobalExportByName) return Module.getGlobalExportByName(name);
    if (Module.findExportByName) return Module.findExportByName(null, name);
    try {
        var libc = Process.getModuleByName("libc.so");
        if (libc) return libc.findExportByName(name);
    } catch(e) {}
    return null;
}

var dlopen = get_export("android_dlopen_ext");
if (dlopen) {
    var is_patched = false;
    Interceptor.attach(dlopen, {
        onLeave: function(retval) {
            if (is_patched) return;
            var mod = Process.findModuleByName("libDexHelper.so");
            if (mod) {
                is_patched = true;
                
                console.log("[*] 捕获 libDexHelper.so 加载 | 基址: " + mod.base);
                OFFSETS.forEach(function(off) {
                    patch_ret(mod.base, off);
                });
            }
        }
    });
} else {
    console.log("[-] 未找到 android_dlopen_ext");
}

效果验证

运行命令：frida -U -f com.bybit.app -l hook_dlopen.js 终端输出（成功示例）：

App 成功进入主界面，无闪退，Frida 连接稳定。

0x06 复盘总结

6.1 查壳

特征识别: 使用 ApkCheckPack 这类工具可以快速确认加固特征。对梆梆企业壳来说，libDexHelper.so 是比较明确的线索。
Root 检测对抗: 传统的 su 改名方式效果有限。实际测试里，Magisk + Shamiko 这类按应用隔离 Root 痕迹的方案更稳定。

6.2 从 `pthread_create` 到 `clone`

API 调用链: Android 中的线程创建并非一步到位的，而是一个层层递进的过程： Java Thread -> Native pthread_create (NDK/Libc) -> clone syscall (Kernel Interface) -> Kernel。
为什么 Hook pthread_create 失败？ 壳在初始化阶段可能会校验 pthread_create 的指令头，或监控该函数是否被 Hook。直接附加到这个点位，容易触发崩溃。
为什么 clone 有效？ clone 位于更底层，直接与内核交互。很多壳对它的防护没有上层 API 那么激进，因此是一个可行的观测点。

源码分析: 通过反编译手机中的 libc.so (64位)，找到了 pthread_create 调用 clone 的部分：

// 伪代码片段 (IDA 64-bit libc.so)
// v51: start_routine (用户线程函数)
// v52: user_arg (用户参数)
// v28: pthread_internal_t* (线程控制块指针)

*(_QWORD *)(v28 + 96) = v51;   // [关键] 将真实线程入口存入 +96
*(_QWORD *)(v28 + 104) = v52;  // [关键] 将参数存入 +104
*(_DWORD *)(v28 + 20) = getpid(inited);

// 调用 clone
// 参数1: __pthread_start (系统包装函数)
// 参数3: flags
// 参数4: v28 (arg，即它的 pthread_internal_t 指针)
if ( (unsigned int)clone(__pthread_start, v17, 4001536, v28, v28 + 16, v21 + 8, v28 + 16) == -1 )

两个关键发现：

Wrapper 机制：clone 的第一个参数不是业务线程函数，而是系统的 __pthread_start，用于初始化线程环境（TLS、Stack Guard 等）。
Arg 传递：clone 的第4个参数 (v28/arg) 实际上是一个指向 pthread_internal_t 的指针。系统把 start_routine 藏在了这个结构体的 +96 偏移处。

6.3 动态库加载

android_dlopen_ext vs dlopen: 在 Android 高版本中，系统加载 SO 往往直接通过 android_dlopen_ext。Hook 这个函数可以让我们拦截到系统加载任何 SO 的动作。
执行顺序:
1. 检测到 libDexHelper.so 正在加载。
2. 此时 SO 的基址 (base) 已经确定。
3. 在 onLeave 阶段通常可以拿到稳定基址并尽快完成 Patch（是否早于具体检测逻辑，取决于壳的实现时机）。
4. 通过 Memory.patchCode 修改目标函数入口，减少后续检测线程执行风险。

6.4 内存修补 (Patching)

NOP (0x1F2003D5)：空指令，CPU 会继续执行下一条。如果后续仍有检测调用，NOP 本身不能阻断流程。
RET (0xC0035FD6)：让函数立即返回。用于这种场景时，通常比 NOP 更直接。

(引用：本文思路参考 xiaoeeyu - 绕过某邦企业壳root、frida检测)

大数据安全与隐私保护 (DSPP) 复习笔记

Tue, 30 Dec 2025 22:35:43 +0800

大数据安全与隐私保护复习笔记

本文档基于《大数据安全与隐私保护》教材及老师高亮部分整理而成，序号仅为排版并非章节号，仅为个人学习备忘，不保证覆盖所有考点。

第一章大数据安全的概念

1.1 大数据安全的内涵

大数据服务中的安全问题：
- 系统架构与认证授权问题。
- 利用系统漏洞攻击大数据服务系统。
- 算法缺陷或训练数据管理漏洞，注入攻击数据。
- 滥用合法功能发起攻击。
- 滥用合法功能获取隐私信息。
大数据技术在安全领域的应用：
- 用流量特征识别攻击流量；分析社交数据（微博/微信）预测突发事件并动态决策。
- 引导网络舆论的走向以防止事态恶化。
- 攻击者也会利用大数据与 AI（如破解验证码、关联分析获取隐私）。

1.2大数据的五个 V 特征

Volume (体量大): 数据规模超出传统数据库的处理能力。
Velocity (速度快): 数据产生和处理的时效性要求高（如流数据）。
Variety (类型多): 包含结构化、半结构化（XML/JSON）、非结构化（视频/图片）数据。
Veracity (真实性/质量): 数据质量参差不齐，存在噪声、伪造或异常数据。
Value (价值): 价值密度低，需要通过分析挖掘其潜在价值。

1.3 隐私权的起源与定义

起源: 1890年，布兰代斯（Brandeis）与沃伦（Warren）在《哈佛法律评论》发表《隐私权》（The Right to Privacy）。
定义: “不受别人干扰的权利” (The right to be let alone)。
演变: 从最初关注物理空间（住宅）的隐私，发展到关注个人信息和数据的隐私。

1.4 隐私与法律（简史）

1965：美国“中央数据银行”计划。
1974：水门事件后，《隐私法》（Privacy Act of 1974）出台。
2002：美国在《2002 年国土安全法》重提中央数据银行计划，命名为“万维信息触角计划”（Total Information Awareness, TIA）。
2013：斯诺登事件曝光“棱镜计划”。
2018-05-25：欧盟《通用数据保护条例》（GDPR）全面实施。
2018-05-01：中国《信息安全技术个人信息安全规范》开始实施（国家推荐性标准）。

本章小结

大数据安全涵盖两面：服务中的安全问题与大数据技术在安全中的应用。
隐私与技术进步紧密相关，法律制度（如 GDPR）重塑数据隐私保护的框架与实践。

第二章基础知识

2.1 密码算法

2.1.1 对称加密 (Symmetric Cryptography)

基本原理：加密和解密使用同一个密钥。
设计技巧：
- 代换 (Substitution)：字符替换（如 a->d）。
- 置换 (Permutation)：位置打乱（如 dog->ogd）。
流密码 (Stream Cipher)：利用密钥生成伪随机比特流，与明文进行异或运算。
分组密码 (Block Cipher)：
- DES：64位分组，56位密钥（8 位奇偶校验），16 轮迭代，含初始置换、S 盒替换、P 盒置换等步骤，安全性较低。
- 三重 DES：使用 2-3 个密钥三重调用 DES，兼容单 DES；
- AES：128位分组，支持128/192/256位密钥，安全性高，广泛使用。
- IDEA：64 位明文分组，128 位密钥。
- 模式：ECB（电码本）、CBC（密码分组链接）、OFB（输出反馈）、CFB（密文反馈）、CTR（计数器）。

2.1.2 公钥加密 (Public Key Cryptography)

核心特点：非对称，公钥公开，私钥保密。解决密钥分发问题。
用接收方公钥安全传递会话（对称）密钥：

RSA 体制
- 安全性：基于大整数因子分解难题（多项式时间内无法完成）；
- 数学基础：欧拉函数、欧拉定理、费马小定理；
- 欧拉函数性质：素数 $p$ 的 $\varphi(p) = p-1$；若 $n = p \times q$（$p, q$ 为不同素数），则 $\varphi(n) = (p-1)(q-1)$；
- 欧拉定理：若 $a$ 与 $n$ 互素，则 $a^{\varphi(n)} \equiv 1 \pmod{n}$；费马定理是其特例（$n$ 为素数时）。
复合式密码系统：对称密码（高效加密数据）+ 公钥密码（加密对称密钥），平衡安全性与效率，应用于电子商务等场景。
公钥密码体制还为数字签名提供了有效方法，一种完善的签名应满足以下三个条件:
1. 签名者事后不能抵赖自己的签名;
2. 任何其他人不能伪造签名;
3. 如果当事的双方关于签名的真伪发生争执，能够在公正的仲裁者面前通过验证确认其真伪。
- 包含签名算法（用私钥对消息或其哈希签名）与验证算法（用公钥验证）。

2.2 消息完整性与 MAC

设消息为 M，可用分组密码的 CBC 模式构造消息验证码（CBC-MAC）。
核心思想：对消息任一分组的修改会影响最终密文分组，从而改变 MAC 值；攻击者缺乏密钥 K，无法为篡改后的 M’ 计算匹配的 MAC’。

2.3 网络安全协议

IPSec（端到端安全）：IPSec(Internet协议安全)是一个工业标准网络安全协议,为IP网络通信提供透明的安全服务，可使TCP/IP通信免遭窃听和篡改，可以有效抵御网络攻击，同时保持易用性。
- IPSec有两个基本目标:①保护 IP 数据包安全；②抵御网络攻击。
- IPSec提供认证与加密，提升透明安全性。
TLS/SSL（传输层安全）：安全套接层(SSL,Secure Socket Layer)协议是Web浏览器和Web服务器之间安全交换信息的网络协议。
- SSL提供了两个基本安全服务:认证与保密。
- SSL提供了Web浏览器与Web服务器之间的逻辑安全管道。
DTLS (数据报传输层加密)：TLS 的扩展，支持 UDP 协议，适用于延迟敏感的数据包传输（如实时视频、网络电话）。

2.4 身份认证

定义：确认实体身份真伪，基于 “用户知道什么（口令、PIN）、拥有什么（令牌、USB key）、是什么（生物特征）” 三类方法；

身份认证的常用方法

口令（现代实现避免明文传输与存储，加入加密或派生保护）。
认证令牌（引入随机性，广泛用于高安全场景）。
基于证书与 PKI（可结合智能卡在卡内完成加密运算）。
生物特征（图像、指纹、声音等；提升体验，免去记忆或携带）。

2.5 单点登录（SSO）与密钥分发

核心思想：一次登录可访问多个相互信任的系统，理论基础为 Needham-Schroeder 协议（对称密钥版与公钥版）；

对称密钥版为 Kerberos 的基础（建立会话密钥以保护后续通信）。
公钥版提供相互身份验证（原始形式不安全，后续有改进）。

2.6 Kerberos 协议

基础：对称密码体制，引入 KDC（密钥分发中心），含 AS（认证服务器）和 TGS（票据授权服务器）；
核心流程：用户向 KDC 申请会话密钥，KDC 生成含有效期的密钥与票据，通过时间戳防止重放攻击；
优势：结合授权机制、票据有有效期、支持双向认证与域间认证。

2.7 访问控制

访问控制可以定义为主体依据某些控制策略或权限对客体本身或是其资源进行授权访问。

主体（访问发起者）、客体（被访问资源）、访问控制策略（访问规则集）

BLP 模型 (Bell-LaPadula): 侧重机密性。
- 规则: No Read Up (不可读高密级), No Write Down (不可写低密级)。
- BLP“下读”模型解析图:
- BLP"上写"模型解析图:
Biba 模型: 侧重完整性。
- 规则: No Read Down (不可读低完整性), No Write Up (不可写高完整性)。
- Biba 安全模型解析图:

2.8 开放授权（OAuth）

核心作用：用户将资源授权给第三方应用，不泄露密码，支持细粒度权限控制；
实现方式：OAuth 协议（在线授权，适用于 SNS 服务）、IAM 服务（预先授权，适用于云计算）；
参与实体：RO（资源所有者）、Client（第三方应用）、AS（授权服务器）、RS（资源服务器）；
OAuth 2.0 四种流程：授权码授权（服务端 WEB 应用）、隐式授权（客户端 WEB 应用）、用户密码凭证（高信任场景）、客户端凭证（无需用户登录）。

本章小结

回顾了密码学基础、常用算法与操作模式，以及 MAC、数字签名等完整性与认证机制。
IPSec/TLS/DTLS 提供网络层与传输层安全保障；SSO 与访问控制（BLP/Biba）奠定系统安全基石。

第三章大数据服务架构及其安全

3.1 SOA 架构

定义：面向服务架构（Service-Oriented Architecture），1996 年由 Gartner Group 提出，是分布式计算模式与组件模型，将应用拆分为动态可重用的服务。
核心优势：代码重用、松耦合、平台独立、语言无关。
组件模型：通过定义良好的中立接口（独立于硬件、操作系统、编程语言），将不同功能单元（服务）关联，实现统一交互。
核心角色与操作：
- 角色：服务提供者（发布服务、响应请求）、服务注册中心（注册、分类、搜索服务）、服务使用者（查找、调用服务）；
- 操作：发布（公开服务描述）、查找（查询满足需求的服务）、绑定（根据服务描述调用服务）。
实现方式：Web Services（基于 SOAP 协议）、RESTful 风格服务（基于 HTTP 协议）。

3.2 Web Services 技术体系

核心规范：
- 传输规范：HTTP；
- 消息规范（SOAP）：简单对象访问协议，基于 XML+HTTP，核心组成包括必须的 Envelope（根元素）、可选的 Headers、必须的 Body（消息负载 / 错误信息）；
- 描述规范（WSDL）：Web 服务描述语言，通过 XML 说明服务地址与调用方法；
- 发布与发现规范（UDDI）：统一描述、发现和集成，用于服务注册与发现；
扩展规范：
- 消息扩展（寻址、可靠性、安全、事务等质量保障）。
- 服务组合（BPEL4WS、BPML）：以编排组合基本服务为业务流程的复合服务。
- 服务协作（WS-CDL, Web Services Choreography Description Language）：定义服务之间协作时的消息通信规则与顺序。
特点
- 松耦合交互方式，支持分布式部署、组合和使用粗粒度应用组件；
- 服务层为 SOA 基础，可直接被应用调用，减少人为依赖性；
- 核心特性：粗粒度、松耦合，通过精确定义的适配器通讯，不涉及底层编程细节。

3.3 Web Services 安全（WS-Security）

由 OASIS 等推动的标准，为 SOAP 通信补强：
- 消息机密性：在请求/响应过程中加密重要信息，防止窃听与篡改。
- 客户/服务身份：核验 SOAP 请求来源与实体身份。
关键技术：提供消息机密性（XML Encryption）、完整性（XML Signature）（合称 WS-Security 的核心实现方式）。

3.4 REST

基于 SOAP和 WSDL的Web Services 架构属于复杂的、重量级的协议。随着 Web2.0的兴起，表述性状态转移(REST)逐步成为一个流行的架构风格。REST是一种轻量级的SOA 架构实现风格,可以完全通过 HTTP协议实现,并且能够利用缓存Cache来提高响应速度，在性能、效率和易用性上都优于基于 SOAP和 WSDL的Web Services 架构。

核心思想：REST = Representation（资源表现形式，如 JSON、XML、JPEG）+ State（状态）+ Transfer（转移），即资源通过网络以某种表现形式完成状态转移；

轻量级 SOA 实现，完全基于 HTTP；面向“资源”（Web Services面向“功能”），通过 URL 访问，支持缓存，性能与易用性优于基于 SOAP/WSDL 的重量级方案。
源自 Roy Fielding（2000）博士论文：良好设计的网络应用如状态机，用户选择链接导致状态（页面）转变。
RESTful 架构约束：
- 每一个 URI 代表一种资源；
- 客户端与服务器传递资源的表现层；
- 通过统一接口（URI）暴露资源，支持跨平台交互。

3.5 微服务（Microservices）

将单体应用按功能、数据分解为多个边界明确、可重组的小规模子服务，服务间通过轻量级通信（如 HTTP/RESTful API）协作，各自拥有独立数据库，支持独立部署、技术异构（不同语言 / 框架开发），适配移动优先与 DevOps 流程。
典型实践：亚马逊的主页由大量微服务协同构成，小型团队负责构建与运维；提升可扩展性与性能。

3.6 微服务中的身份认证与访问控制

API 网关模式：对外统一入口（负责认证、流控、监控），微服务在网关内暴露对应 API。
最常见API安全保护模式：OAuth 2.0（访问授权框架）。
参与实体：
- RO（Resource Owner）：资源拥有者，有授权能力。
- RS（Resource Server）：资源服务器，存储并提供资源访问。
- Client（客户端/第三方应用）：代表 RO 访问资源。
- AS（Authorization Server）：授权服务器，签发访问令牌。
基本流程（如下图所示）：
1. 客户端请求 RO 的授权（包含资源路径、操作类型、客户端身份等）。
2. RO 批准授权，向客户端返回“授权证据”（通常由 AS 提供审批界面）。
3. 客户端向 AS 换取“访问令牌”（提交授权证据与客户端凭证）。
4. AS 验证通过后签发访问令牌（如 bearer 类型）。
5. 客户端携令牌访问 RS 资源（令牌有效期内可重复使用）。
6. RS 验证令牌有效性（真伪、权限、有效期）后提供服务。

本章小结

SOA 是现代主导架构，Web Services（SOAP）与 REST（JSON）均广泛应用
架构演进：SOA (重型/SOAP) $\rightarrow$ REST (轻量) $\rightarrow$ 微服务 (细粒度)。
微服务降低维护与基础设施成本，但安全挑战显著；需从通信安全、身份认证与访问控制三方面构建防护。

第四章可信执行环境

4.1 可信执行环境 (TEE)

定义：由 GlobalPlatform (GP) 提出，是主处理器上的一个安全区域，保证代码和数据的安全性、机密性及完整性。
主要特征：与移动 OS 并行存在，运行可信应用（TA），可访问主处理器和内存全部功能，通过硬件隔离免受其他应用影响。
核心目标：平台身份证明（远程证明）、数据安全存储（存储隔离、密封存储）、安全 I/O、系统资源完整性保障；
启动过程：
主要用途：风险管理、数字版权管理、电子商务信任建立、安全监测与应急响应。
支持 TEE 的嵌入式硬件技术包括：AMD 的 PSP 处理器、ARM 的 TrustZone 技术、Intel x86-64 的 SGX 扩展、MIPS 的虚拟化技术。
Rich OS 、 TEE 和 SE 的位置：
三种环境的安全和特征的比较：
与 Rich OS、SE 的对比：Rich OS 作为丰富环境是很容易受到攻击的，而 SE 虽然很难遭到攻击但是使用很有局限性，对 Rich OS 的性能和 SE 的安全， TEE 在两者间进行了折中。

对比维度	Rich OS（丰富操作系统）	TEE（可信执行环境）	SE（安全元件）
应用下载控制	用户控制	鉴权进程控制	鉴权进程控制
应用代码要求	无需校验和认证	授权前校验认证，下载时授权检查	授权前校验认证，下载时授权检查
认证强度	不认证	认证	强认证
OS 内核 / 驱动 / 库创建	灵活快速	安全快速	安全
API 丰富度	丰富	受限	严格受限
与 Rich OS 数据传输速度	非常快	非常快	慢
抗未授权软件攻击	依赖 OS 内部保护（未认证）	硬件 + 认证 OS 保护	外部软件 + 硬件 + 认证 OS 保护
抗外部硬件攻击	无保护，有限回滚	TEE + 主机硬件特征保护	SE 强保护（不保护主机）
成本	仅软件，无额外开支	软硬件结合，较低额外开销	软件 + 抗干扰硬件，高额外开销
安全级别	低	中	高

4.2 ARM TrustZone

将软硬件资源划分为安全世界（Secure World，处理敏感操作如指纹识别、密码处理）和非安全世界（Normal World，运行用户 OS 和普通应用），通过 Monitor Mode（监控模式）实现切换。

核心设计与原理

总线设计：AMBA3 AXI 总线增加 NS（Non-Secure）控制位，**ARPROT [1]（读操作）**和 AWPROT [1]（写操作），低电平为安全操作，高电平为非安全操作，总线解析模块验证操作合法性；
CPU 设计：

处理器核虚拟化：每个物理核虚拟为安全核（运行安全世界代码）和非安全核（运行非安全世界代码），基于时间片轮流占用物理核；
内存管理：安全世界和非安全世界各有虚拟 MMU，共享 TLB 和 Cache，通过 NS 位标识归属，切换时无需刷新，提升效率；
中断模型：
- 三套异常向量表：非安全世界、安全世界、Monitor 模式，基地址可通过 VBAR 寄存器修改；
- 中断配置：IRQ(Interrupt Request) 作为非安全世界中断源，FIQ(Fast Interrupt Request) 作为安全世界中断源，兼顾兼容性和安全性；
系统模式切换：
- 切换路径：非安全世界→Monitor Mode→安全世界（不可直接切换），安全世界可通过设置 NS 位跳转至非安全世界（建议在 Monitor Mode 中操作）；
- Monitor Mode 功能：保存当前世界状态，恢复下一个世界状态，实现模式间 CPU 状态切换。

隔离机制

内存隔离：通过 TZASC（TrustZone 地址空间控制器）划分外部 DDR 为安全 / 非安全区域，TZMA（TrustZone 内存适配器）隔离片上 ROM 和 SRAM；
外设隔离：APB 总线设备通过 AXI-to-APB bridge 连接，由 TZPC（TrustZone 保护控制器）提供 NS 控制信号，外设安全特性可动态配置（如键盘输入密码时切换为安全设备）。

4.3 Intel SGX (Software Guard Extensions)

定义：Intel 对 IA 架构的扩展，通过创建 enclave（可信执行容器）保护敏感代码和数据，即使 OS 或虚拟机监控器也无法访问 enclave 内容；
与 TrustZone 的区别：TrustZone 将 CPU 划分为两个隔离环境，SGX 一个 CPU 可运行多个 enclave，支持并发执行；
安全边界：仅包含 CPU 和 enclave 自身，通过硬件机制保障机密性和完整性。
原理：在原有架构基础上增加指令集和内存访问机制，在内存中划分 EPC（Enclave Page Cache），enclave 映射至该区域并由内存加密引擎（MEE）加密，仅进入 CPU 时解密
SGX的远端验证

enclave（安全容器）特征：
- 包含独立代码和数据，提供机密性和完整性保护；
- 具有可控入口点，支持多线程，对应用程序内存拥有最高访问权限；
- 加载的代码和数据需被度量，受 SGX 硬件保护免受外部访问；
优势、不足与开发环境
1. 优势：
  - 内存加密保护运行态安全，提升内存泄漏攻击难度；
  - 可信计算基缩小至 CPU，减少系统攻击风险；
  - 支持虚拟化和容器技术，可用性强；
2. 不足：
  - 无法抵御侧信道攻击；
  - enclave 可用内存小，页面换入换出时系统开销大；
  - 大型程序改造难度高，编程成本高；
3. 开发环境：SGX SDK 包含 API、函数库、文档、样本代码和工具，支持 C/C++ 开发，提供 Microsoft Visual Studio 插件，兼容标准开发工具。

本章小结

TEE 填补了 Rich OS 与 SE 之间的空白，提供较强的安全隔离与较好的性能。
ARM TrustZone 通过“双世界”隔离实现移动端安全；Intel SGX 通过内存加密与 Enclave 机制实现 PC/服务器端安全。

第五章大数据处理与存储及其安全隐私

5.1 云计算基础

服务模式：

服务模式	定义	典型应用
SaaS（软件即服务）	开发商统一部署应用软件，用户按需订阅，通过互联网访问，无需维护	Salesforce Sales Cloud、Office Online、在线财务系统
PaaS（平台即服务）	提供应用开发、测试、托管的完整平台，面向开发者	Google App Engine、微软 Azure、Salesforce Force.com
IaaS（基础设施即服务）	提供服务器、存储、网络等硬件及相关软件，为底层计算资源服务	亚马逊 AWS、阿里云、腾讯云、天翼云

核心技术：Google MapReduce, Hadoop 开源系统。
部署方式：

公有云：由服务商运营，多用户共享基础设施，成本低，隐私安全风险较高；
私有云：企业自建自用，隐私安全性最好，建设成本高，支持动态灵活的基础设施；
行业云：由行业主导组织维护，向内部或相关组织提供服务，安全性与政策遵从性高于公有云；
混合云：组合两种及以上云模式，保持独立且互联互通，平衡安全性与投资（如核心应用存私有云，对外服务存公有云）。

5.2 核心处理框架

谷歌 MapReduce

提出背景：2004 年 OSDI 会议发布，为大规模数据批处理设计，是谷歌云计算核心技术之一；
计算模型：以 Key/Value 为输入，通过 Map（按 Key 划分数据）和 Reduce（聚合相同 Key 数据）两个函数实现并行计算；
核心优势：封装分布式细节（伸缩性、容错性），开发者仅需关注算法逻辑；
应用场景：分布式排序、词频统计、网页倒排索引、PageRank 算法、DNA 序列分析等。

开源系统 Hadoop

起源：由 Doug Cutting 基于谷歌技术论文开发，为开源大数据分析通用平台；
核心组件：HDFS（分布式文件系统）、MapReduce（并行计算引擎）、HBase（列式数据库）、Hive（数据仓库）、Zookeeper（协同工作系统）等；
与谷歌技术对应关系：HDFS 对应 GFS、MapReduce 对应谷歌 MapReduce、HBase 对应 BigTable、Zookeeper 对应 Chubby。

5.3 安全机制：Sentry

定位：Hadoop 开源组件，提供细粒度、基于角色的授权与多租户管理；
核心价值：支持存储敏感数据、扩大数据访问权限、适配多用户场景、符合合规要求（SOX、PCI 等）；
访问控制：支持服务器、数据库、表、列、URL 级别的细粒度权限控制，可通过视图屏蔽敏感数据；
授权模型：基于 RBAC（角色访问控制），权限绑定角色，角色关联用户组，统一通过 Kerberos 实现安全认证；
核心组件：Binding（对接不同查询引擎，接管授权）、Policy Engine（权限匹配判定）、Policy Provider（读取预设权限规则）。

5.4 同态加密 (Homomorphic Encryption)

核心问题：解决密文数据的计算难题，使云端无需解密即可处理数据，避免明文泄露；
定义：设加密操作 E，对明文操作 f，存在 F 使得 F (E (m))=E (f (m))，则 E 为 f 的同态加密算法；
发展历程：RSA 支持乘法同态、Paillier 支持加法同态，2009 年 IBM 提出全同态加密算法（仍存在计算效率问题）；
应用场景：不可信设备上的密文计算，如云端编译、格式转换、数据统计等。

5.5 私有信息检索 (PIR)

定义：用户在不泄露查询信息（身份、内容）的前提下，完成数据库查询；
应用场景：疾病治疗查询、股票信息查询、定位服务等隐私敏感场景；
解决方案：信息论 PIR（多数据库副本 + 编码隐藏查询）、计算性 PIR（基于数学困难假设，阻止多项式时间内破解查询信息）。

5.6 虚拟化技术及其安全（未标亮）

5.6.1 虚拟化定义与分类

本质：抽象计算机资源，使用户以统一方式访问，不受物理配置限制；
分类：服务器虚拟化（虚拟多台隔离虚拟机）、存储虚拟化（统一整合存储资源）、应用虚拟化（解除应用与软硬件耦合）、平台虚拟化（提供统一开发接口）、桌面虚拟化（桌面环境与终端解耦）。

5.6.2 虚拟机技术

核心组件：虚拟机监控器（VMM/Hypervisor），分为 Type-1（直接运行在裸机）和 Type-2（介于宿主 OS 与硬件之间）；
虚拟机（Guest-OS）：具备完整系统资源（处理器、内存、网络设备等），与物理服务器运行逻辑一致，支持多 OS 并发隔离运行；
安全风险：同一物理机上的虚拟机存在数据泄露风险（如 Intel Meltdown、Spectre 漏洞，可导致跨虚拟机信息窃取）；
防护措施：内核页表隔离（KPTI），分离内核与用户进程内存，代价是系统调用开销增加。

5.6.3 容器技术（以 Docker 为例）

本质：操作系统级虚拟化，复用本地主机 OS，比虚拟机更轻量；
核心概念：
- 镜像（Images）：文件层次结构 + 运行元数据，Dockerfile 指令构建；
- 容器（Container）：镜像的运行实例，隔离且安全，可启动、停止、删除；
- 仓库（Repositories）：集中存储镜像，分公有（如 Docker Hub）和私有仓库；
核心优势：资源隔离、环境一致、轻量化、“一次构建，随处使用”；
安全防护：
- 攻击风险：Docker API 滥用可导致远程代码执行、恶意软件隐藏；
- 防护措施：基于角色的访问控制（RBAC）、加密秘密存储、TLS 隧道传输秘密、沙箱容器（如 gVisor）增强隔离。

5.6.4 基于虚拟机的入侵分析

传统日志缺陷：依赖可能被篡改的 OS，日志信息不完备；
ReVirt 系统：将 Guest OS 置于虚拟机中，VMM 在独立域记录日志，避免日志篡改，完整记录非确定性事件（如中断、用户输入），支持入侵行为重放分析。

5.7 安全多方计算 (MPC)

定义：多个参与方，每一个参与方拥有一个秘密信息，他们希望利用这些秘密信息作为输入，共同计算一个函数。安全多方计算是无可信第三方的保护隐私计算协议。
模型：
- 半诚实模型：如果所有参与者都是诚实的或者半诚实的，称此模型为半诚实模型，其中的攻击者是被动的。
- 恶意模型：存在恶意参与者的模型称为恶意模型，其中的攻击者是主动的。
经典案例：百万富翁问题（比谁更有钱但不透露具体金额）、平均工资问题。

5.8 大数据存储安全

GFS（Google 文件系统）
- 定位：谷歌分布式文件系统，为云计算提供海量存储，非开源；
- 设计特点：采用廉价商用机器，软件容错，将服务器故障视为正常现象，多维度保障数据安全与服务连续性；
- 影响：启发开源 HDFS，推动后续分布式文件系统发展。
BigTable
- 定位：建立在 GFS 之上的结构化数据存储架构，谷歌多项服务（地图、Youtube、Gmail）的底层存储；
- 数据模型：分布式多维表格，通过行关键字、列关键字、时间戳索引，数据均视为字符串，需用户自行定义结构。
系统：GFS (Google分布式文件系统), BigTable（基于GFS的分布式数据库，列式存储）, Dropbox 架构。
数据完整性机制：
- 核心角色：用户（数据所有者）、云服务器（存储方）、第三方审计者（TPA，代用户完成审计）；
- 潜在风险：外部攻击破坏数据、云服务器为节省成本删除闲置数据或隐瞒数据损坏；
- 解决方案：POR（Proofs of Retrievability数据可恢复性证明），可有效识别数据损坏并恢复损坏文件。
数据去重：
- MLE (Message-Locked Encryption)：消息锁定加密，实现密文去重。
- PoW (Proof of Ownership)：拥有权证明，防止攻击者通过哈希值“盗取”文件访问权。

本章小结

云安全核心在于“数据不可见但可计算”（同态加密）与“查询不可知”（PIR）。
存储安全关注完整性审计（POR/PDP）与高效存储（去重/MLE）。

第六章大数据共享及其安全隐私

6.1 隐私概念与度量

定义：不受干扰的权利（布兰代斯）。
分类：身份隐私、属性隐私、社交隐私等。
量化度量：用 “披露风险” 描述隐私保护效果，即攻击者借助背景知识揭露敏感数据的概率；完美隐私（披露风险为 0）仅存在于特定假设场景，现实中难以实现。

6.2 数据匿名化技术

核心目标：隐匿数据主体标识，平衡数据可用性与隐私保护。
操作：
- 抑制 (Suppression)：隐去特定属性值。
- 泛化 (Generalization)：将具体值替换为更宽泛的区间（如精确年龄 -> 年龄段）。
- 聚合 (Aggregation)：统计汇总。
发布 - 遗忘模型：数据管理员匿名化处理后发布数据，不再追踪后续流转，但该模型存在明显缺陷，易被反匿名化突破。（识别身份信息-抑制-泛化-聚合）

6.3 隐私保护模型

K - 匿名模型：通过泛化 / 抑制使每个准标识符（QID，如邮编 + 生日 + 性别）组至少包含 K 条记录，抵御记录链接攻击，但无法防范属性链接攻击。
L - 多样性模型：弥补 K - 匿名缺陷，要求每个 QID 组的敏感属性至少包含 L 个不同值，防止攻击者通过群组敏感值占比推导个体隐私。
T - 相近模型：进一步要求 QID 组中敏感属性的分布与原始数据分布距离不超过阈值 T，避免敏感值过于集中或相近导致的隐私泄露。
局限性：此类模型依赖对攻击者背景知识的假设，现实中易被突破，陷入 “模型提出 - 被攻破” 的循环。

6.4 差分隐私 (Differential Privacy)

优势：不依赖攻击者背景知识假设，即使攻击者知晓除一条记录外的所有数据，仍能提供隐私保护，且具备严谨的数学理论支撑。
原理：通过添加噪声（如拉普拉斯噪声）来掩盖个体影响，保证攻击者无法判断特定个体是否在数据集中。

本章小结

传统匿名模型（k-匿名 -> l-多样性 -> t-相近）逐步修补漏洞，但难以抵御背景知识攻击。
差分隐私提供了数学上可证明的隐私保障，是当前主流标准。

第七章大数据算法及其安全

知识构建四要素：假设（明确方向）、模型（确定计算方法）、实践（验证修正）、理论（推广应用），算法设计需围绕四要素逐步完善。

7.1 大数据算法基础

搜索引擎核心算法（标亮）
- TF/IDF 模型：用于计算查询与网页的相关性，核心是 “词频（TF）× 逆文本频率（IDF）” 加权求和。TF 为关键词在网页中的归一化出现频率（避免长网页占优），IDF 反映关键词稀缺性（公式为 lg (D/Dw)，D 为总网页数，Dw 为含该关键词的网页数）。
- PageRank 算法：评估网页质量，基于 “数量假设（入链越多越重要）” 和 “质量假设（高权重页面入链更具价值）”，通过递归迭代计算网页得分，最终收敛至真实值，需结合稀疏矩阵技巧降低计算量。
协同过滤推荐算法
- 传统方法：
  - 基于用户：通过 KNN 找到相似偏好用户，推荐邻居喜欢的物品，但存在数据稀疏性和扩展性差的问题；
  - 聚类模型：将相似用户归为群组，基于群组偏好推荐，粒度难平衡（粗粒度准确率低，细粒度计算量大）；
  - 内容搜索法：根据商品属性构造查询条件推荐，适用于用户购买量少的场景。
- 改进方案（亚马逊 Item-based 算法）：预先计算物品间相似度（基于用户历史行为），推荐与用户喜欢物品相似的商品，解决稀疏性和扩展性问题，支持实时响应。
机器学习算法
- 定义：系统通过经验自动改进性能，根据样本集推算世界模型，核心是泛化能力（对未知样本的判断能力）。
- 三要素：一致性假设（样本集与真实世界性质一致）、样本空间划分（寻找决策分界面）、泛化能力。
- 分类与代表算法：
  - 监督学习（有标签数据训练）：决策树、K - 近邻、逻辑回归、SVM；
  - 无监督学习（无标签数据找规律）：关联算法、K - 均值聚类；
  - 强化学习（试错 + 奖励机制）：马尔可夫决策过程、蒙特卡洛算法；
  - 半监督学习（混合标签与无标签数据）：GANs（生成式对抗网络）。
- 通用步骤：数据划分（训练 / 验证 / 测试）→数据建模→模型训练→测试评估→实际应用→调优迭代。
众包技术
- 定义：协调大量不固定参与者完成 “微工作”，解决单个人或软件难以处理的问题（如外卖配送、数据标注）。
- 核心要素：请求者（发布任务）、工人（执行任务）、智能任务（HITs），需解决平台选择、激励机制、质量控制、任务管理等问题。

7.2 对大数据算法的攻击

7.2.1 推荐攻击

攻击目标：干扰推荐系统（如协同过滤算法）的预测结果，分为 “推攻击”（提升目标项目推荐频率）和 “核攻击”（降低目标项目推荐频率）。
攻击方式：注入虚假用户（托攻击），通过模仿真实用户偏好成为目标用户的 “近邻”，或关联目标项目与流行项目，篡改项目相似度矩阵，引导推荐结果偏移。
示例：攻击者为提升项目 6 的推荐率，注入 3 个虚假用户，模仿 User 的评分偏好并给项目 6 打满分，使推荐系统误判 User 对项目 6 感兴趣。

7.2.2 搜索引擎优化（SEO）作弊

攻击目的：利用搜索引擎漏洞提高网页排名，获取更多流量。
常见手段：重复关键词（隐藏式罗列）、买卖链接（批量创建垃圾网站引流）、雇佣水军注入垃圾评论（植入目标链接）。
反作弊逻辑：将作弊行为视为 “噪声”，通过解卷积算法消除 —— 作弊手段具有非随机性和时间相关性，采集一段时间的作弊特征后可精准识别并还原真实排名。

7.2.3 诱导分类器错误分类

攻击场景：针对安全领域的机器学习分类器（如恶意软件检测、垃圾邮件分类）。
攻击原理：利用分类器依赖的 “非本质特征”（如恶意 PDF 文件尺寸小），通过简单修改（如植入无效内容增大文件尺寸、添加 4 行代码）使恶意样本逃逸检测。
案例：修改 500 个恶意 PDF 样本后，PDFrate 和 Hidost 分类器均判为无害；Gmail 恶意软件分类器的逃逸率接近 50%。

7.2.4 诱骗视觉分类算法

攻击方式：在物理世界中对目标物体进行轻微修改（如在停车标志上加贴纸、喷漆），使深度神经网络分类器产生误判（如将 “停止标志” 识别为 “限速标志”）。
核心特点：对抗样本的扰动微小，人类视觉难以察觉，但能突破算法分类边界。

7.2.5 对抗攻击核心技术

定义：通过对原始样本添加特定扰动，构造对抗样本，使模型产生错误分类，根源是模型训练样本覆盖不全，导致模型决策边界与真实边界存在差异。
典型攻击方法：
- 快速梯度攻击（FGSM）：白盒攻击，沿模型梯度最大方向添加全局微小扰动，效率高，支持源 / 目标误分类；
- 雅克比映射攻击（JSMA）：仅扰动对分类影响大的像素点，以最少修改实现攻击；
- 深度欺骗攻击：迭代式扰动样本，逐步推向模型决策边界另一侧，属于白盒攻击；
- 边界攻击：黑盒攻击，仅需模型分类输出，先找到对抗样本，再向原始样本方向逼近，保持对抗性的同时最小化扰动。

章节小结

核心算法：涵盖搜索引擎（TF/IDF 相关性计算、PageRank 网页质量评估）、协同过滤推荐（含亚马逊 Item-based 改进方案）、机器学习（四类学习模式及通用训练流程），以及众包技术，核心是通过建模提取数据规律并实现泛化应用。
安全风险：主要包括推荐攻击（注入虚假用户）、SEO 作弊（篡改排名）、分类器诱导错误、视觉算法诱骗、对抗攻击（构造对抗样本），攻击核心是利用算法漏洞或特征缺陷干扰决策结果。

第八章大数据服务的认证与访问控制

8.1 身份认证

定义与作用：验证用户身份，确定其是否具备资源访问权限，分为消息认证（保障信息完整性、不可否认性）和用户身份认证（鉴别用户身份），涵盖识别（确认身份）与验证（确认合法性）两个环节。
系统组成：包括认证服务器、客户端、认证设备，通过单向 / 双向认证协议实现，主流为 AAA 认证系统（认证 + 授权 + 审计）。
认证即分类：利用机器学习分析用户行为特征（击键、步态）进行持续认证。
基本认证逻辑：基于 “你有什么（物件）、你知道什么（信息）、你是谁（体貌特征）” 三类核心维度设计。
分类器式认证：将身份认证视为机器学习分类器，融合 IP 地址、地理位置、登录习惯等多维度隐式信号，输出访问可能性（实数值），需离散化为 0/1 决策，存在错误接受 / 拒绝风险。
常用认证方式及特点

认证方式	核心原理	优势	风险与不足
静态密码	用户名 + 固定密码验证	简单易用、成本低	易遭受字典攻击、窃听、重放攻击，安全性弱
动态口令	基于不确定因子生成一次性口令（短信验证码、动态令牌）	一次一密，安全性高于静态密码	短信可能被拦截、令牌数据库泄露风险
USB Key 认证	软硬件结合，内置密钥 / 数字证书，支持冲击 / 响应或 PKI 模式	双因素认证，安全性强	依赖硬件设备，丢失易导致权限风险
CA 认证	由 CA 机构签发数字证书（X.509 等标准），验证持有者合法性	适用于多场景，可保障交易 / 通信安全	证书管理复杂，需防止伪造篡改
生物识别	基于生理特征（指纹、人脸）或行为特征，需活体检测	唯一性强，用户体验好	生物特征泄露后无法更改，易被假体攻击
多因子认证	组合两种及以上认证方式（如 “静态密码 + 动态口令”“生物识别 + USB Key”“密码 + 生物特征 + 地理位置”）	多重验证，安全性远高于单一认证方式，攻击难度极大	流程相对繁琐，依赖多种认证介质 / 条件，易因某一环节故障影响使用

8.2 访问控制

传统模式：DAC (自主), MAC (强制), RBAC (基于角色)。
云环境/细粒度：
- ABAC (基于属性)：基于用户、资源、环境属性制定策略，支持细粒度控制。
- FE (函数加密)：支持细粒度访问控制的加密原语。在保障数据机密性的同时，支持灵活的加密数据访问控制。
CryptDB 是 MIT 推出的开源加密数据库查询代理工具，适配 MySQL，以 “应用 - 代理 - 数据库” 架构实现明文与应用交互、密文与数据库交互，支持加密数据的简单操作，保障数据存储安全，已被 Google、SAP 等企业借鉴应用。

第九章大数据采集及其安全隐私

9.1 匿名通信

框架三要素：匿名属性、敌手能力、网络类型。
- 匿名属性：不可辨识性（无法识别用户身份与行为）、不可关联性（操作与主体无关联）、不可观测性（无法分辨特定收发事件）；
- 网络类型划分
  1. 路径拓扑：瀑布型（固定通信路径）、自由型（任意长度路径，匿名性更强）；
  2. 路由机制：单播（主流选择，兼顾效率与部署难度）、组播、广播、任意播；
  3. 路径类型：简单路径（无循环，中继节点唯一）、复杂路径（可循环，中继节点可重复）。

技术方案：

Mix 网络：通过混合节点打乱消息顺序。
洋葱路由 (Onion Routing / Tor)：多层加密，逐跳解密，中间节点只知前后跳，不知源与宿。
泛洪算法：广播消息以隐藏接收者。

技术类型	核心原理	特点
基于 Mix 算法	单个或瀑布型 Mix 节点，接收加密数据后解密、重序、增加冗余，再转发	匿名性高，时延高，不适用于实时通信
基于洋葱路由	源路由技术，层层加密封装数据，中间节点仅解密获取下一跳地址并剥层	双向实时通信，效率低、扩展性差
基于泛洪算法	基于 flooding/epidemic 算法，路径不固定，中间节点未知收发方	仍处实验室阶段，带宽需求大，稳定性不足

9.2 HTTPS 核心特性

定义：HTTP 的安全版，基于 SSL/TLS 构建，解决 HTTP 明文传输的劫持、数据泄露问题；

关键问题：

资源消耗：服务器 CPU 负荷、内存占用、网络流量略有增加（Gmail 案例显示增幅较低）；
时延：新连接需 4 个 RTT（DNS 查询 + TCP 握手 + TLS 握手 + HTTP 连接），会话恢复可降至 3 个 RTT，TLS 1.3 支持 0-RTT 会话恢复；
证书成本：需部署 SSL 安全证书，增加运营成本。

9.3 SSL/TLS 安全风险

典型漏洞：“心脏流血”（OpenSSL 心跳扩展未做长度检查，导致内存泄露）；

其他攻击：CBC 填充模式攻击（Lucky Thirteen、POODLE 等）、RC4 加密漏洞、密钥交换与会话恢复缺陷攻击。

9.4 端到端加密 (E2EE)

原理：发送方本地加密、接收方本地解密，传输媒介（如谷歌、微软服务器）仅能访问密文，无法获取明文；

典型应用：PGP 电子邮件加密、加密即时通信软件；

局限：易用性差，与主流通讯软件相比功能有限，用户接受度低。

CISCN & CCB 2025 部分逆向方向 WP

Mon, 29 Dec 2025 00:14:18 +0800

某人本想在2025年12月第三个周末爆肝一个web安全登录demo，结果不仅搞到周一凌晨，他自己还忘了成功登录时的时间戳了，你能帮他找回来吗？

提交格式为flag{时间戳正确时的check值}。是一个大括号内为一个32位长的小写十六进制字符串。

附件：https://pan.baidu.com/share/init?surl=HbRVmm1xNPqsK4oytlt5zg password：GAME

打开附件后，发现核心文件为 Wasm 格式（WebAssembly），首先尝试使用wabt工具集进行逆向还原，分别生成了wasm.wat（文本格式 Wasm）和wasm.c（还原的 C 语言代码）。但还原后的.c文件存在大量未定义标识符，无法直接编译运行，且代码量庞大，逐行分析效率极低。

随后注意到附件中存在release.wasm.map文件（Wasm 源码映射文件），该文件可直接转换为 JS 格式进行分析，通过映射文件快速定位到核心认证逻辑代码，大幅降低逆向成本。

通过release.wasm.map转换后的 JS 代码，提取到核心登录认证函数authenticate，其完整流程如下：

/**
 * 执行完整的登录认证流程：
 * 1. 对密码进行Base64编码
 * 2. 获取当前时间戳
 * 3. 构建JSON消息
 * 4. 使用HMAC-SHA256进行签名
 * 5. 返回最终的JSON字符串
*/
export function authenticate(username: string, password: string): string {
  // 1. Base64编码密码
  const encodedPassword = encode(stringToUint8Array(password));
  //console.log(encodedPassword);
  // 2. 获取当前时间戳（毫秒）
  const timestamp = Date.now().toString();
  //console.log(timestamp);
  // 3. 构建原始JSON消息
  const message = `{\"username\":\"${username}\",\"password\":\"${encodedPassword}\"}`;
  //"username":"admin","password":""}
  //console.log(message);
  // 4. 使用HMAC-SHA256签名
  const signature = signMessage(message, timestamp);
  //console.log(signature);
  // 5. 构建最终的JSON消息
  const finalMessage = `{\"username\":\"${username}\",\"password\":\"${encodedPassword}\",\"signature\":\"${signature}\"}`;
  
  return finalMessage;
  //return \"ok\";
}

function stringToUint8Array(str: string): Uint8Array {
  const arr = new Uint8Array(str.length);
  for (let i = 0; i < str.length; ++i) {
    arr[i] = str.charCodeAt(i);
  }
  return arr;
}

@inline
function fill(ptr: usize, value: u8, length: u32): void {
  const finalPtr = ptr + length;
  while(ptr < finalPtr) {
    store<u8>(ptr, value);
    ptr++;
  }
}

@inline
function ArrayBufferToUint8Array(input: ArrayBuffer): Uint8Array{
  const res = new Uint8Array(input.byteLength);
  const inputPtr = changetype<usize>(input)
  for (let i = 0; i < input.byteLength; ++i) {
    res[i] = load<u8>(inputPtr + i);
  }
  return res;
} 
/**
 * 使用HMAC-SHA256算法对消息进行签名
 * @param message 待签名的消息
 * @param secret 密钥（时间戳）
 * @returns 签名后的Base64字符串
*/
function signMessage(message: string, secret: string): string {
  const messageBytes = String.UTF8.encode(message);
  const secretBytes = String.UTF8.encode(secret);

  const signatureBytes = hmacSHA256(secretBytes,messageBytes);
  
  return encode(ArrayBufferToUint8Array(signatureBytes));
}    

// 实现 HMAC-SHA256 函数
function hmacSHA256(key: ArrayBuffer, message: ArrayBuffer): ArrayBuffer {
  const blockSize = 64; // SHA256 的块大小为 64 字节

  // 填充密钥
  const keyPtr = changetype<usize>(key);
  const paddedKey = new ArrayBuffer(blockSize);
  const paddedKeyPtr = changetype<usize>(paddedKey);
  if (key.byteLength > blockSize) {
    // 如果密钥长度超过块大小，对密钥进行哈希处理
      init();
      update(keyPtr, key.byteLength);
      final(paddedKeyPtr);
  }else{
    // 填充密钥到块大小
      memory.copy(paddedKeyPtr, keyPtr, key.byteLength);
      fill(paddedKeyPtr + key.byteLength, 0, blockSize - key.byteLength)
  }
  //console.log(ArrayBufferToUint8Array(paddedKey).toString());

  // 计算 ipad 和 opad
  const ipad = new ArrayBuffer(blockSize);
  const opad = new ArrayBuffer(blockSize);
  const ipadPtr = changetype<usize>(ipad);
  const opadPtr = changetype<usize>(opad);
  for (let i = 0; i < blockSize; i++) {
      store<u8>(ipadPtr + i , load<u8>(paddedKeyPtr + i) ^ 0x76);
      store<u8>(opadPtr + i , load<u8>(paddedKeyPtr + i) ^ 0x3C);
  }
  //console.log(ArrayBufferToUint8Array(ipad).toString());
  //console.log(ArrayBufferToUint8Array(opad).toString());

  // 计算 innerHash
  const innerInput = new ArrayBuffer(ipad.byteLength + message.byteLength);
  const innerInputPtr = changetype<usize>(innerInput);
  const messagePtr = changetype<usize>(message)
  memory.copy(innerInputPtr, ipadPtr, ipad.byteLength);
  memory.copy(innerInputPtr + ipad.byteLength, messagePtr, message.byteLength);
  //console.log(ArrayBufferToUint8Array(innerInput).toString());

  init();
  update(innerInputPtr,innerInput.byteLength);
  //update(ipadPtr,ipad.byteLength);
  //update(messagePtr,message.byteLength);
  const innerHash = new ArrayBuffer(32);
  const innerHashPtr = changetype<usize>(innerHash);
  final(innerHashPtr);
  //console.log(ArrayBufferToUint8Array(innerHash).toString());

  // 计算 outerHash
  const outerInput = new ArrayBuffer(opad.byteLength + innerHash.byteLength);
  const outerInputPtr = changetype<usize>(outerInput);
  memory.copy(outerInputPtr, innerHashPtr, innerHash.byteLength);
  memory.copy(outerInputPtr + innerHash.byteLength, opadPtr, opad.byteLength);
  //console.log(ArrayBufferToUint8Array(outerInput).toString());

  init();
  update(outerInputPtr,outerInput.byteLength);
  //update(opadPtr,opad.byteLength);
  //update(innerHashPtr,innerHash.byteLength);
  const outerHash = new ArrayBuffer(32);
  const outerHashPtr = changetype<usize>(outerHash);
  final(outerHashPtr);
  //console.log(ArrayBufferToUint8Array(outerHash).toString());


  return outerHash;
}

通过搜索authenticate相关调用，发现了release.js和index.html中的代码

  const memory = exports.memory || imports.env.memory;
  const adaptedExports = Object.setPrototypeOf({
    authenticate(username, password) {
      // assembly/index/authenticate(~lib/string/String, ~lib/string/String) => ~lib/string/String
      username = __retain(__lowerString(username) || __notnull());
      password = __lowerString(password) || __notnull();
      try {
        return __liftString(exports.authenticate(username, password) >>> 0);
      } finally {
        __release(username);
      }
    },
  }, exports);

和

import { authenticate } from "./build/release.js";
...
// 调用 WASM 中的 authenticate 函数
const authResult = authenticate(username, password);
const authData = JSON.parse(authResult);
...
simulateServerRequest(authData)
              .then(response => {
                if (response.success) {
                  // 登录成功
                  alert('登录成功！');
...
function simulateServerRequest(data) {
          return new Promise(resolve => {
            // 模拟网络延迟
            setTimeout(() => {
              // 实际应用中这里应该是真实的 API 请求
              // 这里仅作演示，使用本地判断
              const check = CryptoJS.MD5(JSON.stringify(data)).toString(CryptoJS.enc.Hex);
              console.log('Debug - Data sent to server:', data);
              console.log('Debug - Check value:', check);
              if (check.startsWith("ccaf33e3512e31f3")){
                resolve({ success: true });
....

release.js中对authenticate函数进行了 Wasm 内存管理封装，确保 JS 与 Wasm 之间的字符串参数正常传递；
index.html中明确了登录成功的判断条件：将authenticate返回的 JSON 数据标准化后（JSON.stringify(JSON.parse(authResult))），通过CryptoJS.MD5计算得到 32 位十六进制校验值check，该值必须以ccaf33e3512e31f3开头才判定为登录成功。

这里需要注意原本release.js中的hmacSHA256等函数==并非标准的实现==，直接复刻易出现偏差，因此采用JS 脚本直接导入 Wasm 封装函数的方式，复用原始加密逻辑，仅对时间戳进行遍历爆破。（原本爆破时间很长，此处为得到时间戳后的缩短的时间范围）

import { createHash } from "node:crypto";
import { authenticate } from "./build/release.js";
const P = "ccaf33e3512e31f3";
const u = "admin", p = "admin";
const T = (x) => (/^\d+$/.test(x) ? +x : new Date(x).getTime());
const s = T(process.argv[2] ?? "2025-12-22T00:00:00+08:00");
const e = T(process.argv[3] ?? "2025-12-22T01:00:00+08:00");

for (let t = s; t <= e; t++) {
  Date.now = () => t;
  try {
    const authResult = authenticate(u, p);
    const j = JSON.stringify(JSON.parse(authResult));
    const h = createHash("md5").update(j).digest("hex");
    if (h.startsWith(P)) {
      console.log(`MD5哈希值：${h}`);
      console.log(`正确时间戳（毫秒）：${t}`);
      console.log(`标准化JSON：${j}`);
      console.log(`对应日期：${new Date(t).toLocaleString()}`);
      break;
    }
  } catch (err) {
    continue;
  }
}

babygame

请找出隐藏的Flag。请注意只有收集了所有的金币，才能验证flag。

附件：https://pan.baidu.com/share/init?surl=KI0XixtMhXvUFap3Ey4c6g password：GAME

使用反编译工具GDRE_tools-v2.4.0-windows 得到资源，可以查看代码

如果没有注意到AB代换，通关游戏也能获得正确的密钥，然后直接使用cyberchef的aes解密就能得到flag

参考学习文献：

JavaScript Source Map 详解

Webassembly逆向手法

wasm逆向

调试 C/C++ WebAssembly | Chrome DevTools | Chrome for Developers

https://github.com/WebAssembly/wabt

数字签名体制学习笔记

Wed, 24 Dec 2025 21:17:41 +0800

数字签名体制学习笔记

1. 概述 (Overview)

数字签名（Digital Signature）是公钥密码学的核心原语，通过“私钥签名、公钥验证”的机制，模拟物理手写签名的法律效力，核心作用是保障消息的完整性（防篡改）、来源认证（防伪造）和不可否认性（防抵赖），是电子政务、电子商务、区块链等领域的安全基石。

1.1 基本模型

一个数字签名方案通常由三个算法组成 $(Gen, Sign, Verify)$：

密钥生成 (Key Generation): $Gen(1^\lambda) \to (pk, sk)$。输入安全参数 $\lambda$，输出公钥 $pk$ 和私钥 $sk$。
签名 (Signing): $Sign(sk, m) \to \sigma$。输入私钥 $sk$ 和消息 $m$，输出签名 $\sigma$。算法通常是概率性的。
验证 (Verification): $Verify(pk, m, \sigma) \to {0, 1}$。输入公钥 $pk$、消息 $m$ 和签名 $\sigma$，输出 1 (有效) 或 0 (无效)。

1.2 安全性定义

最常用的安全定义是 EUF-CMA (Existential Unforgeability under Chosen Message Attack，选择消息攻击下的存在不可伪造性)。

安全游戏 (Security Game)

为什么要引入安全游戏？ 在现代密码学中，“安全”不能只靠直觉。安全游戏通过模拟攻击者 ($\mathcal{A}$) 与挑战者之间的交互，精确地量化了：

攻击者的能力 (例如：可以请求任意消息的签名)。
攻击者的目标 (例如：伪造一个从未见过的消息的签名)。
成功的定义 (例如：验证通过且消息新颖)。

游戏流程如下：

Setup: 挑战者运行 $Gen(1^\lambda)$ 生成 $(pk, sk)$，将 $pk$ 发送给攻击者 $\mathcal{A}$。
Query: $\mathcal{A}$ 可以自适应地请求消息 $m_1, m_2, \dots, m_q$ 的签名。挑战者使用 $sk$ 计算 $\sigma_i = Sign(sk, m_i)$ 并返回给 $\mathcal{A}$。
Forgery: $\mathcal{A}$ 输出一对 $(m^, \sigma^)$。
Win Condition: $\mathcal{A}$ 赢得游戏当且仅当：
- $Verify(pk, m^, \sigma^) = 1$ (签名有效)
- $m^* \notin {m_1, \dots, m_q}$ (消息未被查询过)

若对任意多项式时间攻击者 $\mathcal{A}$，其赢得上述游戏的概率 $Pr[\mathcal{A} \text{ wins}]$ 是关于 $\lambda$ 的可忽略函数（即概率随 $\lambda$ 增大快速趋近于0），则称该数字签名方案是 EUF-CMA 安全的。

与 MAC 的区别

MAC（消息认证码）与数字签名均能提供完整性和来源认证，但核心差异在于“验证方式”和“不可否认性”，具体对比如下：

特性	数字签名 (Digital Signature)	消息认证码 (MAC)
验证密钥	公钥（任何人可验证）	对称密钥（仅持有密钥者可验证）
不可否认性	支持（私钥唯一，签名者无法抵赖）	不支持（收发双方均有密钥，无法区分签名者）
适用场景	开放场景（如互联网通信、电子合同）	封闭场景（如端到端通信、内部数据传输）

2. 经典数字签名方案

2.1 RSA 签名

基于大整数分解困难问题。

教科书式 RSA 签名 (Textbook RSA)

密钥：$N=pq$，$(e, d)$ 满足 $ed \equiv 1 \pmod{\phi(N)}$。$pk=(N, e), sk=d$。
签名：$\sigma = m^d \pmod N$。
验证：检查 $\sigma^e \equiv m \pmod N$。
缺陷：存在乘法同态性 ($\sigma(m_1)\sigma(m_2) = \sigma(m_1m_2)$)，易受伪造攻击。

RSA-PSS签名 (Probabilistic Signature Scheme)

为解决教科书式 RSA 缺陷，PKCS#1 v2.1（RFC 8017）定义了 RSA-PSS（Probabilistic Signature Scheme），引入随机盐值和掩码生成函数（MGF），是目前推荐的 RSA 签名标准。

核心改进：通过“消息哈希+随机填充”破坏同态性，使签名具有随机性（同一消息多次签名结果不同）。
签名流程（简化版）： ① 哈希消息：计算 $h = H(m)$（$H$ 为安全哈希函数，如 SHA-256）； ② 生成盐值：随机选择盐值 $s$（长度与哈希输出一致）； ③ 消息编码：将 $h$、$s$ 拼接后通过 MGF 生成编码 $EM$（确保 $EM < N$）； ④ 生成签名：$\sigma = EM^d \pmod{N}$。
验证流程（简化版）： ① 计算 $\sigma^e \pmod{N}$ 得到 $EM’$； ② 对 $EM’$ 解码，提取盐值 $s’$ 和哈希值 $h’$； ③ 计算 $h = H(m)$，对比 $h$ 与 $h’$，一致则签名有效。
关键特性： ① 安全性：随机预言机模型下，可紧致归约到 RSA 困难问题； ② 实用性：支持任意长度消息，抵抗所有已知攻击； ③ 兼容性：广泛支持于 TLS、SSH、数字证书等场景。

2.2 ElGamal 签名

基于有限域上的离散对数问题 (DLP)：给定有限群 $G$、生成元 $g$ 和元素 $y = g^x$，求解 $x$ 是计算困难的。DLP 家族签名方案因“密钥短、效率高”成为主流，包括 ElGamal、Schnorr、DSA/ECDSA、EdDSA 等。

参数：大素数 $p$，生成元 $g$。私钥 $x \in [1, p-2]$，公钥 $y = g^x \pmod p$。
签名：
1. 选择随机数 $k \in [1, p-2]$，且 $\gcd(k, p-1)=1$（确保 $k$ 存在逆元）。
2. 计算 $r = g^k \pmod p$。
3. 计算 $s = k^{-1}(H(m) - xr) \pmod{p-1}$（$H$ 为哈希函数，$k^{-1}$ 是 $k$ 在模 $p-1$ 下的逆元）。
4. 签名 $\sigma = (r, s)$。
验证：检查 $g^{H(m)} \equiv y^r r^s \pmod p$。
注意：随机数 $k$ 必须保密且不可重用！若 $k$ 泄露或重复使用，攻击者可通过联立方程求解私钥 $x$。

2.3 Schnorr 签名

由 Schnorr 于1989年提出，基于“强离散对数问题”（SDLP），通过 Fiat-Shamir 变换将交互式零知识证明转化为非交互式签名，以“简洁性、高效性”著称，因专利过期后被广泛应用（如 Bitcoin Taproot）。

参数：系统参数：素数阶群 $G$（阶为 $q$，$q$ 为大素数），生成元 $g \in G$；私钥：$x \in [1, q-1]$；公钥：$y = g^x \in G$。
签名：
1. 选择随机数 $k \in [1, q-1]$，计算承诺 $R = g^k \in G$。
2. 计算挑战 $e = H(R | m)$ (将承诺与消息拼接后哈希，绑定消息与承诺)。
3. 计算响应 $s = k + xe \pmod q$。
4. 签名 $\sigma = (e, s)$ 或 $\sigma = (R, s)$（两种表示等价，后者更简洁）。
验证：$\sigma = (e, s)$，计算 $R’ = g^s y^{-e}\pmod{p}$，检查 $H(R’ | m) \stackrel{?}{=} e$。
优点：
- 线性特性：支持多重签名 (Multi-sig) 和聚合签名 (Aggregate Signature)。
- 安全性：在随机预言机模型下证明安全。
- 应用：Bitcoin (BIP-340, Taproot)。

3. 标准化的签名体制

3.1 DSA (Digital Signature Algorithm)

NIST 标准（FIPS 186），1991年发布，是 ElGamal 签名的优化版本，核心改进是“运算在子群上进行”，减少签名长度和运算量。

参数与结构：

$p$：大素数，要求 $2^{L-1} < p < 2^L$，$L$ 早期标准为 $512 \leq L \leq 1024$ 且为 64 的倍数（如 512, 576, …, 1024），新标准支持更大 $L$（如 2048, 3072）。
$q$：$p-1$ 的素因子，$q$ 是 160 位（或更高，取决于 $L$）的素数。
$g$：生成元，$g = h^{(p-1)/q} \pmod p$，其中 $h$ 是 $[2, p-2]$ 内任取的整数，需保证 $g > 1$。
$h$：任意 $2 \leq h \leq p-2$，使 $g$ 满足阶为 $q$。
私钥 $x \in [1, q-1]$，公钥 $y = g^x \pmod p$。

签名流程：

选随机 $k \in [1, q-1]$。
计算 $r = (g^k \pmod p) \pmod q$。
计算 $s = k^{-1}(H(m) + x r) \pmod q$，$H$ 为安全哈希函数（如 SHA-1/SHA-2）。
签名为 $(r, s)$。

验证流程：

计算 $w = s^{-1} \pmod q$。
计算 $u_1 = H(m) w \pmod q$，$u_2 = r w \pmod q$。
计算 $v = ((g^{u_1} y^{u_2}) \pmod p) \pmod q$。
验证 $v \stackrel{?}{=} r$。

补充说明：

$p, q, g$ 的选取保证了安全性和运算效率。
$g$ 的生成方式确保其在模 $p$ 的阶为 $q$ 的子群中。
$k$ 必须随机且不可重用，否则私钥易泄露。
$H$ 通常为 SHA-1（老标准）或 SHA-2（新标准）。
早期标准 $L \in [512, 1024]$，新标准推荐 $L=2048, q=224/256$。
DSA 设计初衷是避开当时的 RSA 专利，兼顾安全与性能。

3.2 ECDSA (Elliptic Curve DSA)

DSA 在椭圆曲线群上的变体（FIPS 186-5），核心优势是“相同安全强度下，密钥和签名长度远短于 RSA/DSA”，是移动设备、区块链、TLS 等场景的主流方案。

优势：相比 RSA/DSA，在相同安全强度下密钥和签名更短。
风险：对随机数 $k$ 极其敏感。
- 若 $k$ 重复使用或可预测，攻击者可通过以下方式求解私钥 $x$：已知 $(r, s_1)$（$m_1$ 的签名）和 $(r, s_2)$（$m_2$ 的签名），联立 $s_1 = k^{-1}(H(m_1) + xr)$ 和 $s_2 = k^{-1}(H(m_2) + xr)$，消去 $k$ 得 $x = (s_2H(m_1) - s_1H(m_2)) \cdot (s_1r - s_2r)^{-1} \pmod{q}$。
- 典型案例：Sony PS3 因 ECDSA 随机数 $k$ 固定，导致私钥泄露。
改进 (RFC 6979)：为了避免随机数生成器 (RNG) 故障带来的灾难性后果，现代实现通常使用确定性 ECDSA。即 $k = HMAC(sk, m)$，确保对同一消息始终生成相同的 $k$，且 $k$ 对攻击者不可预测。
应用：Bitcoin（secp256k1 曲线）、Ethereum、TLS 1.3、iOS/Android 密钥存储。

3.3 EdDSA (Edwards-curve DSA)

基于扭曲爱德华曲线 (Twisted Edwards Curve)，如 Ed25519。

特点：
- 确定性签名：随机数 $k$ 由 $H(sk, m)$ 确定性生成，消除了随机数发生器故障导致的风险。
- 高性能：Ed25519 签名和验证速度极快，且公钥很短 (32 字节)。
- 侧信道安全：设计上避免了分支和秘密相关的内存访问。
- 变体:
  - PureEdDSA: 直接对消息 $m$ 签名。
  - HashEdDSA (Ed25519ph): 先对消息 $m$ 进行哈希，再签名。适用于硬件受限无法一次性处理长消息的场景。

3.4 SM2 数字签名算法

中国国家密码标准（GM/T 0003-2012），基于椭圆曲线离散对数问题（ECDLP），专为中文场景设计，具备自主可控的安全特性。

核心特色：引入“用户身份绑定”机制，签名时需将用户身份 $ID$、椭圆曲线参数、公钥等信息拼接后哈希，得到 $Z_A = H(ID | a | b | x_G | y_G | x_A | y_A)$，再计算 $e = H(Z_A | m)$，确保签名与用户身份强绑定，防止身份伪造。
流程特点：签名/验证流程类似 Schnorr 与 ECDSA 的混合体，安全性可证明，且抗已知攻击。
应用场景：电子政务、金融行业、国内区块链项目（如联盟链）、电子发票。

4. 特殊性质的签名 (Advanced Signatures)

签名者对消息“盲化后签名”，无法获取消息内容；用户去盲后得到有效签名，签名者无法将签名与原始消息关联（盲性+不可链接性）。

性质：
- 盲性 (Blindness): 签名者无法看到 $m$。
- 不可链接性 (Unlinkability): 签名者无法将签名后的结果与之前的签名请求对应起来。
Chaum 盲签名 (RSA based):
1. 用户选择随机因子 $r$，计算盲化消息 $m’ = m \cdot r^e \pmod N$ 发送给签名者。
2. 签名者计算 $\sigma’ = (m’)^d \pmod N$ 发回。
3. 用户去盲：$\sigma = \sigma’ \cdot r^{-1} \pmod N = m^d \pmod N$。
应用：电子现金 (E-Cash)，电子投票。

4.2 群签名 (Group Signature)

允许群成员代表整个群体签名，验证者只能验证是群体成员签的，但不知道具体是谁。

角色：群成员，群管理员 (Group Manager)。
性质：
- 匿名性：对公众匿名。
- 可追踪性：群管理员在争议时可以打开签名，揭示真实签名者身份。
应用：企业授权（员工代表企业签名）、车联网（V2X 通信匿名认证）、分布式系统节点认证。

4.3 环签名 (Ring Signature)

一种简化的群签名，但没有群管理员，完全匿名。

机制：签名者利用自己的私钥和其他 $n-1$ 个成员的公钥生成签名。
性质：
- 无条件匿名：无法追踪真实签名者。
- 自发性：无需其他成员配合，只要有公钥即可成环。
应用：匿名举报、隐私货币（如 Monero 的 RingCT 协议）、匿名通信。

4.4 不可否认签名 (Undeniable Signature)

验证签名的有效性需要签名者的配合（通过交互式“确认协议”验证有效性）。

目的：防止签名被随意验证和传播（保护签名者隐私），但在法律纠纷时签名者无法否认（通过“否认协议”证明伪造签名无效）。
组成：签名算法 + 确认协议 (Confirmation Protocol) + 否认协议 (Disavowal Protocol)。
应用场景：版权保护、电子合同（需双方确认）、敏感信息签名。

4.5 门限签名 (Threshold Signature)

需要 $n$ 个参与者中的至少 $t$ 个合作才能生成有效签名。

机制：私钥被秘密共享 (Secret Sharing) 为 $n$ 份。
应用：多方计算 (MPC) 钱包，高安全级密钥管理。

4.6 BLS 签名 (Boneh-Lynn-Shacham)

基于双线性配对 (Bilinear Pairing) 的签名方案。

原理：利用配对函数 $e: G_1 \times G_2 \to G_T$ 的“双线性特性”（$e(g^a, h^b) = e(g, h)^{ab}$），将签名验证转化为配对运算。
签名：
- 密钥：私钥 $x$，公钥 $y = g^x \in G_2$；
- 签名：$\sigma = H(m)^x \in G_1$（仅需群中一个元素，签名极短）；
- 验证：检查 $e(\sigma, g) \stackrel{?}{=} e(H(m), y)$。
特性：
- 短签名：签名只是群中的一个点，非常短。
- 非交互式聚合 (Non-interactive Aggregation)：可以将多个用户对不同消息的签名聚合成一个签名，且验证成本极低。
应用：Ethereum 2.0 (信标链验证者签名聚合), Zcash, Filecoin。

5. 工程实践与常见陷阱 (Engineering Best Practices)

理论安全不等于实际安全，大多数漏洞都源于实现细节。

5.1 随机数生成 (RNG)

陷阱: 使用弱随机数生成器（如 C 语言 rand()、JavaScript Math.random()）、种子可预测、随机数 $k$ 重复/泄露。
后果: 对于 DSA/ECDSA/Schnorr，只要随机数 $k$ 泄露、预测或重复，私钥就会立即暴露。
最佳实践:
- 使用密码学安全的随机数生成器 (CSPRNG)，如 /dev/urandom, CryptGenRandom。
- 优先选择确定性签名方案 (如 RFC 6979 ECDSA, Ed25519)，完全消除对 RNG 的运行时依赖。

5.2 侧信道攻击 (Side-Channel Attacks)

陷阱: 算法执行时间或功耗与私钥相关。例如，模幂运算中的分支判断。
最佳实践:
- 恒定时间实现 (Constant-time): 确保核心运算的时间不依赖于密钥数据。
- 盲化 (Blinding): 在 RSA 运算前对密文进行随机盲化，防止计时攻击。

5.3 消息编码与哈希

陷阱: 直接对短消息签名而不哈希，或者哈希函数存在碰撞。
最佳实践:
- Hash-then-Sign: 始终先对消息进行哈希。
- 域分离 (Domain Separation): 在哈希输入中加入特定的前缀字符串 (如 Hash("MyApp-v1" || m)), 防止不同协议间的签名重放攻击。

5.4 密钥管理

陷阱: 私钥硬编码（如写死在代码中）、存储在不安全内存中、未加密存储。
最佳实践:
- 使用硬件安全模块 (HSM) 或可信执行环境 (TEE/Enclave)。
- 使用密钥派生函数 (KDF) 保护存储的私钥。
- 定期轮换密钥。

6. 总结与对比

特性	RSA-PSS	ECDSA	EdDSA (Ed25519)	Schnorr	SM2	BLS
数学难题	大整数分解	椭圆曲线 DLP	椭圆曲线 DLP	DLP / ECDLP	椭圆曲线 DLP	双线性配对
签名长度	长 (如 2048-bit)	短 (如 512-bit)	短	短	短	极短
验签速度	快 (小公钥指数)	中等	极快	快	中等	慢 (配对)
随机数依赖	依赖 (PSS)	极高 (私钥泄露风险)	无 (确定性生成)	高 (或确定性)	高	无
线性/聚合	否	否	否	是	否	强
标准化	PKCS#1	NIST FIPS 186	RFC 8032	BIP-340	GM/T 0003	IETF Draft

7. 理解与记忆心法 (Mnemonics)

建立一个**“家族谱系” + “演化故事”**的思维导图，避免死记硬背。

7.1 第一层：核心逻辑（一句话心法）

所有数字签名都在做同一件事：用私钥对“消息的指纹（哈希）”盖章，公钥用来验章。

目的：防篡改（完整性）、你是你（认证）、赖不掉（不可否认）。

7.2 第二层：两大门派（按数学难题分）

1. 大整数分解派（RSA 家族）

代表：RSA。
记忆钩子：“简单粗暴的幂运算”。
核心逻辑：签名就是解密（$s = m^d$），验证就是加密（$m = s^e$）。
演化：
- 教科书 RSA：太简单，容易被利用数学性质攻击（乘法同态）。
- RSA-PSS：为了安全，加了“盐”（随机填充），把消息打乱再签名。

2. 离散对数派（DLP 家族）

这是人丁兴旺的一派，包括 ElGamal, DSA, Schnorr, ECDSA, EdDSA, SM2, BLS。

记忆钩子：“随机数 $k$ 的诅咒”。这一派几乎所有算法在签名时都要选一个随机数 $k$。
演化故事线：
1. ElGamal：老祖宗。开创了用随机数 $k$ 保护私钥 $x$ 的先河。缺点是签名太长（两个大数）。
2. Schnorr：“完美的极简主义者”。把 ElGamal 优化了，签名短、速度快、还能把多个签名加在一起（线性特性）。因为专利原因被雪藏了很久，现在比特币（Taproot）把它请回来了。
3. DSA：“政府版 ElGamal”。NIST 当年为了避开 RSA 专利搞的标准。它是 ElGamal 的变体，专门优化了签名长度。
4. ECDSA：“DSA 的椭圆曲线版”。把 DSA 搬到了椭圆曲线上。好处是钥匙短（256位 vs RSA 3072位），手机、区块链最爱用。坏处是随机数 $k$ 极其脆弱（$k$ 重复 = 私钥丢）。
5. EdDSA (Ed25519)：“工程学的胜利”。为了解决 ECDSA 容易因为随机数 $k$ 写不好而出事的问题，它直接取消了随机数（用哈希确定性生成 $k$），又快又安全。
6. SM2：“国货之光”。结构类似 ECDSA/Schnorr，但加了个特色：把用户身份 ID 也卷进哈希里签了。
7. BLS：“来自未来的魔法”。利用双线性配对，签名极短且支持无限聚合，是以太坊 2.0 的基石。

记忆钩子：“DLP 看 $k$，漏了就完蛋；要快要稳用 Ed，聚合签名用 BLS”。

7.3 第三层：特殊技能（按场景记忆）

把高级签名想象成拥有“超能力”的变种，对应现实故事：

签名类型	超能力	记忆场景/故事
盲签名 (Blind)	隐身术	电子现金/投票。我找银行给钱盖章，但不想让银行知道钱的编号。我把编号装信封里（盲化），银行隔着信封盖章。
群签名 (Group)	公司马甲	警车/公司发言人。你看到一辆警车违章（验证了是警车），但不知道是哪个警察开的（匿名）。只有局长（管理员）能查出是谁（可追踪）。
环签名 (Ring)	匿名混淆	匿名举报信。我把我和几个大佬的公钥混在一起签名。别人知道“肯定是我们这圈人里的一个”，但死活查不出具体是谁。没有管理员能追踪。
门限签名 (Threshold)	集齐龙珠	核按钮/多签钱包。私钥被打碎成碎片。必须集齐 3 个碎片才能合成一个签名。防止单点故障或内鬼。
BLS 签名	合体技	万人大合唱。一万个人的签名可以压缩成一个签名，验证一次等于验证了一万次。

7.4 总结记忆口诀

RSA 看填充（PSS才安全）。
DLP 看随机数（$k$ 漏了就完蛋）。
比特币用两代（老 ECDSA，新 Schnorr）。
要快要稳用 Ed（Ed25519）。
聚合签名用 BLS。
想匿名用环/群，想隐私用盲签。

8. 练习题 (Practice Exercises)

通过手动计算小数值示例，是记忆算法流程的最好方式。

8.1 基础计算题

练习 1: RSA 签名

假设 RSA 参数为 $p=3, q=11$。

计算 $N$ 和 $\phi(N)$。
若公钥 $e=3$，计算私钥 $d$。
对消息 $m=5$ 进行签名，计算 $\sigma$。
验证签名：计算 $\sigma^e \pmod N$ 是否等于 $m$。

练习 2: ElGamal 签名

假设素数 $p=11$，生成元 $g=2$。

私钥 $x=3$，计算公钥 $y$。
对消息 $m=5$ 签名：
- 选择随机数 $k=9$ (检查 $\gcd(k, p-1)=1$)。
- 计算 $r = g^k \pmod p$。
- 计算 $s = k^{-1}(m - xr) \pmod{p-1}$。
验证签名：检查 $g^m \equiv y^r r^s \pmod p$。

练习 3: Schnorr 签名 (严谨版)

为了演示真实的 Schnorr 签名，我们需要在一个素数阶子群上运算。参数：$p=23$ (模数), $q=11$ (子群阶), $g=4$ (生成元，阶为 11)。

密钥生成: 私钥 $x=3$。计算公钥 $y = g^x \pmod p$。
签名: 对消息 $m$ 签名。
- 选择随机数 $k=2$。计算承诺 $R = g^k \pmod p$。
- 假设哈希输出挑战 $e = 4$。
- 计算响应 $s = k + xe \pmod q$。
验证: 计算 $R’ = g^s y^{-e} \pmod p$，并检查是否等于 $R$。

8.2 概念辨析题

练习 4: 连线题

将下列特性与对应的签名体制连接起来： A. 签名长度最短，且支持聚合 B. 必须使用确定性随机数以防侧信道攻击 C. 验证时需要检查填充格式 (Padding) D. 签名由 $(r, s)$ 组成，且 $s$ 的计算涉及 $k^{-1}$

RSA-PSS
Schnorr
ECDSA
EdDSA
BLS

练习 5: 安全分析

在 ECDSA 签名中，Alice 对两个不同的消息 $m_1, m_2$ 签名时，不小心使用了相同的随机数 $k$。已知签名分别为 $(r, s_1)$ 和 $(r, s_2)$。请问攻击者如何利用这两个签名计算出 Alice 的私钥 $x$？(提示：列出 $s_1, s_2$ 的方程并相减)

练习 6: 核心原理简答题

简述数字签名 EUF-CMA 安全定义的核心思想，为何该定义是实用中最严格的安全标准？
对比 RSA-PSS 与 Ed25519 的核心差异，说明在 Web 应用中优先选择 Ed25519 的原因。
为什么 ECDSA 对随机数 $k$ 的安全性要求极高，而 Ed25519 可以消除对随机数生成器的依赖？
什么是盲签名的“盲性”与“不可链接性”，请结合电子投票场景说明其作用。

8.3 参考答案

练习 1 (RSA):

$N=33, \phi(N)=20$。
$3d \equiv 1 \pmod{20} \Rightarrow d=7$。
$\sigma = 5^7 \pmod{33}$。$5^2=25, 5^4=625\equiv 31\equiv -2, 5^7 = 5 \cdot 25 \cdot (-2) = -250 \equiv 14$。所以 $\sigma=14$。
$14^3 = 2744$。$2744 / 33 = 83 \dots 5$。验证通过。

练习 2 (ElGamal):

$y = 2^3 \pmod{11} = 8$。
$r = 2^9 \pmod{11} = 512 \equiv 6$。 $k=9$，在模 10 下 $9^{-1}=9$ (因 $9 \times 9 = 81 \equiv 1$)。 $s = 9(5 - 3 \cdot 6) \pmod{10} = 9(5 - 18) = 9(-13) = 9(7) = 63 \equiv 3$。签名为 $(6, 3)$。
左边 $2^5 = 32 \equiv 10$。右边 $8^6 \cdot 6^3 \pmod{11}$。$8 \equiv -3 \Rightarrow (-3)^6 = 3^6 = 729 \equiv 3$。$6^3 = 216 \equiv 7$。$3 \cdot 7 = 21 \equiv 10$。验证通过。

练习 3 (Schnorr):

公钥: $y = 4^3 = 64 = 2 \times 23 + 18 \equiv 18 \pmod{23}$。
签名:
- $R = 4^2 = 16 \pmod{23}$。
- $s = 2 + 3 \cdot 4 = 14 \equiv 3 \pmod{11}$。
- 签名为 $(R=16, s=3)$。
验证:
- 我们需要验证 $g^s y^{-e} \stackrel{?}{=} R \pmod p$。
- $g^s = 4^3 = 64 \equiv 18 \pmod{23}$。
- $y^e = 18^4 \pmod{23}$。$18 \equiv -5$。$(-5)^4 = 625 = 27 \times 23 + 4 \equiv 4$。
- $y^{-e} = 4^{-1} \pmod{23}$。因为 $4 \times 6 = 24 \equiv 1$，所以逆元是 6。
- $g^s y^{-e} = 18 \times 6 = 108$。
- $108 = 4 \times 23 + 16 \equiv 16 \pmod{23}$。
- 结果等于 $R$ (16)，验证通过。

练习 4 (连线): 1-C, 2-A (部分特性), 3-D, 4-B, 5-A (最强聚合) (注：Schnorr 支持线性聚合，BLS 支持非交互式聚合且签名更短)

练习 5 (安全分析): $s_1 = k^{-1}(H(m_1) + xr)$ $s_2 = k^{-1}(H(m_2) + xr)$ 两式相减：$s_1 - s_2 = k^{-1}(H(m_1) - H(m_2))$ 所以 $k = (H(m_1) - H(m_2)) \cdot (s_1 - s_2)^{-1} \pmod q$。求出 $k$ 后，代回任意一式即可求出私钥 $x$。 练习 6(原理简答):

核心思想：攻击者可自适应请求任意消息的签名，若无法伪造出“未请求过的消息”的有效签名（且伪造概率可忽略），则方案满足EUF-CMA安全。该定义是最严格实用标准的原因：覆盖了现实中攻击者的最强能力（主动获取签名、自适应选择消息），能抵御绝大多数实际攻击场景。
核心差异：① 数学基础：RSA-PSS基于大整数分解，Ed25519基于椭圆曲线离散对数；② 效率：Ed25519签名/验证速度远快于RSA-PSS；③ 随机数依赖：RSA-PSS依赖盐值随机，Ed25519为确定性签名；④ 密钥长度：Ed25519公钥32字节，RSA-PSS（2048位）公钥256字节。Web应用优先选Ed25519的原因：效率高、密钥短（传输存储成本低）、无随机数依赖（降低实现漏洞风险）。
ECDSA对$k$要求高的原因：$k$重复/可预测时，攻击者可通过联立签名方程求解私钥；Ed25519消除RNG依赖的原因：通过哈希函数$H(sk, m)$确定性生成$k$，$k$与私钥、消息强绑定，无需外部随机数，从根源避免$k$泄露风险。
盲性：签名者对盲化后的消息签名，无法知晓原始消息内容；不可链接性：签名者无法将最终有效签名与原始盲化消息关联。电子投票场景中，盲性确保签名者（投票站）无法获取选民投票内容，不可链接性确保签名者无法追溯某张选票的具体投票人，从而保障选民隐私与投票公正性。

9. 参考文献与扩展阅读 (References)

RSA-PSS: RFC 8017 - PKCS #1: RSA Cryptography Specifications Version 2.2
ECDSA: FIPS 186-5 - Digital Signature Standard (DSS)
Deterministic ECDSA: RFC 6979
EdDSA: RFC 8032 - Edwards-Curve Digital Signature Algorithm (EdDSA)
Schnorr: BIP-340 - Schnorr Signatures for secp256k1
BLS: IETF Draft - BLS Signatures
SM2: GB/T 32918.2-2016 - SM2椭圆曲线公钥密码算法第2部分：数字签名算法

AES 学习笔记

Wed, 17 Dec 2025 17:13:59 +0800

1. 简介 (Introduction)

AES (Advanced Encryption Standard)，即高级加密标准，是目前全球最广泛使用的对称加密算法。它由比利时密码学家 Joan Daemen 和 Vincent Rijmen 设计，原名 Rijndael。2001年被 NIST 正式采纳为标准 (FIPS 197)，用以取代老旧的 DES。

1.1 关键参数

分组长度 (Block Size): 固定为 128位 (16字节)。
密钥长度 (Key Length): 支持 128、192、256 位。本笔记主要讨论 AES-128。
轮数 (Rounds):
- AES-128: 10 轮
- AES-192: 12 轮
- AES-256: 14 轮

2. 数学基础 (Mathematical Background)

AES 的运算不是在普通的整数域上进行的，而是在 有限域 (Finite Field)，特别是 伽罗瓦域 $GF(2^8)$ 上进行的。这保证了运算结果始终在一个字节（8位）范围内，且具有良好的非线性特性。

2.1 字节的表示

一个字节 $b_7 b_6 b_5 b_4 b_3 b_2 b_1 b_0$ 可以看作是系数为 ${0, 1}$ 的多项式：

$$ b(x) = b_7x^7 + b_6x^6 + b_5x^5 + b_4x^4 + b_3x^3 + b_2x^2 + b_1x + b_0 $$

例如：十六进制 0x57 (二进制 01010111) 对应多项式 $x^6 + x^4 + x^2 + x + 1$。

2.2 域上的加法 (Addition)

在 $GF(2^8)$ 中，加法就是多项式系数模 2 相加，等价于 异或 (XOR) 运算。

$$ a + b \iff a \oplus b $$

例如：0x57 + 0x83 = 01010111 ^ 10000011 = 11010100 = 0xD4。

2.3 域上的乘法 (Multiplication)

乘法是多项式相乘后，模一个不可约多项式 (Irreducible Polynomial) $m(x)$。AES 规定的不可约多项式为：

$$ m(x) = x^8 + x^4 + x^3 + x + 1 \quad (\text{Hex: } 0x11B) $$

xtime 函数: 这是 AES 乘法的核心。xtime(a) 相当于 $a$ 乘以 $x$（即左移一位）。

如果 $a$ 的最高位 $b_7 = 0$，则 xtime(a) = a << 1。
如果 $a$ 的最高位 $b_7 = 1$，则 xtime(a) = (a << 1) ^ 0x1B (模 $m(x)$ 的结果)。
任意乘法 $a \times b$ 可以通过重复 xtime 和加法（XOR）组合实现。

3. 算法内部结构 (Internal Structure)

AES 处理的数据单位是 状态矩阵 (State Matrix)。16 字节的输入被排列成 $4 \times 4$ 的矩阵（按列优先填充）。

$$ \text{State} = \begin{bmatrix} s_{0,0} & s_{0,1} & s_{0,2} & s_{0,3} \\ s_{1,0} & s_{1,1} & s_{1,2} & s_{1,3} \\ s_{2,0} & s_{2,1} & s_{2,2} & s_{2,3} \\ s_{3,0} & s_{3,1} & s_{3,2} & s_{3,3} \end{bmatrix} $$

3.1 整体流程 (AES-128)

密钥扩展 (Key Expansion): 将初始密钥扩展为 11 组轮密钥 ($K_0, K_1, …, K_{10}$)。
初始轮 (Initial Round):
- AddRoundKey (与 $K_0$ 异或)
常规轮 (Rounds 1 to 9):
- SubBytes (字节代换)
- ShiftRows (行移位)
- MixColumns (列混合)
- AddRoundKey (与 $K_i$ 异或)
最终轮 (Final Round 10):
- SubBytes
- ShiftRows
- AddRoundKey (与 $K_{10}$ 异或)
- (注意：最终轮没有 MixColumns)

4. 详细步骤解析 (Detailed Transformations)

4.1 字节代换 (SubBytes)

这是 AES 中唯一的非线性变换，提供了混淆性 (Confusion)。

原理: 每个字节 $b$ 被替换为 S-Box 中的对应值。
S-Box 构造:
1. 求 $b$ 在 $GF(2^8)$ 中的乘法逆元 $b^{-1}$ (0 的逆元设为 0)。
2. 对 $b^{-1}$ 进行仿射变换 (Affine Transformation)。
查表法: 实际实现通常直接查预计算好的 $16 \times 16$ S-Box 表。

4.2 行移位 (ShiftRows)

对状态矩阵的每一行进行循环左移，提供了扩散性 (Diffusion)。

第 0 行：不移动。
第 1 行：循环左移 1 字节。
第 2 行：循环左移 2 字节。
第 3 行：循环左移 3 字节。

$$ \begin{bmatrix} s_{0,0} & s_{0,1} & s_{0,2} & s_{0,3} \\ s_{1,0} & s_{1,1} & s_{1,2} & s_{1,3} \\ s_{2,0} & s_{2,1} & s_{2,2} & s_{2,3} \\ s_{3,0} & s_{3,1} & s_{3,2} & s_{3,3} \end{bmatrix} \xrightarrow{\text{ShiftRows}} \begin{bmatrix} s_{0,0} & s_{0,1} & s_{0,2} & s_{0,3} \\ s_{1,1} & s_{1,2} & s_{1,3} & s_{1,0} \\ s_{2,2} & s_{2,3} & s_{2,0} & s_{2,1} \\ s_{3,3} & s_{3,0} & s_{3,1} & s_{3,2} \end{bmatrix} $$

4.3 列混合 (MixColumns)

对状态矩阵的每一列进行线性变换，进一步增强扩散性。

原理: 将每一列视为 $GF(2^8)$ 上的多项式，与一个固定的多项式 $c(x)$ 进行模 $x^4 + 1$ 乘法。
$$ c(x) = 03x^3 + 01x^2 + 01x + 02 $$
矩阵形式:
$$ \begin{bmatrix} b_0 \\ b_1 \\ b_2 \\ b_3 \end{bmatrix} = \begin{bmatrix} 02 & 03 & 01 & 01 \\ 01 & 02 & 03 & 01 \\ 01 & 01 & 02 & 03 \\ 03 & 01 & 01 & 02 \end{bmatrix} \times \begin{bmatrix} a_0 \\ a_1 \\ a_2 \\ a_3 \end{bmatrix} $$
这里的乘法是 $GF(2^8)$ 上的乘法，加法是异或。

4.4 轮密钥加 (AddRoundKey)

将状态矩阵与当前的轮密钥进行按位异或 (XOR)。这是将密钥融入密文的关键步骤。

$$ \text{State} = \text{State} \oplus \text{RoundKey}_i $$

5. 密钥扩展 (Key Expansion)

AES-128 需要将 16 字节的初始密钥扩展为 176 字节（44 个字，每个字 4 字节），供 11 轮使用。令 $W[0 \dots 43]$ 为扩展后的字数组。

前 4 个字: 直接复制初始密钥。
后续字 $W[i]$:
- 如果 $i$ 是 4 的倍数: $$ W[i] = W[i-4] \oplus \text{SubWord}(\text{RotWord}(W[i-1])) \oplus \text{Rcon}[i/4] $$
- 否则: $$ W[i] = W[i-4] \oplus W[i-1] $$

RotWord: 字循环左移 1 字节 ($[a_0, a_1, a_2, a_3] \to [a_1, a_2, a_3, a_0]$)。
SubWord: 对字的每个字节应用 S-Box。
Rcon (轮常数): 用于破坏对称性。$Rcon[i] = [x^{i-1}, 00, 00, 00]$ (在 $GF(2^8)$ 中)。

6. 解密流程 (Decryption)

解密是加密的逆过程，需要使用逆变换：

InvSubBytes: 使用逆 S-Box。
InvShiftRows: 循环右移。
InvMixColumns: 乘以 $c(x)$ 的逆多项式 $d(x) = 0Bx^3 + 0Dx^2 + 09x + 0E$。
AddRoundKey: 异或本身就是逆运算。

注意: 解密时轮密钥的使用顺序是相反的（从 $K_{10}$ 到 $K_0$）。

7. 源代码

import sys
from typing import List

# =============================================================================
# AES 常量定义
# =============================================================================

# S-Box (Substitution Box): 用于 SubBytes 步骤的非线性替换表
# 它是基于 GF(2^8) 上的乘法逆元和仿射变换构造的
SBOX = [
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
]

# Inverse S-Box: 用于解密时的逆字节代换
INV_SBOX = [
    0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
    0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
    0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
    0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
    0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
    0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
    0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
    0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
    0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
    0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
    0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
    0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
    0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
    0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
    0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
]

# Rcon (Round Constant): 轮常数，用于密钥扩展
# Rcon[i] 代表 x^(i-1) 在 GF(2^8) 中的值
RCON = [
    0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36
]

BLOCK_SIZE = 16  # AES 分组大小固定为 128 位 (16 字节)

# =============================================================================
# 辅助函数：填充与数据转换
# =============================================================================

def pkcs7_pad(data: bytes, block_size: int = BLOCK_SIZE) -> bytes:
    """
    PKCS#7 填充：将数据填充到 block_size 的倍数。
    填充的值等于填充的字节数。
    例如：如果缺 3 个字节，就填充 0x03 0x03 0x03。
    """
    pad_len = block_size - (len(data) % block_size)
    if pad_len == 0:
        pad_len = block_size
    return data + bytes([pad_len] * pad_len)


def pkcs7_unpad(data: bytes) -> bytes:
    """
    PKCS#7 去填充：读取最后一个字节确定填充长度，并移除填充。
    """
    if not data:
        raise ValueError("空数据不支持去填充")
    pad_len = data[-1]
    if pad_len < 1 or pad_len > BLOCK_SIZE:
        raise ValueError("填充长度非法")
    if data[-pad_len:] != bytes([pad_len] * pad_len):
        raise ValueError("填充内容非法")
    return data[:-pad_len]


def zero_pad_key_to_16(key: bytes) -> bytes:
    """
    将密钥处理为 16 字节 (128 位)。
    如果不足 16 字节，右侧补 0；如果超过，截断。
    (仅用于演示，生产环境应使用 KDF)
    """
    if len(key) >= 16:
        return key[:16]
    return key + bytes(16 - len(key))


def bytes_to_state(block: bytes) -> List[List[int]]:
    """
    将 16 字节的输入块转换为 4x4 的状态矩阵 (State)。
    AES 规定按【列优先】顺序填充。
    """
    return [list(block[i::4])[:4] for i in range(4)]


def state_to_bytes(state: List[List[int]]) -> bytes:
    """
    将 4x4 状态矩阵转换回 16 字节数据 (列优先读取)。
    """
    out = bytearray(16)
    for r in range(4):
        for c in range(4):
            out[c * 4 + r] = state[r][c]
    return bytes(out)

# =============================================================================
# AES 核心变换函数
# =============================================================================

def sub_bytes(state: List[List[int]]):
    """
    SubBytes (字节代换)：
    使用 S-Box 对状态矩阵中的每个字节进行非线性替换。
    提供了算法的混淆性 (Confusion)。
    """
    for r in range(4):
        for c in range(4):
            state[r][c] = SBOX[state[r][c]]


def inv_sub_bytes(state: List[List[int]]):
    """
    InvSubBytes (逆字节代换)：
    使用逆 S-Box 还原字节，用于解密。
    """
    for r in range(4):
        for c in range(4):
            state[r][c] = INV_SBOX[state[r][c]]


def shift_rows(state: List[List[int]]):
    """
    ShiftRows (行移位)：
    对状态矩阵的每一行进行循环左移。
    第0行不移，第1行左移1位，第2行左移2位，第3行左移3位。
    提供了算法的扩散性 (Diffusion)。
    """
    state[1] = state[1][1:] + state[1][:1]
    state[2] = state[2][2:] + state[2][:2]
    state[3] = state[3][3:] + state[3][:3]


def inv_shift_rows(state: List[List[int]]):
    """
    InvShiftRows (逆行移位)：
    对状态矩阵的每一行进行循环右移，用于解密。
    """
    state[1] = state[1][-1:] + state[1][:-1]
    state[2] = state[2][-2:] + state[2][:-2]
    state[3] = state[3][-3:] + state[3][:-3]


# --- GF(2^8) 数学运算辅助函数 ---

def xtime(a: int) -> int:
    """
    xtime 函数：计算 a * x (在 GF(2^8) 域上)。
    相当于左移一位，如果溢出则异或不可约多项式 0x1B。
    """
    return ((a << 1) & 0xFF) ^ (0x1B if (a & 0x80) else 0)


def mul(a: int, b: int) -> int:
    """
    GF(2^8) 上的乘法：计算 a * b。
    通过重复 xtime 和条件异或实现 (类似快速幂/俄罗斯农民乘法)。
    """
    res = 0
    for i in range(8):
        if b & 1:
            res ^= a
        a = xtime(a)
        b >>= 1
    return res


def mix_single_column(col: List[int]) -> List[int]:
    """
    MixColumns 的单列计算。
    将列向量与固定多项式 c(x) = 03x^3 + 01x^2 + 01x + 02 相乘。
    """
    a0, a1, a2, a3 = col
    return [
        mul(a0, 2) ^ mul(a1, 3) ^ a2 ^ a3,
        a0 ^ mul(a1, 2) ^ mul(a2, 3) ^ a3,
        a0 ^ a1 ^ mul(a2, 2) ^ mul(a3, 3),
        mul(a0, 3) ^ a1 ^ a2 ^ mul(a3, 2)
    ]


def mix_columns(state: List[List[int]]):
    """
    MixColumns (列混合)：
    对状态矩阵的每一列进行线性变换，进一步增强扩散性。
    """
    for c in range(4):
        col = [state[r][c] for r in range(4)]
        new_col = mix_single_column(col)
        for r in range(4):
            state[r][c] = new_col[r]


def inv_mix_single_column(col: List[int]) -> List[int]:
    """
    InvMixColumns 的单列计算。
    乘以 c(x) 的逆多项式 d(x) = 0Bx^3 + 0Dx^2 + 09x + 0E。
    """
    a0, a1, a2, a3 = col
    return [
        mul(a0, 0x0e) ^ mul(a1, 0x0b) ^ mul(a2, 0x0d) ^ mul(a3, 0x09),
        mul(a0, 0x09) ^ mul(a1, 0x0e) ^ mul(a2, 0x0b) ^ mul(a3, 0x0d),
        mul(a0, 0x0d) ^ mul(a1, 0x09) ^ mul(a2, 0x0e) ^ mul(a3, 0x0b),
        mul(a0, 0x0b) ^ mul(a1, 0x0d) ^ mul(a2, 0x09) ^ mul(a3, 0x0e)
    ]


def inv_mix_columns(state: List[List[int]]):
    """
    InvMixColumns (逆列混合)：用于解密。
    """
    for c in range(4):
        col = [state[r][c] for r in range(4)]
        new_col = inv_mix_single_column(col)
        for r in range(4):
            state[r][c] = new_col[r]


def add_round_key(state: List[List[int]], round_key: bytes):
    """
    AddRoundKey (轮密钥加)：
    将状态矩阵与当前的轮密钥进行按位异或 (XOR)。
    """
    for r in range(4):
        for c in range(4):
            state[r][c] ^= round_key[c * 4 + r]


# =============================================================================
# 密钥扩展 (Key Expansion)
# =============================================================================

def rot_word(w: List[int]) -> List[int]:
    """字循环左移：[a0, a1, a2, a3] -> [a1, a2, a3, a0]"""
    return w[1:] + w[:1]


def sub_word(w: List[int]) -> List[int]:
    """字代换：对字中的每个字节应用 S-Box"""
    return [SBOX[b] for b in w]


def key_expansion(key: bytes) -> List[bytes]:
    """
    密钥扩展算法 (AES-128)：
    将 16 字节初始密钥扩展为 11 组轮密钥 (每组 16 字节)。
    """
    Nk = 4   # 密钥长度 (字数)，AES-128 为 4
    Nb = 4   # 分组长度 (字数)，固定为 4
    Nr = 10  # 轮数，AES-128 为 10
    
    # w 存储扩展后的所有字 (4 * (Nr + 1) = 44 个字)
    w = [[0, 0, 0, 0] for _ in range(Nb * (Nr + 1))]
    
    # 前 Nk 个字直接取自初始密钥
    for i in range(Nk):
        w[i] = [key[4 * i + 0], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]]
        
    # 生成剩余的字
    for i in range(Nk, Nb * (Nr + 1)):
        temp = w[i - 1][:]
        if i % Nk == 0:
            # 每 Nk 个字进行一次复杂变换：RotWord + SubWord + XOR Rcon
            temp = sub_word(rot_word(temp))
            temp[0] ^= RCON[i // Nk]
        # W[i] = W[i-Nk] XOR temp
        w[i] = [ (w[i - Nk][j] ^ temp[j]) & 0xFF for j in range(4) ]
        
    # 将字数组重新组合成 11 个 16 字节的轮密钥
    round_keys = []
    for r in range(Nr + 1):
        rk = []
        for c in range(Nb):
            rk.extend(w[r * Nb + c])
        round_keys.append(bytes(rk))
    return round_keys


# =============================================================================
# 调试与输出辅助
# =============================================================================

def bytes_hex(b: bytes) -> str:
    return b.hex().upper()


def state_hex(state: List[List[int]]) -> str:
    return state_to_bytes(state).hex().upper()


# =============================================================================
# AES 加密与解密流程 (Block Level)
# =============================================================================

def aes_encrypt_block(block: bytes, round_keys: List[bytes], verbose: bool = False) -> bytes:
    """
    加密单个 16 字节分组。
    流程：AddRoundKey(Initial) -> 9轮(Sub/Shift/Mix/Add) -> 最终轮(Sub/Shift/Add)
    """
    state = bytes_to_state(block)
    if verbose:
        print("\n==================== 开始 AES 加密 (单块) ===================")
        print(f"输入数据 (Hex): {block.hex().upper()}")
        print(f"初始轮密钥 (Hex): {bytes_hex(round_keys[0])}")
        
    # 初始轮：只做 AddRoundKey
    add_round_key(state, round_keys[0])
    
    # 第 1 到 9 轮
    for round_idx in range(1, 10):
        if verbose:
            print(f"\n-- Round {round_idx} --")
        sub_bytes(state)
        if verbose:
            print(f"After SubBytes: {state_hex(state)}")
        shift_rows(state)
        if verbose:
            print(f"After ShiftRows: {state_hex(state)}")
        mix_columns(state)
        if verbose:
            print(f"After MixColumns: {state_hex(state)}")
        add_round_key(state, round_keys[round_idx])
        if verbose:
            print(f"AddRoundKey ({round_idx}): {bytes_hex(round_keys[round_idx])}")
            print(f"State: {state_hex(state)}")
            
    # 最终轮 (第 10 轮)：无 MixColumns
    if verbose:
        print("\n-- Final Round (10) --")
    sub_bytes(state)
    if verbose:
        print(f"After SubBytes: {state_hex(state)}")
    shift_rows(state)
    if verbose:
        print(f"After ShiftRows: {state_hex(state)}")
    add_round_key(state, round_keys[10])
    
    if verbose:
        print(f"AddRoundKey (10): {bytes_hex(round_keys[10])}")
        print(f"[加密结果] (Hex): {state_hex(state)}")
        print("==================== 结束 AES 加密 ====================\n")
        
    return state_to_bytes(state)


def aes_decrypt_block(block: bytes, round_keys: List[bytes], verbose: bool = False) -> bytes:
    """
    解密单个 16 字节分组。
    流程是加密的逆过程，注意轮密钥顺序相反。
    """
    state = bytes_to_state(block)
    if verbose:
        print("\n==================== 开始 AES 解密 (单块) ===================")
        print(f"输入数据 (Hex): {block.hex().upper()}")
        print(f"终止轮密钥 (Hex): {bytes_hex(round_keys[10])}")
        
    # 初始逆变换：先异或最后一轮密钥
    add_round_key(state, round_keys[10])
    inv_shift_rows(state)
    inv_sub_bytes(state)
    
    # 第 9 到 1 轮 (逆序)
    for round_idx in range(9, 0, -1):
        if verbose:
            print(f"\n-- Round {round_idx} --")
        add_round_key(state, round_keys[round_idx])
        if verbose:
            print(f"AddRoundKey ({round_idx}): {bytes_hex(round_keys[round_idx])}")
            print(f"State: {state_hex(state)}")
        inv_mix_columns(state)
        if verbose:
            print(f"After InvMixColumns: {state_hex(state)}")
        inv_shift_rows(state)
        if verbose:
            print(f"After InvShiftRows: {state_hex(state)}")
        inv_sub_bytes(state)
        if verbose:
            print(f"After InvSubBytes: {state_hex(state)}")
            
    # 最终逆变换
    add_round_key(state, round_keys[0])
    
    if verbose:
        print(f"AddRoundKey (0): {bytes_hex(round_keys[0])}")
        print(f"[解密结果] (Hex): {state_hex(state)}")
        print("==================== 结束 AES 解密 ====================\n")
        
    return state_to_bytes(state)


# =============================================================================
# ECB 模式封装
# =============================================================================

def aes_encrypt_ecb(plaintext: bytes, key: bytes, verbose: bool = False) -> bytes:
    """
    AES-128 ECB 模式加密。
    1. 处理密钥
    2. 填充明文 (PKCS#7)
    3. 分块加密
    """
    key16 = zero_pad_key_to_16(key)
    round_keys = key_expansion(key16)
    padded = pkcs7_pad(plaintext, BLOCK_SIZE)
    
    if verbose:
        print("开始加密...")
        print(f"原始长度: {len(plaintext)}, 填充后长度: {len(padded)}")
        
    out = bytearray()
    for i in range(0, len(padded), BLOCK_SIZE):
        blk = padded[i:i+BLOCK_SIZE]
        if verbose:
            try:
                print(f"\n>>> 处理第 {i//BLOCK_SIZE + 1} 块: {blk.decode('utf-8', 'ignore')}")
            except Exception:
                print(f"\n>>> 处理第 {i//BLOCK_SIZE + 1} 块 (Hex): {blk.hex().upper()}")
        ct = aes_encrypt_block(blk, round_keys, verbose)
        out.extend(ct)
    return bytes(out)


def aes_decrypt_ecb(ciphertext: bytes, key: bytes, verbose: bool = False) -> bytes:
    """
    AES-128 ECB 模式解密。
    1. 处理密钥
    2. 分块解密
    3. 去填充 (PKCS#7)
    """
    key16 = zero_pad_key_to_16(key)
    round_keys = key_expansion(key16)
    out = bytearray()
    
    if verbose:
        print("开始解密...")
        
    for i in range(0, len(ciphertext), BLOCK_SIZE):
        blk = ciphertext[i:i+BLOCK_SIZE]
        if verbose:
            print(f"\n>>> 处理第 {i//BLOCK_SIZE + 1} 块 (Hex): {blk.hex().upper()}")
        pt = aes_decrypt_block(blk, round_keys, verbose)
        out.extend(pt)
    return pkcs7_unpad(bytes(out))


def main():
    raw_text = "hello fanshanng"
    raw_key = "secret"
    print(f"原始明文: {raw_text}")
    print(f"原始密钥: {raw_key}")
    
    pt = raw_text.encode("utf-8")
    key_bytes = raw_key.encode("utf-8")
    
    # 加密
    ct = aes_encrypt_ecb(pt, key_bytes, verbose=True)
    print(f"\n最终密文 (Hex): {ct.hex().upper()}")
    
    # 解密
    dec = aes_decrypt_ecb(ct, key_bytes, verbose=True)
    dec_str = dec.decode("utf-8")
    
    print("\n最终验证:")
    print(f"  原始明文: {raw_text}")
    print(f"  解密明文: {dec_str}")
    print(f"  匹配成功: {raw_text == dec_str}")


if __name__ == "__main__":
    main()

8 代码详解：

8.1列混合 (Code Deep Dive: MixColumns)

AES 的列混合（MixColumns）是整个算法中数学味最浓、也最难理解的部分。它本质上是在 有限域 $GF(2^8)$ 上进行的 矩阵乘法。

1. 最底层：`xtime` (x 乘法)

这是 AES 数学运算的基石。在有限域 $GF(2^8)$ 中，数字被视为多项式的系数。

加法/减法：就是异或 (XOR)。
乘法：比较复杂，特别是乘以 2（即多项式 $x$）。

def xtime(a: int) -> int:
    """
    xtime 函数：计算 a * 2 (在 GF(2^8) 域上)。
    相当于左移一位，如果溢出则异或不可约多项式 0x1B。
    """
    # (a << 1) & 0xFF : 左移一位，相当于乘以 x。& 0xFF 确保结果在 8 位以内。
    # (a & 0x80)      : 检查最高位（第8位）是否为 1。
    # ^ 0x1B          : 如果最高位是 1，说明溢出了，需要减去（异或）不可约多项式 0x1B (00011011)。
    return ((a << 1) & 0xFF) ^ (0x1B if (a & 0x80) else 0)

通俗解释：这就好比我们在十进制里规定“最大不能超过 99”。如果你算 $50 \times 2 = 100$，超过了，就得减去一个特定的数（比如 100）让它变回 0。在 AES 的 8 位世界里，如果左移导致最高位变成了 1（溢出），我们就异或 0x1B 来“折叠”回去。

2. 中间层：`mul` (通用乘法)

有了 xtime (乘以 2)，我们就可以计算乘以任意数了。这里用的是**“俄罗斯农民乘法”**（也叫倍增减半法）的变体。

def mul(a: int, b: int) -> int:
    """
    GF(2^8) 上的乘法：计算 a * b。
    """
    res = 0
    for i in range(8):
        # 如果 b 的当前最低位是 1，就把当前的 a 加（异或）到结果里
        if b & 1:
            res ^= a
        
        # a 翻倍 (乘以 x)
        a = xtime(a)
        
        # b 减半 (右移)
        b >>= 1
    return res

举例计算 $A \times 3$：

$3$ 的二进制是 00000011。
$A \times 3 = A \times (2 + 1) = (A \times 2) + (A \times 1)$。
代码里：
- 第一轮：b 末位是 1，res = res ^ A。
- 第二轮：a 变成了 xtime(A) (即 $2A$)，b 末位还是 1，res = res ^ 2A。
- 结果就是 $A \oplus 2A$。

3. 应用层：`mix_single_column` (矩阵变换)

这一步是真正的列混合。AES 规定每一列都要和一个固定的矩阵相乘。这个固定矩阵是：

$$ \begin{bmatrix} 2 & 3 & 1 & 1 \\ 1 & 2 & 3 & 1 \\ 1 & 1 & 2 & 3 \\ 3 & 1 & 1 & 2 \end{bmatrix} $$

代码完全对应这个矩阵乘法公式：

def mix_single_column(col: List[int]) -> List[int]:
    a0, a1, a2, a3 = col  # 输入列的 4 个字节
    
    return [
        # 新的第 0 行 = 2*a0 + 3*a1 + 1*a2 + 1*a3
        mul(a0, 2) ^ mul(a1, 3) ^ a2 ^ a3,
        
        # 新的第 1 行 = 1*a0 + 2*a1 + 3*a2 + 1*a3
        a0 ^ mul(a1, 2) ^ mul(a2, 3) ^ a3,
        
        # 新的第 2 行 = 1*a0 + 1*a1 + 2*a2 + 3*a3
        a0 ^ a1 ^ mul(a2, 2) ^ mul(a3, 3),
        
        # 新的第 3 行 = 3*a0 + 1*a1 + 1*a2 + 2*a3
        mul(a0, 3) ^ a1 ^ a2 ^ mul(a3, 2)
    ]

为什么是 2 和 3？

乘以 1：就是它自己（代码里直接写 a2 而不是 mul(a2, 1)）。
乘以 2：调用 xtime 一次。
乘以 3：等于 xtime(a) ^ a。 AES 设计者选择 1, 2, 3 是因为它们计算最快（只需要移位和异或），同时能保证很好的扩散效果（让一个字节的变化影响到这一列的所有 4 个字节）。

8.2 代码详解：密钥扩展 (Code Deep Dive: Key Expansion)

AES 的密钥扩展（Key Expansion）负责把用户输入的短密钥（16字节）“拉长”成足够 11 轮加密使用的长密钥串（176字节）。

1. 辅助变换

密钥扩展处理的基本单位是 “字” (Word)，即 4 个字节。

rot_word(w) (字循环左移)

1
2
3

def rot_word(w: List[int]) -> List[int]:
    # 输入 [a0, a1, a2, a3] -> 输出 [a1, a2, a3, a0]
    return w[1:] + w[:1]

这很简单，就是把第一个字节移到最后去。

sub_word(w) (字代换)

1
2
3

def sub_word(w: List[int]) -> List[int]:
    # 对字里的每个字节，都去查 S-Box 替换一下
    return [SBOX[b] for b in w]

这和加密步骤里的 SubBytes 一样，引入非线性，防止攻击者通过线性关系推导密钥。

2. 核心逻辑：`key_expansion`

AES-128 需要 44 个字（$4 \times 11$ 轮 = 44 字）。

def key_expansion(key: bytes) -> List[bytes]:
    Nk = 4   # 原始密钥包含的字数 (16字节 / 4 = 4)
    Nb = 4   # 每轮需要的字数 (固定为 4)
    Nr = 10  # 轮数
    
    # w 是一个大列表，用来存这 44 个字
    w = [[0, 0, 0, 0] for _ in range(Nb * (Nr + 1))]
    
    # 【第一步】前 4 个字 (w[0]~w[3]) 直接就是原始密钥
    for i in range(Nk):
        w[i] = [key[4 * i + 0], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]]
        
    # 【第二步】生成剩下的 40 个字 (w[4]~w[43])
    for i in range(Nk, Nb * (Nr + 1)):
        temp = w[i - 1][:]  # 先取出前一个字
        
        # 每隔 4 个字 (i % Nk == 0)，就要进行一次“复杂变换”
        if i % Nk == 0:
            # 1. 循环左移 (RotWord)
            # 2. S盒代换 (SubWord)
            temp = sub_word(rot_word(temp))
            
            # 3. 异或轮常数 (Rcon)
            # RCON[i // Nk] 获取当前是第几轮的常数
            # 只异或第一个字节 (temp[0])，因为 Rcon 的后三个字节都是 0
            temp[0] ^= RCON[i // Nk]
            
        # 核心公式：W[i] = W[i-Nk] XOR temp
        # 也就是说：当前字 = (4个位置前的字) XOR (经过处理的前一个字)
        w[i] = [ (w[i - Nk][j] ^ temp[j]) & 0xFF for j in range(4) ]

逻辑图解：想象一个滑动窗口。

大多数时候（普通列）：新字 = 4个前的字 XOR 前一个字。
每逢 4 的倍数（第一列）：新字 = 4个前的字 XOR g(前一个字)。
- 函数 $g$ 就是：先左移，再代换，最后异或轮常数。

3. 轮常数 `RCON`

1
2
3

RCON = [
    0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36
]

RCON 是为了消除每一轮密钥生成的对称性。

它只作用于每个字的第一个字节。
它的值是 $x^{i-1}$ 在 $GF(2^8)$ 上的幂：
- 第1轮：$x^0 = 1$ (0x01)
- 第2轮：$x^1 = 2$ (0x02)
- …
- 第9轮：$x^8$ (溢出，变成 0x1B)
- 第10轮：$x^9 = x \cdot x^8 = 2 \cdot 0x1B = 0x36$

9. 附录：运行结果（详细日志）

以下日志展示了对明文 "hello fanshanng" 使用密钥 "secret" 进行加密的完整内部状态。

原始明文: hello fanshanng
原始密钥: secret

开始加密...
原始长度: 15, 填充后长度: 16

>>> 处理第 1 块: hello fanshanng

==================== 开始 AES 加密 (单块) ===================
输入数据 (Hex): 68656C6C6F2066616E7368616E6E6701
初始轮密钥 (Hex): 73656372657400000000000000000000

-- Round 1 --
After SubBytes: 84B05399D8E9F0792B7629157886430A
After ShiftRows: 84E9290AD87643792B86539978B0F015
After MixColumns: D742B4B2C67AE73340810CB134BEA817
AddRoundKey (1): 11060011747200117472001174720011
State: C64CB4A19208872234F30CA0602CB806

-- Round 2 --
After SubBytes: 0D5A8166C7F66F5672BDC6872891B03E
After ShiftRows: 0DF6C63EC7BDB06672918156685A6F87
After MixColumns: 75262BEBCD333CAAA5FC11340EA7F864
AddRoundKey (2): 53658283271782925365828327178292
State: 2643A968EA24BE38F69993B729B07AF6

-- Round 3 --
After SubBytes: F71AD3458736AE0742EEDCA9A5E7DA42
After ShiftRows: F736DC4287EEDA4542E7D307A51AAEA9
After MixColumns: 31A6A46CA370092C62FE11FC78D11809
AddRoundKey (3): A776CD4F80614FDDD304CD5EF4134FCC
State: 96D06923231146F1B1FADCA28CC257C5

-- Round 4 --
After SubBytes: 9070F92626825AA1C82D863A64255BA6
After ShiftRows: 908286A6262D5B26C825F9A164705A3A
After MixColumns: 86B8F4F846B7D750BC33FCC63850EEF2
AddRoundKey (4): D2F286F05293C92D8197047375844BBF
State: 544A720814241E7D3DA4F8B54DD4A54D

-- Round 5 --
After SubBytes: 20D64030FA3672FF274941D5E34806E3
After ShiftRows: 203641E3FA490630274840FFE3D672D5
After MixColumns: B86CAACA0252EF3A2988F5841B17B52B
AddRoundKey (5): 9D418E6DCFD247404E4543333BC1088C
State: 252D24A7CD80A87A67CDB6B720D6BDA7

-- Round 6 --
After SubBytes: 3FD8365CBDCDC2DA85BD4EA9B7F67A5C
After ShiftRows: 3FCD4E5CBDBD7A5C85F636DAB7D8C2A9
After MixColumns: 20308A7A9B0E10A3FCF26AFB6DE81091
AddRoundKey (6): C571EA8F0AA3ADCF44E6EEFC7F27E670
State: E54160F591ADBD6CB814840712CFF6E1

-- Round 7 --
After SubBytes: D983D0E681957A506CFA5FC5C98A42F8
After ShiftRows: D9955FF881FA42E66C8AD050C9837AC5
After MixColumns: AAF1E151A84ECEF7DD58AD4EA89FEA28
AddRoundKey (7): 49FFBB5D435C169207BAF86E789D1E1E
State: E30E5A0CEB12D865DAE25520D002F436

-- Round 8 --
After SubBytes: 11ABBEFEE9C9614D5798FCB77077BF05
After ShiftRows: 11C9FC05E998BFFE5777BE4D70AB61B7
After MixColumns: 9B82340C3BE60DE0C42D90AAD029DB2F
AddRoundKey (8): 978DC9E1D4D1DF73D36B271DABF63903
State: 0C0FFDEDEF37D2931746B7B77BDFE22C

-- Round 9 --
After SubBytes: FE765455DF9AB5DCF05AA9A9219E9871
After ShiftRows: FE9AA971DF5A9855F09E54DC2176B5A9
After MixColumns: 8A40BEC8868D5112CAF7B962C4A0C6E9
AddRoundKey (9): CE9FB2831A4E6DF0C9254AED62D373EE
State: 44DF0C4B9CC33CE203D2F38FA673B507

-- Final Round (10) --
After SubBytes: 1B9EFEB3DE2EEB987BB50D73248FD5C5
After ShiftRows: 1B2E0DC5DEB5D5B37B8FFE98249EEB73
AddRoundKey (10): 9E109A29845EF7D94D7BBD342FA8CEDA
[加密结果] (Hex): 853E97EC5AEB226A36F443AC0B3625A9
==================== 结束 AES 加密 ====================


最终密文 (Hex): 853E97EC5AEB226A36F443AC0B3625A9
开始解密...

>>> 处理第 1 块 (Hex): 853E97EC5AEB226A36F443AC0B3625A9

==================== 开始 AES 解密 (单块) ===================
输入数据 (Hex): 853E97EC5AEB226A36F443AC0B3625A9
终止轮密钥 (Hex): 9E109A29845EF7D94D7BBD342FA8CEDA

-- Round 9 --
AddRoundKey (9): CE9FB2831A4E6DF0C9254AED62D373EE
State: 8A40BEC8868D5112CAF7B962C4A0C6E9
After InvMixColumns: FE9AA971DF5A9855F09E54DC2176B5A9
After InvShiftRows: FE765455DF9AB5DCF05AA9A9219E9871
After InvSubBytes: 0C0FFDEDEF37D2931746B7B77BDFE22C

-- Round 8 --
AddRoundKey (8): 978DC9E1D4D1DF73D36B271DABF63903
State: 9B82340C3BE60DE0C42D90AAD029DB2F
After InvMixColumns: 11C9FC05E998BFFE5777BE4D70AB61B7
After InvShiftRows: 11ABBEFEE9C9614D5798FCB77077BF05
After InvSubBytes: E30E5A0CEB12D865DAE25520D002F436

-- Round 7 --
AddRoundKey (7): 49FFBB5D435C169207BAF86E789D1E1E
State: AAF1E151A84ECEF7DD58AD4EA89FEA28
After InvMixColumns: D9955FF881FA42E66C8AD050C9837AC5
After InvShiftRows: D983D0E681957A506CFA5FC5C98A42F8
After InvSubBytes: E54160F591ADBD6CB814840712CFF6E1

-- Round 6 --
AddRoundKey (6): C571EA8F0AA3ADCF44E6EEFC7F27E670
State: 20308A7A9B0E10A3FCF26AFB6DE81091
After InvMixColumns: 3FCD4E5CBDBD7A5C85F636DAB7D8C2A9
After InvShiftRows: 3FD8365CBDCDC2DA85BD4EA9B7F67A5C
After InvSubBytes: 252D24A7CD80A87A67CDB6B720D6BDA7

-- Round 5 --
AddRoundKey (5): 9D418E6DCFD247404E4543333BC1088C
State: B86CAACA0252EF3A2988F5841B17B52B
After InvMixColumns: 203641E3FA490630274840FFE3D672D5
After InvShiftRows: 20D64030FA3672FF274941D5E34806E3
After InvSubBytes: 544A720814241E7D3DA4F8B54DD4A54D

-- Round 4 --
AddRoundKey (4): D2F286F05293C92D8197047375844BBF
State: 86B8F4F846B7D750BC33FCC63850EEF2
After InvMixColumns: 908286A6262D5B26C825F9A164705A3A
After InvShiftRows: 9070F92626825AA1C82D863A64255BA6
After InvSubBytes: 96D06923231146F1B1FADCA28CC257C5

-- Round 3 --
AddRoundKey (3): A776CD4F80614FDDD304CD5EF4134FCC
State: 31A6A46CA370092C62FE11FC78D11809
After InvMixColumns: F736DC4287EEDA4542E7D307A51AAEA9
After InvShiftRows: F71AD3458736AE0742EEDCA9A5E7DA42
After InvSubBytes: 2643A968EA24BE38F69993B729B07AF6

-- Round 2 --
AddRoundKey (2): 53658283271782925365828327178292
State: 75262BEBCD333CAAA5FC11340EA7F864
After InvMixColumns: D742B4B2C67AE73340810CB134BEA817
After InvShiftRows: D7BE0C33C642A8B1407AB4173481E7B2
After InvSubBytes: 0D5A8166C7F66F5672BDC6872891B03E

-- Round 1 --
AddRoundKey (1): 11060011747200117472001174720011
State: 1C5C8177B3846F4706CFC6965CE3B02F
After InvMixColumns: AF20457C678F85729F9F76EF9F6333EF
After InvShiftRows: AF637672672033EF9F8F45EF9F9F857C
After InvSubBytes: 1B000F1E0A5466616E7368616E6E6701
AddRoundKey (0): 73656372657400000000000000000000
[解密结果] (Hex): 68656C6C6F2066616E7368616E6E6701
==================== 结束 AES 解密 ====================


最终验证:
  原始明文: hello fanshanng
  解密明文: hello fanshanng
  匹配成功: True

The Flare-On Challenge 练习记录

Tue, 16 Dec 2025 22:29:11 +0800

2015 Challenge 3

0x00 查壳与环境识别

使用 DIE (Detect It Easy) 进行初步分析：

分析结果显示程序是由 PyInstaller 打包的。

0x01 解包与反编译

1. PyInstaller 解包

使用 pyinstxtractor.py 对目标文件 elfie.exe (或 elfie) 进行解包：

`1`	`python pyinstxtractor.py elfie`

解包后得到 elfie_extracted 文件夹。

2. 字节码分析

进入解包目录，发现存在 .pyc 文件。在尝试使用反编译工具失败后，发现可以直接查看 .pyc 文件内容。观察到文件头魔数 03 f3 0d 0a 以及目录下的 python27.dll，确认这是 Python 2.7 环境。

直接用文本编辑器查看 .pyc 文件，可以清晰看到 base64、b64decode 等关键字及大量混淆变量。这是 Python 2.7 字节码的一个特征：字符串（包括变量名）以未压缩的 ASCII 形式存储。

反编译后的源码（或直接观察）显示程序使用了典型的 exec(base64.b64decode(...)) 混淆方式：

O0OO0OO00000OOOO0OOOOO0O00O0O0O0 = 'IRGppV0FJM3BRRlNwWGhNNG'
# ... 大量混淆变量定义 ...
O00OO00OOO0OOOO0OOOO0OO00000OOO0 += 'nNocTB'
import base64
exec(base64.b64decode(OOO0OOOOOOOO0000O000O00O0OOOO00O + ...))

0x02 去混淆

为了获取被执行的真实代码，我们不需要手动解密，只需“借力打力”。编写脚本模拟 Loader 的变量拼接过程，但将最后的 exec(...) 替换为文件写入操作。

解包脚本逻辑:

# ... (复制原始文件中的所有变量定义) ...

import base64

# 原始代码: exec(base64.b64decode(...))
# 修改为写入文件:
decoded_code = base64.b64decode(OOO0OOOOOOOO0000O000O00O0OOOO00O + ...)

with open(r'elfie.py', 'wb') as f:
    f.write(decoded_code)
print('Decoded stage 2 saved.')

提取出的代码部分如图所示：

0x03 逻辑分析

提取出的 elfie.py 是一个基于 PySide (Qt) 的图形界面应用程序。

运行效果：

代码中使用了大量的 getattr 和字符串切片（如 'txeTnialPot'[::-1] 即 toPlainText）来隐藏 API 调用，增加了静态分析的难度。

核心验证逻辑: 程序定义了一个继承自 QtGui.QLineEdit 的类，并在 keyPressEvent 中监听回车键。当用户按下回车时，触发验证函数 O000OOOOOO0OOOO00000OO0O0O000OO0。

    def O000OOOOOO0OOOO00000OO0O0O000OO0(self):
        # 获取用户输入: getattr(self, 'toPlainText')()
        O0O0O0000OOO000O00000OOO000OO000 = getattr(self, 'txeTnialPot'[::-1])()
        
        # 核心比对逻辑
        if (O0O0O0000OOO000O00000OOO000OO000 == ''.join((OO00O00OOOO00OO000O00OO0OOOO0000 for OO00O00OOOO00OO000O00OO0OOOO0000 in reversed('moc.no-eralf@OOOOY.sev0000L.eiflE')))):
                self.OO0O0O0O0OO0OO00000OO00O0O0000O0.setWindowTitle('!sseccus taerg'[::-1])
                # ... 显示成功状态 ...

0x04 Flag 获取

分析上述比对逻辑： reversed('moc.no-eralf@OOOOY.sev0000L.eiflE') 会将字符串反转。

直接反转硬编码字符串即可得到 Flag：

`1`	`Elfie.L0000ves.YOOOO@flare-on.com`

0x05 附录：现代环境运行兼容性

直接提取的代码依赖于老旧的 PySide (Qt4) 库。在现代 Python 3 环境中，通常使用 PySide2 (Qt5) 或 PySide6 (Qt6)。

为了让提取的代码在现代环境中运行，可以使用以下垫片代码（Shim）进行兼容：

try:
    from PySide import QtGui, QtCore
except ImportError:
    try:
        from PySide2 import QtGui, QtCore, QtWidgets
        # 将 QtWidgets 中的属性映射回 QtGui，以兼容旧代码
        for name in dir(QtWidgets):
            if not hasattr(QtGui, name):
                setattr(QtGui, name, getattr(QtWidgets, name))
    except ImportError:
        from PySide6 import QtGui, QtCore, QtWidgets
        for name in dir(QtWidgets):
            if not hasattr(QtGui, name):
                setattr(QtGui, name, getattr(QtWidgets, name))

此外，代码中还包含两段 Base64 编码的字符串，分别对应验证成功和失败时显示的图片，感兴趣可以解码还原。

2020 Challenge 1: Fidler

挑战概述

挑战以一个简单的点击游戏形式呈现，玩家需要通过点击猫咪赚取硬币，最终达到约1000亿硬币来赢得游戏并揭示flag。游戏使用Pygame编写，并提供了源代码（fidler.py）和可执行文件（fidler.exe）。

密码保护

游戏启动时会显示密码输入界面，标题为“This program is protected by Flare-On TURBO Nuke v55.7”。

密码检查函数 password_check(input) 的逻辑如下：

def password_check(input):
    altered_key = 'hiptu'
    key = ''.join([chr(ord(x) - 1) for x in altered_key])
    return input == key

altered_key = 'hiptu'
对每个字符的ASCII值减1：h(104)-1=g(103), i(105)-1=h(104), p(112)-1=o(111), t(116)-1=s(115), u(117)-1=t(116)
因此，正确密码为 'ghost'

输入错误密码会显示“FBI警告”界面，包含幽默的威胁文本。

游戏机制

界面：640x480的窗口，显示猫咪图像（kittyelaine.png）、硬币计数、自动点击器计数。
玩法：
- 点击猫咪按钮，每次+1硬币。
- 购买自动点击器（每10硬币一个），每秒自动增加相应数量的硬币。
目标：赚取约1000亿硬币（100 Billion coins）。

胜利条件与Flag解码

在 game_screen() 函数中，检查胜利条件：

target_amount = (2**36) + (2**35)  # 2^36 + 2^35 = 68719476736 + 34359738368 = 103079215104
if current_coins > (target_amount - 2**20):  # 2^20 = 1048576
    while current_coins >= (target_amount + 2**20):
        current_coins -= 2**20
    victory_screen(int(current_coins / 10**8))  # token = current_coins // 100000000
    return

当硬币超过 target_amount - 2**20 时触发胜利。
实际胜利硬币数需 >= target_amount + 2**20 ≈ 103080263680。
token = 103080263680 // 100000000 = 1030（向下取整）。

Flag通过 decode_flag(token) 解码：

def decode_flag(frob):
    last_value = frob  # 初始为1030
    encoded_flag = [1135, 1038, 1126, 1028, 1117, 1071, 1094, 1077, 1121, 1087, 1110, 1092, 1072, 1095, 1090, 1027,
                    1127, 1040, 1137, 1030, 1127, 1099, 1062, 1101, 1123, 1027, 1136, 1054]
    decoded_flag = []
    for i in range(len(encoded_flag)):
        c = encoded_flag[i]
        val = (c - ((i%2)*1 + (i%3)*2)) ^ last_value
        decoded_flag.append(val)
        last_value = c
    return ''.join([chr(x) for x in decoded_flag])

解码公式：val = (c - ((i%2)*1 + (i%3)*2)) ^ last_value
last_value 初始为frob（1030），每次循环后更新为c。

运行解码脚本得到flag：idle_with_kitty@flare-on.com

2020 Challenge 2: garbage

首先打开显示

查DIE发现是upx壳，但是直接upx -d会报错

fanshanng@Ubuntu:/mnt/d/Desktop/challenge/attachments_383/2 - garbage2/2 - garbage$ upx -d garbage.exe
                       Ultimate Packer for eXecutables
                          Copyright (C) 1996 - 2025
UPX 5.0.2       Markus Oberhumer, Laszlo Molnar & John Reiser   Jul 20th 2025

        File size         Ratio      Format      Name
   --------------------   ------   -----------   -----------
upx: garbage.exe: OverlayException: invalid overlay size; file is possibly corrupt

Unpacked 1 file: 0 ok, 1 error.

invalid overlay size; file is possibly corrupt没找到是什么原因，于是去翻看源代码

void Packer::checkOverlay(unsigned overlay)
{
    if ((int)overlay < 0 || (off_t)overlay > file_size)
        throw OverlayException("invalid overlay size; file is possibly corrupt");
    if (overlay == 0)
        return;
    info("Found overlay: %d bytes", overlay);
    if (opt->overlay == opt->SKIP_OVERLAY)
        throw OverlayException("file has overlay -- skipped; try '--overlay=copy'");
}

会发现错误原因overlay > file_size是文件头信息显示文件比实际大小大。这一点在 CFF Explorer 中也能看到：

文件中缺少 41472−40740 = 732 字节。于是我打开了010editor，在结尾补全了732个字节

补全后就可以顺利脱壳了

fanshanng@Ubuntu:/mnt/d/Desktop/challenge/attachments_383/2 - garbage2/2 - garbage$ upx -d garbage.exe
                       Ultimate Packer for eXecutables
                          Copyright (C) 1996 - 2025
UPX 5.0.2       Markus Oberhumer, Laszlo Molnar & John Reiser   Jul 20th 2025

        File size         Ratio      Format      Name
   --------------------   ------   -----------   -----------
     80470 <-     42582   52.92%    win32/pe     garbage.exe

Unpacked 1 file.

但是脱完壳后的程序还是不能直接运行

这里应该是产生了无效的资源数据，在Resource Hacker可以清晰看到

右键点击资源将其删除

但是又会遇到另一个错误

在 CFF Explorer 中查看最新文件的导入目录，可以看到模块名称缺失：

点击其中任何一个都会显示这些 DLL 中的函数：

看到这些函数名，我就可以确定第一个函数是kernel32.dll，第二个函数是shell32.dll。

然后就可以看到输出的flag了

参考文献：

DES 学习笔记

Tue, 16 Dec 2025 16:49:17 +0800

1. 算法概览

全称：Data Encryption Standard (数据加密标准)
类型：对称加密（加密和解密使用同一个密钥）
分组长度：64位 (8字节)
密钥长度：64位 (实际有效位 56位，其余8位为奇偶校验位)
结构：Feistel 网络结构 (16轮迭代)

2. 密钥生成 (Key Schedule)

这是 DES 的第一步，目的是从原始的 64 位密钥中生成 16 个 48 位的子密钥 ($K_1, K_2, …, K_{16}$)。

理论与代码对应详解

PC-1 置换 (64位 -> 56位)
- 理论：原始密钥是 64 位，但其中第 8, 16, 24… 等 8 个位是奇偶校验位，不参与加密。PC-1 表将这 8 位丢弃，并打乱剩余 56 位的顺序。
- 代码实现：
  1 2 3
  
  # 对应代码中的 generate_subkeys 函数 # PC1_TABLE 只有 56 个索引，直接完成了"去校验位"和"乱序"两件事 key_56 = permute(key_bin, PC1_TABLE)
左右拆分
- 理论：将 56 位分为前 28 位 ($C_0$) 和后 28 位 ($D_0$)。
- 代码实现：
  1 2
  
  c = key_56[:28] d = key_56[28:]

16轮循环左移 (Left Shift)

理论：每一轮根据固定的规则左移 1 位或 2 位。这能保证每一轮的子密钥都不同。

代码实现：

# SHIFT_SCHEDULE 定义了每轮左移的位数
# [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]
shift = SHIFT_SCHEDULE[i]
# 辅助函数 left_shift 实现切片拼接：data[n:] + data[:n]
c = left_shift(c, shift) 
d = left_shift(d, shift)

PC-2 置换 (56位 -> 48位)
- 理论：从移位后的 56 位 ($C_i + D_i$) 中选出 48 位，作为本轮的子密钥 $K_i$。
- 代码实现：
  1 2
  
  cd = c + d k = permute(cd, PC2_TABLE) # 再次利用通用置换函数，选出48位

3. 加密主流程 (Feistel 结构)

DES 的核心是 16 轮迭代，加上头尾的两个置换。

理论与代码对应详解

初始置换 (IP)
- 理论：将 64 位明文按照 IP 表打乱。
- 代码实现：ip_data = permute(data_bin, IP_TABLE)
左右拆分
- 理论：$L_0$ (前32位), $R_0$ (后32位)。
- 代码实现：l, r = ip_data[:32], ip_data[32:]

16 轮迭代 (Round Function)

理论公式：
- $L_i = R_{i-1}$
- $R_i = L_{i-1} \oplus f(R_{i-1}, K_i)$

代码核心逻辑 (des_process 函数中)：

for i in range(16):
    prev_l = l
    prev_r = r

    # 新的左边 = 旧的右边
    l = prev_r

    # 新的右边 = 旧的左边 XOR 轮函数结果
    # f_function 是核心复杂部分，见下文详解
    f_res = f_function(prev_r, subkeys[i], verbose)
    r = xor(prev_l, f_res)

32位互换与逆初始置换
- 理论：标准 DES 在第 16 轮后，输出是 $R_{16}L_{16}$（注意不是 $L_{16}R_{16}$）。然后进行 $IP^{-1}$。
- 代码实现：
  1 2
  
  final_rl = r + l # 注意这里是 r + l，实现了32位互换 cipher_bin = permute(final_rl, IP_INV_TABLE)

💡 重点：解密过程

解密过程与加密完全相同，唯一的区别是子密钥的使用顺序相反 ($K_{16} \to K_1$)。

代码实现：

1
2

if mode == 'decrypt':
    subkeys = subkeys[::-1] # Python 列表切片反转

4. 核心：轮函数 $f(R, K)$

这是 DES 最复杂的部分，输入 32 位数据 $R$，与 48 位子密钥 $K$ 混合，输出 32 位结果。

理论与代码对应详解

E 扩展置换 (Expansion)
- 理论：将 32 位扩展为 48 位，让数据长度匹配子密钥。
- 代码实现：expanded_r = permute(right_data, E_BOX_TABLE)
密钥加 (XOR)
- 理论：数据与子密钥进行异或运算。
- 代码实现：xored = xor(expanded_r, subkey)

S 盒代换 (Substitution) —— 关键难点

理论：将 48 位压缩回 32 位。48位被分为 8 组，每组 6 位。每组 6 位通过查表变成 4 位。

代码细节详解：

# 遍历 8 个 S盒
for i in range(8):
    chunk = xored[i*6 : (i+1)*6] # 取出 6 位，例如 "101101"

    # 行号计算：取第1位和第6位 ("1...1" -> "11" -> 3)
    row = int(chunk[0] + chunk[5], 2)

    # 列号计算：取中间4位 ("0110" -> 6)
    col = int(chunk[1:5], 2)

    # 查表并转回 4位二进制字符串
    val = S_BOXES[i][row][col]
    s_box_output += format(val, '04b')

P 盒置换 (Permutation)
- 理论：将 S 盒输出的 32 位再次打乱，让某一位的变化能扩散到下一轮的更多位中。
- 代码实现：p_box_output = permute(s_box_output, P_BOX_TABLE)

5. 工程化处理：分组与填充

标准的 DES 只能处理 64 位 (8字节) 的数据块。如果明文长度不是 8 字节的整数倍，或者超过 8 字节，就需要进行填充 (Padding) 和 分组模式 (Block Cipher Mode) 处理。

5.1 PKCS#5 填充

最常见的填充方式是 PKCS#5 (对于 8 字节分组也常称为 PKCS#7)。规则：缺 $N$ 个字节，就填充 $N$ 个数值为 $N$ 的字节。

如果刚好是 8 字节倍数，则填充 8 个 0x08。
数据 ABCDE (5字节)，缺 3 字节 $\to$ 填充 3 个 0x03 $\to$ ABCDE\x03\x03\x03。数据刚好 8 字节 $\to$ 填充 8 个 0x08 (增加一个完整块，以便解密时知道有填充)。

5.2 密钥处理

过短：通常用 \0 补齐，或重复密钥。
过长：直接截断取前 8 字节，或进行 Hash 运算 (如 MD5) 取前 8 字节。

5.3 ECB 模式 (Electronic Codebook)(电子密码本模式)

最简单的分组模式。将明文分成 8 字节的块，每块独立加密。

优点：简单，可并行。
缺点：相同的明文块会产生相同的密文块，容易被模式分析。

附：CBC (密码分组链接模式)：更安全。当前明文块先与前一个密文块异或，再加密。

5.3 常见疑问：密钥过长怎么办？

很多初学者会有疑问：如果密钥长度超过 8 字节，是取前 8 字节，还是也进行分组？

答案是：标准 DES 密钥必须是 8 字节。

截断 (Truncation)：
- 大多数简单的 DES 实现（包括本代码）如果收到长密钥，只会读取前 64 位（8字节）参与密钥生成（PC-1 置换只看前 64 位），后面的部分会被直接忽略。
- 并不会出现“用密钥的第一组加密明文第一组，用密钥第二组加密明文第二组”的情况。密钥在整个通信过程中必须是固定的。
3DES (Triple DES)：
- 如果需要使用更长的密钥（如 16 字节或 24 字节）来提升安全性，标准做法是使用 3DES。
- 3DES 实际上是运行三次 DES：$C = E_{K3}(D_{K2}(E_{K1}(P)))$。
工程实践：
- 在实际工程中，如果用户输入了一个长密码（Passphrase），通常会使用哈希函数（如 SHA-256）将其转换为固定长度的摘要，然后截取前 8 字节作为 DES 密钥。

6. 附录：完整 Python 实现代码

import sys

# =============================================================================
# DES 算法常量定义 (标准表)
# =============================================================================

# 初始置换表 (IP)
IP_TABLE = [
    58, 50, 42, 34, 26, 18, 10, 2,
    60, 52, 44, 36, 28, 20, 12, 4,
    62, 54, 46, 38, 30, 22, 14, 6,
    64, 56, 48, 40, 32, 24, 16, 8,
    57, 49, 41, 33, 25, 17, 9, 1,
    59, 51, 43, 35, 27, 19, 11, 3,
    61, 53, 45, 37, 29, 21, 13, 5,
    63, 55, 47, 39, 31, 23, 15, 7
]

# 逆初始置换表 (IP^-1)
IP_INV_TABLE = [
    40, 8, 48, 16, 56, 24, 64, 32,
    39, 7, 47, 15, 55, 23, 63, 31,
    38, 6, 46, 14, 54, 22, 62, 30,
    37, 5, 45, 13, 53, 21, 61, 29,
    36, 4, 44, 12, 52, 20, 60, 28,
    35, 3, 43, 11, 51, 19, 59, 27,
    34, 2, 42, 10, 50, 18, 58, 26,
    33, 1, 41, 9, 49, 17, 57, 25
]

# 扩展置换表 (E-Box): 32位 -> 48位
E_BOX_TABLE = [
    32, 1, 2, 3, 4, 5,
    4, 5, 6, 7, 8, 9,
    8, 9, 10, 11, 12, 13,
    12, 13, 14, 15, 16, 17,
    16, 17, 18, 19, 20, 21,
    20, 21, 22, 23, 24, 25,
    24, 25, 26, 27, 28, 29,
    28, 29, 30, 31, 32, 1
]

# P盒置换表 (P-Box): 32位 -> 32位
P_BOX_TABLE = [
    16, 7, 20, 21,
    29, 12, 28, 17,
    1, 15, 23, 26,
    5, 18, 31, 10,
    2, 8, 24, 14,
    32, 27, 3, 9,
    19, 13, 30, 6,
    22, 11, 4, 25
]

# 密钥置换表 1 (PC-1): 64位 -> 56位 (去掉了校验位)
PC1_TABLE = [
    57, 49, 41, 33, 25, 17, 9,
    1, 58, 50, 42, 34, 26, 18,
    10, 2, 59, 51, 43, 35, 27,
    19, 11, 3, 60, 52, 44, 36,
    63, 55, 47, 39, 31, 23, 15,
    7, 62, 54, 46, 38, 30, 22,
    14, 6, 61, 53, 45, 37, 29,
    21, 13, 5, 28, 20, 12, 4
]

# 密钥置换表 2 (PC-2): 56位 -> 48位
PC2_TABLE = [
    14, 17, 11, 24, 1, 5,
    3, 28, 15, 6, 21, 10,
    23, 19, 12, 4, 26, 8,
    16, 7, 27, 20, 13, 2,
    41, 52, 31, 37, 47, 55,
    30, 40, 51, 45, 33, 48,
    44, 49, 39, 56, 34, 53,
    46, 42, 50, 36, 29, 32
]

# 密钥左移位数表 (每轮左移的位数)
SHIFT_SCHEDULE = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]

# S盒 (S-Boxes): 8个 S盒，每个将 6位 映射为 4位
S_BOXES = [
    # S1
    [
        [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
        [0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
        [4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
        [15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]
    ],
    # S2
    [
        [15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
        [3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
        [0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
        [13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]
    ],
    # S3
    [
        [10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
        [13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
        [13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
        [1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]
    ],
    # S4
    [
        [7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
        [13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],
        [10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
        [3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]
    ],
    # S5
    [
        [2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
        [14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
        [4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
        [11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]
    ],
    # S6
    [
        [12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
        [10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
        [9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
        [4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]
    ],
    # S7
    [
        [4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
        [13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
        [1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
        [6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]
    ],
    # S8
    [
        [13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
        [1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
        [7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
        [2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]
    ]
]

# =============================================================================
# 辅助工具函数
# =============================================================================

def str_to_bin(text):
    """将字符串转换为二进制字符串 (每个字符8位)"""
    return ''.join(format(ord(c), '08b') for c in text)

def bin_to_str(binary):
    """将二进制字符串转换为 ASCII 字符串"""
    # 每8位一组
    chars = [binary[i:i+8] for i in range(0, len(binary), 8)]
    return ''.join(chr(int(c, 2)) for c in chars)

def hex_to_bin(hex_str):
    """将十六进制字符串转换为二进制字符串"""
    # 每个hex字符对应4位bin
    return ''.join(format(int(c, 16), '04b') for c in hex_str)

def bin_to_hex(binary):
    """将二进制字符串转换为十六进制字符串"""
    # 每4位一组
    hex_str = ""
    for i in range(0, len(binary), 4):
        chunk = binary[i:i+4]
        hex_str += format(int(chunk, 2), 'x').upper()
    return hex_str

def permute(data, table):
    """
    通用置换函数
    data: 输入的二进制字符串
    table: 置换表 (1-based index)
    """
    return ''.join(data[i - 1] for i in table)

def xor(a, b):
    """对两个等长的二进制字符串进行异或运算"""
    return ''.join('1' if x != y else '0' for x, y in zip(a, b))

def left_shift(data, n):
    """循环左移 n 位"""
    return data[n:] + data[:n]

# =============================================================================
# 填充与密钥处理 (新增)
# =============================================================================

def pkcs7_pad(text):
    """PKCS#7 填充: 将文本填充为 8 的倍数"""
    pad_len = 8 - (len(text) % 8)
    padding = chr(pad_len) * pad_len
    return text + padding

def pkcs7_unpad(text):
    """PKCS#7 去填充"""
    pad_len = ord(text[-1])
    return text[:-pad_len]

def process_key(key_str):
    """处理密钥: 确保是 8 字节"""
    # 如果太短，补 \0
    if len(key_str) < 8:
        return key_str.ljust(8, '\0')
    # 如果太长，截断 (实际应用中通常做 Hash)
    elif len(key_str) > 8:
        return key_str[:8]
    return key_str

# =============================================================================
# 核心逻辑函数
# =============================================================================

def generate_subkeys(key_bin, verbose=False):
    """
    生成 16 个 48 位的子密钥
    key_bin: 64位二进制密钥
    """
    if verbose:
        print(f"\n[密钥生成] 原始密钥 (64位): {key_bin}")

    # 1. PC-1 置换 (64位 -> 56位)
    key_56 = permute(key_bin, PC1_TABLE)
    if verbose:
        print(f"[密钥生成] PC-1置换后 (56位): {key_56}")

    # 分为左右两部分 C0, D0
    c = key_56[:28]
    d = key_56[28:]
    
    subkeys = []
    for i in range(16):
        # 2. 循环左移
        shift = SHIFT_SCHEDULE[i]
        c = left_shift(c, shift)
        d = left_shift(d, shift)
        
        # 合并
        cd = c + d
        
        # 3. PC-2 置换 (56位 -> 48位)
        k = permute(cd, PC2_TABLE)
        subkeys.append(k)
        
        if verbose:
            print(f"  Round {i+1:2d}: 左移 {shift} 位 -> 子密钥: {bin_to_hex(k)}")
            
    return subkeys

def f_function(right_data, subkey, verbose=False):
    """
    Feistel 轮函数 f(R, K)
    right_data: 32位
    subkey: 48位
    """
    # 1. 扩展置换 E (32 -> 48)
    expanded_r = permute(right_data, E_BOX_TABLE)
    
    # 2. 与子密钥异或
    xored = xor(expanded_r, subkey)
    
    # 3. S盒代换 (48 -> 32)
    # 将48位分为8组，每组6位
    s_box_output = ""
    for i in range(8):
        chunk = xored[i*6 : (i+1)*6]
        
        # 行号：第1位和第6位
        row = int(chunk[0] + chunk[5], 2)
        # 列号：第2,3,4,5位
        col = int(chunk[1:5], 2)
        
        # 查表
        val = S_BOXES[i][row][col]
        # 转为4位二进制
        s_box_output += format(val, '04b')
        
    # 4. P盒置换 (32 -> 32)
    p_box_output = permute(s_box_output, P_BOX_TABLE)
    
    return p_box_output

def des_process(data_bin, key_bin, mode='encrypt', verbose=True):
    """
    DES 核心处理流程 (加密/解密共用)
    data_bin: 64位数据
    key_bin: 64位密钥
    mode: 'encrypt' 或 'decrypt'
    """
    action_name = "加密" if mode == 'encrypt' else "解密"
    if verbose:
        print(f"\n{'='*20} 开始 DES {action_name} (单块) {'='*20}")
        print(f"输入数据 (Hex): {bin_to_hex(data_bin)}")
        print(f"密钥     (Hex): {bin_to_hex(key_bin)}")

    # 1. 生成子密钥
    subkeys = generate_subkeys(key_bin, verbose=verbose)
    
    # 如果是解密，子密钥顺序反转
    if mode == 'decrypt':
        subkeys = subkeys[::-1]
        if verbose:
            print(f"\n[注意] 解密模式：子密钥顺序已反转")

    # 2. 初始置换 IP
    ip_data = permute(data_bin, IP_TABLE)
    if verbose:
        print(f"\n[初始置换 IP] 结果: {bin_to_hex(ip_data)}")

    # 将数据分为左右两部分 L0, R0
    l = ip_data[:32]
    r = ip_data[32:]
    
    if verbose:
        print(f"初始 L0: {bin_to_hex(l)}")
        print(f"初始 R0: {bin_to_hex(r)}")
        print("-" * 60)

    # 3. 16轮迭代
    for i in range(16):
        prev_l = l
        prev_r = r
        
        # L(i) = R(i-1)
        l = prev_r
        
        # R(i) = L(i-1) XOR f(R(i-1), K(i))
        f_res = f_function(prev_r, subkeys[i], verbose)
        r = xor(prev_l, f_res)
        
        if verbose:
            print(f"Round {i+1:2d}:")
            print(f"  K{i+1 if mode=='encrypt' else 16-i}: {bin_to_hex(subkeys[i])}")
            print(f"  L{i+1}: {bin_to_hex(l)} (from old R)")
            print(f"  f(R,K): {bin_to_hex(f_res)}")
            print(f"  R{i+1}: {bin_to_hex(r)} (L XOR f)")

    # 4. 32位互换
    final_rl = r + l
    if verbose:
        print("-" * 60)
        print(f"[32位互换] 结果 (R16 L16): {bin_to_hex(final_rl)}")

    # 5. 逆初始置换 IP^-1
    cipher_bin = permute(final_rl, IP_INV_TABLE)
    
    if verbose:
        print(f"\n[{action_name}结果] (Hex): {bin_to_hex(cipher_bin)}")
        print(f"{'='*20} 结束 DES {action_name} {'='*20}\n")
    
    return cipher_bin

# =============================================================================
# 高级接口 (支持不定长数据)
# =============================================================================

def des_encrypt_ecb(text, key, verbose=False):
    """ECB 模式加密"""
    key = process_key(key)
    key_bin = str_to_bin(key)
    
    # 1. 填充
    text_padded = pkcs7_pad(text)
    print(f"原始长度: {len(text)}, 填充后长度: {len(text_padded)}")
    
    ciphertext_hex = ""
    
    # 2. 分组处理
    for i in range(0, len(text_padded), 8):
        block = text_padded[i:i+8]
        print(f"\n>>> 处理第 {i//8 + 1} 块: {block}")
        block_bin = str_to_bin(block)
        cipher_bin = des_process(block_bin, key_bin, mode='encrypt', verbose=verbose)
        ciphertext_hex += bin_to_hex(cipher_bin)
        
    return ciphertext_hex

def des_decrypt_ecb(hex_str, key, verbose=False):
    """ECB 模式解密"""
    key = process_key(key)
    key_bin = str_to_bin(key)
    
    plaintext = ""
    
    # 1. 分组处理
    for i in range(0, len(hex_str), 16):
        block_hex = hex_str[i:i+16]
        print(f"\n>>> 处理第 {i//16 + 1} 块 (Hex): {block_hex}")
        block_bin = hex_to_bin(block_hex)
        plain_bin = des_process(block_bin, key_bin, mode='decrypt', verbose=verbose)
        plaintext += bin_to_str(plain_bin)
        
    # 2. 去填充
    return pkcs7_unpad(plaintext)

# =============================================================================
# 用户接口
# =============================================================================

def main():
    # 示例：不定长数据和短密钥
    raw_key = "secret"  # 6字节 (不足8字节)
    raw_text = "hello fanshanng" # 15字节
    
    print(f"原始明文: {raw_text}")
    print(f"原始密钥: {raw_key}")
    
    # 1. 加密
    print("\n开始加密...")
    # verbose=False 避免打印太多细节，只看分组流程
    cipher_hex = des_encrypt_ecb(raw_text, raw_key, verbose=False)
    print(f"\n最终密文 (Hex): {cipher_hex}")
    
    # 2. 解密
    print("\n开始解密...")
    decrypted_text = des_decrypt_ecb(cipher_hex, raw_key, verbose=False)
    
    print(f"\n最终验证:")
    print(f"  原始明文: {raw_text}")
    print(f"  解密明文: {decrypted_text}")
    print(f"  匹配成功: {raw_text == decrypted_text}")

if __name__ == "__main__":
    main()

7. 附录：运行结果示例

注意：运行日志保留了加密过程，实际使用中可以通过设置verbose的值来显示/隐藏。

点击展开查看完整运行日志

原始明文: hello fanshanng
原始密钥: secret

开始加密...
原始长度: 15, 填充后长度: 16

>>> 处理第 1 块: hello fa

==================== 开始 DES 加密 (单块) ===================
=                                                            输入数据 (Hex): 68656C6C6F206661
密钥     (Hex): 7365637265740000

[密钥生成] 原始密钥 (64位): 011100110110010101100011011100100
1100101011101000000000000000000                              [密钥生成] PC-1置换后 (56位): 0000000000111111001111110010000
0110100110010000000001001                                      Round  1: 左移 1 位 -> 子密钥: A0BE86442211
  Round  2: 左移 1 位 -> 子密钥: E03606B08081
  Round  3: 左移 2 位 -> 子密钥: 609E74420607
  Round  4: 左移 2 位 -> 子密钥: C4F0721E2188
  Round  5: 左移 2 位 -> 子密钥: A6C772205141
  Round  6: 左移 2 位 -> 子密钥: EE530342A022
  Round  7: 左移 2 位 -> 子密钥: 2B9359E40D08
  Round  8: 左移 2 位 -> 子密钥: 0D50DB08125A
  Round  9: 左移 1 位 -> 子密钥: 1D43D8C80560
  Round 10: 左移 2 位 -> 子密钥: 16599908CA0C
  Round 11: 左移 2 位 -> 子密钥: 1F2945505490
  Round 12: 左移 2 位 -> 子密钥: 0B6C8D890029
  Round 13: 左移 2 位 -> 子密钥: 5925AC827A00
  Round 14: 左移 2 位 -> 子密钥: D08CA9300334
  Round 15: 左移 2 位 -> 子密钥: D1AA26910882
  Round 16: 左移 1 位 -> 子密钥: B0AE2E0123C4

[初始置换 IP] 结果: DF005E9200FF1D50
初始 L0: DF005E92
初始 R0: 00FF1D50
------------------------------------------------------------ 
Round  1:
  K1: A0BE86442211
  L1: 00FF1D50 (from old R)
  f(R,K): ED9BF922
  R1: 329BA7B0 (L XOR f)
Round  2:
  K2: E03606B08081
  L2: 329BA7B0 (from old R)
  f(R,K): E13F4440
  R2: E1C05910 (L XOR f)
Round  3:
  K3: 609E74420607
  L3: E1C05910 (from old R)
  f(R,K): F7D9E90A
  R3: C5424EBA (L XOR f)
Round  4:
  K4: C4F0721E2188
  L4: C5424EBA (from old R)
  f(R,K): 1057B4FD
  R4: F197EDED (L XOR f)
Round  5:
  K5: A6C772205141
  L5: F197EDED (from old R)
  f(R,K): 54E93256
  R5: 91AB7CEC (L XOR f)
Round  6:
  K6: EE530342A022
  L6: 91AB7CEC (from old R)
  f(R,K): 6448A9B5
  R6: 95DF4458 (L XOR f)
Round  7:
  K7: 2B9359E40D08
  L7: 95DF4458 (from old R)
  f(R,K): 7057F913
  R7: E1FC85FF (L XOR f)
Round  8:
  K8: 0D50DB08125A
  L8: E1FC85FF (from old R)
  f(R,K): 28EFD137
  R8: BD30956F (L XOR f)
Round  9:
  K9: 1D43D8C80560
  L9: BD30956F (from old R)
  f(R,K): 1887DA46
  R9: F97B5FB9 (L XOR f)
Round 10:
  K10: 16599908CA0C
  L10: F97B5FB9 (from old R)
  f(R,K): 7CBA0E4C
  R10: C18A9B23 (L XOR f)
Round 11:
  K11: 1F2945505490
  L11: C18A9B23 (from old R)
  f(R,K): D9AFC90B
  R11: 20D496B2 (L XOR f)
Round 12:
  K12: 0B6C8D890029
  L12: 20D496B2 (from old R)
  f(R,K): B31E0DF2
  R12: 729496D1 (L XOR f)
Round 13:
  K13: 5925AC827A00
  L13: 729496D1 (from old R)
  f(R,K): AF7A0F53
  R13: 8FAE99E1 (L XOR f)
Round 14:
  K14: D08CA9300334
  L14: 8FAE99E1 (from old R)
  f(R,K): D46C878B
  R14: A6F8115A (L XOR f)
Round 15:
  K15: D1AA26910882
  L15: A6F8115A (from old R)
  f(R,K): E5189084
  R15: 6AB60965 (L XOR f)
Round 16:
  K16: B0AE2E0123C4
  L16: 6AB60965 (from old R)
  f(R,K): 93045CD9
  R16: 35FC4D83 (L XOR f)
------------------------------------------------------------ 
[32位互换] 结果 (R16 L16): 35FC4D836AB60965

[加密结果] (Hex): 4FA1769C70F29631
==================== 结束 DES 加密 ====================      


>>> 处理第 2 块: nshanng

==================== 开始 DES 加密 (单块) ===================
=                                                            输入数据 (Hex): 6E7368616E6E6701
密钥     (Hex): 7365637265740000

[密钥生成] 原始密钥 (64位): 011100110110010101100011011100100
1100101011101000000000000000000                              [密钥生成] PC-1置换后 (56位): 0000000000111111001111110010000
0110100110010000000001001                                      Round  1: 左移 1 位 -> 子密钥: A0BE86442211
  Round  2: 左移 1 位 -> 子密钥: E03606B08081
  Round  3: 左移 2 位 -> 子密钥: 609E74420607
  Round  4: 左移 2 位 -> 子密钥: C4F0721E2188
  Round  5: 左移 2 位 -> 子密钥: A6C772205141
  Round  6: 左移 2 位 -> 子密钥: EE530342A022
  Round  7: 左移 2 位 -> 子密钥: 2B9359E40D08
  Round  8: 左移 2 位 -> 子密钥: 0D50DB08125A
  Round  9: 左移 1 位 -> 子密钥: 1D43D8C80560
  Round 10: 左移 2 位 -> 子密钥: 16599908CA0C
  Round 11: 左移 2 位 -> 子密钥: 1F2945505490
  Round 12: 左移 2 位 -> 子密钥: 0B6C8D890029
  Round 13: 左移 2 位 -> 子密钥: 5925AC827A00
  Round 14: 左移 2 位 -> 子密钥: D08CA9300334
  Round 15: 左移 2 位 -> 子密钥: D1AA26910882
  Round 16: 左移 1 位 -> 子密钥: B0AE2E0123C4

[初始置换 IP] 结果: 7F0271CA007F3573
初始 L0: 7F0271CA
初始 R0: 007F3573
------------------------------------------------------------ 
Round  1:
  K1: A0BE86442211
  L1: 007F3573 (from old R)
  f(R,K): E3311305
  R1: 9C3362CF (L XOR f)
Round  2:
  K2: E03606B08081
  L2: 9C3362CF (from old R)
  f(R,K): 12526FF1
  R2: 122D5A82 (L XOR f)
Round  3:
  K3: 609E74420607
  L3: 122D5A82 (from old R)
  f(R,K): 9A973D7F
  R3: 06A45FB0 (L XOR f)
Round  4:
  K4: C4F0721E2188
  L4: 06A45FB0 (from old R)
  f(R,K): 2D61EC83
  R4: 3F4CB601 (L XOR f)
Round  5:
  K5: A6C772205141
  L5: 3F4CB601 (from old R)
  f(R,K): FB826C35
  R5: FD263385 (L XOR f)
Round  6:
  K6: EE530342A022
  L6: FD263385 (from old R)
  f(R,K): B1C4E5B3
  R6: 8E8853B2 (L XOR f)
Round  7:
  K7: 2B9359E40D08
  L7: 8E8853B2 (from old R)
  f(R,K): 7B44D49F
  R7: 8662E71A (L XOR f)
Round  8:
  K8: 0D50DB08125A
  L8: 8662E71A (from old R)
  f(R,K): EB40BF7C
  R8: 65C8ECCE (L XOR f)
Round  9:
  K9: 1D43D8C80560
  L9: 65C8ECCE (from old R)
  f(R,K): 21455B31
  R9: A727BC2B (L XOR f)
Round 10:
  K10: 16599908CA0C
  L10: A727BC2B (from old R)
  f(R,K): C80AD43B
  R10: ADC238F5 (L XOR f)
Round 11:
  K11: 1F2945505490
  L11: ADC238F5 (from old R)
  f(R,K): C481D96D
  R11: 63A66546 (L XOR f)
Round 12:
  K12: 0B6C8D890029
  L12: 63A66546 (from old R)
  f(R,K): C9BB716D
  R12: 64794998 (L XOR f)
Round 13:
  K13: 5925AC827A00
  L13: 64794998 (from old R)
  f(R,K): 82D5154B
  R13: E173700D (L XOR f)
Round 14:
  K14: D08CA9300334
  L14: E173700D (from old R)
  f(R,K): DA486AA4
  R14: BE31233C (L XOR f)
Round 15:
  K15: D1AA26910882
  L15: BE31233C (from old R)
  f(R,K): 42C8DCE9
  R15: A3BBACE4 (L XOR f)
Round 16:
  K16: B0AE2E0123C4
  L16: A3BBACE4 (from old R)
  f(R,K): 920A0F2E
  R16: 2C3B2C12 (L XOR f)
------------------------------------------------------------ 
[32位互换] 结果 (R16 L16): 2C3B2C12A3BBACE4

[加密结果] (Hex): B0B14E7C31FE02AA
==================== 结束 DES 加密 ====================      


最终密文 (Hex): 4FA1769C70F29631B0B14E7C31FE02AA

开始解密...

>>> 处理第 1 块 (Hex): 4FA1769C70F29631

==================== 开始 DES 解密 (单块) ===================
=                                                            输入数据 (Hex): 4FA1769C70F29631
密钥     (Hex): 7365637265740000

[密钥生成] 原始密钥 (64位): 011100110110010101100011011100100
1100101011101000000000000000000                              [密钥生成] PC-1置换后 (56位): 0000000000111111001111110010000
0110100110010000000001001                                      Round  1: 左移 1 位 -> 子密钥: A0BE86442211
  Round  2: 左移 1 位 -> 子密钥: E03606B08081
  Round  3: 左移 2 位 -> 子密钥: 609E74420607
  Round  4: 左移 2 位 -> 子密钥: C4F0721E2188
  Round  5: 左移 2 位 -> 子密钥: A6C772205141
  Round  6: 左移 2 位 -> 子密钥: EE530342A022
  Round  7: 左移 2 位 -> 子密钥: 2B9359E40D08
  Round  8: 左移 2 位 -> 子密钥: 0D50DB08125A
  Round  9: 左移 1 位 -> 子密钥: 1D43D8C80560
  Round 10: 左移 2 位 -> 子密钥: 16599908CA0C
  Round 11: 左移 2 位 -> 子密钥: 1F2945505490
  Round 12: 左移 2 位 -> 子密钥: 0B6C8D890029
  Round 13: 左移 2 位 -> 子密钥: 5925AC827A00
  Round 14: 左移 2 位 -> 子密钥: D08CA9300334
  Round 15: 左移 2 位 -> 子密钥: D1AA26910882
  Round 16: 左移 1 位 -> 子密钥: B0AE2E0123C4

[注意] 解密模式：子密钥顺序已反转

[初始置换 IP] 结果: 35FC4D836AB60965
初始 L0: 35FC4D83
初始 R0: 6AB60965
------------------------------------------------------------ 
Round  1:
  K16: B0AE2E0123C4
  L1: 6AB60965 (from old R)
  f(R,K): 93045CD9
  R1: A6F8115A (L XOR f)
Round  2:
  K15: D1AA26910882
  L2: A6F8115A (from old R)
  f(R,K): E5189084
  R2: 8FAE99E1 (L XOR f)
Round  3:
  K14: D08CA9300334
  L3: 8FAE99E1 (from old R)
  f(R,K): D46C878B
  R3: 729496D1 (L XOR f)
Round  4:
  K13: 5925AC827A00
  L4: 729496D1 (from old R)
  f(R,K): AF7A0F53
  R4: 20D496B2 (L XOR f)
Round  5:
  K12: 0B6C8D890029
  L5: 20D496B2 (from old R)
  f(R,K): B31E0DF2
  R5: C18A9B23 (L XOR f)
Round  6:
  K11: 1F2945505490
  L6: C18A9B23 (from old R)
  f(R,K): D9AFC90B
  R6: F97B5FB9 (L XOR f)
Round  7:
  K10: 16599908CA0C
  L7: F97B5FB9 (from old R)
  f(R,K): 7CBA0E4C
  R7: BD30956F (L XOR f)
Round  8:
  K9: 1D43D8C80560
  L8: BD30956F (from old R)
  f(R,K): 1887DA46
  R8: E1FC85FF (L XOR f)
Round  9:
  K8: 0D50DB08125A
  L9: E1FC85FF (from old R)
  f(R,K): 28EFD137
  R9: 95DF4458 (L XOR f)
Round 10:
  K7: 2B9359E40D08
  L10: 95DF4458 (from old R)
  f(R,K): 7057F913
  R10: 91AB7CEC (L XOR f)
Round 11:
  K6: EE530342A022
  L11: 91AB7CEC (from old R)
  f(R,K): 6448A9B5
  R11: F197EDED (L XOR f)
Round 12:
  K5: A6C772205141
  L12: F197EDED (from old R)
  f(R,K): 54E93256
  R12: C5424EBA (L XOR f)
Round 13:
  K4: C4F0721E2188
  L13: C5424EBA (from old R)
  f(R,K): 1057B4FD
  R13: E1C05910 (L XOR f)
Round 14:
  K3: 609E74420607
  L14: E1C05910 (from old R)
  f(R,K): F7D9E90A
  R14: 329BA7B0 (L XOR f)
Round 15:
  K2: E03606B08081
  L15: 329BA7B0 (from old R)
  f(R,K): E13F4440
  R15: 00FF1D50 (L XOR f)
Round 16:
  K1: A0BE86442211
  L16: 00FF1D50 (from old R)
  f(R,K): ED9BF922
  R16: DF005E92 (L XOR f)
------------------------------------------------------------ 
[32位互换] 结果 (R16 L16): DF005E9200FF1D50

[解密结果] (Hex): 68656C6C6F206661
==================== 结束 DES 解密 ====================      


>>> 处理第 2 块 (Hex): B0B14E7C31FE02AA

==================== 开始 DES 解密 (单块) ===================
=                                                            输入数据 (Hex): B0B14E7C31FE02AA
密钥     (Hex): 7365637265740000

[密钥生成] 原始密钥 (64位): 011100110110010101100011011100100
1100101011101000000000000000000                              [密钥生成] PC-1置换后 (56位): 0000000000111111001111110010000
0110100110010000000001001                                      Round  1: 左移 1 位 -> 子密钥: A0BE86442211
  Round  2: 左移 1 位 -> 子密钥: E03606B08081
  Round  3: 左移 2 位 -> 子密钥: 609E74420607
  Round  4: 左移 2 位 -> 子密钥: C4F0721E2188
  Round  5: 左移 2 位 -> 子密钥: A6C772205141
  Round  6: 左移 2 位 -> 子密钥: EE530342A022
  Round  7: 左移 2 位 -> 子密钥: 2B9359E40D08
  Round  8: 左移 2 位 -> 子密钥: 0D50DB08125A
  Round  9: 左移 1 位 -> 子密钥: 1D43D8C80560
  Round 10: 左移 2 位 -> 子密钥: 16599908CA0C
  Round 11: 左移 2 位 -> 子密钥: 1F2945505490
  Round 12: 左移 2 位 -> 子密钥: 0B6C8D890029
  Round 13: 左移 2 位 -> 子密钥: 5925AC827A00
  Round 14: 左移 2 位 -> 子密钥: D08CA9300334
  Round 15: 左移 2 位 -> 子密钥: D1AA26910882
  Round 16: 左移 1 位 -> 子密钥: B0AE2E0123C4

[注意] 解密模式：子密钥顺序已反转

[初始置换 IP] 结果: 2C3B2C12A3BBACE4
初始 L0: 2C3B2C12
初始 R0: A3BBACE4
------------------------------------------------------------ 
Round  1:
  K16: B0AE2E0123C4
  L1: A3BBACE4 (from old R)
  f(R,K): 920A0F2E
  R1: BE31233C (L XOR f)
Round  2:
  K15: D1AA26910882
  L2: BE31233C (from old R)
  f(R,K): 42C8DCE9
  R2: E173700D (L XOR f)
Round  3:
  K14: D08CA9300334
  L3: E173700D (from old R)
  f(R,K): DA486AA4
  R3: 64794998 (L XOR f)
Round  4:
  K13: 5925AC827A00
  L4: 64794998 (from old R)
  f(R,K): 82D5154B
  R4: 63A66546 (L XOR f)
Round  5:
  K12: 0B6C8D890029
  L5: 63A66546 (from old R)
  f(R,K): C9BB716D
  R5: ADC238F5 (L XOR f)
Round  6:
  K11: 1F2945505490
  L6: ADC238F5 (from old R)
  f(R,K): C481D96D
  R6: A727BC2B (L XOR f)
Round  7:
  K10: 16599908CA0C
  L7: A727BC2B (from old R)
  f(R,K): C80AD43B
  R7: 65C8ECCE (L XOR f)
Round  8:
  K9: 1D43D8C80560
  L8: 65C8ECCE (from old R)
  f(R,K): 21455B31
  R8: 8662E71A (L XOR f)
Round  9:
  K8: 0D50DB08125A
  L9: 8662E71A (from old R)
  f(R,K): EB40BF7C
  R9: 8E8853B2 (L XOR f)
Round 10:
  K7: 2B9359E40D08
  L10: 8E8853B2 (from old R)
  f(R,K): 7B44D49F
  R10: FD263385 (L XOR f)
Round 11:
  K6: EE530342A022
  L11: FD263385 (from old R)
  f(R,K): B1C4E5B3
  R11: 3F4CB601 (L XOR f)
Round 12:
  K5: A6C772205141
  L12: 3F4CB601 (from old R)
  f(R,K): FB826C35
  R12: 06A45FB0 (L XOR f)
Round 13:
  K4: C4F0721E2188
  L13: 06A45FB0 (from old R)
  f(R,K): 2D61EC83
  R13: 122D5A82 (L XOR f)
Round 14:
  K3: 609E74420607
  L14: 122D5A82 (from old R)
  f(R,K): 9A973D7F
  R14: 9C3362CF (L XOR f)
Round 15:
  K2: E03606B08081
  L15: 9C3362CF (from old R)
  f(R,K): 12526FF1
  R15: 007F3573 (L XOR f)
Round 16:
  K1: A0BE86442211
  L16: 007F3573 (from old R)
  f(R,K): E3311305
  R16: 7F0271CA (L XOR f)
------------------------------------------------------------ 
[32位互换] 结果 (R16 L16): 7F0271CA007F3573

[解密结果] (Hex): 6E7368616E6E6701
==================== 结束 DES 解密 ====================      


最终验证:
  原始明文: hello fanshanng
  解密明文: hello fanshanng
  匹配成功: True

博客新增小功能

Mon, 15 Dec 2025 13:30:53 +0800

为了提升博客的趣味性和交互体验，今天给博客添加了一些小功能。本文记录了这些功能的实现方法，主要通过修改 static/js/custom.js 和相关模板文件实现。

1. 网站运行时间 (Site Running Time)

在页脚显示博客已经安全运行了多久，给访客一种持久运营的信任感。

实现效果：页脚显示 “本站已安全运行 XX 天 XX 小时 XX 分 XX 秒”。

代码片段：

function runtime() {
    window.setTimeout("runtime()", 1000);
    let startTime = new Date('01/01/2024 00:00:00'); // 修改为你的建站时间
    let endTime = new Date();
    let timeDiff = endTime.getTime() - startTime.getTime();
    // ... 计算天、时、分、秒 ...
    let timeDisplay = document.getElementById("run-time");
    if(timeDisplay) {
        timeDisplay.innerHTML = `本站已安全运行 ${days} 天 ${hours} 小时 ${minutes} 分 ${seconds} 秒`;
    }
}
runtime();

2. 网页标题动态变化 (Dynamic Title)

当用户切换到其他标签页时，网页标题会卖萌；切回来时，又会变回来。为了增加趣味性，设置了随机语录。

实现效果：

离开页面：随机显示 “(つェ⊂) 我藏好了哦~"、“看不见我…” 等。
回到页面：随机显示 “(´∇｀) 被你发现啦~"、"(OwO) 抓到你了” 等。

代码片段：

const hiddenTitles = ["(つェ⊂) 我藏好了哦~", "看不见我...", "( .•́ _ʖ •̀.) 等你回来", "404 Not Found"];
const visibleTitles = ["(*´∇｀*) 被你发现啦~", "(OwO) 抓到你了", "欢迎回来！", "(HzH) 嘻嘻"];

document.addEventListener('visibilitychange', function() {
    if (document.hidden) {
        document.title = getRandomItem(hiddenTitles);
    } else {
        document.title = getRandomItem(visibleTitles);
        setTimeout(() => { document.title = originTitle; }, 2000);
    }
});

3. 鼠标点击爱心特效 (Click Heart Effect)

点击页面任意位置，会弹出随机颜色的爱心动画，增加点击反馈。

实现原理：监听 click 事件，在鼠标点击坐标处创建一个 div 元素，应用 CSS 动画使其向上浮动并消失。

4. 复制成功提示 (Copy Toast)

当用户复制博客内容时，不再是无声无息，而是弹出一个友好的提示框。

实现效果：屏幕上方弹出黑色半透明提示框：“复制成功！转载请注明出处哦~"。

代码片段：

document.addEventListener('copy', function() {
    const toast = document.createElement('div');
    toast.innerText = '复制成功！转载请注明出处哦~';
    // ... 设置样式和动画 ...
    document.body.appendChild(toast);
});

5. 侧边栏打字机特效 (Typewriter Effect)

让侧边栏的个人简介（Subtitle）像打字机一样逐字显示，比静态文字更有灵动感。

实现原理：

修改 layouts/partials/sidebar/left.html，将副标题内容放入 data-text 属性。
使用 JS 递归函数 typeWriter 逐个字符读取并添加到 innerHTML 中。

6. 全局悬浮音乐播放器 (MetingJS)

在页面左下角添加一个悬浮的音乐播放器，直接同步网易云歌单，无需手动维护歌曲链接。

实现步骤：

在 layouts/partials/head/custom.html 引入 APlayer 的样式：

`1`	`<link rel="stylesheet" href="https://unpkg.com/aplayer@1.10.1/dist/APlayer.min.css" crossorigin="anonymous">`

在 layouts/partials/footer/footer.html 引入 APlayer 和 MetingJS 脚本：

1
2

<script src="https://unpkg.com/aplayer@1.10.1/dist/APlayer.min.js" crossorigin="anonymous" defer></script>
<script src="https://unpkg.com/meting@2.0.1/dist/Meting.min.js" crossorigin="anonymous" defer></script>

在 layouts/partials/sidebar/left.html 的末尾添加 MetingJS 标签（开启 fixed="true"）：

<!-- 悬浮音乐播放器 (MetingJS) -->
<meting-js 
    server="netease" 
    type="playlist" 
    id="17556275859"
    fixed="true"
    list-folded="true"
    theme="#2980b9">
</meting-js>

优势：

自动解析：MetingJS 会自动处理网易云音乐的防盗链和真实地址解析。
全局悬浮：播放器固定在左下角，不占用页面布局空间，且随时可控。
实时同步：在网易云 APP 里更新歌单，博客上也会自动更新。

关于音乐中断问题：由于博客是静态网站（多页架构），每次点击链接跳转都会重新加载页面，因此音乐会中断。这是静态网站的特性。

7. 暗色模式滑动开关 (Dark Mode Slider)

将原本单调的暗色模式切换按钮（月亮/太阳图标）升级为更现代的滑动开关样式。

实现效果：

外观：采用圆角胶囊形状，内部包含太阳和月亮图标。
动画：点击切换时，滑块平滑移动，背景色和图标颜色随之渐变。
交互：太阳和月亮图标在激活状态下会有缩放和变色效果（太阳变橙色，月亮变金色）。

实现原理：

HTML 结构：修改 layouts/partials/sidebar/left.html，将原来的简单 li 标签替换为包含轨道、滑块和图标的复杂结构。
CSS 样式：在 assets/scss/custom.scss 中添加样式。利用 :root[data-scheme="dark"] 选择器来区分深色和浅色模式下的样式，通过 transition 属性实现平滑过渡动画。
逻辑保持：保留原有的 colorScheme.ts 逻辑，点击事件依然绑定在父容器上，确保功能不受影响。

Hugo 博客添加文章密码保护功能

Mon, 15 Dec 2025 13:03:22 +0800

This content is password protected. Please visit the website to view it.

软件逆向工程组会：IDA 常见操作与基础知识

Thu, 06 Nov 2025 13:57:03 +0800

软件逆向工程组会：IDA 常见操作与基础知识

面向课程与安全研究，请遵守所在地法律与软件授权。涉及下载/外链：按授权使用或选开源替代（Ghidra/Cutter）。

一、核心认知：IDA 作用与逆向目标

1.1 IDA Pro 定位

IDA Pro 是逆向工程核心工具，支持将二进制文件（exe/so/elf/dll）反汇编为汇编代码并生成伪代码，辅助解析程序逻辑。

1.2 逆向入门核心目标

将 “不可读的二进制文件” 转化为 “可理解的逻辑”，具体包括：

定位程序入口（主函数）；
识别关键逻辑（验证、加密等）；
修改程序行为（Patch 操作）；
跟踪运行流程（动态调试）。

二、环境准备：IDA工具安装

IDA Pro 版本：推荐 9.1/9.2（稳定性与新功能兼顾），需匹配样本位数（32 位 / 64 位）；

通过网盘分享的文件：IDA Professional 9.1.7z 链接: https://pan.baidu.com/s/1yrROk_2y_jpwky_AsaOQSw?pwd=f4ns 提取码: f4ns

通过网盘分享的文件：ida9.2.zip 链接: https://pan.baidu.com/s/1YInTZr7qnGNMLvqz9b-5ZQ?pwd=f4ns 提取码: f4ns

IDA 9.2的官方文档

三、核心操作：静态分析（逆向基础）

静态分析无需运行程序，直接通过 IDA 解析代码逻辑，是逆向的核心环节。

3.1 视图切换与高频快捷键（分类汇总）

功能类型	快捷键	作用说明
视图切换	tab	汇编视图 ↔ 伪代码视图（核心切换方式）
	空格	text view（文本视图） ↔ graph view（图表视图）
导航类	G	跳转至指定地址（需输入目标地址）
	Alt+T	全局文本搜索（搜指令、字符串、函数名）
编辑类（汇编）	;（分号）	为汇编指令添加注释（便于后续回溯）
	U	Undefine：将代码转换为 “数据”（处理花指令）
	C	Code：将数据转换为 “代码”（恢复误判代码）
编辑类（伪代码）	N	变量 / 函数重命名（如 sub_401000 → main）
	Y	修改变量 / 函数类型（如 void → int，识别 JNI）
	/（斜杠）	为伪代码添加多行注释（可读性优先）
LazyIDA	Ctrl+Alt+N	一键 NOP 选中代码（过反调、去花指令，基础功能）
函数 / 字符串	Shift+F12	打开字符串窗口（定位关键逻辑核心工具）
ida9.2更新跳转	Ctrl-Alt-G	函数、局部类型、名称和段进行不区分大小写的搜索

重点提示：空格（视图切换）、G（地址跳转）、N/Y（伪代码编辑）、Shift+F12（字符串查询）为基础高频操作；LazyIDA 进阶功能见第四章专项。

3.2 汇编界面操作要点

3.2.1 必认汇编指令（对应 C 语言逻辑）

汇编指令	核心作用	对应 C 语言场景
mov	数据赋值（mov a,b → a=b）	变量赋值（如 int a = b;）
push/pop	栈操作（push：数据入栈；pop：数据出栈）	函数传参（参数入栈）、局部变量初始化（栈空间分配 / 释放）
call	调用函数（call sub_401000 → 跳转到 sub_401000 执行）	函数调用（如 check_password (input);）
ret	函数返回（从当前函数跳回调用处）	函数执行结束（return 语句）
jmp	无条件跳转（jmp 0x401200 → 强制跳转到 0x401200）	goto 语句（如 goto end;）
je/jne	条件跳转（je：等于时跳；jne：不等于时跳）	if-else（如 if (a==b) { … } else { … }）、循环
cmp	比较两个值（cmp a,b → 计算 a - b，仅置标志位不保存结果）	if 判断的条件基础（如 if (a==b)、if (a>b) 的底层判断）
jz	零标志位（ZF=1）时跳转（即上一步结果为 0 时跳）	if (结果 == 0)（如 if (func_return == 0) { … }）
jnz	零标志位（ZF=0）时跳转（即上一步结果不为 0 时跳）	if (结果！= 0)（如 if (func_return != 0) { … }）
test	按位与运算（不保存结果，仅置标志位），常用于判断是否为 0	if (变量 == 0)（如 test eax,eax → 判断 eax 是否为 0，对应 if (eax == 0)）
and	按位与运算（a and b → 结果存回 a），可用于清零、保留特定位	按位与操作（如 a &= b;）、清零变量（如 a &= 0;）
lea	计算有效地址（非加载数据），常用于取变量地址或简单计算	取变量地址（如 int *p = &a; → lea eax,[a]）、简单表达式计算（如 lea eax,[ebx+4] → eax = ebx + 4）
add	加法运算（add a,b → a = a + b）	数值加法（如 a = a + b;）
sub	减法运算（sub a,b → a = a - b）	数值减法（如 a = a - b;）
xor	按位异或运算（a xor b → 结果存回 a），可用于清零、交换变量	按位异或操作（如 a ^= b;）、清零变量（如 xor eax,eax → eax = 0）、交换变量（无需临时变量）
shr	逻辑右移（shr a,n → a 右移 n 位，高位补 0）	无符号数除法（如 a = a » 1; → a = a / 2）、取高位字节
shl	逻辑左移（shl a,n → a 左移 n 位，低位补 0）	无符号数乘法（如 a = a « 1; → a = a * 2）、低位字节赋值
leave	释放当前函数栈帧（等价于 mov esp, ebp; pop ebp），恢复调用者栈环境	函数执行结束前清理栈空间（对应 C 函数中局部变量销毁、栈帧恢复，通常紧跟在 return 前）
nop	无操作（仅占用 1 个指令周期，不修改寄存器 / 内存）	代码字节对齐（编译器填充空白）、调试占位（预留指令位置）、延时（底层简单延时逻辑）、屏蔽无用指令（如破解时 nop 掉校验指令）

3.2.2 汇编界面核心操作

注释添加：选中目标指令，按「;」输入注释内容；
关键词搜索：按「Alt+T」输入关键词（如 password,success），定位关键逻辑；
交叉引用查询：选中函数名（如 sub_401000），按「Alt+F7」，查看调用该函数的指令位置。

3.3 伪代码界面操作要点

伪代码可读性优于汇编，是逆向分析的主力视图。

3.3.1 核心编辑操作

重命名（N）：选中默认名称（如 v1、sub_401000），按「N」输入有意义名称（如 input、check）；
类型修改（Y）：选中变量 / 函数，按「Y」修改类型，例如：

JNI 函数（so文件分析）：将 void __cdecl sub_10001234() 改为 JNIEXPORT jint JNICALL Java_com_example_Test_check(JNIEnv *env, jobject thiz, jstring input)，IDA 自动识别 JNI 参数；
数组类型：将 int v2 改为 char v2[]，明确数组逻辑；

注释添加：按「/」输入多行注释，补充逻辑说明（如 “密码验证核心逻辑，返回 1 表示验证通过”）。

3.3.2 伪代码生成失败解决

若提示 “Cannot generate pseudocode”，需修正 IDA 代码识别：

切换至汇编视图，定位报错地址；
选中误判为 “数据” 的代码段，按「U」（undefine）转为数据；
重新选中目标段，按「C」（code）转为代码（按P识别成函数）；
按「tab」切换回伪代码视图，即可正常生成。

3.4 主函数定位方法（分场景）

场景 1：样本带符号（如调试版 exe/so）

一般主界面左侧就是函数列表，如果不存在就按「Shift+F3」打开函数列表；
搜索目标函数名：C 语言程序搜 main/start，Windows GUI 程序搜 WinMain，Android so 搜 JNI_OnLoad；
双击函数名跳转至主函数。

场景 2：样本无符号（脱壳后 /release 版）

按「Shift+F12」打开字符串窗口，筛选关键字符串（如 “success”“right”“flag”）；
右键选中目标字符串 → 「Jump to xref」（交叉引用 , 快捷键是[ x ]），跳转至引用该字符串的代码；
向上追溯代码，找到 “调用次数最少、层级最顶层” 的函数（通常整个程序仅调用一次，且调用其他函数），即为主函数。

场景 3：DLL/so 文件（导出函数）

按「Ctrl+I」打开导出表；
筛选对外提供的函数（如 DLL 的 ExportFunc、so 的 Java_包名_类名_方法名）；
此类导出函数为外部调用入口，等效于 DLL/so 的 “主函数”。

重点提示：无符号样本优先使用「Shift+F12 找关键字符串」，为最高效的主函数定位方式。

四、LazyIDA 专项速查

LazyIDA 是逆向高频操作的 “加速器”，以下按「快捷键」「右键菜单」「实操工作流」分类，覆盖地址处理、Patch、格式转换等核心场景（组会重点演示功能）。

4.1 快捷键速查表（按视图 / 上下文分类）

快捷键	动作	作用说明	适用视图 / 上下文	备注
w	Copy EA	复制当前地址到剪贴板（如：0x401000）	反汇编视图 / 转储视图	输出窗口会打印确认信息
Shift+G	Goto clip EA	读取剪贴板地址 / 文本，打开 Lazy Jumper 窗口并跳转	反汇编视图 / 转储视图	支持 “新镜像基址 + 目标地址” 的无重定位跳转，Esc 关闭窗口
Ctrl+Alt+N	NOP them	对选区批量写 NOP；无选区时对当前指令地址写 1 个 NOP	反汇编视图	输出区打印起止地址与字节数，比基础 Ctrl+N 更灵活
v	Remove return type	把当前函数 / 调用点的返回类型临时改为 void（再次按可还原）	Hex-Rays 伪代码视图	针对 VDI_FUNC / 函数指针调用生效
w（伪代码）	Copy EA (Hex-Rays)	复制当前伪代码位置关联的 EA	Hex-Rays 伪代码视图	与反汇编视图的 w 不冲突，各自生效
c（伪代码）	Copy name	复制当前高亮名称（变量 / 函数名等）	Hex-Rays 伪代码视图	取自 IDA 的 get_highlight () 接口
Shift+G（伪代码）	Goto clip EA (Hex-Rays)	从剪贴板取地址并在 IDA 中跳转	Hex-Rays 伪代码视图	与反汇编视图的 Shift+G 行为一致

小技巧：Lazy Jumper 对话框中，按 Enter/Return 可触发跳转，Esc 关闭窗口，无需鼠标点击（组会实操演示重点）。

4.2 右键菜单功能（按视图分类）

4.2.1 反汇编 / 转储视图（通用右键菜单）

菜单项	作用说明	备注
Paste Data	弹出 “粘贴数据” 窗口，支持 HEX / BASE64 / ASCII 三种输入并写回字节	适合快速打补丁，输入后点击 Apply 生效（组会实操演示）
Lazy Dumper	弹出转储窗口：输入基址与大小，保存选定范围字节到文件	操作失败会在输出窗口提示原因
Lazy Jumper [Shift + G]	打开跳转窗口：输入新基址 / 目标地址，计算偏移后跳到当前 IDB 的等效位置	自动记忆历史基址，下次打开可快速复用
Copy RVA	计算并复制当前地址的 RVA（相对虚拟地址）	调试中按 “模块基址” 计算，非调试按 “imagebase” 计算
NOP them	与 Ctrl+Alt+N 功能一致：选区批量 NOP / 无选区单字节 NOP	快速过反调、去花指令（组会实操演示）
Get xored data	选中一段代码→输入 0–255 的 XOR 值，输出异或后的文本	仅只读输出结果到输出窗口，不写回二进制文件
Fill with NOPs	把选区整段填充为 NOP	必须先框选代码段（单指令不生效），比 NOP them 更彻底
Convert/ → 格式选项	把选中字节转为指定格式：- 转义字符串- 十六进制串- C 数组（BYTE/WORD/DWORD/QWORD）- Python 列表（同上）	转换结果打印到 Output 窗口，需手动复制使用

注：Get xored data / Fill with NOPs / Convert/ 仅在 “存在选区” 或 “当前指令大小 > 1” 时显示。

4.2.2 仅反汇编视图（特定架构专属菜单）

菜单项	作用说明	备注
Scan format string vulnerabilities	扫描 printf/sprintf/fprintf 等调用点，若格式串来自可写段则标记为 “可能漏洞”，列表展示可跳转	仅支持 x86 (32/64)、ARM32 架构，其他架构不挂载

4.2.3 Hex-Rays 伪代码视图（右键菜单）

菜单项	作用说明	备注
Remove return type	与快捷键 v 一致：临时将返回类型改为 void（再次点击还原）	针对复杂函数指针调用场景优化
Copy ea	与快捷键 w（伪代码）一致：复制当前伪代码关联的 EA	快速定位伪代码对应的汇编地址
Copy name	与快捷键 c（伪代码）一致：复制高亮的变量 / 函数名	避免手动输入名称，减少拼写错误
Goto clipboard ea	与快捷键 Shift+G（伪代码）一致：从剪贴板跳转地址	伪代码中快速跳转到外部引用的地址
双击增强：obj->func () 表达式	自动解析并跳转到目标 func；若找不到则尝试 Class::func	命中时直接跳转，未命中无响应（需手动定位）

4.3 常见工作流

一键 NOP 某段代码：

框选目标代码段 → 右键点击「Fill with NOPs」（或按 Ctrl+Alt+N）→ 输出窗口确认 NOP 范围。

（适用场景：批量去除花指令、跳过反调试检测代码）

快速打补丁：

定位需修改的地址 → 右键「Paste Data」→ 选择输入格式（如 HEX）→ 粘贴修改后的字节（如将 74 改为 75，je 改 jne）→ 点击「Apply」→ 保存 Patch 后的文件。

（适用场景：修改跳转条件、绕过验证逻辑）

跨镜像基址跳转：

复制外部样本的目标地址（如 0x10001234）→ 在当前 IDA 按 Shift+G → Lazy Jumper 窗口输入 “新镜像基址（如 0x10000000）” 和 “目标地址（0x10001234）”→ 按 Enter 跳转。

（适用场景：对比多个样本、分析脱壳后代码）

五、Patch/Keypatch（修改程序逻辑）

Patch 即 “二进制打补丁”，通过修改代码实现逻辑调整（如过反调、跳过验证），依赖 IDA+LazyIDA+Keypatch 组合（LazyIDA 负责高效操作，Keypatch 负责指令汇编）。

5.1 Keypatch 插件安装

将 Keypatch 插件文件复制至 IDA 的 plugins 目录，重启 IDA 即可（与 IDA 9.1/9.2 兼容），功能为 “可视化修改汇编指令，无需手动计算机器码”。

5.2 核心 Patch 操作（分场景）

场景 1：NOP 掉无用代码（基础版）

（LazyIDA 已实现进阶批量 NOP，见第四章 4.3 工作流）

适用场景：单指令 NOP、简单逻辑跳过；
操作步骤：选中指令 → 按 Ctrl+N（LazyIDA 基础功能）→ 指令替换为 NOP。

场景 2：修改指令（调整跳转条件）

适用场景：强制跳转至正确逻辑（如跳过验证失败分支）；
操作步骤：

在汇编视图选中待修改指令（如 je 0x401200）；
右键 → 「Keypatch」→ 输入新指令（如 jmp 0x401300）；
点击「Assemble」→ 「Patch file」→ 保存修改后的二进制文件。

场景 3：恢复误判代码（U+C 组合）

适用场景：IDA 将正常代码误判为数据（显示为十六进制）；
操作步骤：

选中误判数据段，按「U」（undefine）转为数据；
重新选中目标段，按「C」（code）转为代码；
按「tab」切换回伪代码视图，恢复解析。

5.3 地址跳转操作（G 快捷键 + Lazy Jumper）

基础跳转：已知地址（如 0x401100）→ 按「G」→ 输入地址跳转；
进阶跳转：跨基址 / 剪贴板地址 → 按 W和Shift+G（Lazy Jumper）组合→ 输入参数跳转（见第四章 4.1）。

六、动态调试：跟踪程序运行

动态调试通过运行程序、下断点，观察变量值与函数调用，精准定位核心逻辑。

6.1 核心概念

断点：程序运行至指定位置暂停，便于观察；
单步执行：暂停后逐行执行代码，跟踪变量变化；
本地调试：在本地设备运行并调试程序；
远程调试：调试其他设备（如 Linux 服务器、Android 手机）上的程序。

6.2 断点类型对比（分场景选用）

断点类型	操作方式	原理	优点	缺点
软件断点	选中指令按「F2」	将指令替换为 int3（调试中断指令）	操作简单、无数量限制	易被程序检测（int3 为特征）
硬件断点	右键断点 → 「Edit breakpoint」→ 勾选「Hardware breakpoint」	利用 CPU 调试寄存器实现	隐蔽性强、不易被检测	数量有限（通常最多 4 个）

重点提示：新手优先使用软件断点（F2），遇到反调试检测时切换为硬件断点（组会实操演示）。

6.3 Windows 平台调试（exe/dll）

6.3.1 本地调试步骤

IDA 加载 exe 文件，等待分析完成；
按「F9」（Start process）启动程序（无断点时程序会直接运行结束）；
在关键位置（如验证函数、字符串引用处）按「F2」下断点，程序运行至断点处自动暂停；
单步操作：

F7：单步步入（进入函数内部，如 call 指令时跟进）；
F8：单步步过（不进入函数，直接执行完 call 指令）；
F9：运行至当前函数结束（快速跳出函数）；

变量观察：暂停时，鼠标悬停伪代码中的变量（如 input_pass），显示当前变量值（组会实操演示重点）。

6.3.2 附加进程调试（调试已运行程序）

确保目标程序已在本地运行；
IDA 菜单栏 → 「Debugger」→ 「Attach」→ 「Local Process」；
在进程列表中筛选目标程序（按名称检索），选中后点击「Attach」；
按「F2」下断点，按「F9」恢复程序运行，触发断点后按单步操作调试。

6.4 Linux 平台调试（elf/so）

6.4.1 远程调试步骤（如调试服务器 / 手机 so）

从本地 IDA 安装目录获取调试服务器：
- 本地路径：E:\IDA\IDA Professional 9.2\dbgsrv
- 选择对应版本：32 位样本用 linux_server，64 位样本用 linux_server（Android 对应 android_server/android_server32）；
将调试服务器文件复制到目标机的「调试样本同目录」；

给调试服务器和样本文件加权（赋予执行权限）：

1
2

chmod 777 linux_server  # 调试服务器加权
chmod 777 test.exe        # 待调试样本加权

启动调试服务器：
- 方式 1：使用自定义端口（推荐，避免端口冲突）
  1
  
  ./linux_server -p 1234 # 1234 为自定义端口，可替换为 1024-65535 之间未占用端口
- 方式 2：使用默认端口（无需指定 -p，默认端口为 23946）
  1
  
  ./linux_server
启动成功后，终端会显示 “Listening on port XXXX”（XXXX 为端口号），保持终端窗口开启。

6.5 调试避坑指南

调试前关闭杀毒软件 / 防火墙，避免程序被拦截；
Windows 调试 GUI 程序时，断点不设置在 UI 初始化函数（易导致程序卡住）；
远程调试需确保目标机与本地机网络互通（如同一局域网，关闭防火墙）；
Android so 调试：先将 so 文件从手机拉取至本地，IDA 加载后远程附加手机进程。这里可以参考

[一次IDA动态调试安卓apk记录]

2024强网杯复盘

Tue, 07 Oct 2025 23:31:14 +0800

bbox

主函数目测是一个类似迷宫，点进去看了逻辑，发现是推箱子，简单来说2是人，3是箱子，4是目的地

这个是d的逻辑，如果不是最右边（19)，就会+1，y_1是新的横坐标索引，x是纵坐标索引，n应该是挑战的个数，5600/400=14个挑战。

前九个的最短路径字符串拼接成是212139211325313,MD5值是fec2d316d20dbacbe0cdff8fb6ff07b9,后五个目测不是推箱子，是qwb!还有一个是纯0填充组成flag：flag {qwb!_fec2d316d20dbacbe0cdff8fb6ff07b9}

11111111111111111111 
11111111111111111111
11411111111111111111
11030011111111111111   
11011011111111111111
00000211111111111111
11101111111111111111
11101111111111111111
01100110001000100010
01000000001000100010
01000000001000111110
01111111111000000010
00000000001000000010
00001111111000111110
00001000001000100010
01111000001000100010
01000000001111100010
01000000000000000010
01000000001111100010
01000000000000000010//2
00000000000000000000
01111111111111111110
01000000000000000010
01200300040000000010
01000000000000000010
01111111111111101110
01000000000000000010
01000011111000111110
01000010001000100010
01111110001000100010
00000010000000100010
00111110001000111110
00100000001000000010
00100010111000111110
00100030001000100010
00111100001000100010
00400000001000100010
01111111111000100010
01000000000000000010
01000000000000000010//4+8=12
11111111111111111111
14000000000000000001
10111111111111100001
10100000000000100001
10100000000000100001
10103000000000100001
10111011101111100001
10000000000000000001
10111111111111011111
10000000100000000001
10000000000000001001
10000000100000001001
11111111100000001001
10000000000000002001
11111111111111111111
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000//13
11111111111111111111
14000000000000000001
10000001111111000001
10000000300001000001
10000001000001000001
10000001000021000001
10000001111111000001
10000000000000000001
11111111111111111111
10000000100000000001
10000000100000000111
10000000100000000100
10111111100000000100
10000000000000000100
11111111111111111111
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000//9
11111111111111111111
10000000000000000001
10111111111111111001
10100000000000001001
10101111111111111001
10101000000000001001
10101011111111111001
10101010000000000001
10101010111111111101
10001000100000000001
11111111111111111111
10000000000000100001
10000001111111101101
10000001000000001001
11111111111111111111
10000000000000040001
10000001111111110101
10000000000000300001
11111011111111101111
10000000000000020001//21
11111111111111111111
14000003000000000001
10111111111111100001
10100000002000000001
10101111111111101101
10101000001000001001
10101011111011101001
10001010001010001001
10111010101010101101
10100000000000000001
11111111111111101111
10000001000000000001
10000001111111011101
10000001000000301001
11111111400000001001
10000000000000001001
10111111111111111001
10100000000000000001
11111111111111111111
10000000000000000001//6+7=13
11111111111111111111
10000010000000000001
10111111111111111001
10100000000000001001
10101111111111111001
10101000021000000001
10101011111011111101
10101010000010000001
10001010111110111101
11111010100000100001
10000010101111101101
10111110101000001001
10100000101011111001
10101111101010000001
10003000000000111111
11111011111010100001
10000000000010101111
10111111111110001001
14000000000000001001
11111111111111111111//25
11111111111111111111
14000000000002003001
10111011111111111001
10100000000000000001
10101111111011111001
10101400001000001001
10101011111010101001
10101010001010101001
10101010111010101101
10003000100000000001
10111011111111111101
10000001000010000001
11111111111111111101
10003000000000041001
10111111111111111001
10100000001000000001
10101111111011111101
10101000001000001001
10101011111111111001
10000000000000000001//15+5+11=31
11111111111111111111
10000000000000100001
10111111111111111001
10100000000000001001
10101111111111111001
10101000000000000001
10101110111011111101
10001013001010001001
11111002111010101001
10000010100000101001
10111114101111111001
10100000001000000001
10101111101111111101
10101000000000001001
10001111111111111001
11111000000000000001
10000011111111111101
10111110000000000001
10100000000000000001
11111111111111111111//3
11111111111111111111
11111111111111111111
11111111111111111111
11100000000001111111
11101111111101111111
11101111111101111111
11101111111101111111
11101111111101111111
11101111111101111111
11100000000001111111
11111111111101111111
11111111111101111111
11111111111101111111
11111111111101111111
11111111111101111111
11111111111101111111
11111111111101111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11011110111101111111
11011110111101111111
11011110111101111111
11011110111101111111
11011110111101111111
11101110111011111111
11101110111011111111
11101101010111111111
11110101010111111111
11110101010111111111
11111011101111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11101111111111111111
11101111111111111111
11101111111111111111
11101111111111111111
11101111111111111111
11100000000011111111
11101111111011111111
11101111111011111111
11101111111011111111
11101111111011111111
11101111111011111111
11101111111011111111
11100000000011111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111111111111111111
11111110000011111111
11111110111011111111
11111110111011111111
11111110111011111111
11111110111011111111
11111110111011111111
11111110111011111111
11111110111011111111
11111110111011111111
11111110000011111111
11111111111111111111
11111111111111111111
11111111000111111111
11111111010111111111
11111111010111111111
11111111000111111111
11111111111111111111
11111111111111111111
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
0000000000000000000

snake

文件打开后发现大概是一个贪吃蛇游戏在绑定上下左右方向键中，学到windows的虚拟键位

符号常量名称	十六进制值	ascii值	描述
`VK_LEFT`	0x25	‘%’	向左键
`VK_UP`	0x26	‘&’	向上键
`VK_RIGHT`	0x27	‘\’	向右键
`VK_DOWN`	0x28	‘(’	向下键

看别人的wp知道

然后就直接玩，保证最短路径就行，到第十分的时候就会自动断下来，进入lpAddress指向的地址2373D8A000h

写了一段 idc 脚本dump出来得到1.bin

// 定义需要提取的起始地址和结束地址（替换为你的实际地址）
auto start_addr = 0x000002373D8A0000;
auto end_addr = 0x000002373D8A047F;
auto file_handle, byte_count, i;

// 创建/打开1.bin文件（"wb"表示二进制写入模式）
file_handle = fopen("1.bin", "wb");
if (file_handle == 0)
{
    Message("创建文件失败！请检查路径\n");
    return;
}

// 计算需要导出的字节数（结束地址 - 起始地址 + 1，确保包含最后一个字节）
byte_count = end_addr - start_addr + 1;

// 循环读取每个地址的字节并写入文件
for (i = 0; i < byte_count; i++)
{
    fputc(Byte(start_addr + i), file_handle);
}

// 关闭文件并提示成功
fclose(file_handle);
Message("导出成功！共导出 %d 字节到 1.bin\n", byte_count);

char __fastcall sub_0(__int64 a1, __int64 a2, __int64 a3, unsigned int *a4)
{
  char *v4; // rdi
  __int64 n78; // rcx
  char v7; // [rsp+20h] [rbp+0h] BYREF
  unsigned int v8; // [rsp+24h] [rbp+4h]
  int v9; // [rsp+44h] [rbp+24h]
  _DWORD v10[12]; // [rsp+68h] [rbp+48h] BYREF
  unsigned int v11; // [rsp+98h] [rbp+78h]
  unsigned int v12; // [rsp+9Ch] [rbp+7Ch]
  unsigned int v13; // [rsp+A0h] [rbp+80h]
  unsigned int v14; // [rsp+A4h] [rbp+84h]
  unsigned int n0x20; // [rsp+C4h] [rbp+A4h]
  unsigned int n0x20_1; // [rsp+E4h] [rbp+C4h]
  _BYTE v17[44]; // [rsp+108h] [rbp+E8h]
  int n16; // [rsp+134h] [rbp+114h]

  v4 = &v7;
  for ( n78 = 78; n78; --n78 )
  {
    *(_DWORD *)v4 = -858993460;
    v4 += 4;
  }
  v8 = 0;
  v9 = -1640531527;
  qmemcpy(v10, "W31c0m3. 2 QWBs8", 16);
  v11 = *a4;
  v12 = a4[1];
  v13 = a4[2];
  v14 = a4[3];
  for ( n0x20 = 0; n0x20 < 0x20; ++n0x20 )
  {
    v11 += (v10[v8 & 3] + v8) ^ (v12 + ((v12 >> 5) ^ (16 * v12)));
    v8 += v9;
    v12 += (v10[(v8 >> 11) & 3] + v8) ^ (v11 + ((v11 >> 5) ^ (16 * v11)));
  }
  for ( n0x20_1 = 0; n0x20_1 < 0x20; ++n0x20_1 )
  {
    v13 += (v10[v8 & 3] + v8) ^ (v14 + ((v14 >> 5) ^ (16 * v14)));
    v8 += v9;
    v14 += (v10[(v8 >> 11) & 3] + v8) ^ (v13 + ((v13 >> 5) ^ (16 * v13)));
  }
  v11 ^= v13;
  v12 ^= v14;
  v14 ^= v11;
  v13 ^= v12;
  v17[0] = -104;
  v17[1] = -96;
  v17[2] = -39;
  v17[3] = -104;
  v17[4] = -70;
  v17[5] = -105;
  v17[6] = 27;
  v17[7] = 113;
  v17[8] = -101;
  v17[9] = -127;
  v17[10] = 68;
  v17[11] = 47;
  v17[12] = 85;
  v17[13] = -72;
  v17[14] = 55;
  v17[15] = -33;
  for ( n16 = 0; n16 < 16; ++n16 )
  {
    if ( *((char *)&v11 + n16) != (char)v17[n16] )
      return 0;
  }
  return 1;
}

魔改tea，脚本如下

from ctypes import *

delta = 0x9e3779b9
sum1 = c_uint32(delta * 64)

def decrypt(v, k):
    v0 = c_uint32(v[0])
    v1 = c_uint32(v[1])
    for i in range(32):
        # 解密轮次运算
        v1.value -= (((v0.value << 4) ^ (v0.value >> 5)) + v0.value) ^ (sum1.value + k[(sum1.value >> 11) & 3])
        sum1.value -= delta
        v0.value -= (((v1.value << 4) ^ (v1.value >> 5)) + v1.value) ^ (sum1.value + k[sum1.value & 3])
    return v0.value, v1.value

def long_to_bytes(n):
    return n.to_bytes((n.bit_length() + 7) // 8, byteorder='big') or b'\x00'

if __name__ == '__main__':
    a = [0x98D9A098, 0x711B97BA, 0x2F44819B, 0xDF37B855]
    k = [0x63313357, 0x2E336D30, 0x51203220, 0x38734257]
    
    # 预处理异或操作
    a[2] ^= a[1]
    a[3] ^= a[0]
    a[1] ^= a[3]
    a[0] ^= a[2]
    
    temp = [0] * 2
    # 分块解密
    for i in range(1, -1, -1):
        temp[0] = a[i * 2]
        temp[1] = a[i * 2 + 1]
        res = decrypt(temp, k)
        a[i * 2] = res[0]
        a[i * 2 + 1] = res[1]
    
    # 转换为字符串并输出
    for i in range(len(a)):
        # 使用自定义的long_to_bytes并处理字节顺序
        print(long_to_bytes(a[i])[::-1].decode(errors='ignore'), end='')
#flag{G0@d_Snake}

2024-强网杯-初赛-Writeup-By-Xp0int

强网杯 2024 All RE wp

2024 强网杯 - Reverse

2024强网杯 web&re 部分wp

mips

`1`	`strings ./emu \| grep -i "qemu.version\\|version.qemu"`

#下载官方完整包（已含子模块）
wget https://download.qemu.org/qemu-6.2.0.tar.xz          # 官方源，子模块都齐了

tar -xf qemu-6.2.0.tar.xz
cd qemu-6.2.0

#一次性配置 + 编译
export CFLAGS="-g -O0"
export CXXFLAGS="-g -O0"

./configure --target-list=x86_64-softmmu \
            --disable-werror \
            --enable-debug \
            --disable-strip

make -j$(nproc)

然后就可以在~/qemu-6.2.0/build 目录下找到qemu-system-x86_64

右键全部 import model ，可以看到一个魔改的RC4

mips64逆向新手入门（从jarvisoj一道mips64题目说起）

安卓逆向入门七：Frida入门

Sun, 28 Sep 2025 22:21:41 +0800

0x00 什么是Frida

frida官方文档

它是原生应用的Greasemonkey，或者用更专业的术语来说，它是一个动态代码插桩工具包。它允许你将 JavaScript 代码片段或你自己的库注入到 Windows、macOS、GNU/Linux、iOS、watchOS、tvOS、Android、FreeBSD 和 QNX 上的原生应用中。Frida 还提供了基于 Frida API 构建的一些简单工具。这些工具可以直接使用，也可以根据你的需求进行调整，或者作为 API 使用示例。

Frida原理及重要组件

frida注入的原理就是找到目标进程,使用ptrace跟踪目标进程获取mmap，dlpoen，dlsym等函数库的偏移获取mmap在目标进程申请一段内存空间将在目标进程中找到存放frida-agent-32/64.so的空间启动执行各种操作由agent去实现

组件名称	功能描述
frida-gum	提供了inline-hook的核心实现，还包含了代码跟踪模块Stalker，用于内存访问监控的MemoryAccessMonitor，以及符号查找、栈回溯实现、内存扫描、动态代码生成和重定位等功能
frida-core	fridahook的核心，具有进程注入、进程间通信、会话管理、脚本生命周期管理等功能，屏蔽部分底层的实现细节并给最终用户提供开箱即用的操作接口。包含了frida-server、frida-gadget、frida-agent、frida-helper、frida-inject等关键模块和组件，以及之间的互相通信底座
frida-gadget	本身是一个动态库，可以通过重打包修改动态库的依赖或者修改smali代码去实现向三方应用注入gadget，从而实现Frida的持久化或免root
frida-server	本质上是一个二进制文件，类似于前面学习到的android_server，需要在目标设备上运行并转发端口，在Frida hook中起到关键作用

Frida与Xposed的对比

工具	优点	缺点
Xposed	直接编写Java代码，Java层hook方便，可打包模块持久化hook	环境配置繁琐，兼容性较差，难以Hook底层代码。
Frida	配置简单，免重启hook。支持Java层和Native层的hook操作	持久化hook相对麻烦

Frida环境配置

推荐用python的虚拟环境env

Python 虚拟环境的创建（venv）

Frida安装以及多版本处理

`1`	`pip install frida-tools -i https://pypi.tuna.tsinghua.edu.cn/simple`

push Frida-server
- 注意要下载对应版本
- 不知道手机基础框架（ABI）的，可以使用这个指令：adb shell getprop ro.product.cpu.abi
- arm64-v8a → 64 位 ARM（主流新机）
- armeabi-v7a → 32 位 ARM（老机型）
- x86 / x86_64 → Intel 架构（模拟器或极少数真机）

FIrda基础知识

基础命令

1.frida-ps -U 查看当前手机运行的进程
2.frida-ps --help 查看help指令

frida-ps --help
使用方式: frida-ps [选项]

选项:
  -h, --help            显示帮助信息并退出
  -D ID, --device ID    连接到具有给定ID的设备
  -U, --usb             连接到USB设备
  -R, --remote          连接到远程frida-server
  -H HOST, --host HOST  连接到HOST上的远程frida-server
  --certificate CERTIFICATE
                        与HOST进行TLS通信，期望的CERTIFICATE
  --origin ORIGIN       连接到设置了"Origin"头为ORIGIN的远程服务器
  --token TOKEN         使用TOKEN验证HOST
  --keepalive-interval INTERVAL
                        设置心跳包间隔(秒)，或设置为0以禁用(默认为-1，根据传输方式自动选择)
  --p2p                 与目标建立点对点连接
  --stun-server ADDRESS
                        设置与--p2p一起使用的STUN服务器地址
  --relay address,username,password,turn-{udp,tcp,tls}
                        添加与--p2p一起使用的中继
  -O FILE, --options-file FILE
                        包含额外命令行选项的文本文件
  --version             显示程序版本号并退出
  -a, --applications    只列出应用程序
  -i, --installed       包括所有已安装的应用程序
  -j, --json            以JSON格式输出结果

3.操作模式 CLI模式：通过命令行直接将JavaScript脚本注入进程中。 RPC模式：使用Python进行JavaScript脚本的注入，适合复杂数据处理。
4.注入模式与启动命令
- Spawn模式
将启动App的权利交由Frida来控制，即使目标App已经启动，在使用Frida注入程序时还是会重新启动App

当需要监控App从启动开始的所有行为时使用 frida -U -f 进程名 -l hook.js 进程名可以通过frida-ps -U来查看
- Attach模式
在目标App已经启动的情况下，Frida通过ptrace注入程序从而执行Hook的操作

frida -U 进程名 -l hook.js 在App已经启动，或者我们只关心特定时刻或特定功能的行为时使用
5.frida_server自定义端口

frida server 默认端口：27042

taimen:/ $ su
taimen:/ # cd data/local/tmp/
taimen:/data/local/tmp # ./fs1280 -l 0.0.0.0:6666

6.基础语法

API名称	描述
`Java.use(className)`	获取指定的Java类并使其在JavaScript代码中可用。
`Java.perform(callback)`	确保回调函数在Java的主线程上执行。
`Java.choose(className, callbacks)`	枚举指定类的所有实例。
`Java.cast(obj, cls)`	将一个Java对象转换成另一个Java类的实例。
`Java.enumerateLoadedClasses(callbacks)`	枚举进程中已经加载的所有Java类。
`Java.enumerateClassLoaders(callbacks)`	枚举进程中存在的所有Java类加载器。
`Java.enumerateMethods(targetClassMethod)`	枚举指定类的所有方法。

7.日志输出

日志方法	描述	区别
`console.log()`	使用JavaScript直接进行日志打印	多用于在CLI模式中，`console.log()`直接输出到命令行界面，使用户可以实时查看。在RPC模式中，`console.log()`同样输出在命令行，但可能被Python脚本的输出内容掩盖。
`send()`	Frida的专有方法，用于发送数据或日志到外部Python脚本	多用于RPC模式中，它允许JavaScript脚本发送数据到Python脚本，Python脚本可以进一步处理或记录这些数据。

8.日志捕获 D：表示级别 “zj2595"这个是标签

9.Hook框架模板

// 定义主函数
function main() {
    // Frida提供的Java环境操作API，确保在Java虚拟机上下文执行
    Java.perform(function() {
        // 调用自定义的Hook逻辑函数（需要自己实现）
        hookTest1();
    });
}

// 立即执行main函数（Frida脚本常用的启动方式）
setImmediate(main);

Java.perform(callback)Frida 的核心 API 之一，用于在目标进程的Java 虚拟机（JVM）上下文中执行代码。因为 Hook Java 方法需要访问 JVM 环境，Java.perform会确保回调函数中的代码在 JVM 就绪后执行，避免因环境未初始化导致的错误。
**hookTest1()**这是一个自定义函数（需要你自己实现具体逻辑），用于编写实际的 Hook 操作，例如：
- 拦截某个 Java 方法的调用
- 修改方法的参数或返回值
- 打印方法调用栈信息等
**setImmediate(main)**用于启动整个 Hook 流程。setImmediate是 JavaScript 的异步 API，会将main函数放入事件循环中立即执行（类似setTimeout(fn, 0)）。在 Frida 脚本中，这是启动 Hook 逻辑的标准方式，确保代码在进程初始化完成后运行。

Frida常用API

1. Hook普通方法

//定义一个名为hookTest1的函数
function hookTest1(){
        //获取一个名为"类名"的Java类，并将其实例赋值给JavaScript变量utils
    var utils = Java.use("类名");
    //修改"类名"的"method"方法的实现。这个新的实现会接收两个参数（a和b）
    utils.method.implementation = function(a, b){
            //将参数a和b的值改为123和456。
        a = 123;
        b = 456;
        //调用修改过的"method"方法，并将返回值存储在`retval`变量中
        var retval = this.method(a, b);
        //在控制台上打印参数a，b的值以及"method"方法的返回值
        console.log(a, b, retval);
        //返回"method"方法的返回值
        return retval;
    }
}

此案例中，类名修改为com.zj.wuaipojie.Demo,将参数和方法名都修改。

最新的jadx中已经可以将方法复制成frida片段，如下：

var Demo = Java.use("com.zj.wuaipojie.Demo");
Demo["a"].implementation = function (str) {
    console.log(`Demo.a is called: str=${str}`);
    let result = this["a"](str);
    console.log(`Demo.a result=${result}`);
    return result;
};

使用frida-ps -U 查看当前手机运行的进程得到 1821 wuaipojie

然后使用frida -U 进程名 -l hook.js启动命令，下图是另一个终端窗口中logcat |grep "D.zj2595"进行的日志捕获

可以看到，终端输出了方法传入的参数和输出的返回值

在let result = this["a"](str);这条语句中即可修改方法的返回值，但需注意原方法返回值的类型，若原方法返回int，应该返回数字22（而不是字符串"22"）

2. Hook重载参数

// .overload()
// .overload('自定义参数')
// .overload('int')
function hookTest2(){
    var utils = Java.use("com.zj.wuaipojie.Demo");
    //overload定义重载函数，根据函数的参数类型填
    utils.Inner.overload('com.zj.wuaipojie.Demo$Animal','java.lang.String').implementation = function(a，b){
        b = "aaaaaaaaaa";
        this.Inner(a,b);
        console.log(b);
    }
}

再看一个自定义参数类型的方法案例

当overload()中没有填入参数类型或者你不知道该参数的类型时候可以尝试运行在报错的提示中可以找到参数类型，也可以从Java文件定位到对应的smali语句，也可以看到相应的参数类型

有时候文件运行后，没有hook成功，可以多尝试几次

3. Hook构造函数

function hookTest3(){
    var utils = Java.use("com.zj.wuaipojie.Demo");
    //修改类的构造函数的实现，$init表示构造函数
    utils.$init.overload('java.lang.String').implementation = function(str){
        console.log(str);
        str = "52";
        this.$init(str);
    }
}

4. Hook字段

function hookTest5(){
    Java.perform(function(){
        //静态字段的修改
        var utils = Java.use("com.zj.wuaipojie.Demo");
        //修改类的静态字段"flag"的值
        utils.staticField.value = "我是被修改的静态变量";
        console.log(utils.staticField.value);
        //非静态字段的修改
        //使用`Java.choose()`枚举类的所有实例
        Java.choose("com.zj.wuaipojie.Demo", {
            onMatch: function(obj){
                    //修改实例的非静态字段"_privateInt"的值为"123456"，并修改非静态字段"privateInt"的值为9999。
                obj._privateInt.value = "123456"; //字段名与函数名相同 前面加个下划线
                obj.privateInt.value = 9999;
            },
            onComplete: function(){

            }
        });
    });

}

在第一次的使用过程中，发现obj.privateInt.value = 9999;并没有成功，可能的原因是

private 修饰：Java 中 private 字段只能在当前类内部访问，外部（包括 Frida 直接访问）默认没有权限修改；
final 修饰：final 字段初始化后不允许重新赋值（即使是类内部也不行），Java 的语法规则会阻止修改。

翻论坛评论的时候发现了这个帖子

尝试了一下，确实可以，真的要和别人多交流学习啊（感慨）

附上代码：

function hookTest5(){
    Java.perform(function(){
        //非静态字段的修改
        //使用`Java.choose()`枚举类的所有实例
        Java.choose("com.zj.wuaipojie.Demo", {
            onMatch: function(obj){
                //修改实例的非静态字段"_privateInt"的值为"123456"，并修改非静态字段"privateInt"的值为9999。
                // obj._privateInt.value = "123456"; //字段名与函数名相同时 前面加个下划线
                console.log("here!")
                obj.publicInt.value = 8888;
                obj.privateInt.value = 9999;
                //由于样本代码的原因，需要再主动调用一下Demo类日志输出函数test()，才能在adb的log界面看到输出改变
                obj.test();
                console.log(obj.privateInt.value )
            },
            onComplete: function(){

            }
        });
    });
}

5.Hook内部类

function hookTest5(){
    Java.perform(function(){
        //内部类
        var innerClass = Java.use("com.zj.wuaipojie.Demo$innerClass");
        console.log(innerClass);
        innerClass.$init.implementation = function(){
            console.log("eeeeeeee");
        }

    });
}

6. 枚举所有类与方法

function hookTest6(){
    Java.perform(function(){
        //枚举所有的类与类的所有方法,异步枚举
        Java.enumerateLoadedClasses({
            onMatch: function(name,handle){
                    //过滤类名
                if(name.indexOf("com.zj.wuaipojie.Demo") !=-1){
                    console.log(name);
                    var clazz =Java.use(name);
                    console.log(clazz);
                    var methods = clazz.class.getDeclaredMethods();
                    console.log(methods);
                }
            },
            onComplete: function(){}
        })
    })
}

7.枚举所有方法

function hookTest7(){
    Java.perform(function(){
        var Demo = Java.use("com.zj.wuaipojie.Demo");
        //getDeclaredMethods枚举所有方法
        var methods =Demo.class.getDeclaredMethods();
        for(var j=0; j < methods.length; j++){
            var methodName = methods[j].getName();
            console.log(methodName);
            for(var k=0; k<Demo[methodName].overloads.length;k++){
                Demo[methodName].overloads[k].implementation = function(){
                    for(var i=0;i<arguments.length;i++){
                        console.log(arguments[i]);
                    }
                    return this[methodName].apply(this,arguments);
                }
            }
        }
    })
}

8.主动调用

静态方法

1
2

var ClassName=Java.use("com.zj.wuaipojie.Demo"); 
ClassName.privateFunc("传参");

下图就能显示出修改后的加密结果

非静态方法

    var ret = null;
    Java.perform(function () {
        Java.choose("com.zj.wuaipojie.Demo",{    //要hook的类
            onMatch:function(instance){
                ret=instance.privateFunc("aaaaaaa"); //要hook的方法
            },
            onComplete:function(){
                    //console.log("result: " + ret);
            }
        });
    })
    //return ret;

0x01 objection

什么是objection

objection是基于frida的命令行hook集合工具, 可以让你不写代码, 敲几句命令就可以对java函数的高颗粒度hook, 还支持RPC调用。可以实现诸如内存搜索、类和模块搜索、方法hook打印参数返回值调用栈等常用功能，是一个非常方便的，逆向必备、内存漫游神器。

项目地址

由于objection在2021就已经停止更新，所以需要使用较低版本的frida和frida_tools，建议重新设置一个虚拟环境，因为之前虚拟环境用的是最新版本的，不太支持objection，配置一个新的环境也方便管理我这里配置的是
1 2 3 4 5

objection 1.11.0 frida 16.2.1 frida-tools 13.2.0
简单测试一下，出现如下图所示就是成功了

objection 命令注释

1.help命令注释

objection --help(help命令)
Checking for a newer version of objection...
Usage: objection [OPTIONS] COMMAND [ARGS]...

       _   _         _   _
   ___| |_|_|___ ___| |_|_|___ ___
  | . | . | | -_|  _|  _| | . |   |
  |___|___| |___|___|_| |_|___|_|_|
        |___|(object)inject(ion)

       Runtime Mobile Exploration
          by: @leonjza from @sensepost

  默认情况下，通信将通过USB进行，除非提供了`--network`选项。

选项:
  -N, --network            使用网络连接而不是USB连接。
  -h, --host TEXT          [默认: 127.0.0.1]
  -p, --port INTEGER       [默认: 27042]
  -ah, --api-host TEXT     [默认: 127.0.0.1]
  -ap, --api-port INTEGER  [默认: 8888]
  -g, --gadget TEXT        要连接的Frida Gadget/进程的名称。 [默认: Gadget]
  -S, --serial TEXT        要连接的设备序列号。
  -d, --debug              启用带有详细输出的调试模式。(在堆栈跟踪中包括代{过}{滤}理源图)
  --help                   显示此消息并退出。

命令:
  api          以无头模式启动objection API服务器。
  device-type  获取关于已连接设备的信息。
  explore      启动objection探索REPL。
  patchapk     使用frida-gadget.so补丁一个APK。
  patchipa     使用FridaGadget dylib补丁一个IPA。
  run          运行单个objection命令。
  signapk      使用objection密钥对APK进行Zipalign和签名。
  version      打印当前版本并退出。

2.注入命令

objection -g 包名 explore

-   help：不知道当前命令的效果是什么，在当前命令前加help比如:help env，回车之后会出现当前命令的解释信息
-   按空格：不知道输入什么就按空格，会有提示出来
-   jobs：可以进行多项hook
-   日志：objection的日志文件生成在 C:\Users\Administrator\.objection

启动前就hook

`1`	`objection -g 进程名 explore --startup-command "android hooking watch class 路径.类名"`

3.objection基础api

memory list modules -查看内存中加载的库

memory list modules
Save the output by adding `--json modules.json` to this command
Name                                                              Base          Size                 Path
----------------------------------------------------------------  ------------  -------------------  ------------------------------------------------------------------------------
app_process64                                                     0x57867c9000  40960 (40.0 KiB)     /system/bin/app_process64
linker64                                                          0x72e326a000  229376 (224.0 KiB)   /system/bin/linker64
libandroid_runtime.so                                             0x72e164e000  2113536 (2.0 MiB)    /system/lib64/libandroid_runtime.so
libbase.so                                                        0x72dfa67000  81920 (80.0 KiB)     /system/lib64/libbase.so
libbinder.so                                                      0x72dec1c000  643072 (628.0 KiB)   /system/lib64/libbinder.so
libcutils.so                                                      0x72de269000  86016 (84.0 KiB)     /system/lib64/libcutils.so
libhidlbase.so                                                    0x72df4cc000  692224 (676.0 KiB)   /system/lib64/libhidlbase.so
liblog.so                                                         0x72e0be1000  98304 (96.0 KiB)     /system/lib64/liblog

memory list exports so名称 - 查看库的导出函数

memory list exports liblog.so
Save the output by adding `--json exports.json` to this command
Type      Name                                  Address
--------  ------------------------------------  ------------
function  android_log_write_int32               0x72e0be77c8
function  android_log_write_list_begin          0x72e0be76f0
function  __android_log_bswrite                 0x72e0be9bd8
function  __android_log_security                0x72e0bf2144
function  __android_log_bwrite                  0x72e0be9a18
function  android_log_reset                     0x72e0be75ec
function  android_log_write_string8             0x72e0be7a38
function  android_logger_list_free              0x72e0be8c04
function  __android_log_print                   0x72e0be9728
function  __android_logger_property_get_bool    0x72e0bf2248
function  android_logger_get_id                 0x72e0be8270
function  android_logger_set_prune_list         0x72e0be8948

android hooking list activities -查看内存中加载的activity /android hooking list services -查看内存中加载的services
android intent launch_activity 类名 -启动activity或service(可以用于一些没有验证的activity,在一些简单的ctf中有时候可以出奇效)
关闭ssl校验 android sslpinning disable
关闭root检测 android root disable

4.objection内存漫游

内存搜刮类实例

android heap search instances 类名(命令)
Class instance enumeration complete for com.zj.wuaipojie.Demo  
 Hashcode  Class                  toString()
---------  ---------------------  -----------------------------
215120583  com.zj.wuaipojie.Demo  com.zj.wuaipojie.Demo@cd27ac7

调用实例的方法

android heap execute <handle> getPublicInt(实例的hashcode+方法名)
如果是带参数的方法，则需要进入编辑器环境  
android heap evaluate <handle>  
console.log(clazz.a("吾爱破解"));
按住esc+enter触发

android hooking list classes -列出内存中所有的类(结果比静态分析的更准确)

android hooking list classes 

tw.idv.palatis.xappdebug.MainApplication
tw.idv.palatis.xappdebug.xposed.HookMain
tw.idv.palatis.xappdebug.xposed.HookMain$a
tw.idv.palatis.xappdebug.xposed.HookMain$b
tw.idv.palatis.xappdebug.xposed.HookMain$c
tw.idv.palatis.xappdebug.xposed.HookMain$d
tw.idv.palatis.xappdebug.xposed.HookSelf
u
v
void
w
xposed.dummy.XResourcesSuperClass
xposed.dummy.XTypedArraySuperClass

Found 10798 classes

android hooking search classes 关键类名 -在内存中所有已加载的类中搜索包含特定关键词的类

android hooking search classes wuaipojie
Note that Java classes are only loaded when they are used, so if the expected class has not been found, it might not have been loaded yet.
com.zj.wuaipojie.Demo
com.zj.wuaipojie.Demo$Animal
com.zj.wuaipojie.Demo$Companion
com.zj.wuaipojie.Demo$InnerClass
com.zj.wuaipojie.Demo$test$1
com.zj.wuaipojie.MainApplication
com.zj.wuaipojie.databinding.ActivityMainBinding
... 

Found 38 classes

android hooking search methods 关键方法名 -在内存中所有已加载的类的方法中搜索包含特定关键词的方法(一般不建议使用，特别耗时，还可能崩溃)
android hooking list class_methods 类名 -内存漫游类中的所有方法

android hooking list class_methods com.zj.wuaipojie.ui.ChallengeSixth
private static final void com.zj.wuaipojie.ui.ChallengeSixth.onCreate$lambda-0(com.zj.wuaipojie.ui.ChallengeSixth,android.view.View)
private static final void com.zj.wuaipojie.ui.ChallengeSixth.onCreate$lambda-1(com.zj.wuaipojie.ui.ChallengeSixth,android.view.View)
private static final void com.zj.wuaipojie.ui.ChallengeSixth.onCreate$lambda-2(com.zj.wuaipojie.ui.ChallengeSixth,android.view.View)
private static final void com.zj.wuaipojie.ui.ChallengeSixth.onCreate$lambda-3(com.zj.wuaipojie.ui.ChallengeSixth,android.view.View)
protected void com.zj.wuaipojie.ui.ChallengeSixth.onCreate(android.os.Bundle)
public final java.lang.String com.zj.wuaipojie.ui.ChallengeSixth.hexToString(java.lang.String)
public final java.lang.String com.zj.wuaipojie.ui.ChallengeSixth.unicodeToString(java.lang.String)
public final void com.zj.wuaipojie.ui.ChallengeSixth.toastPrint(java.lang.String)
public static void com.zj.wuaipojie.ui.ChallengeSixth.$r8$lambda$1lrkrgiCEFWXZDHzLRibYURG1h8(com.zj.wuaipojie.ui.ChallengeSixth,android.view.View)
public static void com.zj.wuaipojie.ui.ChallengeSixth.$r8$lambda$IUqwMqbTKaOGiTaeOmvy_GjNBso(com.zj.wuaipojie.ui.ChallengeSixth,android.view.View)
public static void com.zj.wuaipojie.ui.ChallengeSixth.$r8$lambda$Kc_cRYZjjhjsTl6GYNHbgD-i6sE(com.zj.wuaipojie.ui.ChallengeSixth,android.view.View)
public static void com.zj.wuaipojie.ui.ChallengeSixth.$r8$lambda$PDKm2AfziZQo6Lv1HEFkJWkUsoE(com.zj.wuaipojie.ui.ChallengeSixth,android.view.View)

Found 12 method(s)

5.objectionHook

hook类的所有方法

`1`	`android hooking watch class 类名`

hook方法的参数、返回值和调用栈

`1`	`android hooking watch class_method 类名.方法名 --dump-args --dump-return --dump-backtrace`

hook 类的构造方法

`1`	`android hooking watch class_method 类名.$init`

hook 方法的所有重载

`1`	`android hooking watch class_method 类名.方法名`

参考：

实用FRIDA进阶：内存漫游、hook anywhere、抓包

使用objection对吾爱破解2023春节安卓初级题进行快速解题

trace实战java控制流混淆

用到的实战题目：吾爱破解2023春节红包题

用到的混淆项目：DEX控制流混淆 · BlackObfuscator

项目效果展示：

混淆前

混淆后

对抗方法：

ZenTracer

注意:无法打印调用栈，无法hook构造函数，高版本Frida不一定兼容，需要pyqt5的库
r0tracer

AKA：精简版 objection + Wallbreaker

0x02 Process、Module、Memory基础

1.Process

Process 对象代表当前被Hook的进程，能获取进程的信息，枚举模块，枚举范围等

API	含义
`Process.id`	返回附加目标进程的 `PID`
`Process.isDebuggerAttached()`	检测当前是否对目标程序已经附加
`Process.enumerateModules()`	枚举当前加载的模块，返回模块对象的数组
`Process.enumerateThreads()`	枚举当前所有的线程，返回包含 `id`, `state`, `context` 等属性的对象数组

function processInfo() {
    Java.perform(function() {
        console.log("PID:", Process.id);
        console.log("架构:", Process.arch);
        console.log("平台:", Process.platform);
        console.log("调试器附加:", Process.isDebuggerAttached());
        
        // 枚举模块
        var modules = Process.enumerateModules();
        modules.forEach(function(module) {
            console.log("模块:", module.name, "基址:", module.base, "大小:", module.size);
        });
        
        // 枚举线程
        var threads = Process.enumerateThreads();
        threads.forEach(function(thread) {
            console.log("线程ID:", thread.id, "状态:", thread.state);
        });
    });
}

2.Module

Module 对象代表一个加载到进程的模块(例如，在 Windows 上的 DLL，或在 Linux/Android 上的 .so 文件),能查询模块的信息，如模块的基址、名称、导入/导出的函数等

API	含义
`Module.load()`	加载指定so文件，返回一个Module对象
`enumerateImports()`	枚举所有Import库函数，返回Module数组对象
`enumerateExports()`	枚举所有Export库函数，返回Module数组对象
`enumerateSymbols()`	枚举所有Symbol库函数，返回Module数组对象
`Module.findExportByName(exportName)、Module.getExportByName(exportName)`	寻找指定so中export库中的函数地址
`Module.findBaseAddress(name)、Module.getBaseAddress(name)`	返回so的基地址

function moduleInfo() {
    Java.perform(function() {
        // 获取模块基址的多种方式
        var base1 = Module.findBaseAddress("libtarget.so");
        var base2 = Process.getModuleByName("libtarget.so").base;
        console.log("模块基址:", base1, base2);
        
        // 查找导出函数
        var exportAddr = Module.findExportByName("libtarget.so", "target_function");
        console.log("导出函数地址:", exportAddr);
        
        // 枚举导入表
        var imports = Module.enumerateImports("libtarget.so");
        imports.forEach(function(imp) {
            console.log("导入:", JSON.stringify(imp));
        });
        
        // 枚举导出表
        var exports = Module.enumerateExports("libtarget.so");
        exports.forEach(function(exp) {
            console.log("导出:", JSON.stringify(exp));
        });
    });
}

3.Memory

Memory是一个工具对象，提供直接读取和修改进程内存的功能，能够读取特定地址的值、写入数据、分配内存等

方法	功能
`Memory.copy()`	复制内存
`Memory.scan()`	搜索内存中特定模式的数据
`Memory.scanSync()`	同上，但返回多个匹配的数据
`Memory.alloc()`	在目标进程的堆上申请指定大小的内存，返回一个`NativePointer`
`Memory.writeByteArray()`	将字节数组写入一个指定内存
`Memory.readByteArray`	读取内存

function memoryOperations() {
    Java.perform(function() {
        try {
            // 分配内存
            var allocated = Memory.alloc(1024);
            console.log("分配内存:", allocated);
            
            // 写入字符串
            var testStr = "Hello Frida";
            Memory.writeUtf8String(allocated, testStr);
            
            // 读取字符串
            var readStr = Memory.readCString(allocated);
            console.log("读取字符串:", readStr);
            
            // 内存扫描
            var pattern = "48 89 5C 24 ?? 48 89 6C 24";
            Memory.scan(Module.findBaseAddress("libtarget.so"), 
                       Process.getModuleByName("libtarget.so").size, 
                       pattern, {
                onMatch: function(address, size) {
                    console.log("找到模式在:", address, "大小:", size);
                },
                onError: function(reason) {
                    console.log("扫描错误:", reason);
                },
                onComplete: function() {
                    console.log("扫描完成");
                }
            });
            
        } catch(e) {
            console.log("内存操作错误:", e);
        }
    });
}

0x03 枚举导入导出表

导出表（Export Table）：列出了库中可以被其他程序或库访问的所有公开函数和符号的名称。
导入表（Import Table）：列出了库需要从其他库中调用的函数和符号的名称。

简而言之，导出表告诉其他程序：“这些是我提供的功能。”，而导入表则表示：“这些是我需要的功能。”。

 function hookTest1(){
    Java.perform(function(){
        //打印导入表
        var imports = Module.enumerateImports("lib52pojie.so");
        for(var i =0; i < imports.length;i++){
            if(imports[i].name == "vip"){
                console.log(JSON.stringify(imports[i])); //通过JSON.stringify打印object数据
                console.log(imports[i].address);
            }
        }
        //打印导出表
        var exports = Module.enumerateExports("lib52pojie.so");
        for(var i =0; i < exports.length;i++){
            console.log(JSON.stringify(exports[i]));
        }

    })
}

0x04 Native函数的基础Hook打印

1.整数型、布尔值类型、char类型Hook

function hookTest2(){
Java.perform(function(){
    //根据导出函数名打印地址
    var helloAddr = Module.findExportByName("lib52pojie.so","Java_com_zj_wuaipojie_util_SecurityUtil_checkVip");
    console.log(helloAddr); 
    if(helloAddr != null){
            //Interceptor.attach是Frida里的一个拦截器
        Interceptor.attach(helloAddr,{
                //onEnter里可以打印和修改参数
            onEnter: function(args){  //args传入参数
                console.log(args[0]);  //打印第一个参数的值
                console.log(this.context.x1);  // 打印寄存器内容
                console.log(args[1].toInt32()); //toInt32()转十进制
                                    console.log(args[2].readCString()); //读取字符串 char类型
                                    console.log(hexdump(args[2])); //内存dump

            },
            //onLeave里可以打印和修改返回值
            onLeave: function(retval){  //retval返回值
                console.log(retval);
                console.log("retval",retval.toInt32());
            }
        })
    }
})
}

2.字符串类型Hook

function hookTest2(){
    Java.perform(function(){
        //根据导出函数名打印地址
        var helloAddr = Module.findExportByName("lib52pojie.so","Java_com_zj_wuaipojie_util_SecurityUtil_vipLevel");
        if(helloAddr != null){
            Interceptor.attach(helloAddr,{
                //onEnter里可以打印和修改参数
                onEnter: function(args){  //args传入参数
                    // 方法一
                    var jString = Java.cast(args[2], Java.use('java.lang.String'));
                    console.log("参数:", jString.toString());
                    // 方法二
                    var JNIEnv = Java.vm.getEnv();
                    var originalStrPtr = JNIEnv.getStringUtfChars(args[2], null).readCString();        
                    console.log("参数:", originalStrPtr);                                
                },
                //onLeave里可以打印和修改返回值
                onLeave: function(retval){  //retval返回值
                    var returnedJString = Java.cast(retval, Java.use('java.lang.String'));
                    console.log("返回值:", returnedJString.toString());
                }
            })
        }
    })
}

0x05 Native函数的基础Hook修改

1.整数型修改

 function hookTest3(){
Java.perform(function(){
    //根据导出函数名打印地址
    var helloAddr = Module.findExportByName("lib52pojie.so","Java_com_zj_wuaipojie_util_SecurityUtil_checkVip");
    console.log(helloAddr);
    if(helloAddr != null){
        Interceptor.attach(helloAddr,{
            onEnter: function(args){  //args参数
                args[0] = ptr(1000); //第一个参数修改为整数 1000，先转为指针再赋值
                console.log(args[0]);

            },
            onLeave: function(retval){  //retval返回值
                retval.replace(20000);  //返回值修改
                console.log("retval",retval.toInt32());
            }
        })
    }
})
}

2.字符串类型修改

function hookTest2(){
Java.perform(function(){
    //根据导出函数名打印地址
    var helloAddr = Module.findExportByName("lib52pojie.so","Java_com_zj_wuaipojie_util_SecurityUtil_vipLevel");
    if(helloAddr != null){
        Interceptor.attach(helloAddr,{
            //onEnter里可以打印和修改参数
            onEnter: function(args){  //args传入参数
                var JNIEnv = Java.vm.getEnv();
                var originalStrPtr = JNIEnv.getStringUtfChars(args[2], null).readCString();        
                console.log("参数:", originalStrPtr);
                var modifiedContent = "至尊";
                var newJString = JNIEnv.newStringUtf(modifiedContent);
                args[2] = newJString;                                
            },
            //onLeave里可以打印和修改返回值
            onLeave: function(retval){  //retval返回值
                var returnedJString = Java.cast(retval, Java.use('java.lang.String'));
                console.log("返回值:", returnedJString.toString());
                var JNIEnv = Java.vm.getEnv();
                var modifiedContent = "无敌";
                var newJString = JNIEnv.newStringUtf(modifiedContent);
                retval.replace(newJString);
            }
        })
    }
})
}

0x06 SO基址的获取方式

1
2
3

var moduleAddr1 = Process.findModuleByName("lib52pojie.so").base;  
var moduleAddr2 = Process.getModuleByName("lib52pojie.so").base;  
var moduleAddr3 = Module.findBaseAddress("lib52pojie.so");

0x07 Hook未导出函数与函数地址计算

function hookTest6(){
    Java.perform(function(){
        //根据导出函数名打印基址
        var soAddr = Module.findBaseAddress("lib52pojie.so");
        console.log(soAddr);
        var funcaddr = soAddr.add(0x1071C);  
        console.log(funcaddr);
        if(funcaddr != null){
            Interceptor.attach(funcaddr,{
                onEnter: function(args){  //args参数

                },
                onLeave: function(retval){  //retval返回值
                    console.log(retval.toInt32());
                }
            })
        }
    })
}

函数地址计算

1.安卓里一般32 位的 so 中都是thumb指令，64 位的 so 中都是arm指令
2.通过IDA里的opcode bytes来判断，arm 指令为 4 个字节(options -> general -> Number of opcode bytes (non-graph) 输入4)
3.thumb 指令，函数地址计算方式： so 基址 + 函数在 so 中的偏移 + 1 arm 指令，函数地址计算方式： so 基址 + 函数在 so 中的偏移

0x08 Hook_dlopen

dlopen/android_dlopen_ext 是 Android 加载 SO 的系统函数，Hook 后可捕获 SO 加载时机，实现延迟 Hook（避免 SO 未加载时 Hook 失败）。

dlopen源码 android_dlopen_ext源码

function hook_dlopen() {
    var dlopen = Module.findExportByName(null, "dlopen");
    Interceptor.attach(dlopen, {
        onEnter: function (args) {
            var so_name = args[0].readCString();
            if (so_name.indexOf("lib52pojie.so") >= 0) this.call_hook = true;
        }, onLeave: function (retval) {
            if (this.call_hook) hookTest2();
        }
    });
    // 高版本Android系统使用android_dlopen_ext
    var android_dlopen_ext = Module.findExportByName(null, "android_dlopen_ext");
    Interceptor.attach(android_dlopen_ext, {
        onEnter: function (args) {
            var so_name = args[0].readCString();
            if (so_name.indexOf("lib52pojie.so") >= 0) this.call_hook = true;
        }, onLeave: function (retval) {
            if (this.call_hook) hookTest2();
        }
    });
}

参考文档：

IDA&Frida 学习

FRIDA-API使用篇：rpc、Process、Module、Memory使用方法及示例

IDA&Frida 学习

Frida Hook 常用函数、java 层 hook、so 层 hook、RPC、群控

一次IDA动态调试安卓apk记录

Fri, 26 Sep 2025 23:55:59 +0800

一次IDA动态调试安卓apk记录

工具清单：IDA Pro9.1 小米手机（MIUI 15.5.2）吾爱破解的教程demo（解压密码：52pj） ADB环境
在IDA目录下的dbgsrv，选择跟手机架构一致的server

在mt管理器中点开目标app的属性进行手动提权

也可以adb进入提权

重命名android_server为as，可以防止一些反调试
此处运行编辑好的.bat文件，也可以用命令行替代

运行成功就会显示如下画面（只需点击IDAdebug1.bat即可）

打开ida pro，设置Hostname为127.0.0.1 使用默认端口号为23946
对check函数下断点

然后

附加到对应进程，会出现如下所示窗口，选择same

然后程序会停在如图所示的地方，这时候要点开始调试（蓝色小三角），在手机输入任意字符串后点击验证

等待程序运行到断点
步进到比较函数处

点击_wuaipojie0123456就可以看到比较的值，即为flag

在第一次调试过程遇到了反调试，在JNI_OnLoad中

将对应代码patch掉后，右键保存

点击Apply patches覆盖掉原本的so文件，然后将这个so文件替换原本的apk/lib/arm64-v8a中的so文件，重新安装该应用，再次运行上述操作，即可绕过反调试

补充常见寄存器知识

在进行动态调试，以下是一些常用的寄存器介绍：

寄存器名称	功能介绍
`R0-R12`	通用寄存器，用于存储临时数据。在函数调用时，`R0-R3`用于存储前四个参数，其余的参数通过堆栈传递。返回值也通过`R0`和`R1`传递。
`R13 (SP)`	堆栈指针寄存器，指向当前堆栈的顶部。
`R14 (LR)`	链接寄存器，存储子程序的返回地址。
`R15 (PC)`	程序计数器，指向下一条要执行的指令。
`CPSR`	当前程序状态寄存器，保存程序的状态信息，如算术运算的结果标志、中断禁止标志等。
`FPSCR`	浮点状态和控制寄存器，如果你在调试的代码中涉及到浮点运算，那么这个寄存器会比较重要。

常用快捷键

快捷键	功能
`F2`	在所在行下断点
`F5`	可以将ARM指令转化为可读的C代码，同时可以使用Y键，对JNIEnv指针做一个类型转换，从而对JNI里经常使用的JNIEnv方法能够识别
`F7`	单步进入调试
`F8`	按照顺序一行一行，单步调试
`F9`	直接跳到下一个断点处
`Shift + F12`	快速查看so文件中的字符串信息，分析过程中通过一些关键字符串能够迅速定位到关键函数
`Ctrl + s`	有两个用途，在IDA View页面中可以查看文件so文件的所有段信息，在调试页面可以查看程序中所有so文件映射到内存的基地址。tips:在进行so调试过程中，很有用的一个小技巧就是IDA双开，一个用于进行静态分析；一个用于动态调试。比如说调试过程中要找到一个函数的加载到内存中的位置
`Esc`	回退键，能够倒回上一部操作的视图（只有在反汇编窗口才是这个作用，如果是在其他窗口按下esc，会关闭该窗口）
`g`	直接跳到某个地址
`y`	更改变量的类型
`x`	对着某个函数、变量按该快捷键，可以查看它的交叉引用
`n`	更改变量的名称
`p`	创建函数

可能遇到的问题

1.jdb 不是内部或外部命令，也不是可运行的程序或批处理文件。

http://t.csdn.cn/paKAt

java.io.IOException: handshake failed - connection prematurally closed
        at com.sun.tools.jdi.SocketTransportService.handshake(SocketTransportService.java:136)
        at com.sun.tools.jdi.SocketTransportService.attach(SocketTransportService.java:232)
        at com.sun.tools.jdi.GenericAttachingConnector.attach(GenericAttachingConnector.java:116)
        at com.sun.tools.jdi.SocketAttachingConnector.attach(SocketAttachingConnector.java:90)
        at com.sun.tools.example.debug.tty.VMConnection.attachTarget(VMConnection.java:519)
        at com.sun.tools.example.debug.tty.VMConnection.open(VMConnection.java:328)
        at com.sun.tools.example.debug.tty.Env.init(Env.java:63)
        at com.sun.tools.example.debug.tty.TTY.main(TTY.java:1066)
致命错误:
无法附加到目标 VM。
解决方法：有可能是手机问题，建议低版本真机，不要用模拟器！切命令顺序不要乱！另外也有可能软件有反调试！

3.动态调试中找不到so文件解决方法：可以尝试手动复制一份对应的so文件放到data/app/包名/lib目录下
4.device offline 解决方法：重新插拔usb，再不行就重启机子
5.0.0.0.0:23946: bind: Address already in use 解决方案： adb shell "su -c 'lsof | grep 23946'" //获取pid adb shell "su -c 'kill -9 PID'" //这里的pid要根据上一步获取的填写
6.常见反调试
调试端口检测

检测常见的23946端口，所以在运行时可以加-p指定一个另外的端口来过掉这个检测

例如，使用./as -p 12345命令启动调试server，将调试端口改为12345，然后在IDA Pro中相应地修改端口号为12345进行连接。
调试进程名检测

固定的进程名 android_server gdb_server等等，所以要改个名字，例如as64
ptrace检测

每个进程同时刻只能被1个调试进程ptrace ，主动ptrace本进程可以使得其他调试器无法调试

实现代码：

int ptrace_protect()//ptrace附加自身线程 会导致此进程TracerPid 变为父进程的TracerPid 即zygote
{
    return ptrace(PTRACE_TRACEME,0,0,0);;//返回-1即为已经被调试
}

推荐一个安卓的显示控制软件：QtScrcpy

打开如下按钮后可以实现电脑的模拟点击，非常好用

参考文件：

《安卓逆向这档事》十二、大佬帮我分析一下

IDA修改exe并保存运行

使用IDA进行动态调试与过反调试（上）（三）

安卓逆向入门六：so(ELF)文件分析与ARM基础知识

Thu, 25 Sep 2025 22:07:51 +0800

关键词：ELF文件入门、so文件分析、ARM基础知识

0x00 ELF文件入门

ELF（Executable and Linkable Format）是一种可执行和可链接的文件格式，是linux底下二进制文件，可以理解为windows下的PE文件，在Android中可以比作SO，方便函数的移植，在常用于保护Android软件，增加逆向难度。其核心价值在于支持程序的执行（如二进制程序运行、动态库加载）和链接（编译过程中的模块组合），是跨平台二进制兼容的基础。

ELF文件的主要组成部分包括：

ELF Header：文件头，描述文件的基本信息
Program Header Table：程序头表，描述进程映像的布局
Section Header Table：节区头表，描述文件的各个节区
程序头表与分段头表引用的数据，比如 .text .data。

ELF Header（文件头）

ELF Header 描述了 ELF 文件的概要信息，利用这个数据结构可以索引到 ELF 文件的全部信息，是ELF 文件的 “总目录”，存储文件的基础元信息，可通过这些信息索引到其他所有结构。32 位 ELF 的文件头结构定义如下：

#define EI_NIDENT   16

typedef struct {
    unsigned char   e_ident[EI_NIDENT];
    ELF32_Half      e_type;
    ELF32_Half      e_machine;
    ELF32_Word      e_version;
    ELF32_Addr      e_entry;
    ELF32_Off       e_phoff;
    ELF32_Off       e_shoff;
    ELF32_Word      e_flags;
    ELF32_Half      e_ehsize;
    ELF32_Half      e_phentsize;
    ELF32_Half      e_phnum;
    ELF32_Half      e_shentsize;
    ELF32_Half      e_shnum;
    ELF32_Half      e_shstrndx;
} Elf32_Ehdr;

ELF 头中的 e_shoff 项给出了从文件开头到节头表位置的字节偏移。e_shnum 告诉了我们节头表包含的项数；e_shentsize 给出了每一项的字节大小。

Program Header Table（程序头表）

Program Header Table 是一个结构体数组，每一个元素的类型是 Elf32_Phdr，描述了一个段或者其它系统在准备程序执行时所需要的信息。

其中，ELF 头中的 e_phentsize 和 e_phnum 指定了该数组每个元素的大小以及元素个数。一个目标文件的段包含一个或者多个节。程序的头部只有对于可执行文件和共享目标文件有意义。

可以说，Program Header Table 就是专门为 ELF 文件运行时中的段所准备的。

Elf32_Phdr的定义如下

typedef struct {
    ELF32_Word  p_type;
    ELF32_Off   p_offset;
    ELF32_Addr  p_vaddr;
    ELF32_Addr  p_paddr;
    ELF32_Word  p_filesz;
    ELF32_Word  p_memsz;
    ELF32_Word  p_flags;
    ELF32_Word  p_align;
} Elf32_Phdr;

字段说明

字段	说明
`p_type`	该字段为段的类型，或者表明了该结构的相关信息。
`p_offset`	该字段给出了从文件开始到该段开头的第一个字节的偏移。
`p_vaddr`	该字段给出了该段第一个字节在内存中的虚拟地址。
`p_paddr`	该字段仅用于物理地址寻址相关的系统中，由于 “System V” 忽略了应用程序的物理寻址，可执行文件和共享目标文件的该项内容并未被限定。
`p_filesz`	该字段给出了文件镜像中该段的大小，可能为 0。
`p_memsz`	该字段给出了内存镜像中该段的大小，可能为 0。
`p_flags`	该字段给出了与段相关的标记。
`p_align`	可加载的程序的段的 `p_vaddr` 以及 `p_offset` 的大小必须是 `page` 的整数倍。该成员给出了段在文件以及内存中的对齐方式。如果该值为 0 或 1 的话，表示不需要对齐。除此之外，p_align 应该是 2 的整数指数次方，并且 `p_vaddr` 与 `p_offset` 在模 `p_align` 的意义下，应该相等。

核心意义：操作系统加载 ELF 文件时，根据程序头表将 “段” 映射到内存，例如：

p_type=PT_LOAD的段会被加载到p_vaddr指定的内存地址。
p_flags=0x5（R+X）通常对应代码段（可执行且只读），p_flags=0x6（R+W）对应数据段。

Section Header Table（节区头表）

该结构用于定位 ELF 文件中的每个节区的具体位置。描述 ELF 文件在编译链接时的结构（即 “节区” 信息），用于调试、静态分析等场景。每个条目对应一个Elf32_Shdr结构：

typedef struct {
    ELF32_Word      sh_name;
    ELF32_Word      sh_type;
    ELF32_Word      sh_flags;
    ELF32_Addr      sh_addr;
    ELF32_Off       sh_offset;
    ELF32_Word      sh_size;
    ELF32_Word      sh_link;
    ELF32_Word      sh_info;
    ELF32_Word      sh_addralign;
    ELF32_Word      sh_entsize;
} Elf32_Shdr;

成员	说明	取值	说明
`sh_name`	`sh_name`节名称，是节区头字符串表节区中（Section Header String Table Section）的索引，因此该字段实际是一个数值。在字符串表中的具体内容是以 NULL 结尾的字符串。	0	无名称
`sh_type`	`sh_type`根据节的内容和语义进行分类，具体的类型下面会介绍。	SHT_NULL	限制
`sh_flags`	`sh_flags`每一比特代表不同的标志，描述节是否可写，可执行，需要分配内存等属性。	0	无标志
`sh_addr`	`sh_addr`如果节区将出现在进程的内存映像中，此成员给出节区的第一个字节应该在进程镜像中的位置。否则，此字段为 0。	0	无地址
`sh_offset`	`sh_offset`给出节区的第一个字节与文件开始处之间的偏移。SHT_NOBITS 类型的节区不占用文件的空间，因此其 sh_offset 成员给出的是概念性的偏移。	0	无文件偏移
`sh_size`	`sh_size`此成员给出节区的字节大小。除非节区的类型是 SHT_NOBITS ，否则该节占用文件中的 `sh_size` 字节。类型为 SHT_NOBITS 的节区长度可能非零，不过却不占用文件中的空间。	0	无大小
`sh_link`	`sh_link`此成员给出节区头部表索引链接，其具体的解释依赖于节区类型。	SHN_UNDEF	无链接信息
`sh_info`	`sh_info`此成员给出附加信息，其解释依赖于节区类型。	0	无辅助信息
`sh_addralign`	`sh_addralign`某些节区的地址需要对齐。例如，如果一个节区有一个 doubleword 类型的变量，那么系统必须保证整个节区按双字对齐。也就是说，sh_addr%sh_addralign=0。目前它仅允许为 0，以及 2 的正整数幂数。 0 和 1 表示没有对齐约束。	0	无对齐要求

常见节区（Sections）

节区是 ELF 文件的实际数据载体，常见类型及作用如下：

节区名	描述
`.text`	代码段，存放程序的指令
`.data`	数据段，存放已初始化的全局变量和静态变量
`.rodata`	只读数据段，存放只读数据
`.bss`	未初始化数据段，存放未初始化的全局变量和静态变量
`.symtab`	符号表，存放符号信息
`.strtab`	字符串表，存放字符串数据
`.dynsym`	动态符号表，存放动态链接需要的符号信息
`.dynamic`	动态链接信息，存放动态链接器需要的信息

段与节区的关系

段（Segment）：面向运行时，由一个或多个节区组成（如.text和.rodata可合并为一个 “代码段”）。
节区（Section）：面向编译时，按功能划分的最小数据单元。

例如：一个PT_LOAD段可能包含.text（代码）和.rodata（只读数据）两个节区，共同映射到内存的只读可执行区域。

0x01 ARM基础知识

“x86、arm、RISC-V” 都是 指令集架构 ( CPU架构 )。ARM 是主流的 RISC（精简指令集）架构，广泛用于嵌入式设备（如 Android 手机）。
指令集特点
固定指令长度（32 位 ARM 指令，Thumb 模式为 16 位）。
大部分指令可条件执行（如ADDNE R0, R1, R2：仅当标志位不为 0 时执行加法）。
寄存器操作优先（算术 / 逻辑运算通常基于寄存器，内存访问需专用指令）。
核心寄存器

ARM32 架构有 16 个通用寄存器（R0-R15），其中：

R0-R3：函数调用参数 / 返回值寄存器。
R4-R11：通用寄存器（需手动保存）。
R12（IP）：临时寄存器。
R13（SP）：栈指针寄存器（指向栈顶）。
R14（LR）：链接寄存器（存储函数返回地址）。
R15（PC）：程序计数器（存储下一条执行的指令地址）。

常见寻址方式

寻址方式	描述
立即数寻址	直接使用立即数值作为操作数，例如：`MOV R0, #5`
寄存器直接寻址	使用寄存器中的值作为操作数，例如：`MOV R0, R1`
寄存器间接寻址	使用寄存器中的值作为内存地址，访问该地址中的数据，例如：`LDR R0, [R1]`
寄存器相对寻址	使用寄存器中的值加上一个立即偏移量作为内存地址，例如：`LDR R0, [R1, #4]`
寄存器变址寻址	使用两个寄存器中的值相加作为内存地址，例如：`LDR R0, [R1, R2]`
带有变址寄存器的寄存器相对寻址	使用寄存器中的值加上另一个寄存器的值乘以一个比例因子作为内存地址，例如：`LDR R0, [R1, R2, LSL #2]`
堆栈寻址	使用堆栈指针寄存器（如SP）进行操作，例如：`PUSH {R0, R1}` 或 `POP {R0, R1}`

压栈和出栈指令

指令类型	指令示例	描述
压栈	`PUSH {R0, R1}`	将寄存器R0和R1的内容压入堆栈中
压栈	`PUSH {R0-R5}`	将寄存器R0到R5的内容压入堆栈中
压栈	`STMDB SP!, {R0-R5}`	将寄存器R0到R5的内容压入堆栈中（与PUSH等效）
出栈	`POP {R0, R1}`	从堆栈中弹出数据，恢复到寄存器R0和R1中
出栈	`POP {R0-R5}`	从堆栈中弹出数据，恢复到寄存器R0到R5中

跳转指令

指令类型	指令示例	描述
无条件跳转	`B label`	无条件跳转到标签`label`指向的位置
子程序调用	`BL label`	调用子程序，将当前指令的下一条指令地址存入链接寄存器（LR），然后跳转到标签`label`指向的位置
子程序返回	`BX LR`	返回子程序调用前的位置，跳转到链接寄存器（LR）中存储的地址
寄存器跳转	`BX Rn`	跳转到寄存器Rn中存储的地址

算术运算指令

汇编中也可以进行算术运算，比如加减乘除，常用的运算指令用法如表所示：

指令	计算公式	备注
`ADD Rd, Rn, Rm`	Rd = Rn + Rm	加法运算，指令为 ADD
`ADD Rd, Rn, #immed`	Rd = Rn + #immed	加法运算，指令为 ADD
`ADC Rd, Rn, Rm`	Rd = Rn + Rm + 进位	带进位的加法运算，指令为 ADC
`ADC Rd, Rn, #immed`	Rd = Rn + #immed + 进位	带进位的加法运算，指令为 ADC
`SUB Rd, Rn, Rm`	Rd = Rn - Rm	减法
`SUB Rd, #immed`	Rd = Rd - #immed	减法
`SUB Rd, Rn, #immed`	Rd = Rn - #immed	减法
`SBC Rd, Rn, #immed`	Rd = Rn - #immed - 借位	带借位的减法
`SBC Rd, Rn ,Rm`	Rd = Rn - Rm - 借位	带借位的减法
`MUL Rd, Rn, Rm`	Rd = Rn * Rm	乘法 (32 位)
`UDIV Rd, Rn, Rm`	Rd = Rn / Rm	无符号除法
`SDIV Rd, Rn, Rm`	Rd = Rn / Rm	有符号除法

逻辑运算

汇编语言的时候也可以使用逻辑运算指令，常用的运算指令用法如表所示：

0x02 Android so文件分析

1.SO 文件概述

SO 文件是 Unix/Linux 系统中的动态库文件，被称为共享目标文件（Shared Object File），后缀名为 .so，它是 ELF 的一种，另外属于 ELF 类型的还有可重定位文件（Relocatable File）以及核心转储文件（Core Dump File）。
SO 文件通常用于提高开发效率、方便快速移植代码，以及保护 Android 应用的核心逻辑，增加逆向工程的难度。不同的 CPU 架构（如 ARM、x86 等）需要不同版本的 SO 文件来适配其指令集和运行环境。

ELF 文件类型	典型后缀	核心用途	逆向 / 开发场景举例	与 ARM 的关联
可执行文件	无（如`/bin/ls`）	直接运行的程序	分析 Linux/ARM 嵌入式设备的二进制逻辑	ARM32/64 位设备的可执行文件需对应架构
共享目标文件（SO）	`.so`	供其他程序动态调用的库（代码复用 + 保护）	逆向 Android 的`libnative.so`（核心逻辑载体）	Android SO 分`armeabi-v7a`（ARM32）、`arm64-v8a`（ARM64）
目标文件	`.o`	编译后的中间文件（未链接）	分析编译后的单个模块代码（如 NDK 编译的`xxx.o`）	ARM 编译器（如`arm-linux-androideabi-gcc`）生成对应.o
核心转储文件	`.core`	程序崩溃时的内存快照	分析 SO 崩溃原因（如空指针访问导致的 core dump）	ARM 设备崩溃时生成的 core 需用 ARM 架构的 gdb 分析

Android 是基于 Linux 内核开发的操作系统，所以 Android 平台上的可执行文件格式和 Unix/Linux 是一致的。
so文件大体上可分为四部分，一般来说从上往下是ELF头部->Pargarm头部->节区(Section)->节区头，其中，除了ELF头部在文件位置固定不变外，其余三部分的位置都不固定。
整体结构图参考非虫大佬的图：

2.SO 文件的加载方法

Android 通过 Java 层的System类加载 SO，核心方法有两种：

方法	签名	特点	适用场景
`loadLibrary`	`System.loadLibrary(String name)`	自动拼接文件名（name → libname.so），从默认路径（如`/data/app/.../lib`）加载。	应用内置 SO 的常规加载。
`load`	`System.load(String path)`	需传入 SO 的绝对路径（如`/sdcard/libtest.so`）。	插件化加载、动态下载的 SO。

3.SO 文件的加载流程

loadLibrary 加载流程

调用 System.loadLibrary(String libName) 时，实际上会调用 Runtime.getRuntime().loadLibrary(String libName)。
Runtime.loadLibrary(String libName) 会进一步调用 Runtime.loadLibrary(String libName, ClassLoader loader)，其中 loader 是当前线程的类加载器。
通过类加载器找到对应的 SO 文件路径，然后调用 doLoad(String name, ClassLoader loader) 方法进行加载。

load 加载流程

调用 System.load(String pathName) 时，实际上会调用 Runtime.getRuntime().load(String pathName)。
Runtime.load(String pathName) 会调用 Runtime.load(String pathName, ClassLoader loader)，同样会调用 doLoad(String name, ClassLoader loader) 方法进行加载。

核心加载流程：doLoad

路径处理：doLoad 方法会根据传入的路径和类加载器，确定 SO 文件的实际路径。
动态链接库加载：调用 dlopen 函数加载动态链接库。
JNI_OnLoad 调用：如果 SO 文件中定义了 JNI_OnLoad 函数，则在加载完成后调用该函数进行初始化。

参考文件：

Android so(ELF)文件解析

《安卓逆向这档事》十、不是我说，有了IDA还要什么女朋友？

android 加载so过程分析

[ctfwiki]so 介绍

光速虚拟机3.8.2 root及adb远程连接操作

Tue, 23 Sep 2025 00:37:06 +0800

一、手机端下载并配置光速虚拟机 3.8.2

1.下载模拟器：在手机应用商店或官方渠道，搜索并下载 “光速虚拟机 3.8.2” 版本，安装完成后打开，此时会指导进行解除安卓进程限制，跟着步骤来即可。

2.创建安卓 10 实例：进入模拟器主界面，点击 “新建实例”，在系统版本选项中选择 “安卓 10”，等待实例创建完成（过程需耐心等待，避免中途退出)。

3.开启 root 相关权限：

进入已创建的安卓 10 实例，在实例浮窗内找到 “设置” 图标，进入后依次开启 “Magisk 支持” 和 “超级用户” 功能。

4.调整网络设置：

因使用手机自身流量（路由器不支持远程 adb），需关闭网络隔离：进入浮窗内的 “设置 - 网络设置”，找到 “本地网络隔离” 选项，将其关闭（防止流量网络被隔离，影响后续连接）。

二、安装 Magisk25.0 完成 root

下载指定版本 Magisk：在安卓 10 实例内，通过浏览器访问 Magisk 官网旧版本页面，下载 “Magisk25.0” 安装包（高版本不兼容光速虚拟机 3.8.2，需严格选择 25.0 版本，其余低版本未曾尝试，可能也支持）。
安装 Magisk：

找到下载好的 Magisk25.0 安装包，点击Magisk处的“安装”，弹出安装界面后直接点击 “下一步”，在安装方式中选择 “直接安装（推荐）”，等待安装进度完成。

重启验证 root：

安装完成后，按照提示重启安卓 10 实例；重启后先关闭实例内的 “超级用户” 功能，再重启，此时 root 操作完成（可通过实例内的 Magisk 应用查看 “已安装” 状态，确认 root 成功）。

三、在安卓 10 实例内开启开发者模式与 USB 调试

进入 “关于手机”：在安卓 10 实例内打开 “设置”，滑动至底部找到 “关于手机” 选项，点击进入。
触发开发者模式：在 “关于手机” 页面中，找到 “版本号” 选项，连续点击 7 次 “版本号”，此时会弹出 “您现在处于开发者模式！” 的提示（若弹出验证密码 / 指纹，按实例内设置完成验证即可）。
开启 USB 调试：返回 “设置” 主界面，找到 “系统” 选项；点击进入 “开发者选项”，找到 “USB 调试” 选项并开启（部分系统需勾选 “允许 USB 调试” 弹窗，点击 “确定” 即可）。

四、电脑端通过 adb 远程连接手机

准备工作：确保电脑已提前下载并配置好 adb 环境（adb 工具包路径已添加至系统环境变量，可通过 “cmd 输入 adb –version” 验证配置）。
建立网络连接：

打开手机的 “个人热点”，将电脑连接至该热点（确保手机与电脑处于同一热点网络，替代不支持 adb 的路由器）。

获取手机 IP：

在手机 “设置 - 无线和网络 - 个人热点” 中，查看热点的 “已连接设备” 或 “网络详情”，记录手机当前的 IP 地址（如 10.77.xx.xx）。

执行 adb 连接命令：

打开电脑的命令提示符（CMD），输入命令：adb connect 手机IP:6556（将 “手机 IP” 替换为实际记录的地址，如adb connect 10.77.xx.xx:6556）。
若一切正常此时手机会弹出提示，点击确认即可。
若命令行显示 “connected to 手机 IP:6556”，则表示远程 adb 调试连接成功，可开始进行后续调试操作。

下载用的模拟器以及magisk：

https://pan.baidu.com/s/1ePYYJIPQXNRKJyA9qJclWA?pwd=kdcq 提取码: kdcq

安卓逆向入门五：Xposed和hook入门

Sun, 21 Sep 2025 23:31:39 +0800

关键词：Xposed原理和常用api、Android Studio安装以及环境配置、hook、借助lspatch实现免root注入、SimpleHook快速hook

0x00 什么是Xposed

Xposed 是一款无需修改 APK 即可影响程序运行的 Hook 框架，基于它可以开发功能强大的插件 APP，实现对目标应用的注入、拦截、修改等操作，且多个功能不冲突的模块可同时运行。

简单来说，Xposed 的核心是 “在不改变原应用代码的情况下，动态干预其运行逻辑”，这使得它成为安卓逆向、功能扩展的重要工具。

Xposed (维基百科)

0x01 Xposed原理

Xposed 的核心是劫持 Zygote 进程（安卓系统的进程孵化器，所有应用进程都由它创建），具体过程如下：

用自定义实现的app_process替换系统原生的app_process；
加载额外的 XposedBridge.jar 包，将程序入口从系统默认的com.android.internal.os.ZygoteInit.main()替换为de.robv.android.xposed.XposedBridge.main()；
改造后的 Zygote 进程创建的所有 Dalvik/ART 虚拟机都会被 Hook，从而实现对所有应用进程的动态干预。

通俗来讲，hook就是狸猫换太子

0x02 Xposed的发展及免root框架

随着安卓版本迭代，Xposed 衍生出多个分支，下表整理了主流框架的特点：

名称	地址	支持版本	是否免root
xposed	https://github.com/rovo89/Xposed	2.3-8.1	否
EDXposed	https://github.com/ElderDrivers/EdXposed	8.0-10	否
LSPosed	https://github.com/LSPosed/LSPosed	8.1-13	否
VirtualXposed	https://github.com/android-hacker/VirtualXposed	5.0-10.0	是
太极	https://www.coolapk.com/apk/me.weishu.exp	5.0-13	是
两仪	https://www.coolapk.com/apk/io.twoyi	8.1-13	是
天鉴	https://github.com/Katana-Official/SPatch-Update	6-10	是

0x03 Xposed可以用来做什么？

功能增强：修改应用布局（如上帝模式）、去除广告（如知乎去广告模块）；
数据干预：劫持参数 / 返回值（如微信防撤回、步数修改、一键新机）；
自动化操作：微信自动抢红包、抖音自动操作等；
逆向辅助：动态分析应用逻辑、绕过加密 / 验证（如XServer）。

2022 最好的Xposed模块: GravityBox, Pixelify, XPrivacyLua

基于Xposed的抖音爬虫，抖音风控后自动一键新机，模拟一个全新的运行环境

基于xposed的frida持久化方案

A Xposed Module for Android Penetration Test, with NanoHttpd.

GravityBox

Xposed-Modules-Repo]

一个旨在使QQ变得更好用的开源Xposed模块

杜比大喇叭

哔哩漫游

曲境

自动化创建Xposed模块及钩子，让Xposed模块编写时只需关注钩子实现

0x04 Xposed环境配置

这里下载的是正己提供的Ubuntu虚拟机密码:toor

内置:

Frida开发环境
动态分析及开发工具：android-studio
动态分析工具：ddms
静态分析工具：jadx1.4.4
动静态分析工具：jeb
动态分析工具：集成HyperPwn
静态分析工具：010 editor
抓包工具：Charles
抓包工具：WireShark
动态分析工具:unidbg

1.Android Studio创建新项目
2.将下载的xposedBridgeApi.jar包拖进libs文件夹
3.右击jar包，选择add as library

4.修改AndroidManifest.xml文件配置

将如下代码复制到xml文件中，如图

<!-- 是否是xposed模块，xposed根据这个来判断是否是模块 -->
<meta-data
    android:name="xposedmodule"
    android:value="true" />
<!-- 模块描述，显示在xposed模块列表那里第二行 -->
<meta-data
    android:name="xposeddescription"
    android:value="这是一个Xposed模块" />
<!-- 最低xposed版本号(lib文件名可知) -->
<meta-data
    android:name="xposedminversion"
    android:value="89" />

5.修改build.gradle,将此处修改为compileOnly 默认的是implementation

implementation 使用该方式依赖的库将会参与编译和打包

compileOnly 只在编译时有效，不会参与打包

6.新建–>Folder–>Assets Folder，创建xposed_init(不要后缀名):只有一行代码，就是说明入口类

7.新建Hook类，实现IXposedHookLoadPackage接口，然后在handleLoadPackage函数内编写Hook逻辑

import de.robv.android.xposed.IXposedHookLoadPackage; 
import de.robv.android.xposed.callbacks.XC_LoadPackage;

public class Hook implements IXposedHookLoadPackage {
    @Override
    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {

    }
}

继承了IXposedHookLoadPackag便拥有了hook的能力

0x05 Xposed常用API

1.Hook普通方法

修改返回值

XposedHelpers.findAndHookMethod("com.zj.wuaipojie.Demo", loadPackageParam.classLoader, "a", String.class, new XC_MethodHook() {
    @Override
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
        super.afterHookedMethod(param);
        param.setResult(999);
    }
});

修改参数

XposedHelpers.findAndHookMethod("com.zj.wuaipojie.Demo", loadPackageParam.classLoader, "a", String.class, new XC_MethodHook() {
    @Override
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
        super.beforeHookedMethod(param);
        String a = "pt";
        param.args[0] = a;    }
});

2.Hook复杂&自定义参数

Class a = loadPackageParam.classLoader.loadClass("类名");
XposedBridge.hookAllMethods(a, "方法名", new XC_MethodHook() {
    @Override
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
        super.beforeHookedMethod(param);

        }
});

3.Hook替换函数

使用XC_MethodReplacement直接替换原方法：

Class a = classLoader.loadClass("类名")
XposedBridge.hookAllMethods(a,"方法名",new XC_MethodReplacement() {  
    @Override  
    protected Object replaceHookedMethod(MethodHookParam methodHookParam) throws Throwable {  
        return "";  
    }  
});

上图中日志这里的 “这是替换函数” 就被替换无了

4.Hook加固通杀

加固应用会动态加载 dex，需在Application.attach时获取加载后的类加载器：

XposedHelpers.findAndHookMethod(Application.class, "attach", Context.class, new XC_MethodHook() {  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        Context context = (Context) param.args[0];  
        ClassLoader classLoader = context.getClassLoader();
        //hook逻辑在这里面写  
    }  
});

5.Hook变量

静态变量与实例变量
- 静态变量(static)：类被初始化，同步进行初始化
- 非静态变量：类被实例化(产生一个对象的时候)，进行初始化

6.Hook构造函数

无参构造函数

XposedHelpers.findAndHookConstructor("com.zj.wuaipojie.Demo", classLoader, new XC_MethodHook() {
    @Override
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
        super.beforeHookedMethod(param);
    }
    @Override
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
        super.afterHookedMethod(param);
    }
});

有参构造函数

XposedHelpers.findAndHookConstructor("com.zj.wuaipojie.Demo", classLoader, String.class, new XC_MethodHook() {
    @Override
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
        super.beforeHookedMethod(param);
    }
    @Override
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
        super.afterHookedMethod(param);
    }
});

7.Hook multiDex方法

XposedHelpers.findAndHookMethod(Application.class, "attach", Context.class, new XC_MethodHook() {  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        ClassLoader cl= ((Context)param.args[0]).getClassLoader();  
        Class<?> hookclass=null;  
        try {  
            hookclass=cl.loadClass("类名");  
        }catch (Exception e){  
            Log.e("zj2595","未找到类",e);  
            return;        
        }  
        XposedHelpers.findAndHookMethod(hookclass, "方法名", new XC_MethodHook() {  
            @Override  
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
            }        
        });  
    }  
});

8.主动调用

静态方法

1
2

Class clazz = XposedHelpers.findClass("类名",lpparam.classLoader);
XposedHelpers.callStaticMethod(clazz,"方法名",参数(非必须));

实例方法

1
2

Class clazz = XposedHelpers.findClass("类名",lpparam.classLoader);
XposedHelpers.callMethod(clazz.newInstance(),"方法名",参数(非必须));

9.Hook内部类

内部类名格式为外部类$内部类（如com.zj.wuaipojie.Demo$InnerClass）

XposedHelpers.findAndHookMethod("com.zj.wuaipojie.Demo$InnerClass", lpparam.classLoader, "innerFunc",String.class,  new XC_MethodHook() {  
    @Override  
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
        super.beforeHookedMethod(param);  

    }  
});

10.反射大法

Class clazz = XposedHelpers.findClass("com.zj.wuaipojie.Demo", lpparam.classLoader);
XposedHelpers.findAndHookMethod("com.zj.wuaipojie.Demo$InnerClass", lpparam.classLoader, "innerFunc",String.class,  new XC_MethodHook() {  
    @Override  
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
        super.beforeHookedMethod(param);  
        //第一步找到类
        //找到方法，如果是私有方法就要setAccessible设置访问权限
        //invoke主动调用或者set修改值(变量)
        Class democlass = Class.forName("com.zj.wuaipojie.Demo",false,lpparam.classLoader);  
        Method demomethod = democlass.getDeclaredMethod("refl");  
        demomethod.setAccessible(true);  
        demomethod.invoke(clazz.newInstance());  
    }  
});

11.遍历所有类下的所有方法

XposedHelpers.findAndHookMethod(ClassLoader.class, "loadClass", String.class, new XC_MethodHook() {  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        super.afterHookedMethod(param);  
        Class clazz = (Class) param.getResult();  
        String clazzName = clazz.getName();  
        //排除非包名的类  
        if(clazzName.contains("com.zj.wuaipojie")){  
            Method[] mds = clazz.getDeclaredMethods();  
            for(int i =0;i<mds.length;i++){  
                final Method md = mds[i];  
                int mod = mds[i].getModifiers();  
                //去除抽象、native、接口方法  
                if(!Modifier.isAbstract(mod)  
                    && !Modifier.isNative(mod)  
                    &&!Modifier.isAbstract(mod)){  
                    XposedBridge.hookMethod(mds[i], new XC_MethodHook() {  
                        @Override  
                        protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
                            super.beforeHookedMethod(param);  
                            Log.d("zj2595",md.toString());  
                        }  
                    });  
                }  

           }  
        }  

    }  
});

0x06 Xposed妙用

字符串赋值定位:

XposedHelpers.findAndHookMethod("android.widget.TextView", lpparam.classLoader, "setText", CharSequence.class, new XC_MethodHook() {  
    @Override  
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
        super.beforeHookedMethod(param);  
        Log.d("zj2595",param.args[0].toString());  
                if(param.args[0].equals("已过期")){  
                    printStackTrace();  
                }
    }  
});
private static void printStackTrace() {  
    Throwable ex = new Throwable();  
    StackTraceElement[] stackElements = ex.getStackTrace();  
    for (int i = 0; i < stackElements.length; i++) {  
        StackTraceElement element = stackElements[i];  
        Log.d("zj2595","at " + element.getClassName() + "." + element.getMethodName() + "(" + element.getFileName() + ":" + element.getLineNumber() + ")");  
    }  
}

点击事件监听

Class clazz = XposedHelpers.findClass("android.view.View", lpparam.classLoader);
XposedBridge.hookAllMethods(clazz, "performClick", new XC_MethodHook() {  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        super.afterHookedMethod(param);  
        Object listenerInfoObject = XposedHelpers.getObjectField(param.thisObject, "mListenerInfo");  
        Object mOnClickListenerObject = XposedHelpers.getObjectField(listenerInfoObject, "mOnClickListener");  
        String callbackType = mOnClickListenerObject.getClass().getName();  
        Log.d("zj2595",callbackType);  
    }  
});

改写布局

在 Activity 初始化后修改 UI 元素（如隐藏图片）：

XposedHelpers.findAndHookMethod("com.zj.wuaipojie.ui.ChallengeSixth", lpparam.classLoader,  
        "onCreate", Bundle.class, new XC_MethodHook() {  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        super.afterHookedMethod(param);  
        View img = (View)XposedHelpers.callMethod(param.thisObject,  
                "findViewById", 0x7f0800de);  
        img.setVisibility(View.GONE);  

    }  
});

修改前	修改后

0x07 Lsposed 免root实现

Lsposed：LSPosed 框架的无 Root 实现方案，通过将 dex 文件与 so 文件插入到目标 APK（安卓应用安装包）中，实现 Xposed API（应用程序编程接口）的集成。
核心原理：重打包目标 APK，将模块代码集成到其中，避免对系统环境的依赖。

0x07 Xposed快速Hook—–SimpleHook

SimpleHook 是 GitHub 用户 littleWhiteDuck 开发的一款 Android 轻量型 Hook 工具，核心定位是 “简单易用”—— 无需复杂配置即可实现常见 Hook 需求，适合对 Hook 操作复杂度要求低的用户；若需复杂功能（如自定义脚本）或更多扩展能力，官方推荐搭配 jshook（复杂功能）、曲境（电脑端浏览器操作）或算法助手（扩展功能）使用。

使用步骤：
- 在 LSPosed 中启用 SimpleHook 模块；
- 选择目标应用，添加 Hook 配置（类名、方法名、参数类型等）；
- 重启应用，配置生效。

工具覆盖多种常见 Hook 场景，部分关键模式及示例如下：

模式类型	功能说明	关键特点
Hook 返回值	修改目标方法的返回结果，支持基本类型（如 boolean、int）、字符串及 null	参数类型留空表示无参，多参数用英文逗号分隔（如 `java.lang.String,int`）
Hook 返回值 +	进阶功能，支持通过 JSON 格式将数据转为目标对象（依赖 Gson）	需填写 “返回值类名”，修改值为 JSON 字符串（如 `{"isHook":false,"level":10000}`）
Hook 参数值	修改目标方法的输入参数，支持部分参数或全部参数修改	未修改的参数留空（如仅改第 2、3 个参数，修改值填 `,啦啦啦,99`）
中断执行	拦截目标方法执行，使其不触发原有逻辑	无需填写修改值，仅需配置类名、方法名及参数类型
特殊方法 Hook	- 构造方法：方法名填写 `<init>`- 所有同名方法：参数类型填 ``- 类内所有方法：方法名填 ``	适配不同场景下的批量或特殊方法 Hook 需求
变量 Hook	- 静态变量：支持 `before/after` 两个 Hook 点（方法执行前后修改）- 实例变量：仅支持在本类方法执行后修改，不可跨类	仅支持基本类型和字符串，需填写 “变量所在类名”“变量名”
记录类模式（3 种）	记录参数值、记录返回值、记录参返（参数 + 返回值）	数组或 List 类型参数 / 返回值会自动转为 JSON 格式，便于查看

该软件还满足自定义hook，具体细节请前往SimpleHook学习。

参考文档

《安卓逆向这档事》七、Sorry，会Hook真的可以为所欲为-Xposed快速上手(上)

《安卓逆向这档事》八、Sorry，会Hook真的可以为所欲为-xposed快速上手(下)

源码编译（2）——Xopsed源码编译详解 Xposed Hook技巧，代{过}{滤}理abstract Xposed callMethod 如何传入接口参数

XPOSED魔改一：获取特征 Lsposed 技术原理探讨 && 基本安装使用

安卓逆向入门四

Sun, 20 Jul 2025 12:02:51 +0800

安卓逆向入门四

关键词：apk签名、apk校验及对抗方法、PM代理、io重定向

学习链接：https://www.52pojie.cn/thread-1731181-1-1.html

0x00 APK签名

校验是开发者在数据传送时采用的一种校正数据的一种方式常见的校验有:签名校验(最常见)、dexcrc校验、apk完整性校验、路径文件校验等

什么是APK签名?

我建议直接去看 Android 官方文档 中关于 APK签名 的安全特性介绍。

APK签名是开发者使用私钥对安卓应用进行数字签名的过程，确保应用的完整性和来源，防止被篡改。只有经过签名的应用才能在安卓设备上安装和运行，签名还帮助系统识别应用的开发者，并确保应用在独立的沙盒环境中安全运行。
Android 目前支持以下四种应用签名方案： v1 方案：基于 JAR 签名。 v2 方案：APK 签名方案 v2（在 Android 7.0 中引入） v3 方案：APK 签名方案 v3（在 Android 9 中引入） v4 方案：APK 签名方案 v4（在 Android 11 中引入）

签名方案	推出版本	校验范围	安全优势	局限性	适用场景
v1（JAR 签名）	Android 1.0	仅校验 APK 内单个文件（META-INF 下签名文件）	兼容所有安卓版本	可篡改未签名文件（如新增文件）	需兼容 Android 6.0 及以下设备
v2	Android 7.0	校验整个 APK（通过 “签名块” 校验 APK 完整性）	更高效（无需解压）、防篡改新增文件	不兼容 Android 6.0 及以下	目标设备为 Android 7.0+
v3	Android 9.0	在 v2 基础上支持 “签名轮换”（更换签名无需卸载旧版）	支持签名更新（如企业应用换证书）	依赖 Android 9.0+	需要签名更新的应用（如企业级 APP）
v4	Android 11.0	生成单独的签名文件（.apksig），支持增量更新校验	优化大文件安装效率（仅校验变更部分）	依赖 Android 11.0+	大型应用（如游戏）的增量更新

v4签名生成的.apksig文件必须配合adb install --incremental使用，常规APK安装不会触发此校验。逆向中较少遇到，主要用于Google Play增量更新。
一次让你搞懂Android应用签名这篇文章讲了签名步骤和原理相关知识，值得一看

APP 的签名检验

系统更多的只是对 APK 做完整性校验，身份校验很容易通过卸载方式来解决，因此许多 APP 为了防止自身被修改和破解，会对自身进行额外的校验，确保没有被修改。

我们一般称此类检查自身是否被修改的保护技术为签名校验，其校验原理几乎也都是基于文件完整性检验与签名身份信息验证。

kill/killProcess-----kill/KillProcess()可以杀死当前应用活动的进程，这一操作将会把所有该进程内的资源（包括线程全部清理掉）.当然，由于ActivityManager时刻监听着进程，一旦发现进程被非正常Kill，它将会试图去重启这个进程。这就是为什么，有时候当我们试图这样去结束掉应用时，发现它又自动重新启动的原因.

system.exit-----杀死了整个进程，这时候活动所占的资源也会被释放。

finish----------仅仅针对Activity，当调用finish()时，只是将活动推向后台，并没有立即释放内存，活动的资源并没有被清理

普通获取签名校验代码：

private boolean SignCheck() {
    String trueSignMD5 = "d0add9987c7c84aeb7198c3ff26ca152";
    String nowSignMD5 = "";
    try {
        // 得到签名的MD5
        PackageInfo packageInfo = getPackageManager().getPackageInfo(getPackageName(),PackageManager.GET_SIGNATURES);
        Signature[] signs = packageInfo.signatures;
        String signBase64 = Base64Util.encodeToString(signs[0].toByteArray());
        nowSignMD5 = MD5Utils.MD5(signBase64);
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
    return trueSignMD5.equals(nowSignMD5);
}

系统将应用的签名信息封装在PackageInfo中，调用 PackageManager 的getPackageInfo(String packageName, int flags)即可获取指定包名的签名信息.

0x01 签名校验对抗

方法一:核心破解插件，不签名安装应用方法二:一键过签名工具，例如MT、NP、ARMPro、CNFIX、Modex的去除签名校验功能方法三:具体分析签名校验逻辑(手撕签名校验) 方法四:io重定向–VA&SVC：ptrace+seccomp SVC的TraceHook沙箱的实现&无痕Hook实现思路方法五:去作者家严刑拷打拿到.jks文件和密码

0x02 手动实现PM代{过}{滤}理

1.什么是PMS

思路源自：Android中Hook 应用签名方法

PackageManagerService（简称PMS），是Android系统核心服务之一，处理包管理相关的工作，常见的比如安装、卸载应用等。

核心原理

安卓应用获取签名的流程：应用调用PackageManager.getPackageInfo() → 系统通过PMS（PackageManagerService）查询签名信息并返回；
PM 代理的本质：通过 Hook 替换PMS的返回结果 —— 当应用查询签名时，返回原始合法签名（而非修改后 APK 的签名），从而绕过校验。

使用条件与限制

环境要求：需要 root 权限（修改系统服务）或通过 Xposed/LSPosed 框架（无需 root，但需模块支持）；
局限性：仅对通过PackageManager获取签名的校验有效，若应用直接读取 APK 文件计算签名（如读取/data/app/xxx.apk的签名），则 PM 代理无效（需结合IO重定向，将应用访问的APK路径（如/data/app/包名/base.apk）重定向到保留原始签名的伪造APK文件（仅包含签名所需文件，如META-INF/）。

2.实现方法以及原理解析

HOOK PMS代码:

package com.zj.hookpms;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import android.content.Context;
import android.content.pm.PackageManager;
import android.util.Log;

public class ServiceManagerWraper {

    public final static String ZJ = "ZJ595";

    public static void hookPMS(Context context, String signed, String appPkgName, int hashCode) {
        try {
            // 获取全局的ActivityThread对象
            Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
            Method currentActivityThreadMethod =
                    activityThreadClass.getDeclaredMethod("currentActivityThread");
            Object currentActivityThread = currentActivityThreadMethod.invoke(null);
            // 获取ActivityThread里面原始的sPackageManager
            Field sPackageManagerField = activityThreadClass.getDeclaredField("sPackageManager");
            sPackageManagerField.setAccessible(true);
            Object sPackageManager = sPackageManagerField.get(currentActivityThread);
            // 准备好代{过}{滤}理对象, 用来替换原始的对象
            Class<?> iPackageManagerInterface = Class.forName("android.content.pm.IPackageManager");
            Object proxy = Proxy.newProxyInstance(
                    iPackageManagerInterface.getClassLoader(),
                    new Class<?>[]{iPackageManagerInterface},
                    new PmsHookBinderInvocationHandler(sPackageManager, signed, appPkgName, 0));
            // 1. 替换掉ActivityThread里面的 sPackageManager 字段
            sPackageManagerField.set(currentActivityThread, proxy);
            // 2. 替换 ApplicationPackageManager里面的 mPM对象
            PackageManager pm = context.getPackageManager();
            Field mPmField = pm.getClass().getDeclaredField("mPM");
            mPmField.setAccessible(true);
            mPmField.set(pm, proxy);
        } catch (Exception e) {
            Log.d(ZJ, "hook pms error:" + Log.getStackTraceString(e));
        }
    }

    public static void hookPMS(Context context) {
        String Sign = "原包的签名信息";
        hookPMS(context, Sign, "com.zj.hookpms", 0);
    }
}

ActivityThread的静态变量sPackageManager ApplicationPackageManager对象里面的mPM变量

0x03 IO重定向

什么是IO重定向？

I/O重定向是指改变程序的标准输入（stdin）、标准输出（stdout）和标准错误输出（stderr）的默认设备，将其与其他设备或文件进行关联。通过I/O重定向，我们可以将程序的输入从键盘转向文件或其他设备，将程序的输出和错误信息输出到文件或其他设备而不是屏幕上。

例：在读A文件的时候指向B文件

平头哥的核心代码 Virtual Engine for Android(Support 12.0 in business version)

IO重定向可以干嘛？

1，可以让文件只读，不可写

2，禁止访问文件

3，路径替换

具体实现：过签名检测(读取原包) 风控对抗(例:一个文件记录App启动的次数) 过Root检测，Xposed检测(文件不可取)

using namespace std;  
string packname;  
string origpath;  
string fakepath;  

int (*orig_open)(const char *pathname, int flags, ...);  
int (*orig_openat)(int,const char *pathname, int flags, ...);  
FILE *(*orig_fopen)(const char *filename, const char *mode);  
static long (*orig_syscall)(long number, ...);  
int (*orig__NR_openat)(int,const char *pathname, int flags, ...);  

void* (*orig_dlopen_CI)(const char *filename, int flag);  
void* (*orig_dlopen_CIV)(const char *filename, int flag, const void *extinfo);  
void* (*orig_dlopen_CIVV)(const char *name, int flags, const void *extinfo, void *caller_addr);  

static inline bool needs_mode(int flags) {  
    return ((flags & O_CREAT) == O_CREAT) || ((flags & O_TMPFILE) == O_TMPFILE);  
}  
bool startsWith(string str, string sub){  
    return str.find(sub)==0;  
}  

bool endsWith(string s,string sub){  
    return s.rfind(sub)==(s.length()-sub.length());  
}  
bool isOrigAPK(string  path){  

    if(path==origpath){  
        return true;  
    }  
    return false;  
}  
//该函数的功能是在打开一个文件时进行拦截，并在满足特定条件时将文件路径替换为另一个路径  

//fake_open 函数有三个参数：  
//pathname：一个字符串，表示要打开的文件的路径。  
//flags：一个整数，表示打开文件的方式，例如只读、只写、读写等。  
//mode（可选参数）：一个整数，表示打开文件时应用的权限模式。  
int fake_open(const char *pathname, int flags, ...) {  
    mode_t mode = 0;  
    if (needs_mode(flags)) {  
        va_list args;  
        va_start(args, flags);  
        mode = static_cast<mode_t>(va_arg(args, int));  
        va_end(args);  
    }  
    //LOGI("open,  path: %s, flags: %d, mode: %d",pathname, flags ,mode);  
    string cpp_path= pathname;  
    if(isOrigAPK(cpp_path)){  
        LOGI("libc_open, redirect: %s, --->: %s",pathname, fakepath.data());  
        return orig_open("/data/user/0/com.zj.wuaipojie/files/base.apk", flags, mode);  
    }  
    return  orig_open(pathname, flags, mode);  

}  

//该函数的功能是在打开一个文件时进行拦截，并在满足特定条件时将文件路径替换为另一个路径  

//fake_openat 函数有四个参数：  
//fd：一个整数，表示要打开的文件的文件描述符。  
//pathname：一个字符串，表示要打开的文件的路径。  
//flags：一个整数，表示打开文件的方式，例如只读、只写、读写等。  
//mode（可选参数）：一个整数，表示打开文件时应用的权限模式。  
//openat 函数的作用类似于 open 函数，但是它使用文件描述符来指定文件路径，而不是使用文件路径本身。这样，就可以在打开文件时使用相对路径，而不必提供完整的文件路径。  
//例如，如果要打开相对于当前目录的文件，可以使用 openat 函数，而不是 open 函数，因为 open 函数只能使用绝对路径。  
//  
int fake_openat(int fd, const char *pathname, int flags, ...) {  
    mode_t mode = 0;  
    if (needs_mode(flags)) {  
        va_list args;  
        va_start(args, flags);  
        mode = static_cast<mode_t>(va_arg(args, int));  
        va_end(args);  
    }  
    LOGI("openat, fd: %d, path: %s, flags: %d, mode: %d",fd ,pathname, flags ,mode);  
    string cpp_path= pathname;  
    if(isOrigAPK(cpp_path)){  
        LOGI("libc_openat, redirect: %s, --->: %s",pathname, fakepath.data());  
        return  orig_openat(fd,fakepath.data(), flags, mode);  
    }  
    return orig_openat(fd,pathname, flags, mode);  

}  
FILE *fake_fopen(const char *filename, const char *mode) {  

    string cpp_path= filename;  
    if(isOrigAPK(cpp_path)){  
        return  orig_fopen(fakepath.data(), mode);  
    }  
    return orig_fopen(filename, mode);  
}  
//该函数的功能是在执行系统调用时进行拦截，并在满足特定条件时修改系统调用的参数。  
//syscall 函数是一个系统调用，是程序访问内核功能的方法之一。使用 syscall 函数可以调用大量的系统调用，它们用于实现操作系统的各种功能，例如打开文件、创建进程、分配内存等。  
//  
static long fake_syscall(long number, ...) {  
    void *arg[7];  
    va_list list;  

    va_start(list, number);  
    for (int i = 0; i < 7; ++i) {  
        arg[i] = va_arg(list, void *);  
    }  
    va_end(list);  
    if (number == __NR_openat){  
        const char *cpp_path = static_cast<const char *>(arg[1]);  
        LOGI("syscall __NR_openat, fd: %d, path: %s, flags: %d, mode: %d",arg[0] ,arg[1], arg[2], arg[3]);  
        if (isOrigAPK(cpp_path)){  
            LOGI("syscall __NR_openat, redirect: %s, --->: %s",arg[1], fakepath.data());  
            return orig_syscall(number,arg[0], fakepath.data() ,arg[2],arg[3]);  
        }  
    }  
    return orig_syscall(number, arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6]);  

}  

//函数的功能是获取当前应用的包名、APK 文件路径以及库文件路径，并将这些信息保存在全局变量中  
//函数调用 GetObjectClass 和 GetMethodID 函数来获取 context 对象的类型以及 getPackageName 方法的 ID。然后，函数调用 CallObjectMethod 函数来调用 getPackageName 方法，获取当前应用的包名。最后，函数使用 GetStringUTFChars 函数将包名转换为 C 字符串，并将包名保存在 packname 全局变量中  
//接着，函数使用 fakepath 全局变量保存了 /data/user/0/<packname>/files/base.apk 这样的路径，其中 <packname> 是当前应用的包名。  
//然后，函数再次调用 GetObjectClass 和 GetMethodID 函数来获取 context 对象的类型以及 getApplicationInfo 方法的 ID。然后，函数调用 CallObjectMethod 函数来调用 getApplicationInfo 方法，获取当前应用的 ApplicationInfo 对象。  
//它先调用 GetObjectClass 函数获取 ApplicationInfo 对象的类型，然后调用 GetFieldID 函数获取 sourceDir 字段的 ID。接着，函数使用 GetObjectField 函数获取 sourceDir 字段的值，并使用 GetStringUTFChars 函数将其转换为 C 字符串。最后，函数将 C 字符串保存在 origpath 全局变量中，表示当前应用的 APK 文件路径。  
//最后，函数使用 GetFieldID 和 GetObjectField 函数获取 nativeLibraryDir 字段的值，并使用 GetStringUTFChars 函数将其转换为 C 字符串。函数最后调用 LOGI 函数打印库文件路径，但是并没有将其保存在全局变量中。  

extern "C" JNIEXPORT void JNICALL  
Java_com_zj_wuaipojie_util_SecurityUtil_hook(JNIEnv *env, jclass clazz, jobject context) {  
    jclass conext_class = env->GetObjectClass(context);  
    jmethodID methodId_pack = env->GetMethodID(conext_class, "getPackageName",  
                                               "()Ljava/lang/String;");  
    auto packname_js = reinterpret_cast<jstring>(env->CallObjectMethod(context, methodId_pack));  
    const char *pn = env->GetStringUTFChars(packname_js, 0);  
    packname = string(pn);  

    env->ReleaseStringUTFChars(packname_js, pn);  
    //LOGI("packname: %s", packname.data());  
    fakepath= "/data/user/0/"+ packname +"/files/base.apk";  

    jclass conext_class2 = env->GetObjectClass(context);  
    jmethodID methodId_pack2 = env->GetMethodID(conext_class2,"getApplicationInfo","()Landroid/content/pm/ApplicationInfo;");  
    jobject application_info = env->CallObjectMethod(context,methodId_pack2);  
    jclass pm_clazz = env->GetObjectClass(application_info);  

    jfieldID package_info_id = env->GetFieldID(pm_clazz,"sourceDir","Ljava/lang/String;");  
    auto sourceDir_js = reinterpret_cast<jstring>(env->GetObjectField(application_info,package_info_id));  
    const char *sourceDir = env->GetStringUTFChars(sourceDir_js, 0);  
    origpath = string(sourceDir);  
    LOGI("sourceDir: %s", sourceDir);  

    jfieldID package_info_id2 = env->GetFieldID(pm_clazz,"nativeLibraryDir","Ljava/lang/String;");  
    auto nativeLibraryDir_js = reinterpret_cast<jstring>(env->GetObjectField(application_info,package_info_id2));  
    const char *nativeLibraryDir = env->GetStringUTFChars(nativeLibraryDir_js, 0);  
    LOGI("nativeLibraryDir: %s", nativeLibraryDir);  
    //LOGI("%s", "Start Hook");  

    //启动hook  
    void *handle = dlopen("libc.so",RTLD_NOW);  
    auto pagesize = sysconf(_SC_PAGE_SIZE);  
    auto addr = ((uintptr_t)dlsym(handle,"open") & (-pagesize));  
    auto addr2 = ((uintptr_t)dlsym(handle,"openat") & (-pagesize));  
    auto addr3 = ((uintptr_t)fopen) & (-pagesize);  
    auto addr4 = ((uintptr_t)syscall) & (-pagesize);  

    //解除部分机型open被保护  
    mprotect((void*)addr, pagesize, PROT_READ | PROT_WRITE | PROT_EXEC);  
    mprotect((void*)addr2, pagesize, PROT_READ | PROT_WRITE | PROT_EXEC);  
    mprotect((void*)addr3, pagesize, PROT_READ | PROT_WRITE | PROT_EXEC);  
    mprotect((void*)addr4, pagesize, PROT_READ | PROT_WRITE | PROT_EXEC);  

    DobbyHook((void *)dlsym(handle,"open"), (void *)fake_open, (void **)&orig_open);  
    DobbyHook((void *)dlsym(handle,"openat"), (void *)fake_openat, (void **)&orig_openat);  
    DobbyHook((void *)fopen, (void *)fake_fopen, (void**)&orig_fopen);  
    DobbyHook((void *)syscall, (void *)fake_syscall, (void **)&orig_syscall);  
}

        sget-object p10, Lcom/zj/wuaipojie/util/ContextUtils;->INSTANCE:Lcom/zj/wuaipojie/util/ContextUtils;  

    invoke-virtual {p10}, Lcom/zj/wuaipojie/util/ContextUtils;->getContext()Landroid/content/Context;  

    move-result-object p10  

    invoke-static {p10}, Lcom/zj/wuaipojie/util/SecurityUtil;->hook(Landroid/content/Context;)V

0x04 其他常见校验

root检测：

反制手段 1.算法助手、对话框取消等插件一键hook 2.分析具体的检测代码 3.利用IO重定向使文件不可读 4.修改Andoird源码，去除常见指纹

fun isDeviceRooted(): Boolean {
    return checkRootMethod1() || checkRootMethod2() || checkRootMethod3()
}

fun checkRootMethod1(): Boolean {
    val buildTags = android.os.Build.TAGS
    return buildTags != null && buildTags.contains("test-keys")
}

fun checkRootMethod2(): Boolean {
    val paths = arrayOf("/system/app/Superuser.apk", "/sbin/su", "/system/bin/su", "/system/xbin/su", "/data/local/xbin/su", "/data/local/bin/su", "/system/sd/xbin/su",
            "/system/bin/failsafe/su", "/data/local/su", "/su/bin/su")
    for (path in paths) {
        if (File(path).exists()) return true
    }
    return false
}

fun checkRootMethod3(): Boolean {
    var process: Process? = null
    return try {
        process = Runtime.getRuntime().exec(arrayOf("/system/xbin/which", "su"))
        val bufferedReader = BufferedReader(InputStreamReader(process.inputStream))
        bufferedReader.readLine() != null
    } catch (t: Throwable) {
        false
    } finally {
        process?.destroy()
    }
}

定义了一个 isDeviceRooted() 函数，该函数调用了三个检测 root 的方法：checkRootMethod1()、checkRootMethod2() 和 checkRootMethod3()。

checkRootMethod1() 方法检查设备的 build tags 是否包含 test-keys。这通常是用于测试的设备，因此如果检测到这个标记，则可以认为设备已被 root。

checkRootMethod2() 方法检查设备是否存在一些特定的文件，这些文件通常被用于执行 root 操作。如果检测到这些文件，则可以认为设备已被 root。

checkRootMethod3() 方法使用 Runtime.exec() 方法来执行 which su 命令，然后检查命令的输出是否不为空。如果输出不为空，则可以认为设备已被 root。

模拟器检测

1
2
3

fun isEmulator(): Boolean { 
        return Build.FINGERPRINT.startsWith("generic") || Build.FINGERPRINT.startsWith("unknown") || Build.MODEL.contains("google_sdk") Build.MODEL.contains("Emulator") || Build.MODEL.contains("Android SDK built for x86") || Build.MANUFACTURER.contains("Genymotion") || Build.HOST.startsWith("Build") || Build.PRODUCT == "google_sdk" 
        }

通过检测系统的 Build 对象来判断当前设备是否为模拟器。具体方法是检测 Build.FINGERPRINT 属性是否包含字符串 "generic"。

模拟器检测对抗

反调试检测

安卓系统自带调试检测函数

fun checkForDebugger() {  
    if (Debug.isDebuggerConnected()) {  
        // 如果调试器已连接，则终止应用程序  
        System.exit(0)  
    }  
}

debuggable属性

 public boolean getAppCanDebug(Context context)//上下文对象为xxActivity.this
{
    boolean isDebug = context.getApplicationInfo() != null &&
            (context.getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
    return isDebug;
}

ptrace检测

int ptrace_protect()//ptrace附加自身线程 会导致此进程TracerPid 变为父进程的TracerPid 即zygote
{
    return ptrace(PTRACE_TRACEME,0,0,0);;//返回-1即为已经被调试
}

每个进程同时刻只能被1个调试进程ptrace ，主动ptrace本进程可以使得其他调试器无法调试

调试进程名检测

int SearchObjProcess()
{
    FILE* pfile=NULL;
    char buf[0x1000]={0};

    pfile=popen("ps","r");
    if(NULL==pfile)
    {
        //LOGA("SearchObjProcess popen打开命令失败!\n");
        return -1;
    }
    // 获取结果
    //LOGA("popen方案:\n");
    while(fgets(buf,sizeof(buf),pfile))
    {

        char* strA=NULL;
        char* strB=NULL;
        char* strC=NULL;
        char* strD=NULL;
        strA=strstr(buf,"android_server");//通过查找匹配子串判断
        strB=strstr(buf,"gdbserver");
        strC=strstr(buf,"gdb");
        strD=strstr(buf,"fuwu");
        if(strA || strB ||strC || strD)
        {
            return 1;
            // 执行到这里，判定为调试状态

        }
    }
    pclose(pfile);
    return 0;
}

[原创]对安卓反调试和校验检测的一些实践与结论

frida检测

一些Frida检测手段

0x05 smali语法—–赋值

1.Int型赋值

.method private static final onCreate$lambda-0(Lcom/zj/wuaipojie/ui/SmaliLearn;Landroid/widget/TextView;Landroid/widget/TextView;Landroid/widget/TextView;Landroid/view/View;)V  
    .registers 9  

    .line 21  
    invoke-virtual {p0}, Lcom/zj/wuaipojie/ui/SmaliLearn;->isVip()I  

    move-result p4  
        //判断vip的值分别对应不用的会员的等级
    if-eqz p4, :cond_35  

    const/4 v0, 0x1  

    if-eq p4, v0, :cond_2d  

    const/4 v0, 0x4  

    if-eq p4, v0, :cond_25  

    const/16 v0, 0x10  

    if-eq p4, v0, :cond_1d  

    const/16 v0, 0x63  

    if-eq p4, v0, :cond_15  

    goto :goto_3c  

    :cond_15  
    const-string p4, "至尊会员"  

    .line 26  
    check-cast p4, Ljava/lang/CharSequence;  

    invoke-virtual {p1, p4}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V  

    goto :goto_3c  

    :cond_1d  
    const-string p4, "超级会员"  

    .line 25  
    check-cast p4, Ljava/lang/CharSequence;  

    invoke-virtual {p1, p4}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V  

    goto :goto_3c  

    :cond_25  
    const-string p4, "大会员"  

    .line 24  
    check-cast p4, Ljava/lang/CharSequence;  

    invoke-virtual {p1, p4}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V  

    goto :goto_3c  

    :cond_2d  
    const-string p4, "会员"  

    .line 23  
    check-cast p4, Ljava/lang/CharSequence;  

    invoke-virtual {p1, p4}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V  

    goto :goto_3c  

    :cond_35  
    const-string p4, "非会员"  

    .line 22  
    check-cast p4, Ljava/lang/CharSequence;  

    invoke-virtual {p1, p4}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V

        .line 28  
        //判断vipEndTime的时间戳是否小于系统时间
    :goto_3c  
    new-instance p1, Ljava/util/Date;  

    invoke-direct {p1}, Ljava/util/Date;-><init>()V  

    invoke-virtual {p1}, Ljava/util/Date;->getTime()J  

    move-result-wide v0  

    .line 29  
    new-instance p1, Ljava/text/SimpleDateFormat;  

    const-string p4, "yyyy-MM-dd"  

    invoke-direct {p1, p4}, Ljava/text/SimpleDateFormat;-><init>(Ljava/lang/String;)V  

    .line 30  
    invoke-virtual {p0}, Lcom/zj/wuaipojie/ui/SmaliLearn;->vipEndTime()J  

    move-result-wide v2  

    cmp-long p4, v2, v0  

    if-gez p4, :cond_5c  

    const-string p1, "已过期"  

    .line 31  
    check-cast p1, Ljava/lang/CharSequence;  

    invoke-virtual {p2, p1}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V  

    goto :goto_6d  

    .line 33  
    :cond_5c  
    invoke-virtual {p0}, Lcom/zj/wuaipojie/ui/SmaliLearn;->vipEndTime()J  

    move-result-wide v0  

    invoke-static {v0, v1}, Ljava/lang/Long;->valueOf(J)Ljava/lang/Long;  

    move-result-object p4  

    invoke-virtual {p1, p4}, Ljava/text/SimpleDateFormat;->format(Ljava/lang/Object;)Ljava/lang/String;  

    move-result-object p1  

    check-cast p1, Ljava/lang/CharSequence;  

    invoke-virtual {p2, p1}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V  

    .line 35  
    :goto_6d  
    iget p0, p0, Lcom/zj/wuaipojie/ui/SmaliLearn;->vip_coin:I  

    if-eqz p0, :cond_74  

    .line 36  
    invoke-static {p0}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;

    move-result-object p0

    check-cast p0, Ljava/lang/CharSequence;

    invoke-virtual {p3, p0}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V

    :cond_74  
    return-void  
.end method

const/4和const/16的区别？

const/4 最大只允许存放4个二进制位(4bit)，
const/16 最大值允许存放16个二进制位(16bit)，第一位(即最高位)默认为符号位。单位换算 1byte=8bit 举例说明下寄存器的取值范围: # 以下数据定义高位默认为符号位
const/4 v0,0x2 # 最大只允许存放半字节数据取值范围为 -8 and 7
const/16 v0 , 0xABCD # 定义一个寄存器变量，最大只允许存放16位数据比如short类型数据取值范围为-32768~32767
const v0 , 0xA# 定义一个寄存器，最大只允许存放32位数据,比如int类型数据将数字10赋值给v0 取值范围-2147483647~2147483647
const/high16 #定义一个寄存器，最大只允许存放高16位数值比如0xFFFF0000末四位补0 存入高四位0XFFFF

2.Long型赋值

const-wide vx, lit32 表示将一个 32 位的常量存储到 vx 与 vx+1 两个寄存器中 —— 即一个 long 类型的数据

.method public final vipEndTime()J  
    .registers 3  

    const-wide v0, 0x1854460ef29L  

    return-wide v0  
.end method

-会员到期时间就是2022年12月24日。那么1854460ef29L 怎么来的呢？也就是（2022年12月24日-1970年1月1日）×365天×24小时×60分钟×60秒×1000毫秒，转换成16进制就大概是那个数了

在线时间戳转换

3.变量赋值(正则)

    iget p0, p0, Lcom/zj/wuaipojie/ui/SmaliLearn;->vip_coin:I  

    if-eqz p0, :cond_74  

    .line 36  
    invoke-static {p0}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;

    move-result-object p0

    check-cast p0, Ljava/lang/CharSequence;

    invoke-virtual {p3, p0}, Landroid/widget/TextView;->setText(Ljava/lang/CharSequence;)V

*. ** 这个表示任意寄存器，什么寄存器都能匹配，所以你正则查找的时候只需把寄存器替换成这个就可以了
(.*) 这里多了个英文小括号，框哪个就是对哪个寄存器赋值。

参考文章：

APK 签名：v1 v2 v3 v4 如何把签名校验做到极致 Android PMS HOOK [实战破解]白描-动态代{过}{滤}理Hook签名校验 [原创]对安卓反调试和校验检测的一些实践与结论新版MT去签及对抗【小白教程】正则匹配的写法多行匹配批量赋值 smali逆向简单实用

逆向之Smali入门学习

安卓逆向入门三

Thu, 26 Jun 2025 01:03:40 +0800

安卓逆向入门三

学习关键词: Jeb、动态调试、Log插桩

学习链接：《安卓逆向这档事》五、1000-7=？&动态调试&Log插桩

JEB学习

环境配置

Java环境配置，我这里不细讲。没有配置过java环境的我建议去看看多个 JDK 版本（Java 8、Java 17、Java 21）下载和切换这篇文章，我的建议是一开始就做好java多版本共存的准备

下载JEB

JEB (Java Editor for Android) 是一款用于安卓应用逆向工程的工具，它可以帮助开发者分析和修改安卓应用的字节码。

jeb推荐jdk-11或jdk-17（我用的是jdk-11）
下载教程可以看这篇文章：JEB动态调试Smali-真机/模拟器（详细，新手必看）
本次学习下载正己提供的jeb安装包，下载好就可以使用，如果需要激活就去看上面的文章

动态调试

熟悉IDA的逆向人应该知道动态调试是什么，这里指的是Android动态调试，

修改方法：

修改debug权限

**方法一:**在AndroidManifest.xml里添加可调试权限

`1`	`android:debuggable="true"`

**方法二：**XappDebug模块hook对应的app

**方法三：**Magisk命令(重启失效)

1.  adb shell #adb进入命令行模式

2.  su #切换至超级用户

3.  magisk resetprop ro.debuggable 1

4.  stop;start; #一定要通过该方式重启

**方法四:**刷入MagiskHide Props Config模块

一般来说，在4选项中如果有ro.debuggable那就直接修改
没有的话就选5

端口转发以及开启adb权限

版本号点击七次开启开发者模式并开启adb调试权限
有时候重新进入模拟器的时候usb调试会取消，需要手动开启

下断点

ctrl+b下断点

debug模式启动

`1`	`adb shell am start -D -n com.zj.wuaipojie/.ui.MainActivity`

adb shell am start -D -n adb shell am start -D -n 包名/类名 am start -n 表示启动一个activity am start -D 表示将应用设置为可调试模式

Jeb附加调试进程

常用快捷键： F6 进入方法 F6 跳过方法 F7 从方法中跳出来 R 运行到光标处

运行到断点

步进

得到参数值：5qKA5q61DAUM

Log插桩

定义：Log 插桩是在反编译 APK 后的 Smali 代码中插入日志输出语句，通过Log.v()等方法将关键变量、函数调用过程打印到系统日志，适用于无法动态调试或需要追踪后台逻辑的场景。

`1`	`invoke-static {对应寄存器}, Lcom/mtools/LogUtils;->v(Ljava/lang/Object;)V`

在应用里随机输入字符串，然后查看日志

安卓逆向入门二

Sun, 01 Jun 2025 01:03:40 +0800

0x00 smali及其语法

smali是Dalvik的寄存器语言，smali代码是dex反编译而来的。

Smali是Dalvik虚拟机和ART运行时的寄存器指令语言，相当于Android平台的汇编语言。当APK被反编译时，DEX文件会转换为Smali代码（.smali文件），它是逆向分析的核心载体。

关键字

名称	注释
.class	类名
.super	父类名，继承的上级类名名称
.source	源名
.field	变量
.method	方法名
.register	寄存器
.end method	方法名的结束
public	公有
protected	半公开，只有同一家人才能用
private	私有，只能自己使用
.parameter	方法参数
.prologue	方法开始
.line xxx	位于第xxx行

数据类型对应

smali类型	java类型	注释
V	void	无返回值
Z	boolean	布尔值类型，返回0或1
B	byte	字节类型，返回字节
S	short	短整数类型，返回数字
C	char	字符类型，返回字符
I	int	整数类型，返回数字
J	long （64位需要2个寄存器存储）	长整数类型，返回数字
F	float	单浮点类型，返回数字
D	double （64位需要2个寄存器存储）	双浮点类型，返回数字
string	String	文本类型，返回字符串
Lxxx/xxx/xxx	object	对象类型，返回对象

常用指令

关键字	注释
const	重写整数属性，真假属性内容，只能是数字类型
const-string	重写字符串内容
const-wide	重写长整数类型，多用于修改到期时间。
return	返回指令
if-eq	全称equal(a=b)，比较寄存器ab内容，相同则跳
if-ne	全称not equal(a!=b)，ab内容不相同则跳
if-eqz	全称equal zero(a=0)，z即是0的标记，a等于0则跳
if-nez	全称not equal zero(a!=0)，a不等于0则跳
if-ge	全称greater equal(a>=b)，a大于或等于则跳
if-le	全称little equal(a<=b)，a小于或等于则跳
goto	强制跳到指定位置
switch	分支跳转，一般会有多个分支线，并根据指令跳转到适当位置
iget	获取寄存器数据

“vip终结者”

定位方法：

搜索弹窗关键字（用jd-gui搜索字符串）、抓取按钮id（本质与前一个方法一样）

（字符串有时候是用unicode显示，搜关键文字搜不到的话可以试试搜对应的unicode）

（此处演示的是抓取按钮id）

修改方法：

修改判断、强制跳转、修改寄存器的值 (这里与反调试中修改标志位或者修改跳转指令类似)

demo代码例子（注释为正己所写）：

//一个私有、静态、不可变的方法   方法名
.method private static final onCreate$lambda-2(Lkotlin/jvm/internal/Ref$IntRef;Lcom/zj/wuaipojie/ui/ChallengeSecond;Landroid/widget/ImageView;Landroid/widget/ImageView;Landroid/widget/ImageView;Landroid/view/View;)Z //(这里面是方法的参数)这里是方法返回值类型，表示布尔值类型，返回假或真
    .registers 7  //寄存器数量

    .line 33  //代码所在的行数
    iget p0, p0, Lkotlin/jvm/internal/Ref$IntRef;->element:I  //读取p0(第一个参数，参考寄存器知识)中element的值赋值给p0

    const/4 p5, 0x1  //p5赋值1

    const/16 v0, 0xa //v0赋值10，在16进制里a表示10

    if-ge p0, v0, :cond_15  //判断p0的值是否大于或等于v0的值(即p0的值是否大于或等于10)，如果大于或等于则跳转到:cond_15

    .line 34  //以下是常见的Toast弹窗代码
    check-cast p1, Landroid/content/Context; //检查Context对象引用

    const-string p0, "请先获取10个硬币哦" //弹窗文本信息，把""里的字符串数据赋值给p0

    check-cast p0, Ljava/lang/CharSequence; //检查CharSequence对象引用

    invoke-static {p1, p0, p5}, Landroid/widget/Toast;->makeText(Landroid/content/Context;Ljava/lang/CharSequence;I)Landroid/widget/Toast; 
    //将弹窗文本、显示时间等信息传给p1

    move-result-object p0  //结果传递给p0

    invoke-virtual {p0}, Landroid/widget/Toast;->show()V  //当看到这个Toast;->show你就应该反应过来这里是弹窗代码

    goto :goto_31  //跳转到:goto_31

    :cond_15 //跳转的一个地址

    invoke-virtual {p1}, Lcom/zj/wuaipojie/ui/ChallengeSecond;->isvip()Z  //判断isvip方法的返回值是否为真(即结果是否为1)

    move-result p0  //结果赋值给p0

    if-eqz p0, :cond_43 //如果结果为0则跳转cond_43地址

    const p0, 0x7f0d0018  //在arsc中的id索引，这个值可以进行查询

    .line 37
    invoke-virtual {p2, p0}, Landroid/widget/ImageView;->setImageResource(I)V //设置图片资源

    const p0, 0x7f0d0008

    .line 38
    invoke-virtual {p3, p0}, Landroid/widget/ImageView;->setImageResource(I)V

    const p0, 0x7f0d000a

    .line 39
    invoke-virtual {p4, p0}, Landroid/widget/ImageView;->setImageResource(I)V

    .line 40
    sget-object p0, Lcom/zj/wuaipojie/util/SPUtils;->INSTANCE:Lcom/zj/wuaipojie/util/SPUtils; 

    check-cast p1, Landroid/content/Context;

    const/4 p2, 0x2 //p2赋值2

    const-string p3, "level" //sp的索引

    invoke-virtual {p0, p1, p3, p2}, Lcom/zj/wuaipojie/util/SPUtils;->saveInt(Landroid/content/Context;Ljava/lang/String;I)V //写入数据

    goto :goto_50 //跳转地址

    :cond_43

    check-cast p1, Landroid/content/Context;

    const-string p0, "\u8bf7\u5148\u5145\u503c\u5927\u4f1a\u5458\u54e6\uff01" //请先充值大会员哦！

    check-cast p0, Ljava/lang/CharSequence;

    invoke-static {p1, p0, p5}, Landroid/widget/Toast;->makeText(Landroid/content/Context;Ljava/lang/CharSequence;I)Landroid/widget/Toast;

    move-result-object p0

    invoke-virtual {p0}, Landroid/widget/Toast;->show()V

    :goto_50
    return p5  //返回p5的值
.end method //方法结束

//判断是否是大会员的方法
.method public final isvip()Z
    .registers 2

    const/4 v0, 0x0 //v0赋值0

    return v0 //返回v0的值

.end method

寄存器机制

命名规则：v0-vN 本地寄存器，p0-pN 参数寄存器

关键特性：

非静态方法中 p0 固定表示this指针

静态方法中 p0 对应第一个参数

64位类型(long/double)占用两个连续寄存器（如v0-v1）

这里可以切换成Smali语言（但是java代码更好看一点）

0x02 activity的切换

组件	描述
Activity(活动)	在应用中的一个Activity可以用来表示一个界面，意思可以理解为“活动”，即一个活动开始，代表 Activity组件启动，活动结束，代表一个Activity的生命周期结束。一个Android应用必须通过Activity来运行和启动，Activity的生命周期交给系统统一管理。
Service(服务)	Service它可以在后台执行长时间运行操作而没有用户界面的应用组件，不依赖任何用户界面，例如后台播放音乐，后台下载文件等。
Broadcast Receiver(广播接收器)	一个用于接收广播信息，并做出对应处理的组件。比如我们常见的系统广播：通知时区改变、电量低、用户改变了语言选项等。
Content Provider(内容提供者)	作为应用程序之间唯一的共享数据的途径，Content Provider主要的功能就是存储并检索数据以及向其他应用程序提供访问数据的接口。Android内置的许多数据都是使用Content Provider形式，供开发者调用的（如视频，音频，图片，通讯录等）

广告拦截实战

启动广告流程： 启动Activity->广告Activity->主页Activity
修改方法：
- 1.修改加载时间
  
  此小节中用到了mt管理器的Activity管理器，可以用于记录广告用到的AdActivity类
  
  然后通过类名搜索可以定位到代码位置
  
  转换成java
  
  阅读java代码，然后可以知道有一个3000毫秒广告显示时间，退回到smali代码中修改为零即可。

2.Acitivity切换定位，修改Intent的Activity类名（直接在AndroidManifest.xml文件中修改）

<!---声明实现应用部分可视化界面的 Activity，必须使用 AndroidManifest 中的 <activity> 元素表示所有 Activity。系统不会识别和运行任何未进行声明的Activity。----->
<activity  
    android:label="@string/app_name"  
    android:name="com.zj.wuaipojie.ui.MainActivity"  
    android:exported="true">  <!--当前Activity是否可以被另一个Application的组件启动：true允许被启动；false不允许被启动-->
    <!---指明这个activity可以以什么样的意图(intent)启动--->
    <intent-filter>  
        <!--表示activity作为一个什么动作启动，android.intent.action.MAIN表示作为主activity启动--->
        <action  
            android:name="android.intent.action.MAIN" />  
        <!--这是action元素的额外类别信息，android.intent.category.LAUNCHER表示这个activity为当前应用程序优先级最高的Activity-->
        <category  
            android:name="android.intent.category.LAUNCHER" />  
    </intent-filter>  
</activity>  
<activity  
    android:name="com.zj.wuaipojie.ui.ChallengeFirst" />
<activity  
    android:name="com.zj.wuaipojie.ui.ChallengeFifth"  
    android:exported="true" />  
<activity  
    android:name="com.zj.wuaipojie.ui.ChallengeFourth"  
    android:exported="true" />  
<activity  
    android:name="com.zj.wuaipojie.ui.ChallengeThird"  
    android:exported="false" />  
<activity  
    android:name="com.zj.wuaipojie.ui.ChallengeSecond"  
    android:exported="false" />  
<activity  
    android:name="com.zj.wuaipojie.ui.AdActivity" />

3.在classes.dex文件中查找并修改

图一为之前的查找内容，图二是类的一个smali路径代码

    switch (position) {  
        case 0:  
            Intent intent = new Intent();  
            intent.setClass(it.getContext(), ChallengeFirst.class);  
            it.getContext().startActivity(intent);  
            return;  
        case 1:  
            Intent intent2 = new Intent();  
            intent2.setClass(it.getContext(), ChallengeSecond.class);  
            it.getContext().startActivity(intent2);  
            return;  
        case 2:  
            Intent intent3 = new Intent();  //new一个Intent，
            intent3.setClass(it.getContext(), AdActivity.class);  //传入要切换的Acitivity的类名
            it.getContext().startActivity(intent3);  //启动对应的Activity
            return;  
        case 3:  
            Intent intent4 = new Intent();  
            intent4.setClass(it.getContext(), ChallengeFourth.class);  
            it.getContext().startActivity(intent4);  
            return; 
        default:  
            return;  
    }

0x03 Activity生命周期

函数名称	描述
onCreate()	一个Activity启动后第一个被调用的函数，常用来在此方法中进行Activity的一些初始化操作。例如创建View，绑定数据，注册监听，加载参数等。
onStart()	当Activity显示在屏幕上时，此方法被调用但此时还无法进行与用户的交互操作。
onResume()	这个方法在onStart()之后调用，也就是在Activity准备好与用户进行交互的时候调用，此时的Activity一定位于Activity栈顶，处于运行状态。
onPause()	这个方法是在系统准备去启动或者恢复另外一个Activity的时候调用，通常在这个方法中执行一些释放资源的方法，以及保存一些关键数据。
onStop()	这个方法是在Activity完全不可见的时候调用的。
onDestroy()	这个方法在Activity销毁之前调用，之后Activity的状态为销毁状态。
onRestart()	当Activity从停止stop状态恢进入start状态时调用状态。

0x04 弹窗定位&堆栈分析

修改方法：

1.修改xml中的versioncode

2.Hook弹窗(推荐算法助手开启弹窗定位)

这里demo中的广告返回键被劫持，只能跟着广告走，就需要hook

3.修改dex弹窗代码

在算法助手里找到最新的日志，找到对应打方法名，然后搜索查找对应->show()代码，删掉或者注释掉就行

4.抓包修改响应体(也可以路由器拦截)

0x05 布局优化

1.开发者助手抓布局

2.MT管理器xml搜索定位

3.修改xml代码

用的软件：开发助手（可以识别到图片信息），通过搜索Veiw id（hex），可以查找到对应的xml文件，注意这里是xml文件不是之前的dex文件里搜索。

此处既可以修改图片显示的长宽，也可以通过加入下面这段代码隐藏（布局隐藏，文字图片都可以隐藏）。

`1`	`android:visibility="gone"`

京麒ctf 2025（复盘中）

Fri, 30 May 2025 23:34:46 +0800

热身题

re1

flag{1c98572d-7f7b-4fbf-8750-4a2986c695ce}

注意到如下代码是关键：

  v29 = *(_WORD *)v16;
  v30 = sub_7FF7D5E81800(v4, 1i64);
  if ( !v30 )
    sub_7FF7D5E9AFA0(1i64, v4);
  v31 = (_BYTE *)v30;
  for ( i = 0i64; i != v4; ++i )
  {
    HIWORD(v33) = (v29 >> 2) ^ (v29 >> 3) ^ (v29 >> 1);
    LOWORD(v33) = v29;
    v29 = v33 >> 1;
    v34 = __ROL1__(v33, 4);
    v35 = (4 * (v34 & 0x33)) | (v34 >> 2) & 0x33;
    v31[i] = *(_BYTE *)(v16 + i) ^ (i + ((2 * (v35 & 0x55)) | (v35 >> 1) & 0x55));
  }
  if ( v4 == 42 && !memcmp(v31, &unk_7FF7D5E9C458, 42ui64) )
  {
    sub_7FF7D5E817E0(v31, 42i64, 1i64);
    v39 = &off_7FF7D5E9C4A0;
    Src = (void *)1;
    v41 = 8i64;
    v42 = 0i64;
    sub_7FF7D5E85750(&v39);
  }
  else
  {
    sub_7FF7D5E817E0(v31, v4, 1i64);
    v39 = (void **)&off_7FF7D5E9C488;
    Src = (void *)1;
    v41 = 8i64;
    v42 = 0i64;
    sub_7FF7D5E85750(&v39);
  }

其实就是对输入做了xor，用的序列也是由输入的前两个字节+下标生成，那么z3就是一个很自然的想法。偷懒用AI写的代码。注意需要限制开头字符是flag才能解出唯一解，或者用cfbb的这个办法获取所有解。

from z3 import *

def rol1_byte(value: int, shift: int) -> int:
    """Rotate left 1 byte (8 bits) with carry-over"""
    shift %= 8
    return ((value << shift) | (value >> (8 - shift))) & 0xFF

def transform_data(input_data: bytes) -> bytearray:
    """
    Replicates the transformation logic from the original code:
    - Processes each byte with a custom bit manipulation algorithm
    - Uses a rolling state (v29) that affects subsequent bytes
    - Applies XOR with transformed index values
    """
    n = len(input_data)
    output = bytearray(n)
    v29 = (input_data[1] << 8) | input_data[0]
    
    for i in range(n):
        # HIWORD/LOWORD simulation (assuming v33 is 32-bit)
        hiword = (v29 >> 2) ^ (v29 >> 3) ^ (v29 >> 1)
        loword = v29
        v33 = (hiword << 16) | (loword & 0xFFFF)
        
        v29 = v33 >> 1
        
        # Bit manipulation steps
        v34 = rol1_byte(v33 & 0xFF, 4)  # __ROL1__(v33, 4)
        v35 = (4 * (v34 & 0x33)) | ((v34 >> 2) & 0x33)
        
        # Final XOR operation
        transformed_index = i + ((2 * (v35 & 0x55)) | ((v35 >> 1) & 0x55))
        output[i] = input_data[i] ^ (transformed_index & 0xFF)
    
    return output

# 目标密文
Buf2 = bytes([
    0x00, 0xA1, 0xFB, 0x53, 0x1C, 0xFA, 0xF0, 0x1B, 0x06, 0x40, 0xD4, 0x8C, 0x16, 0xF4, 0x90, 0x27, 
    0x42, 0xB9, 0x8B, 0x0F, 0x02, 0xD7, 0x31, 0xB7, 0x26, 0x12, 0x06, 0x7E, 0xAE, 0xDF, 0xDA, 0x68, 
    0xAF, 0x35, 0xCC, 0xB7, 0xB0, 0xD0, 0x9A, 0x59, 0x2B, 0x0B
])

# 创建 Z3 求解器
solver = Solver()

# 定义输入变量（每个字节是一个 8 位无符号整数）
input_bytes = [BitVec(f'byte_{i}', 8) for i in range(len(Buf2))]

# 初始化状态变量 v29 (32-bit)
#v29 = BitVecVal(0, 32)
v29 = Concat(input_bytes[1], input_bytes[0])

for i in range(len(Buf2)):
    # HIWORD/LOWORD 计算
    hiword = (v29 >> 2) ^ (v29 >> 3) ^ (v29 >> 1)
    loword = v29
    v33 = Concat(Extract(15, 0, hiword), Extract(15, 0, loword))
    
    # 更新 v29
    v29 = v33 >> 1
    
    # ROL1(v33, 4) - 取最低字节并循环左移4位
    v34_lowbyte = Extract(7, 0, v33)
    v34 = RotateLeft(v34_lowbyte, 4)
    
    # v35 = (4 * (v34 & 0x33)) | ((v34 >> 2) & 0x33)
    # 修正后的计算方式：
    part1 = (v34 & 0x33) << 2
    part2 = (v34 >> 2) & 0x33
    v35 = part1 | part2
    
    # transformed_index = i + ((2 * (v35 & 0x55)) | ((v35 >> 1) & 0x55))
    part_a = (v35 & 0x55) << 1
    part_b = (v35 >> 1) & 0x55
    transformed_index = i + (part_a | part_b)
    
    # 添加约束：input_byte ^ (transformed_index的低8位) == cipher_byte
    solver.add(input_bytes[i] ^ Extract(7, 0, transformed_index) == Buf2[i])

# 检查是否有解
solver.add(input_bytes[0] == ord('f'))
solver.add(input_bytes[1] == ord('l'))
solver.add(input_bytes[2] == ord('a'))
solver.add(input_bytes[3] == ord('g'))

def get_models(s, count = 1):
    result = []
    while len(result) < count and s.check() == sat:
        m = s.model()
        sol = bytes([m[input_bytes[i]].as_long() for i in range(len(Buf2))])
        result.append(sol)
        # Create a new constraint the blocks the current model
        block = []
        for d in m:
            # d is a declaration
            if d.arity() > 0:
                raise Z3Exception("uninterpreted functions are not supported")
            # create a constant from declaration
            c = d()
            if is_array(c) or c.sort().kind() == Z3_UNINTERPRETED_SORT:
                raise Z3Exception("arrays and uninterpreted sorts are not supported")
            block.append(c != m[d])
        s.add(Or(block))
    return result

m = get_models(solver, 1000)
print(m)

补一个c语言脚本

#include <stdio.h>
#include <stdint.h>

int main() {
    unsigned char output[42] = {
        0x00, 0xA1, 0xFB, 0x53, 0x1C, 0xFA, 0xF0, 0x1B, 0x06, 0x40, 0xD4, 0x8C,
        0x16, 0xF4, 0x90, 0x27, 0x42, 0xB9, 0x8B, 0x0F, 0x02, 0xD7, 0x31, 0xB7,
        0x26, 0x12, 0x06, 0x7E, 0xAE, 0xDF, 0xDA, 0x68, 0xAF, 0x35, 0xCC, 0xB7,
        0xB0, 0xD0, 0x9A, 0x59, 0x2B, 0x0B
    };
    unsigned char input[42] = { 0 };

    input[0] = 'f';
    input[1] = 'l';

    uint16_t v29 = (input[1] << 8) | input[0];

    for (int i = 0; i < 42; ++i) {
        uint32_t v33= (((v29 >> 2) ^ (v29 >> 3) ^ (v29 >> 1)) << 16) | v29;
       
        v29 = (v33 >> 1) & 0xFFFF;

        uint8_t v34 = ((v33 & 0xFF) << 4) | ((v33 & 0xFF) >> 4); // 循环左移4位
        uint8_t v35 = (4 * (v34 & 0x33)) | ((v34 >> 2) & 0x33);

        uint8_t combined = (2 * (v35 & 0x55)) | ((v35 >> 1) & 0x55);
        uint8_t index = (i + combined) & 0xFF;
        input[i] = output[i] ^ index;
        

    }
    for (int i = 0; i < 42; ++i) {
        printf("%c", input[i]);
    }
    return 0;
}

re2

flag{cdb0444318e24beb8f374e9181599072}

#include <stdio.h>
#include <stdint.h>
#include <string.h>

int main() {
    uint8_t v8[16] = { 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 };
    uint8_t v9[16] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };

    const char* target = "cge87k?9<>?@=pss393=>;8@:Cp@DAuH";
    uint8_t enc[32];
    memcpy(enc, target, 32);

    uint8_t flag[33];
    for (int i = 0; i < 32; i += 16) {
        // 先减去v9[j]
        for (int j = 0; j < 16; j++) {
            flag[i + j] = enc[i + j] - v9[j];
        }
        // 反转块以实现逆置换
        for (int j = 0; j < 8; j++) {
            int pos1 = i + j;
            int pos2 = i + 15 - j;
            uint8_t temp = flag[pos1];
            flag[pos1] = flag[pos2];
            flag[pos2] = temp;
        }
    }

    flag[32] = '\0';
    printf("flag{%s}\n", flag);

    return 0;
}
//flag{cdb0444318e24beb8f374e9181599072}

很简单的一道题，唯一就是涉及到一定的sse语句

Hook

Fri, 30 May 2025 10:26:28 +0800

hook随记

此文目前为摘录他人

hook（钩子）是一种编程机制，在操作系统、编程里也会用到。

hook的作用是让程序能够在特定事件发生时插入自定义代码，或者对系统行为进行拦截和修改。它是一种软件设计模式，借助预留接口，实现对系统或框架原有流程的扩展与增强。

Java中有一种机制，叫做动态代理（Dynamic Proxy），它可以被视为一种特殊的运行时钩子（Runtime Hook），因为它允许你在不修改原有代码的情况下，拦截并增强对象方法的调用。

在编程中，Hook（钩子）的本质是一种 “程序拦截机制”，它允许你在不修改原始代码的前提下，介入并改变程序的执行流程。这种机制通过注入自定义逻辑到现有系统的特定点来实现增强或修改功能的目的。

以JavaScript为例，源代码

function add(a,b){
    return a + b
}

res = add(1,3)
console.log("结果: " + res)

结果显而易见，是4.

但是，我们想在不改变调用的情况下，在执行add方法时，在其前面打印”add方法执行“，结束时打印”add方法结束“，并让返回的结果+1。

function add(a, b) {
    return a + b;
}

const hook = {
    originalAdd: add // 立即保存引用
};

// 重新定义add函数
add = function(a, b) {
    console.log("add方法调用前");
    let res = hook.originalAdd(a, b);
    console.log("add方法调用后");
    return res + 1;
};

let res = add(1, 3);
console.log("结果: " + res); // 输出5

结果如图：

调用的代码并未变化，但是结果发声改变了。上述的案例就是一个hook的过程。它先将原函数对象的引用（即内存地址）保存起来，然后在新函数中调用原add函数，最后令add指向一个新函数。

安卓逆向学习一

Sun, 25 May 2025 16:15:22 +0800

安卓逆向入门一

0x01 前置

下载migisk

Magisk（俗称面具），是一个ROOT工具。

它提供了多种功能，包括但不限于：

MagiskSU: 提供应用程序的 root 访问权限。
Magisk 模块: 通过安装模块来修改只读分区。
MagiskBoot: 用于解包和重新打包 Android 启动镜像的最完整工具。
Zygisk: 在每个 Android 应用程序的进程中运行代码。

不要去Magisk中文网,这里用的是正己提供的安装包

这里如果下载失败的话，可以去设置里修改下图选项

0x02 apk的文件结构

Apk结构

apk 全称 Android Package，它相当于一个压缩文件，只要在电脑上将apk后缀改为zip即可解压。

文件	注释
assets目录	存放APK的静态资源文件，比如视频，音频，图片等
lib 目录	armeabi-v7a基本通用所有android设备，arm64-v8a只适用于64位的android设备，x86常见用于android模拟器，其目录下的.so文件是c或c++编译的动态链接库文件
META-INF目录	保存应用的签名信息，签名信息可以验证APK文件的完整性，相当于APK的身份证(验证文件是否又被修改)
res目录	res目录存放资源文件，包括图片，字符串等等，APK的脸蛋由他的layout文件设计
AndroidManifest.xml文件	APK的应用清单信息，它描述了应用的名字，版本，权限，引用的库文件等等信息
classes.dex文件	classes.dex是java源码编译后生成的java字节码文件，APK运行的主要逻辑
resources.arsc文件	resources.arsc是编译后的二进制资源文件，它是一个映射表，映射着资源和id，通过R文件中的id就可以找到对应的资源

demo实例中另外出现的kotlin代表这个apk文件大概是有kotlin语言编写，OkHttp 是一个流行的开源 HTTP 客户端库，用于发送和接收网络请求。

Kotlin 是一种在 Java 虚拟机上运行的静态类型编程语言，被称之为 Android 世界的Swift，由 JetBrains 设计开发并开源。

Kotlin 可以编译成Java字节码，也可以编译成 JavaScript，方便在没有 JVM 的设备上运行。

在Google I/O 2017中，Google 宣布 Kotlin 成为 Android 官方开发语言。

0x03 双开及原理

指手机同时运行两个或多个相同的应用
【VirtualAPP 双开系列08】如何实现多开 - UID
通过在宿主容器上面新建一个进程供插件 APK 寄宿，然后通过 hook 一些系统接口欺骗应用—让虚拟化后应用以为自己是正常运行的独立 APP，欺骗系统—让系统认为此虚拟化应用是一个已正常安装在系统的应用。

原理	解释
修改包名	让手机系统认为这是2个APP，这样的话就能生成2个数据存储路径，此时的多开就等于你打开了两个互不干扰的APP
修改Framework	对于有系统修改权限的厂商，可以修改Framework来实现双开的目的，例如：小米自带多开
通过虚拟化技术实现	虚拟Framework层、虚拟文件系统、模拟Android对组件的管理、虚拟应用进程管理等一整套虚拟技术，将APK复制一份到虚拟空间中运行，例如：平行空间
以插件机制运行	利用反射替换，动态代{过}{滤}理，hook了系统的大部分与system—server进程通讯的函数，以此作为“欺上瞒下”的目的，欺骗系统“以为”只有一个apk在运行，瞒过插件让其“认为”自己已经安装。例如：VirtualApp

0x04 汉化APK

1.Arsc汉化
2.xml汉化
3.Dex汉化 (~~教程里的汉化插件需要vip，我这里是手动改的，知道原理就行~~)

教程中用到的主要就是在mt管理器或者np管理器中对文件进行字符串搜索（管理器中设置了自动签名），如果手动的话，可以反编译改源码等 apk安装包快速反编译，多种反编译及失败的解决方案

这是汉化前⬇

这是汉化（手改）后⬇

0x05 初识AndroidManifest.xml

AndroidManifest.xml是Android应用的入口文件，它描述了package中暴露的组件（activities, services, 等等），他们各自的实现类，各种能被处理的数据和启动位置。除了能声明程序中的Activities, ContentProviders, Services, 和Intent Receivers,还能指定permissions和instrumentation（安全控制和测试）。

注：这里文件名不能修改

AndroidManifest.xml 最全详解

AndroidManifest.xml文件主要包含以下几个元素：

元素	功能描述
action	添加一个`action`到`intent filter`
activity	声明 activity组件
activity-alias	声明activity别名
application	声明应用程序
category	添加一个`category`名称到`intent filter`
compatible-screens	定义应用所兼容的每种屏幕配置
data	添加数据定义到`intent filter`
grant-uri-permission	定义应用数据的子集以供父内容提供者有权限可以访问
instrumentation	声明Instrumentation工具类并是您可以监控应用程序的交互系统
intent-filter	定义activity、service或者是broadcast receiver可以响应的意图（intent）类型，
manifest	AndroidManifest.xml文件中的根元素
meta-data	一条额外添加的名称-值对，可以给父组件提供任意的数据。
path-permission	在content provider内定义所需路径和权限特定子集数据
permission	声明一个安全权限，可以用来限制访问特定应用的组件或功能
permission-group	声明一个相关权限的逻辑组名称
permission-tree	声明权限树的基础名称
provider	声明一个内容提供者(content provider)组件
receiver	声明一个广播接收器(broadcast receiver)组件
service	声明一个服务(service)组件
supports-gl-texture	声明一种应用单一支持的GL纹理(texture)压缩格式
supports-screens	声明应用所支持的屏幕尺寸大小以及在启用兼容模式下系统屏幕超出应用所支持的尺寸
uses-configuration	声明应用程序的软硬件需求
uses-feature	声明应用程序需要用到的软、硬件特性。
uses-library	指定应用程序必须引用的共享库
uses-permission	指定了让应用程序正常运行，用户必须授予的系统权限。
uses-permission-sdk-23	指定了应用程序在Android 6.0以上所需的特定权限
uses-sdk	通过API整数值来声明应用程序所兼容的Android平台版

Buuctf刷题记录

Thu, 22 May 2025 21:08:17 +0800

并非是wp，而是做题过程中的一些记录

luck_guy

主函数

①.Case2 和 case3 只是一个打印函数。
②.strcat 是连接字符串函数，所以 case4 是对 s 赋值并将 s 与 f2 进行拼接。
③.case5 是对 f2 进行处理：j 为奇数，f2 减 2；j 为偶数，f2 减 1。
④.Case1 是要得到 flag，首先memset函数先对 s 进行初始化，s 变成了一个空数组，所以之后的 strcat 函数相当于直接把 f1 复制到了 s 里，再之后的 strcat 函数将 s 与 f2 连接相当于 f1 与 f2 连接，最终打印出来的 flag 就是 f1 加上 f2。 s=0x7F666F6067756369LL，按r键将它转换为字符就是“\x7Ffo`guci”，这里要注意是小端序存储！所以要把字符顺序反过来，就是“icug`of\x7F”

#include <iostream>
using namespace std;
int main()
{
    char f2[] = "icug`of\x7F";
 
    for (int j = 0; j < 8; ++j)
    {
        if ( j % 2 == 1 )
            f2[j]-=2;
        else
            f2[j]--;
    }
 
    printf("%s",f2);
 
    return 0;
}

刮开有奖

加密逻辑其实挺清晰的一道题，快速排序+base64编码，快速排序这里不懂的话可以去问ai，不过还是要自己判断，也可以把代码复制下来在vscode中运行一遍看看结果 但是第一次疑惑的地方是加密排序那个数组a1只初始化了两个数，但是它的结束索引却是十。这里学到的知识是：

根据这段初始化，知道这段的地址是连续的。所以实际上是一个长度为11的数组，~~别问我为什么不动调，F9点开后调不了一点~~ 然后就是

对比判断的时候这里用的是地址处的值也就是说是排序后的值

然后要提一嘴的是

具体可以去看这里 WinMain函数（winbase.h） WinMain 函数（Windows图形应用程序入口点）

int __clrcall WinMain(
  [in]           HINSTANCE hInstance,
  [in, optional] HINSTANCE hPrevInstance,
  [in]           LPSTR     lpCmdLine,
  [in]           int       nShowCmd
);

参数： hInstance：当前应用程序实例的句柄。 hPrevInstance：上一个实例的句柄（在现代Windows中始终为NULL）。 lpCmdLine：命令行参数，不包括程序名称。 nShowCmd：控制窗口显示方式的标志。 返回值：程序的退出状态码，通常返回 WM_QUIT 消息的 wParam 参数值。

easyre

脱壳后的主函数分析比较语句，大致猜到v5就是输入的函数，这里的意思是输入字符的ascii值+1后作为索引进行判断

python中的find()函数是找到对应的下标值

U
U9
U9X
U9X_
U9X_1
U9X_1S
U9X_1S_
U9X_1S_W
U9X_1S_W6
U9X_1S_W6@
U9X_1S_W6@T
U9X_1S_W6@T?

[GUET-CTF2019]re

考z3处理

from z3 import *

solver = Solver()

# 使用Int类型而非BitVec，并添加字符范围约束
a1 = [Int(f'a1_{i}') for i in range(32)]

# 添加所有等式约束
solver.add(1629056 * a1[0] == 166163712)
solver.add(6771600 * a1[1] == 731332800)
solver.add(3682944 * a1[2] == 357245568)
solver.add(10431000 * a1[3] == 1074393000)
solver.add(3977328 * a1[4] == 489211344)
solver.add(5138336 * a1[5] == 518971936)
solver.add(7532250 * a1[7] == 406741500)
solver.add(5551632 * a1[8] == 294236496)
solver.add(3409728 * a1[9] == 177305856)
solver.add(13013670 * a1[10] == 650683500)
solver.add(6088797 * a1[11] == 298351053)
solver.add(7884663 * a1[12] == 386348487)
solver.add(8944053 * a1[13] == 438258597)
solver.add(5198490 * a1[14] == 249527520)
solver.add(4544518 * a1[15] == 445362764)
solver.add(3645600 * a1[17] == 174988800)
solver.add(10115280 * a1[16] == 981182160)
solver.add(9667504 * a1[18] == 493042704)
solver.add(5364450 * a1[19] == 257493600)
solver.add(13464540 * a1[20] == 767478780)
solver.add(5488432 * a1[21] == 312840624)
solver.add(14479500 * a1[22] == 1404511500)
solver.add(6451830 * a1[23] == 316139670)
solver.add(6252576 * a1[24] == 619005024)
solver.add(7763364 * a1[25] == 372641472)
solver.add(7327320 * a1[26] == 373693320)
solver.add(8741520 * a1[27] == 498266640)
solver.add(8871876 * a1[28] == 452465676)
solver.add(4086720 * a1[29] == 208422720)
solver.add(9374400 * a1[30] == 515592000)
solver.add(5759124 * a1[31] == 719890500)

# 确保每个字符在0-255范围内（ASCII）
for c in a1:
    solver.add(c >= 0, c <= 255)

if solver.check() == sat:
    model = solver.model()
    flag = ''.join([chr(model[c].as_long()) for c in a1]) # type: ignore
    print("", flag)
else:
    print("无解")
# flag{e65421110ba03099a1c039337}

但是疑惑的是少了一位，最后看别人题解都是爆破出来的（，a1[6]=‘1’, 所以正确的应该是flag{e165421110ba03099a1c039337}

CrackRTF

这道题的考点是rtf文件,主要的逻辑是先输入六个数字拼接@DBApp然后判断hash-sha1编码，这里爆破出的结果是123321，然后是长度为6的字符串，拼接在一起进行MD5编码，由于MD5编码不可逆，我尝试过爆破，生成所有 6 位组合，总数为 95^6 ≈ 735 亿次，遂放弃。

RTF是Rich Text Format的缩写，意即多文本格式。

char __cdecl sub_4014D0(LPCSTR Destination)
{
    LPCVOID lpBuffer; // [esp+50h] [ebp-1Ch]
    DWORD NumberOfBytesWritten; // [esp+58h] [ebp-14h] BYREF
    DWORD nNumberOfBytesToWrite; // [esp+5Ch] [ebp-10h]
    HGLOBAL hResData; // [esp+60h] [ebp-Ch]
    HRSRC hResInfo; // [esp+64h] [ebp-8h]
    HANDLE hFile; // [esp+68h] [ebp-4h]

    hFile = 0;
    hResData = 0;
    nNumberOfBytesToWrite = 0;
    NumberOfBytesWritten = 0;
    hResInfo = FindResourceA(0, (LPCSTR)0x65, "AAA");// FindResourceA 函数用于查找程序资源中的一个资源。
    // 第一个参数为 NULL，表示查找当前进程的资源。
    // 第二个参数为资源标识符，这里是 0x65。
    // 第三个参数为资源类型，这里是 "AAA"。
    if ( !hResInfo )
        return 0;
    nNumberOfBytesToWrite = SizeofResource(0, hResInfo);// SizeofResource 函数用于获取资源的大小。
    // 如果资源大小为 0，表示资源无效。
    hResData = LoadResource(0, hResInfo);         // LoadResource 函数用于加载资源。
    if ( !hResData )
        return 0;
    lpBuffer = LockResource(hResData);            // LockResource 函数用于锁定资源，并返回资源的指针。
    sub_401005(Destination, (int)lpBuffer, nNumberOfBytesToWrite);// 异或
    hFile = CreateFileA("dbapp.rtf", GENERIC_ALL, 0, 0, CREATE_ALWAYS, FILE_READ_ATTRIBUTES, 0);// CreateFileA 函数用于创建或打开一个文件。
    // 文件名为 "dbapp.rtf"。
    // 打开模式为 CREATE_ALWAYS，表示如果文件不存在则创建，如果存在则覆盖。
    // 文件访问权限为 GENERIC_ALL，表示完全访问权限。
    if ( hFile == (HANDLE)-1 )                    // 如果文件创建失败，返回 0。
        return 0;
    if ( !WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, &NumberOfBytesWritten, 0) )
        return 0;
    CloseHandle(hFile);                           // 关闭文件句柄。
    return 1;
}

这里就是我们输入的东西拼接后与“AAA”文件中的读取的前几位异或

从网上找到rtf的示例文件下下来对比发现前几位都是一样的

把前几位截下来，然后进行异或处理就能得到前六位~!3a@0123321,很明显**~!3a@0**为所求。于是在ida中动调，生成rtf文件，打开后得到flag

ezpy.exe

1. 初始侦察 (Initial Reconnaissance)

拿到题目文件 ezpy.exe 后，首先需要确定其文件类型。

查壳/识别: 这是一个 Windows 可执行文件。通常 Python 逆向题目都是由 PyInstaller 或 py2exe 打包的。
特征: 文件图标、字符串信息通常会暴露它是 PyInstaller 打包的。
解包: 使用工具 pyinstxtractor.py 对 ezpy.exe 进行解包。

`1`	`python pyinstxtractor.py ezpy.exe`

解包后得到 ezpy.exe_extracted 文件夹。

2. Python 层分析 (Python Layer Analysis)

在解包后的文件夹中，寻找入口点。通常与 EXE 同名的 .pyc 文件是入口脚本。

目标文件: ezpy.pyc
版本识别: 检查文件头 Magic Number 为 3571，确认为 Python 3.13。

2.1 反编译挑战

尝试使用传统的 uncompyle6 或 decompyle3 失败，原因如下：

版本过新: 这些工具主要支持到 Python 3.8/3.9，无法解析 Python 3.13 的新指令集（如 CACHE, RESUME 等）。
工具报错: 强制运行会抛出 Magic Number 不匹配或 Crash。

2.2 字节码分析方案

针对高版本 Python，我们采用了以下两种有效方案：

方案 A：使用 `xdis` 库的 `pydisasm` (推荐)

如果环境中安装了 xdis (pip install xdis)，可以直接使用 pydisasm 命令，它对多版本 Python 支持极好。

`1`	`pydisasm ezpy.pyc`

方案 B：使用 Python 内置 `dis` 模块 (原生)

利用当前环境的 Python 3.13 解释器，编写脚本手动反汇编。这是最准确的方法。

import marshal, dis
with open("ezpy.pyc", "rb") as f:
    f.seek(16) # 跳过 16 字节文件头
    code = marshal.load(f)
    dis.dis(code)

2.3 逻辑还原

通过分析反汇编输出（关键指令如下）：

IMPORT_NAME (mypy): 导入扩展模块。
LOAD_GLOBAL (input) + CALL: 获取输入。
LOAD_GLOBAL (check) + CALL: 调用 mypy.check()。
POP_JUMP_IF_FALSE: 根据检查结果跳转分支。

还原后的 Python 源码:

try:
    from mypy import check
except ImportError:
    print('Error: Cannot import mypy module')
    exit(1)

def main():
    user_input = input('Please input your flag: ').strip()
    if check(user_input):
        print('Correct!')
    else:
        print('Wrong!')

if __name__ == '__main__':
    main()

结论：核心校验逻辑下沉到了 mypy 模块中。在解包目录中找到了 mypy.cp313-win_amd64.pyd，这是一个 C++ 编写的 Python 扩展（本质是 DLL）。

3. Native 层分析 (C Extension Analysis)

使用 IDA Pro (或通过 MCP 连接) 分析 mypy.cp313-win_amd64.pyd。

3.1 定位关键函数

Python 扩展通常导出一个初始化函数 PyInit_mypy。

找到 PyInit_mypy。
查看其返回的 PyModuleDef 结构体。
在 PyModuleDef 中找到 m_methods (方法表)。
方法表中包含模块导出的函数名和对应的 C 函数地址。
- 发现导出函数 "check" 对应地址 0x36F4D1519 (偏移地址)。

3.2 分析 `check` 函数 (`sub_36F4D1519`)

反编译该函数，逻辑如下：

参数解析: 接收一个字符串参数。
长度检查: 检查输入长度是否为 25。
密钥准备: 代码中硬编码了字符串 "ISCTF2025"。
加密算法: 调用了一个子函数 sub_36F4D149C。
- 分析该子函数，发现典型的 RC4 算法特征（256次循环初始化 S 盒，异或交换）。
- 密钥为 "ISCTF2025"。
比较逻辑:
- 将用户输入经过 RC4 加密后的密文，与全局变量 byte_36F4D4050 处的字节数组进行逐字节比较。

4. 数据提取 (Data Extraction)

我们需要提取用于比较的密文数据。

目标地址: 0x36F4D4050
数据长度: 25 字节 (由输入长度限制推断)。
提取困难: 在动态调试或 MCP 工具受限（无法直接读取内存字节）的情况下，需要静态提取。
静态提取方法:
1. 计算 RVA (相对虚拟地址): 0x36F4D4050 - 基址 0x36F4D0000 = 0x4050。
2. 查看 PE 节表 (Section Table):
  - .rdata 节的虚拟地址 (Virtual Address) 通常包含此范围。
  - 计算文件偏移 (File Offset) = RVA - 节虚拟地址 + 节原始数据偏移 (PointerToRawData)。
3. 编写脚本 (inspect_pe.py) 读取文件并提取这 25 个字节。

提取到的密文 (Hex): 1d d5 38 33 af b5 51 f3 2c 6b 6e fe 41 24 43 d2 71 cf a4 4c e3 9a 9a b5 31

5. 解密 (Decryption)

RC4 是对称加密算法，加密和解密过程相同。

算法: RC4
密钥: ISCTF2025
密文: 上述提取的 25 字节。

编写脚本 (solve_flag.py) 运行解密：

1
2
3

key = b"ISCTF2025"
ciphertext = [...] # 提取的数据
print(rc4(key, ciphertext))

最终 Flag: ISCTF{Y0U_GE7_7HE_PYD!!!}

总结 (Summary)

这是一道典型的 Python + C 扩展逆向题。

入口: PyInstaller 解包。
定位: 发现逻辑下沉到 .pyd (DLL)。
逆向: 识别标准加密算法 (RC4)。
数据: 从二进制文件中提取加密常量。
还原: 编写脚本解密。

梵殇-fanshanng

Hunter 设备指纹与 Hook 检测逆向学习实录

0x00 写在前面

0x01 研究对象与初始现象

0x02 动态分析迭代路线

0x02.1 第一阶段：定位核心采集入口

0x02.2 第二阶段：验证 IFAA/Soter 服务绑定链路

0x02.3 第三阶段：一次失败的全局热点 Hook

0x02.4 第四阶段：回到可控策略

0x02.5 第五阶段：动态注册 JNI 路线验证

0x02.6 第六阶段：静态 JNI 路线突破

0x02.7 第七阶段：NativeEngine 全量映射

0x02.8 第八阶段：核心方法精准追踪

0x03 核心证据（节选）

0x03.1 最终脚本实跑结果

0x04 最终映射表（方法 -> 字段 -> 风险意义）

0x05 关键结论（经日志支持）

0x06 学习总结

1. 逆向分析方法论

2. 结论修正记录（学习过程）

3. 关键技术点总结

4. 避坑指南

5. Frida 逆向基础

6. Android 设备指纹核心维度

7. Native 层逆向关键技巧

0x07 延伸阅读

Hunter Root 检测点分析与绕过

0x00 结论先看

0x01 硬件级检测：TEE & Verified Boot

处理方法

原理分析

0x02 日志嗅探检测：Find Root File In Sniff

问题定位

处理方法

原理分析

0x03 验证结果

0x04 小结

绕过某邦企业壳 Root/Frida 检测

0x00 环境

0x01 查壳与威胁建模

0x02 初步分析

0x03 Hook pthread_create

Hook 思路和原理分析

第一次尝试

0x04 Hook clone

0x05 Hook dlopen

完整脚本 (hook_dlopen.js)

效果验证

0x06 复盘总结

6.1 查壳

6.2 从 pthread_create 到 clone

6.3 动态库加载

6.4 内存修补 (Patching)

大数据安全与隐私保护 (DSPP) 复习笔记

大数据安全与隐私保护复习笔记

第一章 大数据安全的概念

1.1 大数据安全的内涵

1.2大数据的五个 V 特征

1.3 隐私权的起源与定义

1.4 隐私与法律（简史）

本章小结

第二章 基础知识

2.1 密码算法

2.1.1 对称加密 (Symmetric Cryptography)

2.1.2 公钥加密 (Public Key Cryptography)

2.2 消息完整性与 MAC

2.3 网络安全协议

2.4 身份认证

2.5 单点登录（SSO）与密钥分发

2.6 Kerberos 协议

2.7 访问控制

2.8 开放授权（OAuth）

本章小结

第三章 大数据服务架构及其安全

3.1 SOA 架构

3.2 Web Services 技术体系

3.3 Web Services 安全（WS-Security）

3.4 REST

3.5 微服务（Microservices）

3.6 微服务中的身份认证与访问控制

0x03 Hook `pthread_create`

0x04 Hook `clone`

0x05 Hook `dlopen`

完整脚本 (`hook_dlopen.js`)

6.2 从 `pthread_create` 到 `clone`

第一章大数据安全的概念

第二章基础知识

第三章大数据服务架构及其安全

第四章可信执行环境

第五章大数据处理与存储及其安全隐私

第六章大数据共享及其安全隐私

第七章大数据算法及其安全

第八章大数据服务的认证与访问控制

第九章大数据采集及其安全隐私