how2heap 深入学习(9)

已于 2022-04-17 23:36:06 修改
阅读量888 收藏
点赞数 1
分类专栏： PWN学习笔记 文章标签： pwn 安全 c语言
于 2022-04-17 23:33:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54218833/article/details/124239224
版权

how2heap下载网址: 传送门
Glibc源码查看网址：传送门
参考书籍：CTF竞赛权威指南-pwn篇

测试环境：Ubuntu 20.04
Glibc 版本：Ubuntu GLIBC 2.31-0ubuntu9.7

最近做题，由于对2.31中添加的检查项缺乏总结，导致浪费了很多时间，本文分析glibc 2.31中关键函数中的检查项。如果读者仔细看过我写的前8篇文章，对于各种bin的结构应该已经较为熟悉，本文的阅读难度就不大了，如有疑问请移步。目前分析的函数有：_int_malloc，unlink_chunk，_int_free函数，之后会更新其他函数的分析。
如果本文的分析有任何错漏之处，还请各位读者不吝赐教，不胜感激。

一、_int_malloc

1. fastbin部分

（1）检查victim是否应该存在于该fastbin

// line 3592
size_t victim_idx = fastbin_index (chunksize (victim));
if (__builtin_expect (victim_idx != idx, 0))
	malloc_printerr ("malloc(): memory corruption (fast)");

这里的fastbin_index函数指的应该是根据victim的大小获取到其应该存放的fastbin索引。显然0x30大小的chunk在正常情况下不可能跑到专门存放0x20大小chunk的fastbin中，该检查就是针对这种异常情况，能够防止victim的size被修改。

2. tcache部分

在2.31版本中，通过搜索关键函数tcache_put、malloc_printerr没有找到对tcache的检查。

3. small bins部分

（1）检查victim->bck->fwd是否为victim

// line 3643
if (__glibc_unlikely (bck->fd != victim))
	malloc_printerr ("malloc(): smallbin double linked list corrupted");

4. unsorted bin部分

关于这部分的检查是最多的，也是最难以绕过的。

（1）检查victim的size是否合法

// line 3734
if (__glibc_unlikely (size <= 2 * SIZE_SZ)
    || __glibc_unlikely (size > av->system_mem))
  malloc_printerr ("malloc(): invalid size (unsorted)");

victim的大小不应小于0x20（64位），不应大于av->system_mem

（2）检查物理地址居victim高位的chunk的size是否合法

mchunkptr next = chunk_at_offset (victim, size);
// line 3737
if (__glibc_unlikely (chunksize_nomask (next) < 2 * SIZE_SZ)
    || __glibc_unlikely (chunksize_nomask (next) > av->system_mem))
  malloc_printerr ("malloc(): invalid next size (unsorted)");

这里的chunk_at_offset函数指的是将victim往后size处作为一个chunk返回，也就是这里检查物理相邻的chunk的size

（3）检查物理地址居victim高位的prev_size是否等于victim的size

// line 3740
if (__glibc_unlikely ((prev_size (next) & ~(SIZE_BITS)) != size))
  malloc_printerr ("malloc(): mismatching next->prev_size (unsorted)");

由于victim是一个free chunk，因此物理地址居高位的chunk的开头理应存放victim的size，这里进行检查。

（4）检查unsorted bin链中victim->bck->fd是否是victim，victim->fd是否为unsorted bin头

// line 3742
if (__glibc_unlikely (bck->fd != victim)
    || __glibc_unlikely (victim->fd != unsorted_chunks (av)))
  malloc_printerr ("malloc(): unsorted double linked list corrupted");

大循环遍历期间，每一次拿出来的victim都在unsorted bin的尾部，其fd指针一定指向unsorted bin头，bk指向后一个chunk或unsorted bin头（当unsorted bin仅有这一个chunk时），因此正常情况下victim->bck->fd==victim与victim->fd==unsorted_chunks(av)一定成立。

（5）检查物理地址居victim高位的chunk的prev_inuse位是否为0

// line 3745
if (__glibc_unlikely (prev_inuse (next)))
  malloc_printerr ("malloc(): invalid next->prev_inuse (unsorted)");

