零 B站案例

0.1 回顾

# day18---心跳 sign 签名

# 1 搜索  sign=---》非常多
# 2 找到 toString 
 public String toString() {
        String str = this.a;
        if (str == null) {
            return "";
        }
        if (this.b == null) {
            return str;
        }
        return this.a + "&sign=" + this.b;
    }
# 3 查看 this.b---》找到b的赋值位置
    public SignedQuery(String str, String str2) {
        this.a = str;
        this.b = str2;
    }
# 4 查找SignedQuery用例【搜不到】---》打印SignedQuery的调用栈
# 5 打印--toString 的调用栈
java.lang.Throwable
	at com.bilibili.nativelibrary.SignedQuery.toString(Native Method)
    # 看这个
	at com.bilibili.okretro.f.a.c(BL:16)
	at com.bilibili.okretro.f.a.a(BL:6)
	at com.bilibili.okretro.d.a.execute(BL:24)
	at com.bilibili.okretro.d.a$a.run(BL:2)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1167)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:641)
	at java.lang.Thread.run(Thread.java:923)
    
# 6 com.bilibili.okretro.f.a 类下的c 方法
public void c(u uVar, c0 c0Var, b0.a aVar) {
   aVar.s(h).l(c0.create(w.d("application/x-www-form-urlencoded; charset=utf-8"), h(hashMap).toString())); # 在这里调用了
        } catch (IOException unused) {
        }
    }
# 7 h(hashMap) 是什么，转成了字符串--》h的代码
  public SignedQuery h(Map<String, String> map) {
        return LibBili.g(map);
    }
# 8 LibBili.g(map)代码如下
    public static SignedQuery g(Map<String, String> map) {
        return s(map == null ? new TreeMap() : new TreeMap(map));
    }
#9 s函数---》jni的方法---》真正的加密---》就是使用so加密的
static native SignedQuery s(SortedMap<String, String> sortedMap);

#10 libbili.so 这个so文件
    static {
        com.getkeepsafe.relinker.c.c("bili");
    }

0.2 分析

#1 心跳sign签名
    libbili.so
    SignQuery s(SortedMap<String,String> sortedMap)

# 2 入参和返回值
	入参1：SortedMap---》hook得到数据--》包裹--》传给unidbg
    返回值：SignedQuery类型--》app自己定义的类型
    
    
#3 Hook参数返回值
    参数：hook到数据，组装成sortedMap  = {....} ->ProxyDvmObject.createObject(...)
    返回：SignQuery是app自定类型 -> 可以使用 DvmObject<?> 类型泛指--》unidbg中所有类型的父类都是DvmObject类型--》StringObject也是它的子类
    
    
#4  分析--》异地昂要补环境  libbili.so中的s方法
	-在so内部，肯定会初始化得到SignQuery对象，然后调用它的toString方法
    -伪代码如下：
    #1 找到类
    jclass cls = (*env)->FindClass(env, "SignQuery");
    # 2 找到构造方法
    jmethodID init = (*env)->GetMethodID(env, cls, "<init>", "(Ljava/lang/String;)V");
    # 3 通过构造方法，实例化得到对象，【传了两个参数，第二个参数就是sign】
    jobject cls_obj = (*env)->NewObject(env, cls, init, (*env)->NewStringUTF(env, "lqz"));

   # 4 通过类，先找到方法
    jmethodID method1 = (*env)->GetMethodID(env, cls, "ShowName", "()Ljava/lang/String;");

    # 5 通过对象执行方法
    jstring res1 = (*env)->CallObjectMethod(env, cls_obj, method1);

 
###5 所以
	上面初始化得到SignQuery对象是，调用构造方法传入的俩参数，第二个参数就是 签名sign
    如下图
    
# 6 调用了toString
this.a=actual_played_time=0&channel=xxl_gdt_wm_253
this.b=加密串
返回的值是：actual_played_time=0&channel=xxl_gdt_wm_253&sign=加密串

# 7 so文件 c语言内部---》一定是c调用了java，实例化得到了SignedQuery，实例化得到对象，一定要传两个参数--》而传的第二个参数--》就是加密后的sign---》一会咱们要补环境--》补 SignedQuery 类---》这个类我们可以不写，也能跑出sign的加密---》咱们补环境时---当调用SignedQuery实例化的时候---》会报错，让咱们补环境---》第二个参数就是sign---》咱们可以直接拿到第二个参数，这样就不需要补SignedQuery环境了

0.3 unidbg

package com.nb.demo;

import com.github.unidbg.AndroidEmulator;
import com.github.unidbg.Module;
import com.github.unidbg.linux.android.AndroidEmulatorBuilder;
import com.github.unidbg.linux.android.AndroidResolver;
import com.github.unidbg.linux.android.dvm.*;
import com.github.unidbg.linux.android.dvm.jni.ProxyDvmObject;
import com.github.unidbg.memory.Memory;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.util.*;


class SignedQuery {

    public static final String KEY_VALUE_DELIMITER = "=";
    public static final String FIELD_DELIMITER = "&";

    private static final char[] a = "0123456789ABCDEF".toCharArray();
    public final String rawParams;
    public final String sign;

    public SignedQuery(String str, String str2) {
        this.rawParams = str;
        this.sign = str2;
    }

    private static boolean a(char c2, String str) {
        return (c2 >= 'A' && c2 <= 'Z') || (c2 >= 'a' && c2 <= 'z') || !((c2 < '0' || c2 > '9') && "-_.~".indexOf(c2) == -1 && (str == null || str.indexOf(c2) == -1));
    }

    static String b(String str) {
        return c(str, null);
    }

    static String c(String str, String str2) {
        StringBuilder sb = null;
        if (str == null) {
            return null;
        }
        int length = str.length();
        int i = 0;
        while (i < length) {
            int i2 = i;
            while (i2 < length && a(str.charAt(i2), str2)) {
                i2++;
            }
            if (i2 != length) {
                if (sb == null) {
                    sb = new StringBuilder();
                }
                if (i2 > i) {
                    sb.append((CharSequence) str, i, i2);
                }
                i = i2 + 1;
                while (i < length && !a(str.charAt(i), str2)) {
                    i++;
                }
                try {
                    byte[] bytes = str.substring(i2, i).getBytes("UTF-8");
                    int length2 = bytes.length;
                    for (int i3 = 0; i3 < length2; i3++) {
                        sb.append('%');
                        char[] cArr = a;
                        sb.append(cArr[(bytes[i3] & 240) >> 4]);
                        sb.append(cArr[bytes[i3] & 15]);
                    }
                } catch (UnsupportedEncodingException e2) {
                    throw new AssertionError(e2);
                }
            } else if (i == 0) {
                return str;
            } else {
                sb.append((CharSequence) str, i, length);
                return sb.toString();
            }
        }
        return sb == null ? str : sb.toString();
    }

    static String r(Map<String, String> map) {
        if (!(map instanceof SortedMap)) {
            map = new TreeMap(map);
        }
        StringBuilder sb = new StringBuilder(256);
        for (Map.Entry<String, String> entry : map.entrySet()) {
            String key = entry.getKey();
            if (!key.isEmpty()) {
                sb.append(b(key));
                sb.append(KEY_VALUE_DELIMITER);
                String value = entry.getValue();
                sb.append(value == null ? "" : b(value));
                sb.append(FIELD_DELIMITER);
            }
        }
        int length = sb.length();
        if (length > 0) {
            sb.deleteCharAt(length - 1);
        }
        if (length == 0) {
            return null;
        }
        return sb.toString();
    }

    public String toString() {
        String str = this.rawParams;
        if (str == null) {
            return "";
        }
        if (this.sign == null) {
            return str;
        }
        return this.rawParams + "&sign=" + this.sign;
    }
}


public class Bili extends AbstractJni {
    public static AndroidEmulator emulator;  // 静态属性，以后对象和类都可以直接使用
    public static Memory memory;
    public static VM vm;
    public static Module module;

    public Bili() {
        // 1.创建设备（32位或64位模拟器）， 具体看so文件在哪个目录。 在armeabi-v7a就选择32位
        emulator = AndroidEmulatorBuilder.for32Bit().setProcessName("com.bili").build();
        // 2.获取内存对象（可以操作内存）
        memory = emulator.getMemory();
        // 3.设置安卓sdk版本（只支持19、23）
        memory.setLibraryResolver(new AndroidResolver(23));

        // 4.创建虚拟机（运行安卓代码需要虚拟机，就想运行py代码需要python解释器一样）    以后会动
        vm = emulator.createDalvikVM(new File("apks/bili/v6240.apk"));
        vm.setJni(this); // 后期补环境会用，把要补的环境，写在当前这个类中，执行这个代码即可，但是必须继承AbstractJni
        //vm.setVerbose(true); //是否展示调用过程的细节

        // 5.加载so文件
        DalvikModule dm = vm.loadLibrary(new File("apks/bili/libbili.so"), false);   // 以后会动
        dm.callJNI_OnLoad(emulator); // jni开发动态注册，会执行JNI_OnLoad，如果是动态注册，需要执行一下这个，如果静态注册，这个不需要执行，车智赢案例是静态注册

        // 6.dm代表so文件，dm.getModule()得到module对象，基于module对象可以访问so中的成员。
        module = dm.getModule(); // 把so文件加载到内存后，后期可以获取基地址，偏移量等，该变量代指so文件

    }

    public void sign() {
        SortedMap<String, String> map = new TreeMap<String, String>();
        map.put("actual_played_time", "0");
        map.put("aid", "466565149");
        map.put("appkey", "1d8b6e7d45233436");
        map.put("auto_play", "0");
        map.put("ts", "1647952932");

        DvmClass LibBili = vm.resolveClass("com/bilibili/nativelibrary/LibBili");
        String method = "s(Ljava/util/SortedMap;)Lcom/bilibili/nativelibrary/SignedQuery;";
        DvmObject<?> byteValues = LibBili.callStaticJniMethodObject(
                emulator,
                method,
                ProxyDvmObject.createObject(vm, map)
        );
        System.out.println(byteValues.getValue().toString());


    }

    public static void main(String[] args) {
        Bili dym = new Bili();
        dym.sign();
    }


    // 补环境 callBooleanMethod 有两个，本质是一样的，下面的signature可以通过dvmMethod.getSignature()得到，使用上面的即可

