# Asm_re
题目给了一个文本文件包含 arm 汇编 (是 ida 的片段),大部分 re 手都只会 x86 汇编,arm 汇编很少接触。
下面给出两种办法获得伪 c 片段
# 方法一 CHATGPT
#include <stdio.h> | |
#include <string.h> | |
// 假设一个类似的全局变量 | |
extern char __stack_chk_guard_ptr; | |
extern char unk_100003F10; | |
extern void __chkstk_darwin(); | |
void main() { | |
// 栈变量 | |
char stack_guard; | |
char var_18; | |
char var_B4; | |
int index=0; | |
char flag[] = "flag{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}"; | |
char var_C0[128]; | |
char lena; | |
char var_D0[128]; | |
char var_8[128]; | |
char var_100[128]; | |
char var_D8[128]; | |
char var_DC[128]; | |
char var_E0[128]; | |
char var_E4[128]; | |
char var_E8[128]; | |
char var_EC[128]; | |
char var_F0[128]; | |
char var_F4[128]; | |
char var_F8[128]; | |
// 初始化 | |
memcpy(var_C0, unk_100003F10, 0x98); | |
size_t len = strlen(flag); | |
lena = len + 1; | |
// 主循环 | |
while (index < lena) { | |
char c = flag[index]; | |
c = (c * 'P' + 0x14) ^ 'M'; | |
c += 0x1E; | |
var_100[index] = c; | |
index++; | |
} | |
// 打印换行 | |
printf("\n"); | |
var_F4[0] = 1; | |
var_F8[0] = 0; | |
// 另一段主循环 | |
while (var_F8[0] < lena) { | |
int comparison_result = var_100[var_F8[0]] == var_8[var_F8[0]]; | |
if (!comparison_result) { | |
var_F4[0] = 0; | |
break; | |
} | |
var_F8[0]++; | |
} | |
// 结果检查 | |
if (var_F4[0] == 1) { | |
printf("Success\n"); | |
} else { | |
printf("Failure\n"); | |
} | |
} |
用 gpt4o 可以得到比较完善的代码 (gpt3.5 的话就有点烂了)
# 方法二 提取十六进制数据
__text:0000000100003BBC FC 6F BE A9 STP X28, X27, [SP,#-0x10+var_10]! | |
__text:0000000100003BC0 FD 7B 01 A9 STP X29, X30, [SP,#0x10+var_s0] | |
__text:0000000100003BC4 FD 43 00 91 ADD X29, SP, #0x10 | |
__text:0000000100003BC8 FF 03 04 D1 SUB SP, SP, #0x100 |
可以看出字节数据都是整齐偏移的
用 vscode 打开文本文件,shif+alt 键进行矩形选择
得到这样的数据
FC 6F BE A9
FD 7B 01 A9
FD 43 00 91
FF 03 04 D1
08 00 00 B0
打开 010 编辑器
新建文件 -> 编辑 -> 粘贴自 16 进制文本 -> 保存到桌面
用 ida 打开文件,选择汇编语言类型,小端序 ARM。
可以看到汇编代码,按 p 键创建函数,F5 即可看到 c 语言代码。
# 解密
有了伪 c 代码解密就和洒洒水一样
#include <stdio.h> | |
int main(){ | |
char flag[] = "flag{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}"; | |
char mm1[]={0xd7,0x1f,0x00,0x00,0xb7,0x21,0x00,0x00,0x47,0x1e,0x00,0x00,0x27,0x20,0x00,0x00,0xe7,0x26,0x00,0x00,0xd7,0x10,0x00,0x00,0x27,0x11,0x00,0x00,0x07,0x20,0x00,0x00,0xc7,0x11,0x00,0x00,0x47,0x1e,0x00,0x00,0x17,0x10,0x00,0x00,0x17,0x10,0x00,0x00,0xf7,0x11,0x00,0x00,0x07,0x20,0x00,0x00,0x37,0x10,0x00,0x00,0x07,0x11,0x00,0x00,0x17,0x1f,0x00,0x00,0xd7,0x10,0x00,0x00,0x17,0x10,0x00,0x00,0x17,0x10,0x00,0x00,0x67,0x1f,0x00,0x00,0x17,0x10,0x00,0x00,0xc7,0x11,0x00,0x00,0xc7,0x11,0x00,0x00,0x17,0x10,0x00,0x00,0xd7,0x1f,0x00,0x00,0x17,0x1f,0x00,0x00,0x07,0x11,0x00,0x00,0x47,0x0f,0x00,0x00,0x27,0x11,0x00,0x00,0x37,0x10,0x00,0x00,0x47,0x1e,0x00,0x00,0x37,0x10,0x00,0x00,0xd7,0x1f,0x00,0x00,0x07,0x11,0x00,0x00,0xd7,0x1f,0x00,0x00,0x07,0x11,0x00,0x00,0x87,0x27,0x00,0x00}; | |
int *mm=mm1; | |
int index=0; | |
size_t len = strlen(flag); | |
int lena = len + 1; | |
while (index < lena){ | |
mm[index]-=0x1e; | |
mm[index]^='M'; | |
mm[index] =(mm[index]-0x14)/'P';; | |
flag[index]=mm[index]; | |
index++; | |
} | |
puts(flag); | |
} |
# Rust_baby
像这种用那些奇葩语言写的二进制文件靠静态分析是很难做出来的
动态调试寻找函数
一直 f8
步过,多窗口观察终端有没有输出什么信息
发现在 sub_7FF7D72B298A
的地方程序输出 where is your flag?:
我们由此确定主逻辑在这里。
函数有里有发现明显的长 base64 字符串
拿去解密得到
{ | |
"henhenaaa!":[1,1,4,5,1,4,1,9,1,9,8,1,0], | |
"cryforhelp":"igdydo19TVE13ogW1AT5DgjPzHwPDQle1X7kS8TzHK8S5KCu9mnJ0uCnAQ4aV3CSYUl6QycpibWSLmqm2y/GqW6PNJBZ/C2RZuu+DfQFCxvLGHT5goG8BNl1ji2XB3x9GMg9T8Clatc=", | |
"whatadoor":"1145141919810WTF", | |
"iwantovisit":"O0PSwantf1agnow1" | |
}{ | |
"where":"where is your flag?:", | |
"omg":"correct flag", | |
"nonono":"nope, wrong flag" | |
} |
这很明显是和加密有关的重要数据。
动调找到输出函数输入函数
从这一段到函数开头有很长一串代码,我们就不用去管它了,这种题只需要关注代码对数据的加密,不然很容易就被绕昏了。
输入函数后面下好断点,在终端输入数据 flagggggggggggg 然后再在输入函数周围寻找对这段字符串的引用,找到引用后观察对输入字符处理
do | |
{ | |
*(_QWORD *)&flagg[0] = 0i64; | |
for ( j = 0i64; j != 8; ++j ) | |
{ | |
v26 = 'E'; | |
if ( v23 + j < v20 ) | |
v26 = flagggggggg[j]; | |
*((_BYTE *)flagg + j) = v26; | |
} | |
v197[0] = (LPVOID)sub_7FF7D72B28C3( | |
*(__int64 *)&flagg[0], | |
byte_7FF7D72D2978[(unsigned __int8)(v24 - 3 * (((unsigned __int8)v24 / 3u) & 0xFE))], | |
*((_QWORD *)v188 + v24)); | |
for ( k = 0i64; k != 8; ++k ) | |
flagm1[k] = *((_BYTE *)v197 + k) ^ 0x33; | |
++v24; | |
flagggggggg += 8; | |
v23 += 8i64; | |
flagm1 += 8; | |
} | |
while ( v24 != 13 ); |
前段是把 flag 每 8 组复制一次,剩下的补 'E'
中间是个加密函数,先跳过
后面是一个异或
flagm1 存储最后的数据,可是对它的调用在 +=8
后就没有了。我们不能得知它在哪又被处理了。
这个时候需要妙用硬件断点分析,对加密后的前几个字节下断点,硬件断点可以下在 stack,监听数据的读写,读写时提示触发代码
Stack[000008D8]:000000DC9FCFEA50 db 56h ; V <-breakpoint
Stack[000008D8]:000000DC9FCFEA51 db 58h ; X
Stack[000008D8]:000000DC9FCFEA52 db 52h ; R
Stack[000008D8]:000000DC9FCFEA53 db 54h ; T
Stack[000008D8]:000000DC9FCFEA54 db 5Bh ; [
Stack[000008D8]:000000DC9FCFEA55 db 5Bh ; [
当触发断点的时候,我们已经从伪 c 代码的 369 行跳转到 634 行,这几百行看起来都极难分析,我们略过,直接观察对加密数据的处理
do | |
{ | |
v93[v97] = v96[v97] ^ *(_BYTE *)(v91 + v97); | |
++v97; | |
} | |
while ( v88 != v97 ); |
可以看出,v91 是 flag 加密后的数据,只是个简单的对表异或,这个异或表,可以经过多次调试推断,是个固定的表
debug027:0000025E67C42FA0 db 0DCh
debug027:0000025E67C42FA1 db 5Fh ; _
debug027:0000025E67C42FA2 db 20h
debug027:0000025E67C42FA3 db 22h ; "
debug027:0000025E67C42FA4 db 0C2h
debug027:0000025E67C42FA5 db 79h ; y
debug027:0000025E67C42FA6 db 19h
debug027:0000025E67C42FA7 db 56h ; V
debug027:0000025E67C42FA8 db 35h ; 5
debug027:0000025E67C42FA9 db 0DAh
debug027:0000025E67C42FAA db 8Bh
debug027:0000025E67C42FAB db 47h ; G
debug027:0000025E67C42FAC db 0D3h
debug027:0000025E67C42FAD db 19h
debug027:0000025E67C42FAE db 0FCh
debug027:0000025E67C42FAF db 55h ; U
debug027:0000025E67C42FB0 db 0ABh
debug027:0000025E67C42FB1 db 0ABh
debug027:0000025E67C42FB2 db 0ABh
debug027:0000025E67C42FB3 db 0ABh
再次对异或后的数据下硬件断点
do | |
v101[v90++] = *(_BYTE *)(v99 + v102++); | |
while ( v100 != v102 ); |
触发断点的是一个数据复制操作
继续对复制后的数据位置下断点
v112 = _byteswap_uint64(*(_QWORD *)&v101[v109]); | |
*(_BYTE *)(v106 + v108 - 32) = byte_7FF7D72D25F8[(v112 >> 58) + 3]; | |
*(_BYTE *)(v106 + v108 - 31) = byte_7FF7D72D25F8[((v112 >> 52) & 0x3F) + 3]; | |
*(_BYTE *)(v106 + v108 - 30) = byte_7FF7D72D25F8[((v112 >> 46) & 0x3F) + 3]; |
这次触发的是一大堆取表操作,数据被转化到 v106
我们对 v106 硬件断点,继续探索逻辑
v86 = v135[*((_QWORD *)&Src[0] + 1)] == v135[v106];
++v135;
if ( !v86 )
{
v136 = sub_7FF7D72C426C("nonono", 6ui64, (__int64)v174);
我们这次直接定位到一个循环的判断代码片段里,这里应该是判断密文的地方了,左边的 src 也确实藏着一个开头得到的密文数据,同时我们点击 v106,发现里面的数据全是可见字符,并且最后一个字符是 '=’, 结合代码特征可知是 base64 加密。
整体分析到此结束,我们来梳理一下:
flag分组补'E'->每组到sub_7FF7D72B28C3加密->异或0x33->异或一个固定的表->base64
现在逻辑再清晰不过了,我们只差 sub_7FF7D72B28C3 这个加密就可得出 flag
这里我引用别人的解法:调试找规律
Stack[000011E8]:000000A8A00FE5A8 offset db 66h ; f | |
Stack[000011E8]:000000A8A00FE5A9 db 66h ; f | |
Stack[000011E8]:000000A8A00FE5AA db 67h ; g | |
Stack[000011E8]:000000A8A00FE5AB db 67h ; g | |
Stack[000011E8]:000000A8A00FE5AC db 68h ; h | |
Stack[000011E8]:000000A8A00FE5AD db 68h ; h | |
Stack[000011E8]:000000A8A00FE5AE db 69h ; i | |
Stack[000011E8]:000000A8A00FE5AF db 69h ; i | |
Stack[000011E8]:000000A8A00FE5B0 flag db 67h ; g | |
Stack[000011E8]:000000A8A00FE5B1 db 67h ; g | |
Stack[000011E8]:000000A8A00FE5B2 db 67h ; g | |
Stack[000011E8]:000000A8A00FE5B3 db 67h ; g | |
Stack[000011E8]:000000A8A00FE5B4 db 67h ; g | |
Stack[000011E8]:000000A8A00FE5B5 db 67h ; g | |
Stack[000011E8]:000000A8A00FE5B6 db 67h ; g | |
Stack[000011E8]:000000A8A00FE5B7 db 67h ; g |
delta = -1 | |
input+= delta | |
if i % 2 =1 | |
delta -= 1 |
简单的一个加减运算,可是看起来却非常难懂,
可知我们解 ctf 题有时也需要一些取巧的技巧,
唉,感觉自己修为还不够,学长调几次就看出了这个伪加密,道阻且长。
tips: 这个函数也可以利用硬件断点来分析,可以分析出flag只在最后的循环语句中被读取,并且只执行了简单的加减操作,以前没发现硬件断点有如此妙用,如今是领教到了
以下是解密脚本
#include <stdio.h> | |
void decodeBase64(char* str,int len,char** in){ | |
char base64[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; | |
char ascill[129]; | |
int k = 0; | |
for(int i=0;i<64;i++){ | |
ascill[base64[i]] = k++; | |
} | |
int decodeStrlen = len / 4 * 3 + 1; | |
char* decodeStr = (char*)malloc(sizeof(char)*decodeStrlen); | |
k = 0; | |
for(int i=0;i<len;i++){ | |
decodeStr[k++] = (ascill[str[i]] << 2) | (ascill[str[++i]] >> 4); | |
if(str[i+1] == '='){ | |
break; | |
} | |
decodeStr[k++] = (ascill[str[i]] << 4) | (ascill[str[++i]] >> 2); | |
if(str[i+1] == '='){ | |
break; | |
} | |
decodeStr[k++] = (ascill[str[i]] << 6) | (ascill[str[++i]]); | |
} | |
decodeStr[k] = '\0'; | |
*in = decodeStr; | |
} | |
int main(){ | |
unsigned char xortable[]={0xdc,0x5f,0x20,0x22,0xc2,0x79,0x19,0x56,0x35,0xda,0x8b,0x47,0xd3,0x19,0xfc,0x55,0x14,0xcd,0xd2,0x7b,0x58,0x59,0x09,0x42,0xde,0x2c,0xb4,0x48,0xd9,0xf2,0x1b,0xa9,0x40,0xe1,0xa6,0xfb,0xff,0x38,0xc1,0xd5,0xe2,0xe8,0x77,0x78,0x6f,0x22,0x04,0xe6,0x16,0x3e,0x0c,0x35,0x27,0x29,0x89,0xb5,0x92,0x2e,0x6a,0xa6,0xdb,0x2f,0xc6,0xa9,0x6e,0x8f,0x34,0x90,0x59,0xfc,0x2d,0x91,0x66,0xeb,0xbe,0x0d,0xf4,0x05,0x0b,0x1b,0xcb,0x18,0x74,0xf9,0x82,0x81,0xbc,0x04,0xd9,0x75,0x8e,0x2d,0x97,0x07,0x7c,0x7d,0x18,0xc8,0x3d,0x4f,0xc0,0xa5,0x6a,0xd7}; | |
unsigned char *mm2; | |
decodeBase64(mm1,strlen(mm1),&mm2); | |
puts(mm2); | |
for(int i=0;i<strlen(mm1) / 4 * 3 + 1;i++){ | |
mm2[i]^=(unsigned char)xortable[i]; | |
mm2[i]^=0x33; | |
} | |
puts(mm2); | |
for(int i=0;i<strlen(mm2);i+=8){ | |
mm2[i]+=1; | |
mm2[i+1]+=1; | |
mm2[i+4]-=1; | |
mm2[i+5]-=1; | |
mm2[i+6]-=2; | |
mm2[i+7]-=2; | |
} | |
puts(mm2); | |
} |