A: 0x67452301
B: 0xefcdab89
C: 0x98badcfe
D: 0x10325476
a=A; b=B; c=C; d=D;

A = a + A;
B = b + B;
C = c + C;
D = d + D;

a=((a+F + K[i] + M[g])<<s[i])+ b

if(0 <= i <= 15){
    F1 = F(b, c, d);
    g = i;
}
else if(16 <= i <= 31){
    F2 = G(b, c, d);
    g = ((i * 5) + 1) % 16;
}
else if(32 <= i <= 47){
    F3 = H(b, c, d);
    g = ((i * 3) + 5) % 16;
}
else{
    F4 = I(b, c, d);
    g = (i * 7) % 16;
}

F(X, Y, Z) = (X & Y) | (~X & Z)
G(X, Y, Z) = (X & Z) | (Y & ~Z)
H(X, Y, Z) = X ^ Y ^ Z
I(X, Y, Z) = Y ^ (X | ~Z)

K[] = {0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
       0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
       0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
       0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
       0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
       0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
       0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
       0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
       0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
       0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
       0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
       0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
       0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
       0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
       0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
       0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391}

S[] = {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
       5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20,
       4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
       6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21}

package com.java.hello;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class MD5Example {
    public static void main(String[] args) {
        String data = "Hello, World!";
        byte[] digest = calculateMD5(data.getBytes());
        assert digest != null;
        String md5Hex = bytesToHex(digest);
        System.out.println("MD5 Hash: " + md5Hex);
    }
    public static byte[] calculateMD5(byte[] data) {
        try {
            // 初始化MessageDigest，并指定MD5算法
            MessageDigest md = MessageDigest.getInstance("MD5");
            // 摘要处理
            return md.digest(data);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }
    public static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}

MD5 Hash: 65a8e27d8879283831b664bd8b7f0ad4

package com.java.Reverse;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class SHAexample {
    public static void main(String[] args) {
        String data = "Hello, World!";
        byte[] digest = calculateSHA(data.getBytes());
        assert digest != null;
        String shaHex = bytesToHex(digest);
        System.out.println("SHA Hash: " + shaHex);
    }
    public static byte[] calculateSHA(byte[] data) {
        try {
            // 初始化MessageDigest，并指定SHA算法
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            // 摘要处理
            return md.digest(data);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }
    public static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}

SHA Hash: dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f

package com.java.Reverse;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
public class MACexample {
    public static void main(String[] args) {
        try {
            // 创建Mac对象，指定算法和密钥
            Mac mac = Mac.getInstance("HmacSHA256");
            byte[] keyBytes = "MiYao".getBytes();
            SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "HmacSHA256");
            mac.init(keySpec);
            // 要计算摘要的消息
            String message = "Hello, world!";
            byte[] messageBytes = message.getBytes();
            // 计算消息摘要
            byte[] digest = mac.doFinal(messageBytes);
            // 将摘要转换为十六进制字符串
            StringBuilder hexString = new StringBuilder();
            for (byte b : digest) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            // 打印摘要
            System.out.println("Message Digest: " + hexString.toString());
        } catch (NoSuchAlgorithmException | InvalidKeyException e) {
            e.printStackTrace();
        }
    }
}

Message Digest: 57e61895de001a806d5a22ba0e4ee2011a02c258f00e121165ba855dbf271321

package com.java.Reverse;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
public class DesExample {
    public static String keys;
    public static String values;
    /**
     * DES加密方法
     * @param key DES加密密钥
     * @param value 待加密的字符串
     * @return 加密后的字节数组
     * @throws Exception
     */
    private static byte[] DesEncryption(String key, String value) throws Exception{
        // 实例化DES密钥材料，注意这里只使用key中的前8个字节作为DES密钥的密钥内容
        DESKeySpec desKeySpec = new DESKeySpec(key.getBytes());
            // 实例化秘密密钥工厂
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            // 生成秘密密钥
        SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
            // 实例化Cipher
        Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding"); // 加密算法/加密模式/填充方式
            // 初始化操作：加载密钥进cipher并设置为加密模式；
        // Cipher.ENCRYPT_MODE为加密模式，Cipher.DECRYPT_MODE为解密模式；
        // 实际上Cipher.ENCRYPT_MODE和Cipher.DECRYPT_MODE都是一个常量；
        // 在反编译的时候这里显示1便是加密模式，显示2便是解密模式。
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            // 执行加密操作并返回密文
        return cipher.doFinal(value.getBytes());
    }
        public static void main(String[] args) throws Exception {
        keys = "a12345678";
        values = "12345678";
            // 对values进行DES加密
        byte[] res = DesExample.DesEncryption(keys, values);
        String str = new BASE64Encoder().encode(res);
        System.out.println("加密后的密文：" + str);
            // 实例化DES密钥材料
        DESKeySpec desKeySpec = new DESKeySpec(keys.getBytes());
            // 实例化秘密密钥工厂
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            // 生成秘密密钥
        SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
            // 实例化Cipher
        Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding"); // 加密算法/加密模式/填充方式
            // 初始化操作：加载密钥进cipher并设置为解密模式
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
            // 执行解密操作
        byte[] res2 = cipher.doFinal(new BASE64Decoder().decodeBuffer(str));
            System.out.println("解密后的明文：" + new String(res2));
    }
}

ZEi7hkmMp+Dr8CE3zdeHkg==
12345678

package com.java.Reverse;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.DESedeKeySpec;
public class DESedeExample {
    private static String DESedeDecode(String keys, String values) throws Exception{
        // 实例化DES密钥材料
        DESedeKeySpec deSedeKeySpec = new DESedeKeySpec(keys.getBytes());
        // 实例化秘密密钥工厂
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");
        // 生成秘密密钥
        SecretKey secretKey = secretKeyFactory.generateSecret(deSedeKeySpec);
        // 实例化
        Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding"); // 加密算法/加密模式/填充方式
        // 初始化操作：把密钥加载进cipher并设置为加/解密模式，反编译时这里1表示加密模式，2表示解密模式
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        // 执行操作
        byte[] decode = cipher.doFinal(new BASE64Decoder().decodeBuffer(values));
        return new String(decode);
    }
    public static void main(String[] args) throws Exception{
        String key = "123456781234567812345678";
        String value = "a12345678";
        // 实例化DESede密钥材料
        DESedeKeySpec deSedeKeySpec = new DESedeKeySpec(key.getBytes());
        // 实例化秘密密钥工厂
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");
        // 生成秘密密钥
        SecretKey secretKey = secretKeyFactory.generateSecret(deSedeKeySpec);
        // 实例化
        Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding"); // 加密算法/加密模式/填充方式
        // 初始化操作：把密钥加载进cipher并设置为加/解密模式，反编译时这里1表示加密模式，2表示解密模式
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        // 执行操作
        byte[] res = cipher.doFinal(value.getBytes());
        String str = new BASE64Encoder().encode(res);
        System.out.println("加密后的内容为：" + str);
        String decode = DESedeDecode(key, str);
        System.out.println("解密后的内容为：" + decode);
    }
}

package com.java.Reverse;
import sun.misc.BASE64Decoder;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Base64;
public class AESexample {
    /**
     * 使用AES算法对数据进行加密
     *
     * @param data 要加密的数据
     * @param key  加密密钥
     * @param iv   初始化向量
     * @return 加密后的数据
     * @throws Exception 加密过程中的异常
     */
    public static String encrypt(String data, String key, String iv) throws Exception {
        // 创建AES加密算法的密钥规范对象
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), "AES");
        // 创建算法参数规范对象，用于指定初始化向量
        AlgorithmParameterSpec niv = new IvParameterSpec(iv.getBytes());
        // 创建AES加密算法的密码器
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); // 加密算法/加密模式/填充方式
        // 初始化密码器为加密模式，指定密钥和初始化向量
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, niv);
        // 加密数据
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());
        // 对加密后的数据进行Base64编码
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }
    public static String decrypt(String data, String key, String iv) throws Exception {
        // 创建AES解密算法的密钥规范对象
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), "AES");
        // 创建算法参数规范对象，用于指定初始化向量
        AlgorithmParameterSpec niv = new IvParameterSpec(iv.getBytes());
        // 创建AES解密算法的密码器
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); // 加密算法/加密模式/填充方式
        // 初始化密码器为解密模式，指定密钥和初始化向量
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, niv);
        // 对加密后的数据进行Base64解码
        byte[] decode = Base64.getDecoder().decode(data);
        // 解密数据
        byte[] decryptedBytes = cipher.doFinal(decode);
        // 将解密后的数据转换为字符串
        return new String(decryptedBytes);
    }
    public static void main(String[] args) throws Exception {
        String data = "a12345678";
        String key = "1234567890abcdef";
        String iv = "1234567890abcdef";
        String encryptedData = encrypt(data, key, iv);
        System.out.println("Encrypted Data: " + encryptedData);
        String decode = decrypt(encryptedData, key, iv);
        System.out.println("Decode Data: " + decode);
    }
}