    @Override
    public boolean callBooleanMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
        if(signature.equals("java/util/Map->isEmpty()Z")){
            // 真正的读取 map的值
            Map m=(Map) dvmObject.getValue();
            return m.isEmpty();

        }
        return super.callBooleanMethod(vm, dvmObject, signature, varArg);
    }

    @Override
    public boolean callBooleanMethod(BaseVM vm, DvmObject<?> dvmObject, DvmMethod dvmMethod, VarArg varArg) {
        return super.callBooleanMethod(vm, dvmObject, dvmMethod, varArg);
    }

    @Override
    public DvmObject<?> callObjectMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
        if(signature.equals("java/util/Map->get(Ljava/lang/Object;)Ljava/lang/Object;")){
            // 这是在执行map的get方法，它需要传入key，得到value，我们不知道目前传入的是哪个key
            // 最后一个参数：varArg ，c中调用java时，传入的参数，全在varArg中，因为就只有一个参数，所以我们取第0个即可
            // 方式一：通过Object泛指
            /*
            // 获取map
            Map m=(Map) dvmObject.getValue();
            // 获取要取的key
            Object key=varArg.getObjectArg(0).getValue();
            Object value =(Object)m.get(key);
            return ProxyDvmObject.createObject(vm, value);
             */

            // 方式二：通过具体类型
            Map m=(Map) dvmObject.getValue();
            // 获取要取的key
            Object key=varArg.getObjectArg(0).getValue();
            // 打印出key的具体类型，我们直接强制类型转换
            //System.out.println(key.getClass()); // 打印出来看到是 class java.lang.String 字符串
            String value =(String)m.get(key);
            System.out.println(value.getClass());  // 也是字符串
            return new StringObject(vm,value);

        }
        return super.callObjectMethod(vm, dvmObject, signature, varArg);
    }
    // 补callStaticObjectMethod
    @Override
    public DvmObject<?> callStaticObjectMethod(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
        if(signature.equals("com/bilibili/nativelibrary/SignedQuery->r(Ljava/util/Map;)Ljava/lang/String;")){
            // r方法 传了map类型，返回了字符串
            //1 取出传入的map
            Map m=(Map) varArg.getObjectArg(0).getValue();
            // 2 反编译app，读懂SignedQuery的r方法逻辑，我们自己实现---》这个方式麻烦，我们直接把别人代码全copy过来
            String r=SignedQuery.r(m);
            return new StringObject(vm,r);


        }
        return super.callStaticObjectMethod(vm, dvmClass, signature, varArg);
    }

    // 继续补 newObject


    @Override
    public DvmObject<?> newObject(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
        if(signature.equals("com/bilibili/nativelibrary/SignedQuery-><init>(Ljava/lang/String;Ljava/lang/String;)V")){
            // 方式一： 咱们之前逆向时，实例化得到SignedQuery的第二个参数就是sign，我们可以不补充，直接取到第二个参数，打印出来即可
            // System.out.println(varArg.getObjectArg(0).getValue()); 第一个参数是待加密的字符串
            //System.out.println(varArg.getObjectArg(1).getValue());
            // 为了防止报错，给返回一个它需要的类型空对象,把sign中的System.out.println(byteValues.getValue().toString());也注释掉
            //return vm.resolveClass("com/bilibili/nativelibrary/SignedQuery").newObject(null);

            // 方式二：通过自己定义的SignedQuery构造
            String param=(String) varArg.getObjectArg(0).getValue();
            String sign=(String)varArg.getObjectArg(1).getValue();
            SignedQuery signedQuery =new SignedQuery(param,sign);
            return vm.resolveClass("com/bilibili/nativelibrary/SignedQuery").newObject(signedQuery);

        }
        return super.newObject(vm, dvmClass, signature, varArg);
    }
}

0.4 补环境

// 补环境 callBooleanMethod 有两个，本质是一样的，下面的signature可以通过dvmMethod.getSignature()得到，使用上面的即可

   @Override
   public boolean callBooleanMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
       if(signature.equals("java/util/Map->isEmpty()Z")){
           // 真正的读取 map的值
           Map m=(Map) dvmObject.getValue();
           return m.isEmpty();

       }
       return super.callBooleanMethod(vm, dvmObject, signature, varArg);
   }

   @Override
   public boolean callBooleanMethod(BaseVM vm, DvmObject<?> dvmObject, DvmMethod dvmMethod, VarArg varArg) {
       return super.callBooleanMethod(vm, dvmObject, dvmMethod, varArg);
   }

   @Override
   public DvmObject<?> callObjectMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
       if(signature.equals("java/util/Map->get(Ljava/lang/Object;)Ljava/lang/Object;")){
           // 这是在执行map的get方法，它需要传入key，得到value，我们不知道目前传入的是哪个key
           // 最后一个参数：varArg ，c中调用java时，传入的参数，全在varArg中，因为就只有一个参数，所以我们取第0个即可
           // 方式一：通过Object泛指
           /*
           // 获取map
           Map m=(Map) dvmObject.getValue();
           // 获取要取的key
           Object key=varArg.getObjectArg(0).getValue();
           Object value =(Object)m.get(key);
           return ProxyDvmObject.createObject(vm, value);
            */

           // 方式二：通过具体类型
           Map m=(Map) dvmObject.getValue();
           // 获取要取的key
           Object key=varArg.getObjectArg(0).getValue();
           // 打印出key的具体类型，我们直接强制类型转换
           //System.out.println(key.getClass()); // 打印出来看到是 class java.lang.String 字符串
           String value =(String)m.get(key);
           System.out.println(value.getClass());  // 也是字符串
           return new StringObject(vm,value);

       }
       return super.callObjectMethod(vm, dvmObject, signature, varArg);
   }
   // 补callStaticObjectMethod
   @Override
   public DvmObject<?> callStaticObjectMethod(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
       if(signature.equals("com/bilibili/nativelibrary/SignedQuery->r(Ljava/util/Map;)Ljava/lang/String;")){
           // r方法 传了map类型，返回了字符串
           //1 取出传入的map
           Map m=(Map) varArg.getObjectArg(0).getValue();
           // 2 反编译app，读懂SignedQuery的r方法逻辑，我们自己实现---》这个方式麻烦，我们直接把别人代码全copy过来
           String r=SignedQuery.r(m);
           return new StringObject(vm,r);


       }
       return super.callStaticObjectMethod(vm, dvmClass, signature, varArg);
   }

   // 继续补 newObject


   @Override
   public DvmObject<?> newObject(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
       if(signature.equals("com/bilibili/nativelibrary/SignedQuery-><init>(Ljava/lang/String;Ljava/lang/String;)V")){
           // 方式一： 咱们之前逆向时，实例化得到SignedQuery的第二个参数就是sign，我们可以不补充，直接取到第二个参数，打印出来即可
           // System.out.println(varArg.getObjectArg(0).getValue()); 第一个参数是待加密的字符串
           //System.out.println(varArg.getObjectArg(1).getValue());
           // 为了防止报错，给返回一个它需要的类型空对象,把sign中的System.out.println(byteValues.getValue().toString());也注释掉
           //return vm.resolveClass("com/bilibili/nativelibrary/SignedQuery").newObject(null);

           // 方式二：通过自己定义的SignedQuery构造
           String param=(String) varArg.getObjectArg(0).getValue();
           String sign=(String)varArg.getObjectArg(1).getValue();
           SignedQuery signedQuery =new SignedQuery(param,sign);
           return vm.resolveClass("com/bilibili/nativelibrary/SignedQuery").newObject(signedQuery);

       }
       return super.newObject(vm, dvmClass, signature, varArg);
   }

一拼多多案例

1.1 目标

# 目标
破解搜索功能的：anti-token

# 版本：v6.32.0
1 需要结合Hook脚本寻找native方法到底定义在那个so文件中。
2 内部读取系统的参数值，可以结合frida去hook获取到相关值并补充至此
3 使用SocksDroid转发再进行抓包

1.2 反编译-搜索

# 1 全局搜索  anti-token
# 目标：
破解 拼多多搜索功能中，请求头中：anti-token
anti-token：2afx8InYRPI6fON2k2lK8YprxK0lM+rWhapt1z2uFT2MbkTrQrk7H+Fd0qIVbJ4qIUuhJmQ4O3cL/8IJUTSRl6hRp97btzJX7ArvuHtbWdTF2Acu/umDgr5abSBDFhS1OzqUGCI0w9+1Xf2UPc7XDK6Q3fXJW0VeH/34Bc/GuiSCxOvUyuSLd0MV1BSsIbFJhJC9bUftrqjRNQk/9TYbO/qdlFD0rRgW6Xxs80B2a3xRekQKz+bc3ixu+fESkK7XwPAHHhjRElfd8ME/A5NG6a3LGbG++5FsLR2hHP1enwLK3Kmmf7CJDsbdN2nnMHWJuSbmoD06Jz4gn+BoxhcfHPNGkMLE5gpyoudzZLqdCbwaj5p85Qq+NehhfAr1mkDFzbYBK5PITw4TkzBXkeP0td3BFqbAwow6g00muUo2AfmcM4=
# 版本：v6.32.0

# 需要登录才能搜索---》不登录不能搜索

#1  使用socketsDroid---》转发
#2 正常搜索，抓包能抓到--》就不用操作了
#3 如果抓不到，先不打开 charles---》使用socketsDroid---》转发 ---》在拼多多搜索---》无网络--》打开charles--》点加载---》就能抓到了



#4 反编译：搜索   anti-token 
# 5 查看第一个：
hashMap.put("anti-token", f);
# 6 确定f是什么
f = com.aimi.android.common.service.d.a().f(context, Long.valueOf(longValue));
# 7 跳到声明---》接口类型
String f(Context context, Long l);
# 8 查找 谁实现了public interface c  接口---》里面重写了 f
public class u implements com.aimi.android.common.service.c {
    @Override // com.aimi.android.common.service.c
    public String f(Context context, Long l) {
        long c;
        if (com.xunmeng.manwe.hotfix.c.p(154561, this, context, l)) {
            return com.xunmeng.manwe.hotfix.c.w();
        }
        if (AbTest.instance().isFlowControl("ab_timestamp_v2_5590", true)) {
            c = TimeStamp.getRealLocalTimeV2();
        } else {
            c = com.xunmeng.pinduoduo.d.l.c(TimeStamp.getRealLocalTime());
        }
        try {
            return SecureNative.deviceInfo2(context, Long.valueOf(c));
        } catch (Throwable th) {
            Logger.e("PDD.SecureServiceImpl", "deviceInfo2 error, %s", th);
            return null;
        }
    }

}

# 9 返回了return SecureNative.deviceInfo2(context, Long.valueOf(c));
   public static String deviceInfo2(Context context, Long l) {
        if (com.xunmeng.manwe.hotfix.c.p(154539, null, context, l)) {
            return com.xunmeng.manwe.hotfix.c.w();
        }
        if (context == null) {
            return null;
        }
        return DeviceNative.info2(context, com.xunmeng.pinduoduo.d.l.c(l));
    }