（6）第二次检查unsorted bin链中victim->bck->fd是否是victim

// line 3785
if (__glibc_unlikely (bck->fd != victim))
  malloc_printerr ("malloc(): corrupted unsorted chunks 3");

在可能进行的remainder拆分后，再一次进行检查。目前尚不清楚这里再次检查的意义何在，理解后更新。

（7）第三次检查unsorted bin链中bck->fd是否是victim

// line 3954
bck = unsorted_chunks (av);
fwd = bck->fd;
if (__glibc_unlikely (fwd->bk != bck))
	malloc_printerr ("malloc(): corrupted unsorted chunks");

这个检查发生于非small bins大小申请的last_remainder拆分部分，又一次进行了unsorted bin的双向链表完整性检查。

（8）第四次检查unsorted bin链中bck->fd是否是victim

// line 4058
bck = unsorted_chunks (av);
fwd = bck->fd;
if (__glibc_unlikely (fwd->bk != bck))
	malloc_printerr ("malloc(): corrupted unsorted chunks 2");

这个检查发生在切割large bin部分，切割后剩余的部分作为last_remainder放入unsorted bin，因此检查。

5. large bins部分

（1）检查fwd->bk_nextsize->fd_nextsize是否等于fwd

// line 3867
if (__glibc_unlikely (fwd->bk_nextsize->fd_nextsize != fwd))
  malloc_printerr ("malloc(): largebin double linked list corrupted (nextsize)");

这个检查发生在victim被链入到large bins的过程中，fwd表示victim被链入后处于victim之前的chunk。这里的检查在正常情况下显然成立。

（2）检查fwd->bk->fd是否等于fwd

// line 3872
bck = fwd->bk;
if (bck->fd != fwd)
  malloc_printerr ("malloc(): largebin double linked list corrupted (bk)");

这个检查也发生在victim被链入到large bins的过程中，检查large bin中双向链表的完整性。

6. top chunk部分

（1）检查top chunk大小

// line 4106
if (__glibc_unlikely (size > av->system_mem))
  malloc_printerr ("malloc(): corrupted top size");

检查top chunk是否大到离谱。

二、unlink_chunk

（1）检查物理地址居victim高位的chunk的prev_size是否等于victim的size

// line 1453
if (chunksize (p) != prev_size (next_chunk (p)))
  malloc_printerr ("corrupted size vs. prev_size");

（2）检查前后双向链表完整性：fd->bk != p || bk->fd != p

// line 1459
if (__builtin_expect (fd->bk != p || bk->fd != p, 0))
  malloc_printerr ("corrupted double-linked list");

（3）检查large bins双向链表完整性：p->fd_nextsize->bk_nextsize != p || p->bk_nextsize->fd_nextsize != p

// line 1466
if (p->fd_nextsize->bk_nextsize != p
	|| p->bk_nextsize->fd_nextsize != p)
	malloc_printerr ("corrupted double-linked list (not small)");

三、_int_free

（1）检查size是否合理，chunk是否正确对齐

// line 4171
if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
    || __builtin_expect (misaligned_chunk (p), 0))
  malloc_printerr ("free(): invalid pointer");

简单解释一下第一个判断的意思：(uintptr_t) p > (uintptr_t) -size。它指的是chunk的地址加上chunk的size不能导致整形溢出。这很好理解，正常情况下这种情况不会发生。不过如果想理解这条语句，需要进行一些移项。

两边均为无符号整数，则-size==2^64-size，等式可以变形为：p+size>2^64。

（2）检查size是否过小，检查size是否对齐

// line 4176
if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
  malloc_printerr ("free(): invalid size");

这里的MINSIZE=0x10，最小的chunk不能小于这个大小。

（3）检查tcache double free

