vmp入门(一)：android dex vmp还原和安全性论述

看了一下，目前市面上关于dex vmp还原就我兄弟写的这一个，我不得不佩服他巨强的二级制分析能力。关于dex vmp 他的大部分都写了，但是，他搞的实在是太复杂了，他的分析基本都是基于静态的数据流向分析，这种对于二进制vmp都有杀伤力的，只能说杀鸡焉用牛刀，而且他的牛刀还没发借给我，这是最气的。
另外一个360大佬在看雪峰会上发的关于dex vmp的ppt演讲，他这个我没看得很懂，技术有限。前面都是大佬，一看就会，一学就废。

vmp宝宝入门知识讲解

vmp目前基本可以说是逆向分析中代码混淆的巅峰，顶点，最高里程碑，dex vmp在我看来是比较简单一点的vmp了，所以我们从这里入门。

vmp设计理念

vmp是一种虚拟机保护壳，如果你第一次听过，估计直接蒙了，他其实就是一个虚拟的执行机器，就比如java虚拟机，他们的原理是一样的。java虚拟机可以叫vmp是保护的意思，所以叫vmp。这种虚拟机一般有两部分：

vmp执行实体运作原理

vmp虽然设计理念上跟别的虚拟机没什么差别，但是他很简陋，基本只有能转换虚拟机的bytecode然后进行运行的能力。写个伪代码示意一下

1 2 3 4 5

