字太多了，更新时打字一卡一卡的，完整版去博客看吧。

深入理解Pwn_Heap及相关例题

源码查看网址

本文主要参考C0Lin和_sky123_两位宝藏师傅的博客。

本文写的较为冗余，适合和我一样的新手朋友看。文中并没有对堆的手法进行详细的说明，文章的堆利用手法可以看上面的文章（包括了目前 how2heap 里全系列的手法，其他手法有时间会补充到里面）。后面关于 _IO_FILE 利用的手法会更新在这里（方便查）。

进行文件读写操作时会为对应文件创建一个 _IO_FILE_plus 结构体，并且链接到 _IO_list_all 链表 头部 上，vtable 指向一张虚函数表_IO_jump_t，此表中记录着对文件进行的各种操作，_IO_FILE 和 _IO_jump_t 组成了 _IO_FILE_plus。 stdin, stdout, stderr 是位于 libc.so 中，而通过 fopen 的创建的则是位于堆内存。

glibc-2.23源

图解

fopen 未调用 vtable 中的函数，fopen 对应的函数 __fopen_internal 内部会调用 malloc 函数，分配 FILE 结构的空间。因此我们可以获知 FILE 结构是存储在堆上的。

流程

使用 malloc 分配 FILE 结构

设置 FILE 结构的 vtable

初始化分配的 FILE 结构

将初始化的 FILE 结构链入 FILE 结构链表头部

调用系统调用打开文件

必须要 libc 的低 32 位地址为负时，攻击才会成功。在 fflush 函数的检查里，它第二步才是跳转，第一步的检查，在 arena 里的伪造 file 结构中这两个值，绝对值一定可以通过，那么就会直接执行虚表函数。所以只有为负时，才会 check 失效。

我们有五次任意地址写 1 字节的机会，并且给了我们 sleep() 函数的地址。

glibc-2.23 版本及之前没有 _IO_vtable_check 检查，因此可以伪造 vtable 劫持程序流程。 exit 函数有一条这样的调用链 exit->__run_exit_handlers->_IO_cleanup->_IO_unbuffer_all->_IO_SETBUFF(fp, NULL, 0)，这里调用了 _IO_2_1_stdout_ 的vatable 中 _setbuf 函数.。但位于 libc 数据段的 vtable 是不可以进行写入的，因为 _IO_jumps_t 的第 11 位是 JUMP_FIELD(_IO_setbuf_t, __setbuf); 所以我们可以在其附近寻找 fake_vtable 将其 (11*8)0x58 处改为 one_gadget ，当程序退出调用 exit 时将会调用 one_gadget 从而 getshell 。

获取信息

libc.sym['_IO_2_1_stdout_'] + 0xd8 是 _IO_2_1_stdout_ 的 vtable 指针，glibc-2.23版本x64 的偏移(struct _IO_FILE大小)为 0xd8，x32 减半。

get_shell

前两次机会我们可以修改 stdout_vtable 的后 16 位将其指向 fake_vtable 。

后面三次机会将 fake_vtable 的高 11*8(0x58) 处的 _IO_SETBUF(实际上是 stderr_vtable) 改为 onegadget，因为都在 libc.so 数据段，所以我们只需要修改其后 8*3 位即可。

最后调用了 one_gadget 。

但是我这里4 个 one_gadget 都不满足条件，这个方法没打通，哪里有问题还想烦请师傅多多指教。

图解

FSOP 的核心思想就是劫持 _IO_list_all 指向伪造的 _IO_FILE_plus 。之后使程序执行 _IO_flush_all_lockp 函数刷新 _IO_list_all 链表中所有项的文件流，相当于对每个 FILE 调用 fflush ，也对应着会调用 _IO_FILE_plus.vtable 中的 _IO_overflow。FSOP 通过伪造 _IO_jump_t 中的 __overflow 为 system() 函数 地 址 ， 最 终 在 _IO_OVERFLOW(fp,EOF) 函 数 中 执 行 system('/bin/sh') 并获得 shell。

_IO_flush_all_lockp 在一些情况下这个函数会被系统调用：

还有一条FSOP的路径是在关闭流的时候，在 _IO_FINISH(fp) 的执行过程中最终会调用伪造的 system('/bin/sh')。

其结构大致为:

其中 orange 是通过 calloc 申请的。

See 函数会打印出 house->name、orange->price 和 orange 图案。

Upgrade 函数重新设置了 len_of_name 后直接向旧的 name 区域读入内容，如果 len_new > len_old 就会导致堆溢出。