// line 4187
	tcache_entry *e = (tcache_entry *) chunk2mem (p);

	/* This test succeeds on double free.  However, we don't 100%
	   trust it (it also matches random payload data at a 1 in
	   2^<size_t> chance), so verify it's not an unlikely
	   coincidence before aborting.  */
	if (__glibc_unlikely (e->key == tcache))
	  {
	    tcache_entry *tmp;
	    LIBC_PROBE (memory_tcache_double_free, 2, e, tc_idx);
	    for (tmp = tcache->entries[tc_idx];
		 tmp;
		 tmp = tmp->next)
	      if (tmp == e)
		malloc_printerr ("free(): double free detected in tcache 2");
	    /* If we get here, it was a coincidence.  We've wasted a
	       few cycles, but don't abort.  */
	  }

在chunk被链入tcache时，会对chunk进行标记，也即将成员key标记为tcache的地址。

tcache chunk定义：

// line 2894
typedef struct tcache_entry
{
  struct tcache_entry *next;
  /* This field exists to detect double frees.  */
  struct tcache_perthread_struct *key;
} tcache_entry;

注意上面的tcache_entry结构体在chunk中的头部是可写段的头部而非chunk的头部，前面还有size和prev_size两个字段。

观察_int_free中的代码，我们可以发现，在这个过程中，如果glibc发现要free的chunk（以下称p）有标志，则说明很可能这是一次double free。为了确认无误，glibc会对相应的tcache中的所有chunk进行检查，如果确实发现该chunk已经存在于tcache中，再报错退出。这是为了防止异常的误报。如果本身这不是一个double free，而key正好填的也是tcache，glibc不能认定这是一次double free，因此它遍历tcache中的chunk进行确认。

（4）检查fastbin chunk size

// line 4236
	bool fail = true;
	/* We might not have a lock at this point and concurrent modifications
	   of system_mem might result in a false positive.  Redo the test after
	   getting the lock.  */
	if (!have_lock)
	  {
	    __libc_lock_lock (av->mutex);
	    fail = (chunksize_nomask (chunk_at_offset (p, size)) <= 2 * SIZE_SZ
		    || chunksize (chunk_at_offset (p, size)) >= av->system_mem);
	    __libc_lock_unlock (av->mutex);
	  }

	if (fail)
	  malloc_printerr ("free(): invalid next size (fast)");
      }

这里检查p的大小是否过小或过大，与_int_malloc中对应检查相同。在检查过程中对这个main_arena上锁以避免多线程的影响。

（5）检查fastbin double free

// line 4256
    fb = &fastbin (av, idx);

    /* Atomically link P to its fastbin: P->FD = *FB; *FB = P;  */
    mchunkptr old = *fb, old2;

    if (SINGLE_THREAD_P)
      {
	/* Check that the top of the bin is not the record we are going to
	   add (i.e., double free).  */
	if (__builtin_expect (old == p, 0))
	  malloc_printerr ("double free or corruption (fasttop)");
	p->fd = old;
	*fb = p;
      }
    else
      do
	{
	  /* Check that the top of the bin is not the record we are going to
	     add (i.e., double free).  */
	  if (__builtin_expect (old == p, 0))
	    malloc_printerr ("double free or corruption (fasttop)");
	  p->fd = old2 = old;
	}
      while ((old = catomic_compare_and_exchange_val_rel (fb, p, old2))
	     != old2);

这里检查的是上一次free的chunk和这一次是不是同一个，即相邻检查。使用两个检查是为了兼容多线程，不用深究。

（6）检查fastbin环境

// line 4286
if (have_lock && old != NULL
&& __builtin_expect (fastbin_index (chunksize (old)) != idx, 0))
  malloc_printerr ("invalid fastbin entry (free)");

这里应该是检查原fastbin头的chunksize是否正确。

（7）检查p是否为top chunk

// line 4308
if (__glibc_unlikely (p == av->top))
  malloc_printerr ("double free or corruption (top)");

（8）检查该chunk是否超出了main_arena的管辖范围

// line 4311
if (__builtin_expect (contiguous (av)
 && (char *) nextchunk
 >= ((char *) av->top + chunksize(av->top)), 0))
	malloc_printerr ("double free or corruption (out)");

这里是检查chunk尾部的地址是否大于top chunk的尾部地址。

（9）检查物理地址后一个chunk是否有prev_inuse位

