一 题目分析
题目有数字命名从0开始到13612共13613个文件夹。
每个文件夹里有一个名为beatme的64位elf可执行文件和若干个so
beatme中会加载so文件,并调用so的导出函数。so只有一个导出函数,并且有可能加载别的so并调用别的so的导出函数。
每个beatme的代码都非常相似,都是encrypt(input, key)==secret?
的问题;解题过程就是提取key,secret,实现encrypt的逆,然后反求input;最后各个beatme解出来的input按顺序组成一个jpeg文件。
解题方向应该是自动化分析这些题目;或者因为encrypt都一样,只需实现decrypt,然后自动化提取key和secret(本文的解决方案,参考了大神Q7的解决方案),其中需要去除 表达式分散在so里 的混淆。
so文件分析
如上所述so只有一个导出函数。
so有两种类型,第一种是"直接型",比如output�AmiOWZLBXmVOGVXC.so
的导出函数,直接是一条表达式:
__int64 __fastcall ZREWkEkEJCljQjvN(int a1, int a2){ return (unsigned int)(a1 + a2);}
第二种是"间接型",比如output�AOinIPkXvMtrtbha.so
的导出函数,调用了别的so的导出函数:
__int64 __fastcall pnstlKQzXnehUbWP(unsigned int a1, unsigned int a2, unsigned int a3){ void *v4; // rax void *v5; // rax v4 = dlopen("./WDhDHuuesoPtRCMX.so", 1); if ( v4 && (v5 = dlsym(v4, "XdpJmBLmALOHLqWC"), (wrapped_func = v5) != 0LL) ) return ((__int64 (__fastcall *)(_QWORD, _QWORD, _QWORD))v5)(a1, a2, a3); else return 0xFFFFFFFFLL;}
从而呈现出一条:间接型so 调用 间接型so 调用 间接型so...最后调用直接型so的调用关系单向链。
一个小细节是,不是所有so都会被使用到(包括直接型,有的也根本就没被执行过)。
beatme的main函数分析
beatme的main函数首先读取8字节的输入。然后加载so并获取导出函数的地址,反编译出来的代码非常有规律,有些被调用过,ida会识别出类型为函数,有些没被调用ida会当成64位整型:
// output�beatme:main// 被调用过的导出函数,ida识别出其为函数 v3 = dlopen("./hESMAGmJLcobKdDM.so", 1); if ( !v3 ) goto LABEL_41; qword_40A0 = (__int64 (__fastcall *)(_QWORD, _QWORD, _QWORD))dlsym(v3, "vpUjPultKryajeRF"); if ( !qword_40A0 ) goto LABEL_41;// 没被调用过的导出函数,ida识别其为64位整型 v8 = dlopen("./oSeJlOQqzYFRkBXO.so", 1); if ( !v8 ) goto LABEL_41; qword_4078 = (__int64)dlsym(v8, "tYUJnAiKvXEypybB"); if ( !qword_4078 ) goto LABEL_41;
最后多次调用一个加密函数(调用次数不是固定的),然后和目标进行对比
这是加密函数调用次数大于3次的ida反汇编:
// output�beatme:main v21 = 4; // 加密函数调用次数 v24[0] = 0x11BC44D6247B0D72LL; // 原始key v24[1] = 0xA9B5A0DEDE1121C5LL; // 原始key do { sub_1670((unsigned int *)&buf, (unsigned int *)v24); // 调用加密函数 --v21; } while ( v21 ); if ( buf == 0x6DC5E11CB9C04362LL ) // 比对加密后的结果 { puts(":)"); return 0LL; } else {LABEL_41: puts(":("); return 0xFFFFFFFFLL; }
但加密函数调用次数小于等于3次时,反编译结果有所不一样(猜测是编译优化把循环展开了,也可能是出题人故意的)。
如果是使用ida的反编译,次数小于等于3次时,最后几个加载so获取导出函数的规律也有所变化。
这是加密函数调用次数为1次的ida反汇编(前40个中,3、5、28都是这种情况):
// output5beatme:main v19 = dlopen("./jRetpolsrphrQPtF.so", 1); if ( v19 && (qword_4020 = (__int64)dlsym(v19, "fLlwjsNFHveEXhbW")) != 0 && (v20 = dlopen("./GHITvdoIgYolDeOt.so", 1)) != 0LL && (qword_4018 = (__int64)dlsym(v20, "hYiKvwpyPcByLGBL")) != 0 && (v23[0] = 0x29D8E96D6458B149LL, v23[1] = 0xE5B375A8205A7EA0LL, sub_1660(&buf, v23), buf == 0xF1151196B7E3EEC1LL) ) { puts(":)"); return 0LL; } else {LABEL_37: puts(":("); return 0xFFFFFFFFLL; }
这是加密函数调用次数为2次的ida反汇编(前40个中,8、12、36都是这种情况):
// output8beatme:main v19 = dlopen("./dXLsupdunzHSBdjV.so", 1); if ( !v19 ) goto LABEL_39; qword_4020 = (__int64)dlsym(v19, "KlIIGXPuIRUJEvgE"); if ( qword_4020 && (v20 = dlopen("./gxDqevBaXMJekHMu.so", 1)) != 0LL && (qword_4018 = (__int64)dlsym(v20, "bkBLrwUXLBTMrIVr")) != 0 && (v23[0] = 0x67C77F122DE22A1BLL, v23[1] = 0x86399F4E521A3DAELL, sub_1670(&buf, v23), sub_1670(&buf, v23), buf == 0xA5BEF5332059C1BELL) ) { puts(":)"); return 0LL; } else {LABEL_39: puts(":("); return 0xFFFFFFFFLL; }
这是加密函数调用次数为3次的ida反汇编(前60个中,只有51是这种情况):
// output51beatme:main v20 = dlopen("./joVUJgIesOtuXwqZ.so", 1); if ( v20 && (qword_4018 = (__int64)dlsym(v20, "XzocYrjvPODlZHPH")) != 0 && (v23[0] = 0xEA455F54018BB47DLL, v23[1] = 0xCB8F0ED6858DB4F8LL, sub_1680(&buf, v23), sub_1680(&buf, v23), sub_1680(&buf, v23), buf == 0x81A1A5064491BBD4LL) ) { puts(":)"); return 0LL; } else {LABEL_39: puts(":("); return 0xFFFFFFFFLL; }
beatme的加密函数
原本长这个样子:
// output�beatme:sub_1670// a1:buf,用户输入的8字节内容// a2:key v3 = *a1; v4 = a1[1]; v5 = qword_4030(*a2, a2[1], 346850382LL); v6 = qword_4028(a2[1], a2[3], 9128242LL); v7 = qword_4020(a2[2], a2[4], 1916420973LL); v8 = 0; v44 = 16; v27 = qword_4018(a2[3], v5, 2064015388LL); do { v9 = qword_4088(v8, 2654435769LL, 353937606LL); v36 = (__int64 (__fastcall *)(_QWORD, _QWORD, __int64))qword_4040; // ... v12 = v36(v11, v40, 1456051295LL); // ... v25 = v44-- == 1; v4 = v24; } while ( !v25 ); result = a1; *a1 = v3; a1[1] = v4; return result;
将qword_xxxx都替换成前面so文件分析中所说的直接型so里面的代码,去掉混淆。
分析去掉混淆后的代码发现,key会被修改,然后是16*2=32轮tea,对比不同beatme的加密函数。
只有修改key那四句代码里的8个常数会变:
// output�beatme:sub_1670 fix// a1:buf,用户输入的8字节内容// a2:key v3 = *a1; v4 = a1[1]; v5 = 346850382LL ^ *a2 ^ 0x11824E8Au; // 修改key第0个DWORD v6 = a2[1] ^ (unsigned int)(9128242LL + 1447939560); // 修改key第1个DWORD v7 = (a2[2] + 1916420973LL) ^ 0x17FF8240u; // 修改key第2个DWORD v8 = 0; v44 = 16; v27 = (a2[3] - 2064015388LL) ^ 0x3CC50BEBu; // 修改key第3个DWORD do { v9 = (unsigned int)(v8 + 2654435769LL); v40 = (unsigned int)((v4 >> 5) + v6); v28 = (unsigned int)(v4 + v9 + 1); v10 = (unsigned int)((16 * v4) + v5); v11 = v28 ^ v10; v12 = v40 ^ v11; v13 = (unsigned int)(v3 + v12); v41 = (unsigned int)((v13 >> 5) + v27); v29 = (unsigned int)(v13 + v9); v14 = (unsigned int)((16 * v13) + v7 + 1); v15 = v29 ^ v14; v16 = v41 ^ v15; v17 = (unsigned int)(v4 + v16); v8 = (unsigned int)(v9 + 2654435769LL); v42 = (unsigned int)((v17 >> 5) + v6); v30 = (unsigned int)(v17 + v8); v18 = (unsigned int)((16 * v17) + v5); v19 = v30 ^ v18; v20 = v42 ^ v19; v3 = (unsigned int)(v13 + v20); v43 = (unsigned int)((v3 >> 5) + v27); v31 = (unsigned int)(v3 + v8); v21 = (unsigned int)((16 * v3) + v7); v22 = v31 ^ v21; v23 = v43 ^ v22; v24 = (unsigned int)(v17 + v23); v25 = v44-- == 1; v4 = v24; } while ( !v25 ); result = a1; *a1 = v3; a1[1] = v4; return result;
二
解题方案:ida批处理模式反编译+正则匹配
可行性
单线程情况下完整分析一个beatme大概19~20s;如果已经生成好i64并输出了反编译C代码,分析一个beatme只需要0.5~0.8s。
多进程(python multiprocessing,processes=8;笔记本R7 4800H 8核16线程)分析一个beatme大概24~34s。
考虑最坏情况34s一个,开32核,4小时解完全部:13613*34/32/3600=4h
主要时间花在ida批处理反编译上了。
ida批处理模式
Igor’s tip of the week #08: Batch mode under the hood – Hex Rays (hex-rays.com)
用ida批处理模式可以输出指定函数的反编译到文件:
os.system('idat64.exe -Ohexrays:{filename}.{func}.c:{func} -A {pathname}')
但是有个很奇怪的问题,如果没有i64文件的情况下,第一次指定反编译main函数反编译结果会为空,似乎是反编译没有被执行,需要再重新指定反编译main一次。
解决思路
1.获取so文件的调用单向链,遍历所有so文件:
(1)根据是否导入dlopen和dlsym判断是否为"间接型"的so;
(2)记录"间接型"so导入的so名和调用的导出函数名:
① 导入的so的名称和调用的导出函数的名称是相邻的,可通过正则匹配二进制内容找出。
2.反编译beatme的main函数(ida批处理反编译)得到main.c;
3.获取main函数中变量对应的加载的so和导出函数(正则匹配main.c内容)
4.获取main函数中调用加密函数相关信息(正则匹配main.c内容):
(1)加密函数的名称(反编译加密函数时用于通过名称指定函数);
(2)加密函数调用轮次;
(3)原始key;
(4)secret;
(5)注意:前面分析调用轮次有4种情况,每种情况都做一个正则的规则。
5.处理beatme的加密函数,反编译与去掉混淆得到sub_xxxx.c:
(1)反编译beatme的加密函数(ida批处理反编译,通过函数名指定)得到sub_xxxx.c;
(2)匹配sub_xxxx.c中所有v?? = qword_????,将v??替换成qword_????;
(3)根据变量对应的加载的so和导出函数,找到sub_xxxx.c中每个qword_xxxx(p0, p1, p2)对应的(so名,函数名)和该函数调用的实参;
① 根据调用单向链找到最终的"直接型"(so名,函数名);
② 反编译"直接型"so的导出函数(ida批处理反编译)得到xxxx.so.xxxx.c;
③ 获取xxxx.so.xxxx.c中的表达式并将形参替换成实参(正则)。
将sub_xxxx.c中qword_xxxx(p0, p1, p2)替换成前面处理完的表达式。
6.正则匹配sub_xxxx.c中修改key的四条语句的常数,然后修改key;
7.decrypt(加密函数调用轮次, secret, 修改后的key)得到输入。
看雪ID:wx_御史神风 https://bbs.kanxue.com/user-home-907036.htm
原文始发于微信公众号(看雪学苑):DEFCON 2024-Quals nloads ida批处理反编译+正则 处理so混淆和提取表达式常量
- 左青龙
- 微信扫一扫
-
- 右白虎
- 微信扫一扫
-
评论