本题没有 free 函数，存在堆溢出。当 top chunk的剩余部分已经不能够满足请求时，就会调用函数 sysmalloc()分配新内存， 这时可能会发生两种情况，一种是调用 sbrk函数直接扩充 top chunk，另一种是调用 mmap 函数分配一块新的 top chunk。具体调 用哪一种方法是由申请大小决定的，为了能够使用前一种扩展 top chunk，需要请求小于阈值 mp_.mmap_threshold。 要成功调用 _int_free() 还需绕过两个断言:

(unsigned long) (old_size) >= MINSIZE 也就是 0x20。

prev_inuse == 1

((unsigned long) old_end & (pagesize - 1)) == 0 页对齐

(unsigned long) (old_size) < (unsigned long) (nb + MINSIZE) 新申请的 size 大于 old size + MINSIZE

这样便可成功泄露 libc 基址，从而获得 _IO_list_all 地址，然后可以利用 unsorted bin attack 劫持 _IO_list_all 到main_arena+88，利用 fp->chain 域，使 fp 指 向 old_top，前 8 字节为 '/bin/sh\x00' 字符串，使 _IO_OVERFLOW 为system 函数的地址，从而获得 shell。

前置脚本

泄露libc和heap基址

首先通过堆溢出将 top_chunk 的大小改为 0xf81。

然后申请一块大于 0xf81 的 chunk 利用上面讲的 sysmalloc 中的 _int_free 函数将 old_top_chunk 放入 unsorted_bin 中。在申请 0x400 大小的 large_chunk ，ptmalloc2 会先将 old_top_chunk 放进 large_bin，然后切分 old_top_chunk，再将其放回 unsorted_bin。 所以此时其 fd_nextsize 和 bk_nextsize 遗留了 heap 地址。其 bk 位置遗留了 main_arean+0x668 的地址。我们可以通过 0x400 这个堆块泄露出 heap 和 libc 地址，然后通过计算偏移获得基址。

FSOP

我们可以通过 unsorted_bin_attack 将 _IO_list_all 指向 main_arena+0x58 ，但这块区域是我们不可控的，我们看一下 malloc_state 结构体源码:

(tips:bins[2*N - 2] 和 bins[2 * N - 1]分别对应链表头和链表尾指针)

bins[11] == small_bin[5] == small_bin_0x60 ，bins[0] == unsorted_bin，相差是 12*8 = 0x60。结合 _IO_FILE_plus 结构体如下图所示:

我们可以控制 old_top_chunk 的大小，把它 size 置为 0x61，并在其内部构建 fake_IO_FILE_plus_2 放进 small_bin[5]，那么fp->_chain 将会指向 fake_IO_FILE_2。此时 main_arena 如下图。

为了绕过如下检查:

我们构造的 fake_IO_FILE_plus 如下图:

检测到内存错误后的调用 _IO_OVERFLOW (fp, EOF)->_IO_OVERFLOW("/bin/sh\x00, EOF")->system("/bin/sh\x00")。

完整exp

glibc-2.24 后加入了针对 IO_FILE_plus 的 vtable 劫持的检测措施，glibc 会在调用虚函数之前首先检查 vtable 地址的是否合法。首先会验证 vtable 是否位于_IO_vtable 段中，如果满足条件就正常执行，否则会调用 _IO_vtable_check 做进一步检查。如果 vtable 是非法的，那么会引发 abort。

_IO_FILE 在使用标准 IO 库时会进行创建并负责维护一些相关信息，其中有一些域是表示调用 fwrite、fread 等函数时写入地址或读取地址的，如果可以控制这些数据就可以实现任意地址写或任意地址读。进程中包含了系统默认的三个文件流 stdin,stdout,stderr，因此这种方式可以不需要进程中存在文件操作，通过 scanf,printf 一样可以进行利用。

stdin 任意写

大致了解 fread 的执行流程后，还需要绕过以下检查:

即:

示例

使用 libc6_2.31-0ubuntu9.9_amd64 版本编译运行结果如下:

stdout 任意写

有如下源码:

将_IO_write_ptr 指向 write_start ，_IO_write_end 指向 write_end 即可实现在目标地址写入数据。

示例

使用 libc6_2.31-0ubuntu9.9_amd64 版本编译运行结果如下:

stdout 任意读

程序正确执行到 _IO_overflow 时，有如下源码：

即

示例

