Vuln Research

安全研究元思考方法论

从先知社区5600+篇安全文档中提炼的漏洞挖掘核心思维框架。

核心元思考模型

┌─────────────────────────────────────────────────────────────────────────┐
│                        安全研究思维金字塔                                │
├─────────────────────────────────────────────────────────────────────────┤
│  L4: 防御反推    ← 从补丁/过滤规则/安全机制反推绕过点                    │
│  L3: 边界探索    ← 在已知攻击面上寻找corner case                        │
│  L2: 假设验证    ← 构建推理链条，逐步验证假设                           │
│  L1: 攻击面识别  ← 寻找数据与指令不分离的接口                           │
└─────────────────────────────────────────────────────────────────────────┘

通用决策循环

输入点识别 → 上下文分析 → 假设构建 → payload构造 → 响应分析 → 迭代优化
     ↑                                                              │
     └──────────────────────────────────────────────────────────────┘

跨领域核心公式

---

快速导航

根据研究场景选择对应的方法论模块：

---

元思考原则

1. 假设-验证循环

所有安全研究都遵循：假设 → 测试 → 迭代优化

2. 边界条件思维

Corner case 是所有漏洞类型的共同温床

3. 防御反推

从已知防御措施反推攻击路径是高效的研究策略

4. 链式思维

单个漏洞价值有限，漏洞链才能完成完整攻击

5. 版本敏感

同一漏洞点在不同版本需要不同利用方法

6. 语义差异

不同组件对同一输入的解析差异是绕过的核心

---

使用指南

1. 确定研究目标：明确要分析的漏洞类型或攻击场景 2. 查阅对应模块：根据快速导航表选择合适的方法论文档 3. 应用元思考框架：使用L1-L4思维金字塔指导分析过程 4. 参考案例索引：查找相关CVE或技术的具体案例 5. 迭代优化：根据实际情况调整策略

---

核心洞察速查

Web安全

• 漏洞本质 = 数据指令分离失效
• JNDI版本边界：JDK 8u191 后需不同利用路径
• WAF绕过 = 语义差异利用

反序列化

• "万物皆可Gadget"：任何Serializable类都可能成为链的一环
• 二次反序列化是协议降级的关键（SignedObject）
• 黑名单必有遗漏，代理封装是高版本绕过通用思路

二进制安全

• 利用链本质：原语的组合与放大
• glibc版本决定可用技术（2.27 tcache、2.32 safe-linking）
• IO利用演进：vtable检查后，_wide_data成为突破口

域渗透

• SPN查询优于端口扫描（更精准更隐蔽）
• 委派配置错误可能导致整域沦陷
• 最隐蔽的攻击往往利用合法的域功能而非漏洞

逆向分析

• 逆向 = 信息熵降低过程
• VM保护三路径：opcode还原、z3约束、插桩爆破
• Triton + Z3 + AI 是 OLLVM 反混淆现代范式

红队攻防

• 完整链：边界突破→提权→穿透→横向→域控→维持
• "内网密码复用"是经验驱动的横向移动关键
• 云原生新攻击面：K8S hostPath + tolerations

公众号搜索“探微杜渐人工智能”

微信群已经满了 可以加我微信 拉你进群 <img width="200" alt="微信二维码" src="https://github.com/user-attachments/assets/3bc7a5b4-a975-4cda-be6d-b662b117cbea" />

🔐 安全研究元思考方法论

从先知社区 5621 篇安全文档中提炼的漏洞挖掘核心思维框架


---

📝 项目背景

继上次我们分析了 wooyun legacy skill 后，我们又做了一件事——把先知社区 5621 篇安全研究文章全部过了一遍。

不是为了学习具体的漏洞利用技巧（那些网上到处都是），而是想搞清楚一个问题：

顶尖安全研究员的思维方式到底有什么共性？

答案比我们想象的要简单，也更有价值。

但更重要的是——我们不想让这些洞察只停留在一篇文章里。我们把它做成了一个可复用的"Skill"，让 AI 能够像顶尖安全研究员一样思考。

---

00 为什么要做这件事？

之前的 wooyun legacy skill 解决的是漏洞发现的 corner cases 的覆盖问题，也就是 skill 能抽取 wooyun 漏洞里足够细的一些犄角旮旯的检测手段以及参数，解决的是具体执行的 corner cases 问题；而这次先知研究员 skill 解决的是方法论 corner cases 的问题，就像一群研究员一起讨论帮你解决问题一样。

LLM 不能彻底帮你解决这些问题，因为 LLM 无法覆盖具体的思维执行，比如就某个漏洞的研究方法，他的价值判断不如人类，而 skill 可以很好的把这些专家的价值判断落到硬盘里，你只需要加载对应的文件就行，但是他也有一个缺点，就是比较死，像是一个放大版的 workflow，这点是需要读者注意的。

那先说说我们的初衷。

安全行业有个痛点：知识传承效率太低。

一个资深研究员花了十年积累的经验，很难高效地传授给新人。写文章？新人看完记不住。带徒弟？一个人带不了几个。

我们在想：有没有可能把"专家的思维方式"提取出来，变成一种可以被 AI 调用的能力？

这就是我们做这个 Skill 的初衷——不是让 AI 掌握更多漏洞知识，而是让 AI 学会像专家一样思考问题。