#10 找到jni方法
public static native String info2(Context context, long j);

# 11 使用unidbg跑--分析---》定位是那个so文件，咱就可以使用unidbg跑了

	参数和返回值：
    	第一个参数：context
        第二个参数：long
        返回值是：String
        
        
# 12 如果不知道是那个so文件，如何做？

1.3 hook验证

import frida
import sys

rdev = frida.get_remote_device()

# 12957  拼多多         com.xunmeng.pinduoduo
session = rdev.attach("拼多多")

scr = """
Java.perform(function () {
    var DeviceNative = Java.use("com.xunmeng.pinduoduo.secure.DeviceNative");
   
    DeviceNative.info2.implementation = function (ctx, i) {
        var res = this.info2(ctx, i);
        console.log("info2==",res);
        return res;
    }
});
"""
script = session.create_script(scr)


def on_message(message, data):
    print(message, data)


script.on("message", on_message)
script.load()
sys.stdin.read()

1.4 定位so

知道了他是基于native方法实现，但他定义在那个so中呢？

可以通过Hook安卓系统底层的方法来定位。

1.4.1 静态注册

如果是静态注册的成员，可以去Hook libdl.so中的dlsym。

Java.perform(function () {
    var dlsymadd = Module.findExportByName("libdl.so", 'dlsym');
    Interceptor.attach(dlsymadd, {
        onEnter: function (args) {
            this.info = args[1];

        }, onLeave: function (retval) {
            var module = Process.findModuleByAddress(retval);
            if (module == null) {
                return retval;
            }
            var funcName = this.info.readCString();
			
            //info2 是方法名
            if (funcName.indexOf("info2") !== -1) {
                console.log(module.name);
                console.log('\t', funcName);
            }
            return retval;
        }
    })
});


// frida -U -f  com.xunmeng.pinduoduo  -l 3.static_findso.js

1.4.2 动态注册

动态注册的话，就去找RegisterNatives并hook就行了。

var symbols = Module.enumerateSymbolsSync("libart.so");
var addrRegisterNatives = null;
for (var i = 0; i < symbols.length; i++) {
    var symbol = symbols[i];
    if (symbol.name.indexOf("art") >= 0 &&
        symbol.name.indexOf("JNI") >= 0 &&
        symbol.name.indexOf("RegisterNatives") >= 0 &&
        symbol.name.indexOf("CheckJNI") < 0) {
        addrRegisterNatives = symbol.address;
        console.log("RegisterNatives is at ", symbol.address, symbol.name);
        //问题：break
    }
}

console.log("addrRegisterNatives=", addrRegisterNatives);

if (addrRegisterNatives != null) {
    Interceptor.attach(addrRegisterNatives, {
        onEnter: function (args) {
            var env = args[0];
            var java_class = args[1];
            var class_name = Java.vm.tryGetEnv().getClassName(java_class);
            
            //当前native所在类：  包.类 
            var taget_class = "com.xunmeng.pinduoduo.secure.DeviceNative";
            
            if (class_name === taget_class) {
                console.log("\n[RegisterNatives] method_count:", args[3]);
                var methods_ptr = ptr(args[2]);
                var method_count = parseInt(args[3]);

                for (var i = 0; i < method_count; i++) {
                    // Java中函数名字的
                    var name_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3));
                    // 参数和返回值类型
                    var sig_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3 + Process.pointerSize));
                    // C中的函数指针
                    var fnPtr_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3 + Process.pointerSize * 2));

                    var name = Memory.readCString(name_ptr); // 读取java中函数名
                    var sig = Memory.readCString(sig_ptr); // 参数和返回值类型
                    var find_module = Process.findModuleByAddress(fnPtr_ptr); // 根据C中函数指针获取模块

                    var offset = ptr(fnPtr_ptr).sub(find_module.base) // fnPtr_ptr - 模块基地址
                    // console.log("[RegisterNatives] java_class:", class_name);
                    console.log("name:", name, "sig:", sig, "module_name:", find_module.name, "offset:", offset);
                    //console.log("name:", name, "module_name:", find_module.name, "offset:", offset);

                }
            }
        }
    });
}

// frida -U -f  com.xunmeng.pinduoduo  -l 4.dynamic_findso.js
// frida -UF  -l 4.dynamic_findso.js

// 提取64位so  libpdd_secure.so

1.5 补环境

腾讯日志库

public void callStaticVoidMethodV(BaseVM vm, DvmClass dvmClass, String signature, VaList vaList) {
    // 1 腾讯日志库
    if(signature.equals("com/tencent/mars/xlog/PLog->i(Ljava/lang/String;Ljava/lang/String;)V")){
        return;
    }
    super.callStaticVoidMethodV(vm, dvmClass, signature, vaList);
}

权限之手机状态

#1 开发者 在Manifest文件中添加权限
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
<uses-permission android:name="android.permission.READ_CALL_LOG" />
<uses-permission android:name="android.permission.CALL_PHONE" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.ANSWER_PHONE_CALLS" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
#2 用户使用app，会弹窗提醒
#3  ContextCompat.checkSelfPermission()方法检测授权状态，返回的结果为PackageManager中的两个常量:PERMISSION_GRANTED（已授权）和PERMISSION_DENIED（未授权）
    public static final int PERMISSION_DENIED = -1; # 未授权
    public static final int PERMISSION_GRANTED = 0; # 授权
    
# 4 我们获取方式如下：
获取方式一：我们可以通过hook拿到
获取方式二：我们直接搜索写死-1或0
获取方式三：我们自己写安卓应该，看自己手机的状态

# 5 我们补环境
if(signature.equals("android/content/Context->checkSelfPermission(Ljava/lang/String;)I")){
    // 1 取出第一个位置参数(String 类型)
    String str=(String)varArg.getObjectArg(0).getValue();
    // android.permission.READ_PHONE_STATE 拿的是手机状态
    // 获取方式一：我们可以通过hook拿到
    // 获取方式二：我们直接搜索写死
    // 获取方式三：我们自己写安卓应该，看自己手机的状态
    System.out.println(str);
    return -1;
}

hook获取相关值

Java.perform(function () {
    var TelephonyManager = Java.use("android.telephony.TelephonyManager");

    TelephonyManager.getSimState.overload().implementation = function () {
        var res = this.getSimState();
        console.log("value=",res);
        return res;
    }
});

// frida -U -f  com.xunmeng.pinduoduo  -l hook_value.js

getSystemService

#1 getSystemService 获取系统信息
android/content/Context->getSystemService(Ljava/lang/String;)Ljava/lang/Object;
# 2 安卓中对应
/*
* SIM的状态信息：
*  SIM_STATE_UNKNOWN             未知状态 0
*  SIM_STATE_ABSENT                 没插卡 1
*  SIM_STATE_PIN_REQUIRED     锁定状态，需要用户的PIN码解锁 2
*  SIM_STATE_PUK_REQUIRED    锁定状态，需要用户的PUK码解锁 3
*  SIM_STATE_NETWORK_LOCKED   锁定状态，需要网络的PIN码解锁 4
*  SIM_STATE_READY            就绪状态 5
*/
TelephonyManager tm=(TelephonyManager)this.getSystemService(TELEPHONY_SERVICE); //  public static final String TELEPHONY_SERVICE = "phone";
System.out.println(tm.getSimState());
System.out.println(tm.getNetworkType()); // 申请android.permission.READ_PHONE_STATE权限才能获取
System.out.println(tm.getSimOperatorName());

# 3 我们补环境
if(signature.equals("android/content/Context->getSystemService(Ljava/lang/String;)Ljava/lang/Object;")){
    // 虽然是Object类型，但是作为安卓开发知道是：TelephonyManager 类型，我们直接补
    return vm.resolveClass("android/telephony/TelephonyManager").newObject(null); //不能用ProxyDvmObject.createObject(vm,null) 补
}

# 4 继续补 android/telephony/TelephonyManager->getSimState()I
if (signature.equals("android/telephony/TelephonyManager->getSimState()I")) {
    /*
    * SIM的状态信息：
    *  SIM_STATE_UNKNOWN             未知状态 0
    *  SIM_STATE_ABSENT                 没插卡 1
    *  SIM_STATE_PIN_REQUIRED     锁定状态，需要用户的PIN码解锁 2
    *  SIM_STATE_PUK_REQUIRED    锁定状态，需要用户的PUK码解锁 3
    *  SIM_STATE_NETWORK_LOCKED   锁定状态，需要网络的PIN码解锁 4
    *  SIM_STATE_READY            就绪状态 5
    */
    return 5;
}
# 5 继续补：android/telephony/TelephonyManager->getSimOperatorName()Ljava/lang/String;
if (signature.equals("android/telephony/TelephonyManager->getSimOperatorName()Ljava/lang/String;")) {
    return new StringObject(vm, "中国电信"); // 运营商
}

# 6 继续补：android/telephony/TelephonyManager->getSimCountryIso()Ljava/lang/String;
if (signature.equals("android/telephony/TelephonyManager->getSimCountryIso()Ljava/lang/String;")) {
    return new StringObject(vm, "cn");
}
# 7继续补：android/telephony/TelephonyManager->getNetworkType()I
# 网络类型：https://codeleading.com/article/33471321733/
if (signature.equals("android/telephony/TelephonyManager->getNetworkType()I")) {
    return 13;
}

# 8 继续补：android/telephony/TelephonyManager->getNetworkOperator()Ljava/lang/String;
if (signature.equals("android/telephony/TelephonyManager->getNetworkOperator()Ljava/lang/String;")) {
    //https://blog.csdn.net/ztp800201/article/details/44198031/
    return new StringObject(vm, "46003");
}

# 9 继续补：android/telephony/TelephonyManager->getNetworkCountryIso()Ljava/lang/String;
if (signature.equals("android/telephony/TelephonyManager->getNetworkCountryIso()Ljava/lang/String;")) {
    // 获取国家代码
    return new StringObject(vm, "cn");
}
#10 android/telephony/TelephonyManager->getDataState()I
if (signature.equals("android/telephony/TelephonyManager->getDataState()I")) {
    return 0;
}

# 11 android/telephony/TelephonyManager->getDataActivity()I
if (signature.equals("android/telephony/TelephonyManager->getDataActivity()I")) {
    return 4;
}

app自己的方法

# 补环境：
com/xunmeng/pinduoduo/secure/EU->gad()Ljava/lang/String;
# 解决方案
	- hook得到值
    - 反编译读源码分析，自己实现
    
# 补环境
if (signature.equals("com/xunmeng/pinduoduo/secure/EU->gad()Ljava/lang/String;")) {
    return new StringObject(vm, "7202111111112f2");
}