__start___libc_IO_vtables指向第一个 vtable 地址_IO_helper_jumps，而__stop___libc_IO_vtables指向最后一个vtable_IO_str_chk_jumps结束的地址。想将 vtable 覆盖成外部地址且仍然通过检查，可以有两种方式：

第一种方式不可控，因为 flag 的获取和比对是类似 canary 的方式，其对应的汇编代码如下：

第二种方式，理论上可行，但是如果我们可以找到存在往_dl_open_hook中写值的方法，完全利用该方法来进行更为简单的利用。

第三种方式， _IO_str_jumps 与 __IO_wstr_jumps 这两个 vtable 就位于 __stop___libc_IO_vtables 和 __start___libc_IO_vtables 之间，所以我们是可以利用他们来通过 IO_validate_vtable 的检测的，只需要将 *vtable 填成 _IO_str_jumps 或 _IO_wstr_jumps 地址即可。_IO_wstr_jumps与_IO_str_jumps功能基本一致，只是_IO_wstr_jumps是处理 wchar的，利用方式主要有针对 _IO_str_jumps 中的 _IO_str_finsh 函数和 _IO_str_overflow 两种。

一些下面用到的结构体定义

_IO_str_jumps 符号在 strip 后会丢失，定位其地址方法如下：

_IO_str_finish

下面是 _IO_str_finish 函数：

它使用了 _IO_FILE 结构体中的值当作函数地址来直接调用，如果修改 ((_IO_strfile *) fp)->_s._free_buffer 为 system 地址，然后修改 fp->_IO_buf_base 为 /bin/sh\x00 字符串地址，然后触发程序执行 _IO_str_finish 函数就可以得到 shell 。

_IO_str_overflow

即绕过条件为

直接将 vtable->fake_IO_str_jumps_vtable 即可，因为 _IO_str_overflow 也在 0x18 的位置。

其用法和_IO_str_jumps 相似，_IO_wstr_jumps与_IO_str_jumps功能基本一致，只是_IO_wstr_jumps是处理 wchar的。其定义如下：

_IO_wstr_overflow

_IO_wstr_finish

在 glibc-2.28 版本中，用操作堆的 malloc 函数和 free 函 数 替 换 原 来 在 _IO_str_fields 里 的 _allocate_buffer 和 _free_buffer 。 由 于 不 再 使 用 偏 移 ， 也 就 不 能 利 用 __libc_IO_vtables 上的 vtable 绕过检查，于是新的 FOSP 利用技术 就失效了。

开了 NX 和 Canary，题目 libc 为 2.24 版本。

由于程序开启了 FORTIFY 机制， 因此在程序编译时所有的 printf() 都被 __printf_chk() 替换掉了，它有如下限制：

先分配 size 大小的空间（不超过0x1000），然后在这里读入字符串，由于使用的是 gets() 函数，存在堆溢出漏洞。然后直接调用__printf_chk() 打印这个字符串，存在栈信息泄露漏洞。

前置脚本

泄露libc

通过溢出将 top_chunk 的 size 改成 fe1，然后利用申请 0x1000 > 0xfe1 大小的 chunk 将 old_top_chunk 放进 unsorted bin 中，并利用第二次的格式化字符串漏洞泄露 libc 地址。

house of orange

利用堆溢出漏洞构造如下 Heap 与 IO_FILE 结构:

我们需要利用 abort 调用 _IO_OVERFLOW 所以需要 fp->_mode为 0 且 fp->_IO_write_ptr>_fp->_IO_write_base。然后利用 _IO_str_overflow 函数所以需要绕过以下检查。

利用 house of orange 将 _IO_list_all 的 vtable 指向 _IO_str_jumps，然后利用 abort 调用 _IO_OVERFLOW->_IO_str_overflow 然后进入我们上面讲的调用流，最后调用 system("/bin/sh\x00")。

最后libc 的低 32 位地址为负时，攻击才会成功。

glibc >= 2.23

这种攻击方式主要是利用了printf的一个调用链，应用场景是只能分配较大 chunk 时(超过fastbin)，存在或可以构造出UAF漏洞。printf 函数通过检查 __printf_function_table 是否为空，来判断是否有自定义的格式化字符，若为 printf 类格式字符串函数，则会根据格式字符串的种类去执行 __printf_arginfo_table[spec] 处的函数指针。

我们可以利用这样一条调用链printf->vfprintf->printf_positional->__parse_one_specmb，通过篡改__printf_arginfo_table和__printf_function_table来进行攻击，可以看到当__printf_function_table非空，将会调用printf_positional函数

泄露 libc 地址。

