2014 NAGA&PIOWIND APP应用攻防竞赛 Crackme04
Java层比较简单
查看so，发现加密，依旧dump，IDA调试时未发现有反调试，不过有那么一瞬间看到了inotify，没具体看
auto fp, dex_addr, end_addr;
fp = fopen("E:\\libcrackme.so", "wb");
for(dex_addr = 0xA357D000; dex_addr < 0xA35DE000; dex_addr++)
fputc(Byte(dex_addr), fp);修复dump后的so文件头，使用IDA打开，关键的依旧是这个函数
但是我们跟入后，发现壳好像没有脱干净（后来发现其实不是没脱干净）
再次动态调试脱壳，这次我们找到校验函数，单步跟下去看看具体是什么情况
我们需要先找到校验函数的地址，使用给dvmUseJNIBridge函数下断点的方法
我们使用调试模式启动应用，IDA挂上去，找到libdvm.so的dvmUseJNIBridge函数，下断点
然后把IDA跑起来，在应用界面输入账号密码，点击登录，就可以发现断在这里了，我们注意观察参数，第二个参数就是我们的crackme函数
跟过去，可以看到确实是校验函数
找到我们看到是跳转地址的地方
双击过去
再次双击过去，发现是关键加解密点了，此时我们记录一下这个地址
再次dump这个so文件
动静结合，接下来看能力了
入口的数据初始化，然后调用_Unwind_GetCFAB，这和前几题是类似的
跟入，开始做了一些参数的存储操作，然后存储了_Unwind_GetCFAB函数的指针到栈中
LOAD:0002DB28 STMFD SP!, {R4,R11,LR}
LOAD:0002DB2C ADD R11, SP, #8
LOAD:0002DB30 SUB SP, SP, #0x24
LOAD:0002DB34 LDR R4, =(off_46CC8 - 0x2DB40)
LOAD:0002DB38 ADD R4, PC, R4 ; off_46CC8 ; 神奇的地址，暂时不知道干什么的
LOAD:0002DB3C STR R0, [R11,#var_20] ; R0 = var_20 = szUserName
LOAD:0002DB40 STR R1, [R11,#var_24] ; R1 = var_24 = szRegCode
LOAD:0002DB44 MOV R3, #0 ; R3 = 0
LOAD:0002DB48 STR R3, [R11,#var_18] ; R3 = var_18 = 0
LOAD:0002DB4C LDR R3, =dword_2CC ; R3 = 0x2CC
LOAD:0002DB50 LDR R3, [R4,R3]
LOAD:0002DB54 LDR R3, [R3]
LOAD:0002DB58 STR R3, [R11,#var_14] ; var_14为_Unwind_GetCFAB函数指针一开始并没有看出来，所以使用了动态调试来确定
接下来的操作是为了调用tdog_decrypt而做参数的计算
LOAD:0002DB5C LDR R3, =dword_2CC ; R3 = 0x2CC
LOAD:0002DB60 LDR R3, [R4,R3]
LOAD:0002DB64 LDR R3, [R3] ; R3 = _Unwind_GetCFAB
LOAD:0002DB68 ADD R3, R3, #0x14 ; R3 = _Unwind_GetCFAB + 0x14
LOAD:0002DB6C MOV R1, R3 ; R1 = R3 = R3 = _Unwind_GetCFAB + 0x14
LOAD:0002DB70 LDR R3, =dword_2B0 ; R3 = 0x2B0
LOAD:0002DB74 LDR R3, [R4,R3]
LOAD:0002DB78 LDR R3, [R3] ; 动调 : R3 = 0x104
LOAD:0002DB7C SUB R2, R3, #0x14 ; R2 = 0xF0
LOAD:0002DB80 LDR R3, =dword_2CC ; R3 = 0x2CC
LOAD:0002DB84 LDR R3, [R4,R3]
LOAD:0002DB88 LDR R3, [R3] ; R3 = _Unwind_GetCFAB
LOAD:0002DB8C ADD R3, R3, #0x14 ; R3 = _Unwind_GetCFAB + 0x14
LOAD:0002DB90 LDR R0, =dword_1D4 ; R0 = 0x1D4
LOAD:0002DB94 LDR R0, [R4,R0]
LOAD:0002DB98 LDR R0, [R0]
LOAD:0002DB9C STR R0, [SP,#0x2C+var_2C] ; var_2C = abs_export_function_key
LOAD:0002DBA0 MOV R0, R1 ; R0 = _Unwind_GetCFAB + 0x14
LOAD:0002DBA4 MOV R1, R2 ; R1 = R2 = 0xF0
LOAD:0002DBA8 MOV R2, R3 ; R3 = _Unwind_GetCFAB + 0x14
LOAD:0002DBAC LDR R3, =dword_314 ; R3 = 0x314
LOAD:0002DBB0 LDR R3, [R4,R3] ; 指向内存
LOAD:0002DBB4 BL tdog_decrypt看名字就可以猜到这个函数很重要
tdog_decrypt(_Unwind_GetCFAB + 0x14, 0xF0, _Unwind_GetCFAB + 0x14, 某内存变量指针)双击跟入，发现其调用了一个XorArray()函数
LOAD:000387F8 STMFD SP!, {R11,LR}
LOAD:000387FC ADD R11, SP, #4
LOAD:00038800 SUB SP, SP, #0x10
LOAD:00038804 ; 5: v5 = a2;
LOAD:00038804 STR R0, [R11,#var_8] ; R0 = var_8 = _Unwind_GetCFAB + 0x14
LOAD:00038808 STR R1, [R11,#var_C] ; R1 = var_C = 0xF0
LOAD:0003880C ; 6: v6 = a4;
LOAD:0003880C STR R2, [R11,#var_10] ; R2 = var_10 = _Unwind_GetCFAB + 0x14
LOAD:00038810 STR R3, [R11,#var_14] ; R3 = var_14 = 第四个参数，为一个指针
LOAD:00038814 ; 7: XorArray(a5, a1, a1, a2);
LOAD:00038814 LDR R2, [R11,#var_8] ; R2 = _Unwind_GetCFAB + 0x14
LOAD:00038818 LDR R3, [R11,#var_8] ; R3 = _Unwind_GetCFAB + 0x14
LOAD:0003881C LDR R0, [R11,#arg_0] ; 动调 : R0 = 0x5F7C8B38
LOAD:00038820 MOV R1, R2 ; R1 = R2 = _Unwind_GetCFAB + 0x14
LOAD:00038824 MOV R2, R3 ; R2 = R3 = _Unwind_GetCFAB + 0x14
LOAD:00038828 LDR R3, [R11,#var_C] ; R3 = 0xF0
LOAD:0003882C BL _Z8XorArrayjPhS_j ; XorArray(uint,uchar *,uchar *,uint)在XorArray函数里有一个PolyXorKey函数，用于生成秘钥，这个函数在后续的娜迦壳里面是一个比较重要的特征，后续的类抽取技术里就有用到这个函数进行秘钥的计算
我一直觉得这里加了junk code，前面有些指令反复做同样的操作时我就感觉出来了，但是加的junk code并不是很多，比如这该函数的第一个函数块后面的几句
LOAD:00038D7C STMFD SP!, {R11,LR}
LOAD:00038D80 ADD R11, SP, #4
LOAD:00038D84 SUB SP, SP, #0x20
LOAD:00038D88 ; 10: v6 = a2;
LOAD:00038D88 STR R0, [R11,#var_18] ; var_18 = 0X5F7C8B38 //神秘变量
LOAD:00038D8C STR R1, [R11,#var_1C] ; var_1C = _Unwind_GetCFAB + 0x14
LOAD:00038D90 ; 11: v5 = a3;
LOAD:00038D90 STR R2, [R11,#var_20] ; var_20 = _Unwind_GetCFAB + 0x14
LOAD:00038D94 ; 12: v4 = a4;
LOAD:00038D94 STR R3, [R11,#var_24] ; var_24 = 0xF0
LOAD:00038D98 ; 13: v7 = result;
LOAD:00038D98 LDR R3, [R11,#var_18] ; R3 = 0X5F7C8B38 //神秘，神秘
LOAD:00038D9C STR R3, [R11,#var_14] ; var_14 = 0X5F7C8B38 //又是神秘
LOAD:00038DA0 ; 14: v8 = &v7;
LOAD:00038DA0 SUB R3, R11, #-var_14
LOAD:00038DA4 STR R3, [R11,#var_10] ; R3存储的是神秘变量0X5F7C8B38的指针
LOAD:00038DA8 ; 15: v10 = 0;
LOAD:00038DA8 MOV R3, #0 ; R3 = 0
LOAD:00038DAC STR R3, [R11,#var_C] ; var_C = 0
LOAD:00038DB0 MOV R3, #0 ; R3 = 0
LOAD:00038DB4 STR R3, [R11,#var_8] ; var_8 = 0
LOAD:00038DB8 ; 16: for ( i = 0; v4 > i; ++i )
LOAD:00038DB8 MOV R3, #0 ; R3 = 0
LOAD:00038DBC STR R3, [R11,#var_C] ; R3 = 0
LOAD:00038DC0 B loc_38E40开始进入循环
LOAD:00038E40 loc_38E40 ;
LOAD:00038E40 LDR R2, [R11,#var_24] ; R2 = 0xF0 = 240
LOAD:00038E44 LDR R3, [R11,#var_C] ; R3 = i
LOAD:00038E48 CMP R2, R3
LOAD:00038E4C MOVLE R3, #0
LOAD:00038E50 MOVGT R3, #1 ; 循环中使用这一句 : i < 240 --- > R3 = 1
LOAD:00038E54 AND R3, R3, #0xFF ; 用于判断是否到达退出条件
LOAD:00038E58 CMP R3, #0
LOAD:00038E5C BNE loc_38DC4两个基址获取字节数据，进行异或操作，异或后的数据，存在_Unwind_GetCFAB + 0x14 + i指向的字节
LOAD:00038DC4 ; 19: v5[i] = v6[i] ^ *((_BYTE *)v8 + v10);
LOAD:00038DC4 loc_38DC4 ;
LOAD:00038DC4 LDR R3, [R11,#var_C] ; R3 = i
LOAD:00038DC8 LDR R2, [R11,#var_20] ; R2 = _Unwind_GetCFAB + 0x14
LOAD:00038DCC ADD R3, R2, R3 ; R3 = _Unwind_GetCFAB + 0x14 + i
LOAD:00038DD0 LDR R2, [R11,#var_C] ; R2 = i
LOAD:00038DD4 LDR R1, [R11,#var_1C] ; R1 = _Unwind_GetCFAB + 0x14
LOAD:00038DD8 ADD R2, R1, R2 ; R2 = _Unwind_GetCFAB + 0x14 + i
LOAD:00038DDC ; 18: result = (int)v8;
LOAD:00038DDC LDRB R1, [R2] ; 取第一个字节，动调 : R1 = 0xBB
LOAD:00038DE0 LDR R2, [R11,#var_8] ; R2 = j
LOAD:00038DE4 LDR R0, [R11,#var_10] ; R0为神秘变量指针
LOAD:00038DE8 ADD R2, R0, R2 ; R2 = 神秘变量指针 + j
LOAD:00038DEC LDRB R2, [R2] ; 取第一个字节，动调 : 0x38
LOAD:00038DF0 EOR R2, R1, R2 ; 两个取出来的字节异或
LOAD:00038DF4 AND R2, R2, #0xFF
LOAD:00038DF8 STRB R2, [R3]
LOAD:00038DFC ; 20: if ( v10 == 3 )
LOAD:00038DFC LDR R3, [R11,#var_8]
LOAD:00038E00 CMP R3, #3
LOAD:00038E04 BNE loc_38E28这里是在计算一个四字节的数据
我们在内存中跟随，可以看到这四个字节的数据已经修改成了83 93 00 23，不清楚的同学可以在异或的地方下个断点循环调试看看
接着是调用PolyXorKey，参数是神秘变量自身
LOAD:00038E08 ; 22: result = PolyXorKey(v7);
LOAD:00038E08 LDR R3, [R11,#var_14] ; 取出神秘变量
LOAD:00038E0C MOV R0, R3 ; 神秘变量作为参数R0
LOAD:00038E10 BL _Z10PolyXorKeyj ; PolyXorKey(先使用异或操作对神秘变量进行修改
LOAD:00038BC8 STR R11, [SP,#-4+var_s0]!
LOAD:00038BCC ADD R11, SP, #0
LOAD:00038BD0 SUB SP, SP, #0x24
LOAD:00038BD4 ; 11: v4 = 0;
LOAD:00038BD4 STR R0, [R11,#var_20] ; var_20 = 神秘变量
LOAD:00038BD8 MOV R3, #0 ; R3 = 0
LOAD:00038BDC STR R3, [R11,#var_18] ; var_18 = 0
LOAD:00038BE0 MOV R3, #0 ; R3 = 0
LOAD:00038BE4 STR R3, [R11,#var_14] ; var_14 = 0
LOAD:00038BE8 ; 12: v5 = 0;
LOAD:00038BE8 MOV R3, #0 ; R3 = 0
LOAD:00038BEC STR R3, [R11,#var_10] ; var_10 = 0
LOAD:00038BF0 ; 13: v6 = (char *)&v2;
LOAD:00038BF0 SUB R3, R11, #-var_20
LOAD:00038BF4 STR R3, [R11,#var_C] ; var_C为神秘变量指针
LOAD:00038BF8 ; 14: v7 = 0;
LOAD:00038BF8 MOV R3, #0 ; R3 = 0
LOAD:00038BFC STRB R3, [R11,#var_7] ; var_7指向的byte为0
LOAD:00038C00 ; 15: v8 = 0;
LOAD:00038C00 MOV R3, #0
LOAD:00038C04 STRB R3, [R11,#var_6] ; var_6指向的byte为0
LOAD:00038C08 ; 16: v9 = 0;
LOAD:00038C08 MOV R3, #0
LOAD:00038C0C STRB R3, [R11,#var_5] ; var_5指向的byte为0
LOAD:00038C10 ; 17: v2 = a1 ^ 0xDF138530;
LOAD:00038C10 LDR R3, [R11,#var_20] ; R3 = 神秘变量
LOAD:00038C14 MOV R2, R3 ; R2 = R3 = 神秘变量
LOAD:00038C18 LDR R3, =0xDF138530 ; R3 = 0xDF138530
LOAD:00038C1C EOR R3, R2, R3 ; 神秘变量异或 ---> R3 = 0x5F7C8B38 ^ 0xDF138530
LOAD:00038C20 STR R3, [R11,#var_20] ; 修改神秘变量为0x806F0E08
LOAD:00038C24 ; 18: v3 = 0;
LOAD:00038C24 MOV R3, #0 ; R3 = 0
LOAD:00038C28 STR R3, [R11,#var_18] ; var_18 = 0
LOAD:00038C2C B loc_38D48进入大循环，整个大循环就是循环计算神秘变量的四个字节，但是内部又有很多的循环计算
LOAD:00038D48 ; 19: while ( v3 <= 3 )
LOAD:00038D48 loc_38D48 ; 开始循环计算
LOAD:00038D48 LDR R3, [R11,#var_18] ; R3 = i
LOAD:00038D4C CMP R3, #3 ; 条件判断 i < 4
LOAD:00038D50 MOVGT R3, #0
LOAD:00038D54 MOVLE R3, #1
LOAD:00038D58 AND R3, R3, #0xFF
LOAD:00038D5C CMP R3, #0
LOAD:00038D60 BNE loc_38C30取字节，这里的var_C会在后面自加一
LOAD:00038C30 ; 21: v7 = *v6;
LOAD:00038C30 loc_38C30 ;
LOAD:00038C30 LDR R3, [R11,#var_C] ; R3为神秘变量指针
LOAD:00038C34 LDRB R3, [R3] ; 获取计算后的神秘变量的字节
LOAD:00038C38 STRB R3, [R11,#var_7] ; var_7 = 08
LOAD:00038C3C ; 22: v4 = 128;
LOAD:00038C3C MOV R3, #0x80 ; '€' ; R3 = 0x80
LOAD:00038C40 STR R3, [R11,#var_14] ; var_14 = 0x80
LOAD:00038C44 ; 23: v5 = 7;
LOAD:00038C44 MOV R3, #7 ; R3 = 0x7
LOAD:00038C48 STR R3, [R11,#var_10] ; var_10 = 0x7
LOAD:00038C4C B loc_38CE0内部的循环
LOAD:00038CE0 ; 24: while ( v4 > 1 )
LOAD:00038CE0
LOAD:00038CE0 loc_38CE0 ;
LOAD:00038CE0 LDR R3, [R11,#var_14] ; R3 = 0x80
LOAD:00038CE4 CMP R3, #1
LOAD:00038CE8 MOVLE R3, #0
LOAD:00038CEC MOVGT R3, #1
LOAD:00038CF0 AND R3, R3, #0xFF
LOAD:00038CF4 CMP R3, #0
LOAD:00038CF8 BNE loc_38C50接下来的循环计算可以还原出C代码，但是具体是什么数学算法之类的就不是很清楚了，可能只是个计算，这个函数最终的功能目测应该是计算一个四字节的数据作为返回值
LOAD:00038C50 ; 27: v8 = ((signed int)(unsigned __int8)(v7 & v4) >> v5) ^ v9;
LOAD:00038C50 loc_38C50 ; 进入循环，重命名神秘变量为sec
LOAD:00038C50 LDRB R2, [R11,#var_7] ; R2 = 0x08
LOAD:00038C54 LDR R3, [R11,#var_14] ; R3 = 0x80
LOAD:00038C58 AND R2, R2, R3 ; R2 = sec[i] & 0x80
LOAD:00038C5C LDR R3, [R11,#var_10] ; R3 = 0x07
LOAD:00038C60 MOV R3, R2,ASR R3 ; R3 = (sec[i] & 0x80) / 0x07
LOAD:00038C64 ; 26: v9 = (v7 & v4 / 2) >> (v5 - 1);
LOAD:00038C64 STRB R3, [R11,#var_6] ; var_6 = (sec[i] & 0x80) / 0x07
LOAD:00038C68 LDRB R2, [R11,#var_7] ; R2 = sec[i]
LOAD:00038C6C LDR R3, [R11,#var_14] ; R3 = 0x80
LOAD:00038C70 MOV R1, R3,LSR#31 ; R1 = 0x00000080 >> 31 = 0
LOAD:00038C74 ADD R3, R1, R3 ; R3 = 0x80
LOAD:00038C78 MOV R3, R3,ASR#1 ; R3 = 0x80 / 2
LOAD:00038C7C AND R2, R2, R3 ; R2 = sec[i] & (0x80 / 2)
LOAD:00038C80 LDR R3, [R11,#var_10] ; R3 = 0x07
LOAD:00038C84 SUB R3, R3, #1 ; R3 = 0x07 - 1
LOAD:00038C88 MOV R3, R2,ASR R3 ; R3 = (sec[i] & (0x80 / 2)) / (0x07 - 1)
LOAD:00038C8C STRB R3, [R11,#var_5] ; var_5存储计算后的结果
LOAD:00038C90 LDRB R2, [R11,#var_6] ; R2 = (sec[i] & 0x80) / 0x07
LOAD:00038C94 LDRB R3, [R11,#var_5] ; R3 = (sec[i] & (0x80 / 2)) / (0x07 - 1)
LOAD:00038C98 EOR R3, R2, R3 ; 上面两个进行异或，存储到R3
LOAD:00038C9C STRB R3, [R11,#var_6] ; 异或结果存储到var_6
LOAD:00038CA0 ; 28: v8 <<= v5;
LOAD:00038CA0 LDRB R2, [R11,#var_6] ; R2 = 异或结果
LOAD:00038CA4 LDR R3, [R11,#var_10] ; R3 = 0x07
LOAD:00038CA8 MOV R3, R2,LSL R3 ; R3 = 异或结果 << 0x07
LOAD:00038CAC STRB R3, [R11,#var_6] ; var_6 = 异或结果 << 0x07
LOAD:00038CB0 ; 29: v7 |= v8;
LOAD:00038CB0 LDRB R2, [R11,#var_7] ; R2 = sec[i]
LOAD:00038CB4 LDRB R3, [R11,#var_6] ; R3 = 异或结果 << 0x07
LOAD:00038CB8 ORR R3, R2, R3 ; R3 = sec[i] | (异或结果 << 0x07)
LOAD:00038CBC STRB R3, [R11,#var_7] ; var_7 = sec[i] | (异或结果 << 0x07)
LOAD:00038CC0 ; 30: v4 /= 2;
LOAD:00038CC0 LDR R3, [R11,#var_14] ; R3 = 0x80
LOAD:00038CC4 MOV R2, R3,LSR#31 ; R2 = 0
LOAD:00038CC8 ADD R3, R2, R3 ; R3 = 0x80
LOAD:00038CCC MOV R3, R3,ASR#1 ; R3 = 0x80 / 2
LOAD:00038CD0 STR R3, [R11,#var_14] ; var_14 = 0x80 / 2 //这里应该是这个变量循环除2
LOAD:00038CD4 ; 31: --v5;
LOAD:00038CD4 LDR R3, [R11,#var_10] ; 0x07-- //这里也是这个变量循环自减一结果作为下次循环的值
LOAD:00038CD8 SUB R3, R3, #1
LOAD:00038CDC STR R3, [R11,#var_10]直接在最后面下个断点跑完这个函数，可以看到返回值是0x80FF1E18
这是整个大循环
回到上一层函数，这个值应该是固定的，暂时没有看到有其它参数对这个计算过程造成了影响
一边分析一边写的，估计有些地方会分析错
这个函数整个大循环是0xF0次，也就是240次，我们来验证一下PolyXorKey函数是否每次都是生成一样的数据
0xFFFCBF78
0x60FF7ED8
0xFFFCFFF8
0x60FFFED8
0xFFFCFFF8
0x60FFFED8
0xFFFCFFF8
0x60FFFED8
0xFFFCFFF8
..........
0xFFFCFFF8开始变成两个常数的交替出现，难道是动态调试出问题了
这里非常绕，跟了好几次都没有找到关键的地方，后来半猜半想，根据调用operator new[]()的函数往回找，找到了和前几题一样的函数，虽然这里算法不一样，但是对于用户名和注册码的存储还是一样的
接下来是校验的地方，单步走一遍先，找到关键的地方，可以看到这里调用了四个函数
但是在静态时这位置我是手动找的，这个费劲，有的函数没有识别出来，红色的
其实还有非常多的函数未识别出来，不过并不是很重要
由于前面没有完整的跟过来，所以这里的一些偏移需要根据动态调试确定指向的数据是什么
那么0x34偏移指向的就是用户名
并且有长度的限制，用户名长度应该在[8, 24]之间
LOAD:00005E66 MOVS R0, R3 ; s
LOAD:00005E68 BLX strlen ; 获取用户名长度
LOAD:00005E6C MOVS R6, R0 ; R6 = R0 = 用户名长度
LOAD:00005E6E SUBS R6, #8 ; R6 = strlen(UserName) - 8
LOAD:00005E70 MOVS R0, R5 ; s
LOAD:00005E72 BLX strlen ; 获取注册码长度
LOAD:00005E76 CMP R6, #0x16 ; 对比strlen(UserName) - 8和0x16
LOAD:00005E78 BHI loc_5E80偏移0x38指向的是注册码，注册码长度需要在[12, 100]之间
LOAD:00005E7A SUBS R0, #0xC
LOAD:00005E7C CMP R0, #0x58 ; 'X' ; 对比strlen(RegCode) - 0xC和0x58
LOAD:00005E7E BLS loc_5E94第二个函数比较长
获取用户名
LOAD:00005D48 PUSH {LR}
LOAD:00005D4A SUB SP, SP, #0x2C
LOAD:00005D4C STR R0, [SP,#0x30+var_20] ; 结构体基址
LOAD:00005D4E LDR R0, [R0,#0x34] ; 获取用户名
LOAD:00005D50 BLX strlen ; R0 = 用户名长度
LOAD:00005D54 CMP R0, #7 ; 用户名长度与7进行对比
LOAD:00005D56 BGT loc_5D6E ; 用户名长度需要大于7 ---> strlen(UserMame) >= 8存储一下中间变量
LOAD:00005D84 loc_5D84
LOAD:00005D84 LDR R3, =(dword_16AF8 - 0x5D8A)
LOAD:00005D86 ADD R3, PC ; dword_16AF8
LOAD:00005D88 ADDS R3, #0x30 ; '0' ; env
LOAD:00005D8A STR R3, [SP,#0x30+env] ; 将env变量存储到栈中
LOAD:00005D8C STR R3, [SP,#0x30+var_C] ; var_C = env进入一个0x08 * 0x100次的循环，循环获取用户名的前八位数据
LOAD:00005D9E loc_5D9E ;
LOAD:00005D9E LDR R1, [SP,#0x30+var_20] ; R1为结构体基址
LOAD:00005DA0 LDR R2, [SP,#0x30+var_28] ; R2 = 0
LOAD:00005DA2 LDR R3, [R1,#0x34] ; R3 = pUserName
LOAD:00005DA4 LDRB R3, [R3,R2] ; 循环取用户名的字节数据
LOAD:00005DA6 STR R3, [SP,#0x30+var_2C] ; 获取的数据暂存栈中获取一个关键偏移
LOAD:00005DA8 loc_5DA8 ;
LOAD:00005DA8 MOVS R3, #0 ; R3 = 0
LOAD:00005DAA STR R3, [SP,#0x30+var_24] ; var_24 = 0
LOAD:00005DAC LDR R3, =(dword_16AF8 - 0x5DB4)
LOAD:00005DAE LDR R1, =0x104B2 ; R1 = 0x104B2
LOAD:00005DB0 ADD R3, PC ; dword_16AF8 ; 定位结构体基址
LOAD:00005DB2 ADDS R3, #0x30 ; '0' ; env
LOAD:00005DB4 STR R3, [SP,#0x30+var_14] ; var_14 = env
LOAD:00005DB6 STR R1, [SP,#0x30+var_10] ; var_10 = 0x104B2这个偏移在这里的作用是重定位一个Table，通过和用户名相同的偏移来进行数据获取，然后两者异或
LOAD:00005DC8 loc_5DC8 ;
LOAD:00005DC8 LDR R3, [SP,#0x30+var_10] ; R3 = 0x104B2
LOAD:00005DCA LDR R2, [SP,#0x30+var_24] ; R2 = i
LOAD:00005DCC LDR R1, [SP,#0x30+var_2C] ; R1 = UserName[i]
LOAD:00005DCE ADD R3, PC ; 动调 : R3 = 0xA33E8284
LOAD:00005DD0 ADDS R3, #0x38 ; '8'
LOAD:00005DD2 LDRB R3, [R2,R3] ; 同一偏移取某地址字节数据
LOAD:00005DD4 EORS R3, R1 ; 两个地址同偏移数据异或
LOAD:00005DD6 LSLS R3, R3, #0x18 ; 这两句效果等效&0xFF
LOAD:00005DD8 LSRS R3, R3, #0x18
LOAD:00005DDA STR R3, [SP,#0x30+var_2C]大概就是
var_2C = ((byte) UserName[i] ^ (byte) Table[i]) & 0xFF最后进行次数的判断
LOAD:00005DDC loc_5DDC ;
LOAD:00005DDC LDR R2, [SP,#0x30+var_24] ; var_24 = i
LOAD:00005DDE MOVS R3, #0x100 ; R3 = 0x100
LOAD:00005DE2 ADDS R2, #1 ; i++
LOAD:00005DE4 STR R2, [SP,#0x30+var_24]
LOAD:00005DE6 CMP R2, R3 ; i < 0x100 //循环0x100次
LOAD:00005DE8 BNE loc_5DB8每个字节一共是0x100次，动态调试把整个表dump出来
1A B7 00 3A 19 B7 00 2A 20 00 9D E5 C7 97 00 AA
C6 97 00 BA 91 03 03 E0 C8 3D 00 1A C7 3D 00 0A
48 60 9D E5 03 C2 00 CA 02 C2 00 DA 3C 40 8D E5
B4 3F 00 2A B3 3F 00 3A E7 76 27 E2 F0 31 00 6A
EF 31 00 7A DA 2C 4C E2 AE A2 00 1A AD A2 00 0A
0A 6B 86 E2 04 C1 00 4A 03 C1 00 5A B4 20 9D E5
B2 18 00 AA B1 18 00 BA 06 30 8A E0 83 0C 00 0A
82 0C 00 1A 0A 80 88 E0 FA BE 00 3A F9 BE 00 2A
0C 10 21 E0 4A 9D 00 0A 49 9D 00 1A 21 5A 8F E2
DE 5E 85 E2 00 50 95 E5 63 84 00 AA 62 84 00 BA
D8 70 9D E5 E6 09 00 CA E5 09 00 DA 91 02 02 E0
88 6B 00 6A 87 6B 00 7A 02 20 86 E0 DE 10 00 2A
DD 10 00 3A 87 3C 83 E2 31 C2 00 9A 30 C2 00 8A
9C B0 9D E5 EE A4 00 9A ED A4 00 8A DD 06 00 1A
8C 8A 00 3A 8B 8A 00 2A 71 25 82 E2 F0 0C 00 6A
EF 0C 00 7A FA 19 21 E2 65 AF 00 6A 64 AF 00 7A补充一点，这个表其实不是动态生成的，静态分析时就可以dump出来
因为异或的计算比较有意思，整个表循环异或一遍其实可以等效于异或一个值，这个值我们可以通过计算来确定，输入为0x00，看输出是什么即可
在IDA里将这个表保存为文件，使用WinHex打开，拷贝存为C Source
unsigned AnsiChar data[256] = {
0x1A, 0xB7, 0x00, 0x3A, 0x19, 0xB7, 0x00, 0x2A, 0x20, 0x00, 0x9D, 0xE5, 0xC7, 0x97, 0x00, 0xAA,
0xC6, 0x97, 0x00, 0xBA, 0x91, 0x03, 0x03, 0xE0, 0xC8, 0x3D, 0x00, 0x1A, 0xC7, 0x3D, 0x00, 0x0A,
0x48, 0x60, 0x9D, 0xE5, 0x03, 0xC2, 0x00, 0xCA, 0x02, 0xC2, 0x00, 0xDA, 0x3C, 0x40, 0x8D, 0xE5,
0xB4, 0x3F, 0x00, 0x2A, 0xB3, 0x3F, 0x00, 0x3A, 0xE7, 0x76, 0x27, 0xE2, 0xF0, 0x31, 0x00, 0x6A,
0xEF, 0x31, 0x00, 0x7A, 0xDA, 0x2C, 0x4C, 0xE2, 0xAE, 0xA2, 0x00, 0x1A, 0xAD, 0xA2, 0x00, 0x0A,
0x0A, 0x6B, 0x86, 0xE2, 0x04, 0xC1, 0x00, 0x4A, 0x03, 0xC1, 0x00, 0x5A, 0xB4, 0x20, 0x9D, 0xE5,
0xB2, 0x18, 0x00, 0xAA, 0xB1, 0x18, 0x00, 0xBA, 0x06, 0x30, 0x8A, 0xE0, 0x83, 0x0C, 0x00, 0x0A,
0x82, 0x0C, 0x00, 0x1A, 0x0A, 0x80, 0x88, 0xE0, 0xFA, 0xBE, 0x00, 0x3A, 0xF9, 0xBE, 0x00, 0x2A,
0x0C, 0x10, 0x21, 0xE0, 0x4A, 0x9D, 0x00, 0x0A, 0x49, 0x9D, 0x00, 0x1A, 0x21, 0x5A, 0x8F, 0xE2,
0xDE, 0x5E, 0x85, 0xE2, 0x00, 0x50, 0x95, 0xE5, 0x63, 0x84, 0x00, 0xAA, 0x62, 0x84, 0x00, 0xBA,
0xD8, 0x70, 0x9D, 0xE5, 0xE6, 0x09, 0x00, 0xCA, 0xE5, 0x09, 0x00, 0xDA, 0x91, 0x02, 0x02, 0xE0,
0x88, 0x6B, 0x00, 0x6A, 0x87, 0x6B, 0x00, 0x7A, 0x02, 0x20, 0x86, 0xE0, 0xDE, 0x10, 0x00, 0x2A,
0xDD, 0x10, 0x00, 0x3A, 0x87, 0x3C, 0x83, 0xE2, 0x31, 0xC2, 0x00, 0x9A, 0x30, 0xC2, 0x00, 0x8A,
0x9C, 0xB0, 0x9D, 0xE5, 0xEE, 0xA4, 0x00, 0x9A, 0xED, 0xA4, 0x00, 0x8A, 0xDD, 0x06, 0x00, 0x1A,
0x8C, 0x8A, 0x00, 0x3A, 0x8B, 0x8A, 0x00, 0x2A, 0x71, 0x25, 0x82, 0xE2, 0xF0, 0x0C, 0x00, 0x6A,
0xEF, 0x0C, 0x00, 0x7A, 0xFA, 0x19, 0x21, 0xE2, 0x65, 0xAF, 0x00, 0x6A, 0x64, 0xAF, 0x00, 0x7A
};写个程序跑一下
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
unsigned char xor_table[256] = {
0x1A, 0xB7, 0x00, 0x3A, 0x19, 0xB7, 0x00, 0x2A, 0x20, 0x00, 0x9D, 0xE5, 0xC7, 0x97, 0x00, 0xAA,
0xC6, 0x97, 0x00, 0xBA, 0x91, 0x03, 0x03, 0xE0, 0xC8, 0x3D, 0x00, 0x1A, 0xC7, 0x3D, 0x00, 0x0A,
0x48, 0x60, 0x9D, 0xE5, 0x03, 0xC2, 0x00, 0xCA, 0x02, 0xC2, 0x00, 0xDA, 0x3C, 0x40, 0x8D, 0xE5,
0xB4, 0x3F, 0x00, 0x2A, 0xB3, 0x3F, 0x00, 0x3A, 0xE7, 0x76, 0x27, 0xE2, 0xF0, 0x31, 0x00, 0x6A,
0xEF, 0x31, 0x00, 0x7A, 0xDA, 0x2C, 0x4C, 0xE2, 0xAE, 0xA2, 0x00, 0x1A, 0xAD, 0xA2, 0x00, 0x0A,
0x0A, 0x6B, 0x86, 0xE2, 0x04, 0xC1, 0x00, 0x4A, 0x03, 0xC1, 0x00, 0x5A, 0xB4, 0x20, 0x9D, 0xE5,
0xB2, 0x18, 0x00, 0xAA, 0xB1, 0x18, 0x00, 0xBA, 0x06, 0x30, 0x8A, 0xE0, 0x83, 0x0C, 0x00, 0x0A,
0x82, 0x0C, 0x00, 0x1A, 0x0A, 0x80, 0x88, 0xE0, 0xFA, 0xBE, 0x00, 0x3A, 0xF9, 0xBE, 0x00, 0x2A,
0x0C, 0x10, 0x21, 0xE0, 0x4A, 0x9D, 0x00, 0x0A, 0x49, 0x9D, 0x00, 0x1A, 0x21, 0x5A, 0x8F, 0xE2,
0xDE, 0x5E, 0x85, 0xE2, 0x00, 0x50, 0x95, 0xE5, 0x63, 0x84, 0x00, 0xAA, 0x62, 0x84, 0x00, 0xBA,
0xD8, 0x70, 0x9D, 0xE5, 0xE6, 0x09, 0x00, 0xCA, 0xE5, 0x09, 0x00, 0xDA, 0x91, 0x02, 0x02, 0xE0,
0x88, 0x6B, 0x00, 0x6A, 0x87, 0x6B, 0x00, 0x7A, 0x02, 0x20, 0x86, 0xE0, 0xDE, 0x10, 0x00, 0x2A,
0xDD, 0x10, 0x00, 0x3A, 0x87, 0x3C, 0x83, 0xE2, 0x31, 0xC2, 0x00, 0x9A, 0x30, 0xC2, 0x00, 0x8A,
0x9C, 0xB0, 0x9D, 0xE5, 0xEE, 0xA4, 0x00, 0x9A, 0xED, 0xA4, 0x00, 0x8A, 0xDD, 0x06, 0x00, 0x1A,
0x8C, 0x8A, 0x00, 0x3A, 0x8B, 0x8A, 0x00, 0x2A, 0x71, 0x25, 0x82, 0xE2, 0xF0, 0x0C, 0x00, 0x6A,
0xEF, 0x0C, 0x00, 0x7A, 0xFA, 0x19, 0x21, 0xE2, 0x65, 0xAF, 0x00, 0x6A, 0x64, 0xAF, 0x00, 0x7A
};
int main()
{
unsigned char test =0x00;
for (int i = 0; i < 256; i++)
{
test ^= xor_table[i];
}
printf("0x%x\n", test);
return 0;
}可以看到整个异或表的异或效果和单独异或0x93的效果是一样的
计算完后会判断计算后的数据是否为0
LOAD:00005DFE loc_5DFE ;
LOAD:00005DFE LDR R1, [SP,#0x30+var_1C] ; R1 = 异或后的数据
LOAD:00005E00 CMP R1, #0 ; 判断异或后的数据是否为0
LOAD:00005E02 BNE loc_5E1E如果是0，则会改为0x99
LOAD:00005E04 LDR R0, =(dword_16AF8 - 0x5E0A)
LOAD:00005E06 ADD R0, PC ; dword_16AF8
LOAD:00005E08 ADDS R0, #0x30 ; '0' ; env
LOAD:00005E0A BLX setjmp_0
LOAD:00005E0E MOVS R2, #0x99 ; '
LOAD:00005E10 STR R2, [SP,#0x30+var_2C] ; 如果计算后的数据为0，则改为0x99
LOAD:00005E12 CMP R0, #0
LOAD:00005E14 BEQ loc_5E1E每个字节计算完成存储到栈中，一共八次
LOAD:00005E1E loc_5E1E ;
LOAD:00005E1E LDR R2, [SP,#0x30+var_28] ; R2 = i
LOAD:00005E20 LDR R1, [SP,#0x30+var_20] ; R1 = 结构体基址
LOAD:00005E22 ADDS R3, R1, R2
LOAD:00005E24 LDR R2, [SP,#0x30+var_28]
LOAD:00005E26 MOV R1, SP
LOAD:00005E28 LDRB R1, [R1,#0x30+var_2C]
LOAD:00005E2A ADDS R3, #0x5A ; 'Z' ; 0x5A为计算后数据存储偏移
LOAD:00005E2C ADDS R2, #1
LOAD:00005E2E STRB R1, [R3] ; 将计算后的值存储到栈中
LOAD:00005E30 STR R2, [SP,#0x30+var_28]
LOAD:00005E32 CMP R2, #8 ; 计算8字节，那么取的就是用户名前8位
LOAD:00005E34 BNE loc_5D8E最终我们可以看到生成的8字节数据
在上图的位置下个断点，数据区跟随R3，可以看到完整的生成过程
第三个函数，就一个小循环，应该比较简单
后来分析下来是我错了，它不简单，参数之类的预处理
LOAD:000060A0 PUSH {R4-R6,LR}
LOAD:000060A2 LDR R3, =(off_15E9C - 0x60AC)
LOAD:000060A4 SUB SP, SP, #0x18
LOAD:000060A6 STR R0, [SP,#0x28+var_24] ; var_24 = 结构体基址
LOAD:000060A8 ADD R3, PC ; off_15E9C
LOAD:000060AA LDR R3, [R3] ; __stack_chk_guard
LOAD:000060AC ADD R0, SP, #0x28+s ; s
LOAD:000060AE MOVS R1, #0 ; R1 = 0
LOAD:000060B0 LDR R3, [R3]
LOAD:000060B2 MOVS R2, #0xA ; R2 = 0x0A
LOAD:000060B4 STR R3, [SP,#0x28+var_14] ; 栈保护
LOAD:000060B6 BLX memset ; memset(s, 0, 0x0A)
LOAD:000060BA LDR R0, =(dword_16AF8 - 0x60C0)
LOAD:000060BC ADD R0, PC ; dword_16AF8
LOAD:000060BE ADDS R0, #0x30 ; '0' ; env
LOAD:000060C0 BLX setjmp_0
LOAD:000060C4 SUBS R4, R0, #0 ; R4 = 0 //影响了标志位，这里用于判断函数的执行
LOAD:000060C6 BEQ loc_60CE调用了一个函数，这个函数可复杂了
LOAD:000060CE loc_60CE ;
LOAD:000060CE LDR R0, [SP,#0x28+var_24] ; R0 = 结构体基址
LOAD:000060D0 ADDS R0, #0x5A ; 'Z' ; 取出计算后的8字节数据
LOAD:000060D2 BL sub_57D4参数是计算后的8字节数据，里面有五个函数的调用，继续一个个跟
开始做参数的存储，重定位了一个Table
LOAD:000057D4 PUSH {R0-R2,R4-R7,LR}
LOAD:000057D6 LDR R4, =(dword_165F8 - 0x57E0)
LOAD:000057D8 MOVS R1, R0 ; R1 = R0 = 计算后的8字节数据
LOAD:000057DA MOVS R2, #0x40 ; '@' ; R2 = 0x40
LOAD:000057DC ADD R4, PC ; dword_165F8这个Table在动态调试的过程中是有值的
但是在静态分析的时候是空的，这里有一个0x30的偏移
我看到了后面一层又一层的，而且明显的跟其它数据分开了
我发现不对劲，而且这么多计算我都看不懂，于是开启猜测模式
这里应该是某加密，前面那个8字节应该是秘钥，然后后面的函数一个个看，看看有没有什么Table，现代加密算法一般都有各种Table去做计算
运气不错，发现了DES加密算法的S盒
它是八个二维数组，规格就是8 * 4 * 16
可以自行对比一下，当然也可以靠其它Table的特征
当然AES也有S盒，但是这两者的S盒是有很多区别的，比如AES的S盒如下
unsigned char sBox[] =
{ /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, /*0*/
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, /*1*/
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, /*2*/
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, /*3*/
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, /*4*/
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, /*5*/
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, /*6*/
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, /*7*/
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, /*8*/
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, /*9*/
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, /*a*/
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, /*b*/
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, /*c*/
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, /*d*/
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, /*e*/
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 /*f*/
};首先是规模不一样，其实是数量不一样，输入输出的值也都不一样
那么这里可以确定是DES加密算法，但是它是加密还是解密就需要再考量一下了
先放着，我们接着看代码，在初始化完秘钥后，开始给两个数组进行初始化操作
LOAD:000060D6 LDR R2, [SP,#0x28+var_24] ; R2 = 结构体基址
LOAD:000060D8 LDR R0, [R2,#0x38] ; R0 = s1 //结构体偏移0x38，为注册码
LOAD:000060DA BLX strlen ; R0 = strlen(s)
LOAD:000060DE LDR R5, [SP,#0x28+var_24] ; R5 = 结构体基址
LOAD:000060E0 LSRS R6, R0, #4 ; R6 = strlen(s) >> 4 //长度一定是非负，等效于除16
LOAD:000060E2 MOVS R1, R4 ; R1 = R4 = 0
LOAD:000060E4 ADDS R5, #0x3C ; '<' ; R5 = s2 //结构体偏移0x3C
LOAD:000060E6 MOVS R0, R5 ; R0 = R5 = s2
LOAD:000060E8 MOVS R2, #0x1E ; R2 = 0x1E
LOAD:000060EA BLX memset ; memset(s2, 0, 0x1E)
LOAD:000060EE B loc_6108顺带把注册码分为16字节每组，每组进行循环解密
LOAD:00006108 loc_6108
LOAD:00006108 CMP R4, R6
LOAD:0000610A BLT loc解密后的数据存储到s2，结构体偏移0x3C
LOAD:000060F0 loc_60F0 ;
LOAD:000060F0 LDR R2, [SP,#0x28+var_24] ; R2 = 结构体基址
LOAD:000060F2 LSLS R3, R4, #4 ; i << 4 //此处用于注册码偏移的跳转
LOAD:000060F4 ADD R0, SP, #0x28+s ; R0 = s = buffer
LOAD:000060F6 LDR R1, [R2,#0x38] ; R1 = s1 = 注册码
LOAD:000060F8 ADDS R4, #1
LOAD:000060FA ADDS R1, R1, R3
LOAD:000060FC BL sub_58F8 ; 此处入口对数据进行解密
LOAD:00006100 MOVS R0, R5 ; dest
LOAD:00006102 ADD R1, SP, #0x28+s ; src
LOAD:00006104 BLX strcat_0 ; 解密后的数据存储到s2最后第四个函数就是解密后的注册码和用户名进行对比，红色表示异常分支，蓝色表示正常循环，最后由两个灰色的代码块结束循环
我们来计算一组有效的KEY
不过好像出了点问题，哪里不对的样子
因为在分析的时候我注意到了取了用户名前8位进行计算秘钥，而且后续使用了十六位进行分组解密
所以这里单纯的使用了一个八字节字符串当做用户名进行输入
再次打个断点进行调试，看看解密后的数据是个啥
首先获取注册码
然后两组计算完后，得到解密后的数据
那这个就很尴尬了，怎么会多出八位
发现用Java的加解密库计算出来的数据并不正确，其实可能是校验的过程改了
正常情况下解密出来的数据应该是这样的
既然这样，那我就不客气了，去网上找DES的C代码实现
随意找了个代码，看到了S盒，想起刚才也是S盒，会不会S盒动了手脚，于是对比了一波S盒
首先把正常DES算法的S盒准备好
static char S_Box[8][4][16] = {
// S1
14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
// S2
15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,
// S3
10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
// S4
7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
// S5
2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,
// S6
12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
// S7
4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
// S8
13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
};然后将动态调试时的S盒dump出来
跟前面拷贝出xor_table一样，使用保存为文件，然后WinHex转为C Source
unsigned AnsiChar data[512] = {
0x0E, 0x04, 0x0D, 0x01, 0x02, 0x0F, 0x0B, 0x08, 0x03, 0x0A, 0x06, 0x0C, 0x05, 0x09, 0x00, 0x07,
0x00, 0x0F, 0x07, 0x04, 0x0E, 0x02, 0x0D, 0x01, 0x0A, 0x06, 0x0C, 0x0B, 0x09, 0x05, 0x03, 0x08,
0x04, 0x01, 0x0E, 0x08, 0x0D, 0x06, 0x02, 0x0B, 0x0F, 0x0C, 0x09, 0x07, 0x03, 0x0A, 0x05, 0x00,
0x0F, 0x0C, 0x08, 0x02, 0x04, 0x09, 0x01, 0x07, 0x05, 0x0B, 0x03, 0x0E, 0x0A, 0x00, 0x06, 0x0D,
0x0F, 0x01, 0x08, 0x0E, 0x06, 0x0B, 0x03, 0x04, 0x09, 0x07, 0x02, 0x0D, 0x0C, 0x00, 0x05, 0x0A,
0x03, 0x0D, 0x04, 0x07, 0x0F, 0x02, 0x08, 0x0E, 0x0C, 0x00, 0x01, 0x0A, 0x06, 0x09, 0x0B, 0x05,
0x00, 0x0E, 0x07, 0x0B, 0x0A, 0x04, 0x0D, 0x01, 0x05, 0x08, 0x0C, 0x06, 0x09, 0x03, 0x02, 0x0F,
0x0D, 0x08, 0x0A, 0x01, 0x03, 0x0F, 0x04, 0x02, 0x0B, 0x06, 0x07, 0x0C, 0x00, 0x05, 0x0E, 0x09,
0x0A, 0x00, 0x09, 0x0E, 0x06, 0x03, 0x0F, 0x05, 0x01, 0x0D, 0x0C, 0x07, 0x0B, 0x04, 0x02, 0x08,
0x0D, 0x07, 0x00, 0x09, 0x03, 0x04, 0x06, 0x0A, 0x02, 0x08, 0x05, 0x0E, 0x0C, 0x0B, 0x0F, 0x01,
0x0D, 0x06, 0x04, 0x09, 0x08, 0x0F, 0x03, 0x00, 0x0B, 0x01, 0x02, 0x0C, 0x05, 0x0A, 0x0E, 0x07,
0x01, 0x0A, 0x0D, 0x00, 0x06, 0x09, 0x08, 0x07, 0x04, 0x0F, 0x0E, 0x03, 0x0B, 0x05, 0x02, 0x0C,
0x07, 0x0D, 0x0E, 0x03, 0x00, 0x06, 0x09, 0x0A, 0x01, 0x02, 0x08, 0x05, 0x0B, 0x0C, 0x04, 0x0F,
0x0D, 0x08, 0x0B, 0x05, 0x06, 0x0F, 0x00, 0x03, 0x04, 0x07, 0x02, 0x0C, 0x01, 0x0A, 0x0E, 0x09,
0x0A, 0x06, 0x09, 0x00, 0x0C, 0x0B, 0x07, 0x0D, 0x0F, 0x01, 0x03, 0x0E, 0x05, 0x02, 0x08, 0x04,
0x03, 0x0F, 0x00, 0x06, 0x0A, 0x01, 0x0D, 0x08, 0x09, 0x04, 0x05, 0x0B, 0x0C, 0x07, 0x02, 0x0E,
0x02, 0x0C, 0x04, 0x01, 0x07, 0x0A, 0x0B, 0x06, 0x08, 0x05, 0x03, 0x0F, 0x0D, 0x00, 0x0E, 0x09,
0x0E, 0x0B, 0x02, 0x0C, 0x04, 0x07, 0x0D, 0x01, 0x05, 0x00, 0x0F, 0x0A, 0x03, 0x09, 0x08, 0x06,
0x04, 0x02, 0x01, 0x0B, 0x0A, 0x0D, 0x07, 0x08, 0x0F, 0x09, 0x0C, 0x05, 0x06, 0x03, 0x00, 0x0E,
0x0B, 0x08, 0x0C, 0x07, 0x01, 0x0E, 0x02, 0x0D, 0x06, 0x0F, 0x00, 0x09, 0x0A, 0x04, 0x05, 0x03,
0x0C, 0x01, 0x0A, 0x0F, 0x09, 0x02, 0x06, 0x08, 0x00, 0x0D, 0x03, 0x04, 0x0E, 0x07, 0x05, 0x0B,
0x0A, 0x0F, 0x04, 0x02, 0x07, 0x0C, 0x00, 0x05, 0x06, 0x01, 0x0D, 0x0E, 0x00, 0x0B, 0x03, 0x08,
0x09, 0x0E, 0x0F, 0x05, 0x02, 0x08, 0x0C, 0x03, 0x07, 0x00, 0x04, 0x0A, 0x01, 0x0D, 0x0B, 0x06,
0x04, 0x03, 0x02, 0x0C, 0x09, 0x05, 0x0F, 0x0A, 0x0B, 0x0E, 0x01, 0x07, 0x06, 0x00, 0x08, 0x0D,
0x04, 0x0B, 0x02, 0x0E, 0x0F, 0x00, 0x08, 0x0D, 0x03, 0x0C, 0x09, 0x07, 0x05, 0x0A, 0x06, 0x01,
0x0D, 0x00, 0x0B, 0x07, 0x04, 0x00, 0x01, 0x0A, 0x0E, 0x03, 0x05, 0x0C, 0x02, 0x0F, 0x08, 0x06,
0x01, 0x04, 0x0B, 0x0D, 0x0C, 0x03, 0x07, 0x0E, 0x0A, 0x0F, 0x06, 0x08, 0x00, 0x05, 0x09, 0x02,
0x06, 0x0B, 0x0D, 0x08, 0x01, 0x04, 0x0A, 0x07, 0x09, 0x05, 0x00, 0x0F, 0x0E, 0x02, 0x03, 0x0C,
0x0D, 0x02, 0x08, 0x04, 0x06, 0x0F, 0x0B, 0x01, 0x0A, 0x09, 0x03, 0x0E, 0x05, 0x00, 0x0C, 0x07,
0x01, 0x0F, 0x0D, 0x08, 0x0A, 0x03, 0x07, 0x04, 0x0C, 0x05, 0x06, 0x0B, 0x00, 0x0E, 0x09, 0x02,
0x07, 0x0B, 0x04, 0x01, 0x09, 0x0C, 0x0E, 0x02, 0x00, 0x06, 0x0A, 0x0D, 0x0F, 0x03, 0x05, 0x08,
0x02, 0x01, 0x0E, 0x07, 0x04, 0x0A, 0x08, 0x0D, 0x0F, 0x0C, 0x09, 0x00, 0x03, 0x05, 0x06, 0x0B
};然后跟上面正常的S盒进行循环对比，找到不同的地方
找了个C实现的DES算法代码，发现结果不对
想了想，如果S盒有问题，那么其它几个Table和盒子可能也有问题，于是开始对比了一波，最后发现PC2_Table有问题
再一次的计算，发现注册码计算还是有问题，当时场面一度很尴尬
突然，我想起了一件事，秘钥开始的时候经过了一次神奇的异或
赶紧的赶紧的，继续改代码，东平西凑，瞎改瞎改
就先这样吧，眼泪掉下来，以后再找个时间分析一下这个样本的保护技术
最后，如果是第一次接触这种动静结合分析的同学，要时刻注意指令集的切换，中间有大量的指令集切换，看指令的地址即可，通常都是三步走，断在调用处，先别跟过去，此时跟过去会断不下来的，直接效果就是和F9一样，这一点应该有体会吧，比如使用的是BL R3，在这一句下个断点，先断下来，直接在反汇编窗口跟随R3，就可以看到要执行的代码了，但是如果指令集识别有问题，需要先ALT + G，选择Thumb模式，然后按一下C转为代码模式，再按P识别函数
Last updated