系统方法isDebuggerConnected

# android/os/Debug->isDebuggerConnected()Z
isDebuggerConnected是否有调试器挂载到程序上

# https://blog.csdn.net/qq_29078329/article/details/128394432

# 补环境
@Override
public boolean callStaticBooleanMethod(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
    if (signature.equals("android/os/Debug->isDebuggerConnected()Z")) {
        return false;
    }
    return super.callStaticBooleanMethod(vm, dvmClass, signature, varArg);
}

异常

# java/lang/Throwable-><init>()V
# 补环境 java的Throwable
@Override
public DvmObject<?> newObject(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
    if (signature.equals("java/lang/Throwable-><init>()V")) {
        Throwable t=new Throwable(); // 可以new出来，可以传null
        return vm.resolveClass("java/lang/Throwable").newObject(t);
    }
    return super.newObject(vm, dvmClass, signature, varArg);
}

# java/lang/Throwable->getStackTrace()[Ljava/lang/StackTraceElement;
if (signature.equals("java/lang/Throwable->getStackTrace()[Ljava/lang/StackTraceElement;")) {
    return new ArrayObject(vm.resolveClass("java/lang/StackTraceElement").newObject(null));
}

# java/lang/StackTraceElement->getClassName()Ljava/lang/String;
if (signature.equals("java/lang/StackTraceElement->getClassName()Ljava/lang/String;")) {
    return new StringObject(vm, "");
}

replace

#java/lang/String->replaceAll(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;

public DvmObject<?> callObjectMethodV(BaseVM vm, DvmObject<?> dvmObject, String signature, VaList vaList) {
    if (signature.equals("java/lang/String->replaceAll(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;")) {
        String origin = (String) dvmObject.getValue();
        String a0 = (String) vaList.getObjectArg(0).getValue();
        String a1 = (String) vaList.getObjectArg(1).getValue();
        String result = origin.replaceAll(a0, a1);
        return new StringObject(vm, result);
    }
    return super.callObjectMethodV(vm, dvmObject, signature, vaList);
}

文件读写输入输出相关

'''
- 输入输出相关对象
    - python：内容 + 文件对象 -> f.write(内容)
    -  java:  内容 -> 输入输出流对象  -> 文件对象 -> 内部读取并写入
         ByteArrayOutputStream
             read
             write
             finish/close
'''

# java/io/ByteArrayOutputStream-><init>()V

if (signature.equals("java/io/ByteArrayOutputStream-><init>()V")) {
    ByteArrayOutputStream obj = new ByteArrayOutputStream();
    return vm.resolveClass("java/io/ByteArrayOutputStream").newObject(obj);
}


# java/util/zip/GZIPOutputStream-><init>(Ljava/io/OutputStream;)V
if (signature.equals("java/util/zip/GZIPOutputStream-><init>(Ljava/io/OutputStream;)V")) {
    try {
        OutputStream chunk = (OutputStream) varArg.getObjectArg(0).getValue();
        GZIPOutputStream obj = new GZIPOutputStream(chunk);
        return vm.resolveClass("java/util/zip/GZIPOutputStream").newObject(obj);
    } catch (Exception e) {
        System.out.println("写入错误1" + e);
    }
}

# java/util/zip/GZIPOutputStream->write([B)V
public void callVoidMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
    if (signature.equals("java/util/zip/GZIPOutputStream->write([B)V")) {
        GZIPOutputStream obj = (GZIPOutputStream) dvmObject.getValue();
        byte[] chunk = (byte[]) varArg.getObjectArg(0).getValue();
        try {
            obj.write(chunk);
        } catch (Exception e) {
        }
        return;
    }
    if (signature.equals("java/util/zip/GZIPOutputStream->finish()V")) {
        GZIPOutputStream obj = (GZIPOutputStream) dvmObject.getValue();
        try {
            obj.finish();
        } catch (Exception e) {
        }
        return;
    }
    if (signature.equals("java/util/zip/GZIPOutputStream->close()V")) {
        GZIPOutputStream obj = (GZIPOutputStream) dvmObject.getValue();
        try {
            obj.close();
        } catch (Exception e) {
        }
        return;
    }
    super.callVoidMethod(vm, dvmObject, signature, varArg);
}

1.6 unidbg

package com.nb.demo;

import com.github.unidbg.AndroidEmulator;
import com.github.unidbg.Module;
import com.github.unidbg.linux.android.AndroidEmulatorBuilder;
import com.github.unidbg.linux.android.AndroidResolver;
import com.github.unidbg.linux.android.dvm.*;
import com.github.unidbg.linux.android.dvm.array.ArrayObject;
import com.github.unidbg.linux.android.dvm.array.ByteArray;
import com.github.unidbg.linux.android.dvm.jni.ProxyDvmObject;
import com.github.unidbg.memory.Memory;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.OutputStream;
import java.util.zip.GZIPOutputStream;

public class PDD extends AbstractJni {
    public static AndroidEmulator emulator;  // 静态属性，以后对象和类都可以直接使用
    public static Memory memory;
    public static VM vm;
    public static Module module;

    // 构造方法,以后这个代码，基本是固定的，只需要改app位置即可，其他不用动
    public PDD() {
        // 1.创建设备（32位或64位模拟器）， 具体看so文件在哪个目录。 在armeabi-v7a就选择32位
        // 传进设备时，如果是32位，后面so文件就要用32位，同理需要用64位的
        // 这个名字可以随便写,一般写成app的包名    以后可能会动
        emulator = AndroidEmulatorBuilder.for32Bit().setProcessName("com.che168.autotradercloud").build();
        // 2.获取内存对象（可以操作内存）
        memory = emulator.getMemory();
        // 3.设置安卓sdk版本（只支持19、23）
        memory.setLibraryResolver(new AndroidResolver(23));

        // 4.创建虚拟机（运行安卓代码需要虚拟机，就想运行py代码需要python解释器一样）    以后会动
        vm = emulator.createDalvikVM(new File("apks/pdd/v6.32.0.apk"));
        vm.setJni(this); // 后期补环境会用，把要补的环境，写在当前这个类中，执行这个代码即可，但是必须继承AbstractJni
        //vm.setVerbose(true); //是否展示调用过程的细节

        // 5.加载so文件
        DalvikModule dm = vm.loadLibrary(new File("apks/pdd/libpdd_secure.so"), false);   // 以后会动
        dm.callJNI_OnLoad(emulator); // jni开发动态注册，会执行JNI_OnLoad，如果是动态注册，需要执行一下这个，如果静态注册，这个不需要执行，车智赢案例是静态注册

        // 6.dm代表so文件，dm.getModule()得到module对象，基于module对象可以访问so中的成员。
        module = dm.getModule(); // 把so文件加载到内存后，后期可以获取基地址，偏移量等，该变量代指so文件

    }

    // sign 成员方法，用来破解加密
    public void sign() {
        // 找到java中native所在的类，并加载
        DvmClass DeviceNative = vm.resolveClass("com/xunmeng/pinduoduo/secure/DeviceNative");

        // 方法的符号表示
        String method = "info2(Landroid/content/Context;J)Ljava/lang/String;";

        // 执行类中的静态成员
        StringObject obj = DeviceNative.callStaticJniMethodObject(emulator, method, vm.resolveClass("android/content/Context").newObject(null), 122121121221L);

        String keyString = obj.getValue();
        System.out.println(keyString);

    }

    // 代码右键运行，创建一个main
    public static void main(String[] args) {
        PDD che = new PDD();
        che.sign();
    }


    @Override
    public void callStaticVoidMethodV(BaseVM vm, DvmClass dvmClass, String signature, VaList vaList) {
        // 1 腾讯日志库
        if (signature.equals("com/tencent/mars/xlog/PLog->i(Ljava/lang/String;Ljava/lang/String;)V")) {
            return;
        }

        super.callStaticVoidMethodV(vm, dvmClass, signature, vaList);
    }

    @Override
    public DvmObject<?> callStaticObjectMethodV(BaseVM vm, DvmClass dvmClass, String signature, VaList vaList) {
        if (signature.equals("com/xunmeng/pinduoduo/secure/EU->gad()Ljava/lang/String;")) {
            return new StringObject(vm, "7202111111112f2");
        }

        return super.callStaticObjectMethodV(vm, dvmClass, signature, vaList);
    }

    @Override
    public int callIntMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
        if (signature.equals("android/content/Context->checkSelfPermission(Ljava/lang/String;)I")) {
            // 1 取出第一个位置参数(String 类型)
            String str = (String) varArg.getObjectArg(0).getValue();
            // android.permission.READ_PHONE_STATE 拿的是手机状态
            // 获取方式一：我们可以通过hook拿到
            // 获取方式二：我们直接搜索写死
            // 获取方式三：我们自己写安卓应该，看自己手机的状态
//            System.out.println(str);
            return -1;
        }
        if (signature.equals("android/telephony/TelephonyManager->getSimState()I")) {
            /*
             * SIM的状态信息：
             *  SIM_STATE_UNKNOWN             未知状态 0
             *  SIM_STATE_ABSENT                 没插卡 1
             *  SIM_STATE_PIN_REQUIRED     锁定状态，需要用户的PIN码解锁 2
             *  SIM_STATE_PUK_REQUIRED    锁定状态，需要用户的PUK码解锁 3
             *  SIM_STATE_NETWORK_LOCKED   锁定状态，需要网络的PIN码解锁 4
             *  SIM_STATE_READY            就绪状态 5
             */
            return 5;
        }
        if (signature.equals("android/telephony/TelephonyManager->getNetworkType()I")) {
            // https://codeleading.com/article/33471321733/
            return 1;
        }
        if (signature.equals("android/telephony/TelephonyManager->getDataState()I")) {
            return 0;
        }