具体来说，我们希望实现：

---

01 我们是怎么提取这个 Skill 的？

这里分享一下我们的方法论，也许对其他想做类似事情的团队有参考价值。

第一步：分类与聚类

5621 篇文章，我们先做了一轮人工分类：

第二步：抽象思维模式

分类完成后，我们不是去总结"有哪些漏洞类型"，而是去分析：作者在发现和利用这个漏洞时，经历了怎样的思维过程？

我们发现，尽管漏洞类型千差万别，但底层的思维模式高度相似。

比如，无论是挖 SQL 注入还是挖反序列化，高手都会：

1. 先识别输入入口（攻击面） 2. 然后追踪数据流向（假设验证） 3. 接着探索边界条件（边界探索） 4. 最后反推防御逻辑（防御逆向）

这就是我们后面会讲的"四层思维模型"的由来。

第三步：结构化输出

最后，我们把提炼出的思维模式，封装成了 Claude Code 可以调用的 Skill 格式。

这样做的好处是：当你用 Claude Code 做安全研究时，它不再是一个只会查资料的工具，而是一个具备专家思维方式的研究伙伴。

---

02 这个 Skill 怎么用？

说了这么多，具体怎么用呢？我们整理了六个典型场景。

场景一：漏洞挖掘思路卡住了

当你卡住的时候，可以让 AI 用这个 Skill 来引导你的思考。

/vuln-research 我在测试一个Java应用，找到了一个反序列化入口但不知道怎么利用

<img width="600" alt="场景一：漏洞挖掘思路" src="https://github.com/user-attachments/assets/32482679-ee04-491a-9af7-95cbe7ecbfb3" />

场景二：规划完整渗透路径

当你需要规划完整渗透路径时，可以让 AI 帮你串联各个模块。

/vuln-research 帮我规划从Web入口到域控的完整攻击路径

<img width="600" alt="场景二：渗透路径规划" src="https://github.com/user-attachments/assets/ffdeee4d-1b99-4142-a76b-ac50f046e5fd" />

场景三：分析一个新 CVE

当你需要快速理解一个新漏洞时。

/vuln-research 分析CVE-2024-XXXX的利用思路

场景四：代码审计找漏洞

当你需要系统性地审计代码时。

/vuln-research 拿到一套Spring Boot源代码应该如何审计

场景五：CTF 快速解题

当你需要快速找到利用思路时。

/vuln-research CTF中遇到Java反序列化题目，如何快速构造Gadget链

场景六：防御审计

反过来用，可以帮助防御方发现盲区。

/vuln-research 帮我用攻击者视角审计一下我们的Java应用安全

AI 调用 Skill 后会按攻击面逐一检查：

1. 反序列化风险：ObjectInputStream使用、Fastjson版本、XStream配置 2. 注入风险：SQL拼接、OGNL/SpEL表达式、模板引擎 3. 权限维持风险：是否有Agent加载入口、Filter动态注册能力 4. 供应链风险：依赖库版本、是否存在已知CVE

---

03 一个反直觉的发现

现在回到我们最初的问题：高手和新手的差距到底在哪？

我们原以为，差距在于知识量——高手懂得更多漏洞类型、掌握更多利用技巧。

但分析了几千篇文章后，我们发现：差距其实在于提问的方式。

举个例子。

面对同一个目标，新手的思维链条是这样的：

找到SQL注入点 → 尝试payload → 被WAF拦截 → 换payload → 还是被拦 → 放弃

而高手的思维链条是这样的：

找到SQL注入点 → 被WAF拦截 → 停下来想：WAF的检测逻辑是什么？
→ 它检测POST body，那Header呢？
→ X-Forwarded-For会写入日志表
→ 日志写入用的是预编译吗？
→ 不是，直接拼接
→ 二次注入！

看出区别了吗？

新手在技术层面打转，高手在认知层面跃迁。

这个跃迁，我们把它抽象成了一个四层模型。

---

04 四层思维模型

我们把安全研究中的思维活动，分成了四个层次：

大多数人卡在 L1 和 L2 之间来回打转。

高手的秘密是：当 L1-L2 走不通时，会主动跳到 L4。

这就是上面那个例子中发生的事情——被 WAF 拦截后，高手没有继续在 payload 层面较劲，而是切换到防御者视角，去思考"WAF 是怎么工作的"。

一旦理解了防御逻辑，绕过就变成了找盲区的游戏。

这就是我们说的"元认知"——不是思考问题本身，而是思考"我应该怎么思考这个问题"。

---

05 跨域攻击链：高手的组合拳

分析完单点突破的思维模式后，我们又发现了另一个规律：高手很少只用一种技术。

他们擅长把不同领域的技术串联起来，形成完整的攻击链。

这个表格的价值在于：当你在某个领域卡住时，可以考虑换一个领域突破。

我们内部把这个叫做"攻击链思维"：不要只想着单点突破，要想着如何把多个小漏洞串成一个大漏洞。

---

06 几条"元规律"

最后，分享几条我们从 5621 篇文章中提炼出的跨领域规律。

---

07 结构和能力边界