Encrypted Data: 0l99zkQGHvlWysaJwl5naA==
Decode Data: a12345678

package com.java.Reverse;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
public class RsaBase {
    public static BASE64Encoder base64Encoder;
    public static BASE64Decoder base64Decoder;
    public static String pub_str = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQD1BT9h2x0ate1h3686kXeivygS\n" +
            "0/RrYQcy1PqtFnhwrGq6yyP6Av8gtzKgQzilIwwU2fRu0ugvGYfB5BwYNJwAMX4i\n" +
            "TAcvVoOmm2HNDGaOlrEMkqgIfS77546wfwtIk1CUx6Euu+9FV/Y3gryssrhYoarH\n" +
            "Vu3IooiqfxRNws7a+QIDAQAB"; // 公钥
    public static String pri_str = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAPUFP2HbHRq17WHf\n" +
            "rzqRd6K/KBLT9GthBzLU+q0WeHCsarrLI/oC/yC3MqBDOKUjDBTZ9G7S6C8Zh8Hk\n" +
            "HBg0nAAxfiJMBy9Wg6abYc0MZo6WsQySqAh9LvvnjrB/C0iTUJTHoS6770VX9jeC\n" +
            "vKyyuFihqsdW7ciiiKp/FE3Cztr5AgMBAAECgYALnqgW1/FVZvNPBPCmcmeeDDq2\n" +
            "Sd75iKxyuK76rmofzc1x9lhKbwHyZz27Y/S3wCW+h2eUKeRg93D8vPioHTaYo/6H\n" +
            "AO3U5iDchbwIj/kvnLXIXwJWTCmpI+sadqrERbSneYgIKhvIX+91GRoCgCLoOH6M\n" +
            "eihxg1skYPREtf1yUQJBAP2Pfj9LYHt7/04YJygnY6z1WEpOaTQkI4JK5Wjz+F7h\n" +
            "IpIenEbxg2oz1vSkcwdjezEPPD8B3k7z8cuNAEF1UecCQQD3YLiFlMecSQALrUn3\n" +
            "3v7v4Nh1mB1EbuXGHA94gICZLXRV1sb/C2QNZwc41bRiu00uJ9GK1OEeJwdv7vML\n" +
            "OJAfAkA4xfJMlcIKpB7sC3hpAzjMNzsHmDryE81nlQF82HOaOuqUsQno0JbOJsFQ\n" +
            "kam308x3laO1r+No5jITk4SlI3GtAkEAoH1ZeSB7GAOsSecU9ADyeIHxLOmRI1Kn\n" +
            "M44E43LK+5WnwgDjfZfQQ3myD8dljiBiBC3FHkLaAgvkIVRuzbrWlQI/P2xpYRx4\n" +
            "/R4w/45yn47DZ4+GJ8qdN5f6j1jjB/0sIMTjx7M5Xm7HucgYQaZ6pbijnQWad0oD\n" +
            "M3XeUL3VPVIt"; // 私钥
    static {
        base64Encoder = new BASE64Encoder();
        base64Decoder = new BASE64Decoder();
    }
    // 从Base64编码的字符串中获取公钥
    public static PublicKey getPublicKey(String pub_key) throws Exception {
        // Base64解码，得到真实的字节数据
        byte[] new_key = base64Decoder.decodeBuffer(pub_key);
        // 创建X509EncodedKeySpec对象，使用字节数据
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(new_key);
        // 获取RSA密钥工厂的实例
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        // 生成用于加密的公钥
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        return publicKey;
    }
    // 从Base64编码的字符串中获取私钥
    public static PrivateKey getPrivateKey(String pri_key) throws Exception {
        // Base64解码，得到真实的字节数据
        byte[] new_key = base64Decoder.decodeBuffer(pri_key);
        // 创建PKCS8EncodedKeySpec对象，使用字节数据
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(new_key);
        // 获取RSA密钥工厂的实例
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        // 生成用于加密的私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        return privateKey;
    }
    // 加密方法，使用公钥加密字节数组
    public static byte[] encrypt(byte[] encrypt_str) throws Exception {
        PublicKey publicKey = getPublicKey(pub_str);
        // 获取Cipher实例
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); // 加密算法/加密模式/填充方式
        // 初始化操作：将密钥加载到Cipher中，并设置为加密模式
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        // 执行加密操作
        byte[] example = cipher.doFinal(encrypt_str);
        return example;
    }
    // 解密方法，使用私钥解密字节数组
    public static byte[] decrypt(byte[] decrypt_str) throws Exception {
        PrivateKey privateKey = getPrivateKey(pri_str);
        // 获取Cipher实例
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); // 加密算法/加密模式/填充方式
        // 初始化操作：将密钥加载到Cipher中，并设置为解密模式
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        // 执行解密操作
        byte[] decode = cipher.doFinal(decrypt_str);
        return decode;
    }
    // 将字节数组转换为十六进制字符串
    public static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
    public static void main(String[] args) throws Exception {
        String str_base64 = "0123456789";
        byte[] ec_cipher = encrypt(str_base64.getBytes());
        System.out.println("明文：" + str_base64);
        System.out.println("密文：" + bytesToHex(ec_cipher));
        byte[] deByteStr = decrypt(ec_cipher);
        String deString = new String(deByteStr);
        System.out.println("解密结果：" + deString);
    }
}

