[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`
标题：Chunk Extend and Overlapping
章节：Chunk Extend and Overlapping > HITCON Training lab13 > 基本信息
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本信息”展开。
- ``shell ➜ hitcontraning_lab13 git:(master) file heapcreator heapcreator: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=5e69111eca74cba2fb372dfcd3a59f93ca...

关键术语：
- 堆
- 栈
- pwn
- linux
- user-mode
- heap
- code:shell

代码/命令片段线索：
- shell: 9 行，首行 `➜ hitcontraning_lab13 git:(master) file heapcreator`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

基本信息

Chunk Extend and Overlapping
HITCON Training lab13
基本信息

Chunk Extend and Overlapping


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md` 中的章节「关闭」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md`
标题：用户代码不可执行
章节：用户代码不可执行 > x86 - SMEP - Supervisor Mode Execution Protection > 开启与关闭 > 关闭
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 在 /etc/default/grub 的如下两行中添加 nosmep `` GRUB_CMDLINE_LINUX_DEFAULT="quiet" GRUB_CMDLINE_LINUX="initrd=/install/initrd.gz" ` 然后运行 update-grub 并且重启系统就可以关闭 smep。
- 如果是使用 qemu 启动的内核，我们可以在 -append 选项中添加 nosmep` 来关闭 SMEP。

关键术语：
- pwn
- linux
- kernel-mode
- defense

代码/命令片段线索：
- plain: 2 行，首行 `GRUB_CMDLINE_LINUX_DEFAULT="quiet"`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

关闭

x86 - SMEP - Supervisor Mode Execution Protection

用户代码不可执行


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md` 中的章节「基本结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md`
标题：内核堆概述
章节：内核堆概述 > slab allocator > 基本结构
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本结构”展开。
- > 一个 object 可以理解为用户态 glibc 中的 chunk，不过 object 并不像 chunk 那样需要有一个 header，因为 page 结构体与物理内存间存在线性对应关系，我们可以直接通过 object 地址找到其对应的 page 结构体。
- slub 版本的 allocator 为现在绝大多数 Linux kernel 所装配的版本，因此本篇文章主要叙述的也是 slub allocator，其基本结构如下图所示： [图片: image.png;
- kmem_cache 为一个基本的 allocator 组件，其用于分配某个特定大小（某种特定用途）的对象，所有的 kmem\_cache 构成一个双向链表，并存在两个对应的结构体数组 kmalloc_caches 与 kmalloc_dma_caches。
- 一个 kmem_cache 主要由两个模块组成： - kmem_cache_cpu：这是一个percpu 变量（即每个核心上都独立保留有一个副本，原理是以 gs 寄存器作为 percpu 段的基址进行寻址），用以表示当前核心正在使用的 slub，因此当前 CPU 在从 kmem\_cache\_cpu 上取 object 时不需要加锁，从而极大地提高了性能 - kmem_cache_node：可以理解为当前 kmem_cache 的 slub 集散中心，其中存放着两个 slub 链表： - partial：该...
- 文件: figure/slub_allocator.png] 我们将 slub allocator 每次向 buddy system 请求得来的单张/多张内存页称之为一个 slub，其被分割为多个同等大小对象（object），每个 object 作为一个被分配实体，在 slub 的第一张内存页对应的 page 结构体上的 freelist 成员指向该张内存页上的第一个空闲对象，一个 slub 上的所有空闲对象组成一个以 NULL 结尾的单向链表。

关键术语：
- 堆
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

基本结构

堆 漏洞利用 pwn linux kernel-mode exploitation

内核堆概述


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「now, we are on the new stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：now, we are on the new stack
路径分类：pwn / pwn/linux/user-mode
分块：1/2

核心知识点：
- 本节主题围绕“now, we are on the new stack”展开。
- io.send(p64(0x600B30)) # fake dynstr location io.send(dynstr) # fake dynstr io.send("/bin/sh\x00") io.interactive() `` 直接运行，发现不行，经过调试发现程序在 0x7f2512db3e69 处崩了。

关键术语：
- 边界/溢出
- 堆
- 栈
- ROP/JOP
- AI安全
- pwn
- linux
- user-mode
- stackoverflow

代码/命令片段线索：
- plain: 1 行，首行 `直接运行，发现不行，经过调试发现程序在 0x7f2512db3e69 处崩了。`
- plain: 1 行，首行 `经过逐步调试发现，在 `_dl_runtime_resolve` 会在栈中保存大量的数据`
- plain: 1 行，首行 `其中 qword_227808 处的值为0x0000000000000380。`
- plain: 1 行，首行 `当执行完下面的指令后`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

now, we are on the new stack

边界/溢出 堆 栈 ROP/JOP AI安全 pwn linux user-mode stackoverflow

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/browser/chrome/js-engine/mutable-heap-numbers.md` 中的章节「Mutable Heap Numbers」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/browser/chrome/js-engine/mutable-heap-numbers.md`
标题：Mutable Heap Numbers
章节：Mutable Heap Numbers
路径分类：pwn / pwn/browser/chrome
分块：1/1

核心知识点：
- 本节主题围绕“Mutable Heap Numbers”展开。
- Floating-point arthmetic ：虽然 Math.random 全程使用整型操作，但 seed 存放在一个通用的 HeapNumber 当中，从而导致编译器生成较慢的浮点数操作指令，以及在编译器已知这可能是一个 32 位整型的情况下仍会需要潜在的 64 位浮点到 32 位整型的转换以及精度损失检查。
- Mutable heap Int32 ：V8 团队增强了 script context slot 类型以追踪一个数字值是否在 Int32 的范围内，若是则 HeapNumber 将其存放为一个纯 Int32 ，若需要扩展为 double 则不会需要重分配 HeapNumber 的空间；
- 最终，对于 Math.random 的优化结果如下： - No allocation / fast in-place updates ：seed 的更新不需要重复分配新的堆对象。
- 堆数量不可变 机制是 2025 年 V8 团队公开的优化机制，其思路来源于于 async-fs 这一 JS 文件系统实现在 Math.random 上的运行瓶颈，例如对于下面的这样一段代码： ``javascript let seed;
- 相应地，大于 31 位的数据都会存放在堆上，由 ScriptContext 的 Slot 存储指向这些对象的指针，例如对于简单的数值类型据而言会使用一个 HeapNumber 对象存放，对于复杂对象则是 JSObject 结构体一类的。

关键术语：
- 堆
- pwn
- browser
- chrome
- js-engine
- code:javascript

代码/命令片段线索：
- javascript: 12 行，首行 `let seed;`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Mutable Heap Numbers

堆 pwn browser chrome js-engine code:javascript

Mutable Heap Numbers


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「申请内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`
标题：申请内存块
章节：define DEFAULT_TOP_PAD 131072 > 申请内存
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“申请内存”展开。
- ``c / Don't try to call MORECORE if argument is so big as to appear negative.
- Note that since mmap takes size_t arg, it may succeed below even if we cannot call MORECORE. / if (size > 0) { brk = (char *)(MORECORE(size));
- LIBC_PROBE(memory_sbrk_more, 2, brk, size);

关键术语：
- 堆
- pwn
- linux
- user-mode
- heap
- code:c

代码/命令片段线索：
- c: 9 行，首行 `/*`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

申请内存

申请内存块


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md` 中的章节「（已过时）UAF 使用同样堆块」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md`
标题：Change Self
章节：Change Self > 直接改 cred > 间接定位 > （已过时）UAF 使用同样堆块
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“（已过时）UAF 使用同样堆块”展开。
- 如果我们在进程初始化时能控制 cred 结构体的位置，并且我们可以在初始化后修改该部分的内容，那么我们就可以很容易地达到提权的目的。

关键术语：
- UAF
- 堆
- AI安全
- pwn
- linux
- kernel-mode
- aim
- code:c

代码/命令片段线索：
- c: 6 行，首行 `void __init cred_init(void)`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

（已过时）UAF 使用同样堆块

Change Self
直接改 cred
间接定位
（已过时）UAF 使用同样堆块

UAF 堆 AI安全 pwn linux kernel-mode aim code:c

Change Self


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「CTF kernel pwn 相关」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`
标题：基础知识
章节：基础知识 > CTF kernel pwn 相关
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“CTF kernel pwn 相关”展开。
- 1. boot.sh: 一个用于启动 kernel 的 shell 的脚本，多用 qemu，保护措施与 qemu 不同的启动参数有关 2. bzImage: compressed kernel binary 3. rootfs.cpio: 文件系统映像
- ``bash CISCN2017_babydriver [master●] ls babydriver.tar CISCN2017_babydriver [master●] x babydriver.tar boot.sh bzImage rootfs.cpio CISCN2017_babydriver [master●] ls babydriver.tar boot.sh bzImage rootfs.cpio CISCN2017_babydriver [master●] file bzImage bzIm...
- - -initrd rootfs.cpio，使用 rootfs.cpio 作为内核启动的文件系统 - -kernel bzImage，使用 bzImage 作为 kernel 映像 - -cpu kvm64,+smep，设置 CPU 的安全选项，这里开启了 smep - -m 64M，设置虚拟 RAM 为 64M，默认为 128M

关键术语：
- AI安全
- pwn
- linux
- kernel-mode
- basic-knowledge.md
- code:bash

代码/命令片段线索：
- bash: 24 行，首行 `CISCN2017_babydriver [master●] ls`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

CTF kernel pwn 相关

AI安全 pwn linux kernel-mode basic-knowledge.md code:bash

基础知识


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「题目分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`
标题：Heap Spray
章节：Heap Spray > 例题：RWCTF2023体验赛 - Digging into kernel 3 > 题目分析
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“题目分析”展开。
- ` 经过笔者测试，出题人手动关闭了如下默认开启的保护（出题人为了降低题目难度，可能关的更多，笔者只测了这几个）： - 关闭了 CONFIG_MEMCG_KMEM，这使得GFP_KERNEL 与 GFP_KERNEL_ACCOUNT 会从同样的 kmalloc-xx 中进行分配 - 关闭了 CONFIG_RANDOMIZE_KSTACK_OFFSET，这使得固定函数调用到内核栈底的偏移值是不变的 - 关闭了 SLAB_FREELIST_HARDENED`，这使得 freelist 几乎没有任何保护，我们可以轻易...
- 0xC0DECAFE：释放一个之前分配的 object ，存在 UAF。
- 文件: figure/rwctf2023kernel.png] 我们需要传入如下结构体： `c struct node { uint32_t idx;
- 按惯例查看启动脚本，发现开启了 SMEP、SMAP、KASLR、KPTI： ``bash #!

关键术语：
- UAF
- 堆
- 栈
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation
- code:bash
- code:c

代码/命令片段线索：
- bash: 13 行，首行 `#!/bin/sh`
- c: 5 行，首行 `struct node {`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

题目分析

Heap Spray
例题：RWCTF2023体验赛 - Digging into kernel 3
题目分析

UAF 堆 栈 漏洞利用 pwn linux kernel-mode exploitation code:bash code:c

Heap Spray


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Page-level UAF」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`
标题：Page-level UAF
章节：Page-level UAF
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- Page-level UAF 同样是针对 buddy system 的利用手法，这种攻击手法主要指的是对内存页本身/内存页结构体 page 的释放后利用，例如： - 我们可以通过内存页重分配的方式将 UAF page 分配为指定 kmem_cache 的 slub pages ，从而实现无需任何限制的跨 kmem_cache 的 UAF 利用。
- 我们可以通过内存页重分配的方式将 UAF page 分配为指定进程的页表，从而实现 任意内存映射攻击。
- 我们可以通过 slab objects 的全部释放导致的 slab free 后对实现 page 上数据的 UAF，从而 将对内核对象的 UAF 读写转换为对 page 的 UAF 读写 。
- ...... 作为近几年新出现的利用手法，page-level UAF 还有更多值得我们去探索的地方。
- > 注：我们不使用 某“团伙”重新命名的 “PageJack” 这个叫法，仅 CTF-Wiki 页面的发布时间便至少早于 BlackHat 2024 USA 一年多（更早时候便应当在一些小圈子里已有传播）。
- 对一个至少一年多前就公开的旧事物，在一年多后承认并使用来自非原创作者的命名无疑是荒谬的。

关键术语：
- UAF
- 堆
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Page-level UAF

UAF 堆 漏洞利用 pwn linux kernel-mode exploitation

Page-level UAF


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md` 中的章节「Attack SMEP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md`
标题：用户代码不可执行
章节：用户代码不可执行 > x86 - SMEP - Supervisor Mode Execution Protection > Attack SMEP
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Attack SMEP”展开。
- 内核中修改 cr4 的代码最终会调用到 native_write_cr4，当我们能够劫持控制流后，我们可以执行内核中的 gadget 来修改 CR4。
- 把 CR4 寄存器中的第 20 位置为 0 后，我们就可以执行用户态的代码。
- 一般而言，我们会使用 0x6f0 来设置 CR4，这样 SMAP 和 SMEP 都会被关闭。
- 从另外一个维度来看，内核中存在固定的修改 cr4 的代码，比如在 refresh_pce 函数、 set_tsc_mode 等函数里都有。

关键术语：
- 漏洞利用
- pwn
- linux
- kernel-mode
- defense

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Attack SMEP

用户代码不可执行


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「Small Bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`
标题：堆相关数据结构
章节：define INTERNAL_SIZE_T size_t > bin > Small Bin
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“Small Bin”展开。
- 每个链表都有链表头结点，这样可以方便对于链表内部结点的管理。
- #define smallbin_index(sz) \ ((SMALLBIN_WIDTH == 16 ?
- (((unsigned) (sz)) >> 4) \ : (((unsigned) (sz)) >> 3)) + \ SMALLBIN_CORRECTION) ` 或许，大家会很疑惑，那 fastbin 与 small bin 中 chunk 的大小会有很大一部分重合啊，那 small bin 中对应大小的 bin 是不是就没有什么作用啊？
- 其实不然，fast bin 中的 chunk` 是有可能被放到 small bin 中去的，我们在后面分析具体的源代码时会有深刻的体会。
- 比如对于 32 位系统来说，下标 2 对应的双向链表中存储的 chunk 大小为均为 16 字节。