vuln-research/
├── SKILL.md                     # 主入口 - 元思考框架 (136行)
├── README.md                    # 本文档
└── references/                  # 专题模块 (9个文件, 1651行)
    ├── web-injection.md         # Web注入方法论
    ├── binary-exploitation.md   # 二进制安全
    ├── domain-pentest.md        # 域渗透
    ├── reverse-engineering.md   # 逆向分析
    ├── fuzzing.md               # Fuzzing方法论
    ├── privilege-bypass.md      # 提权/绕过
    ├── rce-persistence.md       # RCE与持久化
    ├── redteam-ctf.md           # 红队/CTF
    └── case-index.md            # CVE案例索引

总规模: 84KB, 11个文件, ~1880行

能力边界说明：

• ✅ 提供系统化的思维框架和方法论指导
• ✅ 覆盖主流安全研究领域
• ✅ 可作为 Claude Code Skill 直接调用
• ⚠️ 不提供具体的漏洞利用代码
• ⚠️ 需要配合实际技术能力使用

---

08 写在最后

回到开头那个问题：

顶尖安全研究员的思维方式到底有什么共性？

我们的答案是：

他们不是知道更多的漏洞，而是掌握了一套在未知领域快速建立认知框架的能力。

这也是我们做这个 Skill 的意义——把这种能力提取出来，让更多人能够借助 AI 获得专家级的思维引导。

我们相信，未来的安全研究，不再是人与工具的关系，而是人与 AI 协作的关系。

AI 不是来替代研究员的，而是来放大研究员能力的。

而这个 Skill，就是我们在这个方向上的一次尝试。

---

🚀 如何获取这个 Skill？

vuln-research skill 已开源，可以直接集成到 Claude Code 中使用。

安装方法

git clone https://github.com/tanweai/xianzhi-research.git ~/.claudeg/skills/vuln-research

使用方法

在 Claude Code 对话中：

/vuln-research 如何审计一套Spring Boot代码
/vuln-research Java反序列化Gadget链构造思路
/vuln-research 域渗透中的Kerberos攻击路径

也可以主动询问："用 vuln-research skill 帮我分析 xxx"

---

🧠 核心思维模型速览

┌─────────────────────────────────────────────────────────────────────────┐
│                        安全研究思维金字塔                                │
├─────────────────────────────────────────────────────────────────────────┤
│  L4: 防御反推    ← 从补丁/过滤规则/安全机制反推绕过点                    │
│  L3: 边界探索    ← 在已知攻击面上寻找corner case                        │
│  L2: 假设验证    ← 构建推理链条，逐步验证假设                           │
│  L1: 攻击面识别  ← 寻找数据与指令不分离的接口                           │
└─────────────────────────────────────────────────────────────────────────┘

🎯 跨领域核心公式

---

📚 模块索引

---

🔑 元思考原则

1. 假设-验证循环 — 所有安全研究都遵循：假设 → 测试 → 迭代优化 2. 边界条件思维 — Corner case 是所有漏洞类型的共同温床 3. 防御反推 — 从已知防御措施反推攻击路径是高效的研究策略 4. 链式思维 — 单个漏洞价值有限，漏洞链才能完成完整攻击 5. 版本敏感 — 同一漏洞点在不同版本需要不同利用方法 6. 语义差异 — 不同组件对同一输入的解析差异是绕过的核心

---

⚠️ 免责声明

本项目仅供安全研究和教育目的使用。使用者应遵守当地法律法规，在获得授权的情况下进行安全测试。作者不对任何滥用行为负责。

---

关于我们

探微杜渐安全研究团队，专注于 AI + 安全的交叉领域研究。

我们相信：让 AI 学会像专家一样思考，是提升整个行业效率的关键。

如果你也在做类似的事情，欢迎交流。

---

📄 License

MIT License

---

贡献者: 欢迎提交 Issue 和 PR 来完善方法论内容。

原创内容，转载请注明出处

二进制安全研究方法论

元思考框架

核心思维范式

漏洞本质 = 边界失控 + 状态不一致 + 信任假设违背

三层抽象模型：

利用思维递进模型

信息泄露 → 原语构造 → 控制流劫持 → 任意代码执行
   ↓           ↓           ↓            ↓
 地址获取    写原语      RIP控制     shellcode/ROP

核心洞察：每一步都是为下一步创造条件，利用链的本质是原语的组合与放大。

---

漏洞模式识别

栈溢出

识别checklist： 1. 危险函数: gets(), strcpy(), sprintf(), scanf("%s"), read()无边界 2. 栈布局分析: buffer到ebp/rbp的偏移 + 指针大小 = 返回地址偏移 3. 保护检查: checksec确认NX/Canary/PIE/ASLR状态

偏移计算公式（32位）：

offset = buffer_size + saved_ebp(4) = distance_to_ret

堆漏洞

格式化字符串

漏洞代码：printf(user_input); 正常代码：printf("%s", user_input);

利用能力：

• %p/%x：泄露栈上数据
• %s：泄露任意地址内容
• %n：向任意地址写入数据

---

保护绕过矩阵

ASLR绕过的信息泄露链

泄露libc地址的典型方法:
1. 格式化字符串: %p泄露栈上的libc地址
2. GOT泄露: 调用puts(puts_got)泄露puts真实地址
3. UAF泄露: free后的chunk进入unsorted bin，fd/bk指向main_arena
4. stdout泄露: 利用_IO_2_1_stdout_结构体

