// hookAes函数用于hook目标应用中的AES加密方法
function hookAes(){
    // 获取目标类com.gaomu.fridatest.utils.AES的Java对象
    var AES = Java.use("com.gaomu.fridatest.utils.AES")
    // 重写aesEncrypt方法的实现
    AES.aesEncrypt.implementation = function (mode, plainText, keyHex, ivHex) {
        // 打印传入的参数，便于分析加密过程
        console.log("mode:" + mode);
        console.log("plainText:" + plainText);
        console.log("keyHex:" + keyHex);
        console.log("ivHex:" + ivHex);
        // 调用原始的aesEncrypt方法，获取加密结果
        var res = this.aesEncrypt(mode, plainText, keyHex, ivHex)
        // 打印加密结果
        console.log(res)
        // 返回加密结果
        return res;
    }
}

// main函数作为入口，确保在Java环境准备好后执行hook
function main() {
    Java.perform(function () {
        hookAes()
    })
}

// 立即执行main函数，开始hook
setImmediate(main)
    
//服务端frida启动后，客户端使用frida -UF -l ./hook1.js 进行hook，执行方法后，就可以在控制台打印出参数信息。 

function hookAes(){
    // 获取目标类com.gaomu.fridatest.utils.AES的Java对象
    var AES = Java.use("com.gaomu.fridatest.utils.AES")
    // 重写aesEncrypt方法的实现
    AES.aesEncrypt.overload('java.lang.String','java.lang.String','java.lang.String','java.lang.String').implementation = function (mode, plainText, keyHex, ivHex) {
        // 打印传入的参数，便于分析加密过程
        console.log("tip:" + "use have four args of reload method");
        var res = this.aesEncrypt(mode, plainText, keyHex, ivHex)
        // 打印加密结果
        console.log(res)
        // 返回加密结果
        return res;
    }
}

// 获取getOver方法的所有重载方法的数量
var len = utils.getOver.overloads.length;
// 循环遍历所有重载方法
for (var i=0; i<len; i++) {
    utils.getOver.overloads[i].implementation = function(){
        //获取所有参数并输出
        for (var a = 0; a < arguments.length; a++) {
            console.log(a + '---' + arguments[a])
        }
        
        //调用原始方法
        return this.getOver.apply(this, arguments)
    }
}

// 主动调用md5方法
function initMD5() {
    var MD5 = Java.use("com.gaomu.fridatest.utils.MD5");
    var md5hash = MD5.md5Hash("adminx");
    console.log("md5: " + md5hash);
}

// main函数作为入口，确保在Java环境准备好后执行hook
function main() {
    Java.perform(function () {
        initMD5()
    })
}

// 立即执行main函数，开始hook
setImmediate(main)

//主动调用获取实例对象
function useDesSecurityConstructor() function() {
    const DesSecurity = Java.use("com.dodonew.online.util.DesSecurity");
    //获取参数为两个字符串类型的构造方法
	const ctorOverload = DesSecurity.$overload('java.lang.String', 'java.lang.String');
    //使用构造方法new一个对象
	const ds = ctorOverload.$new(b, c);//获取一个DesSecurity实例对象
}

// 获取class对象
var moneyClass = Java.use("com.gaomu.Money");
// 新建一个实例对象
var money = moneyClass.$new();
// 直接调用其方法
var res = money.getInfo();
// 获取实例中的静态变量值   .value获取
var value = money.falg.value;

function demo(){
    
    Java.choose("com.gaomu.Money", {
       //找到所有为com.gaomu.Money类的对象，每当调用这个对象时都会执行一次onMatch函数
       onMatch: function(obj){
           //obj 即为匹配到的Money对象
           var name = obj.name.value //获取非静态变量 如果字段名和方法名相同时需要在前面加上_
           var num = obj.num.value //获非取静态变量
           console.log(obj.getInfo())
       },
       onComplete: function(){
           console.log("内存中Money操作完毕")
       }
    });
}

