House of Pig 与 House of Pig ORW 利用技术详解<\/h1>

1. 技术概述<\/h2>
House of Pig 是一种结合了多种堆利用技术的攻击方法，主要利用 `_IO_str_overflow<\/code> 函数中的 malloc、memcpy 和 free 操作链，通过伪造 FILE 结构体实现任意代码执行。当系统调用被限制时，可以演变为 House of Pig ORW 技术实现绕过。<\/p>`

2. 核心利用点<\/h2>
2.1 _IO_str_overflow 利用<\/h3>
_IO_str_overflow<\/code> 函数中存在以下关键操作序列：<\/p>
old_blen =<\/span> _IO_blen(fp);
<\/span><\/span>new_size =<\/span> 2<\/span> *<\/span> old_blen +<\/span> 0x64<\/span>;
<\/span><\/span>new_buf =<\/span> malloc(new_size);
<\/span><\/span>memcpy(new_buf, old_buf, old_blen);
<\/span><\/span>free(old_buf);
<\/span><\/span><\/code><\/pre>通过精心构造的 FILE 结构体，可以控制：<\/p>

malloc 的大小和返回地址<\/li>
memcpy 的源地址和目标地址<\/li>
free 的参数<\/li>
<\/ol>
2.2 _IO_str_jumps 表<\/h3>
_IO_str_jumps<\/code> 是 GLIBC 中定义的一个跳转表，包含 _IO_str_overflow<\/code> 等函数的指针。通过将 FILE 结构体的 vtable 指向 _IO_str_jumps<\/code>，可以劫持程序执行流。<\/p>
3. 利用条件<\/h2>

能够泄露堆和 libc 地址<\/li>
能够进行 largebin attack<\/li>
能够伪造 FILE 结构体<\/li>
能够触发 exit 或 flush 操作<\/li>
<\/ol>
4. 完整利用流程<\/h2>
4.1 House of Pig 标准流程<\/h3>


准备阶段<\/strong>：<\/p>

布置 tcache 和 smallbin 中的 chunk<\/li>
使用 largebin attack 泄露 libc 和堆地址<\/li>
<\/ul>
<\/li>

largebin attack<\/strong>：<\/p>

第一次攻击：向 __free_hook-0x8<\/code> 写入堆地址<\/li>
第二次攻击：向 _IO_list_all<\/code> 写入堆地址<\/li>
<\/ul>
<\/li>

tcache stashing unlink attack<\/strong>：<\/p>

将 __free_hook-0x10<\/code> 链入 tcache<\/li>
通过修改 smallbin 的 bk 指针实现<\/li>
<\/ul>
<\/li>

伪造 FILE 结构体<\/strong>：<\/p>

设置 _IO_write_ptr > _IO_write_base<\/code><\/li>
设置 _IO_buf_base<\/code> 和 _IO_buf_end<\/code> 控制 malloc 大小<\/li>
vtable 指向 _IO_str_jumps<\/code><\/li>
<\/ul>
<\/li>

触发利用<\/strong>：<\/p>

通过 exit 或 flush 触发 _IO_str_overflow<\/code><\/li>
最终实现 system("\/bin\/sh")<\/code> 调用<\/li>
<\/ul>
<\/li>
<\/ol>
4.2 House of Pig ORW 流程<\/h3>
当 system 被禁用时，利用 _IO_str_overflow<\/code> 的特殊指令实现 ORW：<\/p>


利用指令<\/strong>：<\/p>

mov rdx,QWORD PTR [rdi+0x28]<\/code>：rdi 指向伪造的 FILE 结构体<\/li>
<\/ul>
<\/li>

具体步骤<\/strong>：<\/p>

劫持 stderr->_chain<\/code> 为堆地址 ck0<\/li>
劫持 global_max_fast<\/code> 或 tcache 管理结构为堆地址 ck1<\/li>
设置 tcache 使得 malloc 返回 __malloc_hook<\/code><\/li>
构造 FILE 结构体使 rdi+0x28<\/code> 指向伪造的 SROP frame<\/li>
通过 exit 触发两次 _IO_str_overflow<\/code>：