---

ROP技术谱系

┌─────────────────────────────────────────────────────────────┐
│                      ROP技术谱系                            │
├─────────────────────────────────────────────────────────────┤
│  ret2text ─────► 程序内有后门函数，直接跳转                 │
│       ↓                                                     │
│  ret2libc ─────► 利用libc中的system("/bin/sh")             │
│       ↓                                                     │
│  ret2syscall ──► 静态编译，直接构造系统调用                 │
│       ↓                                                     │
│  ret2csu ──────► gadget不足时，利用__libc_csu_init          │
│       ↓                                                     │
│  SROP ─────────► 利用sigreturn控制所有寄存器                │
│       ↓                                                     │
│  ret2dlresolve ► 无libc泄露，伪造延迟绑定结构               │
└─────────────────────────────────────────────────────────────┘

ret2libc标准流程（64位）

# 第一阶段: 泄露libc地址
payload1 = padding + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main)

# 第二阶段: 计算并调用system
libc_base = leaked_puts - libc.symbols['puts']
system = libc_base + libc.symbols['system']
binsh = libc_base + next(libc.search(b'/bin/sh'))
payload2 = padding + p64(pop_rdi) + p64(binsh) + p64(system)

---

House of系列

tcache poisoning

目标: 让tcache链表包含目标地址，使malloc返回任意地址

glibc 2.32+需要解密:
encrypted_ptr = (heap_addr >> 12) ^ target_addr

---

IO_FILE利用

演进思路

glibc 2.24之前: 直接伪造vtable
glibc 2.24-2.35: 利用_IO_str_overflow等合法函数
glibc 2.35+: _wide_data利用 (house_of_apple2)

House of Apple2核心

绕过思路：vtable检查只检查_IO_FILE的vtable，不检查_wide_data的vtable

利用链：

_IO_flush_all_lockp → _IO_wfile_overflow → _IO_wdoallocbuf → WDOALLOCATE

---

调试核心命令

# 基础检查
checksec ./binary

# pwndbg扩展
heap              # 查看堆布局
bins              # 查看所有bin
tcache            # 查看tcache
vmmap             # 查看内存映射

# ROPgadget
ROPgadget --binary ./binary --only "pop|ret"

案例索引

按技术类型和CVE分类的安全研究案例库，基于先知社区5600+篇文档提炼。

---

按漏洞类型分类

Web注入类

反序列化类

二进制安全类

域渗透/内网类

逆向分析类

代码审计类

---

按CVE分类

2024-2025年

2021-2023年

2020年及之前

---

按框架/组件分类

Java生态

PHP生态

基础设施

---

按攻击场景分类

边界突破到内网

红队实战

---

使用指南

1. 按技术点查找：根据需要研究的漏洞类型查找相关案例 2. 按CVE查找：研究特定漏洞时查找相关分析文章 3. 按框架查找：审计特定框架时参考已有案例 4. 按场景查找：规划攻击路径时参考实战案例

文档路径：/Users/xsser/Downloads/xzdocs_community/{案例ID}.{标题}/

域渗透/内网安全研究方法论

元思考框架

域渗透的本质认知

域渗透的核心是信任关系的滥用：

攻击者思维模型

边界突破 → 立足点建立 → 信息收集 → 权限提升 → 横向移动 → 域控攻击 → 权限维持
    ↑                                                                    ↓
    └────────────────── 持久化后门确保重入 ─────────────────────────────────┘

---

信息收集矩阵

域环境基础信息

SPN服务探测

核心洞察：SPN是Kerberos客户端标识服务的唯一方式，基于SPN的服务探测比端口扫描更精准且隐蔽。

setspn -T domain -Q */*                    # 查询域内所有SPN
setspn -T domain -Q */* | findstr "MSSQLSvc"  # 查询MSSQL
Get-NetUser -SPN | Select serviceprincipalname  # PowerView

BloodHound关键边缘

---

攻击路径决策树

普通域用户
    │
    ├─── [有SPN注册] ──→ Kerberoasting离线爆破
    │
    ├─── [AS-REP Roastable] ──→ 无预认证攻击
    │
    ├─── [可创建机器账户] ──→ RBCD攻击
    │
    ├─── [存在委派配置] ──→ 委派攻击
    │         ├─── 非约束委派: 捕获TGT
    │         └─── 约束委派: S4U2Self + S4U2Proxy
    │
    ├─── [ADCS配置不当] ──→ ESC1-ESC15证书攻击
    │
    └─── [存在漏洞] ──→ CVE利用
              ├─── MS14-068 (PAC伪造)
              ├─── CVE-2021-42287/42278 (sAMAccountName欺骗)
              └─── CVE-2020-1472 (ZeroLogon)

---

横向移动决策

---

Kerberos攻击矩阵

---

委派攻击

非约束委派

触发条件: 域管访问配置了非约束委派的机器
利用链: 控制机器 → 触发域控访问(打印机漏洞) → 捕获域控TGT → DCSync

约束委派

触发条件: 获取配置了约束委派的账户凭据
利用链: S4U2Self获取票据 → S4U2Proxy转发 → 访问目标服务

RBCD (基于资源的约束委派)