package com.java.Reverse;

import sun.misc.BASE64Decoder;  
import sun.misc.BASE64Encoder;  
import javax.crypto.Cipher;  
import java.security.KeyFactory;  
import java.security.PrivateKey;  
import java.security.PublicKey;  
import java.security.spec.PKCS8EncodedKeySpec;  
import java.security.spec.X509EncodedKeySpec;

public class RsaBase {  
    public static BASE64Encoder base64Encoder;  
    public static BASE64Decoder base64Decoder;  
    public static String pub_str = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB...";  
    public static String pri_str = "MIICdQIBADANBgkqhkiG9w0BAQEFA...";

static {  
    base64Encoder = new BASE64Encoder();  
    base64Decoder = new BASE64Decoder();  
}

public static PublicKey getPublicKey(String pub_key) throws Exception {  
    ...  
}  
public static PrivateKey getPrivateKey(String pri_key) throws Exception {  
    ...  
}

public static byte[] encrypt(byte[] encrypt_str) throws Exception {  
    ...  
}  
public static byte[] decrypt(byte[] decrypt_str) throws Exception {  
    ...  
}

public static String bytesToHex(byte[] bytes) {  
    ...  
}

public static void main(String[] args) throws Exception {  
    String str_base64 = "0123456789";  
    byte[] ec_cipher = encrypt(str_base64.getBytes());  
    System.out.println("明文：" + str_base64);  
    System.out.println("密文：" + bytesToHex(ec_cipher));  
    byte[] deByteStr = decrypt(ec_cipher);  
    String deString = new String(deByteStr);  
    System.out.println("解密结果：" + deString);  
}

package com.java.Reverse;
/*
 RsaHex类演示了RSA加密解密的过程，包括密钥对生成、加密、解密等操作。*/
import javax.crypto.Cipher; import java.math.BigInteger; import java.security.*; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; import java.security.spec.RSAPrivateKeySpec; import java.security.spec.RSAPublicKeySpec;
public class RsaHex {
    // 定义公钥和私钥的参数
    public static BigInteger publicN;
    public static BigInteger publicE;
    public static BigInteger privateN;
    public static BigInteger privateD;
    /**
     * 加密方法，使用公钥加密字节数组
     * @param encrypt_str 需要加密的字符串
     * @return 加密后的字节数组
     * @throws Exception 加密过程中可能出现异常
     */
    public static byte[] encrypt(String encrypt_str) throws Exception {
        // 创建公钥对象
        PublicKey publicKey = createPublicKey(publicN, publicE);
        // 获取Cipher实例，指定加密算法、加密模式、填充方式
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        // 初始化操作：将密钥加载到Cipher中，并设置为加密模式
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        // 执行加密操作
        byte[] example = cipher.doFinal(encrypt_str.getBytes());
        return example;
    }
    /**
     * 解密方法，使用私钥解密字节数组
     * @param decrypt_str 需要解密的字节数组
     * @return 解密后的字节数组
     * @throws Exception 解密过程中可能出现异常
     */
    public static byte[] decrypt(byte[] decrypt_str) throws Exception {
        // 创建私钥对象
        PrivateKey privateKey = createPrivateKey(privateN, privateD);
        // 获取Cipher实例，指定加密算法、加密模式、填充方式
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        // 初始化操作：将密钥加载到Cipher中，并设置为解密模式
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        // 执行解密操作
        byte[] decode = cipher.doFinal(decrypt_str);
        return decode;
    }
    /**
     * 创建公钥对象
     * @param bigIntegerN 公钥参数N
     * @param bigIntegerE 公钥参数E
     * @return 公钥对象
     * @throws Exception 创建过程中可能出现异常
     */
    public static PublicKey createPublicKey(BigInteger bigIntegerN, BigInteger bigIntegerE) throws Exception {
        // 创建RSAPublicKeySpec对象，指定公钥参数N和E
        RSAPublicKeySpec spec = new RSAPublicKeySpec(bigIntegerN, bigIntegerE);
        // 创建KeyFactory对象，指定算法为RSA
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        // 生成公钥对象
        return keyFactory.generatePublic(spec);
    }
    /**
     * 创建私钥对象
     * @param bigIntegerN 私钥参数N
     * @param bigIntegerD 私钥参数D
     * @return 私钥对象
     * @throws Exception 创建过程中可能出现异常
     */
    public static PrivateKey createPrivateKey(BigInteger bigIntegerN, BigInteger bigIntegerD) throws Exception {
        // 创建RSAPrivateKeySpec对象，指定私钥参数N和D
        RSAPrivateKeySpec spec = new RSAPrivateKeySpec(bigIntegerN, bigIntegerD);
        // 创建KeyFactory对象，指定算法为RSA
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        // 生成私钥对象
        return keyFactory.generatePrivate(spec);
    }
    /**
     * 将字节数组转换为十六进制字符串
     * @param bytes 需要转换的字节数组
     * @return 转换后的十六进制字符串
     */
    public static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
    public static void rsaKeyGenerator(int byteSize, String strValues) throws Exception {
        // 选择算法为RSA
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        // 设置密钥长度位数
        keyPairGenerator.initialize(byteSize);
        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 获取公钥和私钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        // 打印公钥和私钥的参数
        publicN = publicKey.getModulus();
        publicE = publicKey.getPublicExponent();
        privateN = privateKey.getModulus();
        privateD = privateKey.getPrivateExponent();
        System.out.println("公钥N：" + publicN);
        System.out.println("公钥E：" + publicE);
        System.out.println("私钥N：" + privateN);
        System.out.println("私钥D：" + privateD);
        byte[] encrypt_str = encrypt(strValues);
        System.out.println("明文：" + strValues);
        System.out.println("加密后：" + bytesToHex(encrypt_str));
        byte[] decrypt_base = decrypt(encrypt_str);
        String decrypt_str = new String(decrypt_base);
        System.out.println("解密后：" + decrypt_str);
    }
    public static void main(String[] args) throws Exception{
        String str_base64 = "0123456789";
        rsaKeyGenerator(2048, str_base64);
    }
}

package com.java.Reverse;  
/*  
 RsaHex类演示了RSA加密解密的过程，包括密钥对生成、加密、解密等操作。
 */  
import javax.crypto.Cipher;   
import java.math.BigInteger;   
import java.security.*;   
import java.security.interfaces.RSAPrivateKey;   
import java.security.interfaces.RSAPublicKey;   
import java.security.spec.RSAPrivateKeySpec;   
import java.security.spec.RSAPublicKeySpec;

public static BigInteger publicN;  
public static BigInteger publicE;  
public static BigInteger privateN;  
public static BigInteger privateD;

public static byte[] encrypt(String encrypt_str) throws Exception {  
    PublicKey publicKey = createPublicKey(publicN, publicE);  
    Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");  
    cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
    byte[] example = cipher.doFinal(encrypt_str.getBytes());  
        return example;  
}

public static byte[] decrypt(byte[] decrypt_str) throws Exception {  
    PrivateKey privateKey = createPrivateKey(privateN, privateD);  
    Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");  
    cipher.init(Cipher.DECRYPT_MODE, privateKey);  
    byte[] decode = cipher.doFinal(decrypt_str);  
        return decode;  
}

public static PublicKey createPublicKey(BigInteger bigIntegerN, BigInteger bigIntegerE) throws Exception {  
    RSAPublicKeySpec spec = new RSAPublicKeySpec(bigIntegerN, bigIntegerE);  
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
        return keyFactory.generatePublic(spec);  
}  
public static PrivateKey createPrivateKey(BigInteger bigIntegerN, BigInteger bigIntegerD) throws Exception {  
    RSAPrivateKeySpec spec = new RSAPrivateKeySpec(bigIntegerN, bigIntegerD);  
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
        return keyFactory.generatePrivate(spec);  
}

public static String bytesToHex(byte[] bytes) {  
    StringBuilder sb = new StringBuilder();  
    for (byte b : bytes) {  
        sb.append(String.format("%02x", b));  
    }  
    return sb.toString();  
}

public static void rsaKeyGenerator(int byteSize, String strValues) throws Exception {  
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");  
    keyPairGenerator.initialize(byteSize);  
    KeyPair keyPair = keyPairGenerator.generateKeyPair();  
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
    publicN = publicKey.getModulus();  
    publicE = publicKey.getPublicExponent();  
    privateN = privateKey.getModulus();  
    privateD = privateKey.getPrivateExponent();  
        System.out.println("公钥N：" + publicN);  
    System.out.println("公钥E：" + publicE);  
    System.out.println("私钥N：" + privateN);  
    System.out.println("私钥D：" + privateD);  
        byte[] encrypt_str = encrypt(strValues);  
    System.out.println("明文：" + strValues);  
    System.out.println("加密后：" + bytesToHex(encrypt_str));  
        byte[] decrypt_base = decrypt(encrypt_str);  
    String decrypt_str = new String(decrypt_base);  
    System.out.println("解密后：" + decrypt_str);  
}

public static void main(String[] args) throws Exception{  
    String str_base64 = "0123456789";  
    rsaKeyGenerator(2048, str_base64);  
}

import de.robv.android.xposed.IXposedHookLoadPackage; 
import de.robv.android.xposed.callbacks.XC_LoadPackage;
public class Hook01 implements IXposedHookLoadPackage {
    @Override
    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {
    }
}

if (loadPackageParam.packageName.equals("com.dodonew.online")) {
    // 如果目标包名是"com.dodonew.online"
}

if (!loadPackageParam.packageName.equals("com.dodonew.online")) {
    return;
}

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逻辑在这里面写  
    }  
});