修改 global_max_fast 为很大的值，可以 large bin attack/unsorted bin attack

将 __printf_function_table 或者 __printf_arginfo_table 覆盖为指向写有 one_gadget 的内存的指针。其中 one_gadget 在内存中的偏移对应与之后触发漏洞的 spec 。

如果是利用 __printf_function_table 触发漏洞需要让 __printf_arginfo_table 指向一块内存并且该内存对应 spec 偏移处设为 null ，否则会在 __parse_one_specmb 函数的 if 判断中造成不可预知的错误。

最后调用 printf 触发漏洞获取 shell 。

图解
对于 glibc-2.27 而言：

静态编译并且没有去除符号。

存在缓冲区漏洞，向 .bss 节的 name 变量写入内容，然后打印它。并且 flag 位于 .data 节，可以利用 __stack_chk_fail() 将其打印出来。

利用缓冲区溢出篡改 __printf_function_table 指向一个非零值，因为 %s 的 ascii 是 0x73，所以让 __printf_arginfo_table 指向 fake_arginfo_table[0x73*8] == __stack_chk_fail()，将 argv[0] 改为 flag 地址。

exp

glibc < 2.36

有如下调用链:

tips:通过large bin chunk的size中flag位修改,或者top chunk的inuse写0等方法可以触发assert

当我们触发 assert 断言时会调用 __malloc_assert，__malloc_assert 里有这样一条调用链：fflush->_IO_fflush

执行到 result = _IO_SYNC (fp) ? EOF : 0; 时，会调用 _IO_new_file_sync， _IO_file_jumps_ 可写。因此将 _IO_file_jumps_ 对应 _IO_new_file_sync 函数指针的位置覆盖为 one_gadget 就可以获取 shell 。

利用前提：

未开沙箱 poc

开了沙箱禁用 execve

对于禁用 execve 的程序需要借助 (setcontext+61) + rop 或 shellcode 进行 orw 。glibc 2.29之后 setcontext中的 gadget变成了以 rdx 索引，因此还要先通过 ROP控制 RDX的值。

tips:注意，内存中有不止一个 _IO_helper_jumps_ ，具体是哪一个要通过调试确定

调用 _IO_new_file_sync 时 rdx 指向的是 _IO_helper_jumps_ 结构，该结构同样可写。因此可以通过修改 _IO_helper_jumps_ 中的内容来给寄存器赋值。还需要设置 rsp 指向提前布置好的 rop 的起始位置，同时设置 rip 指向 ret 指令。最后劫持程序流实现 orw 。

总体利用思路如下:

poc

来自 _sky123_老师

glibc-2.36 的执行流

glibc-2.36 的 __malloc_assert 发生重大改变，直接通过系统调用不走 IO，该方法失效。

再来看一下 _IO_str_overflow 函数：

利用流程如下：

在 glibc-2.34 后 ptmalloc 取消了各种 hook，但依然可以用 house of pig 实现任意地址写任意值，借助其他手段完成权限获取，后面有时间会做补充。

House of Pig 是一个将 Tcache Statsh Unlink Attack 和 FSOP 结合的攻击，同时使用到了 Largebin Attack 进行辅助。主要适用于 libc 2.31 及以后的新版本 libc 并且程序中仅有 calloc 时。

利用条件为

没找到原 libc，这里使用如上 libc 。

一道 c++ 的 pwn 题。三只猪用户，一共五种操作，添加，查看，修改，删除，登录。最开始默认peppa（猪A）先操作，猪A的 id=1 ，Mummy （猪B）的 id=2，Daddy （猪C）的 id=3。

添加操作一共有三种，分别对应猪A，猪B，猪C。猪A可以遍历 0~19 的索引，并添加一个大小在 0x90~0x430 的 chunk，猪B 只能遍历 0~9 的索引，并添加大小在 0x90~0x450 的 chunk。对于猪C，则是 0~4 的索引和 0x90~0x440 的 chunk。猪A, 猪B分配的chunk大小只能一次比一次大或者本次与上一次相等，但猪C没有这个限制。另外，在猪C函数中如果添加 chunk 的索引为 4，则还可以再分配一个大小为0xE8的chunk并写入最大长度为0xE8的内容。 3只猪在add之后可以立即向新分配的chunk中写入内容，但不是chunk中任何位置都能写，chunk空间以48字节为大小分组。对于猪A，每一组48字节空间只能写前面16字节，对于猪B则是只能写中间16字节，对于猪C只能写后面16字节。在写入后，会设置两个标志位为0。