触发条件: 可创建机器账户 + 对目标有msDS-AllowedToActOnBehalfOfOtherIdentity写权限
利用链: 创建恶意机器账户 → 修改RBCD属性 → S4U2Self+S4U2Proxy → SYSTEM权限

---

持久化技术栈

推荐持久化组合

第一层: 黄金票据（快速恢复域管权限）
第二层: AdminSDHolder（普通用户即可恢复高权限）
第三层: SSP/DSRM（即使票据失效也可捕获新凭证）
第四层: RBCD变种黄金票据（KRBTGT改密也不影响）

---

ADCS证书攻击速查

---

核心洞察

1. 系统性思维：域渗透不是单点突破，而是信任链条的逐级瓦解 2. 杠杆效应：一个委派配置错误可能导致整个域的沦陷 3. 逆向思考：防守方关注的补丁和加固措施，恰恰指明了攻击方向 4. 隐蔽性悖论：最隐蔽的攻击往往利用的是合法的域功能而非漏洞

Fuzzing/漏洞发现方法论

元思考框架

核心认知模型

漏洞发现 = 攻击面识别 + 输入控制 + 状态异常触发 + 可利用性评估

关键思维转变

从CTF-Pwn到实战的认知跃迁：

• CTF提供明确的增删改查接口，实战需要逆向分析程序中的每一个堆操作
• 实战漏洞往往只能触发一次，需要精确的堆风水和状态控制
• 需要了解整个Linux机制，筛选出可控的堆操作来提升漏洞可用性

---

目标选择策略

高价值目标特征矩阵

目标选择决策流程

1. 识别输入入口点
   ├── 文件解析 (stdin/file)
   ├── 网络协议 (socket)
   ├── 命令行参数 (argv)
   └── 环境变量 (envp)

2. 评估复杂度与攻击面
   ├── 状态机复杂度 → 越复杂越容易出错
   ├── 边界条件数量 → 边界条件是漏洞温床
   └── 历史漏洞记录 → 同类问题往往重复出现

3. 确认可测试性
   ├── 源码可用性 → 插桩编译可行性
   ├── 反馈机制 → 覆盖率收集能力
   └── 执行效率 → 单次执行时间 < 1秒

---

输入构造与变异

覆盖率驱动机制

AFL++核心流程：

源码插桩 → 语料库变异 → 执行收集覆盖率 → 路径反馈优化

变异策略

特殊场景处理

命令行程序Fuzzing（sudo案例）：

问题：密码验证、参数控制、程序名切换

解决方案：
1. Patch密码验证函数，返回固定值
2. 使用AFL++的argv-fuzz-inl.h从stdin构建argv
3. 使用AFL_INIT_SET0("sudoedit")控制程序名

---

崩溃分析

从crash到可利用

crash分类
    │
    ├─── 空指针解引用 → 通常不可利用
    │
    ├─── 栈溢出 → 控制返回地址 → ROP
    │
    ├─── 堆溢出 → 破坏堆元数据 → 任意写
    │
    ├─── UAF → 控制freed内存 → 代码执行
    │
    └─── 整数溢出 → 导致其他内存错误

ASAN辅助

# 编译时启用
gcc -fsanitize=address -g target.c

# 运行时环境变量
ASAN_OPTIONS=detect_leaks=0:abort_on_error=1

---

CVE复现思维

1day分析流程

1. 补丁分析
   └─ 对比补丁前后的代码差异
   └─ 定位漏洞触发点

2. 环境搭建
   └─ 获取漏洞版本
   └─ 配置调试环境

3. 触发验证
   └─ 构造触发条件
   └─ 验证漏洞存在

4. 利用开发
   └─ 分析可利用性
   └─ 编写exploit

补丁分析技巧

• 关注边界检查：新增的长度/范围检查
• 关注初始化：新增的变量初始化
• 关注释放逻辑：新增的内存释放
• 关注权限检查：新增的权限验证

---

Fuzzing工具链

---

核心洞察

1. 目标选择是关键：解析器 > 协议处理 > 命令行工具 2. 状态机复杂度：越复杂越容易出错，边界条件是漏洞温床 3. 覆盖率驱动：AFL++ 插桩→变异→反馈→优化 是核心循环 4. CTF到实战：实战漏洞往往只能触发一次，需精确堆风水 5. 历史漏洞规律：同类问题往往重复出现，关注历史CVE模式

提权/绕过安全研究方法论

元思考框架

提权的本质

提权 = 突破当前权限边界，获取更高权限的访问能力

---

提权向量识别

Windows提权向量

Linux提权向量

内核漏洞提权

---

WAF绕过策略

绕过思维模型

WAF检测逻辑 → 找到检测盲区 → 构造绕过payload
     ↓              ↓              ↓
  规则分析      语义差异利用     验证绕过

通用绕过技术

特定WAF绕过

---

EDR/AV绕过

免杀技术层次

指令级(等价替换) → 结构级(控制流平坦化) → 数据级(多算法加密) → 噪音注入

绕过技术矩阵

进程注入技术

---

沙箱绕过

沙箱检测六维度

父进程伪造

// 使用STARTUPINFOEX指定父进程
STARTUPINFOEXW si = { sizeof(si) };
UpdateProcThreadAttribute(si.lpAttributeList,
    PROC_THREAD_ATTRIBUTE_PARENT_PROCESS,
    &hParentProcess, sizeof(HANDLE), NULL, NULL);

