决赛在 il2cpp 上的防护以及 anti-debug 上并没有增加难度,而是把重心放在了注册机算法上,所以决赛篇就不重复写 dump 和 anti-debug 部分了
getflag
在有 dump 的情况下拿 flag 就是洒洒水了,分析我都懒得贴了,上个代码意思一下
1 2 3 4 5 6 7 8 | function CheatFlag()
{
var g_libil2cpp_addr = Module.findBaseAddress("libil2cpp.so");
var coin_cmp = g_libil2cpp_addr.add(0x4652ac);
Memory.protect(coin_cmp, 4, "rwx");
Memory.writeInt(coin_cmp, 0x7100001f);
Memory.protect(coin_cmp, 4, "rx");
}CheatFlag();
|
注册机
il2cpp 中分析过程还是一样的,很容易可以找到验证点,稍微分析就可以知道这里的验证方法是低位与rand比较,高位为0
sec 的 so 里也同样有个加密函数
这次调试出现了一个奇怪的问题(上次打的时候没这个问题,不知道是怎么触发的),跳转 libsec 会到一个只读的段,里面代码完全相同,所以断点下载这里面根本不会断下来
把这个段删除就好了
分析加密函数 0x94368,像这种函数还是好计算的,不过为了方便也可以直接调试
可以看到 0x9E93C 函数的参数是输入& 0xFFFF00FFFFFF 的值,也就是拿了输入的这些位
同时下面那个函数 ida 也标出来了是 strcmp,观察参数可以理解 v8 是 0x9E93C 的输出
而函数内第一个用到输入的函数是 0x9f4c4,这个函数很简单就是赋值,那么接下来就是需要针对 v10,也就是需要观察下一个函数 0x9f0a8
这个函数里面有一些混淆但不多,还是调试起来看好一点
先看传进来的参数
第一个参数是输入&0xFFFF00FFFFFF,第二个 0x11 也就是 17,在 0x9E93C 中可以看到赋值 17,第三个参数是一串不知道干什么用的二进制,第四个是 0
第一个函数调用完也就是用了 a4 的那个函数,把 1 写到了 a4
第二个函数的参数 v15, ida 分析它是一个 char 数组,原本里面的东西应该是没有清空,执行完第二个函数之后就清空了并且 memcpy 了输入,第三个函数和第二个函数是一样的,所以结果就是把 17 存储到了 v14 的空间处
可以简单的把这俩个函数都归为 copy 的功能
至于后面的,就慢慢 F8,看它执行哪个分支
第一句是比较 (0x11 & 1) == 0,很显然结果是假
而后要执行的是这一块,把它暂且叫分支 1
这里的参数 a4 前面被赋值为1,v15 是 input 的复制,v13 前面还没有用到过
执行完以后 a4 和 v15 没有改变,而 v13 变成了 0x2b67,也就是 v15 的当前值
下一句用到了更改后的 v13,以及不知道用来做什么的二进制入参和没变过的 a4
执行完以后 v13 和 a3 都没有变化, a4 则变成了 0x2b67
似乎这就是复制来复制去,暂时猜不出有效信息
然后程序继续执行,跳到了这个分支,把它暂且叫分支 2
第一个函数执行完之后 v13 变成了8,v14 没有变化还是 0x11
第二个函数跟最开始的 copy 是一个函数,也就是把 v13 的 8 赋值给了 v14
第三个函数啥事没干,v14 进去什么样出来就什么样,不过出来的时候 x0 = 0,应该是用于判断走向的
后面又走到这了,把它暂且叫分支 3
实际上这个分支的函数就是第一次分支执行的,不过参数不一样,区别就在于 a4 换成了 v15, v15 目前还是 input 的复制
执行完以后 v13 从 8 变成了 0x75bc371,并且 v15 也被这个值覆盖了,看起来 v13 是一个 temp 值,只用于储存中间值
这之后又到 (8 & 1) == 0,这回的结果是真,会执行不同的分支
果然这一次直接执行到了分支 2,之前为假是执行到分支 1 的
这个函数之前把 0x11 变成了 0x8,这回变成了 0x4,可以猜测是除 2,判断结果还是 0
不出意外又执行到了分支 3,这一次 0x75bc371 变成了 0x362594b58b57e1, 好像执行一次,长度就会涨一倍,符合这种运算的应该是平方
1 2 3 4 | >>> hex(0x75bc371*0x75bc371)
'0x362594b58b57e1'
>>> hex(0x2b67*0x2b67)
'0x75bc371'
|
那这个意思应该明白了
先判断是不是单数次方,是单数就执行分支 1,分支 1 是用最开始赋值的 1 来乘
然后把次方数除 2,如果不为零就执行分支 3 继续乘,乘法的两边是自己,也就是平方
那么 off_12EC00 是乘,off_12EC10 是除,off_12EC18 是判断
还剩下一个用到了入参的 off_12EC08,猜测是取余,只是因为输入的数太小而没有显示出作用
尝试输入一个大的 input 比如 0xFFFF00FFFFFF
本来这次运算的结果应该是左边 hex 中的内容,执行后右边变小了
按照它的读法,a3 是0x28a831a5bf4b902e95318e50c2075259f91094d08d84409e1b76eadfa0865d1278acc90fa7c6cf6acb375,尝试一下
1 2 | hex(0xfff8081bc7dca7d4e8c54ebc420e2cb73b9dbc3fdc7d4455b2f5b4ef598916bd20fc37f15870001bc8140007f8000001%0x28a831a5bf4b902e95318e50c2075259f91094d08d84409e1b76eadfa0865d1278acc90fa7c6cf6acb375)
'0x228c023ea3485a0244b4820c12cc034e874a8afe26cfc87b997c23889da89ed6d7b038236b04f34dc353f'
|
发现结果是对应的
那么最开始所比较的应该是次方后的结果的字符串
果不其然
所以只要知道哪个数的17次方取余这个大数等于另一个大数就可以了
这个问题实际上是 rsa 问题,可以用 yafu 把模数分解乘两个大质数相乘,当时我吃了不会用 yafu 的亏
yafu.ini 配置如下,特别注意 dir 相关配置,我这配置有问题执行不下去,后面快结束了我才回头整的 yafu
1 2 3 4 5 6 7 8 9 10 11 | B1pm1=100000
B1pp1=20000
B1ecm=11000
rhomax=1000
threads=16
pretest_ratio=0.25
%ggnfs_dir=.\ggnfs-bin\Win32\
ggnfs_dir=.\ggnfs-bin\
%ecm_path=.\gmp-ecm\bin\x64\Release\ecm.exe
%ecm_path=.\ecm\current\ecm
tune_info= Intel(R) Xeon(R) CPU E5-4650 0 @ 2.70GHz,LINUX64,1.73786e-05,0.200412,0.400046,0.0987873,98.8355,2699.98
|
最后运算结果是
1 2 3 4 5 6 7 8 9 10 | NFS elapsed time = 925.8149 seconds.
Total factoring time = 925.8163 seconds
***factors found***
P51 = 555183147936225271626794036740589959032732535469347
P51 = 640704384372038524783151782406101498608483916642951
ans = 1
|
顺手上传到 factordb 上了
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | import gmpy2
q = 640704384372038524783151782406101498608483916642951
p = 555183147936225271626794036740589959032732535469347
n = 0x28a831a5bf4b902e95318e50c2075259f91094d08d84409e1b76eadfa0865d1278acc90fa7c6cf6acb375
c = 0x25f6b048b4f32e3ce9175bb64930f65101a706ae74988a4ec87b4d5ec7feb9223ab782bcf1ec9d7fee750
e = 17
phi = (p - 1) * (q - 1)
d = gmpy2.invert(e, phi)
m = pow(c, d, n)
print(hex(m))
|
最终结果是 0x7be300df8b2c
就是说,0x7be300df8b2c 是 input % 0xFFFF00FFFFFF 的结果,还剩下 3 个 byte 在余下的运算之中
回到最初的解密 0x94368, strcmp 下面的是混淆看不懂结构了
我的做法是再每一处跳转做记号,并对被跳转地也做记号,这样就可以清晰看到路径
然后发现对照图来还比较方便
可以看到是先比较 strcmp 的结果,再下一次运行就往 3 走了
4 这里我做了标记,参数是排列好的输入,并且执行完之后改变了输入
5 就是正常的程序自检然后退出
那么重点就在 4 调用的函数 0x99ef4 之中
0x99ef4 虽然后面做了混淆,不过经过调试可以知道到 0x98e50 这个函数就计算完了,后面没有再改变
不过这个函数里面混淆的很厉害,什么也看不见,经过调试,可以发现有一处用到了输入,并且更改了输入
而这个函数内部不用说也是混淆的厉害,而且通过多次这个函数会发现这个函数不是一个固定的函数,就是说这里跳转的函数是从函数列表中拿出来的,与此同时 X8 似乎是个记录 index 的寄存器,观察汇编可以看出 X0 也是从内存列表中与 X8 相关取出的,于是乎可以拿到两个列表
另注意,ARM64架构处理器采用48位物理寻址机制,就是说开头 1 字节不要
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 | 0:
0x7042D23DB4,0x7042D2327C,0x7042D10004,0x7042D22148,0x7042D11A88,0x7042D10004,0x7042D13AD0,0x7042D22148,0x7042D13AD0,0x7042D17158,0x7042D22148,0x7042D17E00,0x7042D12CC0,0x7042CFB1BC,0x7042CFB1BC,0x7042CFB1BC
10:
0x7042CFB1BC,0x7042CFB1BC,0x7042D27BF4,0x7042D11A88,0x7042D22148,0x7042D10004,0x7042D10004,0x7042D24E18,0x7042D25C50,0x7042D2A564,0x7042D21BE8,0x7042D22148,0x7042D21BE8,0x7042D2075C,0x7042D19B64,0x7042D16A78
20:
0x7042D11B2C,0x7042D2A564,0x7042D13420,0x7042D10AC4,0x7042D29054,0x7042D25980,0x7042D27BF4,0x7042D27BF4,0x7042D12AE8,0x7042D22148,0x7042D19B64,0x7042D19B64,0x7042D2A564,0x7042D13420,0x7042D16A78,0x7042D25980
30:
0x7042D10004,0x7042D29054,0x7042D12AE8,0x7042D18F4C,0x7042D10004,0x7042D24E18,0x7042D18F4C,0x7042D16518,0x7042D24E18,0x7042D17E00,0x7042D21BE8,0x7042D10004,0x7042D24E18,0x7042D2A564,0x7042D2A564,0x7042D2A564
40:
0x7042D13420,0x7042D16518,0x7042D24E18,0x7042D2A564,0x7042D21BE8,0x7042D19B64,0x7042D29054,0x7042D2A564,0x7042D13420,0x7042D16A78,0x7042D25980,0x7042D11B2C,0x7042D20458,0x7042D27BF4,0x7042D10AC4,0x7042D27BF4
50:
0x7042D12AE8,0x7042D10004,0x7042D29054,0x7042D12AE8,0x7042D10004,0x7042D22468,0x7042CFB1BC
0:
0xF01E0FF3,0x95417BFD,0xD30043FD,0x92003F3,0x5000000,0xB200E000,0x64000000,0x761303E1,0xF8000000,0xBD417BFD,0x673303E0,0xC04207F3,0x14123456,0,0x6D5F6D76,0x206E6961
10:
0x41007825,0,0xC38043FF,0x91000009,0x541F03E8,0xCB856129,0xFD0033EA,0x75C03BFF,0xFD401BFF,0x18137C0C,0x1E1C03EB,0x6F00158C,0x7A9F03ED,0x31CB7D8E,0x424D6D2F,0x750B01CE
20:
0x3F001DD0,0x6F9E7610,0x63861DD0,0x601001EE,0x8F0001BF,0xFDAD694E,0xE88005AD,0x1D00216B,0xAEFFFEBC,0xD53F03EB,0x77EB6D4C,0x400B6D2D,0x75857D8E,0x3D1D1D8E,0x2E2D01CC,0xC8AB694C
30:
0xFA80056B,0xBF000D7F,0x1FFFFF11,0xDD003BEB,0x1E01D56B,0xBDC03BEB,0x558037EB,0x719F196B,0x418037EB,0xB9400FEC,0x7A9D03EB,0x3F03058D,0xFDC033ED,0x60907D8D,0x18105D8C,0x1E1F798C
40:
0x57871DAC,0x759F018C,0x55803BEC,0x71901D80,0x340003EC,0x16EC654D,0xBF00019F,0x6F877DAE,0x639F1DAE,0x610C01CD,0x2EC6D4D,0x3D001DAD,0x48EB35AD,0x9D00058C,0x572001A0,0x5E80216B
50:
0x3FFFFEAC,0x61800508,0x5804011F,0xBCFFF8C1,0xF58043FF,0xEAC73BD4,0xD06BA216
|
X1 中储存着输入
多执行几次可以发现这应该是一个整体,以 8 字节为一个整体
最后一个字节表示 index
然后就可以通过看这块内存猜运算了,不过这也局限于比较简单的,如果比较复杂还是猜不出来,这个时候可以用 ida trace
比方说第 1e 个指令赋值 0x6B(上次知道的),想知道 0x6B 是怎么来的就得看 trace 了
可以通过下条件断点精准降落
断下来之后先修改 trace 选项
取消跳过 debugger 段
再点选项上面的 Instruction tracing,然后对下一句语句按 F4,就可以了记录下中间所有的指令以及寄存器的变化,点开 trace window 右键 Export trace to text file,然后就可以面向 trace 逆向了
很容易可以找到 0x6b 是来源于 0x6ECDD62D00 + 0x15A
1 2 3 4 5 6 | 000013D3 libsec2023.so:0000007042D18DDC ADD X2, X8, X0 X2=000000000000015A
000013D3 libsec2023.so:0000007042D0D010 LDR X16, [X1,
000013D3 libsec2023.so:0000007042D0D030 ADD X12, X16, X2 X12=B400006ECDD62E5A
000013D3 libsec2023.so:0000007042D0D074 STR X12, [SP,
000013D3 libsec2023.so:0000007042D0D2C4 LDR X0, [SP,
000013D3 libsec2023.so:0000007042D0D2C8 LDRB W0, [X0] X0=000000000000006B
|
0x6ECDD62D00 是这一轮的 X0,再往上其实可以找到是来源于 input 那块空间的后面一个指针,不过知道是来源于这里的就行了
剩余的字节都以此类推,还包括一些跳转
最大的跳转是一个 256 轮次的,可以还原之后,运算一轮对比结果,如果运算十轮都没错,那基本上就是没错了
我最终扣出来的正向代码如下
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 | int main()
{
int input = 0xffffff;//这是输入的剩下的那几位
for(int j = 0; j < 256; ++j)//这是0x53->0x19之间的256次循环
{
int magic[3] = {0x6b, 0xA2, 0x16};
int t = ((input >> 16) >> 3);
int temp[3] = {};
for(int i = 0; i < 3; ++i)//这是0x28->0x1d之间的3次循环
{
long long s = (2 - i) * 8;
long long tt = ((t | (input << 5)) >> s) ^ s;
//printf("tt = 0x%llx\n", tt);
long long ttt = (tt & 0xff) << 2;
long long tttt = (((((tt >> 6) | (tt<< 0x1A)) & 0x3FC000003) | ttt) & 3) | ttt;
//printf("tttt = 0x%llx\n", tttt);
tttt += magic[i];
temp[i] = tttt & 0xff;
//printf("tttt = 0x%llx\n", tttt);
}
int temp2[3] = {};
for(int i = 2;i >= 0; --i)//这是0x32->0x2a之间的3次循环
{
long long t = temp[i];
long long tt = ((t >> 5) | (t << 3)) ^ magic[i];
//printf("tt = 0x%llx\n", tt);
temp2[i] = tt & 0xff;
}
temp2[0] += 0x75;
temp2[1] ^= 0xfe;
temp2[2] += 0xc1;
for(int i = 0; i < 3; ++i)//本来这个循环只是0x50到0x45的两次循环,修改了一下逻辑把前面一部分加进去了
{
if(i == 0)
{
long long t = temp2[i] & 0xff;
//printf("t = 0x%x\n", t);
long long ttt = 0xff00 | t;
long long tttt = (((t >> 0x1f) | (t << 1)) & 0xfffffffe);
long long ttttt = ((((ttt >> 7) | (ttt << 0x19) & 0x1FE000001) | tttt) & 1);
long long tt = (tttt | ttttt) ^ (2 - i);
//printf("tt = 0x%x\n", tt);
((char*)&input)[2-i] = tt & 0xff;
}
else
{
long long t = temp2[i] & 0xff;
//printf("t = 0x%x\n", t);
long long tt = ((((t << 1) | (t >> 0x1f)) & 0x1fe) | ((t >> 7 | t << 0x19) & 0x1FFFFFF))^ (2 - i);
//printf("tt = 0x%x\n", tt);
((char*)&input)[2-i] = tt & 0xff;
}
}
}
printf("result = 0x%08x\n", input);
}
|
不是很懂有些部分怎么逆,范围也不大,就直接爆破了,最终 solve 代码如下
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 | int vm(int inp)
{
int input = inp;//这是输入的剩下的那几位
for(int j = 0; j < 256; ++j)//这是0x53->0x19之间的256次循环
{
int magic[3] = {0x6b, 0xA2, 0x16};
int t = ((input >> 16) >> 3);
int temp[3] = {};
for(int i = 0; i < 3; ++i)//这是0x28->0x1d之间的3次循环
{
long long s = (2 - i) * 8;
long long tt = ((t | (input << 5)) >> s) ^ s;
//printf("tt = 0x%llx\n", tt);
long long ttt = (tt & 0xff) << 2;
long long tttt = (((((tt >> 6) | (tt<< 0x1A)) & 0x3FC000003) | ttt) & 3) | ttt;
//printf("tttt = 0x%llx\n", tttt);
tttt += magic[i];
temp[i] = tttt & 0xff;
//printf("tttt = 0x%llx\n", tttt);
}
int temp2[3] = {};
for(int i = 2;i >= 0; --i)//这是0x32->0x2a之间的3次循环
{
long long t = temp[i];
long long tt = ((t >> 5) | (t << 3)) ^ magic[i];
//printf("tt = 0x%llx\n", tt);
temp2[i] = tt & 0xff;
}
temp2[0] += 0x75;
temp2[1] ^= 0xfe;
temp2[2] += 0xc1;
for(int i = 0; i < 3; ++i)//本来这个循环只是0x50到0x45的两次循环,修改了一下逻辑把前面一部分加进去了
{
if(i == 0)
{
long long t = temp2[i] & 0xff;
//printf("t = 0x%x\n", t);
long long ttt = 0xff00 | t;
long long tttt = (((t >> 0x1f) | (t << 1)) & 0xfffffffe);
long long ttttt = ((((ttt >> 7) | (ttt << 0x19) & 0x1FE000001) | tttt) & 1);
long long tt = (tttt | ttttt) ^ (2 - i);
//printf("tt = 0x%x\n", tt);
((char*)&input)[2-i] = tt & 0xff;
}
else
{
long long t = temp2[i] & 0xff;
//printf("t = 0x%x\n", t);
long long tt = ((((t << 1) | (t >> 0x1f)) & 0x1fe) | ((t >> 7 | t << 0x19) & 0x1FFFFFF))^ (2 - i);
//printf("tt = 0x%x\n", tt);
((char*)&input)[2-i] = tt & 0xff;
}
}
}
return input;
}
int main()
{
int tofind = 0;
printf("pls input token:");
scanf("%d", &tofind);
int i;
for(i = 0; i < 0xffffff; ++i)
{
if( vm(i) == tofind )
{
break;
}
}
unsigned long long aa = (unsigned long long)(((unsigned long long)(i & 0xffff00)) << 40) | (unsigned long long)((unsigned long long)(i & 0xff) << 24);
aa |= 0x7be300df8b2c;
printf("%llu", aa);
}
|
vm 逆到最后一天晚上 9 点,那时候还没有解 RSA ,准备出去吃个饭,回来就直接交了,后来看到论坛一个 512 位的 RSA yafu 爆破,觉得还是有希望能出的,11点半解出来两个大质数,当时最终代码不是这样写的,打了一个 0xffffff 的表,直接找表,导致代码庞大,测试打包改wp也要时间,最后上传时间太长,逾期了 3 分钟
当然,最主要还是 rsa 问题以前上手解的少了,工具不熟悉,流程不熟悉,不然也不会最后 10 分钟才完整搞完,既然事实已成,后悔也是无用,今年也要毕业了,明年就没得打了,爷青结
[2023春季班]2023，新的征程，脱壳机更新、iOS/eBPF、赠送云手机套装！一块裸板虚拟化五个容器云手机！3月25日起同时上调价格并赠送新设备！
最后于 13小时前
被|_|sher编辑
，原因：
