Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

我需要用frida hook 安卓Cipher的doFinal在doFinal中输出它的iv,key和文本

  1. User

    我需要用frida hook 安卓Cipher的doFinal在doFinal中输出它的iv,key和文本

  2. Assistant

    Frida是一个动态代码插桩工具,它让你能够在运行时注入自己的代码到一个进程中去。下面是一个使用Frida来hook Android应用中的Cipher对象的doFinal方法,并且在该方法中输出它的IV(初始向量),密钥和文本的示例脚本。

    请注意,这仅是一个示例,具体的实现可能会根据你要hook的Android应用和所使用的Cipher模式等因素有所不同。

    首先,需要写一个Frida hook脚本(JavaScript),如下所示:

    Java.perform(function () {
        var Cipher = Java.use("javax.crypto.Cipher");
    
        // Hook doFinal方法
        Cipher.doFinal.overloads.forEach(function (overload) {
            overload.implementation = function () {
                try {
                    // 转换参数为byte数组类型(如果有的话)
                    var dataBytes;
                    if (arguments.length > 0 && arguments[0] instanceof Java.array('byte')) {
                        dataBytes = arguments[0];
                    }
    
                    // 打印IV值
                    if (this.getIV() !== null) {
                        console.log('IV:', byteArrayToHex(this.getIV()));
                    }
    
                    // 打印密钥
                    var keyBytes = this.getAlgorithmParameters().getEncoded();
                    console.log('Key:', byteArrayToHex(keyBytes));
    
                    // 转换并打印原文本
                    if (dataBytes !== undefined) {
                        console.log('Text:', byteArrayToHex(dataBytes));
                    }
                } catch (e) {
                    console.log('Error:', e.message);
                }
    
                // 调用原始方法
                return overload.apply(this, arguments);
            };
        });
    
        function byteArrayToHex(byteArray) {
            var hexStr = '';
            for (var i = 0; i < byteArray.length; i++) {
                var hexByte = ('0' + (byteArray[i] & 0xFF).toString(16)).slice(-2);
                hexStr += hexByte;
            }
            return hexStr;
        }
    });
    

    然后,你需要启动Frida,并附加到你想要hook的Android应用上。这可能需要使用frida命令行工具或者frida-server。

    例如,如果已经安装了Frida并且手机ADB调试已打开,可以使用以下命令来启动Frida并注入脚本:

    frida -U -f com.target.app -l path_to_your_hook_script.js --no-pause
    

    其中com.target.app需要替换为目标安卓应用的包名,path_to_your_hook_script.js是你保存Frida脚本的路径。

    当doFinal方法被调用时,你的脚本会打印出IV值、密钥和文本。

    要确保这个脚本按预期工作,你需要理解相关的API,并且可能需要根据具体使用情况对脚本进行适当的调整。例如,获取密钥的代码段可能需要根据你的Cipher对象的配置进行修改。这个脚本还假设getAlgorithmParameters().getEncoded()能够返回密钥,但这在实践中不总是正确的,这取决于加密算法和密钥存储的具体情况。在某些情况下,你可能需要调整代码来适应不同的密钥获取方式。

  3. User

    没有getAlgorithmParameters

  4. Assistant

    如果Cipher对象没有提供getAlgorithmParameters()方法或者它不返回期望的信息,那么我们需要找到其他方式来获取密钥和IV。通常情况下,密钥(Key)和初始化向量(IV)会在Cipher实例化时被设置。

    如果你知道密钥和IV是如何被设置的(例如使用init方法),那么你可以尝试hook对应的方法来获取这些信息。下面是一个修改后的脚本,它尝试hook init 方法:

    Java.perform(function () {
        var Cipher = Java.use("javax.crypto.Cipher");
        var SecretKeySpec = Java.use("javax.crypto.spec.SecretKeySpec");
        var IvParameterSpec = Java.use("javax.crypto.spec.IvParameterSpec");
    
        // Hook Cipher的init方法
        Cipher.init.overload('int', 'java.security.Key', 'java.security.spec.AlgorithmParameterSpec').implementation = function (opmode, key, params) {
            // 输出密钥(Key)
            if (key && key instanceof SecretKeySpec) {
                console.log('Key:', byteArrayToHex(key.getEncoded()));
            }
    
            // 输出IV
            if (params && params instanceof IvParameterSpec) {
                console.log('IV:', byteArrayToHex(params.getIV()));
            }
    
            // 继续执行init方法
            return this.init.overload('int', 'java.security.Key', 'java.security.spec.AlgorithmParameterSpec').apply(this, arguments);
        };
    
        // Hook doFinal方法
        Cipher.doFinal.overloads.forEach(function (overload) {
            overload.implementation = function () {
                // 处理参数并输出文本(bytes)的十六进制形式
                if (arguments[0]) {
                    console.log('Text:', byteArrayToHex(arguments[0]));
                }
                // 继续执行doFinal方法
                return overload.apply(this, arguments);
            };
        });
    
        // Helper函数:将byte数组转换为十六进制字符串
        function byteArrayToHex(byteArray) {
            var hexStr = '';
            for (var i = 0; i < byteArray.length; i++) {
                var hexByte = ('0' + (byteArray[i] & 0xFF).toString(16)).slice(-2);
                hexStr += hexByte;
            }
            return hexStr;
        }
    });
    

    这个脚本hook了Cipher的init方法,并在这一步时尝试获取和打印出密钥和IV,然后它同样hook了doFinal方法来获取和打印待加密或待解密的数据。

    需要注意的是,因为存在多个init方法的重载,如果在应用中使用了不同的重载方法,你可能需要额外hook其他版本的init方法。

    再次提醒,要让这段脚本正确工作,你需要理解你要hook的安卓应用如何处理密钥和IV,并根据具体情况调整代码。另外,如果你正为了安全性或是隐私保护目的而hook一个应用,请确保你有合法权利这么做。

  5. User

    我想让iv,key,文本在一个地方输出不然无法解决两个线程都new了Cipher导致无法对应的情况

  6. Assistant

    为了确保IV、Key和文本在一个地方输出,并且能够匹配正确的Cipher实例,你可以考虑在同一个hook中捕获和输出这些信息。你可以在每个Cipher实例初始化时捕获并存储相关信息,然后在调用doFinal时返回。

    下面是一个示例脚本,该脚本在同一个Cipher实例被初始化时记录IV和Key,并在执行doFinal时输出所有信息:

    Java.perform(function () {
        var Cipher = Java.use("javax.crypto.Cipher");
        var SecretKeySpec = Java.use("javax.crypto.spec.SecretKeySpec");
        var IvParameterSpec = Java.use("javax.crypto.spec.IvParameterSpec");
    
        // 用于存储每个Cipher实例的信息
        var cipherInfoMap = new WeakMap();
    
        // Hook Cipher的init方法
        Cipher.init.overload('int', 'java.security.Key', 'java.security.spec.AlgorithmParameterSpec').implementation = function (opmode, key, params) {
            var keyStr = key ? byteArrayToHex(key.getEncoded()) : null;
            var ivStr = (params && params instanceof IvParameterSpec) ? byteArrayToHex(params.getIV()) : null;
    
            // 存储密钥和IV
            cipherInfoMap.set(this, {
                key: keyStr,
                iv: ivStr
            });
    
            // 继续执行init方法
            return this.init.overload('int', 'java.security.Key', 'java.security.spec.AlgorithmParameterSpec').apply(this, arguments);
        };
    
        // Hook doFinal方法
        Cipher.doFinal.overloads.forEach(function (overload) {
            overload.implementation = function () {
                var result;
    
                // 捕获执行结果或异常
                try {
                    // 继续执行doFinal方法
                    result = overload.apply(this, arguments);
                } finally {
                    var info = cipherInfoMap.get(this);
                    // 输出IV、Key和文本
                    if (info) {
                        console.log('IV:', info.iv);
                        console.log('Key:', info.key);
                    }
                    // 处理参数并输出文本(bytes)的十六进制形式
                    if (arguments.length && arguments[0]) {
                        console.log('Text:', byteArrayToHex(arguments[0]));
                    }
                    // 输出加密或解密后的结果
                    if (result) {
                        console.log('Result:', byteArrayToHex(result));
                    }
                }
    
                return result;
            };
        });
    
        // Helper函数:将byte数组转换为十六进制字符串
        function byteArrayToHex(byteArray) {
            var hexStr = '';
            for (var i = 0; i < byteArray.length; i++) {
                var hexByte = ('0' + (byteArray[i] & 0xFF).toString(16)).slice(-2);
                hexStr += hexByte;
            }
            return hexStr;
        }
    });
    

    这个脚本使用了WeakMap来关联每个Cipher实例和其对应的IV和Key。这样在调用doFinal时可以确保输出正确的IV、Key和文本。

    请注意,可能需要根据实际的应用或安卓版本做一些适当的调整。例如,如果应用使用了不同的API来初始化Cipher,你可能需要hook其他重载的init方法。如果你不确定如何修改代码来匹配你的特定应用,你可能需要更多地了解该应用的加密流程。

    此外,考虑到多线程情况下的调试,Frida的绑定是线程安全的,所以WeakMap为每个Cipher对象实例维护的信息应该不会发生混淆。

    确保在安全合规的范围内使用这些信息,特别是如果你在处理涉及用户隐私或专有数据的应用时。

  7. User

    运行后只输出了Text

  8. Assistant

    如果只有Text被输出而Key和IV没有输出,这意味着可能没有正确地hook到初始化Key和IV的部分或者这些部分代码没有被执行。可能的情况包括但不限于使用的init方法重载不同,或者密钥和IV以不同的方式设置。

    首先,确保你hook了所有可能的init重载方法,因为开发者可能会使用不同的方法来初始化Cipher实例。这是init重载方法的一个通用列表:

    init(int, Key)
    init(int, Key, AlgorithmParameterSpec)
    init(int, Key, AlgorithmParameters)
    init(int, Key, SecureRandom)
    init(int, Key, AlgorithmParameterSpec, SecureRandom)
    init(int, Key, AlgorithmParameters, SecureRandom)
    

    修改你的Frida脚本来hook所有这些重载方法,再次尝试。这是init方法的一个基本的hook例子:

    Cipher.init.overload('int', 'java.security.Key').implementation = function(opmode, key) {
        // 处理密钥
        performActionsOnKey(key);
        return this.init(opmode, key);
    };
    
    // 其他重载...
    

    同时,我们会将IV和Key的捕获逻辑移到一个函数中,以免代码重复:

    function performActionsOnKeyAndIv(key, iv) {
        var keyStr = null;
        if (key) {
            keyStr = byteArrayToHex(key.getEncoded());
            console.log('Key:', keyStr);
        } else {
            console.log('Key is not provided');
        }
    
        var ivStr = null;
        if (iv) {
            ivStr = byteArrayToHex(iv.getIV());
            console.log('IV:', ivStr);
        } else {
            console.log('IV is not provided');
        }
    
        return { key: keyStr, iv: ivStr };
    }
    

    然后在每个init方法的hook中调用performActionsOnKeyAndIv,将Key和IV捕获并存储在WeakMap中。

    最后,如果你的输出仍然缺失某些信息,可能需要你更深入地确定加密函数如何被调用。你需要检查是否有自定义的加密封装,或是是否有通过JNI调用底层C/C++库函数的用例。这些情况可能需要你采用更为复杂的hook策略。

    此外,请确认是否有全局错误处理逻辑会捕获并隐藏hook中的异常,这可能会导致你无法看到所有的输出。

    如果输出还是不一致或者发生在多个线程的情况下,考虑将IV和Key以及待加密或解密数据与线程ID(Thread.currentThread().getId())相关联,这样就可以在同一个线程内部进行匹配输出。

    请综合以上的指南和可能的情形,针对性地调试你的代码,并确保遵守法律法规和最佳实践。

  9. User

    帮我写个完整的能直接使用的

  10. Assistant

    如果你需要hook Cipher 的 init 和 doFinal 方法,下面是一个可以使用的Frida脚本示例。这个脚本会为每个Cipher实例存储Key和IV,然后在调用doFinal方法时一起输出所有信息:

    Java.perform(function () {
        var Cipher = Java.use("javax.crypto.Cipher");
        var SecretKeySpec = Java.use("javax.crypto.spec.SecretKeySpec");
        var IvParameterSpec = Java.use("javax.crypto.spec.IvParameterSpec");
    
        var cipherInstanceMap = new WeakMap();
    
        function captureCipherInstance(cipher, key, iv) {
            var keyStr = key ? byteArrayToHex(key.getEncoded()) : null;
            var ivStr = iv ? byteArrayToHex(iv.getIV()) : null;
    
            // 存储到WeakMap中
            cipherInstanceMap.set(cipher, {
                key: keyStr,
                iv: ivStr
            });
        }
    
        // Hook init方法的重载
        var initOverloads = Cipher.init.overloads;
        for (var i in initOverloads) {
            var initOverload = initOverloads[i];
            initOverload.implementation = function() {
                if (arguments.length >= 2 && arguments[1] instanceof SecretKeySpec) {
                    // 密钥总是作为第二个参数传递给init方法
                    var key = arguments[1];
                    var iv = null;
                    // 用于检查是使用IvParameterSpec还是AlgorithmParameters
                    if (arguments.length >= 3 && arguments[2] instanceof IvParameterSpec) {
                        iv = arguments[2]; // IV参数(如果存在)
                    }
    
                    captureCipherInstance(this, key, iv);
                }
                return initOverload.apply(this, arguments);
            };
        }
    
        // Hook doFinal方法的重载
        Cipher.doFinal.overloads.forEach(function (overload) {
            overload.implementation = function () {
                var result;
                // 存储doFinal实际运行结果
                try {
                    result = overload.apply(this, arguments);
                } finally {
                    var info = cipherInstanceMap.get(this);
                    if (info) {
                        console.log('Cipher Info - Key:', info.key, 'IV:', info.iv);
                    }
                    if (arguments.length && arguments[0]) {
                        console.log('Text:', byteArrayToHex(arguments[0]));
                    }
                    if (result) {
                        console.log('Result:', byteArrayToHex(result));
                    }
                }
                return result;
            };
        });
    
        // 辅助函数:将byte数组转化为十六进制字符串
        function byteArrayToHex(byteArray) {
            var hexStr = [];
            for (var i = 0; i < byteArray.length; ++i) {
                var byte = ('0' + (byteArray[i] & 0xFF).toString(16)).slice(-2);
                hexStr.push(byte);
            }
            return hexStr.join('');
        }
    });
    

    要使用这个脚本:

    1. 将其保存为一个.js文件,比如hook_cipher.js。
    2. 确保Frida已经被安装在你的设备上,并且你的设备与你的电脑相连(通过USB或网络)。
    3. 使用以下命令来运行这个脚本:
    frida -U -l hook_cipher.js -f your.package.name --no-pause
    

    替换your.package.name为目标应用的包名。

    请注意,根据不同的加密场景,这个脚本可能仍需进一步调整。例如,如果密钥和IV以不同的方式被传递给Cipher实例,你需要根据你的具体情况修改init方法中的参数相关逻辑。另外,脚本目前只打印了输入和输出的十六进制值以及密钥和IV,如果需要其他信息,则需要进一步修改代码以获取。

  11. User

    还是只获取到了text

  12. Assistant

    很抱歉上一个方案没有按预期工作。这可能意味着Cipher实例的密钥和IV不是通过我们hook的init方法来设置的,或者使用了一种不同的方法。有时,密钥和IV可以在Cipher实例创建时就已经预设,或者通过不同的机制分配。

    让我们尝试一个不同的策略: 我们将定义一个辅助函数来打印我们需要的数据,然后尝试hook到Cipher中对应的setter方法。

    下面是一个新的Frida脚本, 它会hook Cipher的各个可能用于设置密钥和IV的方法,以及doFinal方法:

    Java.perform(function () {
        var Cipher = Java.use('javax.crypto.Cipher');
        var SecretKeySpec = Java.use('javax.crypto.spec.SecretKeySpec');
        var IvParameterSpec = Java.use('javax.crypto.spec.IvParameterSpec');
        var AndroidKeyStoreSecretKey = Java.use('android.security.keystore.AndroidKeyStoreSecretKey');
    
        // 定义一个注入到每个Cipher实例的Map,以便存储Key和IV。
        var cipherDataMap = new Map();
    
        // Helper function to convert byte array to hex string.
        function byteArrayToHex(byteArray) {
            var hexStr = '';
            for (var i = 0; i < byteArray.length; i++) {
                var hexByte = ('0' + (byteArray[i] & 0xFF).toString(16)).slice(-2);
                hexStr += hexByte;
            }
            return hexStr;
        }
        
        // Helper function to log cipher data.
        function logCipherData(cipher, key, iv, data, result) {
            console.log('Cipher instance:', cipher);
            console.log('Key:', key !== null ? byteArrayToHex(key) : 'none');
            console.log('IV:', iv !== null ? byteArrayToHex(iv) : 'none');
            console.log('Data:', byteArrayToHex(data));
            console.log('Result:', byteArrayToHex(result));
        }
    
        Cipher.init.overloads.forEach(function (overload) {
            overload.implementation = function (opMode, key, param) {
                // 如果使用了SecretKeySpec或是Key的其他常常用实现。
                if (key instanceof SecretKeySpec) {
                    cipherDataMap.set(this, { key: key.getEncoded(), iv: null });
                }
                // 如果使用了AndroidKeyStoreSecretKey或其他Keystore的密钥实现
                else if (key instanceof AndroidKeyStoreSecretKey) {
                    cipherDataMap.set(this, { key: null, iv: null }); // Android Keystore密钥可能需要特别处理
                }
    
                // 如果使用了IvParameterSpec来设置IV
                if (param instanceof IvParameterSpec) {
                    var cipherData = cipherDataMap.get(this);
                    cipherData.iv = param.getIV();
                }
    
                return this.init.overload('int', 'java.security.Key', 'java.security.spec.AlgorithmParameterSpec').apply(this, arguments);
            };
        });
    
        Cipher.doFinal.overloads.forEach(function(dofinal) {
            dofinal.implementation = function () {
                var result = dofinal.apply(this, arguments);
                var input = arguments[0];
                var cipherData = cipherDataMap.get(this);
                var key = cipherData ? cipherData.key : null;
                var iv = cipherData ? cipherData.iv : null;
    
                // 打印出我们钩取到的数据。
                logCipherData(this, key, iv, input, result);
    
                return result;
            };
        });
    });
    

    请确保用上述脚本替换你的当前Frida脚本,并按照前面的说明进行操作。

    如果仍然没法获取到Key和IV,有可能是因为它们被存储在硬件安全模块(如TEE)中,或者以无法直接访问的方式被使用(例如,通过Android Keystore System)。在这些情况下,密钥可能根本就不会出现在Java层中,或者在创建SecretKeySpec对象时不使用常见的构造方法。

    此脚本假设你的应用使用前面定义过的类,如果你知道应用使用了不同的类来包装Key和IV,你需要相应地修改hook的逻辑。

    再次强调,一定要确保你有权访问和操作这些加密信息,并且使用的是安全和合法的方式。如果你还是无法获取需要的信息,可能需要进一步分析应用的代码,看看是否有特殊的安全机制在起作用。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.