---

核心洞察

1. 提权是权限边界的突破：从配置错误到内核漏洞，层层递进 2. WAF绕过靠语义差异：不同组件对同一输入的解析差异 3. 免杀是持续对抗：静态→动态→行为，检测和绕过不断演进 4. 沙箱检测六维度：用户名、调试器、VM、资源、时间、父进程 5. 直接系统调用：绕过用户态hook的终极手段

RCE/持久化安全研究方法论

元思考框架

攻击链思维模型

┌─────────────────────────────────────────────────────────────────┐
│                     攻击链思维模型                                │
├─────────────────────────────────────────────────────────────────┤
│  入口点发现 → 漏洞触发 → 代码执行 → 权限维持 → 隐蔽驻留          │
│      ↓           ↓           ↓           ↓           ↓          │
│  信息收集     RCE触发     命令执行     持久化     免杀对抗        │
│  资产测绘     链式利用     内存马       后门      流量混淆        │
└─────────────────────────────────────────────────────────────────┘

三层对抗模型

---

RCE触发点识别矩阵

Java生态

Fastjson2 RCE绕过（双代理链）

攻击链路径：
JSONObject.toString()
  → getters()遍历
    → [黑名单检测: TemplatesImpl被拦截]
      → 绕过：JdkDynamicAopProxy代理
        → Templates接口不在黑名单
          → invoke()委托给真实对象
            → TemplatesImpl.getOutputProperties()
              → 恶意字节码加载 → RCE

关键绕过原理：检测逻辑只校验代理接口，不检查被代理的真实对象

Node.js/前端生态

---

内存马类型与注入原理

Java内存马分类体系

                    Java内存马技术栈
                          │
        ┌─────────────────┼─────────────────┐
        │                 │                 │
   Web组件型           框架型            Agent型
        │                 │                 │
  ┌─────┼─────┐     ┌─────┼─────┐    ┌─────┼─────┐
  │     │     │     │     │     │    │     │     │
Servlet Filter Listener Controller Interceptor redefine retransform

组件生命周期决定注入策略

获取StandardContext

HttpServletRequest.getServletContext()
    → context (ApplicationContext)
        → context (StandardContext) // 反射获取

Agent内存马攻防博弈

                      JvmtiEnv链结构
                           │
    ┌──────────────────────┼──────────────────────┐
    │                      │                      │
no-retransformable     retransformable       攻击者注入
    jvmti链                jvmti链              的jvmti
    │                      │                      │
 普通transformer      canRetransform=true    最后执行位置
    │                      │                      │
  先执行               后执行                决定隐蔽性

核心发现：

• 链末尾位置决定检测可见性
• "借尸还魂"技术：复用已存在的JvmtiEnv，无需新注入Agent
• 保证自己始终在链末尾，修改后自我卸载

Next.js内存马（原型污染）