关键术语：
- 堆
- pwn
- linux
- user-mode
- heap
- code:c++

代码/命令片段线索：
- c++: 13 行，首行 `#define NSMALLBINS 64`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Small Bin

define INTERNAL_SIZE_T size_t
bin
Small Bin

堆相关数据结构


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md` 中的章节「fastbin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md`
标题：堆中的检查
章节：堆中的检查 > __int_free > fastbin
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- = idx | invalid fastbin entry (free) |

关键术语：
- 堆
- pwn
- linux
- user-mode
- heap

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

fastbin

堆中的检查


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「漏洞确定」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`
标题：Unsorted Bin Attack
章节：in order not to merge into top chunk > 2016 0CTF zerostorage-待完成 > 漏洞确定
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“漏洞确定”展开。
- 通过这么简单的分析，我们可以 基本确定漏洞主要就是集中在insert操作与merge操作中，尤其是当我们merge两个较小size的storage时，会出现一些问题。
- 而且需要注意的是，我们还是可以去修改merge后的B的内容的，所以这其实就是个Use After Free。
- 但是，我们之前刚刚把A对应的内存释放掉，而A由于不在fast bin范围内，所以只会被放到unsorted bin中（而且此时只有一个），所以此时A的fd和bk都存放的是unsorted bin的一个基地址。
- 如果我们在merge之前曾经删除过一个storage C，那么在我们merge A后，A就会插在unsorted bin的双向链表的首部，所以其fd则是C对应的地址，bk则是unsorted bin的一个基地址。
- 我们来具体分析一下，如果我们在insert过程中插入较小的size（比如8）的storage A，那么，当我们进行merge时，假设我们选择merge的两个storage 都为A，那么此时程序会直接把就会直接把A的内容再添加到A的原有内容的后面，然后接着就会把A对应的存储数据部分的内存free掉，但是这并没有什么作用，因为A存储内容的地址被赋给了另外一个storage，当再访问merge 后的 storage B部分的内容时，由于B的存储数据部分的地址其实就是A对应的存储数据的地址，所以打印的就是A的数据部分...

关键术语：
- UAF
- 堆
- 漏洞利用
- pwn
- linux
- user-mode
- heap

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

漏洞确定

in order not to merge into top chunk
2016 0CTF zerostorage-待完成
漏洞确定

Unsorted Bin Attack


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「context.log_level="debug"」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：context.log_level="debug"
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“context.log_level="debug"”展开。
- \n') gdb.attach(io) fake_linkmap_addr = bss_addr+0x100

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- stackoverflow

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

context.log_level="debug"

边界/溢出 栈 ROP/JOP AI安全 漏洞利用 pwn linux user-mode stackoverflow

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「Page-level Heap Fengshui」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`
标题：Cross-Cache Overflow & Page-level Heap Fengshui
章节：Cross-Cache Overflow & Page-level Heap Fengshui > Page-level Heap Fengshui
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Page-level Heap Fengshui”展开。
- 顾名思义，页级堆风水即以内存页为粒度的内存排布方式，而内核内存页的排布对我们来说不仅未知且信息量巨大，因此这种利用手法实际上是让我们手工构造一个新的已知的页级粒度内存页排布。
- 释放其中一份内存页，在 vulnerable kmem_cache 上堆喷，让其取走这份内存页。
- 释放另一份内存页，在 victim kmem_cache 上堆喷，让其取走这份内存页。
- 此时我们便有可能溢出到其他的内核结构体上，从而完成 cross-cache overflow
- 文件: figure/slub-new-page.png] 接下来让我们重新审视 buddy system ，其基本原理就是以 2 的 order 次幂张内存页作为分配粒度，相同 order 间空闲页面构成双向链表，当低阶 order 的页面不够用时便会从高阶 order 取一份连续内存页拆成两半，其中一半挂回当前请求 order 链表，另一半返还给上层调用者；

关键术语：
- 边界/溢出
- 堆
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Page-level Heap Fengshui

Cross-Cache Overflow & Page-level Heap Fengshui