        if (signature.equals("android/telephony/TelephonyManager->getDataActivity()I")) {
            return 4;
        }
        return super.callIntMethod(vm, dvmObject, signature, varArg);
    }

    @Override
    public DvmObject<?> callObjectMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
        if (signature.equals("android/content/Context->getSystemService(Ljava/lang/String;)Ljava/lang/Object;")) {
            //1 取出第一个参数，是字符串
            String str = (String) varArg.getObjectArg(0).getValue();
            System.out.println("-----");
            System.out.println(str); // phone
        }
        if (signature.equals("android/content/Context->getSystemService(Ljava/lang/String;)Ljava/lang/Object;")) {
            // 虽然是Object类型，但是作为安卓开发知道是：TelephonyManager 类型，我们直接补
            return vm.resolveClass("android/telephony/TelephonyManager").newObject(null); //不能用ProxyDvmObject.createObject(vm,null) 补
        }

        if (signature.equals("android/telephony/TelephonyManager->getSimOperatorName()Ljava/lang/String;")) {
            return new StringObject(vm, "中国电信"); // 运营商
        }

        if (signature.equals("android/telephony/TelephonyManager->getSimCountryIso()Ljava/lang/String;")) {
            return new StringObject(vm, "cn");
        }
        if (signature.equals("android/telephony/TelephonyManager->getNetworkOperator()Ljava/lang/String;")) {
            //https://blog.csdn.net/ztp800201/article/details/44198031/
            return new StringObject(vm, "46003");
        }
        if (signature.equals("android/telephony/TelephonyManager->getNetworkOperatorName()Ljava/lang/String;")) {
            //https://blog.csdn.net/Myfittinglife/article/details/118685804
            return new StringObject(vm, "中国电信");
        }
        if (signature.equals("android/telephony/TelephonyManager->getNetworkCountryIso()Ljava/lang/String;")) {
            // 获取国家代码
            return new StringObject(vm, "cn");
        }


        if (signature.equals("java/lang/Throwable->getStackTrace()[Ljava/lang/StackTraceElement;")) {
            return new ArrayObject(vm.resolveClass("java/lang/StackTraceElement").newObject(null));
        }

        if (signature.equals("java/lang/StackTraceElement->getClassName()Ljava/lang/String;")) {
            return new StringObject(vm, "");
        }


        if (signature.equals("java/io/ByteArrayOutputStream->toByteArray()[B")) {
            ByteArrayOutputStream obj = (ByteArrayOutputStream) dvmObject.getValue();

            return new ByteArray(vm, obj.toByteArray());
        }
        return super.callObjectMethod(vm, dvmObject, signature, varArg);
    }

    @Override
    public boolean callStaticBooleanMethod(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
        if (signature.equals("android/os/Debug->isDebuggerConnected()Z")) {
            return false;
        }
        return super.callStaticBooleanMethod(vm, dvmClass, signature, varArg);
    }

    @Override
    public DvmObject<?> newObject(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
        if (signature.equals("java/lang/Throwable-><init>()V")) {
            Throwable t = new Throwable(); // 可以new出来，可以传null
            return vm.resolveClass("java/lang/Throwable").newObject(t);
        }
        if (signature.equals("java/io/ByteArrayOutputStream-><init>()V")) {
            ByteArrayOutputStream obj = new ByteArrayOutputStream();
            return vm.resolveClass("java/io/ByteArrayOutputStream").newObject(obj);
        }
        if (signature.equals("java/util/zip/GZIPOutputStream-><init>(Ljava/io/OutputStream;)V")) {
            try {
                OutputStream chunk = (OutputStream) varArg.getObjectArg(0).getValue();
                GZIPOutputStream obj = new GZIPOutputStream(chunk);
                return vm.resolveClass("java/util/zip/GZIPOutputStream").newObject(obj);
            } catch (Exception e) {
                System.out.println("写入错误1" + e);
            }
        }


        return super.newObject(vm, dvmClass, signature, varArg);
    }

    @Override
    public DvmObject<?> callObjectMethodV(BaseVM vm, DvmObject<?> dvmObject, String signature, VaList vaList) {
        if (signature.equals("java/lang/String->replaceAll(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;")) {
            String origin = (String) dvmObject.getValue();
            String a0 = (String) vaList.getObjectArg(0).getValue();
            String a1 = (String) vaList.getObjectArg(1).getValue();
            String result = origin.replaceAll(a0, a1);
            return new StringObject(vm, result);
        }
        return super.callObjectMethodV(vm, dvmObject, signature, vaList);
    }

    @Override
    public void callVoidMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
        if (signature.equals("java/util/zip/GZIPOutputStream->write([B)V")) {
            GZIPOutputStream obj = (GZIPOutputStream) dvmObject.getValue();
            byte[] chunk = (byte[]) varArg.getObjectArg(0).getValue();
            try {
                obj.write(chunk);
            } catch (Exception e) {
            }
            return;
        }
        if (signature.equals("java/util/zip/GZIPOutputStream->finish()V")) {
            GZIPOutputStream obj = (GZIPOutputStream) dvmObject.getValue();
            try {
                obj.finish();
            } catch (Exception e) {
            }
            return;
        }
        if (signature.equals("java/util/zip/GZIPOutputStream->close()V")) {
            GZIPOutputStream obj = (GZIPOutputStream) dvmObject.getValue();
            try {
                obj.close();
            } catch (Exception e) {
            }
            return;
        }
        super.callVoidMethod(vm, dvmObject, signature, varArg);
    }
}

二主动调用

2.0 概念

# 之前调用方法，只能掉 nativate方法-- so文件中的具体某个方法是掉不了的
DvmClass CheckSignUtil = vm.resolveClass("com/xunmeng/pinduoduo/secure/DeviceNative");
String method = "info2(Landroid/content/Context;J)Ljava/lang/String;";
StringObject obj = CheckSignUtil.callStaticJniMethodObject(
    emulator,
    method,
    vm.resolveClass("android/content/Context").newObject(null),
    1700834524073L
);
// 4 得到结果，打印出来
String result = obj.getValue();
System.out.println(result);


# 以后通过这种方式调用so文件中具体的某个方法
Number number = module.callFunction(
    emulator,
    "Java_com_yoloho_libcore_util_Crypt_encrypt_1data",
    vm.getJNIEnv(),
    vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")),
    0,
    vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504eHjtL0AQ==")),
    85
);
int result = number.intValue();
String v = (String) vm.getObject(result).getValue();
System.out.println(v);

2.1 回顾

在之前的案例中，我们是基于 native方法的签名的方式来执行so中的方法，例如：

如果在逆向过程中，你想要主动调用so中的某个函数，例如：只想要调用 sub_1DA0，看看他有什么作用。那么你就可以学习本节的内容。

2.2 常见表示

符号名称（是汇编中名称，非函数名）
1
Java_com_yoloho_libcore_util_Crypt_encrypt_1data

偏移地址（32位需+1）

1
2
3

0x2414

与地址不同， 地址 = 基址 + 偏移地址

Symbol对象（根据符号名称找到对象）

1	Symbol symbol = module.findSymbolByName("Java_com_yoloho_libcore_util_Crypt_encrypt_1data");

// 1.偏移地址 0x40002414
long addr = symbol.getAddress();
System.out.println(Long.toHexString(addr));

// 2.指针对象  RX@0x40002414[libCrypt.so]0x2414
UnidbgPointer ptr = (UnidbgPointer)symbol.createPointer(emulator);
System.out.println(ptr.toString());

注意：如果只主动加载一个SO，其基址恒为0x40000000，可以在 com/github/unidbg/memory/Memory.java 中做修改

2.3 callFunction

基于符号调用

Number number = module.callFunction(
    emulator,
    "Java_com_yoloho_libcore_util_Crypt_encrypt_1data",
    vm.getJNIEnv(),
    vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")),
    0,
    vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504eHjtL0AQ==")),
    85
);
int result = number.intValue();
String v = (String) vm.getObject(result).getValue();
System.out.println(v);

基于偏移量调用

Number number = module.callFunction(
        emulator,
        0x2414,
        vm.getJNIEnv(),
        vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")),
        0,
        vm.addLocalObject(new StringObject(vm, "64e6176e45397c5...lKpHjtL0AQ==")),
        85
);
int result = number.intValue();
String v = (String) vm.getObject(result).getValue();
System.out.println(v);

2.3 案例

package com.nb.demo;

import com.github.unidbg.AndroidEmulator;
import com.github.unidbg.Module;
import com.github.unidbg.Symbol;
import com.github.unidbg.linux.android.AndroidEmulatorBuilder;
import com.github.unidbg.linux.android.AndroidResolver;
import com.github.unidbg.linux.android.dvm.*;
import com.github.unidbg.memory.Memory;
import com.github.unidbg.pointer.UnidbgPointer;
import com.github.unidbg.utils.Inspector;

import java.io.File;
import java.util.ArrayList;
import java.util.List;


public class DaYiMa2 extends AbstractJni {
    public static AndroidEmulator emulator;
    public static Memory memory;
    public static VM vm;
    public static DalvikModule dm;
    public static Module module;

    DaYiMa2() {

        // 1.创建设备（32位或64位模拟器）， 具体看so文件在哪个目录。 在armeabi-v7a就选择32位
        emulator = AndroidEmulatorBuilder.for64Bit().setProcessName("com.che168.autotradercloud").build();

        // 2.获取内存对象（可以操作内存）
        memory = emulator.getMemory();

        // 3.设置安卓sdk版本（只支持19、23）
        memory.setLibraryResolver(new AndroidResolver(23));

        // 4.创建虚拟机（运行安卓代码需要虚拟机，就想运行py代码需要python解释器一样）
        vm = emulator.createDalvikVM(new File("unidbg-android/apks/dayima/v8.6.0.apk"));
        vm.setJni(this);
        //vm.setVerbose(true); //是否展示调用过程的细节

        // 5.加载so文件
        DalvikModule dm = vm.loadLibrary(new File("unidbg-android/apks/dayima/libCrypt.so"), false);
        //dm.callJNI_OnLoad(emulator);

        // 6.dm代表so文件，dm.getModule()得到module对象，基于module对象可以访问so中的成员。
        module = dm.getModule();

    }

    public static void main(String[] args) {
        DaYiMa2 obj = new DaYiMa2();
        obj.sign1();
        obj.sign2();
    }
    public void sign(){
        Symbol symbol = module.findSymbolByName("Java_com_yoloho_libcore_util_Crypt_encrypt_1data");
        // 1.偏移地址 0x40002414
        long addr = symbol.getAddress();
        System.out.println(Long.toHexString(addr));

        // 2.指针对象  RX@0x40002414[libCrypt.so]0x2414
        UnidbgPointer ptr = (UnidbgPointer) symbol.createPointer(emulator);
        System.out.println(ptr.toString());


        for (Module module : emulator.getMemory().getLoadedModules()) {
            Symbol target = module.findSymbolByName("_1data", false);
            System.out.println(target.getName());
            break;
        }

    }

    public void sign1() {
        Number number = module.callFunction(
                emulator,
                "Java_com_yoloho_libcore_util_Crypt_encrypt_1data",
                vm.getJNIEnv(),
                vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")),
                0,
                vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==")),
                85
        );
        int result = number.intValue();
        String v = (String) vm.getObject(result).getValue();
        System.out.println(v);

    }

    public void sign2() {

        Number number = module.callFunction(
                emulator,
                0x2414,
                vm.getJNIEnv(),
                vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")),
                0,
                vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==")),
                85
        );
        int result = number.intValue();
        String v = (String) vm.getObject(result).getValue();
        System.out.println(v);

    }
}