3只猪可以查看的索引范围和可以add的索引范围相同。而且查看时需要有一个标志位为0。这个标志位是add中设置的两个标志位中的第一个。本题限制view的次数最多为2次。

3只猪可以修改的索引范围和可以add的索引范围相同。而且修改时需要有一个标志位为0。这个标志位和view message的标志位相同。本题限制edit的次数最多为8次。

3只猪可以删除的索引范围和可以add的索引范围相同。删除后会将两个标志位置为1。

根据条件爆破密码。

需要知道每个角色的密码，才能通过对应密码 md5 的比较判断，但是这里判断用的 strcmp，且其中有个 md5 值中的包含 ‘\x00’ ，所以实际上会提前截断，而以 ‘\x3c\x44\x00’ 开头的 md5，对应的原值其实是有很多的，所以这里可以任意切换角色。

在检查函数通过之后，如果我们会更换用户，则会将原来用户分配的chunk复制到一个程序预先分配号的一块空间，然后将新用户的chunk以及标志位等从那一块空间中复制出来。

本题的漏洞就在于用户的分配上。由于新用户只是复制了第二个标志位，对于某个chunk的索引而言，如果原用户的两个对应标志位均为0，而新用户的两个标志位为1，则用户转换后，两个标志位分别为0和1。注意view message和edit message检查的都是第1个标志位是否为0，对于新用户而言，这个索引原本的chunk是已经被释放的，但这样一来我们就可以再一次访问这个chunk，这就产生了UAF。我们可以申请到在tcache保存大小范围的chunk，也可以申请到大于tcache大小的chunk，而且程序通过calloc 分配堆块会跨过 tcache，符合 house of pig 利用条件。关于新版本 largebin_attack 和 tcache_stashing_unlink_attack 请看前言提到的文章。

前置脚本

泄露地址并部署堆

tcache stashing unlink的堆环境要求有5个chunk位于同一个tcache bins中，同时有2个相同大小的chunk位于small bins，之后通过修改small bins中链首chunk的bk指针可以将任意地址链入到tcache。

这里先将 peppa(0) 放进 unsorted bin，之后将其切分，由于转换身份时存在 UAF 漏洞，可以以此泄露 libc 地址，不过要注意先将对应的 tcache 填满。切分后我们再次申请 0x160 大小的 chunk 将剩余部分放进 small bin 中已备 tcache stashing unlink attack 攻击。

同理也可以利用身份转换的 UAF 漏洞泄露堆地址，通过 tcache 的 fd 指针泄露堆地址，两次view的机会全部用完了，后面将不能使用view查看。我们这里add(0xb0)时将 unsorted bin 中的 chunk 切割成了 0xb0 大小。

第一次large bin attack

large bin attack 可以任意地址写堆地址，我们可以使得 __free_hook 周围变得可写。这种手法可以从前言的文章了解，这里不再细讲，我们把 large_bin_chunk.bk_nextsize -> (__free_hook - 0x30)，再次申请 0xf0 大小的 chunk 时会先把 unsorted_bin_chunk 放进 large bin ，再去 large bin 中找到合适的 chunk 进行切割。借此可以完成 large bin attack。

构造的结构如下：

攻击后如下：

第二次 large bin attack

第二次 large bin attack，我们的目标是将未来的假 _IO_FILE地址写到_IO_list_all中。上一次 large bin attack中使用的large bin是可以重用的，我们将bk_nextsize指针改到其他位置还能够再一次进行攻击。第二次large bin attack应该写的具体的堆地址应该根据堆环境进行确定，选择的偏移至关重要。为了方便起见，我们的伪造_IO_FILE结构体应该在daddy分配索引为4的chunk时附加送给我们的一个chunk中进行构造。向_IO_list_all中写入的是large bin chunk的地址，如果想要这里同时也指向假_IO_FILE指针，就需要计算好chunk的分配数量，在calloc(0xE8)时能够正好让这个chunk被拆分，这样就实现了此处可写。可以让bk_nextsize的值为_IO_list_all-0x20。

构造如下：

攻击后：

这里_IO_list_all已经指向了我们伪造的 fake_IO_FILE。

tcache stashing unlink attack

在第一次 large bin attack之后，我们将一个堆地址写到了__free_hook-10的位置，接下来就需要通过 tcache stashing unlink attack将这个地址用_IO_str_overflow函数中的malloc函数分配出来，然后利用 memcpy 将其改写为 system 地址，并传入 /bin/sh\x00 参数，通过 exit 函数触发即可。