public class Application extends ContextWrapper implements ComponentCallbacks2 {
    // ......
    // ------------------ Internal API ------------------
    /**
     * @hide
     */
    @UnsupportedAppUsage
    /* package */ final void attach(Context context) {
        attachBaseContext(context);
        mLoadedApk = ContextImpl.getImpl(context).mPackageInfo;
    }
    // ......
}

public static String md5(String string) {
    byte[] arr_b;
    try {
        MessageDigest messageDigest0 = MessageDigest.getInstance("MD5");
        messageDigest0.update(string.getBytes());
        arr_b = messageDigest0.digest();
    }
    catch(NoSuchAlgorithmException e) {
        throw new RuntimeException("Huh, MD5 should be supported?", e);
    }
    StringBuilder hex = new StringBuilder(arr_b.length * 2);
    int v;
    for(v = 0; v < arr_b.length; ++v) {
        byte b = arr_b[v];
        if((b & 0xFF) < 16) {
            hex.append("0");
        }
            hex.append(Integer.toHexString(b & 0xFF));
    }
        return hex.toString();
}

XposedHelpers.findAndHookMethod("com.dodonew.online.util.Utils", loadPackageParam.classLoader, "md5", String.class, new XC_MethodHook() {
    @Override
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
        super.beforeHookedMethod(param);
        Log.i("hhh123",param.args[0].toString());
        printStackTrace();
    }
    @Override
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
        super.afterHookedMethod(param);
        Log.w("hhh123", param.getResult().toString().toUpperCase());
    }
});