第一次设置 __malloc_hook<\/code> 为 setcontext+61<\/li>
第二次触发 SROP 执行 ORW<\/li>
<\/ul>
<\/li>
<\/ul>
<\/li>
<\/ol>
5. 关键数据结构构造<\/h2>
5.1 伪造的 FILE 结构体<\/h3>
fake_IO_FILE =<\/span> 2<\/span> *<\/span> p64(0<\/span>)  # _flags and _IO_read_ptr<\/span>
<\/span><\/span>fake_IO_FILE +=<\/span> p64(1<\/span>)      # _IO_write_base = 1<\/span>
<\/span><\/span>fake_IO_FILE +=<\/span> p64(0x1000<\/span>) # _IO_write_ptr = 0x1000<\/span>
<\/span><\/span>fake_IO_FILE +=<\/span> p64(0<\/span>)      # _IO_write_end = 0<\/span>
<\/span><\/span>fake_IO_FILE +=<\/span> p64(heap_base +<\/span> 0x148a0<\/span>) # _IO_buf_base<\/span>
<\/span><\/span>fake_IO_FILE +=<\/span> p64(heap_base +<\/span> 0x148b8<\/span>) # _IO_buf_end<\/span>
<\/span><\/span>fake_IO_FILE =<\/span> fake_IO_FILE.<\/span>ljust(0xb0<\/span>, b<\/span>'<\/span>\x00<\/span>'<\/span>)
<\/span><\/span>fake_IO_FILE +=<\/span> p64(0<\/span>)      # _mode = 0<\/span>
<\/span><\/span>fake_IO_FILE =<\/span> fake_IO_FILE.<\/span>ljust(0xc8<\/span>, b<\/span>'<\/span>\x00<\/span>'<\/span>)
<\/span><\/span>fake_IO_FILE +=<\/span> p64(IO_str_vtable) # vtable<\/span>
<\/span><\/span><\/code><\/pre>5.2 内存布局要求<\/h3>

_IO_write_ptr > _IO_write_base<\/code>：确保进入 _IO_str_overflow<\/code> 的利用路径<\/li>
_IO_buf_end - _IO_buf_base<\/code>：控制 malloc 的大小<\/li>
_IO_buf_base<\/code>：通常设置为包含 "\/bin\/sh" 的地址<\/li>
<\/ol>
6. 相关地址获取<\/h2>
6.1 关键符号地址<\/h3>
# libc 符号<\/span>
<\/span><\/span>libc_base =<\/span> leak_address -<\/span> 0x1ebfe0<\/span>
<\/span><\/span>IO_list_all =<\/span> libc_base +<\/span> libc.<\/span>sym['_IO_list_all'<\/span>]
<\/span><\/span>IO_str_vtable =<\/span> libc_base +<\/span> 0x1ED560<\/span>
<\/span><\/span>system_addr =<\/span> libc_base +<\/span> libc.<\/span>sym['system'<\/span>]
<\/span><\/span>free_hook =<\/span> libc_base +<\/span> libc.<\/span>sym['__free_hook'<\/span>]
<\/span><\/span>
<\/span><\/span># 堆地址<\/span>
<\/span><\/span>heap_base =<\/span> leak_address -<\/span> 0x13940<\/span>
<\/span><\/span><\/code><\/pre>6.2 偏移说明<\/h3>

_IO_str_jumps<\/code> 通常位于 libc 的 data 段，偏移固定<\/li>
_IO_list_all<\/code> 是全局变量，指向链表头<\/li>
__free_hook<\/code> 是最后 free 时调用的函数指针<\/li>
<\/ul>
7. 防御绕过技巧<\/h2>


检查绕过<\/strong>：<\/p>

largebin attack 需要绕过完整性检查<\/li>
tcache stashing 需要确保目标地址可写<\/li>
<\/ul>
<\/li>

限制绕过<\/strong>：<\/p>

当存在写入限制时，利用不同角色的部分写入能力组合完成利用<\/li>
使用 SROP 技术绕过系统调用限制<\/li>
<\/ul>
<\/li>

稳定性提升<\/strong>：<\/p>

在修改关键指针后修复相关结构<\/li>
确保各 bin 状态符合预期<\/li>
<\/ul>
<\/li>
<\/ol>
8. 实际应用示例<\/h2>
8.1 例题分析<\/h3>
题目特点：<\/p>

C++ 实现，堆管理结构存储在栈上<\/li>
不同角色有不同写入权限：

