do-analyze
对 jar-analyzer-engine 构建的 SQLite 数据库执行安全审计分析查询。支持方法调用搜索、调用链追踪、Spring 组件分析、字符串搜索、漏洞模式检测等。
Quellinformationen
- Repository
- jar-analyzer/jar-analyzer-claude
- Letzte Quellaktivität
- 20. März 2026 um 18:54
- Erkannte Sprache von SKILL.md
- Chinesisch
- Sterne
- 140
- Forks
- 8
Installationsoptionen
Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Quelldateien prüfen
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.
SKILL.md wird angezeigt
SKILL.md
Quellanweisungen · Schreibgeschützte Vorschau- name
- do-analyze
- description
- 对 jar-analyzer-engine 构建的 SQLite 数据库执行安全审计分析查询。支持方法调用搜索、调用链追踪、Spring 组件分析、字符串搜索、漏洞模式检测等。
# do-analyze — Jar Analyzer 数据库分析与安全审计
## 概述
在 `build-db` skill 构建好 `jar-analyzer.db` 后，使用本 skill 对数据库进行各类安全分析查询。
通过 SQL 查询 + 反编译验证的方式，实现方法调用搜索、调用链追踪、漏洞模式检测等功能。
## 前提条件
- 已使用 `build-db` skill 构建了 `jar-analyzer.db` 数据库
- 当前工作目录下存在 `jar-analyzer.db` 文件
- Java 8+ 可用（用于反编译验证）
## 数据库表结构
> **不要在本文件中重复描述数据库表结构。**
> 请参考 `<plugin_dir>/references/DATABASE.md` 获取完整的数据库 Schema、字段说明、表关联关系和常用查询模式。
## 重要约定
### 方法唯一标识（四元组）
任何方法节点必须通过 **四元组** 唯一标识：
```
(jar_id, class_name, method_name, method_desc)
```
> **禁止**仅用方法名进行 join 或追链，因为方法重载很常见。
### 类名格式
数据库中的类名使用 `/` 分隔（JVM 内部格式），而非 `.` 分隔：
- ✅ `com/example/controller/UserController`
- ❌ `com.example.controller.UserController`
### 方法描述符格式
使用 JVM 方法描述符格式：
- `(Ljava/lang/String;)V` = `void method(String)`
- `(Ljava/lang/String;I)Ljava/lang/String;` = `String method(String, int)`
- `()V` = `void method()`
## 分析操作流程（SOP）
### 执行 SQL 查询的方式
**优先使用 `sqlite3` 命令行工具**（直接、高效）：
```bash
# 单条查询
sqlite3 jar-analyzer.db "SELECT COUNT(*) FROM method_table;"
# 格式化输出（带表头、列对齐）
sqlite3 -header -column jar-analyzer.db "SELECT class_name, method_name FROM method_table LIMIT 10;"
# 多条查询
sqlite3 -header -column jar-analyzer.db <<'EOF'
SELECT 'JAR文件' AS type, COUNT(*) AS count FROM jar_table
UNION ALL
SELECT '类', COUNT(*) FROM class_table
UNION ALL
SELECT '方法', COUNT(*) FROM method_table;
EOF
# 输出为 CSV
sqlite3 -header -csv jar-analyzer.db "SELECT * FROM spring_method_table;" > routes.csv
```
**如果 `sqlite3` 不可用，使用 Python 作为备选**：
```python
import sqlite3
conn = sqlite3.connect('jar-analyzer.db')
cursor = conn.execute("SQL_QUERY_HERE")
for row in cursor:
print(row)
conn.close()
```
> 将上述代码写入临时 `.py` 文件执行，分析完成后删除临时文件。
### 常用分析场景与 SQL
#### 1. 项目概览 — 了解分析目标的基本信息
```sql
SELECT 'JAR文件' AS type, COUNT(*) AS count FROM jar_table
UNION ALL
SELECT '类', COUNT(*) FROM class_table
UNION ALL
SELECT '方法', COUNT(*) FROM method_table
UNION ALL
SELECT '方法调用', COUNT(*) FROM method_call_table
UNION ALL
SELECT '字符串常量', COUNT(*) FROM string_table
UNION ALL
SELECT 'Spring Controller', COUNT(*) FROM spring_controller_table
UNION ALL
SELECT 'Spring 映射', COUNT(*) FROM spring_method_table
UNION ALL
SELECT 'Servlet/Filter', COUNT(*) FROM java_web_table;
```
#### 2. 方法调用搜索 — 查找谁调用了某个方法
```sql
-- 查找谁调用了某个特定类的方法（精确搜索）
SELECT DISTINCT
caller_class_name, caller_method_name, caller_method_desc
FROM method_call_table
WHERE callee_class_name = 'java/lang/Runtime'
AND callee_method_name = 'exec';
-- 模糊搜索
SELECT DISTINCT
caller_class_name, caller_method_name,
callee_class_name, callee_method_name
FROM method_call_table
WHERE callee_class_name LIKE '%ClassName%'
AND callee_method_name LIKE '%methodName%';
```
#### 3. 方法定义搜索 — 查找某个方法定义在哪里
```sql
-- 精确搜索
SELECT class_name, method_name, method_desc, is_static, line_number
FROM method_table
WHERE method_name = 'execute';
-- 模糊搜索
SELECT class_name, method_name, method_desc, line_number
FROM method_table
WHERE method_name LIKE '%upload%'
OR method_name LIKE '%file%';
```
#### 4. 反向调用链追踪 — 从 sink 回溯到 entry
```sql
-- 使用 SQLite 递归 CTE 追踪调用链（推荐）
WITH RECURSIVE call_chain AS (
SELECT caller_class_name, caller_method_name, caller_method_desc,
callee_class_name, callee_method_name, callee_method_desc, 1 AS depth
FROM method_call_table
WHERE callee_class_name = 'java/lang/Runtime' AND callee_method_name = 'exec'
UNION ALL
SELECT mc.caller_class_name, mc.caller_method_name, mc.caller_method_desc,
mc.callee_class_name, mc.callee_method_name, mc.callee_method_desc, cc.depth + 1
FROM method_call_table mc
JOIN call_chain cc ON mc.callee_class_name = cc.caller_class_name
AND mc.callee_method_name = cc.caller_method_name
AND mc.callee_method_desc = cc.caller_method_desc
WHERE cc.depth < 10
)
SELECT DISTINCT caller_class_name, caller_method_name, depth
FROM call_chain
ORDER BY depth;
```
> 也可以编写 Python 脚本实现 DFS/BFS 调用链追踪，灵活度更高。
#### 5. Spring 入口分析
```sql
-- 列出所有 Spring Controller
SELECT class_name FROM spring_controller_table;
-- 列出所有 HTTP 映射（API 入口）
SELECT class_name, method_name, restful_type, path
FROM spring_method_table
ORDER BY path;
-- 查找特定 URL 模式的处理方法
SELECT class_name, method_name, method_desc, restful_type, path
FROM spring_method_table
WHERE path LIKE '%user%' OR path LIKE '%admin%';
```
#### 6. Java Web 组件分析
```sql
-- 列出所有 Servlet/Filter/Listener
SELECT type_name, class_name FROM java_web_table;
-- 只看 Filter（可能是安全过滤器）
SELECT class_name FROM java_web_table WHERE type_name = 'Filter';
```
#### 7. 字符串搜索 — 敏感信息检测
```sql
-- 搜索包含关键字的字符串（如密码、密钥等）
SELECT class_name, method_name, value
FROM string_table
WHERE value LIKE '%password%'
OR value LIKE '%secret%'
OR value LIKE '%key%'
OR value LIKE '%token%';
-- 搜索 JNDI/LDAP/RMI 相关字符串
SELECT class_name, method_name, value
FROM string_table
WHERE value LIKE '%jndi%' OR value LIKE '%ldap://%' OR value LIKE '%rmi://%';
-- 搜索 SQL 语句（可能有 SQL 注入风险）
SELECT class_name, method_name, value
FROM string_table
WHERE value LIKE '%SELECT%FROM%'
OR value LIKE '%INSERT%INTO%'
OR value LIKE '%UPDATE%SET%'
OR value LIKE '%DELETE%FROM%';
-- 搜索 IP 地址和 URL
SELECT class_name, method_name, value
FROM string_table
WHERE value LIKE '%://%'
OR value LIKE '%.%.%.%';
```
#### 8. 继承关系分析
```sql
-- 查找某个类的所有子类
SELECT class_name, super_class_name
FROM class_table
WHERE super_class_name LIKE '%AbstractController%';
-- 查找某个接口的所有实现类
SELECT class_name, interface_name
FROM interface_table
WHERE interface_name LIKE '%Serializable%';
-- 查找方法实现（接口方法 → 具体实现）
SELECT class_name, method_name, method_desc, impl_class_name
FROM method_impl_table
WHERE method_name = 'doFilter';
```
#### 9. 注解分析
```sql
-- 查找所有带特定注解的类/方法
SELECT class_name, method_name, anno_name
FROM anno_table
WHERE anno_name LIKE '%RequestMapping%'
OR anno_name LIKE '%GetMapping%'
OR anno_name LIKE '%PostMapping%';
-- 查找 Controller 类注解
SELECT class_name, anno_name
FROM anno_table
WHERE method_name IS NULL
AND anno_name LIKE '%Controller%';
```
#### 10. 漏洞 Sink 检测
> **Sink 定义文件**：`<plugin_dir>/references/dfs-sink.json`
>
> 该 JSON 文件包含完整的危险方法（sink）列表，每个条目包含 `className`、`methodName`、`methodDesc` 三个字段。
> 进行漏洞检测时，**必须读取并解析该文件**，然后基于其中的 sink 定义构造 SQL 查询。
**Sink 检测流程**：
1. 读取 `<plugin_dir>/references/dfs-sink.json` 文件
2. 解析 JSON 获取所有 sink 条目
3. 对每个 sink，查询 `method_call_table` 中是否存在调用：
```sql
-- 通用 sink 查询模板（根据 dfs-sink.json 中的条目填充参数）
SELECT DISTINCT
caller_class_name, caller_method_name, caller_method_desc
FROM method_call_table
WHERE callee_class_name = '<sink.className>'
AND callee_method_name = '<sink.methodName>'
AND callee_method_desc = '<sink.methodDesc>';
```
**dfs-sink.json 覆盖的漏洞类型**包括但不限于：
| 漏洞类型 | 典型 Sink |
|:---------|:----------|
| RCE（远程代码执行） | `Runtime.exec`、`ProcessBuilder.start`、`ScriptEngine.eval` |
| JNDI 注入 | `InitialContext.lookup`、`Context.lookup` |
| LDAP 注入 | `DirContext.search`、`LdapContext.search` |
| SQL 注入 | `Statement.execute/executeQuery/executeUpdate`、`Connection.prepareStatement/prepareCall` |
| 反序列化 | `ObjectInputStream.readObject`、`XMLDecoder.readObject`、`Yaml.load`、`JSON.parseObject`、`XStream.fromXML` 等 |
| 文件操作 | `FileInputStream/FileOutputStream/RandomAccessFile` 构造、`File.delete` |
| SSRF | `URL.openConnection`、`HttpURLConnection.connect` |
| 类加载 | `BCEL ClassLoader.loadClass` |
> 注意：dfs-sink.json 中的 `methodDesc` 是精确匹配的，确保查询时使用完整的描述符。
**批量 Sink 检测示例（Python）**：
```python
import json
import sqlite3
# 读取 sink 定义
with open('<plugin_dir>/references/dfs-sink.json', 'r') as f:
sinks = json.load(f)
conn = sqlite3.connect('jar-analyzer.db')
for sink in sinks:
cursor = conn.execute("""
SELECT DISTINCT caller_class_name, caller_method_name, caller_method_desc
FROM method_call_table
WHERE callee_class_name = ?
AND callee_method_name = ?
AND callee_method_desc = ?
""", (sink['className'], sink['methodName'], sink['methodDesc']))
results = cursor.fetchall()
if results:
print(f"\n=== {sink['boxName']} ===")
for row in results:
print(f" {row[0]}.{row[1]} {row[2]}")
conn.close()
```
### 反编译验证（关键步骤）
> **重要**：SQL 查询只能发现方法调用关系，无法判断数据流和上下文。
> **必须使用 `--decompile` 反编译可疑类的源码，从具体代码中确认问题是否真实存在。**
当通过 SQL 分析发现可疑调用后，使用反编译功能查看完整源码：
```bash
java -jar <plugin_dir>/bin/jar-analyzer-engine-1.2.0.jar \
-j <target_jar_path> \
-d <fully.qualified.ClassName>
```
> 类名使用 `.` 分隔格式（如 `com.example.MyController`），而非数据库中的 `/` 分隔格式。
> 数据库中查到的类名是 `/` 分隔的，需要替换为 `.` 再传给 `-d` 参数。
**反编译确认要点**：
- 查看可疑方法的完整实现，确认外部输入是否能到达危险调用
- 检查是否有参数校验、白名单过滤、安全沙箱等防护措施
- 确认调用路径上是否存在条件分支导致实际不可达
- 对于调用链中的每一跳，都建议反编译查看中间方法的逻辑
**示例**：SQL 查询发现 `com/example/controller/FileController` 的 `upload` 方法调用了 `FileOutputStream.<init>`，反编译确认：
```bash
java -jar <plugin_dir>/bin/jar-analyzer-engine-1.2.0.jar \
-j app.jar \
-d com.example.controller.FileController
```
查看反编译结果中 `upload` 方法是否对文件名做了路径穿越防护、文件类型校验等。
## 分析工作流建议
### 基本流程
1. **了解目标**：执行概览查询，了解项目规模和技术栈
2. **识别入口**：分析 Spring 映射、Servlet/Filter 等 HTTP 入口点
3. **检测 Sink**：读取 `dfs-sink.json`，批量检测所有已知危险方法调用
4. **追踪链路**：从 sink 向上追踪调用链，检查是否可从入口可达
5. **反编译确认**：**对链路上的关键类使用 `--decompile` 查看源码**，确认数据流是否可控、是否有安全防护
6. **字符串辅助**：搜索敏感字符串作为补充线索
7. **形成报告**：汇总发现的安全问题
### 优先级建议
| 优先级 | 漏洞类型 | 危害程度 |
|:-------|:---------|:---------|
| P0 | RCE（命令执行）、反序列化 | 严重 |
| P1 | SQL 注入、JNDI 注入、SpEL 注入 | 高 |
| P2 | SSRF、XXE、任意文件读写 | 高 |
| P3 | 文件上传、路径穿越 | 中 |
| P4 | 信息泄露、硬编码密钥 | 中 |
## 注意事项
- SQL 查询中的类名使用 `/` 分隔格式
- 反编译命令中的类名使用 `.` 分隔格式
- `method_desc` 是精确匹配的关键，避免因方法重载导致误判
- `callee_jar_id = -1` 表示被调用方法来自 JDK/外部库（不在分析的 JAR 中）
- 大型数据库查询可能较慢，建议使用 `LIMIT` 限制结果数量
- 优先使用 `sqlite3` 命令行查询，不可用时再使用 Python
- 分析完成后请删除临时脚本文件
Auf GitHub ansehen