// 定义一个私有的静态方法，用于打印当前线程的调用栈信息  
private static void printStackTrace() {  
    // 创建一个新的Throwable对象，以获得当前的堆栈跟踪  
    Throwable ex = new Throwable();  
        // 获取当前调用堆栈的元素数组  
    StackTraceElement[] stackElements = ex.getStackTrace();  
        // 遍历每一个堆栈元素  
    for (StackTraceElement element : stackElements) {  
        // 打印每个堆栈元素的信息，包括类名、方法名、文件名和行号  
        Log.d("hhh123", "at " + element.getClassName() + "." +   
                        element.getMethodName() + "(" +   
                        element.getFileName() + ":" +   
                        element.getLineNumber() + ")");  
    }  
}

/**  
 * 将给定的映射（Map）转换为带有签名的字符串  
 *  
 * @param map0 需要处理的输入映射  
 * @param append 用于签名的附加字符串  
 * @param sign 签名字段（虽然这个参数在当前版本中没有直接使用）  
 * @return 处理后的JSON字符串，包含签名  
 */  
public static String paraMap(Map map0, String append, String sign) {  
    try {  
        // 获取map0的键集  
        Set set0 = map0.keySet();  
        StringBuilder builder = new StringBuilder(); // 用于构建最终的字符串  
        ArrayList list = new ArrayList(); // 用于存放格式化的键值对  
        // 遍历每个键，构建 "key=value" 的格式，并存入list  
        for(Object object0: set0) {  
            String keyName = (String)object0; // 键转换为字符串  
            list.add(keyName + "=" + ((String)map0.get(keyName))); // 获取值并构造 "key=value"  
        }  
        // 将键值对按字母顺序排序  
        Collections.sort(list);  
        // 将排序后的键值对添加到StringBuilder中，并用"&"连接  
        int i;  
        for(i = 0; i < list.size(); ++i) {  
            builder.append(((String)list.get(i))); // 添加键值对  
            builder.append("&"); // 使用"&"连接  
        }  
        // 在字符串末尾追加 "key=" 和附加字符串  
        builder.append("key=" + append);  
        String s3 = builder.toString(); // 将构建的字符串转换为最终字符串  
        Log.d("CustomTag", s3); // 输出调试信息  
        // 计算字符串s3的MD5值，并转为大写形式  
        String s4 = Utils.md5(s3).toUpperCase();   
        Log.d("CustomTag", s4); // 输出签名调试信息  
        // 将计算得到的签名存入map0  
        map0.put("sign", s4);  
        // 将map0按键排序后转换为JSON格式的字符串  
        String s5 = new Gson().toJson(RequestUtil.sortMapByKey(map0));  
        Log.w("yang", s5 + "   result"); // 输出最终结果  
        return s5; // 返回处理后的JSON字符串  
    }  
    catch(Exception e) {  
        e.printStackTrace(); // 捕捉异常并打印堆栈跟踪  
        return ""; // 在出现异常时返回空字符串  
    }  
}