// line 4316
if (__glibc_unlikely (!prev_inuse(nextchunk)))
  malloc_printerr ("double free or corruption (!prev)");

（10）检查物理地址后一个chunk的大小是否合理

// line 4320
if (__builtin_expect (chunksize_nomask (nextchunk) <= 2 * SIZE_SZ, 0)
|| __builtin_expect (nextsize >= av->system_mem, 0))
  malloc_printerr ("free(): invalid next size (normal)");

（11）检查物理地址前一个chunk的size是否等于prev_size

// line 4327
if (!prev_inuse(p)) {
  prevsize = prev_size (p);
  size += prevsize;
  p = chunk_at_offset(p, -((long) prevsize));
  if (__glibc_unlikely (chunksize(p) != prevsize))
    malloc_printerr ("corrupted size vs. prev_size while consolidating");
  unlink_chunk (av, p);
}

这里是尝试与前一个chunk进行合并，顺便进行一下前面chunk的size检查。

（12）检查unsorted bin链表尾部的双向链表完整性

// line 4353
bck = unsorted_chunks(av);
fwd = bck->fd;
if (__glibc_unlikely (fwd->bk != bck))
	malloc_printerr ("free(): corrupted unsorted chunks");

与_int_malloc中频繁进行的检查相同。

C0Lin
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
how2heap 1-4
WHOISjxb的博客
04-06 487
文章目录1. First_fit.c2. Fastbin_dup.c 64位系统以下各字段均为8字节，32位系统为4字节。 glibc2.26及以上版本有tcache机制。咱目前也不太懂，快刀斩乱麻，glibc2.25的实验在Ubuntu16.04上做，glibc版本信息如下： 1. First_fit.c 运行结果： 分析： 新版的how2heap这里改为0x512、0x256（十六进制...
how2heap:一个用于学习各种堆利用技术的存储库
04-05
此仓库用于学习各种堆利用技术。 我们使用Ubuntu的Libc版本作为黄金标准。 每种技术均已验证可在相应的Ubuntu版本上使用。 您可以运行apt source libc6来下载您在基于Debian的操作系统上使用的Libc的源代码。 我们...
程序执行到一半报错“`malloc(): mismatching next-＞prev_size (unsorted)`”死掉
handily_1的博客
05-20 1444
报错的原因是：当前栈空间不足。程序执行到一半报错“先检查当前栈空间大小。
how2heap总结
Juny0117的博客
12-07 738
今天，让我们来总结下how2heap，之前粗略过了一下，但最近发现还是有很多细节不太清楚，于是现在回头来重新调试下how2heap。 就按顺序来吧。 0x01 fastbin_dup： 源码: 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 int main() 5 { 6 ...
How2Heap笔记（一）
kelxLZ的博客
01-21 2605
Author：ZERO-A-ONE Date：2021-01-21 ​ “how2heap”是shellphish团队在Github上开源的堆漏洞系列教程。上面有很多常见的堆漏洞教学示例，实现了以下技术： File Technique Glibc-Version Patch Applicable CTF Challenges first_fit.c Demonstrating glibc malloc’s first-fit behavior. calc_tcache_idx..
how2heap注意点总结-上
九层台
03-11 927
1.chunk的申请机制，在申请chunk的时候满足first-fit算法（从unsorted bin中遍历遇到第一个比需要chunk大的chunk切割，然后遍历unsorted bin链对应chunk放入对应位置） （所需chunk大小大于small bin或者small bin中没有找到恰好满足的chunk大小，或者fastbin中没有找到合适的chunk大小会引起fast bins遍历合并放...
语雀how2heap
wulou4hao的博客
12-08 315
fastbin_dup_into_stack部分 此语句能够得到 stack_var 的地址 令我不解 同理此语句可完成如此功能 令我不解
ion_heap.rar_ION_V2 _heap
09-19
2. **缓存对齐**：为了提高数据访问效率，ION V2 heap会确保分配的内存块满足缓存对齐的要求，这对于硬件加速和数据传输至关重要。 3. **内存共享**：ION V2 heap支持跨进程的内存共享，允许多个驱动程序或者进程...
深入Java虚拟机中的Stack和Heap
08-10
"深入Java虚拟机中的Stack和Heap" 在Java虚拟机（JVM）中，内存分为两个部分：Stack（栈）和Heap（堆）。Stack是JVM的内存指令区，管理很简单，push一定长度字节的数据或者指令，Stack指针压栈相应的字节位移；pop...
HeapAnalyzer
03-05
《深入解析Java虚拟机堆内存分析工具：HeapAnalyzer》 在Java编程领域，理解并优化JVM（Java Virtual Machine）的内存管理是提升系统性能的关键环节。HeapAnalyzer是一款专门用于分析JVM堆内存的工具，它能帮助...
深入Java虚拟机：JVM中的Stack和Heap
08-10
"深入Java虚拟机：JVM中的Stack和Heap" Java虚拟机（JVM）是一种运行Java字节码的虚拟机环境，它具有自己的内存管理机制。JVM的内存分为两个部分：Stack（栈）和Heap（堆）。 Stack（栈）是JVM的内存指令区，管理...
how2heap总结-上
hl1293348082的专栏
04-07 677
0x00 前言 "how2heap"是shellphish团队在Github上开源的堆漏洞系列教程. 我这段时间一直在学习堆漏洞利用方面的知识,看了这些利用技巧以后感觉受益匪浅. 这篇文章是我学习这个系列教程后的总结,在此和大家分享.我会尽量翻译原版教程的内容,方便英语不太好的同学学习。 源码部分我的可能和原版教程不一样，改动的地方我是为了方便自己理解，所以还是建议大家看这篇总结之前去看原版教程。 不过在学习这些技巧之前,建议大家去看一看华庭写的"Glibc内存管理-Ptmalloc2源码分析"
how2heap glibc 2.27
qq_46441427的博客
10-10 467
fastbin dup 展示了glibc2.27里利用double free进行的fastbin attack #include <stdio.h> #include <stdlib.h> #include <assert.h> int main() { setbuf(stdout, NULL); printf("This file demonstrates a simple double-free attack with fastbins.\n"); pri
how2heap 深入学习(1)
CoLin的pwn小屋
02-10 2793
how2heap glibc 2.23学习
how2heap—glibc 2.23—unsafe_unlink.c
xy_369的博客
06-22 137
①：p 是高地址的 chunk ，if 判断中首先检测 P 的 Size 字段的 P 位是否为 0 ，是则说明物理相邻的低地址 chunk 为 free chunk ，可以向后合并，然后就获取 p 的 Prev_size，将 p 的 Prev_size 加到 p 的 Size 就算把物理相邻的低地址 chunk 合并了，然后将 p 指向被合并的低地址 chunk ，再利用 unlink 将其从 bin 中删除就算完成了向后合并。②：第一句检测过后，会执行 FD = P->fd;BK = P->bk;
how2heap 深入学习(8)
CoLin的pwn小屋
03-21 2889
how2heap 2.27学习
how2heap 深入学习(4)
CoLin的pwn小屋
03-10 2601
glibc 2.23 how2heap学习——large_bin attack + overlapping chunks + poison_null_byte
how2heap 深入学习(2)
CoLin的pwn小屋
02-12 762
glibc 2.23源码分析系列之house_of_mind_fastbin + house of orange
how2heap2.31学习(2)
m0_51251108的博客
10-01 1011
how2heaplibc2.31的house部分
H2数据库 java.lang.OutofMemoryError:Java heap space
最新发布
10-19
H2数据库是一个开源的嵌入式关系型数据库，它是用Java语言编写的。在使用H2数据库时，有时会遇到Java heap space的错误，这是由于JVM分配给应用程序的内存不足所导致的。这种错误通常可以通过增加JVM的内存限制来解决。可以通过在启动应用程序时添加JVM参数“-Xmx”来增加JVM的最大内存限制，例如“-Xmx2g”表示将JVM的最大内存限制设置为2GB。此外，还可以通过优化应用程序的代码和数据结构来减少内存使用量，从而避免Java heap space错误的发生。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值