// 获取class对象
var money = Java.use("com.gaomu.Money")
// hook构造参数类型为java.lang.String和int的构造方法
money.$init.overload('java.lang.String', 'int').implementation = function(str, num) {
    console.log(str, num)
    // 执行原本逻辑
    this.$init(str, num)
}

var innerClass = Java.use('com.gaomu.Money$InnerClass')

console.log(Java.enumerateLoadedClassesSync().join('\n'));

var utils = Java.use("com.gaomu.Utils");
var methods = utils.class.getDeclaredMethods();
for (var i=0; i<methods.length; i++){
    console.log(methods[i].getName());
}

//获取所有构造方法
var constructors = utils.class.getDeclaredConstructors();
//遍历构造方法
console.log(constructors);
for (var i = 0; i < constructors.length; i++) {
    var constructor = constructors[i];
    console.log(constructor.toString());
    console.log(constructor.getName());
}

//获取所有字段
var fields = money.class.getDeclaredFields();

//hashMap 
//直接打印，如果配置的hashMap键值对是String类型的话，可以输入字符串内容
console.log(hashMap);
//迭代遍历获取键值对
var key = hashMap.keySet();
var it = key.iterator();
while(it.hasNext()){
    var keyStr = it.next();
    var valueStr = hashMap.get(keyStr);
    console.log("key->" + keystr + " | val->" + valSuetr);
}

//修改hashMap中的值
hashMap.put("name", "gaomu");

//hook 请求地址
function hookOkhttpURL() {
    var Builder = Java.use('okhttp3.Request$Builder');
    //url有三种重载方法，分别是java.lang.String/java.net.URL/okhttp3.HttpUrl，大多数请求都是使用的HttpUrl类型参数
    Builder.url.overload('okhttp3.HttpUrl').implementation = function(a) {
        console.log('a: ' + a);
        var res = this.url(a);
        return res;
    }
}

var okHttpClinet = Java.use("okhttp3.OkHttpClient");
OkHttpClient.newCall.overload("okhttp3.Request").implementation = function (request) {
    console.log("HTTP Reqeust -> " + request.url().toString());
    var call = this.newCall(request); //获取新的call对象
    var response = call.execute(); //调用call对象的execute发送请求 并获取响应
    console.log("HTTP Response -> " + response.body().string());
    return call;
}

var okHttpClinet = Java.use("okhttp3.Request$Builder");
//hook Builder类的addHeader方法
Builder["addHeader"].implementation = function(str, str2) {
    console.log("key: " + str);
    console.log("val: " + str2);
    //showStacks()
    var result = this["addHeader"](str, str2);
    return result;
}

function showStacks() {
    Java.perform(function() {
        console.log(Java.use("android.util.Log").getStackTraceString(
        Java.use("java.lang.Throwable").$new()
        ))
    })
}

setImmediate(main)

function main() {
    Java.perform(function () {
        hookHashMap();
    })
}

function hookHashMap() {
    var hashMap = Java.use("java.util.HashMap");
    hashMap.put.implementation = function (a, b){
        console.log("print out ---------->",a,b);
        return this.put(a,b);
    }
}

function hookHashMap() {
    var hashMap = Java.use("java.util.HashMap");
    hashMap.put.implementation = function (a, b){
        if (a == "Encrypt") {
            console.log("print out ---------->",a,b);
            showStacks();
        }
        return this.put(a,b);
    }
}

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

function hookClass() {
    // 方法1：使用同步过滤
    const targetPackage = "com.dodonew.online";
    const loadedClasses = Java.enumerateLoadedClassesSync();

    // 过滤目标包下的类
    const filteredClasses = loadedClasses.filter(className =>
        className.startsWith(targetPackage + ".")
    );

    console.log(`[+] 找到 ${filteredClasses.length} 个类:`);
    console.log(filteredClasses.join('\n'));
}