A：控制 fd\/bk<\/li>
B：控制 fd_nextsize\/bk_nextsize<\/li>
C：控制其他部分<\/li>
<\/ul>
<\/li>
通过 change role 时的拷贝不完全漏洞实现 UAF<\/li>
<\/ul>
8.2 利用脚本关键部分<\/h3>
# largebin attack 修改 __free_hook-8<\/span>
<\/span><\/span>Edit(8<\/span>, p64(0<\/span>) +<\/span> p64(free_hook-<\/span>0x28<\/span>) +<\/span> b<\/span>'<\/span>\n<\/span>'<\/span>)
<\/span><\/span>
<\/span><\/span># tcache stashing unlink attack<\/span>
<\/span><\/span>payload =<\/span> b<\/span>'A'<\/span>*<\/span>0x50<\/span> +<\/span> p64(heap_base+<\/span>0x12280<\/span>) +<\/span> p64(free_hook-<\/span>0x20<\/span>)
<\/span><\/span>Edit(8<\/span>, payload +<\/span> b<\/span>'<\/span>\n<\/span>'<\/span>)
<\/span><\/span>
<\/span><\/span># 伪造 FILE 结构体<\/span>
<\/span><\/span>fake_IO_FILE =<\/span> 2<\/span>*<\/span>p64(0<\/span>)
<\/span><\/span>fake_IO_FILE +=<\/span> p64(1<\/span>)  # _IO_write_base<\/span>
<\/span><\/span>fake_IO_FILE +=<\/span> p64(0x1000<\/span>)  # _IO_write_ptr<\/span>
<\/span><\/span>[...<\/span>]
<\/span><\/span><\/code><\/pre>9. 调试技巧<\/h2>


关键断点：<\/p>

_IO_str_overflow<\/code> 函数入口<\/li>
malloc\/memcpy\/free 调用处<\/li>
exit 函数调用处<\/li>
<\/ul>
<\/li>

内存检查：<\/p>

验证 FILE 结构体伪造是否正确<\/li>
检查各 bin 状态是否符合预期<\/li>
确认 hook 是否被正确覆盖<\/li>
<\/ul>
<\/li>

错误处理：<\/p>

修复被破坏的堆结构<\/li>
调整偏移计算<\/li>
验证指针有效性<\/li>
<\/ul>
<\/li>
<\/ol>
10. 扩展技术<\/h2>
10.1 其他 IO 函数利用<\/h3>
除了 _IO_str_overflow<\/code>，还可以研究：<\/p>

_IO_file_overflow<\/code><\/li>
_IO_wstr_overflow<\/code><\/li>
_IO_switch_to_get_mode<\/code><\/li>
<\/ul>
10.2 结合其他攻击技术<\/h3>


与 FSOP 结合<\/strong>：<\/p>

利用更广泛的 FILE 操作函数<\/li>
通过多个 FILE 结构体形成利用链<\/li>
<\/ul>
<\/li>

与堆风水结合<\/strong>：<\/p>

精确控制堆布局<\/li>
提高利用稳定性<\/li>
<\/ul>
<\/li>

与 SROP 结合<\/strong>：<\/p>

实现更复杂的利用链<\/li>
绕过更多保护机制<\/li>
<\/ul>
<\/li>
<\/ol>
11. 防护措施<\/h2>


检测措施<\/strong>：<\/p>

监控 _IO_list_all<\/code> 等关键全局变量<\/li>
检查 FILE 结构体的 vtable 指针<\/li>
<\/ul>
<\/li>

缓解措施<\/strong>：<\/p>

启用 vtable 验证<\/li>
随机化关键数据结构地址<\/li>
加强堆完整性检查<\/li>
<\/ul>
<\/li>

开发建议<\/strong>：<\/p>

避免使用不安全的 IO 操作<\/li>
及时更新 libc 版本<\/li>
实施严格的输入验证<\/li>
<\/ul>
<\/li>
<\/ol>
12. 总结<\/h2>
House of Pig 及其变种是高级堆利用技术的代表，结合了多种利用方法，展示了现代漏洞利用的复杂性。理解这些技术不仅有助于漏洞挖掘和利用开发，也能帮助设计更好的防护机制。掌握这些技术需要深入理解 glibc 的堆管理和 IO 子系统实现细节。<\/p>

House of Pig 与 House of Pig ORW 利用技术详解<\/h1>

2.2 _IO_str_jumps 表<\/h3> _IO_str_jumps<\/code> 是 GLIBC 中定义的一个跳转表，包含 _IO_str_overflow<\/code> 等函数的指针。通过将 FILE 结构体的 vtable 指向 _IO_str_jumps<\/code>，可以劫持程序执行流。<\/p>

4. 完整利用流程<\/h2>

5. 关键数据结构构造<\/h2>

6. 相关地址获取<\/h2>

8. 实际应用示例<\/h2>

10. 扩展技术<\/h2>

2.2 _IO_str_jumps 表<\/h3>
`_IO_str_jumps<\/code> 是 GLIBC 中定义的一个跳转表，包含 _IO_str_overflow<\/code> 等函数的指针。通过将 FILE 结构体的 vtable 指向 _IO_str_jumps<\/code>，可以劫持程序执行流。<\/p>`