// 找到指定的类，使用类加载器加载  
final Class<?> clazz = XposedHelpers.findClass("com.dodonew.online.http.RequestUtil", loadPackageParam.classLoader);  
// 钩住 paraMap 方法，参数为 Map、String、String 类型  
XposedHelpers.findAndHookMethod(clazz, "paraMap", Map.class, String.class, String.class, new XC_MethodHook() {  
    // 方法执行之前的钩子  
    @Override  
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
        super.beforeHookedMethod(param); // 调用父类方法  
        // 遍历方法参数，并将其打印到日志中  
        for (int i = 0; i < param.args.length; i++) {  
            Log.i("hhh123", param.args[i].toString()); // 记录每个参数的字符串表示  
        }  
    }  
    // 方法执行之后的钩子  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        super.afterHookedMethod(param); // 调用父类方法  
        // 获取并打印方法返回结果到日志中  
        Log.w("hhh123", param.getResult().toString()); // 记录返回结果的字符串表示  
    }  
});

/**  
 * 解码给定的加密 JSON 字符串，使用 DES 解密算法。
 *   
 * @param json   需要解密的加密 JSON 字符串。
 * @param desKey 用于 DES 解密的秘密密钥。
 * @param desIV  用于 DES 解密的初始化向量。
 * @return 解密后的 JSON 字符串，如果解密成功；如果输入字符串为空或发生异常，则返回原始 JSON 字符串。
 */  
public static String decodeDesJson(String json, String desKey, String desIV) {  
    // 检查输入的 JSON 字符串是否为空或为 null  
    if (TextUtils.isEmpty(json)) {  
        return json; // 返回原始输入的 JSON 字符串  
    }  
    try {  
        // 创建 DesSecurity 实例，使用给定的密钥和 IV，解密 JSON 字符串并以 UTF-8 编码返回  
        return new String(new DesSecurity(desKey, desIV).decrypt64(json), "UTF-8");  
    } catch (Exception e) {  
        // 如果解密过程中出现任何异常，打印异常堆栈信息  
        e.printStackTrace();  
        return json; // 在发生异常时返回原始 JSON 字符串  
    }  
}  
/**  
 * 使用 DES 加密算法对给定的数据字符串进行编码（加密）。
 *   
 * @param data   需要加密的数据字符串。
 * @param desKey 用于 DES 加密的秘密密钥。
 * @param desIV  用于 DES 加密的初始化向量。
 * @return 加密后的数据字符串，以 Base64 格式编码；如果发生异常，则返回空字符串。
 */  
public static String encodeDesMap(String data, String desKey, String desIV) {  
    try {  
        // 创建 DesSecurity 实例，使用 UTF-8 编码将数据转换为字节，然后进行加密，返回 Base64 编码的字符串  
        return new DesSecurity(desKey, desIV).encrypt64(data.getBytes("UTF-8"));  
    } catch (Exception e) {  
        // 如果加密过程中出现任何异常，打印异常堆栈信息  
        e.printStackTrace();  
        return ""; // 在发生异常时返回空字符串  
    }  
}  
/**  
 * 将数据字符串编码为一个 Map，其中值为加密后的数据。
 *   
 * @param data   需要加密的数据字符串。
 * @param mpKey  加密数据在 Map 中的存储键。
 * @param desKey 用于 DES 加密的秘密密钥。
 * @param desIV  用于 DES 加密的初始化向量。
 * @return 一个包含加密数据的 HashMap；如果发生异常，则返回一个空 Map。
 */  
public static Map encodeDesMap(String data, String mpKey, String desKey, String desIV) {  
    // 创建一个 HashMap 以存储加密后的数据  
    HashMap map = new HashMap();  
    try {  
        // 加密数据字符串，并将结果存储在 Map 中，键为 mpKey  
        map.put(mpKey, new DesSecurity(desKey, desIV).encrypt64(data.getBytes()));  
    } catch (Exception e) {  
        // 如果加密过程中出现任何异常，打印异常堆栈信息  
        e.printStackTrace();  
    }  
    // 返回 HashMap，可能为空（如果发生异常）  
    return map;  
}