function hookMethod() {
    var DesSecurity = Java.use("com.dodonew.online.util.DesSecurity");

    // 获取类的 Class 对象
    var clazz = DesSecurity.class;

    // 正确获取所有声明的方法
    var methods = clazz.getDeclaredMethods();
    console.log("\n[+] DesSecurity 类方法列表:");
    for (var i = 0; i < methods.length; i++) {
        // 获取方法名和参数类型
        var method = methods[i];
        var methodName = method.getName();
        var paramTypes = method.getParameterTypes().map(t => t.getSimpleName());
        console.log(`  - ${methodName}(${paramTypes.join(", ")})`);
    }

    // 正确获取所有声明的字段
    var fields = clazz.getDeclaredFields();
    console.log("\n[+] DesSecurity 类字段列表:");
    for (var i = 0; i < fields.length; i++) {
        // 获取字段名和类型
        var field = fields[i];
        var fieldName = field.getName();
        var fieldType = field.getType().getSimpleName();
        console.log(`  - ${fieldType} ${fieldName}`);
    }
}

function hookDesSecurity() {
    var DesSecurity = Java.use("com.dodonew.online.util.DesSecurity");
    DesSecurity.encrypt64.implementation = function (byte){
        showStacks();
        console.log("encrypt64 execute!!!!!");
        return this.encrypt64(byte);
    }
}

function hookEncodeDesMap() {
    try {
            const RequestUtil = Java.use("com.dodonew.online.http.RequestUtil");

            // 获取 encodeDesMap 方法的所有重载
            const encodeDesMapOverloads = RequestUtil.encodeDesMap.overloads;

            console.log("\n===== encodeDesMap 方法重载分析 =====");
            console.log(`[+] 共找到 ${encodeDesMapOverloads.length} 个重载方法`);

            if (encodeDesMapOverloads.length === 0) {
                console.log("[!] 未找到 encodeDesMap 方法，可能是方法名错误或类未加载");
                return;
            }

            // 遍历所有重载
            encodeDesMapOverloads.forEach((overload, index) => {
                console.log(`\n[重载 #${index + 1}]`);

                // 获取参数类型
                const paramTypes = overload.argumentTypes;
                console.log(`  参数数量: ${paramTypes.length}`);

                // 打印每个参数类型
                paramTypes.forEach((paramType, paramIndex) => {
                    try {
                        const className = paramType.className;
                        const simpleName = className.split('.').pop();
                        console.log(`  参数 ${paramIndex + 1}: ${simpleName} (${className})`);
                    } catch (e) {
                        console.log(`  参数 ${paramIndex + 1}: <无法获取类型信息>`);
                    }
                });

                // 获取返回类型
                try {
                    const returnType = overload.returnType.className;
                    const simpleReturnType = returnType.split('.').pop();
                    console.log(`  返回类型: ${simpleReturnType} (${returnType})`);
                } catch (e) {
                    console.log("  返回类型: <未知>");
                }

                // 实际 Hook 该重载
                overload.implementation = function() {
                    console.log(`\n[encodeDesMap 重载 #${index + 1} 被调用]`);

                    // 打印参数值
                    if (arguments.length > 0) {
                        console.log("  调用参数:");
                        for (let i = 0; i < arguments.length; i++) {
                            const arg = arguments[i];

                            // 特殊处理常见类型
                            if (arg === null) {
                                console.log(`    参数 ${i + 1}: null`);
                            } else if (typeof arg === 'object' && arg.getClass) {
                                try {
                                    // 尝试获取对象的类名
                                    const className = arg.getClass().getName();
                                    console.log(`    参数 ${i + 1}: ${className} 对象`);

                                    // 如果是 Map 类型，尝试打印内容
                                    if (className.endsWith('Map')) {
                                        try {
                                            const mapSize = arg.size();
                                            console.log(`      Map 大小: ${mapSize}`);

                                            if (mapSize > 0) {
                                                const entrySet = arg.entrySet();
                                                const iterator = entrySet.iterator();

                                                console.log("      Map 内容:");
                                                while (iterator.hasNext()) {
                                                    const entry = iterator.next();
                                                    const key = entry.getKey();
                                                    const value = entry.getValue();
                                                    console.log(`        ${key} = ${value}`);
                                                }
                                            }
                                        } catch (e) {
                                            console.log("      无法解析 Map 内容");
                                        }
                                    }
                                } catch (e) {
                                    console.log(`    参数 ${i + 1}: 对象 (无法获取类信息)`);
                                }
                            } else {
                                console.log(`    参数 ${i + 1}: ${arg} (${typeof arg})`);
                            }
                        }
                    } else {
                        console.log("  无参数");
                    }

                    // 调用原方法
                    const result = this.encodeDesMap.apply(this, arguments);

                    // 打印返回值
                    if (result !== null && result !== undefined) {
                        console.log("  返回结果:", result.toString());
                    } else {
                        console.log("  返回结果: null");
                    }

                    return result;
                };
            });

            console.log("\n[+] Hook 已设置，等待方法调用...");

        } catch (e) {
            console.error("[!] 分析失败:", e.message);
        }
}