构造的堆空间：

此时用 calloc 申请 0xA0 大小的堆块会跨过 tcache 从 small bin 获取， tcache 未满将会把 small bin 中的堆块先放进 tcache 中。

攻击后：

成功链接进入 tcache。

构造的 fake_IO_FILE:

_IO_buf_end - _IO_buf_base = 30，所以申请的大小刚好为 30*2+100=0xA0，会把 __free_hook 申请出来。

我们申请出来的用户空间在 0x...30，而 &__free_hook = 0x...48，我们将 old_buf == _IO_buf_base 指向这样的地址 b'/bin/sh\x00'+p64(system_addr)*2就可以把 system 地址写入到 __free_hook，并且把 _IO_buf_base ->'/bin/sh\x00' 作为其参数调用。

exp

glibc >= 2.23

在 ld.so 里，存在一个 _rtld_global 指针，指向 rtld_global 结构体，程序通过 exit 退出时，会调用 rtld_global 的结构体中的一系列函数来进行诸如恢复寄存器，清除缓冲区等操作。

其结构体定义如下：

我们看到里面有多个 _dl_ns 结构体，调试发现，该结构体存储着的实际就是 elf 各段的符号结构体。当调用到 _dl_fini 函数时，会执行每个 so 中注册的 fini 函数，其中主要是 fini_array 段的动态链接结构体指针，该结构体实际在 _dl_fini 中被使用。

只要伪造 rtld_global 结构体就可以使得 array 指向我们可控的数据区，从而伪造好一系列函数，进而劫持程序的流。可以触发 call 的有两个点，第一个点可以 call 到很多指针，是一个数组；另一个点就只有一个函数。剩下的工作就是根据代码绕过检测，调用到调用点，需要注意的是，有时候远程的 rtld_global 的偏移与本地不一样，需要爆破。house of banana便是利用large bin attack往 rtld_global 写入堆的地址，并事先在堆里伪造好rtld_global结构体，这样程序exit或者正常退出 main 函数时，便会执行到伪造的函数，此时若我们将函数伪造成one_gadget或者system 则可以 get shell。

利用思路：

试用场景：

需绕过的点：

劫持&(_rtld_global._dl_ns._ns_loaded->l_next->l_next->l_next) = fake。

maps 必须要有四个元素，所以我劫持的是第三个节点的 next 指针这样不会破环长度从而绕过下面的两个断言。劫持时只需在_rtld_global._dl_ns._ns_loaded->l_next->l_next->l_next处写入 fake 就行，这时可以使用 large bin attack。

为了能写入 maps[i] = l;，需要绕过 if (l == l->l_real)，所以fake+0x28 (offset is 0x28)处要写入 fake 自己的地址。

是个枚举体中成员 l_init_called，由于各版本有所差异，所以还是现查现用。

在 fake+0x110 写入的内容会直接控制 array，在 fake+0x120 写入的内容会控制i，只要把fake+0x120，fake+0x110 控制好就可以控制最后的((fini_t) array[i]) ();

需要在fake+0x110写入一个 ptr，且 ptr+0x8 处有 ptr2，ptr2 处写入的是最后要执行的函数地址，需要在fake+0x120写入一个ptr，且 ptr+0x8 处是i*8。例如fake+0x110写入fake+0x40，在fake+0x48写入fake+0x58，在fake+0x58写入 shell，在fake+0x120写入fake+0x48，在fake+0x50处写入 8。

glibc > 2.23。

在 vtable 段中存在一个 _IO_cookie_jumps：

_IO_cookie_file 有如下定义：

其中的函数定义如下：

可以看到上面代码的函数调用前都被PTR_DEMANGLE加密了，其定义如下：

这段宏定义的操作是将函数指针 ROR 循环右移 11 位然后与 fs:[0x30] 异或得到真正的函数地址。解密时首先异或 pointer_guard，然后循环左移 0x11 位。

fs:[0x28] 是 tls 上存储的 canary，根据 tcbhead_t 结构体的定义，fs[0x30] 是 pointer_guard ，用于对指针进行加密。我们可以先泄露堆地址和 libc 基地址，然后利用 large bin attack 在 tls 对应 pointer_guard 上写一个 chunk 地址，从而绕过指针保护。除此之外还需要让 _lock指向一块可写内存。

调用链如下：

利用条件：

[培训]内核驱动高级班，冲击BAT一流互联网大厂工作，每周日13:00-18:00直播授课