边界/溢出 堆 漏洞利用 pwn linux kernel-mode exploitation


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md` 中的章节「second largebin atk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md`
标题：House of Pig
章节：second largebin atk
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“second largebin atk”展开。
- change_rol(3) add_message(0x330,'pass\n' (0x430 // 48)) # 3 add_message(0x430,'pass\n' (0x430 // 48)) # 4
- fake_IO_FILE = '' fake_IO_FILE += 2 p64(0) fake_IO_FILE += p64(1) # _IO_write_base fake_IO_FILE += p64(0xFFFFFFFFFFFFFFFF) # _IO_write_ptr fake_IO_FILE += p64(0) # _IO_write_end fake_IO_FILE += p64(heap_base + 0x13E20) # old_buf, _IO_buf_base fake_IO_FILE +...

关键术语：
- 堆
- 漏洞利用
- pwn
- linux
- user-mode
- heap

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

second largebin atk

House of Pig


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「_例题：西湖论剑2021线上初赛 - easykernel_」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`
标题：利用 pt\_regs 构造通用内核 ROP
章节：利用 pt\_regs 构造通用内核 ROP > _例题：西湖论剑2021线上初赛 - easykernel_
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“_例题：西湖论剑2021线上初赛 - easykernel_”展开。
- 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/XHLJ2021-easykernel](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/XHLJ2021-easykernel) 下载。

关键术语：
- ROP/JOP
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

_例题：西湖论剑2021线上初赛 - easykernel_

利用 pt\_regs 构造通用内核 ROP
_例题：西湖论剑2021线上初赛 - easykernel_

ROP/JOP 漏洞利用 pwn linux kernel-mode exploitation

利用 pt\_regs 构造通用内核 ROP


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「arena 数量」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`
标题：堆相关数据结构
章节：define INTERNAL_SIZE_T size_t > 宏观结构 > arena > arena 数量
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“arena 数量”展开。
- 对于不同系统，arena数量的约束如下 ``text For 32 bit systems: Number of arena = 2 number of cores.
- For 64 bit systems: Number of arena = 8 number of cores.
- `` 显然，不是每一个线程都会有对应的 arena。
- 此外，因为每个系统的核数是有限的，当线程数大于核数的二倍（超线程技术）时，就必然有线程处于等待状态，所以没有必要为每个线程分配一个 arena。
- 至于为什么64位系统，要那么设置，我也没有想明白。

关键术语：
- 堆
- pwn
- linux
- user-mode
- heap
- code:text

代码/命令片段线索：
- text: 4 行，首行 `For 32 bit systems:`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

arena 数量

define INTERNAL_SIZE_T size_t
宏观结构
arena
arena 数量

堆相关数据结构


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「在远程题目环境中进行利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`
标题：基础知识
章节：基础知识 > CTF kernel pwn 相关 > 在远程题目环境中进行利用
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“在远程题目环境中进行利用”展开。
- 我们可以使用 musl-C、uclibc 等库来大幅降低可执行文件的大小，对于时间比较充足的题目也可以使用纯汇编来编写 exp。

关键术语：
- 漏洞利用
- pwn
- linux
- kernel-mode
- basic-knowledge.md
- code:python

代码/命令片段线索：
- python: 19 行，首行 `from pwn import *`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

在远程题目环境中进行利用

基础知识
CTF kernel pwn 相关
在远程题目环境中进行利用

漏洞利用 pwn linux kernel-mode basic-knowledge.md code:python

基础知识


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md` 中的章节「概括」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md`
标题：House of Pig
章节：House of Pig > 概括
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“概括”展开。
- House of Pig 是一个将 Tcache Stash Unlink+ Attack 和 FSOP 结合的攻击，同时使用到了 Largebin Attack 进行辅助。
- 利用条件为 存在 UAF 能执行abort流程或程序显式调用 exit 或程序能通过主函数返回。
- 主要利用的函数为 _IO_str_overflow，可以参考 glibc 2.24下 IO_FILE 的利用。
- 利用流程为 1. 进行一个 Tcache Stash Unlink+ 攻击，把地址 __free_hook - 0x10 写入 tcache_pthread_struct。
- 由于该攻击要求 __free_hook - 0x8 处存储一个指向可写内存的指针，所以在此之前需要进行一次 large bin attack。

关键术语：
- UAF
- 边界/溢出
- 堆
- 漏洞利用
- pwn
- linux
- user-mode
- heap

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

概括

UAF 边界/溢出 堆 漏洞利用 pwn linux user-mode heap

House of Pig


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「exploit」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`
标题：堆中的 Off-By-One
章节：堆中的 Off-By-One > 实例 1: Asis CTF 2016 b00ks > 利用 > exploit
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“exploit”展开。
- ```python from pwn import * context.log_level="info"
- binary = ELF("b00ks") libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") io = process("./b00ks")
- def createbook(name_size, name, des_size, des): io.readuntil("> ") io.sendline("1") io.readuntil(": ") io.sendline(str(name_size)) io.readuntil(": ") io.sendline(name) io.readuntil(": ") io.sendline(str(des_size)) io.readuntil(": ") io.sendline(des)
- def printbook(id): io.readuntil("> ") io.sendline("4") io.readuntil(": ") for i in range(id): book_id = int(io.readline()[:-1]) io.readuntil(": ") book_name = io.readline()[:-1] io.readuntil(": ") book_des = io.readline()[:-1] io.readuntil(": ") book_author...
- def createname(name): io.readuntil("name: ") io.sendline(name)

关键术语：
- 堆
- 漏洞利用
- pwn
- linux
- user-mode
- heap
- code:python

代码/命令片段线索：
- python: 73 行，首行 `from pwn import *`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

exploit

堆中的 Off-By-One
实例 1: Asis CTF 2016 b00ks
利用
exploit

堆 漏洞利用 pwn linux user-mode heap code:python

堆中的 Off-By-One


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「send resolve data」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：send resolve data
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“send resolve data”展开。
- io.send(resolve_data) rop = ROP("./main_partial_relro_64") rop.raw(offset'a') sh = "/bin/sh\x00" bin_sh_addr = store_addr+len(resolve_data) rop.raw(csu(0, 1 ,elf.got['read'],0,bin_sh_addr,len(sh))) rop.raw(vuln_addr) rop.raw("a"(256-len(rop.chain()))) io.se...

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- pwn
- linux
- user-mode
- stackoverflow

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

send resolve data

边界/溢出 栈 ROP/JOP AI安全 pwn linux user-mode stackoverflow

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md` 中的章节「add_note」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md`
标题：Use After Free
章节：Use After Free > 例子 > 功能分析 > add_note
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“add_note”展开。
- 根据程序，我们可以看出程序最多可以添加5个note。
- note的结构体定义如下: ``c struct note { void (printnote)();
- ` add_note 函数代码如下: `c++ unsigned int add_note() { note *v0;
- // [esp+1Ch] [ebp-Ch] v5 = __readgsdword(0x14u);
- notelist[i] ) { notelist[i] = malloc(8u);

关键术语：
- UAF
- 堆
- pwn
- linux
- user-mode
- heap
- code:c
- code:c++

代码/命令片段线索：
- c: 4 行，首行 `struct note {`
- c++: 45 行，首行 `unsigned int add_note()`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

add_note

UAF 堆 pwn linux user-mode heap code:c code:c++

Use After Free


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md` 中的章节「-- coding: utf-8 --」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md`
标题：Use After Free
章节：-- coding: utf-8 --
路径分类：pwn / pwn/linux/user-mode
分块：1/3

核心知识点：
- 本节主题围绕“-- coding: utf-8 --”展开。
- def addnote(size, content): r.recvuntil(":") r.sendline("1") r.recvuntil(":") r.sendline(str(size)) r.recvuntil(":") r.sendline(content)
- def delnote(idx): r.recvuntil(":") r.sendline("2") r.recvuntil(":") r.sendline(str(idx))
- def printnote(idx): r.recvuntil(":") r.sendline("3") r.recvuntil(":") r.sendline(str(idx))
- addnote(32, "aaaa") # add note 0 addnote(32, "ddaa") # add note 1
- delnote(0) # delete note 0 delnote(1) # delete note 1

关键术语：
- UAF
- 边界/溢出
- 堆
- 栈
- AI安全
- pwn
- linux
- user-mode
- heap

代码/命令片段线索：
- plain: 2 行，首行 `我们可以具体看一下执行的流程，首先先下断点`
- plain: 1 行，首行 `**两处free下断点**`
- plain: 1 行，首行 `然后继续执行程序，可以看出申请note0时，所申请到的内存块地址为0x0804b008。（eax存储函数返回值）`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

-- coding: utf-8 --

UAF 边界/溢出 堆 栈 AI安全 pwn linux user-mode heap

Use After Free


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stack privot to bss segment, set esp = base_stage」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：stack privot to bss segment, set esp = base_stage
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“stack privot to bss segment, set esp = base_stage”展开。
- stack_size = 0x800 # new stack size is 0x800 base_stage = bss_addr + stack_size rop.raw('a' * offset) # padding rop.read(0, base_stage, 100) # read 100 byte to base_stage rop.migrate(base_stage) r.sendline(rop.chain())

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- pwn
- linux
- user-mode
- stackoverflow

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

stack privot to bss segment, set esp = base_stage

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location”展开。
- rop = ROP("./main_partial_relro_64") offset = 112+8 rop.raw(offset'a') resolve_data, resolve_call = ret2dlresolve_x64(elf, store_addr, "system",elf.got["write"]) rop.raw(csu(0, 1 ,elf.got['read'],0,store_addr,len(resolve_data))) rop.raw(vuln_addr) rop.raw("...

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- pwn
- linux
- user-mode
- stackoverflow

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「简单检查 chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`
标题：申请内存块
章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > 寻找较大 chunk > 简单检查 chunk
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“简单检查 chunk”展开。
- It is likely to be non-empty / // 获取对应的bin victim = last(bin);
- / If a false alarm (empty bin), clear the bit. / // 如果victim=bin，那么我们就将map对应的位清0，然后获取下一个bin // 这种情况发生的概率应该很小。
- if (victim == bin) { av->binmap[ block ] = map &= ~bit;
- / Write through / bin = next_bin(bin);

关键术语：
- 堆
- pwn
- linux
- user-mode
- heap
- code:c

代码/命令片段线索：
- c: 11 行，首行 `/* Inspect the bin. It is likely to be non-empty */`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

简单检查 chunk

申请内存块
_int_malloc
大循环-遍历 unsorted bin
寻找较大 chunk
简单检查 chunk

申请内存块


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/browser/chrome/introduction.md` 中的章节「Reference」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/browser/chrome/introduction.md`
标题：Chromium
章节：Chromium > Reference
路径分类：pwn / pwn/browser/chrome
分块：1/1

核心知识点：
- 本节主题围绕“Reference”展开。
- https://arttnba3.cn What Are Rendering Engines: An In-Depth Guide RenderingNG deep-dive: BlinkNG How Does the Browser Render HTML?

关键术语：
- pwn
- browser
- chrome
- introduction.md

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Reference

Chromium


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md` 中的章节「内核堆概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md`
标题：内核堆概述
章节：内核堆概述
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“内核堆概述”展开。
- 类似于用户态进程中的堆（heap），内核也有着自己的一套动态内存管理机制，为了方便这里我们同样将内核中动态分配的内存称为“堆”。
- Linux kernel 将内存分为 页→区→节点 三级结构，主要有两个内存管理器—— buddy system 与 slab allocator，前者负责以内存页为粒度管理所有可用的物理内存，后者则向前者请求内存页并划分为多个较小的对象（object）以进行细粒度的内存管理。

关键术语：
- 堆
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

内核堆概述

内核堆概述


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「分配chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:19] > 堆布局 > 分配chunk
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“分配chunk”展开。
- ``python additem(0x40, b"a"8) # chunk0 - 存放 fake chunk 的容器 additem(0x80, b"b"8) # chunk1 - 将被 free 触发 unlink additem(0x40, b"c"*8) # chunk2 - 隔离层，防止合并到 top chunk ` 此时内存布局如下： `text 低地址 高地址 [chunk0: 0x50] [chunk1: 0x90] [chunk2: 0x50] [top chunk] ``

关键术语：
- 堆
- pwn
- linux
- user-mode
- heap
- code:python
- code:text

代码/命令片段线索：
- python: 3 行，首行 `additem(0x40, b"a"*8) # chunk0 - 存放 fake chunk 的容器`
- text: 2 行，首行 `低地址 高地址`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

分配chunk

zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:19]

堆 pwn linux user-mode heap code:python code:text

Unlink


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「二、Pool Memory（before 19H1）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`
标题：基础知识
章节：基础知识 > 内存管理 > 二、Pool Memory（before 19H1）
路径分类：pwn / pwn/windows/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“二、Pool Memory（before 19H1）”展开。
- Windows NT kernel 将页面按照不同的用途分为不同的“池”（Pool）来管理，并将这些页面划分为更细粒度的小对象供内核组件使用，池的总类一共有三种： - 非换页池（Non Paged Pool）：该池中的页面常驻物理内存中，不会被换出到磁盘 - 换页池（Paged Pool）：该池中的页面在内存紧张时可能被换出到磁盘 - 会话换页池（Session Paged Pool）：该池中的页面在内存紧张时可能被换出到磁盘，不同会话间存在隔离

关键术语：
- pwn
- windows
- kernel-mode
- basic-knowledge

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

二、Pool Memory（before 19H1）

基础知识


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md` 中的章节「内核堆利用与绑核」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md`
标题：简介
章节：简介 > 内核堆利用与绑核
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“内核堆利用与绑核”展开。
- slub allocator 会优先从当前核心的 kmem_cache_cpu 中进行内存分配，在多核架构下存在多个 kmem_cache_cpu ，由于进程调度算法会保持核心间的负载均衡，因此我们的 exp 进程可能会被在不同的核心上运行，这也就导致了利用过程中 kernel object 的分配有可能会来自不同的 kmem_cache_cpu ，这使得利用模型变得复杂，也降低了漏洞利用的成功率。
- > 比如说你在 core 0 上整了个 double free，准备下一步利用时 exp 跑到 core 1去了，那就很容易让人摸不着头脑 :（ 因此为了保证漏洞利用的稳定，我们需要将我们的进程绑定到特定的某个 CPU 核心上，这样 slub allocator 的模型对我们而言便简化成了单个 kmem_cache_node + 单个 kmem_cache_cpu ，我们也能更加方便地进行漏洞利用。
- 现笔者给出如下将 exp 进程绑定至指定核心的模板： ``c #include <sched.h> / to run the exp on the specific core only / void bind_cpu(int core) { cpu_set_t cpu_set;
- sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
- printf("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);

关键术语：
- 堆
- AI安全
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation
- code:c

代码/命令片段线索：
- c: 10 行，首行 `#include <sched.h>`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

内核堆利用与绑核

堆 AI安全 漏洞利用 pwn linux kernel-mode exploitation code:c

简介


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/windows/user-mode/stackoverflow/ret2dll.md` 中的章节「dll_base=0x7ffe71e00000」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/windows/user-mode/stackoverflow/ret2dll.md`
标题：ret2dll利用
章节：dll_base=0x7ffe71e00000
路径分类：pwn / pwn/windows/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“dll_base=0x7ffe71e00000”展开。
- print("base addr:",hex(dll_base)) cmd_addr = dll_base +cmd_dll system_addr=dll_base+sytem_dll print("start attck") payload = b'a' * (0x10 + 8) payload += p64(ret_addr) payload += p64(rcx_addr) payload += p64(cmd_addr) payload += p64(system_addr) p.sendline(...
- 文件: ./figure/ret2dll-1.png]

关键术语：
- 边界/溢出
- 栈
- 漏洞利用
- pwn
- windows
- user-mode
- stackoverflow

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

边界/溢出 栈 漏洞利用 pwn windows user-mode stackoverflow

ret2dll利用


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「泄露binary」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`
标题：例子
章节：例子 > 格式化字符串盲打 > 例子2-盲打劫持got > 泄露binary
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“泄露binary”展开。
- 一般来说有格式化字符串漏洞的盲打都是可以读入 '\x00' 字符的，，不然没法泄露怎么玩，，除此之后，输出必然是 '\x00' 截断的，这是因为格式化字符串漏洞利用的输出函数均是 '\x00' 截断的。
- 由于程序是64位，所以我们从 0x400000 处开始泄露。

关键术语：
- ROP/JOP
- 漏洞利用
- pwn
- linux
- user-mode
- fmtstr
- code:python

代码/命令片段线索：
- python: 40 行，首行 `##coding=utf8`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

泄露binary

例子 格式化字符串盲打 例子2-盲打劫持got 泄露binary

ROP/JOP 漏洞利用 pwn linux user-mode fmtstr code:python

例子


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md` 中的章节「Step.II - 利用 fork 绕过 hardened usercopy」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md`
标题：在内存中直接搜索 flag
章节：在内存中直接搜索 flag > 例题：RWCTF2023体验赛 - Digging into kernel 3 > 漏洞利用：ldt\_struct 直接读取 initramfs 内容 > Step.II - 利用 fork 绕过 hardened usercopy
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Step.II - 利用 fork 绕过 hardened usercopy”展开。
- //... } `` 该操作是完全处在内核中的操作，因此不会触发 hardened usercopy 的检查，我们只需要在父进程中设定好搜索的地址之后再开子进程来用 read\_ldt() 读取数据即可。
- 虽然在用户空间与内核空间之间的数据拷贝存在 hardened usercopy，但是在内核空间到内核空间的数据拷贝间并不存在类似的保护机制，因此我们可以通过一些手段绕过 hardended usercopy。
- 阅读 Linux 内核源码，我们不难观察到当进程调用 fork() 时，内核会通过 memcpy() 将父进程的 ldt->entries 上的内容拷贝给子进程： ``c / Called on fork from arch_dup_mmap().
- Just copy the current LDT state, the new task is not running, so nothing can be installed. / int ldt_dup_context(struct mm_struct old_mm, struct mm_struct mm) { //... memcpy(new_ldt->entries, old_mm->context.ldt->entries, new_ldt->nr_entries * LDT_ENTRY_SIZE);

关键术语：
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation
- code:c

代码/命令片段线索：
- c: 11 行，首行 `/*`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Step.II - 利用 fork 绕过 hardened usercopy

在内存中直接搜索 flag
例题：RWCTF2023体验赛 - Digging into kernel 3
漏洞利用：ldt\_struct 直接读取 initramfs 内容
Step.II - 利用 fork 绕过 hardened usercopy

漏洞利用 pwn linux kernel-mode exploitation code:c

在内存中直接搜索 flag


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`
标题：House Of Force
章节：House Of Force > HITCON training lab 11 > 利用
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 这里，程序在开始的时候申请了一块内存来存储两个函数指针，hello_message用于程序开始时使用，goodbye_message 用于在程序结束时使用，所以我们可以利用覆盖 goodbye_message 来控制程序执行流。
- 具体思路如下 1. 添加物品，利用堆溢出漏洞覆盖 top chunk 的大小为 -1，即 64 位最大值。
- 2. 利用 house of force 技巧，分配 chunk 至堆的基地址。
- 3. 覆盖 goodbye_message 为magic 函数地址来控制程序执行流 这里需要注意的是，在触发top chunk 转移到指定位置时，所使用的大小应该合适，以便于设置新的 top chunk 大小，从而可以绕过下一次分配top chunk 的检测。
- 由于程序中有个 magic 函数，所以我们的核心目的是覆盖某个指针为 magic 函数的指针。

关键术语：
- 边界/溢出
- 堆
- 漏洞利用
- pwn
- linux
- user-mode
- heap

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

利用

House Of Force
HITCON training lab 11
利用

House Of Force


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「下载编译 busybox」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`
标题：搭建内核运行环境
章节：搭建内核运行环境 > 使用 BusyBox 搭建基本的文件系统 > 下载编译 busybox
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“下载编译 busybox”展开。
- > 需要注意的是，在主机使用较新的内核版本的情况下，BusyBox 可能会无法完成编译，这个 Bug 早在 2024 年 1 月便有人 提交了报告 ，但直到现在都尚未进行修复。
- > > 如果你的 BusyBox 编译失败，考虑切换到老内核继续进行，或是选择直接下载预编译版本。

关键术语：
- AI安全
- 修复/缓解
- pwn
- linux
- kernel-mode
- environment

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

下载编译 busybox

搭建内核运行环境
使用 BusyBox 搭建基本的文件系统
下载编译 busybox

AI安全 修复/缓解 pwn linux kernel-mode environment

搭建内核运行环境


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「基本功能」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`
标题：Chunk Extend and Overlapping
章节：trigger system("/bin/sh") > 2015 hacklu bookstore > 基本功能
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本功能”展开。
- 根据编号来删除 order，但是这里只是单纯地 free 掉，并没有置为 NULL，因此会出现 use after free 的漏洞。
- 这里虽然程序的漏洞能力很强，但是所有进行 malloc 的大小都是完全固定的，我们只能借助这些分配的 chunk 来进行操作。
- 这里由于上面堆溢出的问题，这里也会出现堆溢出的漏洞。
- 该程序的主要功能是订书，具体如下 - 最多可以订购两本书。
- 根据编号来选择订购第几本书，可以为每本书添加对应的名字。

关键术语：
- UAF
- 边界/溢出
- 堆
- 漏洞利用
- pwn
- linux
- user-mode
- heap

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

基本功能

trigger system("/bin/sh")
2015 hacklu bookstore
基本功能

Chunk Extend and Overlapping


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md` 中的章节「exp」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md`
标题：用 userfaultfd 创造条件竞争
章节：用 userfaultfd 创造条件竞争 > 例题：QWB2021-notebook > exp
路径分类：pwn / pwn/linux/kernel-mode
分块：2/3

核心知识点：
- 本节主题围绕“exp”展开。
- } / Exploite stage */ void fix_size_by_add(void args) { sem_wait(&evil_add_sem);
- } void construct_uaf(void args) { sem_wait(&evil_edit_sem);
- } void exploit() { struct knotebook kernel_notebook[NOTE_NUM];
- if (note_fd < 0) { err_exit("failed to open /dev/notebook!
- pthread_t uffd_monitor_thread, add_fix_size_thread, edit_uaf_thread;

关键术语：
- UAF
- AI安全
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

exp

用 userfaultfd 创造条件竞争
例题：QWB2021-notebook
exp

UAF AI安全 漏洞利用 pwn linux kernel-mode exploitation

用 userfaultfd 创造条件竞争


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「确定保护」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`
标题：花式栈溢出技巧
章节：context.log_level = "debug" > 2018-XNUCA-gets > 确定保护
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“确定保护”展开。
- 先来看看程序的保护 ``c [*] '/mnt/hgfs/CTF/2018/1124XNUCA/pwn/gets/gets' Arch: amd64-64-little RELRO: Full RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x400000) `` 比较好的是程序没有 canary，自然我们很容易控制程序的 EIP，但是控制到哪里是一个问题。

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- pwn
- linux
- user-mode
- stackoverflow
- code:c

代码/命令片段线索：
- c: 6 行，首行 `[*] '/mnt/hgfs/CTF/2018/1124XNUCA/pwn/gets/gets'`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

确定保护

context.log_level = "debug"
2018-XNUCA-gets
确定保护

边界/溢出 栈 ROP/JOP pwn linux user-mode stackoverflow code:c

花式栈溢出技巧


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「分配 malloc_hook 附近chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`
标题：Fastbin Attack
章节：Fastbin Attack > 2015 9447 CTF : Search Engine > 利用 > 分配 malloc_hook 附近chunk
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“分配 malloc_hook 附近chunk”展开。
- 此时，fastbin 的链表为 b->a->b->a->…，则我们可以在申请第一个相同大小的 chunk 时，设置 b 的 fd 为 malloc_hook 附近处的 chunk 0x7fd798586aed（这里是举一个例子，代码中需使用相对地址）。
- 此后便只需要将 malloc_hook 修改为 one_gadget 地址就可以拿到 shell 了。

关键术语：
- 堆
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- heap
- code:shell
- code:python

代码/命令片段线索：
- shell: 21 行，首行 `pwndbg> print (void*)&main_arena`
- python: 12 行，首行 `# 3. fastbin attack to malloc_hook nearby chunk`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

分配 malloc_hook 附近chunk

Fastbin Attack
2015 9447 CTF : Search Engine
利用
分配 malloc_hook 附近chunk

堆 AI安全 漏洞利用 pwn linux user-mode heap code:shell code:python

Fastbin Attack


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「基本功能分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`
标题：Unsorted Bin Attack
章节：in order not to merge into top chunk > 2016 0CTF zerostorage-待完成 > 基本功能分析
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本功能分析”展开。
- 这个storage的结构体如下 ``text 00000000 Storage struc ;
- 程序管理在 bss 段的存储空间 storage ，具有插入，删除，合并，删除，查看，枚举，退出功能。
- (sizeof=0x18, mappedto_7) 00000000 ;
- XREF: .bss:storage_list/r 00000000 use dq ?
- 00000018 Storage ends ``

关键术语：
- 堆
- 漏洞利用
- pwn
- linux
- user-mode
- heap
- code:text

代码/命令片段线索：
- text: 6 行，首行 `00000000 Storage struc ; (sizeof=0x18, mappedto_7)`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

基本功能分析

in order not to merge into top chunk
2016 0CTF zerostorage-待完成
基本功能分析

堆 漏洞利用 pwn linux user-mode heap code:text

Unsorted Bin Attack


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「2015-hitcon-quals-blinkroot」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：send "/bin/sh\x00" > 2015-hitcon-quals-blinkroot
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“2015-hitcon-quals-blinkroot”展开。
- DATA XREF: main+72↑o .bss:0000000000600BD0 _bss ends ` 因此，我们可以控制 s 为 /bin/sh，同时控制字符串表中的 puts 函数为 system 函数，那就可以调用 system 函数了。
- 由于不能泄露地址信息，所以我们可以采用伪造 linkmap 的思路，即 - 利用题目提供的任意写的思路修改 linkmap 指向已经解析的地址 - 通过题目中接下来将要调用的 puts 函数来实现劫持控制流的目的 这里我们可以发现 linkmap 存储的地址为 0x600B48，因此我们可以从 0x600B40 开始设置数据。
- 同时我们观察到 `c int __cdecl __noreturn main(int argc, const char argv, const char envp) { if ( recvlen(0, (char )&data, 0x400uLL) == 1024 ) { close(0);
- 简单看一下程序开的保护 ``bash ❯ checksec blinkroot [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-hitcon-quals-blinkroot/blinkroot' Arch: amd64-64-little RELRO: No RELRO Stack: Canary found NX: NX enabled PIE: No PIE (0x400000) ` 发现程序开启了 Canary 保护。
- DATA XREF: main+B↑o .bss:0000000000600BC0 ;

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- stackoverflow
- code:bash
- code:c
- code:assembly

代码/命令片段线索：
- bash: 7 行，首行 `❯ checksec blinkroot`
- c: 12 行，首行 `int __cdecl __noreturn main(int argc, const char **argv, const char **envp)`
- plain: 8 行，首行 `.bss:0000000000600BC0 public data`
- plain: 3 行，首行 `LOAD:00000000006009E8 Elf64_Dyn <5, 400340h> ; DT_STRTAB`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

2015-hitcon-quals-blinkroot

边界/溢出 栈 ROP/JOP AI安全 漏洞利用 pwn linux user-mode stackoverflow code:bash code:c code:assembly

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`
标题：例子
章节：例子 > 堆上的格式化字符串漏洞 > 例子 > 利用思路
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“利用思路”展开。
- 其实既然有格式化字符串漏洞，我们应该是可以通过劫持got表或者控制程序返回地址来控制程序流程。
- 其次，不能够直接控制程序返回地址来控制程序流程的是因为我们并没有一块可以直接执行的地址来存储我们的内容，同时利用格式化字符串来往栈上直接写入 system\_addr + 'bbbb' + addr of '/bin/sh‘ 似乎并不现实。
- 这里我们通过 leave 指令来进行栈迁移，所以在迁移之前我们需要修改程序保存 ebp 的值为我们想要的值。
- 但是，程序中压入栈中的 ebp 值其实保存的是上一个函数的保存 ebp 值的地址，所以我们可以修改其上层函数的保存的 ebp 的值，即上上层函数（即main函数）的 ebp 数值。
- 而这里，我们可以控制的恰好是堆内存，所以我们可以把栈迁移到堆上去。

关键术语：
- 边界/溢出
- 堆
- 栈
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- fmtstr

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

利用思路

例子 堆上的格式化字符串漏洞 例子 利用思路

边界/溢出 堆 栈 AI安全 漏洞利用 pwn linux user-mode fmtstr

例子


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「一、NT kernel 中的进程与线程」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`
标题：基础知识
章节：基础知识 > 进程管理 > 一、NT kernel 中的进程与线程
路径分类：pwn / pwn/windows/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“一、NT kernel 中的进程与线程”展开。
- 在 Windows NT kernel 当中使用 _EPROCESS 结构体来表示一个进程，类似于 Linux 下的 task_struct，该结构体当中存储了 Windows 进程的所有信息，所有进程的 _EPROCESS 之间构成一个双向链表。
- 内核态 GS 寄存器指向 处理器控制区（Process Control Region），类似于 Linux 下的 .percpu 段，其中存放着指向当前线程控制块的指针，在这其中便又存放着指向当前进程控制块的指针。
- [图片文件: https://s2.loli.net/2025/02/01/a5lbF1fgDAUErcz.png]

关键术语：
- pwn
- windows
- kernel-mode
- basic-knowledge

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

一、NT kernel 中的进程与线程

基础知识
进程管理
一、NT kernel 中的进程与线程

基础知识


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/hardware/cpu/side-channel/prefetch.md` 中的章节「KASLR bypass」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/hardware/cpu/side-channel/prefetch.md`
标题：prefetch side-channel attack
章节：prefetch side-channel attack > KASLR bypass
路径分类：pwn / pwn/hardware/cpu
分块：1/1

核心知识点：
- 本节主题围绕“KASLR bypass”展开。
- 通过这个方式，我们可以得知对应系统调用的虚拟地址，从而绕过 KASLR。
- 我们使用 Address-translation oracle 的一种变种来绕过 KASLR。
- 不同于搜索映射到同一物理页面的虚拟地址，我们通过如下方式确认一个虚拟地址 $p$ 是否被系统调用所使用： 1. 清除所有的缓存（通过访问一个足够大的 buffer 来完成）。
- 3. 测量一组 prefetch 指令的执行时间，从而得知虚拟地址 $p$ 是否被系统调用所使用。
- 2. 执行系统调用，此时相应的页面会被载入到缓存中。

关键术语：
- pwn
- hardware
- cpu
- side-channel

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

KASLR bypass

prefetch side-channel attack
KASLR bypass

prefetch side-channel attack


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「0x01 Tcache overview」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`
标题：tcache makes heap exploitation easy again
章节：tcache makes heap exploitation easy again > 0x01 Tcache overview
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“0x01 Tcache overview”展开。
- / There is one of these for each thread, which contains the per-thread cache (hence "tcache_perthread_struct").
- ` 其中有两个重要的函数， tcache_get() 和 tcache_put(): `C static void tcache_put (mchunkptr chunk, size_t tc_idx) { tcache_entry e = (tcache_entry ) chunk2mem (chunk);
- } static void tcache_get (size_t tc_idx) { tcache_entry e = tcache->entries[tc_idx];
- } ` 这两个函数会在函数 _int_free 和 __libc_malloc 的开头被调用，其中 tcache_put 当所请求的分配大小不大于0x408并且当给定大小的 tcache bin 未满时调用。
- ``c / This is another arbitrary limit, which tunables can change.

关键术语：
- 堆
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- heap
- code:c

代码/命令片段线索：
- C: 12 行，首行 `/* We overlay this structure on the user-data portion of a chunk when the chunk is stored in the per-thread cache. */`
- C: 19 行，首行 `static void`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

0x01 Tcache overview

tcache makes heap exploitation easy again

堆 AI安全 漏洞利用 pwn linux user-mode heap code:c


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md` 中的章节「(s)brk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md`
标题：堆概述
章节：堆概述 > 堆的基本操作 > 内存分配背后的系统调用 > (s)brk
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“(s)brk”展开。
- 对于堆的操作，操作系统提供了 brk 函数，glibc 库提供了 sbrk 函数，我们可以通过增加 brk 的大小来向操作系统申请内存。
- 在第一次调用brk之前 从下面的输出可以看出，并没有出现堆。
- 初始时，堆的起始地址 start_brk 以及堆的当前末尾 brk 指向同一地址。
- 具体效果如下图（这个图片与网上流传的基本一致，这里是因为要画一张大图，所以自己单独画了下）所示 [图片文件: ./figure/program_virtual_address_memory_space.png] 例子 ``c / sbrk and brk example / #include <stdio.h> #include <unistd.h> #include <sys/types.h> int main() { void curr_brk, tmp_brk = NULL;
- } ` 需要注意的是，在每一次执行完操作后，都执行了getchar()函数，这是为了我们方便我们查看程序真正的映射。

关键术语：
- 堆
- AI安全
- pwn
- linux
- user-mode
- heap
- code:c
- code:shell

代码/命令片段线索：
- c: 23 行，首行 `/* sbrk and brk example */`
- shell: 10 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/syscalls$ ./sbrk`
- shell: 12 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/syscalls$ ./sbrk`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

(s)brk

堆概述 堆的基本操作 内存分配背后的系统调用 (s)brk

堆 AI安全 pwn linux user-mode heap code:c code:shell

堆概述


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/arm/rop.md` 中的章节「预备知识」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`
标题：Arm ROP
章节：Arm ROP > 预备知识
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“预备知识”展开。
- 先看一下 arm 下的函数调用约定，函数的第 1 ～ 4 个参数分别保存在 r0 ～ r3 寄存器中， 剩下的参数从右向左依次入栈， 被调用者实现栈平衡，函数的返回值保存在 r0 中 [图片文件: https://courses.washington.edu/cp105/_images/ARM_Calling_Convention.png] 除此之外，arm 的 b/bl 等指令实现跳转;
- pc 寄存器相当于 x86 的 eip，保存下一条指令的地址，也是我们要控制的目标

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- pwn
- linux
- user-mode
- stackoverflow

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

预备知识

边界/溢出 栈 ROP/JOP pwn linux user-mode stackoverflow

Arm ROP


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「核心独占内存池：Lookaside Lists」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`
标题：基础知识
章节：基础知识 > 内存管理 > 二、Pool Memory（before 19H1） > 核心独占内存池：Lookaside Lists
路径分类：pwn / pwn/windows/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“核心独占内存池：Lookaside Lists”展开。
- 池描述符对应的内存池在所有核心间共享，核心一多效率就灾难了，因此每个核心实际上还有一个独有的内存池，存放在内核态 GS 寄存器指向的 处理器控制区（Process Control Region，为 _KPCR 结构体，类似于 Linux 下的 .percpu 段）当中—— Lookaside Lists 用于优先处理当前核心的池内存请求，只有当其不足以满足需求时才会向共享内存池请求内存。
- LookasideList 的结构如下图所示，根据大小归属数组上不同的链表，每个链表又分为二个子链：一个单向链表（默认，长度有上限，LIFO）与一个双向链表（前者满时放到这），LookasideList 的数组成员数量较少因此仅用于较小的内存分配。
- 笔者也不知道 ~~，静待 Windows 开源的那一天~~ ......
- [图片文件: https://s2.loli.net/2025/02/05/VBuc9hZysC2fbr4.png] LookasideList 一共有四类（PP == Per Processsor）： - PPLookasideList：用于频繁分配与释放的对象的 LookasideList - PPNxPagedLookasideList：非换页池的 non-eXecuted 页面的 LookasideList - PPNPagedLookasideList：非换页池的 LookasideList - P...

关键术语：
- pwn
- windows
- kernel-mode
- basic-knowledge

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

核心独占内存池：Lookaside Lists

基础知识
内存管理
二、Pool Memory（before 19H1）
核心独占内存池：Lookaside Lists

基础知识


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/sandbox/seccomp/c-sandbox-escape.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/sandbox/seccomp/c-sandbox-escape.md`
标题：C 沙盒逃逸
章节：C 沙盒逃逸 > orw > 例题 > Balsn_CTF_2019-PlainText > 分析
路径分类：pwn / pwn/sandbox/seccomp
分块：1/1

核心知识点：
- 本节主题围绕“分析”展开。
- `` 通过使用这个 gadget 之后改变 rdx，ret 到 setcontext 之后就可以 rop 了（这个 chunk 无法通过 ROPgadget 找出，需要使用 ropper）。
- 在 orw 之前的利用这里不再赘述，请见《Glibc Heap 利用》目录下的《堆中的 Off-By-One》中对此题的分析 比较讨厌的是，在 libc-2.29 下，free 函数不会再将 rdi 赋值给 rdx，我们无法直接控制 rdx，仅能控制 rdi，幸好比较巧合的，在本题的 libc 中有这样一个 gadget `` 0x12be97: mov rdx, qword ptr [rdi + 8];
- mov rax, qword ptr [rdi];

关键术语：
- 堆
- ROP/JOP
- 密码学
- 漏洞利用
- pwn
- sandbox
- seccomp
- c-sandbox-escape.md

代码/命令片段线索：
- plain: 1 行，首行 `0x12be97: mov rdx, qword ptr [rdi + 8]; mov rax, qword ptr [rdi]; mov rdi, rdx; jmp rax;`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

分析

C 沙盒逃逸
orw
例题
Balsn_CTF_2019-PlainText
分析

堆 ROP/JOP 密码学 漏洞利用 pwn sandbox seccomp c-sandbox-escape.md

C 沙盒逃逸


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「失败」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`
标题：申请内存块
章节：define DEFAULT_TOP_PAD 131072 > 申请内存 > 失败
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“失败”展开。
- ``c else { / If have mmap, try using it as a backup when MORECORE fails or cannot be used.
- = MAP_FAILED) { / We do not need, and cannot use, another sbrk call to find end / brk = mbrk;
- This is worth doing on systems that have "holes" in address space, so sbrk cannot extend to give contiguous space, but space is available elsewhere.
- / If we are relying on mmap as backup, then use larger units / if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE)) size = MMAP_AS_MORECORE_SIZE;
- / Don't try if size wraps around 0 / if ((unsigned long)(size) > (unsigned long)(nb)) { char mbrk = (char )(MMAP(0, size, PROT_READ | PROT_WRITE, 0));

关键术语：
- 堆
- AI安全
- pwn
- linux
- user-mode
- heap
- code:c

代码/命令片段线索：
- c: 32 行，首行 `else {`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

失败

申请内存块


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「tcache stashing unlink attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`
标题：tcache makes heap exploitation easy again
章节：define TCACHE_FILL_COUNT 7 > 0x03 Pwn Tcache > tcache stashing unlink attack
路径分类：pwn / pwn/linux/user-mode
分块：1/2

核心知识点：
- 本节主题围绕“tcache stashing unlink attack”展开。
- 这种攻击利用的是 tcache bin 有剩余(数量小于 TCACHE_MAX_BINS )时，同大小的small bin会放进tcache中(这种情况可以用 calloc 分配同大小堆块触发，因为 calloc 分配堆块时不从 tcache bin 中选取)。
- 当攻击者可以写一个small bin的bk指针时，其可以在任意地址上写一个libc地址(类似 unsorted bin attack 的效果)。
- 模拟 UAF 漏洞修改 bin2->bk 为 fake_chunk ，在 calloc(0x90) 的时候触发攻击。
- 调用 calloc(size-0x10) 的时候会返回给用户 chunk0 (这是因为 smallbin 的 FIFO 分配机制)，假设 tcache[sz] 中有 5 个空闲堆块，则有足够的位置容纳 chunk1 以及 fake_chunk 。
- ``c #include <stdio.h> #include <stdlib.h> int main(){ unsigned long stack_var[0x10] = {0};

关键术语：
- UAF
- 堆
- 栈
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- heap
- code:c

代码/命令片段线索：
- c: 54 行，首行 `#include <stdio.h>`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

tcache stashing unlink attack

define TCACHE_FILL_COUNT 7
0x03 Pwn Tcache
tcache stashing unlink attack

UAF 堆 栈 AI安全 漏洞利用 pwn linux user-mode heap code:c


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「used to make faking data, such relocation, Symbol, Str」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：construct ropchain > used to make faking data, such relocation, Symbol, Str
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“used to make faking data, such relocation, Symbol, Str”展开。
- buf += rop.dl_resolve_data(bss_base + 20, 'system') buf += rop.fill(100, buf) r.send(buf) r.interactive() `` 关于 dl_resolve_call 与 dl_resolve_data 的具体细节请参考 roputils.py 的源码，比较容易理解。
- 效果如下 `shell ❯ python roptool.py [+] Starting local process './main_partial_relro_32': pid 24673 [DEBUG] Received 0x17 bytes: 'Welcome to XDCTF2015~!
- 需要注意的是，dl_resolve 执行完之后也是需要有对应的返回地址的。

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- pwn
- linux
- user-mode
- stackoverflow

代码/命令片段线索：
- plain: 2 行，首行 `关于 dl_resolve_call 与 dl_resolve_data 的具体细节请参考 roputils.py 的源码，比较容易理解。需要注意的是，dl_resolve 执行完之后也是需要有对应的返回地址的。`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

used to make faking data, such relocation, Symbol, Str

边界/溢出 栈 ROP/JOP AI安全 pwn linux user-mode stackoverflow

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/virtualization/basic-knowledge/basic-knowledge.md` 中的章节「虚拟化技术简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/basic-knowledge.md`
标题：虚拟化技术简介
章节：虚拟化技术简介
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“虚拟化技术简介”展开。
- 利用虚拟化技术，我们可以打破实体结构间不可切割的特性——一份实体资源可以对用户呈现为多份虚拟资源，多份实体资源也可以呈现为一份物理资源。
- 通过虚拟化技术，我们可以实现资源的动态分配、灵活调度、跨域共享等，从而提高资源的利用率。
- > > ——《系统虚拟化：原理与实现》 即虚拟化技术的实现其实源自于现代计算机系统自下而上的多层抽象的结构：「每个层次都向上一层次呈现一个抽象，每一层只需要知道下层的抽象接口，而无需了解其内部运作机制」——我们不难想到的是，只要我们能够通过某种方式向上层提供表现相同的抽象接口，在上层看来我们就是正常的该层所提供的资源，从而就实现了对该层的虚拟化。
- 根据资源的不同，在这两个定语之后我们可以接不同的名词：例如我们将一台物理机器称之为 Host Machine （宿主机），将运行在其上的虚拟机称之为 Guest Machine （客户机）；
- 操作系统层上的虚拟化：通常指的是操作系统内核可以提供多个互相隔离的用户态实例（通常称之为容器），这些用户态实例对其用户而言就像是一台真实的计算机，有着自己独立的网络、文件系统等（例如 VServer）。

关键术语：
- 漏洞利用
- pwn
- virtualization
- basic-knowledge
- basic-knowledge.md

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

虚拟化技术简介

漏洞利用 pwn virtualization basic-knowledge basic-knowledge.md

虚拟化技术简介


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「寻找write@plt」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`
标题：中级ROP
章节：中级ROP > BROP > 攻击原理 > Blind ROP > 寻找输出函数 > 寻找write@plt
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“寻找write@plt”展开。
- 一般情况下，我们有两种方法来找到这个值 - 使用rop chain，同时使得每个rop对应的文件描述符不一样 - 同时打开多个连接，并且我们使用相对较高的数值来试一试。
- 当我们可以控制write函数的三个参数的时候，我们就可以再次遍历所有的plt表，根据write函数将会输出内容来找到对应的函数。
- 需要注意的是 - linux默认情况下，一个进程最多只能打开1024个文件描述符。
- 需要注意的是，这里有个比较麻烦的地方在于我们需要找到文件描述符的值。
- posix标准每次申请的文件描述符数值总是当前最小可用数值。

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- pwn
- linux
- user-mode
- stackoverflow

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

寻找write@plt

中级ROP
BROP
攻击原理
Blind ROP
寻找输出函数
寻找write@plt

中级ROP


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「send resolve data」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：send resolve data
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“send resolve data”展开。
- rop.raw(bin_sh_addr) rop.raw(resolve_call) rop.raw('a'(256-len(rop.chain()))) io.send(rop.chain()) io.interactive() `` 然而， 简单地运行后发现，程序崩溃了。
- } ` 我们发现，如果把 l->l_info[VERSYMIDX(DT_VERSYM)] 设置为 NULL，那程序就不会执行下面的代码，版本号就为 NULL，就可以正常执行代码。
- 估计有点难 - bss 的起始地址为 0x601050，那么索引值最小为 (0x601050-0x400398)/24=87517，即 0x4003f6 + 875172 = 0x42afb0 - bss 可以最大使用的地址为 0x601fff，对应的索引值为(0x601fff-0x400398)/24=87684，即0x4003f6 + 876842 = 0x42b0fe 显然都在非映射的内存区域。
- 通过阅读 dl_fixup 的代码 `c // 获取符号的版本信息 const struct r_found_version version = NULL;
- = NULL) { const ElfW(Half) vernum = (const void )D_PTR(l, l_info[VERSYMIDX(DT_VERSYM)]);

关键术语：
- 边界/溢出
- 堆
- 栈
- ROP/JOP
- 密码学
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- stackoverflow

代码/命令片段线索：
- plain: 1 行，首行 `然而， 简单地运行后发现，程序崩溃了。`
- plain: 4 行，首行 `通过调试，我们发现，程序是在获取对应的版本号`
- plain: 4 行，首行 `那我们能不能想办法让它位于映射的内存中呢。估计有点难`
- plain: 6 行，首行 `我们发现，如果把 l->l_info[VERSYMIDX(DT_VERSYM)] 设置为 NULL，那程序就不会执行下面的代码，版本号就为 NULL，就可以正常执行代码。但是，这样的话，我们就需要知道 link_map 的地址了。 G...`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

send resolve data

边界/溢出 堆 栈 ROP/JOP 密码学 AI安全 漏洞利用 pwn linux user-mode stackoverflow

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/race-condition/introduction.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`
标题：Race Condition
章节：参考
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“参考”展开。
- - http://www.teraits.com/pitagoras/marcio/segapp/05.ppt - http://repository.root-me.org/Programmation/C%20-%20C++/EN%20-%20Secure%20Coding%20in%20C%20and%20C++%20Race%20Conditions.pdf - https://www.blackhat.com/presentations/bh-europe-04/bh-eu-04-tsyrklevic...

关键术语：
- ROP/JOP
- AI安全
- pwn
- linux
- user-mode
- race-condition

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

参考

ROP/JOP AI安全 pwn linux user-mode race-condition

Race Condition


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md` 中的章节「0x1407e0 = 101 0 0000 0011 1111 00000」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md`
标题：bypass-smep （已过时）
章节：0x1407e0 = 101 0 0000 0011 1111 00000
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“0x1407e0 = 101 0 0000 0011 1111 00000”展开。
- 使用 GDB 调试内核时，我们可以通过 info register cr4 命令查看当前 CPU 的 CR4 寄存器的值以及对应启用的标志位： `shell (gdb) info registers cr4 cr4 0x3006f0 [ SMAP SMEP OSXMMEXCPT OSFXSR PGE MCE PAE PSE ] ``

关键术语：
- ROP/JOP
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

代码/命令片段线索：
- plain: 2 行，首行 `即可关闭 smep 保护。`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

0x1407e0 = 101 0 0000 0011 1111 00000

ROP/JOP 漏洞利用 pwn linux kernel-mode exploitation

bypass-smep （已过时）


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「signal机制」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`
标题：SROP
章节：SROP > signal机制
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“signal机制”展开。
- 文件: figure/signal2-stack.png] 对于signal Frame来说，会因为架构的不同而有所区别，这里给出分别给出x86以及x64的sigcontext - x86 ``c struct sigcontext { unsigned short gs, __gsh;
- 2. 内核会为该进程保存相应的上下文，主要是将所有寄存器压入栈中，以及压入signal信息，以及指向sigreturn的系统调用地址。
- 此时栈的结构如下图所示，我们称ucontext以及siginfo这一段为Signal Frame。
- 一般来说，信号机制常见的步骤如下图所示： [图片: Process of Signal Handlering;
- 比如说，进程之间可以通过系统调用kill来发送软中断信号。

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- pwn
- linux
- user-mode
- stackoverflow
- code:c

代码/命令片段线索：
- c: 25 行，首行 `struct sigcontext`
- c: 50 行，首行 `struct _fpstate`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

signal机制

SROP


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md` 中的章节「prepare done」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md`
标题：House of Pig
章节：prepare done
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“prepare done”展开。
- change_rol(1) add_message(0x410,'leak_libc\n' (0x410 // 48)) # 11 add_message(0x410,'largebin\n' (0x410 // 48)) # 12 add_message(0x410,'\n' * (0x410 // 48)) # 13 delete_message(12)
- change_rol(2) change_rol(1) view_message(12) sh.recvuntil("is: ") libc_base = u64(sh.recv(6).ljust(8,'\x00')) - libc.sym["__malloc_hook"] - 0x10 - 96 view_message(5) sh.recvuntil("is: ") heap_base = u64(sh.recv(6).ljust(8,'\x00')) - 0x12750 log.success("lib...
- change_rol(1) delete_message(14) add_message(0x430,'push\n' * (0x430 // 48)) # 15

关键术语：
- 堆
- pwn
- linux
- user-mode
- heap

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

prepare done

House of Pig


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「控制rdx」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`
标题：中级ROP
章节：中级ROP > BROP > 攻击原理 > Blind ROP > 控制rdx
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 需要提前说的是，并不是所有的程序都会调用strcmp函数，所以在没有调用strcmp函数的情况下，我们就得利用其它方式来控制rdx的值了。
- 之前，我们已经找到了brop的gadgets，所以我们可以控制函数的前两个参数了。
- 我们可以选择如下的一种方法 - 利用plt表项的慢路径 - 并且利用下一个表项的慢路径的地址来覆盖返回地址 这样，我们就不用来回控制相应的变量了。
- 那么我们如果控制传递的参数为这两种地址的组合，会出现以下四种情况 - strcmp(bad,bad) - strcmp(bad,readable) - strcmp(readable,bad) - strcmp(readable,readable) 只有最后一种格式，程序才会正常执行。
- 当我们找到plt表之后，下面，我们就该想办法来控制rdx的数值了，那么该如何确认strcmp的位置呢？
- 注：在没有PIE保护的时候，64位程序的ELF文件的0x400000处有7个非零字节。

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- 漏洞利用
- pwn
- linux
- user-mode
- stackoverflow

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

控制rdx

边界/溢出 栈 ROP/JOP 漏洞利用 pwn linux user-mode stackoverflow

中级ROP


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Final Exploitation」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`
标题：Page-level UAF
章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Final Exploitation
路径分类：pwn / pwn/linux/kernel-mode
分块：4/8

核心知识点：
- 本节主题围绕“Final Exploitation”展开。
- uaf / log_info("[] construct a second-level uaf pipe page...");
- } } if (snd_vicitm_pid == -1) { err_exit("FAILED to corrupt second-level pipe_buffer!
- } } / VI - SECONDARY exploit stage: build pipe for arbitrary read & write / void building_self_writing_pipe(void) { size_t buf[0x1000];
- } if (fcntl(pipe_fd[i][1], F_SETPIPE_SZ, trd_pipe_sz) < 0) { printf("[x] failed to resize %d pipe!
- err_exit("FAILED to re-alloc pipe_buffer!

关键术语：
- UAF
- 堆
- AI安全
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Final Exploitation

Page-level UAF
例题：D^3CTF2023 - d3kcache
漏洞利用
Final Exploitation

UAF 堆 AI安全 漏洞利用 pwn linux kernel-mode exploitation

Page-level UAF


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Final Exploitation」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`
标题：Page-level UAF
章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Final Exploitation
路径分类：pwn / pwn/linux/kernel-mode
分块：7/8

核心知识点：
- 本节主题围绕“Final Exploitation”展开。
- printf(INFO_MSG("[] kernel stack's addr: ") "0x%lx\n",stack_addr);
- } /* It may also be okay to write ROP chain on pipe_write's stack, if there's no CONFIG_RANDOMIZE_KSTACK_OFFSET_DEFAULT(it can also be bypass by RETs).
- / reading the page table directly to get physical addr of kernel stack/ log_info("[] Reading page table...");
- printf( SUCCESS_MSG("[+] Got another virt addr of kernel stack: ") "0x%lx\n\n", stack_addr_another );
- stack_page = direct_map_addr_to_page_addr(stack_addr_another);

关键术语：
- UAF
- 堆
- 栈
- ROP/JOP
- AI安全
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Final Exploitation

UAF 堆 栈 ROP/JOP AI安全 漏洞利用 pwn linux kernel-mode exploitation

Page-level UAF


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`
标题：基本 ROP
章节：基本 ROP > ret2shellcode > 例子
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“例子”展开。
- } ` 可以看出，程序仍然是基本的栈溢出漏洞，不过这次还同时将对应的字符串复制到 buf2 处。
- > 点击下载: ret2shellcode 首先检测程序开启的保护： ``shell ➜ ret2shellcode checksec ret2shellcode Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX disabled PIE: No PIE (0x8048000) RWX: Has RWX segments ` 可以看出源程序几乎没有开启任何保护，并且有可读，可写，可执行段。
- 接下来我们再使用 IDA 对程序进行反编译： `C int __cdecl main(int argc, const char argv, const char envp) { int v4;
- ─────────────────────────────────────────────────────────────────────[ source:ret2shellcode.c+8 ]──── 6 int main(void) 7 { → 8 setvbuf(stdout, 0LL, 2, 0LL);
- `shell gef➤ b main Breakpoint 1 at 0x8048536: file ret2shellcode.c, line 8. gef➤ r Starting program: /mnt/hgfs/Hack/CTF-Learn/pwn/stack/example/ret2shellcode/ret2shellcode Breakpoint 1, main () at ret2shellcode.c:8 8 setvbuf(stdout, 0LL, 2, 0LL);

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- stackoverflow
- code:shell
- code:c
- code:asm
- code:text
- code:python

代码/命令片段线索：
- shell: 7 行，首行 `➜ ret2shellcode checksec ret2shellcode`
- C: 11 行，首行 `int __cdecl main(int argc, const char **argv, const char **envp)`
- asm: 2 行，首行 `.bss:0804A080 public buf2`
- shell: 33 行，首行 `gef➤ b main`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

例子

边界/溢出 栈 ROP/JOP AI安全 漏洞利用 pwn linux user-mode stackoverflow code:shell code:c code:asm code:text code:python

基本 ROP


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「IOMMU 与虚拟化」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`
标题：IO 虚拟化
章节：IO 虚拟化 > IOMMU > IOMMU 与虚拟化
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“IOMMU 与虚拟化”展开。
- 当引入了 IOMMU 之后，IOMMU 可以根据 Host 侧提供的 GPA 到 HPA 之间的地址转换表，进行DMA remapping，这样外设就能正常地访问到 Guest 的物理内存，而不会错误地访问到 Host 对应的物理内存区域。
- 虽然 IOMMU 的引入增加了与外设通信间的开销，但 IOMMU 解决了系统虚拟化技术的一个难点：对于非纯模拟的设备而言，其并不知道 GPA 与 HPA 之间的映射关系，当其按 Guest OS 提供的地址进行 DMA 时会直接访问到 Host 的内存。

关键术语：
- pwn
- virtualization
- basic-knowledge
- io-virtualization.md

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

IOMMU 与虚拟化

pwn virtualization basic-knowledge io-virtualization.md

IO 虚拟化


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「演示」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`
标题：Fastbin Attack
章节：Fastbin Attack > Alloc to Stack > 演示
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“演示”展开。
- 这次我们把 fake_chunk 置于栈中称为 stack_chunk，同时劫持了 fastbin 链表中 chunk 的 fd 值，通过把这个 fd 值指向 stack_chunk 就可以实现在栈中分配 fastbin chunk。
- int main(void) { CHUNK stack_chunk;
- (long long *)chunk1=&stack_chunk;
- `` typedef struct _chunk { long long pre_size;

关键术语：
- 堆
- 栈
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- heap

代码/命令片段线索：
- plain: 20 行，首行 `typedef struct _chunk`
- plain: 3 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1`
- plain: 3 行，首行 `0x7ffff7dd1b20 <main_arena>: 0x0000000000000000 <=== unsorted bin`
- plain: 22 行，首行 `0x400629 <main+83> call 0x4004c0 <malloc@plt>`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

演示

Fastbin Attack


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「now, we are on the new stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：now, we are on the new stack
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“now, we are on the new stack”展开。
- 这里我们同时给出另外一种方法，即通过多次使用 vuln 函数进行漏洞利用。
- ``python from pwn import

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- stackoverflow

代码/命令片段线索：
- plain: 1 行，首行 `最终执行效果如下`
- plain: 2 行，首行 `到了这里我们发现，与 32 位不同，在 64 位下进行栈迁移然后利用 ret2dlresolve 攻击需要精心构造栈的位置，以避免破坏 .dynamic 节的内容。`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

now, we are on the new stack

边界/溢出 栈 ROP/JOP AI安全 漏洞利用 pwn linux user-mode stackoverflow

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct rop chain」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：construct rop chain
路径分类：pwn / pwn/linux/user-mode
分块：1/2

核心知识点：
- 本节主题围绕“construct rop chain”展开。
- __libc_start_main@@GLIBC_2.0 LOAD:080482E4 dw 2 ;
- } ` 进一步分析可以知道，因为我们伪造了 write 函数的重定位表项，其中 reloc->r_info 被设置成了比较大的值（由于 index_dynsym 离符号表比较远）。
- global symbol: _IO_stdin_used `` 那我们可以再次运行看一下伪造后 ndx 具体的值
- } ` 以及源码可以知道程序是在访问 version 的 hash 时出错。
- 通过分析 .dynmic 节，我们可以发现 vernum 的地址为 0x80482d8。

关键术语：
- 边界/溢出
- 堆
- 栈
- ROP/JOP
- AI安全
- pwn
- linux
- user-mode
- stackoverflow

代码/命令片段线索：
- plain: 1 行，首行 `直接执行后发现并不行`
- plain: 1 行，首行 `发现程序已经崩溃了，通过 coredump，可以发现程序在 `ld-linux.so.2` 中崩了。`
- plain: 1 行，首行 `通过逆向分析 ld-linux.so.2`
- plain: 1 行，首行 `以及源码可以知道程序是在访问 version 的 hash 时出错。`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

construct rop chain

边界/溢出 堆 栈 ROP/JOP AI安全 pwn linux user-mode stackoverflow

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/rop/rop.md` 中的章节「Reference and Thanks to」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/rop/rop.md`
标题：Kernel ROP
章节：Kernel ROP > Reference and Thanks to
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Reference and Thanks to”展开。
- https://arttnba3.cn/2021/02/21/OS-0X00-LINUX-KERNEL-PART-I/
- https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#0x01-Kernel-ROP-basic
- https://unix.stackexchange.com/questions/5518/what-is-the-difference-between-the-following-kernel-makefile-terms-vmlinux-vml
- https://blog.csdn.net/gatieme/article/details/78311841
- https://veritas501.space/2018/06/05/qwb2018%20core/

关键术语：
- 栈
- ROP/JOP
- AI安全
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Reference and Thanks to

栈 ROP/JOP AI安全 漏洞利用 pwn linux kernel-mode exploitation

Kernel ROP


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「HITCON Training lab14 magic heap」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`
标题：Unsorted Bin Attack
章节：Unsorted Bin Attack > HITCON Training lab14 magic heap
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“HITCON Training lab14 magic heap”展开。
- 题目链接 这里我们修改一下源程序中的 l33t 函数，以便于可以正常运行。
- ``c void l33t() { system("cat ./flag");

关键术语：
- 堆
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- heap
- code:c

代码/命令片段线索：
- c: 1 行，首行 `void l33t() { system("cat ./flag"); }`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

HITCON Training lab14 magic heap

Unsorted Bin Attack
HITCON Training lab14 magic heap

堆 AI安全 漏洞利用 pwn linux user-mode heap code:c

Unsorted Bin Attack


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/virtualization/qemu/basic-knowledge/dev.md` 中的章节「QEMU 设备 IO 处理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/virtualization/qemu/basic-knowledge/dev.md`
标题：QEMU 设备模拟
章节：QEMU 设备模拟 > QEMU 设备 IO 处理
路径分类：pwn / pwn/virtualization/qemu
分块：1/1

核心知识点：
- 本节主题围绕“QEMU 设备 IO 处理”展开。
- > accel/kvm/kvm-all.c ``c int kvm_cpu_exec(CPUState cpu) { //... do { //... run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);
- // VCPU 退出运行，处理对应事件 trace_kvm_run_exit(cpu->cpu_index, run->exit_reason);
- switch (run->exit_reason) { case KVM_EXIT_IO: DPRINTF("handle_io\n");
- / Called outside BQL / kvm_handle_io(run->io.port, attrs, (uint8_t )run + run->io.data_offset, run->io.direction, run->io.size, run->io.count);
- case KVM_EXIT_MMIO: DPRINTF("handle_mmio\n");

关键术语：
- pwn
- virtualization
- qemu
- basic-knowledge
- code:c

代码/命令片段线索：
- c: 29 行，首行 `int kvm_cpu_exec(CPUState *cpu)`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

QEMU 设备 IO 处理

pwn virtualization qemu basic-knowledge code:c

QEMU 设备模拟


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md` 中的章节「VMX 操作模式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`
标题：CPU 虚拟化
章节：CPU 虚拟化 > 硬件辅助虚拟化 > VMX 操作模式
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“VMX 操作模式”展开。
- > > 每个 MSR 寄存器都会有一个 id，称之为 MSR Index，我们可以通过这个 id 来利用 RDMSR 与 WRMSR 指令读写指定的 MSR 寄存器。
- 作为传统的 IA32 架构的扩展，VMX 操作模式在默认下是关闭的，只有当 VMM 需要使用硬件辅助虚拟化功能时才会使用 Intel 提供的两条新指令来开关 VMX 操作模式： - VMXON：开启 VMX 操作模式。
- VMM 可以通过 VM entries 进入 Guest VM（单次只能执行一个 VM），VMM 通过 VMLAUNCH （第一次进入 VM）与 VMRESUME （从 VMM 中恢复到 VM）指令来使能 VM entry，通过 VM exits 重获控制权。
- 根据需要通过写 VMCS 的 VM-entry Interrucption-Information 向 VM 进行事件注入（如异常、异步中断等）。
- > > 我们可以在 Intel SDM 的 Volume 4 中获取到到 MSR 寄存器的详细信息。

关键术语：
- 漏洞利用
- pwn
- virtualization
- basic-knowledge
- cpu-virtualization.md

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

VMX 操作模式

CPU 虚拟化
硬件辅助虚拟化
VMX 操作模式

漏洞利用 pwn virtualization basic-knowledge cpu-virtualization.md

CPU 虚拟化


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「top chunk's offset to heap base」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`
标题：House Of Force
章节：top chunk's offset to heap base
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“top chunk's offset to heap base”展开。
- offset_to_heap_base = -(0x40 + 0x20) malloc_size = offset_to_heap_base - 0x8 - 0xf #gdb.attach(r) additem(malloc_size, "dada") additem(0x10, p64(magic) * 2) print r.recv() r.interactive() ``` 当然，这一题也可以使用 unlink 的方法来做。

关键术语：
- 堆
- pwn
- linux
- user-mode
- heap

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

top chunk's offset to heap base

House Of Force


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「轻量级的检测」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`
标题：释放内存块
章节：释放内存块 > _int_free > 合并非 mmap 的空闲 chunk > 轻量级的检测
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“轻量级的检测”展开。
- ``c++ / Lightweight tests: check whether the block is already the top block. / // 当前free的chunk不能是top chunk if (__glibc_unlikely(p == av->top)) { errstr = "double free or corruption (top)";
- } // 当前要free的chunk的使用标记没有被标记，double free / Or whether the block is actually not marked used. / if (__glibc_unlikely(!
- prev_inuse(nextchunk))) { errstr = "double free or corruption (!
- } // 下一个chunk的大小 nextsize = chunksize(nextchunk);
- } // 当前free的chunk的下一个chunk不能超过arena的边界 / Or whether the next chunk is beyond the boundaries of the arena. / if (__builtin_expect(contiguous(av) && (char ) nextchunk >= ((char ) av->top + chunksize(av->top)), 0)) { errstr = "double free or corruption (out)";

关键术语：
- 堆
- pwn
- linux
- user-mode
- heap
- code:c++

代码/命令片段线索：
- c++: 32 行，首行 `/* Lightweight tests: check whether the block is already the`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

轻量级的检测

释放内存块
_int_free
合并非 mmap 的空闲 chunk
轻量级的检测

释放内存块


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/mips/rop.md` 中的章节「1 ropemporium ret2text」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`
标题：mips - ROP
章节：mips - ROP > 题目 > 1 ropemporium ret2text
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“1 ropemporium ret2text”展开。
- 所以我们可以构造如下 payload： `python pay = 'A'*36 + p32(ret2win_addr) `` 即能 get flag [图片: image-20201028012453672;
- 文件: https://sw-blog.oss-cn-hongkong.aliyuncs.com/img/20201028011258.png] 在看该函数里的 read， a2 为读取的 size 大小，将被赋值为 0x38，buf 为位于 $sp + 0x18 的位置，明显的一个栈溢出漏洞，且能覆盖返回地址。
- 通过计算，可以计算出 padding 为 36 `` 60 - 0x18 = 36 ` 另外程序有一个 ret2win 函数 [图片: image-20201028011734928;
- 文件: https://sw-blog.oss-cn-hongkong.aliyuncs.com/img/20201028010554.png] 我们可以看到函数一开始，将 ra 寄存器的值，放入 $sp+60 的位置里。
- 跟到 pwnme 函数里 [图片: image-20201028010553089;

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- 漏洞利用
- pwn
- linux
- user-mode
- stackoverflow
- code:python

代码/命令片段线索：
- plain: 1 行，首行 `60 - 0x18 = 36`
- python: 1 行，首行 `pay = 'A'*36 + p32(ret2win_addr)`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

1 ropemporium ret2text

边界/溢出 栈 ROP/JOP 漏洞利用 pwn linux user-mode stackoverflow code:python

mips - ROP


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/introduction.md` 中的章节「常用代码模板」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/introduction.md`
标题：简介
章节：简介 > 常用代码模板
路径分类：pwn / pwn/linux/kernel-mode
分块：5/5

核心知识点：
- 本节主题围绕“常用代码模板”展开。
- #endif `` 在后续的漏洞利用的 exp 编写当中，我们也会借用到该文件中的部分内容（或是直接 include` 为我们的 exp 的一部分）。
- void (wait_until_sent)(struct tty_struct tty, int timeout);
- If the pages in the pipe belong to a file system, we may need to wait for IO completion in this hook.
- dio_copy.src = (unsigned long long) temp_page_for_stuck;
- uffdio_copy.dst = (unsigned long long) msg.arg.pagefault.address & ~(0x1000 - 1);

关键术语：
- AI安全
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

常用代码模板

AI安全 漏洞利用 pwn linux kernel-mode exploitation

简介


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md` 中的章节「fileno 与缓冲区的相关利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md`
标题：glibc 2.24下 IO_FILE 的利用
章节：glibc 2.24下 IO_FILE 的利用 > 新的利用技术 > fileno 与缓冲区的相关利用
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“fileno 与缓冲区的相关利用”展开。
- `` 因为进程中包含了系统默认的三个文件流stdin\stdout\stderr，因此这种方式可以不需要进程中存在文件操作，通过scanf\printf一样可以进行利用。
- 在vtable难以被利用之后，利用的关注点从vtable转移到_IO_FILE结构内部的域中。
- 前面介绍过_IO_FILE在使用标准IO库时会进行创建并负责维护一些相关信息，其中有一些域是表示调用诸如fwrite、fread等函数时写入地址或读取地址的，如果可以控制这些数据就可以实现任意地址写或任意地址读。
- 在_IO_FILE中_IO_buf_base表示操作的起始地址，_IO_buf_end表示结束地址，通过控制这两个数据可以实现控制读写的操作。
- `` struct _IO_FILE { int _flags;

关键术语：
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- io-file

代码/命令片段线索：
- plain: 22 行，首行 `struct _IO_FILE {`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

fileno 与缓冲区的相关利用

glibc 2.24下 IO_FILE 的利用
新的利用技术
fileno 与缓冲区的相关利用

glibc 2.24下 IO_FILE 的利用


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「古老的 unlink」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：Unlink > 原理 > 古老的 unlink
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“古老的 unlink”展开。
- `` 这里我们以 32 位为例，假设堆内存最初的布局是下面的样子 [图片文件: ./figure/old_unlink_vul.png] 现在有物理空间连续的两个 chunk（Q，Nextchunk），其中 Q 处于使用状态、Nextchunk 处于释放状态。
- 那么如果我们通过某种方式（比如溢出）将 Nextchunk 的 fd 和 bk 指针修改为指定的值。
- 则当我们free(Q)时 - glibc 判断这个块是 small chunk - 判断前向合并，发现前一个 chunk 处于使用状态，不需要前向合并 - 判断后向合并，发现后一个 chunk 处于空闲状态，需要合并 - 继而对 Nextchunk 采取 unlink 操作 那么 unlink 具体执行的效果是什么样子呢？
- 我们可以来分析一下 - FD=P->fd = target addr -12 - BK=P->bk = expect value - FD->bk = BK，即 (target addr-12+12)=BK=expect value - BK->fd = FD，即(expect value +8) = FD = target addr-12 看起来我们似乎可以通过 unlink 直接实现任意地址读写的目的，但是我们还是需要确保 expect value +8 地址具有可写的权限。
- ``c // 由于 P 已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致(size检查) if (__builtin_expect (chunksize(P) !

关键术语：
- 边界/溢出
- 堆
- pwn
- linux
- user-mode
- heap
- code:c

代码/命令片段线索：
- c: 12 行，首行 `// 由于 P 已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致(size检查)`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

古老的 unlink

Unlink


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「QCOW2 格式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`
标题：搭建内核运行环境
章节：搭建内核运行环境 > 使用 BusyBox 搭建基本的文件系统 > 打包文件系统 > QCOW2 格式
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“QCOW2 格式”展开。
- QEMU Copy-on-Write version 2 QCOW2 是 QEMU 的一种常用的硬盘镜像格式，我们可以使用如下命令创建一个指定大小的 QCOW2 镜像文件：
- ``shell $ qemu-img create -f qcow2 rootfs.qcow2 8M ``
- > 在此之前你可能需要手动启用如下内核模块： > > ``shell > $ sudo modprobe nbd > ``
- ``shell $ sudo qemu-nbd -c /dev/nbd0 ./rootfs.qcow2 ``
- ``shell $ sudo cp -auv _install/* /mnt $ sudo chown -R root:root /mnt/ $ sudo chmod 700 /mnt/root $ sudo chown -R 1000:1000 /mnt/home/ctf/ ``

关键术语：
- pwn
- linux
- kernel-mode
- environment
- code:shell

代码/命令片段线索：
- shell: 1 行，首行 `$ qemu-img create -f qcow2 rootfs.qcow2 8M`
- shell: 2 行，首行 `> $ sudo modprobe nbd`
- shell: 1 行，首行 `$ sudo qemu-nbd -c /dev/nbd0 ./rootfs.qcow2`
- shell: 1 行，首行 `$ sudo mkfs.ext4 /dev/nbd0`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

QCOW2 格式

搭建内核运行环境
使用 BusyBox 搭建基本的文件系统
打包文件系统
QCOW2 格式

pwn linux kernel-mode environment code:shell

搭建内核运行环境


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「Step.II - page-level heap fengshui」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`
标题：Cross-Cache Overflow & Page-level Heap Fengshui
章节：Cross-Cache Overflow & Page-level Heap Fengshui > 例题：corCTF2022 - cache-of-castaways > 漏洞利用 > Step.II - page-level heap fengshui
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Step.II - page-level heap fengshui”展开。
- setsockopt() 也可以帮助我们完成页级堆风水，当我们耗尽 buddy system 中的 low order pages 后，我们再请求的页面便都是物理连续的，因此此时我们再进行 setsockopt() 便相当于获取到了一块近乎物理连续的内存（为什么是”近乎连续“是因为大量的 setsockopt() 流程中同样会分配大量我们不需要的结构体，从而消耗 buddy system 的部分页面）。
- 释放掉之前的间隔内存页，调用漏洞函数分配堆块，这样便有几率获取到我们释放的间隔内存页。
- 利用模块中漏洞进行越界写，篡改 cred->uid ，完成提权。
- 间隔一张内存页释放掉部分单张内存页，之后堆喷 cred，这样便有几率获取到我们释放的单张内存页。
- 我们的子进程需要轮询等待自己的 uid 变为 root，但是这种做法并不优雅：) ，所以笔者这里选择用一个新的管道在主进程与子进程间通信，当子进程从管道中读出1字节时便开始检查自己是否成功提权，若未提权则直接 sleep 即可。

关键术语：
- 边界/溢出
- 堆
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

Step.II - page-level heap fengshui

Cross-Cache Overflow & Page-level Heap Fengshui

边界/溢出 堆 漏洞利用 pwn linux kernel-mode exploitation


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/browser/chrome/js-engine/v8.md` 中的章节「架构 & 编译管线」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/browser/chrome/js-engine/v8.md`
标题：V8 Engine Intro
章节：V8 Engine Intro > 架构 & 编译管线
路径分类：pwn / pwn/browser/chrome
分块：1/1

核心知识点：
- 本节主题围绕“架构 & 编译管线”展开。
- [图片文件: https://s2.loli.net/2025/03/09/Jx1al6Qbemqhuig.png]
- - 读入 JavaScript 源码后，Parser 首先会将其解析成 AST 这样的中间表示 - 中间表示会交给名为 Ignition Interpreter 的解释器进行翻译，生成简洁的字节码（大小仅为基准机器码的 25～50%） - JavaScript 是一门解释型语言，因此完成字节码翻译后会由 Ignition 进行解释执行 - 对于高频执行的或是处于其他原因被认为需要优化的代码，Ignition Interpreter 会将翻译后的字节码交由 TurboFan Compiler 进行即时编译（Ju...
- 此外，V8 Engine 当中还有一个特殊的设计叫 Deoptimization ：将 TurboFan 生成的机器码 _反向翻译回字节码，重新交回 Ignition 解释执行_ ，这通常出现于以下两种场景：
- - Eager Deoptimization：在类似 JIT code 执行出错（例如动态检查未通过）的情况下会出现，此时会立即放弃执行 JIT code，调用 deoptimizer 翻译回 bytecode，再交由 interpreter 解释执行 - Lazy Deoptimization：例如某个全局变量发生了改变，依赖该变量的代码会被认为需要 deoptimization，但只会先进行 patch，在执行到对应代码时再调用 deoptimizer

关键术语：
- 修复/缓解
- pwn
- browser
- chrome
- js-engine

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

架构 & 编译管线

V8 Engine Intro


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stack privot to bss segment, set esp = base_stage」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：stack privot to bss segment, set esp = base_stage
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“stack privot to bss segment, set esp = base_stage”展开。
- stack_size = 0x800 # new stack size is 0x800 base_stage = bss_addr + stack_size rop.raw('a' * offset) # padding rop.read(0, base_stage, 100) # read 100 byte to base_stage rop.migrate(base_stage) r.sendline(rop.chain())
- rop = ROP('./main_partial_relro_32') sh = "/bin/sh"
- plt0 = elf.get_section_by_name('.plt').header.sh_addr rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr dynsym = elf.get_section_by_name('.dynsym').header.sh_addr dynstr = elf.get_section_by_name('.dynstr').header.sh_addr

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- pwn
- linux
- user-mode
- stackoverflow

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

stack privot to bss segment, set esp = base_stage

边界/溢出 栈 ROP/JOP AI安全 pwn linux user-mode stackoverflow

ret2dlresolve


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/tricks/writable-root.md` 中的章节「直接改写根文件系统」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/writable-root.md`
标题：直接改写根文件系统
章节：直接改写根文件系统
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“直接改写根文件系统”展开。
- 因此在 CTF 比赛当中，一个小技巧便是首先查看文件系统的权限是否配好，对于存在此类情况的题目，我们可以直接改写文件系统根目录，从而使得部分恶意命令被通过 root 权限执行。
- 这种方法虽然不能让选手在第一时间理解出题人的意图，但可以让选手在第一时间得分。
- 部分题目由于出题人的疏忽，会导致题目所使用的文件系统的根目录对非特权用户是可写的，这通常是因为出题人对文件系统进行了规范度不够打包。
- 比较常见的是替换掉 /bin/poweroff ，因为在通用 kernel pwn 出题规范当中的 init 脚本的最后一句通常都使用该命令进行关机。

关键术语：
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

直接改写根文件系统

直接改写根文件系统


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「2016 0CTF zerostorage-待完成」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`
标题：Unsorted Bin Attack
章节：in order not to merge into top chunk > 2016 0CTF zerostorage-待完成
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“2016 0CTF zerostorage-待完成”展开。
- 这个题当时给了服务器的系统版本和内核版本，所以自己可以下一个一模一样的进行调试，这里我们就直接用自己的本地机器调试了。
- 但是在目前的Ubuntu 16.04 中，由于进一步的随机化，导致 libc 加载的位置与程序模块加载的位置之间的相对偏移不再固定，所以 BrieflyX 的策略就无法再次使用，似乎只能用 angelboy 的策略了。
- 这里我们以 2016 年 0CTF 的 zerostorage 为例，进行介绍。

关键术语：
- 堆
- 漏洞利用
- pwn
- linux
- user-mode
- heap

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

2016 0CTF zerostorage-待完成

in order not to merge into top chunk
2016 0CTF zerostorage-待完成

Unsorted Bin Attack


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「参考阅读」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`
标题：中级ROP
章节：中级ROP > BROP > 参考阅读
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“参考阅读”展开。
- http://ytliu.info/blog/2014/09/28/blind-return-oriented-programming-brop-attack-gong-ji-yuan-li/ - http://bobao.360.cn/learning/detail/3694.html - http://o0xmuhe.me/2017/01/22/Have-fun-with-Blind-ROP/

关键术语：
- 边界/溢出
- 栈
- ROP/JOP
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- stackoverflow

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

参考阅读

中级ROP


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/environment.md` 中的章节「安装 gdb」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/environment.md`
标题：简介
章节：pwn-related tools > 在本地直接搭建 CTF Pwn 做题环境 > 安装 gdb
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- Type "apropos word" to search for commands related to "word". (gdb) ` 若你的计算机尚未安装 gdb，则可以使用如下命令进行安装，请自行分辨你所使用的发行版。
- Type "show copying" and "show warranty" for details.
- Type "show configuration" for configuration details.
- gdb 在绝大部分 Linux 发行版上都已默认安装，你可以在 shell 中输入 gdb 命令进行确认（输入 q 退出）: ``shell $ gdb GNU gdb (GDB;
- GNU Debugger（GDB）是 GNU 项目开发的软件调试器，使用 gdb 我们可以很方便地对二进制程序进行动态调试。
- SUSE Linux Enterprise 15) 13.2 Copyright (C) 2023 Free Software Foundation, Inc.

关键术语：
- ROP/JOP
- AI安全
- pwn
- linux
- user-mode
- environment.md
- code:shell

代码/命令片段线索：
- shell: 16 行，首行 `$ gdb`
- shell: 1 行，首行 `sudo apt-get install -y gdb`
- shell: 1 行，首行 `sudo zypper install gdb`
- shell: 1 行，首行 `sudo yay -S gdb # 若未配置 AUR，你也可以使用 pacman -S gdb 进行安装`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

安装 gdb

pwn-related tools
在本地直接搭建 CTF Pwn 做题环境
安装 gdb

ROP/JOP AI安全 pwn linux user-mode environment.md code:shell

简介


[System] 你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md` 中的章节「总结」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md`
标题：House Of Einherjar
章节：House Of Einherjar > 原理 > 总结
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 这里我们总结下这个利用技术需要注意的地方 - 需要有溢出漏洞可以写物理相邻的高地址的 prev_size 与 PREV_INUSE 部分。
- 我们需要在目的 chunk 附近构造相应的 fake chunk，从而绕过 unlink 的检测。
- 我们需要计算目的 chunk 与 p1 地址之间的差，所以需要泄漏地址。
- 其实，该技术与 chunk extend/shrink 技术比较类似。

关键术语：
- 边界/溢出
- 堆
- 漏洞利用
- pwn
- linux
- user-mode
- heap

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。

总结

House Of Einherjar