setImmediate(main)

function main() {
    Java.perform(function () {
        hookEncodeDesMap();
        hookHashMap();
    })
}

function hookEncodeDesMap() {
    const RequestUtil = Java.use("com.dodonew.online.http.RequestUtil");
    RequestUtil.encodeDesMap.overload("java.lang.String","java.lang.String","java.lang.String").implementation = function (a,b,c) {
        console.log("a--------->", a);
        console.log("b--------->", b);
        console.log("c--------->", c);
        return this.encodeDesMap(a, b, c);
    }
}


function hookHashMap() {
    var hashMap = Java.use("java.util.HashMap");
    hashMap.put.implementation = function (a, b){
        if (a == "Encrypt") {
            console.log("print out ---------->",a,b);
            //showStacks();
        }
        return this.put(a,b);
    }
}

function hookDesSecurityContructor() {
    const RequestUtil = Java.use("com.dodonew.online.http.RequestUtil");
    //反射获取指定参数类型的方法
    const encodeDesMapMethod =  RequestUtil.encodeDesMap.overload("java.lang.String","java.lang.String","java.lang.String");
   //反射调用RequestUtil类中的encodeDesMapMethod方法。
    var cipher = encodeDesMapMethod.call(RequestUtil, "{\"equtype\":\"ANDROID\",\"loginImei\":\"Androidb40a5c0f41fef63f\",\"sign\":\"C30222B6DF6FF2BCFF34A6E412BE0CA6\",\"timeStamp\":\"1751045128588\",\"userPwd\":\"1314520\",\"username\":\"114614\"}","65102933", "32028092");
    console.log("cipher: ", cipher);
}
//输出cipher:  NIszaqFPos1vd0pFqKlB42Np5itPxaNH//FDsRnlBfgL4lcVxjXii+gDPsXiVF3VBzVAsMjQKraf
//7KdDY8QjXCrDyjbdep0QyDb+fluS62QBfyio5TUMRlhfetK0JJUAEaNIwv7SujX6+4EN/CAunlQe
//cDNagp872sabGkggHRlKAcNuPr0wcSqiY9K9GHk/IrHEw6rClCrfZjYolrq0MXo5I9mSpJA3NEQH
//Rp5KRms=

Java.perform(function () {
    var TextUtils = java.use("android.text,TextUtils");
    TextUtils.isEmpty.implementation = function (a) {
        console.log("TextUtils-->" , aa);
        retrun this.isEmpty(aa);
    }
})