while(1){                                    //一旦进入虚拟机就会开始读取字节码，除非遇到退出指令，否则一直执行下去     bytecode_ins = read(bytecode_buff);  //不断的读取指令     exe(bytecode_ins)                   //运行指令 }

就是这样一直循环

vmp加固软件

在vmp执行实体中，可以看到有个bytecode_buff，虚拟机为什么能识别他，因为加固软件将源码，转变成虚拟机的bytecode，然后将虚拟机和bytecode一起打包到需要加固的软件中。

逆向目标

对于一个vmp,我们的目标只有一个，那就是还原，还原成c也好，汇编也好，java也好，反正就是去除vmp化。这就是最务实的目标，所以这篇博客的目的就是如何将dex vmp 还原成java代码。

程序分析

Java层函数入口

首先看入口函数，如果看过我上面提到过的dex vmp 你就该知道，这个pro.getxxx，其实就是调用的dex vmp函数的入口，而第一个参数，其实就是代表了当前这个函数，用这个数字来索引已经被虚拟化的代码来执行。

然后再看看这个函数的定义，这个如果你经验丰富，经常写java代码和别的代码的交互，你就会发现，这是一个java 和c的交互代码，写了这么多类型，就是可以从c 层返回任何一种类型的java对象，看不出来也没事。

寻找java方法的native 地址

这个本来不想写的，但是其实其实比较简单，有人多人去hook NativeRegister，很多加固去通过各种奇葩的手段绕过NativeRegister进行注册，但是其实没必要，java方法的native地址根本无法隐藏。分享一个frida脚本寻找native方法的地址。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

var offset = -1 //这个函数是用来做偏移矫正的 function get_android_api_jnioffset() {     if(offset != -1){         return offset     }     var native_addr = Module.findExportByName("libandroid_runtime.so", "_Z32android_os_Process_getUidForNameP7_JNIEnvP8_jobjectP8_jstring")     // console.log("native_addr:",native_addr)     var className = "android.os.Process";     var classResult = Java.use(className).class;     var methodArr = classResult.getDeclaredMethods();     for (var i = 0; i < methodArr.length; i++) {         var methodName = methodArr[i].toString();         var flags = methodArr[i].getModifiers()         if (flags & 256) {             if(methodName.indexOf("getUidForName")!= -1){                 var artmethod = methodArr[i].getArtMethod();                 for (var i = 0; i < 30; i=i+1) {                     var jni_native_addr = Memory.readPointer(ptr(artmethod + i))                     if(native_addr.equals(jni_native_addr)){                         offset = i                         return i                     }                 }             }         }     }     return -1 } 遍历一个类的所有native 方法并打印地址 function get_jni_native_method_addr(classResult) {           var jnioffset = get_android_api_jnioffset()     var methodArr = classResult.getDeclaredMethods();     for (var i = 0; i < methodArr.length; i++) {         var methodName = methodArr[i].toString();         var flags = methodArr[i].getModifiers()         if (flags & 256) {             var artmethod = methodArr[i].getArtMethod();             var native_addr = Memory.readPointer(ptr(artmethod + jnioffset))             //找到本手机系统中artmethod的便宜地址，然后用20+偏移             var module             var offset             console.log("methodName->", methodName);             try {                 module = Process.getModuleByAddress(native_addr)                 offset = native_addr - module.base                 console.log("Func.offset==", module.name, offset);             } catch (err) {             }             console.log("Func.getArtMethod->native_addr:", native_addr); //打印出java方法jni函数调用的native函数地址             console.log("Func.flags->", flags);         }     } }

getobjresult 函数native分析

这个函数是我们主要的分析，怎么寻找native函数，so动态下发分析不讲了，直接找native函数地址开始分析流程

初步调试分析

拿到这个包以后，已经找到要逆向的函数，所以直接用上面的frida 脚本找到函数的偏移，然后ida直接附加进程，在这个位置下断点，确实没问题，函数在这里断下来了，trace了一下，程序直接崩溃了，有反调试，无所谓，停掉所有其他的线程trace，这个getobjresult函数有时候能跑完，有时候跑不完。但是trace确实完成了，第一次trace 90w，第二次2700w行。trace代码的长度，流程都不一样。经过代码一段时间的汇编分析（比较简单），我发现出问题代码这个地方开始不一致。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

.text:000000000001AD18 FC 6F BA A9             STP             X28, X27, [SP,#-0x10+var_50]! .text:000000000001AD1C FA 67 01 A9             STP             X26, X25, [SP,#0x50+var_40] .text:000000000001AD20 F8 5F 02 A9             STP             X24, X23, [SP,#0x50+var_30] .text:000000000001AD24 F6 57 03 A9             STP             X22, X21, [SP,#0x50+var_20] .text:000000000001AD28 F4 4F 04 A9             STP             X20, X19, [SP,#0x50+var_10] .text:000000000001AD2C FD 7B 05 A9             STP             X29, X30, [SP,#0x50+var_s0] .text:000000000001AD30 FD 43 01 91             ADD             X29, SP, #0x50 .text:000000000001AD34 FF 83 07 D1             SUB             SP, SP, #0x1E0 .text:000000000001AD38 48 D0 3B D5             MRS             X8, #3, c13, c0, #2 .text:000000000001AD3C E8 07 00 F9             STR             X8, [SP,#8] .text:000000000001AD40 08 15 40 F9             LDR             X8, [X8,#0x28] .text:000000000001AD44 F9 03 01 AA             MOV             X25, X1 .text:000000000001AD48 FA 03 00 AA             MOV             X26, X0 .text:000000000001AD4C A8 03 1A F8             STUR            X8, [X29,#var_60] .text:000000000001AD50 37 A0 40 A9             LDP             X23, X8, [X1,#8] .text:000000000001AD54 29 0C 40 F9             LDR             X9, [X1,#0x18] .text:000000000001AD58 E8 5B 00 F9             STR             X8, [SP,#0xB0] .text:000000000001AD5C 28 14 40 F9             LDR             X8, [X1,#0x28] .text:000000000001AD60 E9 0F 00 F9             STR             X9, [SP,#0x18] .text:000000000001AD64 E8 5F 00 F9             STR             X8, [SP,#0xB8] .text:000000000001AD68 28 00 40 F9             LDR             X8, [X1] .text:000000000001AD6C E8 57 00 F9             STR             X8, [SP,#0xA8] .text:000000000001AD70 28 8F 44 78             LDRH            W8, [X25,#0x48]! .text:000000000001AD74 68 00 00 34             CBZ             W8, loc_1AD80 .text:000000000001AD74 .text:000000000001AD78 E8 03 00 32             MOV             W8, #1 .text:000000000001AD7C 28 E0 01 39             STRB            W8, [X1,#0x78] .text:000000000001AD7C .text:000000000001AD80 .text:000000000001AD80                         loc_1AD80                               ; CODE XREF: bl_x8+5C↑j .text:000000000001AD80 F4 02 40 79             LDRH            W20, [X23] .text:000000000001AD84 28 60 02 91             ADD             X8, X1, #0x98 .text:000000000001AD88 F6 02 00 B0             ADRP            X22, #data_rel@PAGE .text:000000000001AD8C E8 53 00 F9             STR             X8, [SP,#0xA0] .text:000000000001AD90 88 1E 40 92             AND             X8, X20, #0xFF .text:000000000001AD94 D6 C2 19 91             ADD             X22, X22, #data_rel@PAGEOFF .text:000000000001AD98 38 40 02 91             ADD             X24, X1, #0x90 .text:000000000001AD9C C8 7A 68 F8             LDR             X8, [X22,X8,LSL#3]      ; @64[X22 + (X8 << 0x3)], X8 .text:000000000001ADA0 29 00 03 91             ADD             X9, X1, #0xC0 .text:000000000001ADA4 F8 A7 08 A9             STP             X24, X9, [SP,#0x88] .text:000000000001ADA8 29 A0 02 91             ADD             X9, X1, #0xA8 .text:000000000001ADAC E9 4F 00 F9             STR             X9, [SP,#0x98] .text:000000000001ADB0 29 80 02 91             ADD             X9, X1, #0xA0 .text:000000000001ADB4 3B C0 02 91             ADD             X27, X1, #0xB0 .text:000000000001ADB8 E9 67 07 A9             STP             X9, X25, [SP,#0x70] .text:000000000001ADBC 29 40 03 91             ADD             X9, X1, #0xD0 .text:000000000001ADC0 E9 37 00 F9             STR             X9, [SP,#0x68] .text:000000000001ADC4 E1 27 00 F9             STR             X1, [SP,#0x48] .text:000000000001ADC8 FA 43 00 F9             STR             X26, [SP,#0x80] .text:000000000001ADCC FB 1F 00 F9             STR             X27, [SP,#0x38] .text:000000000001ADD0 00 01 1F D6             BR              X8

为什么要贴这段汇编那，其实不贴也可以。因为假如你有一天去你想vmp,并且发现这种br x8,这种，不断取x23内容，加上x22地址，是dex vmp，我调研过有几个类似样本都这样。
然后就进入完全看不懂的乱序执行

有很多图，全部都是乱的。开始我以为是混淆，经过分析以后发现，并没有混淆。但是这个执行顺序完全是乱飞，我们一般对于1个函数，或者说c编译的函数，识别的他的方法是开栈和闭栈并且栈平衡，这是一个完整的函数，但是这个函数全是乱的，没有开栈也没有闭栈。

加固方式识别

对于一个未知的加固方案，如果你想从汇编完全暴力破解他，把他撸出来，而且还是2700w行汇编，难度太高了。所以第一个是识别他，然后去网上找大神的破解方法来对症下药。如何识别那，不断的运行，进行猜测，这个过程会很久，经过分析我发现他里面有大量的jni函数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

switch ( v63 )     {       case 'B':         v72 = (v55->functions->NewByteArray)(v55, v57, a3, a4, a5, a6, a7, a8);         goto LABEL_24;       case 'C':         v72 = (v55->functions->NewCharArray)(v55, v57, a3, a4, a5, a6, a7, a8);         goto LABEL_24;       case 'D':         v72 = (v55->functions->NewDoubleArray)(v55, v57, a3, a4, a5, a6, a7, a8);         goto LABEL_24;       case 'F':         v72 = (v55->functions->NewFloatArray)(v55, v57, a3, a4, a5, a6, a7, a8);         goto LABEL_24;       case 'I':         v72 = (v55->functions->NewIntArray)(v55, v57, a3, a4, a5, a6, a7, a8);         goto LABEL_24;       case 'J':         v72 = (v55->functions->NewLongArray)(v55, v57, a3, a4, a5, a6, a7, a8);         goto LABEL_24;       case 'S':         v72 = (v55->functions->NewShortArray)(v55, v57, a3, a4, a5, a6, a7, a8);         goto LABEL_24;       case 'Z':         v72 = (v55->functions->NewBooleanArray)(v55, v57, a3, a4, a5, a6, a7, a8); LABEL_24:

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

cls_name = v58->functions->FindClass(v58, v100);   functions = v58->functions;   v103 = v58;   cls_name_2 = cls_name;   v105 = v58;   obj = *(a39 + 8 * a22);   functions->ExceptionClear(&v105->functions);   free(v100);   method_id = v103->functions->GetMethodID(&v103->functions, cls_name_2, method_name, fun_sign);   free(fun_sign);   if ( method_id )   {     a40 = 0.0;     v57 = a32;     if ( v95 )     {       switch ( *return_type )       {         case 'B':           v110 = env->functions->CallNonvirtualByteMethodA(env, obj, cls_name_2, method_id, args);           goto LABEL_74;         case 'C':           v115 = env->functions->CallNonvirtualCharMethodA(env, obj, cls_name_2, method_id, args);           goto LABEL_87;         case 'D':           env->functions->CallNonvirtualDoubleMethodA(env, obj, cls_name_2, method_id, args);           goto LABEL_89;         case 'F':           env->functions->CallNonvirtualFloatMethodA(env, obj, cls_name_2, method_id, args);           goto LABEL_78;         case 'I':           v112 = env->functions->CallNonvirtualIntMethodA(env, obj, cls_name_2, method_id, args);           goto LABEL_81;         case 'J':           v113 = COERCE_DOUBLE(env->functions->CallNonvirtualLongMethodA(env, obj, cls_name_2, method_id, args));           goto LABEL_84;         case 'L':         case '[':           v108 = env;           v109 = COERCE_DOUBLE(env->functions->CallNonvirtualObjectMethodA(env, obj, cls_name_2, method_id, args));           goto LABEL_68;         case 'S':           v117 = env->functions->CallNonvirtualShortMethodA(env, obj, cls_name_2, method_id, args);           goto LABEL_92;         case 'V':           env->functions->CallNonvirtualVoidMethodA(env, obj, cls_name_2, method_id, args);           goto LABEL_93;         case 'Z':           v114 = env->functions->CallNonvirtualBooleanMethodA(env, obj, cls_name_2, method_id, args);           goto LABEL_96;         default:           goto LABEL_97;       }     }     switch ( *return_type )     {       case 'B':         v110 = CallNonvirtualByteMethodV(env, obj, cls_name_2, method_id); LABEL_74:         v44 = v110;         goto LABEL_75;       case 'C':         v115 = CallNonvirtualCharMethodV(env, obj, cls_name_2, method_id); LABEL_87:         v44 = v115;

很多很多，在运行中分析这些数据发现他调用很多java的代码，各种各样，有很多我甚至都没有用过。

• 第一个特征使用了大量的jni函数而且，没有什么别的函数
• 第二就是上面贴的这个函数，正常的函数调用，谁没事搞这么多参数，各种各种的jni方法调用啊，摆明了不就是一个通用的c成调用任何java方法的功能吗
• 第三特征，在前面分析入口的时候，遇到一个常量函数列表，在调用中我经过函数交叉引用我发现很多函数都在这个常量函数列表我觉得不对劲，然后我数了数，刚好256个。这个数字很微妙，而且不正常。
• 第四特征，我对上面的这些函数的功能进行了分析，我发现更像是在执行单条Dalvik 指令（本人对于dalivk分非常熟悉，手写过一段时间smali）。

到这里基本破案了，256条指令对应了256个Dalvik 指令的opcode,虽然很多没用。

vmp框架分析

前面我们说了我们的目标，就是将某一段代码还原。而vmp，还原的方法只能去分析整个vmp的框架,进行功能含义分析，然后通过某一段vm的指令，将他手工转化成java代码。说白了就是一个vmp的反向过程。

• vmp基本单元指令
  上文提到的那个256个函数地址的数组，我第一时间就判断为vmp的基本单元指令，毕竟太巧了，而且试试也无妨（对逆向来说猜测并测试也是一种极为重要的方法）
• vm运行方式

1 2 3 4 5

while(1){                                    //一旦进入虚拟机就会开始读取字节码，除非遇到退出指令，否则一直执行下去     bytecode_ins = read(bytecode_buff);  //不断的读取指令     exe(bytecode_ins)                   //运行指令 }

我签名写的这个，就是vmp简单的执行示意，它必然需要不断的循环运行，来执行基本单元指令，除非基本单元指令退出，否则会无线循环。
但是实际分析过程中，我发现没有while循环，也没有这种wile里读指令，然后根据不同的指令跳转到不同的vmp基本单元指令。（猜测失败的代价就是对自己的技术产生怀疑）
然后我去研究了一下trace，看一下他这个指令之间是如何关联起来的，上一条指令如何跳转到下一条指令。（研究过多条指令，很长的函数还没有间隔，完全不知道出口在哪里，但是很幸运的是有比较短的）

1 2 3 4 5 6

.text:00000076F68DBDD4                         nop                                     ; DATA XREF: .data.rel.ro:00000076F6938940↓o .text:00000076F68DBDD4 F7 0A 00 91             ADD             X23, X23, #2                                                              ; monitor:loc_76F690C534↓j .text:00000076F68DBDD8 F4 02 40 79             LDRH            W20, [X23] .text:00000076F68DBDDC 88 1E 40 92             AND             X8, X20, #0xFF .text:00000076F68DBDE0 C8 7A 68 F8             LDR             X8, [X22,X8,LSL#3] .text:00000076F68DBDE4 00 01 1F D6             BR              X8

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

.text:00000076F68E0C0C C9 02 00 B0             ADRP            X9, #translator_8_12_2@PAGE .text:00000076F68E0C10 CB 02 00 B0             ADRP            X11, #translator_12_16_2@PAGE .text:00000076F68E0C14 29 01 47 F9             LDR             X9, [X9,#translator_8_12_2@PAGEOFF] .text:00000076F68E0C18 6B 45 47 F9             LDR             X11, [X11,#translator_12_16_2@PAGEOFF] .text:00000076F68E0C1C 88 2E 48 D3             UBFX            X8, X20, #8, #4 .text:00000076F68E0C20 8A 3E 4C D3             UBFX            X10, X20, #0xC, #4 .text:00000076F68E0C24 28 69 68 38             LDRB            W8, [X9,X8] .text:00000076F68E0C28 69 69 6A 38             LDRB            W9, [X11,X10] .text:00000076F68E0C2C 28 6D 1C 33             BFI             W8, W9, #4, #0x1C .text:00000076F68E0C30 13 1D 00 13             SXTB            W19, W8 .text:00000076F68E0C34 F3 00 F8 36             TBZ             W19, #0x1F, loc_76F68E0C50 .text:00000076F68E0C34 .text:00000076F68E0C38 28 03 40 39             LDRB            W8, [X25] .text:00000076F68E0C3C A8 00 20 36             TBZ             W8, #4, loc_76F68E0C50 .text:00000076F68E0C3C .text:00000076F68E0C40 E8 5B 40 F9             LDR             X8, [SP,#arg_B0] .text:00000076F68E0C44 E0 27 40 F9             LDR             X0, [SP,#arg_48] .text:00000076F68E0C48 17 01 1F F8             STUR            X23, [X8,#-0x10] .text:00000076F68E0C4C F4 C8 00 94             BL              sub_76F691301C .text:00000076F68E0C4C .text:00000076F68E0C50 .text:00000076F68E0C50                         loc_76F68E0C50                          ; CODE XREF: goto+28↑j .text:00000076F68E0C50                                                                 ; goto+30↑j .text:00000076F68E0C50 F7 C6 33 8B             ADD             X23, X23, W19,SXTW#1 .text:00000076F68E0C54 F4 02 40 79             LDRH            W20, [X23] .text:00000076F68E0C58 88 1E 40 92             AND             X8, X20, #0xFF .text:00000076F68E0C5C C8 7A 68 F8             LDR             X8, [X22,X8,LSL#3] .text:00000076F68E0C60 00 01 1F D6             BR              X8

不多贴了，他们的尾部都是一样的，x20 当前指令，x22 data_rel，x23 指令数据表。他是通过上一条指令的内容计算下一条指令的地址，然后读取数据数据，和指令处理的地址，用x8跳过去，他不是一个while模式。写个运行的伪代码的例子

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

data_rel= 指令数据数组(fun1,fun2,fun3) fun1（）{   XXXXXX正文内容   下一套指令地址=read(data_rel(当前的数据)+fun1函数这个指令的长度)    bl  下一套指令地址 } fun2（）{   XXXXXX正文内容   下一套指令地址=read(data_rel(当前的数据)+fun1函数这个指令的长度)    bl  下一套指令地址 } fun3（）{   XXXXXX正文内容   下一套指令地址=read(data_rel(当前的数据)+fun1函数这个指令的长度)    bl  下一套指令地址 } call fun1

这样一旦开始执行，除非遇到退出指令，否则函数会一直执行下去。android dvm虚拟机以前读源码的时候见过这种模式，这种计算指令长度的方式，davlik也确实可以这样搞。他每个指令长度都是可以提前写死的，没有变长的可能。

指令函数分析

我们知道了他的基本单元指令，以及基本单元指令的函数，这个时候我们对基本单元指令进行一个一个的分析，然后将某一个vmp化的java函数vmp指令进行反向转化。

• 裸函数
  所有的函数都是裸函数，纯用汇编写的可能性不打，毕竟还有jni函数，这些裸函数直接打乱了ida的反汇编
• 函数代码乱序
  很多指令函数其实都是正常顺序的，但是大部分中间都有个错误处理，这些错误处理都会调向同一个函数的位置。直白点就是，这个指令处理的函数开始的内存地址和结束的内存地址是连续的，但是中间有一条错误处理指令，跳到了远方地址，让ida进行函数识别的时候出错了，直接把这个错误处理nop就可以正常分析了。
• dex字符编码支持
  这个其实我是没想到了，分析了好久，搞不懂里面有一段很繁琐的代码，到底是干嘛，对于追求优雅和有强迫症的我，这是不能接受的。然后我搞出跑了一下，发现跟一个以前的字符编码格式很像。不知道没关系，也不影响。如果想了解可以看看

1 2 3 4

v62 = (*(*a30 + 0x58LL) + *(*(*a30 + 16LL) + 4 * v59));   do     v64 = *v62++;   while ( (v64 & 0x80000000) != 0 );

• vmp指令函数匹配davlik指令
  这个有很多人说叫指令对照表，不过无所谓，我兄弟的博客中已经说了很多还原的方法，具体啥意思，没完全懂，他好像是数据流向分析+vmp指令分析，但是我在实际还原的过程中使用的是人肉+推倒，不算快，但是速度客观，不算太难。算了，这部分不具体写了，感觉没啥难的，主要还是对于davlik指令要熟悉，后面跟别的一起写为什么这个不难。
• 指令参数匹配
  vmp对于寄存器原来的含义，进行了加密，在运行的时候进行解密。寄存器标示着这个寄存器位移栈的位置，这种vmp是有自己定义栈的，但是他的指令的参数所在的位置在运行过程中是和真正davlik相同的，加了一道转化手续而已。下面的代码中有translator_8_12，这个类似的就是做转化的。

vmp指令还原

以前听说360还原用的是对照表。但是逆向到我这个地步，写对照表已经属于浪费时间了，而且对照表还要对着opcode一个一个的改，懒得搞了。我直接写了一个小型的opcode 转smali语言的ida脚本，将vmp指令转变为smali指令，然后写道对应的dex中反编译的smali工程中，进行回编译。直接贴脚本，这是一个的半自动化+手工来进行指令还原的脚本，扔给你们做参考吧。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720

import idaapi global_table = 0x78D05D8E80 fun_id = 158 fun_addr_ref = 0x0 instr_fun_table = 0x0 # 0x1b4 translator_8_12=[3,2,1,0,7,6,5,4,0xb,0xA ,9, 8, 0xF, 0xE, 0xD, 0xC] translator_12_16=[0xB, 0xA, 9, 8, 0xF, 0xE, 0xD, 0xC, 3, 2, 1, 0, 7, 6, 5, 4] def aget(instr_addr,x10):     print("aget","arg:")     return 4 def const_4(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     arg0 = translator_8_12[(instr_0_2 >> 8) & 0xF]     arg1 = translator_12_16[instr_0_2 >> 12]     print("const/4 v%d, %d"%(arg0,arg1))     return 2 def const_16(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     arg0 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     instr_2_4 = read_mem_to_Int(instr_addr+2, 2)     print("const/16 v%d, %d"%(arg0,instr_2_4))     return 4 def const(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     arg0 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     instr_2_4 = read_mem_to_Int(instr_addr+2, 2)     print("const v%d, %d"%(arg0,instr_2_4))     return 6 def const_string(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_2_4 = read_mem_to_Int(instr_addr+2, 2)     v60 = instr_0_2 >> 12     v61 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF     v63 = 16 * (translator_12_16[v60] & 0xF)     v75 = v63 | v61     #     a38_index_11 = read_mem_to_Int(x10 + 0x58, 8)     a38_index_2 = read_mem_to_Int(x10 + 0x10, 8)     v3 = read_mem_to_Int(instr_2_4 * 4 + a38_index_2, 4)     string =  v3+ a38_index_11     # print("string addr",hex(string),hex(instr_addr))     # cla_len =  read_mem_to_Int(string, 1)     # return_type = idaapi.dbg_read_memory(string+1, cla_len).decode('utf-8')     #     # print("const-string ",v75,return_type)     print("const-string v%d, %s"%(v75,hex(string)))     return 4 def xor(instr_addr,x10):     print("xor","arg:")     return 4 def move_16(instr_addr,x10):     print("move-16","arg:")     return 2 def iput_object(instr_addr,x10):     print("iput_object","arg:")     return 4 def aput_object(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v37 = (instr_0_2 >> 8) & 0xF     v38 = instr_0_2 >> 12     v40 = translator_8_12[v37];     v41 = translator_12_16[v38];     arg_v1 = v40 & 0xF | (16 * (v41 & 0xF))     arg_v2 = read_mem_to_Int(instr_addr+2, 1)     arg_v3 = read_mem_to_Int(instr_addr+3, 1)     print("aput-object v%d, v%d, v%d"%(arg_v1,arg_v2,arg_v3))     return 4 def goto(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v3 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     if v3 >= 128:         int_num = (v3 - 256)*2     else:         int_num = v3 *2     print("goto","arg:",hex(instr_addr+int_num),int_num)     return 2 def rsub(instr_addr,x10):     print("rsub","arg:")     return 4 def cmp(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v1 = read_mem_to_Int(instr_addr+2, 1)     v2 = read_mem_to_Int(instr_addr+3, 1)     v3 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     print("cmp","arg:",v3,v1,v2)     return 4 def invoke_super(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_add_4 = read_mem_to_Int(instr_addr+4, 2)     v63 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF));   #处理一个字节(8 bit)的 数据，作为寄存器转换     register_size = v63 >> 4     arg1 = instr_add_4   & 0xF     arg2 = instr_add_4   >> 4 & 0xF     arg3 = (instr_add_4   >> 8) & 0xf     arg4 = instr_add_4   >> 12     arg5 = v63   & 0xF     ref_index = read_mem_to_Int(instr_addr + 2, 2)     classname_str = get_class_name(x10,ref_index)     method_name_str = get_method_name(x10,ref_index)     type_name_str = get_proto_type_name(x10, ref_index)     # arg_name_str = get_method_arg(x10,ref_index)     # print("invoke_direct class:",classname_str,"method:",method_name_str,"method_ref_index",hex(ref_index),"type:",type_name_str,"register:",register_size,"arg1:",arg1,"arg2:",arg2,"arg3:",arg3,"arg4:",arg4,"arg5:",arg5)     print("invoke-super ",classname_str+"->"+method_name_str+type_name_str,"method_ref_index",hex(ref_index),"register:",register_size,"arg1:",arg1,"arg2:",arg2,"arg3:",arg3,"arg4:",arg4,"arg5:",arg5)     return 6 def invoke_direct(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_add_4 = read_mem_to_Int(instr_addr+4, 2)     v63 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF));   #处理一个字节(8 bit)的 数据，作为寄存器转换     register_size = v63 >> 4     arg1 = instr_add_4   & 0xF     arg2 = instr_add_4   >> 4  & 0xF     arg3 = (instr_add_4   >> 8) & 0xf     arg4 = instr_add_4   >> 12     arg5 = v63   & 0xF     ref_index = read_mem_to_Int(instr_addr + 2, 2)     classname_str = get_class_name(x10,ref_index)     method_name_str = get_method_name(x10,ref_index)     type_name_str = get_proto_type_name(x10, ref_index)     # arg_name_str = get_method_arg(x10,ref_index)     # print("invoke-direct class:",classname_str,"method:",method_name_str,"method_ref_index",hex(ref_index),"type:",type_name_str,"register:",register_size,"arg1:",arg1,"arg2:",arg2,"arg3:",arg3,"arg4:",arg4,"arg5:",arg5)     print("invoke-direct ",classname_str+"->"+method_name_str+type_name_str,"method_ref_index",hex(ref_index),"register:",register_size,"arg1:",arg1,"arg2:",arg2,"arg3:",arg3,"arg4:",arg4,"arg5:",arg5)     return 6 def invoke_static(instr_addr, x10):    # 第一个字节是指令，主导函数偏移，第二个字节是寄存器，三四字节是方法偏移     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_add_4 = read_mem_to_Int(instr_addr+4, 2)     v63 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF));   #处理一个字节(8 bit)的 数据，作为寄存器转换     register_size = v63 >> 4     arg1 = instr_add_4   & 0xF     arg2 = instr_add_4   >> 4 & 0xF     arg3 = (instr_add_4   >> 8) & 0xf     arg4 = instr_add_4   >> 12     arg5 = v63   & 0xF     ref_index = read_mem_to_Int(instr_addr + 2, 2)     classname_str = get_class_name(x10,ref_index)     method_name_str = get_method_name(x10,ref_index)     type_name_str = get_proto_type_name(x10, ref_index)     # arg_name_str = get_method_arg(x10,ref_index)     # print("invoke-static class:",classname_str,"method:",method_name_str,"method_ref_index",hex(ref_index),"type:",type_name_str,"register:",register_size,"arg1:",arg1,"arg2:",arg2,"arg3:",arg3,"arg4:",arg4,"arg5:",arg5)     print("invoke-static ",classname_str+"->"+method_name_str+type_name_str,"method_ref_index",hex(ref_index),"register:",register_size,"arg1:",arg1,"arg2:",arg2,"arg3:",arg3,"arg4:",arg4,"arg5:",arg5)     # print("CallStaticVoidMethod arg_name_str:",arg_name_str)     return 6 def invoke_interface(instr_addr,x10):    # 第一个字节是指令，主导函数偏移，第二个字节是寄存器，三四字节是方法偏移     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_add_4 = read_mem_to_Int(instr_addr+4, 2)     v63 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF));   #处理一个字节(8 bit)的 数据，作为寄存器转换     register_size = v63 >> 4     arg1 = instr_add_4   & 0xF     arg2 = instr_add_4   >> 4 & 0xF     arg3 = (instr_add_4   >> 8) & 0xf     arg4 = instr_add_4   >> 12     arg5 = v63   & 0xF     ref_index = read_mem_to_Int(instr_addr + 2, 2)     classname_str = get_class_name(x10,ref_index)     method_name_str = get_method_name(x10,ref_index)     type_name_str = get_proto_type_name(x10, ref_index)     # arg_name_str = get_method_arg(x10,ref_index)     print("invoke-interface ",classname_str+"->"+method_name_str+type_name_str,"method_ref_index",hex(ref_index),"register:",register_size,"arg1:",arg1,"arg2:",arg2,"arg3:",arg3,"arg4:",arg4,"arg5:",arg5)     # print("CallStaticVoidMethod arg_name_str:",arg_name_str)     return 6 def invoke_virutal(instr_addr,x10):    # 第一个字节是指令，主导函数偏移，第二个字节是寄存器，三四字节是方法偏移     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_add_4 = read_mem_to_Int(instr_addr+4, 2)     v63 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF));   #处理一个字节(8 bit)的 数据，作为寄存器转换     register_size = v63 >> 4     arg1 = instr_add_4   & 0xF     arg2 = instr_add_4   >> 4 & 0xF     arg3 = (instr_add_4   >> 8) & 0xf     arg4 = instr_add_4   >> 12     arg5 = v63   & 0xF     ref_index = read_mem_to_Int(instr_addr + 2, 2)     classname_str = get_class_name(x10,ref_index)     method_name_str = get_method_name(x10,ref_index)     type_name_str = get_proto_type_name(x10, ref_index)     # arg_name_str = get_method_arg(x10,ref_index)     print("invoke-virtual ",classname_str+"->"+method_name_str+type_name_str,"method_ref_index",hex(ref_index),"register:",register_size,"arg1:",arg1,"arg2:",arg2,"arg3:",arg3,"arg4:",arg4,"arg5:",arg5)     # print("CallStaticVoidMethod arg_name_str:",arg_name_str)     return 6 def rem_doule(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v_arg_0 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     instr_2_4 = read_mem_to_Int(instr_addr + 2, 2)     print("rem-doule",hex(v_arg_0),hex(instr_2_4))     return 4 def move_result_object(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v_arg_0 =     translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     instr_2_4 = read_mem_to_Int(instr_addr + 2, 2)     print("move-result-object v%d"%v_arg_0)     return 2 def MonitorEnter(instr_addr,x10):     print("MonitorEnter","arg:")     return 2 def return_object(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v_arg_0 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     print("return-object v%d"%v_arg_0)     return 2 def move_object(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v_arg_0 = translator_8_12[(instr_0_2 >> 8) & 0xF];     v_arg_1 = translator_12_16[instr_0_2 >> 12]     print("move-object v%d, v%d"%(v_arg_0,v_arg_1))     return 2 def new_instance(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v_arg_0 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     ref_index = read_mem_to_Int(instr_addr + 2, 2)     dex_base_addr = read_mem_to_Int(x10 + 0x58, 8)     dex_type_off = read_mem_to_Int(x10 + 0x18, 8)     dex_string_list_off = read_mem_to_Int(x10 + 0x10, 8)     classname_str = byIndexGet_dex_type_name(dex_base_addr,dex_type_off,dex_string_list_off,ref_index)     print("new-instance v%d, %s"%(v_arg_0,classname_str))     return 4 def move_result(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v_arg_0 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     print("move-result v%d"%v_arg_0)     return 2 def new_array(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v_arg_size = translator_12_16[instr_0_2 >> 12]     v_arg_0 = translator_8_12[(instr_0_2 >> 8) & 0xF];     ref_index = read_mem_to_Int(instr_addr + 2, 2)     dex_base_addr = read_mem_to_Int(x10 + 0x58, 8)     dex_type_off = read_mem_to_Int(x10 + 0x18, 8)     dex_string_list_off = read_mem_to_Int(x10 + 0x10, 8)     classname_str = byIndexGet_dex_type_name(dex_base_addr,dex_type_off,dex_string_list_off,ref_index)     print("new-array v%d, v%d, %s"%(v_arg_0,v_arg_size,classname_str))     return 4 def if_ne(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_2_4 = read_mem_to_Int(instr_addr+2, 2)     arg1 = translator_8_12[(instr_0_2 >> 8) & 0xF];     arg2 = translator_12_16[instr_0_2 >> 12];     print("if-ne v%d, v%x, %x"%(arg1,arg2,instr_addr+instr_2_4*2))     return 4 def if_eqz(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_2_4 = read_mem_to_Int(instr_addr+2, 2)     v63 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF));   #处理一个字节(8 bit)的 数据，作为寄存器转换     print("if-eqz v%d, %x"%(v63,instr_addr+instr_2_4*2))     return 4 def if_gt(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_2_4 = read_mem_to_Int(instr_addr+2, 2)     arg1 = translator_8_12[(instr_0_2 >> 8) & 0xF];     arg2 = translator_12_16[instr_0_2 >> 12];     print("if-gt v%d, v%x, %x"%(arg1,arg2,instr_addr+instr_2_4*2))     return 4 def if_lt(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_2_4 = read_mem_to_Int(instr_addr+2, 2)     arg1 = translator_8_12[(instr_0_2 >> 8) & 0xF];     arg2 = translator_12_16[instr_0_2 >> 12];     print("if-lt v%d, v%x, %x"%(arg1,arg2,instr_addr+instr_2_4*2))     return 4 def if_lez(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_2_4 = read_mem_to_Int(instr_addr+2, 2)     v63 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF));   #处理一个字节(8 bit)的 数据，作为寄存器转换     print("if-lez v%d, %x"%(v63,instr_addr+instr_2_4*2))     return 4 def if_nez(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     instr_2_4 = read_mem_to_Int(instr_addr+2, 2)     v63 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF));   #处理一个字节(8 bit)的 数据，作为寄存器转换     print("if-nez v%d, %x"%(v63,instr_addr+instr_2_4*2))     return 4 def iput(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     filed_index = read_mem_to_Int(instr_addr+2, 2)     v_arg_0 = translator_12_16[instr_0_2 >> 12]     v_arg_1 = translator_8_12[(instr_0_2 >> 8) & 0xF]     dex_filed_off = read_mem_to_Int(x10 + 0x20, 8)     class_index = read_mem_to_Int(8 * filed_index + dex_filed_off, 2)     filed_type_index = read_mem_to_Int(8 * filed_index + dex_filed_off+2, 2)     name_string_index = read_mem_to_Int(8 * filed_index + dex_filed_off+4, 2)     dex_base_addr = read_mem_to_Int(x10 + 0x58, 8)     dex_type_off = read_mem_to_Int(x10 + 0x18, 8)     dex_string_list_off = read_mem_to_Int(x10 + 0x10, 8)     class_type_string = byIndexGet_dex_type_name(dex_base_addr, dex_type_off, dex_string_list_off, class_index)     filed_type_string = byIndexGet_dex_type_name(dex_base_addr, dex_type_off, dex_string_list_off, filed_type_index)     name_string = byIndexGet_dex_string_name(dex_base_addr,dex_string_list_off,name_string_index)     # print("iput-object ",v_arg_0,v_arg_1,class_type_string,"->",name_string,";",filed_type_string,"filed_index:",filed_index)     print("iput-object v%d, v%d, %s"%(v_arg_1,v_arg_0,class_type_string+"->"+name_string+":"+filed_type_string+" filed_index: "+filed_index))     return 4 def aget_object(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     arg_1 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     arg_v2 = read_mem_to_Int(instr_addr+2, 1)     arg_v3 = read_mem_to_Int(instr_addr+3, 1)     print("aget-object v%d, v%d, v%d"%(arg_1,arg_v2,arg_v3))     return 4 def iget_object(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     filed_index = read_mem_to_Int(instr_addr+2, 2)     v_arg_0 = translator_12_16[instr_0_2 >> 12]     v_arg_1 = translator_8_12[(instr_0_2 >> 8) & 0xF]     dex_filed_off = read_mem_to_Int(x10 + 0x20, 8)     class_index = read_mem_to_Int(8 * filed_index + dex_filed_off, 2)     filed_type_index = read_mem_to_Int(8 * filed_index + dex_filed_off+2, 2)     name_string_index = read_mem_to_Int(8 * filed_index + dex_filed_off+4, 2)     dex_base_addr = read_mem_to_Int(x10 + 0x58, 8)     dex_type_off = read_mem_to_Int(x10 + 0x18, 8)     dex_string_list_off = read_mem_to_Int(x10 + 0x10, 8)     class_type_string = byIndexGet_dex_type_name(dex_base_addr, dex_type_off, dex_string_list_off, class_index)     filed_type_string = byIndexGet_dex_type_name(dex_base_addr, dex_type_off, dex_string_list_off, filed_type_index)     name_string = byIndexGet_dex_string_name(dex_base_addr,dex_string_list_off,name_string_index)     print("iget-object v%d, v%d, %s"%(v_arg_1,v_arg_0,class_type_string+"->"+name_string+":"+filed_type_string+" filed_index: "+filed_index))     return 4 def check_cast(instr_addr,x10):     type_index = read_mem_to_Int(instr_addr+2, 2)     dex_base_addr = read_mem_to_Int(x10 + 0x58, 8)     dex_type_off = read_mem_to_Int(x10 + 0x18, 8)     dex_string_list_off = read_mem_to_Int(x10 + 0x10, 8)     type_string = byIndexGet_dex_type_name(dex_base_addr, dex_type_off, dex_string_list_off, type_index)     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v_arg = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     print("check-cast v%d, %s"%(v_arg,type_string))     return 4 def sget_object(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     filed_index = read_mem_to_Int(instr_addr+2, 2)     v_arg_0 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     dex_filed_off = read_mem_to_Int(x10 + 0x20, 8)     class_index = read_mem_to_Int(8 * filed_index + dex_filed_off, 2)     filed_type_index = read_mem_to_Int(8 * filed_index + dex_filed_off+2, 2)     name_string_index = read_mem_to_Int(8 * filed_index + dex_filed_off+4, 2)     dex_base_addr = read_mem_to_Int(x10 + 0x58, 8)     dex_type_off = read_mem_to_Int(x10 + 0x18, 8)     dex_string_list_off = read_mem_to_Int(x10 + 0x10, 8)     class_type_string = byIndexGet_dex_type_name(dex_base_addr, dex_type_off, dex_string_list_off, class_index)     filed_type_string = byIndexGet_dex_type_name(dex_base_addr, dex_type_off, dex_string_list_off, filed_type_index)     name_string = byIndexGet_dex_string_name(dex_base_addr,dex_string_list_off,name_string_index)     print("sget-object v%d, %s"%(v_arg_0,class_type_string+"->"+name_string+":"+filed_type_string))     return 4 def sget_boolean(instr_addr, x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     filed_index = read_mem_to_Int(instr_addr+2, 2)     v_arg_0 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     dex_filed_off = read_mem_to_Int(x10 + 0x20, 8)     class_index = read_mem_to_Int(8 * filed_index + dex_filed_off, 2)     filed_type_index = read_mem_to_Int(8 * filed_index + dex_filed_off+2, 2)     name_string_index = read_mem_to_Int(8 * filed_index + dex_filed_off+4, 2)     dex_base_addr = read_mem_to_Int(x10 + 0x58, 8)     dex_type_off = read_mem_to_Int(x10 + 0x18, 8)     dex_string_list_off = read_mem_to_Int(x10 + 0x10, 8)     class_type_string = byIndexGet_dex_type_name(dex_base_addr, dex_type_off, dex_string_list_off, class_index)     filed_type_string = byIndexGet_dex_type_name(dex_base_addr, dex_type_off, dex_string_list_off, filed_type_index)     name_string = byIndexGet_dex_string_name(dex_base_addr,dex_string_list_off,name_string_index)     print("sget-boolean v%d, %s"%(v_arg_0,class_type_string+"->"+name_string+":"+filed_type_string))     return 4 def nop(instr_addr,x10):     print("nop")     return 2 def return_void(instr_addr,x10):     print("return-void")     return 2 def throw(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v_arg_0 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     print("throw v%d"%v_arg_0)     return 2 def throw_2(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     v_arg_0 = translator_8_12[(instr_0_2 >> 8) & 0xF] & 0xF | (16 * (translator_12_16[instr_0_2 >> 12] & 0xF))     print("move-exception v%d"%v_arg_0)     return 2 def array_length(instr_addr,x10):     instr_0_2 = read_mem_to_Int(instr_addr, 2)     arg_0 = translator_12_16[instr_0_2 >> 12]     arg_1 =  translator_8_12[(instr_0_2 >> 8) & 0xF]     print("array-length v%d, v%d"%(arg_1,arg_0))     return 2 switch = {0x0:iput, 0x1:invoke_super, 0x2:aget, 0x3:xor, 0x4:move_16, 0x5:iput_object, 0x5a:nop, 0xd:goto, 0xda:aput_object , 0x7:rsub, 0x8:cmp, 0x1e:if_lez, 0x2b:if_nez, 0x3e:if_eqz, 0x3c:if_gt,0x21:if_lt,0x44:const_16, 0xc3:const,           0x5e:move_result , 0x68:invoke_direct, 0xA6:invoke_virutal, 0xAA:new_instance, 0xc7:move_result_object, 0xbb:return_object, 0x92:return_void, 0xfc:move_object, 0x79:invoke_interface, 0xf9:check_cast,           0xf0:const_4, 0xfa:if_ne, 0x93:sget_object, 0xc2:sget_boolean, 0x9a:invoke_static, 0x9b:const_string, 0x1f:new_array, 0x19:iget_object, 0x9d:MonitorEnter,0xc4:array_length,0x6b:aget_object,0xf5:throw,0xee:throw_2} def ByFunIDgetFunAddr(id):     offset_mem = int.from_bytes(idaapi.dbg_read_memory(4*id+global_table,4),byteorder='little')     method_addr = global_table+offset_mem     print("fun_id:",hex(id),"method_addr:",hex(offset_mem),"method_addr:",hex(method_addr))     return method_addr def read_mem_to_String(addr,size):     mem = idaapi.dbg_read_memory(addr,size)     return mem def read_mem_to_Int(addr, size):     mem = int.from_bytes(idaapi.dbg_read_memory(addr,size),byteorder='little')     return mem def get_proto_type_name(x10, type_index):     dex_method_off = read_mem_to_Int(x10 + 0x28, 8)     dex_string_list_off = read_mem_to_Int(x10 + 0x10, 8)     dex_type_off = read_mem_to_Int(x10 + 0x18, 8)     dex_base_addr = read_mem_to_Int(x10 + 0x58, 8)     dex_proto_off = read_mem_to_Int(x10 + 0x30, 8)     proto_index = read_mem_to_Int(8 * type_index + dex_method_off + 2, 2)     return_type_index = read_mem_to_Int(dex_proto_off + 12 * proto_index + 4,4)     pararm_off = read_mem_to_Int(dex_proto_off + 12 * proto_index + 8,4)     sign_type_string_list = "("     if pararm_off != 0:         pararm_size = read_mem_to_Int(dex_base_addr+pararm_off,4)         # pararm_mem_total =  pararm_size * 2         # for i in pararm_size:         for i in range(pararm_size):             pararm_type_index = read_mem_to_Int(dex_base_addr + pararm_off+4+i*2, 2)             pararm_type_string = byIndexGet_dex_type_name(dex_base_addr, dex_type_off, dex_string_list_off, pararm_type_index)             sign_type_string_list =sign_type_string_list+pararm_type_string     return_type_string = byIndexGet_dex_type_name(dex_base_addr,dex_type_off,dex_string_list_off,return_type_index)     sign_type_string_list=sign_type_string_list+")"+return_type_string     return sign_type_string_list def byIndexGet_dex_type_name(dex_base_addr,dex_type_off,dex_string_list_off,pararm_type_index):     string_index = read_mem_to_Int(pararm_type_index * 4 + dex_type_off, 4)     type_string = byIndexGet_dex_string_name(dex_base_addr,dex_string_list_off,string_index)     return type_string def byIndexGet_dex_string_name(dex_base_addr,dex_string_list_off,string_index):     v3 = read_mem_to_Int(string_index * 4 + dex_string_list_off, 4)     cla_len = read_mem_to_Int(dex_base_addr+v3,1)     class_str = idaapi.dbg_read_memory(dex_base_addr+v3+1, cla_len).decode('utf-8')     print("byIndexGet_dex_string_name:",hex(dex_base_addr+v3))     return class_str def get_class_name(x10,class_index):     a38_index_5 = read_mem_to_Int(x10 + 0x28, 8)     a38_index_2 = read_mem_to_Int(x10 + 0x10, 8)     a38_index_3 = read_mem_to_Int(x10 + 0x18, 8)     a38_index_11 = read_mem_to_Int(x10 + 0x58, 8)     v1 = read_mem_to_Int(8 * class_index + a38_index_5, 2)     v2 = read_mem_to_Int(v1 * 4 + a38_index_3, 4)     v3 = read_mem_to_Int(v2 * 4 + a38_index_2, 4)     class_str_addr = v3+a38_index_11     cla_len =  read_mem_to_Int(class_str_addr, 1)     class_str = idaapi.dbg_read_memory(class_str_addr+1, cla_len).decode('utf-8')     # print("classname len:",cla_len)     return class_str def get_method_name(x10, method_index):     a38_index_5 = read_mem_to_Int(x10 + 0x28, 8)     a38_index_2 = read_mem_to_Int(x10 + 0x10, 8)     a38_index_3 = read_mem_to_Int(x10 + 0x18, 8)     a38_index_11 = read_mem_to_Int(x10 + 0x58, 8)     v1 = read_mem_to_Int(8 * method_index + a38_index_5 + 4, 2)     v3 = read_mem_to_Int(v1 * 4 + a38_index_2, 4)     method_name_str_addr =  v3 + a38_index_11     method_name_str_len =  read_mem_to_Int(method_name_str_addr, 1)     method_name_str = idaapi.dbg_read_memory(method_name_str_addr+1, method_name_str_len).decode('utf-8')     return method_name_str def get_method_arg(x10, index):     # (v70 + * (v69 + 4LL * * (v68 + 4LL * * (v81 + v84 + 2))));     a38_index_5 = read_mem_to_Int(x10 + 0x28, 8)     a38_index_2 = read_mem_to_Int(x10 + 0x10, 8)     a38_index_3 = read_mem_to_Int(x10 + 0x18, 8)     a38_index_11 = read_mem_to_Int(x10 + 0x58, 8)     a38_index_6 = read_mem_to_Int(x10 + 0x30, 8)     v0 = read_mem_to_Int(8 * index + a38_index_5 + 2, 2)     v80 = read_mem_to_Int(a38_index_6 + 12 * v0 + 8,4)     print("arg_addr a38_index_5:",hex(a38_index_5))     print("arg_addr a38_index_2:",hex(a38_index_2))     print("arg_addr a38_index_3:",hex(a38_index_3))     print("arg_addr a38_index_11:",hex(a38_index_11))     print("arg_addr a38_index_6:",hex(a38_index_6))     print("arg_addr v80:",v80)     v81 = v80 + a38_index_11     # print("arg_addr v81:",v81)     v1 = read_mem_to_Int(v81+2, 4)     v2 = read_mem_to_Int(v1 * 4 + a38_index_3, 4)     v3 = read_mem_to_Int(v2 * 4 + a38_index_2, 4)     return_type =  v3+a38_index_11     # cla_len =  read_mem_to_Int(return_type, 1)     # return_type = idaapi.dbg_read_memory(return_type+1, cla_len).decode('utf-8')     print("arg_addr:",return_type)     return return_type # def instr_handle(instr_addr,x10): #     offset_mem = read_mem(instr_addr,2) & 0xff #     instr_len = dexinstr[offset_mem](instr_addr,x10) # #     return instr_len def get_segment_address(segment_name):     seg = idaapi.get_segm_by_name(segment_name)     if seg is not None:         return seg.start_ea, seg.end_ea     else:         return None # 使用方法 def main():     method_addr = ByFunIDgetFunAddr(fun_id)     register_size = read_mem_to_Int(method_addr, 2)     ins_size = read_mem_to_Int(method_addr+2, 2)     insns_size = read_mem_to_Int(method_addr+12, 4)     print("method registers_size:",hex(register_size))     print("method ins_size:",hex(ins_size))     print("method insns_size:",hex(insns_size))     method_addr_2 = ByFunIDgetFunAddr(fun_id+1)     funSize = method_addr_2 - method_addr     print("method_size:",hex(funSize))     instr_addr = method_addr+0x10     print("method_end:",hex(instr_addr+insns_size*2 ))     while(1):         offset = read_mem_to_Int(instr_addr, 2) & 0xff  #第一个字节         instr_fun_addr = instr_fun_table+offset*8         print("-----------------------------------")         print("instr_fun_addr:", hex(instr_fun_addr),hex(offset))         instr_handle = switch[offset]         print("instr_addr:", hex(instr_addr))         print(hex(offset))         if(instr_handle == None):             break         instr_len = instr_handle(instr_addr, fun_addr_ref)         instr_addr = instr_addr + instr_len     print(hex(offset)) def init_var():     global global_table     global instr_fun_table     global fun_addr_ref     bss_start, bss_end = get_segment_address(".bss")     qword_78B9BFCDC8 = read_mem_to_Int(bss_start + 0x2B8, 8)     global_table = read_mem_to_Int(bss_start + 0x270, 8)     yaq2__sec = read_mem_to_Int(bss_start + 0x2B0, 8)     v6 = yaq2__sec+ fun_id *12     v6_index_1 = read_mem_to_Int(v6 + 4, 4)     v6_index_2 = read_mem_to_Int(v6 + 8, 4)     fun_addr_ref = read_mem_to_Int(8 * (v6_index_2 - 1) + qword_78B9BFCDC8, 8)     instr_fun_table, data_rel_end = get_segment_address(".data.rel.ro")     print("qword_78B9BFCDC8", hex(qword_78B9BFCDC8))     print("global_table", hex(global_table))     print("v6_index_1", hex(v6_index_1))     print("v6_index_2", hex(v6_index_2))     print("fun_addr_ref", hex(fun_addr_ref)) if __name__ == '__main__':     init_var()     main()

效果图，我就不贴
大致讲一下这个脚本原理思路和使用

这个脚本需要在vmp已经装载完成以后调用，找到还原的dex和对应的vmp指令地址，可以直接循环翻译成smali指令

• dex文件的骨架(内存地址)，来解析辅助davlik指令反编译
• 具体某个函数的vmp指令，进行转化,通过函数index和vmp规则进行计算
• 函数长度，人工分析+寻找return类指令

这个脚本需要在vmp已经装载完成以后调用，找到还原的dex和对应的vmp指令地址，可以直接循环翻译成smali指令。具体的指令是有具体的长度写在代码里的。smali函数结束都有smali指令的返回指令（return类指令），可以随便找个smali工程看一下，函数结束都有一个return类指令.也有可能是其中的一个返回，通过跳转指令结合分析

dex vmp安全性论述

易攻击的缺点

dex vmp 虽然跟二进制vmp的原理一样，但是他的逆向难度和vmp却不是一个量级的。为什么会出现这种情况

• dex vmp的基础支撑其实是jni函数，而这些函数熟悉人的人过于的多，能进行分析和追踪的方法也很多，有经验和耐心的甚至可以通过jni方法追踪来分析代码。
• dex vmp的框架设计和运行原理跟我早起读过的dvm虚拟机的解释模式基本差不多。
• dex vmp的指令设计是跟davlik指令有着一对一的关系，可以说只是一个简单的对照关系，这导致如果对于davlik指令足够熟悉，相当于对于dex vmp的指令熟悉。
  对于一个vmp虚拟机，如果你熟悉他的程序，熟悉他的指令，知道如何测试他（通过jni将dex vmp当作黑河测试），这种情况下，即使不去完全的人肉分析每一条指令，完全通过测试分析，也是可以慢慢进行还原的。

已知的保护措施

这个已知保护措施是dex vmp在可被逆向的情况下，如果提高一些安全性

• 指令对照加密进行动态版本变更
• 指令参数再加一层对照加密
  目前就知道这两个，如果dex vmp对照表已经被破解，如果有这两种保护措施，也无法被自动换还原。

不知道有没有一种通讯协议进行加解密破解的感觉，而dex vmp是一种拥有一定规律，可被暴力分析和破解的算法

易分析的davlik指令

分析vmp指令，对他进行还原的时候，并没有非常具体的写。在这里一切写，这是一些写davlik指令，或者说反编译分析davlik的一些经验。
davlik指令是非常容易分析的，基本不太存在保护的价值，因为一般的防护扛不住静态分析工具的分析，这个他的设计是有很大关系的。

上下文关联性强，基本都是编译器自动生成，不存在dalvik底层对抗问题

dalvik中的部分指令有很强的关联性。比如

1 2	0000: invoke-static       {}, Lcom/hepta/davlik/JvmRuntime;->getClassLoaderList()[Ljava/lang/ClassLoader; # method@0012 0003: move-result-object  v0

前面这个invoke-static ,如果有返回值，必会跟这后面这条指令，甚至可以说他们是一条指令

1 2	001e: const-string        v2, "/libjvmRuntime.so" # string@0006 0020: invoke-virtual      {v1, v2}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder; # method@0028

变量在定义之后，有大概率在下一条就会使用，当然不是绝对

1 2	000b: new-instance        v1, Ljava/lang/StringBuilder; # type@001f 000d: invoke-direct       {v1}, Ljava/lang/StringBuilder;-><init>()V # method@0026

这是new一个对象的代码，会立即调用init方法

1 2 3

return-void return-object return vAA

函数结束必有return指令，当然遇到return不一定是结束。但是进行人工还原的时候通过上下文分析函数结束位置，还是非常有价值的。

变量类型明确，指令基本很少有歧义性

有很多操作相同，但是操作类型却不同的指令

这一条aget指令，针对于各种不同的类型有不同的指令。在指令中有个对应的索引，我们甚至可以直接查看这个类型来反向推理这个指令操作的是什么类型。这种设计也从侧面给说明了，dalvik一个指令只有一个解释，没有歧义性，不想汇编，c，不知道类型，更不知道操作具体是什么，只是数据进行了操作。即使是一些虚函数，java中你可能分不出来他具体调用的是那个类的，但是在dalvik中，这个类的类型已经写死在索引中了。

真正的功能指令少

虽然dalvik号称256个opcode，但是有很多不用的，还有一些是同一个功能，但是不同类型

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

switch (opcode.format) {            case Format10t:                return new FixDexBackedInstruction10t(dexFile, opcode, instructionStartOffset,reader);            case Format10x:                return new DexBackedInstruction10x(dexFile, opcode, instructionStartOffset);  //            case Format11n:                return new FixDexBackedInstruction11n(dexFile, opcode, instructionStartOffset,reader);            case Format11x:                return new FixDexBackedInstruction11x(dexFile, opcode, instructionStartOffset,reader);            case Format12x:                return new FixDexBackedInstruction12x(dexFile, opcode, instructionStartOffset,reader);            case Format20bc:                return new FixDexBackedInstruction20bc(dexFile, opcode, instructionStartOffset,reader);            case Format20t:                return new FixDexBackedInstruction20t(dexFile, opcode, instructionStartOffset,reader);            case Format21c:                return new FixDexBackedInstruction21c(dexFile, opcode, instructionStartOffset,reader);            case Format21ih:                return new FixDexBackedInstruction21ih(dexFile, opcode, instructionStartOffset,reader);            case Format21lh:                return new FixDexBackedInstruction21lh(dexFile, opcode, instructionStartOffset,reader);            case Format21s:                return new FixDexBackedInstruction21s(dexFile, opcode, instructionStartOffset,reader);            case Format21t:                return new FixDexBackedInstruction21t(dexFile, opcode, instructionStartOffset,reader);            case Format22b:                return new FixDexBackedInstruction22b(dexFile, opcode, instructionStartOffset,reader);            case Format22c:                return new FixDexBackedInstruction22c(dexFile, opcode, instructionStartOffset,reader);            case Format22cs:                return new FixDexBackedInstruction22cs(dexFile, opcode, instructionStartOffset,reader);            case Format22s:                return new FixDexBackedInstruction22s(dexFile, opcode, instructionStartOffset,reader);            case Format22t:                return new FixDexBackedInstruction22t(dexFile, opcode, instructionStartOffset,reader);            case Format22x:                return new FixDexBackedInstruction22x(dexFile, opcode, instructionStartOffset,reader);            case Format23x:                return new FixDexBackedInstruction23x(dexFile, opcode, instructionStartOffset,reader);            case Format30t:                return new FixDexBackedInstruction30t(dexFile, opcode, instructionStartOffset,reader);            case Format31c:                return new FixDexBackedInstruction31c(dexFile, opcode, instructionStartOffset,reader);            case Format31i:                return new FixDexBackedInstruction31i(dexFile, opcode, instructionStartOffset,reader);            case Format31t:                return new FixDexBackedInstruction31t(dexFile, opcode, instructionStartOffset,reader);            case Format32x:                return new FixDexBackedInstruction32x(dexFile, opcode, instructionStartOffset,reader);            case Format35c:                return new FixDexBackedInstruction35c(dexFile, opcode, instructionStartOffset,reader);            case Format35ms:                return new FixDexBackedInstruction35ms(dexFile, opcode, instructionStartOffset,reader);            case Format35mi:                return new FixDexBackedInstruction35mi(dexFile, opcode, instructionStartOffset,reader);            case Format3rc:                return new FixDexBackedInstruction3rc(dexFile, opcode, instructionStartOffset,reader);            case Format3rmi:                return new FixDexBackedInstruction3rmi(dexFile, opcode, instructionStartOffset,reader);            case Format3rms:                return new FixDexBackedInstruction3rms(dexFile, opcode, instructionStartOffset,reader);            case Format45cc:                return new FixDexBackedInstruction45cc(dexFile, opcode, instructionStartOffset,reader);            case Format4rcc:                return new FixDexBackedInstruction4rcc(dexFile, opcode, instructionStartOffset,reader);            case Format51l:                return new FixDexBackedInstruction51l(dexFile, opcode, instructionStartOffset,reader);            case PackedSwitchPayload:                return new FixDexBackedPackedSwitchPayload(dexFile, instructionStartOffset,reader);            case SparseSwitchPayload:                return new FixDexBackedSparseSwitchPayload(dexFile, instructionStartOffset,reader);            case ArrayPayload:                return new FixDexBackedArrayPayload(dexFile, instructionStartOffset,reader);            default:                throw new ExceptionWithContext("Unexpected opcode format: %s", opcode.format.toString());

这是smali解析的dalvik指令，就上面这些功能，不算多。

指令以方法为单位，封闭性好

dalvik的指令如果想要运行，必须在一个method里，不可能超出一个函数的范围，更不可能先汇编语言那样全局的大跳，动态跳转地址，每一个函数都是一个密封的黑盒，当然可能会有一些类变量什么的，但是就代码含义分析这一块基本没问题。

Future

一般在这个位置都是要吹牛逼的，但是我发现牛逼可能成真，就留个悬念。

最后

如果真的觉得可以就关注一下公众号吧。也不发图推广了。
哦，对了，我这脚本配合人工半自动换，是可以做到一个函数一个函数还原的，我经过测试了，图，就不贴，怕人找，虽然目前没人找过。
我随便找的其中的某个样本，发的照片，很多样本好像都差不多，都是这个逆向思路