// Header隐蔽路由（不依赖固定URL）
Accept: image/webp,*/*
Accept-Encoding: gzip, deflate, br, gzipp  // 'gzipp'为识别标记

// 技术创新点：
// 1. 修改http.Server.prototype.emit全局拦截请求
// 2. 日志中看起来像正常图片请求
// 3. WAF难以基于路径规则拦截

---

Webshell免杀技术栈

JSP免杀

PHP免杀（异或+变量函数）

<?php
$_=('%01'^'`').('%13'^'`').('%07'^'`').('%05'^'`').('%20'^'`');  // _GET
@${$_}[_](${$_}[__]);  // 等价于 $_GET[_]($_GET[__])

多层次免杀技术矩阵

┌─────────────────────────────────────────────────────────────┐
│                    免杀技术层次模型                           │
├─────────────────────────────────────────────────────────────┤
│ 指令级 │ 指令等价替换、寄存器重分配                           │
├────────┼────────────────────────────────────────────────────┤
│ 结构级 │ 指令序列重组、控制流平坦化                           │
├────────┼────────────────────────────────────────────────────┤
│ 数据级 │ 多算法字符串加密（XOR/AES/Base64轮换）              │
├────────┼────────────────────────────────────────────────────┤
│ 噪音级 │ 智能垃圾指令插入、死代码注入                         │
├────────┼────────────────────────────────────────────────────┤
│ 策略级 │ 策略组合引擎、动态变异、多态生成                     │
└────────┴────────────────────────────────────────────────────┘

控制流平坦化

原始控制流:          平坦化后:
    ↓                   ↓
  func1()          ┌─ dispatcher ─┐
    ↓              │   switch(state)  │
  func2()          │  case 1: func1() │
    ↓              │  case 2: func2() │
  func3()          │  case 3: func3() │
                   └──────────────────┘

效果：绕过微步、360云沙箱等检测

---

持久化决策矩阵

Linux持久化技术

eBPF后门技术（SSH密钥劫持）

攻击流程:
1. Hook read系统调用入口(sys_enter_read)
2. 记录进程名为sshd的read调用参数
3. 在read返回时(sys_exit_read)检查buffer内容
4. 如果包含"ssh-rsa"，替换为攻击者公钥
5. 实现免密登录后门

技术优势：
- 运行在内核沙箱中，稳定安全
- 无文件落地，难以检测
- 需要较高版本内核支持

持久化选择决策树

                    目标环境
                       │
         ┌─────────────┼─────────────┐
         │             │             │
      Windows        Linux        容器
         │             │             │
    ┌────┼────┐   ┌────┼────┐   ┌────┼────┐
    │    │    │   │    │    │   │    │    │
  域环境 单机 云  内核高 内核低  K8s Docker
    │    │    │   │    │    │   │    │
   DCSync 注册表 RDP后门 eBPF SSH后门 挂载卷 镜像投毒
  委派攻击 服务  IAM    模块  定时任务 sidecar

---

Rootkit技术层次

LD_PRELOAD劫持检测

# 常规检测
strace -f /bin/ls 2>&1 | grep preload

# 对抗方法：使用busybox（静态编译，不受劫持影响）
./busybox ls

---

核心规律提炼

规律一：复杂度即机会

• 功能越多，攻击面越大
• 解析器/引擎是RCE高发区

规律二：时序决定可见性

• 先加载的检测后加载的修改
• 内存马检测的本质是时序竞争

规律三：抽象层越高，防御越难

• 内核态对用户态天然不可见
• eBPF/Rootkit难以用常规手段检测

规律四：特征变形vs行为本质

• 静态特征可无限变形
• 行为才是恶意软件的本质
• 最终防御应基于行为而非签名

---

代表性案例索引

红队攻防/CTF方法论

红队攻防思维

完整攻击链

边界突破 → 权限提升 → 内网穿透 → 横向移动 → 域控攻击 → 权限维持
    ↓          ↓          ↓          ↓          ↓          ↓
 Web漏洞   Potato系    代理隧道    密码复用   Zerologon   黄金票据
 服务CVE   Mimikatz   Stowaway    PTH/PTT    krbtgt      持久化

各阶段核心技术

阶段一：边界突破

阶段二：权限提升

• Windows：Potato系列提权、PsExec提升至SYSTEM
• Linux：SUID、sudo配置、内核漏洞
• 密码抓取：Mimikatz抓取明文/Hash

阶段三：内网穿透

阶段四：横向移动

核心洞察："内网里的服务器账号密码有部分可能是相同的" —— 经验驱动的横向移动思维

阶段五：域控攻击

• CVE-2020-1472 (ZeroLogon)：置空域控机器账户NTLM Hash
• CVE-2021-42287/42278：sAMAccountName欺骗
• 黄金票据：获取krbtgt的NTLM Hash制作永久后门

无CS/MSF场景的替代

问题：目标不出网，无法使用常规C2

替代方案：
├── 正向连接木马（目标不出网时）
├── certutil远程下载
├── 原生Windows工具利用（Living off the Land）
└── PowerShell Empire内存执行

---

CTF解题思维

核心思维模式

分类解题方法论

Web方向

• 路径穿越：../../构造访问非预期资源
• 编码绕过：双重URL编码、Unicode编码
• 序列化攻击：Phar反序列化、Fastjson
• 代码审计链：源码泄露 → 路由分析 → 危险函数 → Payload

Crypto方向

Pwn方向

• 栈溢出 → ROP → ret2libc/ret2syscall
• 堆利用 → tcache poisoning → 任意地址分配
• 格式化字符串 → 任意读写

---

云安全攻防

对象存储(S3/OBS)攻击面

1. Bucket暴力猜解（NoSuchBucket vs AccessDenied）
2. 对象遍历（ListBucket权限泄露）
3. ACL策略可写（Everyone写ACL）
4. 策略冲突（桶策略与桶ACL配置不一致）

关键发现：

• --no-sign-request参数可绕过某些认证检查
• X-Forwarded-For可绕过IP限制的ListBucket
• Referer头部Fuzzing绕过防盗链

IAM安全挑战

Cognito身份池利用：

# 获取身份ID
aws cognito-identity get-id --identity-pool-id "us-east-1:xxx"
# 获取临时凭据
aws cognito-identity get-credentials-for-identity --identity-id "xxx"

K8S云原生渗透

攻击路径：

普通用户 → 创建Pod(挂载hostPath) → Node权限 → 容忍度绕过 → Master权限

核心技术：

• hostPath挂载Node根目录
• tolerations绕过Master污点(Taints)
• kubeconfig配置文件利用

---

应急响应方法论

标准化排查流程

日志分析 → 异常账户 → 恶意文件 → 后门清除 → 加固修复

关键排查点

---

核心洞察

1. 链式思维：单个漏洞价值有限，漏洞链才能完成完整攻击 2. 经验驱动："内网密码复用"是横向移动的重要经验判断 3. 无工具场景：无CS/MSF时用certutil+正向连接替代 4. 云原生攻击面：K8S的hostPath+tolerations是新突破口 5. 隐蔽性悖论：最隐蔽的攻击利用合法功能而非漏洞

逆向分析安全研究方法论

元思考框架

逆向分析的本质

逆向分析 = 信息熵降低过程：将未知二进制行为映射到已知模式库

分析策略决策树

样本获取 → 初步分类 → 策略选择 → 深入分析 → 行为提取 → 规则编写
              ↓
         ┌────────────┐
         │ 静态优先？ │
         │ 动态优先？ │
         │ 混合分析？ │
         └────────────┘

---

样本分类决策

文件头魔数识别

查壳与编译器识别

恶意行为模式速查

---

分析策略选择

静态分析思维框架

1. 字符串提取 → 快速定位关键功能
2. 导入表分析 → 判断程序能力
3. 函数识别 → 定位关键代码
4. 控制流分析 → 理解程序逻辑
5. 数据流分析 → 追踪敏感数据

动态调试策略

工具链组合

---

反混淆思维

常见混淆技术与对抗

VM类保护分析方法

三条路径：

1. opcode还原（传统）

• 分析VM入口、dispatcher、handler
• 逐个识别虚拟指令含义
• 还原原始逻辑

2. z3约束求解（数学）

• 将VM执行建模为约束
• 使用SMT求解器求解
• 适合简单变换

3. 插桩爆破（侧信道）

• Unicorn模拟执行
• 逐字符爆破输入
• 根据执行路径差异判断

OLLVM反混淆范式

Triton符号执行 → AST提取 → Z3/AI化简 → 算法还原

---

沙箱绕过六维度

恶意软件常用的沙箱检测技术：

---

脱壳方法论

通用脱壳方法

---

免杀技术层次

指令级 → 结构级 → 数据级 → 噪音注入
   ↓         ↓         ↓         ↓
等价替换  控制流平坦化  多算法加密  垃圾代码

---

C2通信分析

通信协议识别

加密通信分析

1. 定位加密函数：断点CryptEncrypt、SSL_write等 2. 提取密钥：内存搜索、动态调试 3. 协议逆向：分析包结构、字段含义

---

核心洞察

1. 逆向是信息熵降低：将未知映射到已知模式库 2. VM对抗三路径：opcode还原、z3约束、插桩爆破各有适用场景 3. 动态调试精髓：EXE附加绕TLS，ELF远程调试，APK加debuggable 4. AI辅助逆向：Triton + Z3 + AI 是 OLLVM 反混淆现代范式 5. 沙箱六维度：恶意软件的标配检测，需逐一识别分析

Web注入类安全研究方法论

元思考框架

核心认知模型

┌─────────────────────────────────────────────────────────────────┐
│                     安全研究思维金字塔                            │
├─────────────────────────────────────────────────────────────────┤
│  L4: 防御反推    ← 从补丁/过滤规则反推绕过点                      │
│  L3: 边界探索    ← 在已知攻击面上寻找corner case                  │
│  L2: 假设验证    ← 构建推理链条，逐步验证假设                     │
│  L1: 攻击面识别  ← 寻找数据与指令不分离的接口                     │
└─────────────────────────────────────────────────────────────────┘

关键思维原则

---

攻击面识别模式

SQL注入识别

输入点特征： 1. 参数直接拼接SQL语句的位置 2. 动态表名/列名/排序字段 3. 批量操作接口（IN子句） 4. 搜索/过滤功能 5. 文件名/路径参数被存入数据库

快速验证序列：

-- 闭合探测
?id=1'           -- 单引号闭合
?id=1"           -- 双引号闭合
?id=1')          -- 带括号闭合
?id=1\           -- 转义符探测

-- 布尔差异验证
?id=1' or 1=1#   -- 真条件
?id=1' and 1=2#  -- 假条件
?id=1' and sleep(5)#  -- 时间差异

数据库指纹：

JNDI注入识别

触发点特征：

InitialContext.lookup(userInput)
Context.lookup(userInput)
JndiTemplate.lookup(name)  // Spring

版本边界（关键）：

模板注入(SSTI)识别

Jinja2探测：

{{config}}          # Flask配置对象
{{request}}         # 请求对象
{{[].__class__.__base__.__subclasses__()}}  # 类链探测

Thymeleaf触发：

viewName包含::时解析为片段表达式
__${expression}__::x  # 预处理表达式

命令注入识别

高危功能点：

• ping/trace测试功能
• 文件操作接口（压缩、解压）
• 系统管理接口
• 定时任务配置
• 外部程序调用接口

截断符：; | || && & \ $() %0a %0d`

---

WAF绕过策略树

                    ┌─ 大小写混写: UnIoN SeLeCt
                    ├─ 双写绕过: uniunionon
         关键字过滤 ─┼─ 编码绕过: hex/base64/char()
                    ├─ 注释插入: un/**/ion
                    └─ 同义替换: || 代替 or

                    ┌─ ${IFS}系列: cat${IFS}file
                    ├─ 注释符: select/**/database()
         空格过滤 ──┼─ 括号嵌套: select(database())
                    ├─ 换行符: %0a %0d
                    └─ 反引号: `select`

                    ┌─ 宽字节注入: %df%27
         引号过滤 ──┼─ 反斜杠逃逸: admin\' and password='
                    └─ 十六进制: 0x61646D696E

                    ┌─ from...for: substr(x from 1 for 1)
         逗号过滤 ──┼─ offset: limit 1 offset 2
                    └─ join别名技术

---

Corner Case 思维

编码层面

• 双重URL编码
• Unicode变体（%u0027）
• 宽字节（GBK环境 %df%27）

语法层面

• 注释嵌套 /*!50000select*/
• 科学计数法 1e0union
• 浮点数 1.0union

协议层面

• HTTP参数污染
• 分块传输编码
• Content-Type混淆

---

代表性案例索引