// 获取指定类的引用，这里是 com.dodonew.online.http.RequestUtil 类  
final Class<?> clazz = XposedHelpers.findClass("com.dodonew.online.http.RequestUtil", loadPackageParam.classLoader);  
// Hook 对象所有方法，特别是 encodeDesMap 方法  
XposedBridge.hookAllMethods(clazz, "encodeDesMap", new XC_MethodHook() {  
        // 在方法调用之前的回调  
    @Override  
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
        super.beforeHookedMethod(param); // 调用父类方法  
                // 遍历调用方法时传入的所有参数，并打印每个参数的值到日志中  
        for (int i = 0; i < param.args.length; i++) {  
            Log.i("hhh123", param.args[i].toString()); // 使用 info 日志级别输出参数  
        }  
    }  
    // 在方法调用之后的回调  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        super.afterHookedMethod(param); // 调用父类方法  
                // 打印方法的返回结果到日志，使用 warn 日志级别  
        Log.w("hhh123", param.getResult().toString());  
                // 调用 decodeDesJson 静态方法，传入返回结果和两个参数  
        // 这里假设 decodeDesJson 方法会对结果进行某种解码处理  
        Object data = XposedHelpers.callStaticMethod(clazz, "decodeDesJson",   
                          param.getResult().toString(),   
                          param.args[1].toString(),   
                          param.args[2].toString());  
                // 使用 error 日志级别输出解码后的数据  
        Log.e("hhh123", data.toString());  
    }  
});

// 查找指定类的 Class 对象  
// "类名" 需要替换为你要查找的类的全名，例如 "com.example.MyClass"  
// loadPackageParam.classLoader 是被注入应用的类加载器，用于加载类  
Class clazz = XposedHelpers.findClass("类名", loadPackageParam.classLoader);  
// 创建该类的一个新实例  
// 注意：此处必须确保类具有公共的无参构造函数，否则会抛出异常  
Object instance = clazz.newInstance();  
// 调用该实例的指定方法  
// "方法名" 应该替换为你想要调用的方法的名称  
// 参数(非必须) 是可选的，可以传递一个或多个参数，如果方法不需要参数可以省略  
XposedHelpers.callMethod(instance, "方法名", 参数(非必须));

// 实现 IXposedHookLoadPackage 接口的 Hook02 类，相当于在应用程序加载时进行钩子处理。
public class Hook02 implements IXposedHookLoadPackage {
    // handleLoadPackage 方法在应用程序包被加载时调用。
    @Override
    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {
        // 检查加载的包名是否为 "com.PASSWPZZ"。如果不是，则提前返回，避免执行后续代码。
        if (!loadPackageParam.packageName.equals("com.PASSWPZZ")) {
            return;
        }
        // 钩住 Application 类中的 attach 方法，该方法在应用程序启动时被调用。
        XposedHelpers.findAndHookMethod(Application.class, "attach", Context.class, new XC_MethodHook() {
            // 在原始 attach 方法执行后调用此方法。
            @Override
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                // 获取传递给 attach 方法的上下文。
                Context context = (Context) param.args[0];
                // 获取应用程序上下文的类加载器。
                ClassLoader classLoader = context.getClassLoader();
                // 使用类加载器加载 Toast 类，以便进行进一步的钩子处理。
                Class<?> clazz = classLoader.loadClass("android.widget.Toast");
                // 钩住 Toast 类中所有名为 "makeText" 的方法。
                XposedBridge.hookAllMethods(clazz, "makeText", new XC_MethodHook() {
                    // 在原始 makeText 方法执行前调用此方法。
                    @Override
                    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                        super.beforeHookedMethod(param); // 调用父类方法以保持钩子链。
                        // 初始化标志变量，用于跟踪特定消息是否被检测到。
                        int a = 0;
                        // 遍历提供给 makeText 方法的所有参数。
                        for (int b = 0; b < param.args.length; b++) {
                            // 检查任何参数是否包含字符串 "写入成功"。
                            if (param.args[b].toString().contains("写入成功")) {
                                a = 1; // 如果找到，设置标志。
                            }
                        }
                        // 如果未找到特定消息，提前返回，不执行后续方法。
                        if (a != 1) {
                            return;
                        }
                        // 如果找到特定消息，调用打印堆栈跟踪的方法。
                        printStackTrace();
                    }
                });
            }
        });
    }
    // 打印当前线程的堆栈跟踪的方法。
    private static void printStackTrace() {
        // 创建一个新的 Throwable 实例，以获取当前的堆栈跟踪。
        Throwable ex = new Throwable();
        // 从 Throwable 中获取堆栈跟踪元素。
        StackTraceElement[] stackElements = ex.getStackTrace();
        // 遍历堆栈跟踪元素并记录它们的信息。
        for (StackTraceElement element : stackElements) {
            Log.d("hhh123", "at " + element.getClassName() + "." + element.getMethodName() + "(" + element.getFileName() + ":" + element.getLineNumber() + ")");
        }
    }
}