2.4 参数形式

当调用so中的方法时，如果想要传参数，可以基于两种方式：

普通的位置传参

Number number = module.callFunction(
        emulator,
        0x2414,
        vm.getJNIEnv(),
        vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")),
        0,
        vm.addLocalObject(new StringObject(vm, "64e6176e45397c5..MlKpHjtL0AQ==")),
        85
);
int result = number.intValue();
String v = (String) vm.getObject(result).getValue();
System.out.println(v);

Array形式

List<Object> args = new ArrayList<>();
args.add(vm.getJNIEnv()); // 第一个参数是env
args.add(vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")));
args.add(0);
args.add(vm.addLocalObject(new StringObject(vm, "64e6176e4KaCsUMlKpHjtL0AQ==")));
args.add(85);

Number number = module.callFunction(
        emulator,
        0x2414, // 32位+1
        args.toArray()
);
int result = number.intValue();
String v = (String) vm.getObject(result).getValue();
System.out.println(v);

2.5 案例

package com.nb.demo;

import com.github.unidbg.AndroidEmulator;
import com.github.unidbg.Module;
import com.github.unidbg.Symbol;
import com.github.unidbg.linux.android.AndroidEmulatorBuilder;
import com.github.unidbg.linux.android.AndroidResolver;
import com.github.unidbg.linux.android.dvm.*;
import com.github.unidbg.memory.Memory;
import com.github.unidbg.pointer.UnidbgPointer;
import com.github.unidbg.utils.Inspector;

import java.io.File;
import java.util.ArrayList;
import java.util.List;


public class DaYiMa2 extends AbstractJni {
    public static AndroidEmulator emulator;
    public static Memory memory;
    public static VM vm;
    public static DalvikModule dm;
    public static Module module;

    DaYiMa2() {

        // 1.创建设备（32位或64位模拟器）， 具体看so文件在哪个目录。 在armeabi-v7a就选择32位
        emulator = AndroidEmulatorBuilder.for64Bit().setProcessName("com.che168.autotradercloud").build();

        // 2.获取内存对象（可以操作内存）
        memory = emulator.getMemory();

        // 3.设置安卓sdk版本（只支持19、23）
        memory.setLibraryResolver(new AndroidResolver(23));

        // 4.创建虚拟机（运行安卓代码需要虚拟机，就想运行py代码需要python解释器一样）
        vm = emulator.createDalvikVM(new File("unidbg-android/apks/dayima/v8.6.0.apk"));
        vm.setJni(this);
        //vm.setVerbose(true); //是否展示调用过程的细节

        // 5.加载so文件
        DalvikModule dm = vm.loadLibrary(new File("unidbg-android/apks/dayima/libCrypt.so"), false);
        //dm.callJNI_OnLoad(emulator);

        // 6.dm代表so文件，dm.getModule()得到module对象，基于module对象可以访问so中的成员。
        module = dm.getModule();

    }

    public static void main(String[] args) {
        DaYiMa2 obj = new DaYiMa2();
        obj.sign1();
        obj.sign2();
        obj.sign3();
        obj.sign4();
    }
    public void sign(){
        Symbol symbol = module.findSymbolByName("Java_com_yoloho_libcore_util_Crypt_encrypt_1data");
        // 1.偏移地址 0x40002414
        long addr = symbol.getAddress();
        System.out.println(Long.toHexString(addr));

        // 2.指针对象  RX@0x40002414[libCrypt.so]0x2414
        UnidbgPointer ptr = (UnidbgPointer) symbol.createPointer(emulator);
        System.out.println(ptr.toString());


        for (Module module : emulator.getMemory().getLoadedModules()) {
            Symbol target = module.findSymbolByName("_1data", false);
            System.out.println(target.getName());
            break;
        }

    }

    public void sign1() {
        Number number = module.callFunction(
                emulator,
                "Java_com_yoloho_libcore_util_Crypt_encrypt_1data",
                vm.getJNIEnv(),
                vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")),
                0,
                vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==")),
                85
        );
        int result = number.intValue();
        String v = (String) vm.getObject(result).getValue();
        System.out.println(v);

    }

    public void sign2() {

        Number number = module.callFunction(
                emulator,
                0x2414,
                vm.getJNIEnv(),
                vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")),
                0,
                vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==")),
                85
        );
        int result = number.intValue();
        String v = (String) vm.getObject(result).getValue();
        System.out.println(v);

    }

    public void sign3() {
        List<Object> args = new ArrayList<>();
        args.add(vm.getJNIEnv()); // 第一个参数是env
        args.add(vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")));
        args.add(0);
        args.add(vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==")));
        args.add(85);

        Number number = module.callFunction(
                emulator,
                "Java_com_yoloho_libcore_util_Crypt_encrypt_1data",
                args.toArray()
        );
        int result = number.intValue();
        String v = (String) vm.getObject(result).getValue();
        System.out.println(v);

    }

    public void sign4() {
        List<Object> args = new ArrayList<>();
        args.add(vm.getJNIEnv()); // 第一个参数是env
        args.add(vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")));
        args.add(0);
        args.add(vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==")));
        args.add(85);

        Number number = module.callFunction(
                emulator,
                0x2414, // 32位+1
                args.toArray()
        );
        int result = number.intValue();
        String v = (String) vm.getObject(result).getValue();
        System.out.println(v);

    }
}

2.6 大姨妈案例

2.6.1 执行方法（java类型）

package com.nb.demo;

import com.github.unidbg.AndroidEmulator;
import com.github.unidbg.Module;
import com.github.unidbg.Symbol;
import com.github.unidbg.linux.android.AndroidEmulatorBuilder;
import com.github.unidbg.linux.android.AndroidResolver;
import com.github.unidbg.linux.android.dvm.*;
import com.github.unidbg.memory.Memory;
import com.github.unidbg.pointer.UnidbgPointer;
import com.github.unidbg.utils.Inspector;

import java.io.File;
import java.util.ArrayList;
import java.util.List;


public class DaYiMa2 extends AbstractJni {
    public static AndroidEmulator emulator;
    public static Memory memory;
    public static VM vm;
    public static DalvikModule dm;
    public static Module module;

    DaYiMa2() {

        // 1.创建设备（32位或64位模拟器）， 具体看so文件在哪个目录。 在armeabi-v7a就选择32位
        emulator = AndroidEmulatorBuilder.for64Bit().setProcessName("com.che168.autotradercloud").build();

        // 2.获取内存对象（可以操作内存）
        memory = emulator.getMemory();

        // 3.设置安卓sdk版本（只支持19、23）
        memory.setLibraryResolver(new AndroidResolver(23));

        // 4.创建虚拟机（运行安卓代码需要虚拟机，就想运行py代码需要python解释器一样）
        vm = emulator.createDalvikVM(new File("unidbg-android/apks/dayima/v8.6.0.apk"));
        vm.setJni(this);
        //vm.setVerbose(true); //是否展示调用过程的细节

        // 5.加载so文件
        DalvikModule dm = vm.loadLibrary(new File("unidbg-android/apks/dayima/libCrypt.so"), false);
        //dm.callJNI_OnLoad(emulator);

        // 6.dm代表so文件，dm.getModule()得到module对象，基于module对象可以访问so中的成员。
        module = dm.getModule();

    }

    public static void main(String[] args) {
        DaYiMa2 obj = new DaYiMa2();
        obj.sign1();
        obj.sign2();
        obj.sign3();
        obj.sign4();
    }

    public void sign1() {
        Number number = module.callFunction(
                emulator,
                "Java_com_yoloho_libcore_util_Crypt_encrypt_1data",
                vm.getJNIEnv(),
                vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")),
                0,
                vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==")),
                85
        );
        int result = number.intValue();
        String v = (String) vm.getObject(result).getValue();
        System.out.println(v);

    }

    public void sign2() {

        Number number = module.callFunction(
                emulator,
                0x2414,
                vm.getJNIEnv(),
                vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")),
                0,
                vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==")),
                85
        );
        int result = number.intValue();
        String v = (String) vm.getObject(result).getValue();
        System.out.println(v);

    }

    public void sign3() {
        List<Object> args = new ArrayList<>();
        args.add(vm.getJNIEnv()); // 第一个参数是env
        args.add(vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")));
        args.add(0);
        args.add(vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==")));
        args.add(85);

        Number number = module.callFunction(
                emulator,
                "Java_com_yoloho_libcore_util_Crypt_encrypt_1data",
                args.toArray()
        );
        int result = number.intValue();
        String v = (String) vm.getObject(result).getValue();
        System.out.println(v);

    }

    public void sign4() {
        List<Object> args = new ArrayList<>();
        args.add(vm.getJNIEnv()); // 第一个参数是env
        args.add(vm.addLocalObject(vm.resolveClass("com/yoloho/libcore/util/Crypt")));
        args.add(0);
        args.add(vm.addLocalObject(new StringObject(vm, "64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==")));
        args.add(85);

        Number number = module.callFunction(
                emulator,
                0x2414, // 32位+1
                args.toArray()
        );
        int result = number.intValue();
        String v = (String) vm.getObject(result).getValue();
        System.out.println(v);

    }
}

2.6.2 执行方法（c类型）

package com.nb.demo;

import com.github.unidbg.AndroidEmulator;
import com.github.unidbg.Emulator;
import com.github.unidbg.Module;
import com.github.unidbg.Symbol;
import com.github.unidbg.arm.context.RegisterContext;
import com.github.unidbg.hook.hookzz.HookEntryInfo;
import com.github.unidbg.hook.hookzz.HookZz;
import com.github.unidbg.hook.hookzz.IHookZz;
import com.github.unidbg.hook.hookzz.WrapCallback;
import com.github.unidbg.linux.android.AndroidEmulatorBuilder;
import com.github.unidbg.linux.android.AndroidResolver;
import com.github.unidbg.linux.android.dvm.AbstractJni;
import com.github.unidbg.linux.android.dvm.DalvikModule;
import com.github.unidbg.linux.android.dvm.StringObject;
import com.github.unidbg.linux.android.dvm.VM;
import com.github.unidbg.memory.Memory;
import com.github.unidbg.pointer.UnidbgPointer;
import com.github.unidbg.utils.Inspector;
import com.sun.jna.Pointer;

import java.io.File;
import java.util.ArrayList;
import java.util.List;


public class DaYiMa3 extends AbstractJni {
    public static AndroidEmulator emulator;
    public static Memory memory;
    public static VM vm;
    public static DalvikModule dm;
    public static Module module;

    DaYiMa3() {

        // 1.创建设备（32位或64位模拟器）， 具体看so文件在哪个目录。 在armeabi-v7a就选择32位
        emulator = AndroidEmulatorBuilder.for64Bit().setProcessName("com.che168.autotradercloud").build();

        // 2.获取内存对象（可以操作内存）
        memory = emulator.getMemory();

        // 3.设置安卓sdk版本（只支持19、23）
        memory.setLibraryResolver(new AndroidResolver(23));

        // 4.创建虚拟机（运行安卓代码需要虚拟机，就想运行py代码需要python解释器一样）
        vm = emulator.createDalvikVM(new File("unidbg-android/apks/dayima/v8.6.0.apk"));
        vm.setJni(this);
        //vm.setVerbose(true); //是否展示调用过程的细节

        // 5.加载so文件
        DalvikModule dm = vm.loadLibrary(new File("unidbg-android/apks/dayima/libCrypt.so"), false);
        //dm.callJNI_OnLoad(emulator);

        // 6.dm代表so文件，dm.getModule()得到module对象，基于module对象可以访问so中的成员。
        module = dm.getModule();

    }

    public static void main(String[] args) {
        DaYiMa3 obj = new DaYiMa3();
        obj.call_1();
    }


    public void call_1() {
        int v7 = 0;

        UnidbgPointer v9 = memory.malloc(100, false).getPointer();
        v9.write("64e6176e45397c5989504e76f98ecf2e63b2679euser/login15131255555A4rE0CKaCsUMlKpHjtL0AQ==".getBytes());

        int v8 = 85;

        UnidbgPointer v11 = memory.malloc(100, false).getPointer();

        module.callFunction(
                emulator,
                0x1DA0,
                v7,
                v9,
                v8,
                v11
        );

        System.out.println( v11.getString(0) );
        // byte[] bArr = v11.getByteArray(0,100);
        // Inspector.inspect(bArr,"结果");
    }

}

三打包

3.1 配置

3.2 车智赢获取秘钥案例–无输入参数

3.2.1 编译

# 构建成jar文件--》发现在项目根路径下出现out文件夹，如下

##### 注意把apks文件夹复制过来####

# unidbg-0.9.7.jar为主运行的jar包

3.3 终端调用

1	java -jar unidbg-0.9.7.jar

3.4 python调用

import subprocess

cmd = f"java -jar  unidbg-0.9.7.jar"
signature = subprocess.check_output(cmd, shell=True, cwd="unidbg_0_9_7_jar")
data_string = signature.strip().decode('utf-8')
print("加密结果为：",data_string)

3.3 B站案例

3.3.1 参数化和注意事项

## 因为要使用python调用，我们需要把参数动态传递个jar包
## java中通过main函数中的String[] args 数组获取
# 例如： 
	终端调用：java -jar unidbg.jar name=justin
	java中获取 String argString = args[0];

####  注意事项 #### 
1 参数中如果包含   &   空格 都有问题，
	java -jar unidbg.jar  name=justin&age=19  #把&解析成空格
	java -jar unidbg.jar  name=justin age=999 # 把空格解析完后，认为传了两个args[0]只能取出第一个
   
    所以用双引号引起来传递进去
       
2 字符串特别长，终端不支持
    - 写入文件   shihuo.txt
    - java -jar unidbg.jar  shihuo.txt
    - java代码中
    public static void main(String[] args){
        args[0] # 取出文件名，使用java打开文件读出，再用
        ...
    }
    
3 python -> java 只能是字符串形式

3.3.2 修改代码

package com.nb.demo;

import com.github.unidbg.AndroidEmulator;
import com.github.unidbg.Module;
import com.github.unidbg.linux.android.AndroidEmulatorBuilder;
import com.github.unidbg.linux.android.AndroidResolver;
import com.github.unidbg.linux.android.dvm.*;
import com.github.unidbg.linux.android.dvm.jni.ProxyDvmObject;
import com.github.unidbg.memory.Memory;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;


// 正常完成copy过来，里面可能有些别的引用---》能copy就copy，不能copy的就自己写
class SignedQuery {

    public static final String KEY_VALUE_DELIMITER = "=";
    public static final String FIELD_DELIMITER = "&";

    private static final char[] a = "0123456789ABCDEF".toCharArray();
    public final String rawParams;
    public final String sign;

    public SignedQuery(String str, String str2) {
        this.rawParams = str;
        this.sign = str2;
    }

    private static boolean a(char c2, String str) {
        return (c2 >= 'A' && c2 <= 'Z') || (c2 >= 'a' && c2 <= 'z') || !((c2 < '0' || c2 > '9') && "-_.~".indexOf(c2) == -1 && (str == null || str.indexOf(c2) == -1));
    }

    static String b(String str) {
        return c(str, null);
    }

    static String c(String str, String str2) {
        StringBuilder sb = null;
        if (str == null) {
            return null;
        }
        int length = str.length();
        int i = 0;
        while (i < length) {
            int i2 = i;
            while (i2 < length && a(str.charAt(i2), str2)) {
                i2++;
            }
            if (i2 != length) {
                if (sb == null) {
                    sb = new StringBuilder();
                }
                if (i2 > i) {
                    sb.append((CharSequence) str, i, i2);
                }
                i = i2 + 1;
                while (i < length && !a(str.charAt(i), str2)) {
                    i++;
                }
                try {
                    byte[] bytes = str.substring(i2, i).getBytes("UTF-8");
                    int length2 = bytes.length;
                    for (int i3 = 0; i3 < length2; i3++) {
                        sb.append('%');
                        char[] cArr = a;
                        sb.append(cArr[(bytes[i3] & 240) >> 4]);
                        sb.append(cArr[bytes[i3] & 15]);
                    }
                } catch (UnsupportedEncodingException e2) {
                    throw new AssertionError(e2);
                }
            } else if (i == 0) {
                return str;
            } else {
                sb.append((CharSequence) str, i, length);
                return sb.toString();
            }
        }
        return sb == null ? str : sb.toString();
    }

    static String r(Map<String, String> map) {
        if (!(map instanceof SortedMap)) {
            map = new TreeMap(map);
        }
        StringBuilder sb = new StringBuilder(256);
        for (Map.Entry<String, String> entry : map.entrySet()) {
            String key = entry.getKey();
            if (!key.isEmpty()) {
                sb.append(b(key));
                sb.append(KEY_VALUE_DELIMITER);
                String value = entry.getValue();
                sb.append(value == null ? "" : b(value));
                sb.append(FIELD_DELIMITER);
            }
        }
        int length = sb.length();
        if (length > 0) {
            sb.deleteCharAt(length - 1);
        }
        if (length == 0) {
            return null;
        }
        return sb.toString();
    }

    public String toString() {
        String str = this.rawParams;
        if (str == null) {
            return "";
        }
        if (this.sign == null) {
            return str;
        }
        return this.rawParams + "&sign=" + this.sign;
    }
}


public class Bili2 extends AbstractJni {
    public static AndroidEmulator emulator;  // 静态属性，以后对象和类都可以直接使用
    public static Memory memory;
    public static VM vm;
    public static Module module;

    public Bili2() {
        emulator = AndroidEmulatorBuilder.for32Bit().setProcessName("com.bili").build();
        // 2.获取内存对象（可以操作内存）
        memory = emulator.getMemory();
        // 3.设置安卓sdk版本（只支持19、23）
        memory.setLibraryResolver(new AndroidResolver(23));

        // 4.创建虚拟机（运行安卓代码需要虚拟机，就想运行py代码需要python解释器一样）    以后会动
        vm = emulator.createDalvikVM(new File("apks/bili/v6240.apk"));
        vm.setJni(this); // 后期补环境会用，把要补的环境，写在当前这个类中，执行这个代码即可，但是必须继承AbstractJni
        //vm.setVerbose(true); //是否展示调用过程的细节

        // 5.加载so文件
        DalvikModule dm = vm.loadLibrary(new File("apks/bili/libbili.so"), false);   // 以后会动
        dm.callJNI_OnLoad(emulator); // jni开发动态注册，会执行JNI_OnLoad，如果是动态注册，需要执行一下这个，如果静态注册，这个不需要执行，车智赢案例是静态注册

        // 6.dm代表so文件，dm.getModule()得到module对象，基于module对象可以访问so中的成员。
        module = dm.getModule(); // 把so文件加载到内存后，后期可以获取基地址，偏移量等，该变量代指so文件

    }

    private static Map<String, String> convertStringToMap(String inputString) {
        Map<String, String> map = new HashMap<>();
        String[] keyValuePairs = inputString.split("&");

        for (String pair : keyValuePairs) {
            String[] entry = pair.split("=");
            String key = entry[0];
            String value = entry.length > 1 ? entry[1] : null;
            map.put(key, value);
        }

        return map;
    }

    public void sign(String str) {
        //  str:actual_played_time=0&aid=466565149&appkey=1d8b6e7d45233436&auto_play=0&ts=1647952932

        Map<String, String> map = convertStringToMap(str);

        // 打印结果
        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }

        // 1 找到类
        DvmClass LibBili = vm.resolveClass("com/bilibili/nativelibrary/LibBili");
        // 2 找到方法和签名
        String method = "s(Ljava/util/SortedMap;)Lcom/bilibili/nativelibrary/SignedQuery;";

        // 3 调用
        DvmObject<?> obj = LibBili.callStaticJniMethodObject(
                emulator,
                method,
                ProxyDvmObject.createObject(vm, map) // map需要包裹
        );

        // 4 打印结果
        String res = obj.getValue().toString();
        System.out.println(res);

    }

    // 代码右键运行，创建一个main
    public static void main(String[] args) {
        // python调用时，传入的参数取出来
        String str = args[0]; //actual_played_time=0&aid=466565149&appkey=1d8b6e7d45233436&auto_play=0&ts=1647952932
        Bili2 che = new Bili2();
        che.sign(str);
    }

    // 补环境

    @Override
    public boolean callBooleanMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
        if (signature.equals("java/util/Map->isEmpty()Z")) {
            //1  c中调用java中 的isEmpty 包错了
            // 2 map 调用 isEmpty 报了错--需要补环境
            // java开发会懂，这是在判断map是否为空，反回true或false
            //return true;  // 写死为true---》不好处---》即便这个map是空的，c在调的时候，返回true，c认为有值--》可能会出错

            // 我们自己主动调用---》拿到c中的map---》如何取到c中的map

            // 咱么要拿map需要从dvmObject 中拿，调用方法 isEmpty 如果有参数，放在了varArg里面
            Map m = (Map) dvmObject.getValue();
//            System.out.println(m);
            return m.isEmpty();

        }
        return super.callBooleanMethod(vm, dvmObject, signature, varArg);
    }

    @Override
    public DvmObject<?> callObjectMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
        if (signature.equals("java/util/Map->get(Ljava/lang/Object;)Ljava/lang/Object;")) {
            // map 根据key取值，得到value报错了
            // 1 拿出map
            Map m = (Map) dvmObject.getValue();
            // 2 拿出调用 get的第一个参数
            // Object key = (Object)varArg.getObjectArg(0).getValue();
            String key = (String) varArg.getObjectArg(0).getValue();
//            System.out.println(key);
            // 方案一
            //Object value=m.get(key);  // 但实际上value是字符串
            //return ProxyDvmObject.createObject(vm,value);

            // 方案二
            String value = (String) m.get(key);
            return new StringObject(vm, value);

        }
        return super.callObjectMethod(vm, dvmObject, signature, varArg);
    }

    @Override
    public DvmObject<?> callStaticObjectMethod(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
        if (signature.equals("com/bilibili/nativelibrary/SignedQuery->r(Ljava/util/Map;)Ljava/lang/String;")) {
            // SignedQuery的对象调用r方法--》传入了map--》返回了String，报错了
            // SignedQuery 是app自己的---》遇到这个应该怎么做，自己写个类--》完全实现人家源码中SignedQuery 类---》反编译把别人的copy过来即可
            // 类直接调用r方法，因为r是静态方法--》调用对象的 r 方法--》传入参数[varArg],把返回值返回即可
            Map m = (Map) varArg.getObjectArg(0).getValue();
            String res = SignedQuery.r(m);
            return new StringObject(vm, res);

        }
        return super.callStaticObjectMethod(vm, dvmClass, signature, varArg);
    }

    @Override
    public DvmObject<?> newObject(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
        if (signature.equals("com/bilibili/nativelibrary/SignedQuery-><init>(Ljava/lang/String;Ljava/lang/String;)V")) {
            // 调用 SignedQuery的构造方法---》传入两个参数---》之前读反编译代码---》第二个参数就是sign

            // 方案一：直接得到秘钥
//            String sign=(String) varArg.getObjectArg(1).getValue();
//            System.out.println(sign);
//            // 为了阻止它报错---》返回一个空的SignedQuery
//            return vm.resolveClass("com/bilibili/nativelibrary/SignedQuery").newObject(null);

            // 方案二：完成整个流程
            String str = (String) varArg.getObjectArg(0).getValue();
            String sign = (String) varArg.getObjectArg(1).getValue();
            SignedQuery sq = new SignedQuery(str, sign);
            return vm.resolveClass("com/bilibili/nativelibrary/SignedQuery").newObject(sq);

        }
        return super.newObject(vm, dvmClass, signature, varArg);
    }
}

3.3.3 编译

3.3.4 终端调用

1	java -jar unidbg-0.9.7.jar "actual_played_time=0&aid=466565149&appkey=1d8b6e7d45233436&auto_play=0&ts=1647952932"

3.3.5 python调用

import subprocess
body = "actual_played_time=0&aid=466565149&appkey=1d8b6e7d45233436&auto_play=0&ts=1647952932"
cmd = f'java -jar  unidbg-0.9.7.jar "{body}"'
signature = subprocess.check_output(cmd, shell=True, cwd="unidbg_0_9_7_jar")
data_string = signature.strip().decode('utf-8').split("\n")[-1]
print("加密结果为：",data_string)

3.4 识货案例

1	加密文本太长，所以选择把他放在一个文件，让unidbg去读取文件的内容

3.4.1 修改代码

package com.nb.demo;

import com.github.unidbg.AndroidEmulator;
import com.github.unidbg.Module;
import com.github.unidbg.linux.android.AndroidEmulatorBuilder;
import com.github.unidbg.linux.android.AndroidResolver;
import com.github.unidbg.linux.android.dvm.*;
import com.github.unidbg.linux.android.dvm.array.ByteArray;
import com.github.unidbg.memory.Memory;

import java.io.File;
import java.io.FileReader;
import java.util.Base64;

public class ShiHuo2 extends AbstractJni {
    public static AndroidEmulator emulator;
    public static Memory memory;
    public static VM vm;
    public static Module module;

    public ShiHuo2() {
        emulator = AndroidEmulatorBuilder.for32Bit().setProcessName("com.shihuo").build();
        // 2.获取内存对象（可以操作内存）
        memory = emulator.getMemory();
        // 3.设置安卓sdk版本（只支持19、23）
        memory.setLibraryResolver(new AndroidResolver(23));

        // 4.创建虚拟机（运行安卓代码需要虚拟机，就想运行py代码需要python解释器一样）    以后会动
        vm = emulator.createDalvikVM(new File("apks/shihuo/v7.20.1.apk"));
        vm.setJni(this); // 后期补环境会用，把要补的环境，写在当前这个类中，执行这个代码即可，但是必须继承AbstractJni
        //vm.setVerbose(true); //是否展示调用过程的细节

        // 5.加载so文件
        DalvikModule dm = vm.loadLibrary(new File("apks/shihuo/libdusanwa.so"), false);   // 以后会动
        dm.callJNI_OnLoad(emulator); // jni开发动态注册，会执行JNI_OnLoad，如果是动态注册，需要执行一下这个，如果静态注册，这个不需要执行，车智赢案例是静态注册

        // 6.dm代表so文件，dm.getModule()得到module对象，基于module对象可以访问so中的成员。
        module = dm.getModule(); // 把so文件加载到内存后，后期可以获取基地址，偏移量等，该变量代指so文件

    }

    // sign 成员方法，用来破解加密
    public String sign(String fileName) {

        String filePath = "apks" + File.separator + "shihuo" + File.separator + fileName;
        String body = readFileBody(filePath);

        byte[] bArr = Base64.getUrlDecoder().decode(body);
        // 3 调用 so --》heracles--》把结果传入
        DvmClass SwSdk = vm.resolveClass("com/shizhuang/dusanwa/main/SwSdk");
        String method = "heracles([BII)[B";
        ByteArray byteValues = SwSdk.callStaticJniMethodObject(
                emulator,
                method,
                new ByteArray(vm, bArr),
                0,
                0
        );
        // 4 返回的byte数组，转成字符串就是明文
        byte[] info = byteValues.getValue(); //取到具体的值
        String data = new String(info);
        return data;


    }

    public static void main(String[] args) {
        ShiHuo2 obj = new ShiHuo2();
        //String fileName = "info.txt";
        String fileName = args[0];
        String result = obj.sign(fileName);
        System.out.println(result);
    }

    public String readFileBody(String path) {
        try {
            FileReader reader = new FileReader(new File(path));
            StringBuilder stringBuilder = new StringBuilder();
            char[] buffer = new char[10];
            int size;
            while ((size = reader.read(buffer)) != -1) {
                stringBuilder.append(buffer, 0, size);
            }
            return stringBuilder.toString();
        } catch (Exception e) {
            return "";
        }
    }
    // 补环境


    @Override
    public DvmObject<?> callStaticObjectMethod(BaseVM vm, DvmClass dvmClass, String signature, VarArg varArg) {
        if (signature.equals("android/app/ActivityThread->currentActivityThread()Landroid/app/ActivityThread;")) {
            // 使用ActivityThread类对象的currentActivityThread方法没有参数，返回值是ActivityThread 的时候报错了
            // 应该返还给c一个ActivityThread的对象--》安卓的系统对象 ---》模仿之前contxt--》new出一个null的，先穿进去，如果报错，再补
            return vm.resolveClass("android/app/ActivityThread").newObject(null);

        }
        return super.callStaticObjectMethod(vm, dvmClass, signature, varArg);
    }

    // 继续补 callObjectMethod

    @Override
    public DvmObject<?> callObjectMethod(BaseVM vm, DvmObject<?> dvmObject, String signature, VarArg varArg) {
        if (signature.equals("android/app/ActivityThread->getApplication()Landroid/app/Application;")) {
            // Application 是安卓系统的对象
            return vm.resolveClass("android/app/Application").newObject(null);

        }
        if (signature.equals("android/app/Application->getPackageManager()Landroid/content/pm/PackageManager;")) {
            // Application 是安卓系统的对象
            return vm.resolveClass("android/content/pm/PackageManager").newObject(null);

        }

        // 补充：如果咱们在写的时候：报了  android/app/Application->getPackageName()Ljava/lang/String;
        if (signature.equals("android/app/Application->getPackageName()Ljava/lang/String;")) {
            // 使用Application的对象，调用getPackageName 返回字符串--》返回包名
            // 百度搜：getPackageName干啥用---》获得包名的---》包名又是字符串，我们写死
            // 包名如何获得：1 hook getPackageName  2 直接使用frida打印出这个app包名即可
            //return new StringObject(vm,"com.hupu.shihuo");
            // unidbg 针对于安卓的东西，也会写一点
            String packlageName = vm.getPackageName();
            System.out.println(packlageName);
            return new StringObject(vm, packlageName);


        }
        return super.callObjectMethod(vm, dvmObject, signature, varArg);
    }
}

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

3.4.2 编译

3.4.3 终端调用

1 2	java -jar unidbg-0.9.7.jar shihuo

3.4.4 python调用

import subprocess
body = "shihuo"
cmd = f'java -jar  unidbg-0.9.7.jar "{body}"'
signature = subprocess.check_output(cmd, shell=True, cwd="unidbg_0_9_7_jar")
print("加密结果为：",signature)

__END__

Unidbg_03

零 B站案例

0.1 回顾

0.2 分析

0.3 unidbg

0.4 补环境

一 拼多多案例

1.1 目标

1.2 反编译-搜索

1.3 hook验证

1.4 定位so

1.4.1 静态注册

1.4.2 动态注册

1.5 补环境

腾讯日志库

权限之手机状态

hook获取相关值

getSystemService

app自己的方法

系统方法isDebuggerConnected

异常

replace

文件读写输入输出相关

1.6 unidbg

二 主动调用

2.0 概念

2.1 回顾

2.2 常见表示

2.3 callFunction

2.3 案例

2.4 参数形式

2.5 案例

2.6 大姨妈案例

2.6.1 执行方法（java类型）

2.6.2 执行方法（c类型）

三 打包

3.1 配置

3.2 车智赢获取秘钥案例–无输入参数

3.2.1 编译

3.3 终端调用

3.4 python调用

3.3 B站案例

3.3.1 参数化和注意事项

3.3.2 修改代码

3.3.3 编译

3.3.4 终端调用

3.3.5 python调用

3.4 识货案例

3.4.1 修改代码

3.4.2 编译

3.4.3 终端调用

3.4.4 python调用

一拼多多案例

二主动调用

三打包