// Hook JSONObject 构造方法
    var JSONObject = Java.use('org.json.JSONObject');
    
    // Hook 所有重载的构造函数
    JSONObject.$init.overloads.forEach(function(overload) {
        overload.implementation = function() {
            try {
                // 打印调用堆栈和参数
                console.log('\n[JSONObject] Constructor called:');
                console.log('Arguments: ' + JSON.stringify(arguments));
                console.log('Stack trace: ' + Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Exception").$new()));
                
                // 调用原始构造函数
                var result = this.$init.apply(this, arguments);
                
                // 打印构造后的JSON内容
                console.log('Created JSON: ' + result.toString(2));
                return result;
            } catch (e) {
                console.error('Error in JSONObject hook: ' + e);
                return this.$init.apply(this, arguments);
            }
        };
    });

    // Hook toString() 方法
    JSONObject.toString.overload().implementation = function() {
        try {
            var original = this.toString();
            console.log('\n[JSONObject.toString()]');
            console.log('Original: ' + original);
            
            // 修改示例：给所有JSON对象添加新字段
            var modified = original.replace(/\}$/, ', "hooked":true}');
            console.log('Modified: ' + modified);
            return modified;
        } catch (e) {
            console.error(e);
            return this.toString();
        }
    };

    // Hook JSONArray 的 put 方法
    var JSONArray = Java.use('org.json.JSONArray');
    JSONArray.put.overload('java.lang.Object').implementation = function(value) {
        console.log('\n[JSONArray.put]');
        console.log('Inserting value: ' + value);
        return this.put(value);
    };
    
    // Hook JSON 解析入口 (示例)
    var JSONTokener = Java.use('org.json.JSONTokener');
    JSONTokener.$init.overload('java.lang.String').implementation = function(jsonStr) {
        console.log('\n[PARSING JSON]');
        console.log('Raw JSON: ' + jsonStr);
        return this.$init(jsonStr);
    };

// hook java md5
function javaMD5() {
    // Hook MessageDigest 的 digest 方法
    const MessageDigest = Java.use('java.security.MessageDigest');
    MessageDigest.digest.overload('[B').implementation = function(input) {

        // 将字节数组转换为 UTF-8 字符串
        const inputString = Java.use('java.lang.String').$new(input, "UTF-8");
        console.log("\nInput: " + inputString);
        console.log("\n=== MD5 Hook Called ===");

        // 原始调用
        const result = this.digest(input);

        // 转换结果为十六进制字符串
        const hex = Array.from(result, byte =>
            ('0' + (byte & 0xFF).toString(16)).slice(-2)).join('');

        console.log("MD5 Result: " + hex);
        console.log("=========================");

        return result;
    }
}

// hookJavaAes
function hookJavaAes() {
    // 首先hookAES加密的明文部分
    const Cipher = Java.use("javax.crypto.Cipher");
    Cipher.doFinal.overload('[B').implementation = function(input) {
        var plainText = Java.use('java.lang.String').$new(input, "UTF-8");
        console.log("\nAES Encrypt plainText: ->>>> ", plainText);
        return this.doFinal(input);
    }

    // 再hook密钥
    const SecretKeySpec = Java.use("javax.crypto.spec.SecretKeySpec");
    SecretKeySpec.$init.overload('[B', 'java.lang.String').implementation = function (keyBytes, alg) {
        var keyHex = bytesToHex(keyBytes);
        console.log("\nAES Encrypt keyHex: ->>>>", keyHex);
        console.log("\nAES Encrypt ALG: ->>>>", alg);
        return this.$init(keyBytes, alg);
    }

    // hook IV
    const IvParameterSpec = Java.use("javax.crypto.spec.IvParameterSpec");
    IvParameterSpec.$init.overload('[B').implementation = function (keyBytes) {
        var ivHex = bytesToHex(keyBytes);
        console.log("\nAES Encrypt ivHex: ->>>>", ivHex);
        return this.$init(keyBytes);
    }
}


// 将hook算法内部参数Byte数组转换为hex字符串
function bytesToHex(bytes) {
    return Array.from(bytes, byte =>
        ('0' + (byte & 0xFF).toString(16)).slice(-2)
    ).join('');
}