// 创建一个新的 Throwable 实例，以获取当前的堆栈跟踪。
Throwable ex = new Throwable();  
// 从 Throwable 中获取当前的堆栈跟踪元素。
StackTraceElement[] stackElements = ex.getStackTrace();  
// 遍历堆栈跟踪元素  
for (StackTraceElement element : stackElements) {  
    // 检查类名是否包含特定的包名  
    if (element.getClassName().contains("com.e4a.runtime") || element.getClassName().contains("com.PASSWPZZ")) {  
                // 记录当前堆栈信息，包括类名、方法名、文件名和行号  
        Log.d("hhh123", "at " + element.getClassName() + "." + element.getMethodName() + "(" + element.getFileName() + ":" + element.getLineNumber() + ")");  
                // 使用类加载器加载当前堆栈元素对应的类  
        Class<?> loadClass = classLoader.loadClass(element.getClassName());  
        // 钩住该类中的指定方法  
        XposedBridge.hookAllMethods(loadClass, element.getMethodName(), new XC_MethodHook() {  
            // 在被钩住的方法调用之前执行的方法  
            @Override  
            protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
                super.beforeHookedMethod(param);  
                // 遍历方法参数并记录其值  
                for (int i = 0; i < param.args.length; i++) {  
                    Log.w("hhh123", param.args[i].toString()); // 打印每个参数的值  
                }  
            }  
            // 在被钩住的方法调用之后执行的方法  
            @Override  
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
                super.afterHookedMethod(param);  
                // 记录方法返回结果  
                Log.e("hhh123", param.getResult().toString()); // 打印方法的返回值  
            }  
        });  
    }  
}

import java.io.BufferedInputStream;  
import java.io.BufferedOutputStream;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
public class FileIOExample {  
    public static void main(String[] args) {  
        // 使用try-with-resources确保流会被自动关闭  
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"));  
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {  
                        byte[] buffer = new byte[1024]; // 创建一个1KB的缓冲区  
            int bytesRead;  
                        // 读取文件中的数据到缓冲区，直到文件结束  
            while ((bytesRead = bis.read(buffer)) != -1) {  
                // 将缓冲区的数据写入到输出文件  
                bos.write(buffer, 0, bytesRead);  
            }  
                    } catch (IOException e) {  
            // 捕获并处理可能出现的IO异常  
            e.printStackTrace();  
        }  
    }  
}

// 使用类加载器加载 java.io.FileOutputStream 类，以便进行进一步的钩子处理。
Class<?> clazz1 = classLoader.loadClass("java.io.FileOutputStream");  
// 使用 XposedBridge 钩住所有构造函数，创建一个新的 XC_MethodHook 实例  
XposedBridge.hookAllConstructors(clazz1, new XC_MethodHook() {  
    // 覆盖 beforeHookedMethod 方法，在构造函数执行前调用此方法  
    @Override  
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
        super.beforeHookedMethod(param); // 调用父类的实现，以确保链的完整性  
        // 遍历构造函数的所有参数  
        for (int i = 0; i < param.args.length; i++) {  
            // 使用日志打印每一个参数的字符串表示，以便进行调试  
            Log.w("hhh123", param.args[i].toString()); // 打印每个参数的值，以便追踪文件输出流的创建过程  
        }  
        // 钩子执行时调用此方法，打印当前的方法调用堆栈信息，有助于调试  
        printStackTrace(); // 打印堆栈跟踪信息，帮助我们了解当前的调用路径  
    }  
});

// 尝试加载 "com.e4a.runtime.文件操作" 类并记录其方法信息。
try {  
    // 使用 classLoader 加载指定的类  
    Class<?> loadClass = classLoader.loadClass("com.e4a.runtime.文件操作");  
    Log.d("hhh123", "Class found: " + loadClass.getName()); // 记录找到的类的名称  
    // 通过Java反射获取该类的所有声明的方法  
    Method[] methods = loadClass.getDeclaredMethods();  
    Log.d("hhh123", "Number of methods: " + methods.length); // 记录方法的数量  
    // 遍历并记录每个方法的名称  
    for (Method md : methods) {  
        Log.w("hhh123", "Method: " + md.getName()); // 记录方法名称  
    }  
} catch (ClassNotFoundException e) {  
    // 当指定的类未找到时，捕获 ClassNotFoundException 并记录错误信息  
    Log.e("hhh123", "Class not found: " + e.getMessage());  
} catch (Exception e) {  
    // 捕获其他异常并记录相关错误信息  
    Log.e("hhh123", "Error retrieving methods: " + e.getMessage());  
}

// 加载 "com.e4a.runtime.文件操作" 类  
Class<?> loadClass = classLoader.loadClass("com.e4a.runtime.文件操作");  
// 通过Java反射获取所有方法  
Method[] methods = loadClass.getDeclaredMethods();   
// 遍历所有方法  
for (Method md : methods) {  
    // 设置方法可访问，以便能够调用私有方法  
    md.setAccessible(true);   
        // 输出当前方法的名称，方便调试  
    Log.w("hhh123", md.getName());  
        // 钩住每个方法，记录参数和返回结果  
    XposedBridge.hookAllMethods(loadClass, md.getName(), new XC_MethodHook() {  
        @Override  
        protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
            super.beforeHookedMethod(param);  
            // 遍历方法参数并输出  
            for (int i = 0; i < param.args.length; i++) {  
                Log.w("hhh123", param.args[i].toString()); // 输出每个参数的值  
            }  
        }  
        @Override  
        protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
            super.afterHookedMethod(param);  
            // 输出方法返回结果，便于调试  
            Log.e("hhh123", param.getResult().toString()); // 输出返回结果  
        }  
    });  
}

# 往期推荐

1、PWN入门：整数溢出

2、野蛮fuzz：持久性fuzz

3、修改PE导入表注入DLL——实例图文教程

4、【入门篇】Android漏洞挖掘，实战演示挖掘技巧

5、野蛮fuzz：深入了解代码覆盖率