opencode-api-security-testing 2.0.0 → 2.1.1

package/references/validation.md

@@ -1,425 +1,78 @@
-# 漏洞验证标准
+# Validation Guidance
 
-## 漏洞验证流程
+验证和分类发现。
 
-```
-发现 → 分析 → 验证 → 定级 → 报告
+## 报告标准
 
-     ┌─────────────────────────────────┐
-     │          发现 (Discover)          │
-     │  - 可疑响应差异                   │
-     │  - 异常状态码                     │
-     │  - 敏感信息暴露                   │
-     └─────────────┬───────────────────┘
-                   ▼
-     ┌─────────────────────────────────┐
-     │          分析 (Analyze)          │
-     │  - 多次请求确认差异稳定           │
-     │  - 对比正常/异常请求              │
-     │  - 排除 WAF/路由/认证             │
-     └─────────────┬───────────────────┘
-                   ▼
-     ┌─────────────────────────────────┐
-     │          验证 (Verify)           │
-     │  - 10 维度检查                   │
-     │  - 证据收集                      │
-     │  - 确认或排除                     │
-     └─────────────┬───────────────────┘
-                   ▼
-     ┌─────────────────────────────────┐
-     │          定级 (Severity)         │
-     │  - CVSS 评分                     │
-     │  - 业务影响评估                   │
-     │  - 修复优先级                     │
-     └─────────────┬───────────────────┘
-                   ▼
-     ┌─────────────────────────────────┐
-     │          报告 (Report)           │
-     │  - 漏洞详情                      │
-     │  - 复现步骤                      │
-     │  - 修复建议                      │
-     └─────────────────────────────────┘
-```
+仅报告有足够支持的问题：
 
----
+### 必须包含
 
-## 10 维度验证检查表
+- **受影响资产**: 具体的 API endpoint 或操作
+- **证据**: 请求/响应样本
+- **复现路径**: 清晰的步骤
+- **影响**: 现实世界的影响
+- **置信级别**: 确认/高/中/低/假设
 
-| 维度 | 检查项 | 通过条件 | 典型误报 |
-|------|--------|----------|----------|
-| **D1 响应类型** | 是 JSON 还是 HTML? | JSON 响应包含业务数据 | HTML 页面 (WAF/SPA) |
-| **D2 状态码** | 状态码是否合理? | 与漏洞场景匹配 | 302 重定向 |
-| **D3 响应长度** | 响应长度是否正常? | 长度 > 100 字节 | 过短响应 (拦截) |
-| **D4 WAF 识别** | 是否为 WAF 拦截? | 无 WAF 特征 | HTML 拦截页 |
-| **D5 敏感信息** | 是否包含敏感字段? | 字段不属于测试数据 | 测试假数据 |
-| **D6 一致性** | 多次请求是否一致? | 多次响应相同 | 不稳定响应 |
-| **D7 SQL 注入** | 是否包含 SQL 错误? | 无 SQL 错误特征 | 通用错误信息 |
-| **D8 IDOR** | 是否返回他人数据? | 返回数据属于他人 | 返回自己的数据 |
-| **D9 认证绕过** | 是否返回 token/session? | Token 有效且可用 | 无效/过期 Token |
-| **D10 信息泄露** | 是否泄露非公开信息? | 信息非公开 | 公开信息 |
+### 证据不完整时
 
----
+- 标记为假设 (hypothesis)、弱信号 (weak signal) 或可能问题 (likely issue)
+- 明确解释确认所需内容
 
-## 各类型漏洞验证标准
+### 不要
 
-### SQL 注入
+- 从模糊行为夸大严重性
+- 基于不完整的证据做强声明
+- 假设最坏情况
 
-```python
-# 验证标准
-SQLI_VERIFICATION = {
-    # 必须满足
-    'required': [
-        '响应包含数据库错误信息',
-        'UNION 查询有回显',
-        '时间盲注有延迟',
-    ],
-    # 参考指标
-    'indicators': [
-        '错误信息包含 SQL 关键词',
-        '响应时间 > 5秒 (盲注)',
-        '页面结构与正常响应不同 (UNION)',
-    ],
-    # 排除条件
-    'exclude': [
-        '通用错误信息 (无 SQL 关键词)',
-        'WAF 拦截页面',
-        '响应时间正常但无其他特征',
-    ]
-}
+## 置信级别
 
-# 验证步骤
-def verify_sqli(url, param, payload):
-    # 1. 原始请求 (基线)
-    baseline = requests.get(url, params={param: "1"})
-    
-    # 2. 注入测试
-    inject = requests.get(url, params={param: payload})
-    
-    # 3. 对比分析
-    indicators = {
-        'sql_error': contains_sql_error(inject.text),
-        'response_diff': baseline.text != inject.text,
-        'data_leak': extract_data(inject.text),  # UNION 注入时
-        'time_delay': measure_time(inject),  # 盲注时
-    }
-    
-    # 4. 综合判断
-    if indicators['sql_error'] or indicators['data_leak'] or indicators['time_delay'] > 5:
-        return True, indicators
-    return False, indicators
-```
+| 级别 | 标准 |
+|------|------|
+| **确认 (Confirmed)** | 完整的 PoC、明确的证据 |
+| **高 (High)** | 强指标、合理推断 |
+| **中 (Medium)** | 中等指标、需要更多验证 |
+| **低 (Low)** | 弱指标、可能是误报 |
+| **假设 (Hypothesis)** | 基于观察的推断、需要进一步调查 |
 
-### XSS
+## 影响评估
 
-```python
-# 验证标准
-XSS_VERIFICATION = {
-    'required': [
-        'Payload 未经处理回显',
-        '可执行 JavaScript',
-    ],
-    'indicators': [
-        'Payload 在响应中完整回显',
-        '<script> 标签未转义',
-        '事件处理器未被过滤',
-    ],
-    'exclude': [
-        'HTML 实体转义',
-        '<script> 被删除/过滤',
-        'CSP 阻止执行',
-    ]
-}
+### 考虑
 
-# 验证步骤
-def verify_xss(url, param, payload):
-    # 1. 发送 XSS Payload
-    resp = requests.get(url, params={param: payload})
-    
-    # 2. 检查回显
-    if payload in resp.text:
-        # 3. 检查是否是存储型
-        # 用另一请求检查是否持久化
-        resp2 = requests.get(url)  # 再次访问
-        
-        if payload in resp2.text:
-            return True, {'type': 'stored', 'persisted': True}
-        return True, {'type': 'reflected', 'persisted': False}
-    
-    return False, {'type': None}
-```
+- 攻击复杂度
+- 用户交互需求
+- 数据敏感性
+- 受影响用户数量
+- 财务/合规影响
 
-### IDOR
+### 避免
 
-```python
-# 验证标准
-IDOR_VERIFICATION = {
-    'required': [
-        '用自己的 Token 访问他人资源',
-        '返回他人敏感数据',
-    ],
-    'indicators': [
-        '资源 ID 可枚举',
-        '响应包含不同用户数据',
-        '无权限检查错误',
-    ],
-    'exclude': [
-        '返回 401/403',
-        '返回空数据',
-        '返回自己的数据',
-    ]
-}
+- 夸大威胁
+- 基于假设的影响
+- 不切实际的利用场景
 
-# 验证步骤
-def verify_idor(base_url, token, victim_resource_id):
-    # 1. 自己的资源 (基线)
-    headers = {'Authorization': f'Bearer {token}'}
-    my_resource = requests.get(
-        f'{base_url}/resource/1',
-        headers=headers
-    )
-    
-    # 2. 他人的资源 (测试)
-    victim_resource = requests.get(
-        f'{base_url}/resource/{victim_resource_id}',
-        headers=headers
-    )
-    
-    # 3. 对比分析
-    if victim_resource.status_code == 200:
-        my_data = my_resource.json()
-        victim_data = victim_resource.json()
-        
-        # 检查是否是不同用户的数据
-        if my_data.get('userId') != victim_data.get('userId'):
-            return True, {
-                'my_user': my_data.get('userId'),
-                'victim_user': victim_data.get('userId'),
-                'leaked_fields': list(victim_data.keys())
-            }
-    
-    return False, {'status': victim_resource.status_code}
-```
+## 验证技术
 
-### JWT 漏洞
+### 认证问题
 
-```python
-# 验证标准
-JWT_VERIFICATION = {
-    'alg_none': {
-        'required': ['使用 alg:none 的 Token 可正常使用'],
-        'test': '去除签名的 Token 可通过验证',
-    },
-    'key_confusion': {
-        'required': ['使用公钥作为对称密钥可伪造 Token'],
-        'test': 'RS256 算法可被转换为 HS256',
-    },
-    'weak_secret': {
-        'required': ['弱密钥可被暴力破解'],
-        'test': '常见密钥可成功签名',
-    },
-    'kid_injection': {
-        'required': ['kid 参数存在 SQL/NoSQL 注入'],
-        'test': '利用 kid 注入读取任意密钥',
-    },
-}
+- 验证 token 伪造是否可能
+- 测试会话管理缺陷
+- 确认账户接管场景
 
-def verify_jwt_alg_none(token):
-    header = decode_header(token)
-    if header.get('alg') == 'none':
-        # 尝试去除签名
-        unsigned_token = create_unsigned_token(header, payload)
-        if is_valid(unsigned_token):
-            return True, {'alg': 'none', 'exploitable': True}
-    return False, {}
-```
+### 授权问题
 
-### 敏感信息泄露
+- 测试 IDOR 是否可利用
+- 验证水平/垂直越权
+- 确认权限提升路径
 
-```python
-# 验证标准
-SENSITIVE_DATA_VERIFICATION = {
-    'password': {
-        'required': ['响应包含明文密码'],
-        'severity': 'Critical',
-        'exclude': ['密码已加密/哈希', '测试数据密码'],
-    },
-    'token': {
-        'required': ['响应包含有效 Token'],
-        'severity': 'High',
-        'exclude': ['过期 Token', '测试 Token'],
-    },
-    'api_key': {
-        'required': ['响应包含有效 API 密钥'],
-        'severity': 'High',
-        'exclude': ['测试环境密钥'],
-    },
-    'internal_ip': {
-        'required': ['响应包含内网 IP 地址'],
-        'severity': 'Medium',
-    },
-    'internal_url': {
-        'required': ['响应包含内部系统 URL'],
-        'severity': 'Medium',
-    },
-}
+### 输入处理
 
-def verify_sensitive_data(resp, field_name):
-    sensitive_fields = {
-        'password', 'passwd', 'pwd', 'secret',
-        'token', 'api_key', 'apikey', 'private_key',
-        'ssn', 'id_card', 'phone', 'email',
-    }
-    
-    if field_name.lower() in sensitive_fields:
-        # 检查值是否存在
-        value = resp.json().get(field_name)
-        if value and value not in ['', 'null', 'undefined']:
-            return True, {'field': field_name, 'severity': get_severity(field_name)}
-    
-    return False, {}
-```
+- 使用安全 payload 验证
+- 确认漏洞触发条件
+- 评估利用难度
 
----
+### 数据泄露
 
-## 误报排除规则
-
-### 规则 1: WAF 识别
-
-```python
-WAF_PATTERNS = [
-    # 通用 WAF
-    r'(?i)(waf|firewall|attack|blocked|intercepted)',
-    r'(?i)(forbidden|access.*denied|security)',
-    # 特定 WAF
-    r'Aliyun',
-    r'Tencet',
-    r'AWS.*WAF',
-    r'Cloudflare',
-    r'Incapsula',
-]
-
-def is_waf_response(resp):
-    content = resp.text
-    for pattern in WAF_PATTERNS:
-        if re.search(pattern, content):
-            return True
-    return False
-```
-
-### 规则 2: SPA 路由识别
-
-```python
-SPA_PATTERNS = [
-    r'<div id="app">',
-    r'<div id="root">',
-    r'__VUE__',
-    r'__NUXT__',
-    r'ReactDOM',
-    r'webpack',
-]
-
-def is_spa_response(resp):
-    content = resp.text
-    for pattern in SPA_PATTERNS:
-        if re.search(pattern, content):
-            return True
-    return False
-```
-
-### 规则 3: 统一错误页识别
-
-```python
-ERROR_PAGE_PATTERNS = [
-    r'页面不存在|404 Not Found',
-    r'服务器错误|500 Internal Server Error',
-    r'请求超时|Timeout',
-]
-
-def is_error_page(resp):
-    for pattern in ERROR_PAGE_PATTERNS:
-        if re.search(pattern, resp.text):
-            return True
-    return False
-```
-
----
-
-## 验证结果记录
-
-### 漏洞验证报告模板
-
-```markdown
-## 漏洞验证记录
-
-### 基本信息
-- **漏洞类型**: SQL 注入
-- **测试目标**: GET /api/user?id=1
-- **测试时间**: 2026-04-03 10:30:00
-- **验证人员**: Agent
-
-### 验证过程
-1. **原始请求**
-   - 请求: GET /api/user?id=1
-   - 响应: 200 OK, {"userId": 1, "name": "张三"}
-
-2. **Payload 测试**
-   - Payload: 1' OR '1'='1
-   - 请求: GET /api/user?id=1' OR '1'='1
-   - 响应: 200 OK, {"userId": 1, "name": "张三"}
-   - 响应: [{"userId": 1}, {"userId": 2}, {"userId": 3}]
-
-3. **对比分析**
-   - 原始响应: 1 条记录
-   - 注入响应: 3 条记录
-   - **差异确认**: 存在 SQL 注入
-
-### 维度评分
-| 维度 | 得分 | 说明 |
-|------|------|------|
-| D1 响应类型 | 15/15 | JSON 响应正常 |
-| D2 状态码 | 15/15 | 200 OK |
-| D3 响应长度 | 18/20 | 长度增加 |
-| D4 WAF | 20/20 | 无 WAF 特征 |
-| D5 敏感信息 | 15/20 | 数据泄露 |
-| D6 一致性 | 15/15 | 多次一致 |
-| D7 SQL注入 | 25/25 | 确认注入 |
-| D8 IDOR | 15/15 | N/A |
-| D9 认证绕过 | 15/15 | N/A |
-| D10 信息泄露 | 10/20 | 泄露用户列表 |
-
-### 最终结论
-- **漏洞确认**: ✅ 是
-- **CVSS**: 8.6 (High)
-- **风险等级**: High
-```
-
----
-
-## 验证检查清单
-
-```
-□ 基础验证
-  □ 多次请求确认差异稳定
-  □ 对比正常/异常响应
-  □ 排除 WAF/安全设备
-  □ 排除 SPA 路由
-  □ 排除测试数据
-
-□ 类型验证
-  □ SQL 注入: 数据库错误/数据泄露/时间延迟
-  □ XSS: Payload 回显/JavaScript 执行
-  □ IDOR: 跨用户数据访问
-  □ JWT: 算法攻击/密钥破解
-  □ SSRF: 内网访问/元数据获取
-
-□ 证据收集
-  □ 请求/响应截图
-  □ Payload 记录
-  □ 时间戳记录
-  □ 关键响应内容
-
-□ 定级评估
-  □ CVSS 计算
-  □ 业务影响评估
-  □ 修复优先级
-```
+- 确认敏感数据暴露
+- 评估信息价值
+- 检查数据聚合风险

package/scripts/postinstall.js

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, cpSync, rmSync, readdirSync, statSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = __dirname;
+
+const OPENCODE_DIR = process.env.OPENCODE_CONFIG_DIR || join(process.env.HOME || "/root", ".config/opencode");
+const SKILL_DIR = join(OPENCODE_DIR, "skills/api-security-testing");
+
+function copyRecursive(src, dest) {
+  if (!existsSync(src)) {
+    console.warn(`[api-security-testing] Warning: ${src} does not exist, skipping`);
+    return;
+  }
+  
+  const stat = statSync(src);
+  if (stat.isDirectory()) {
+    if (!existsSync(dest)) {
+      mkdirSync(dest, { recursive: true });
+    }
+    for (const entry of readdirSync(src)) {
+      copyRecursive(join(src, entry), join(dest, entry));
+    }
+  } else {
+    cpSync(src, dest, { force: true });
+  }
+}
+
+console.log("[api-security-testing] Setting up skill files...");
+
+try {
+  copyRecursive(join(packageRoot, "core"), join(SKILL_DIR, "core"));
+  copyRecursive(join(packageRoot, "references"), join(SKILL_DIR, "references"));
+  
+  const skillMdSrc = join(packageRoot, "SKILL.md");
+  if (existsSync(skillMdSrc)) {
+    cpSync(skillMdSrc, join(SKILL_DIR, "SKILL.md"), { force: true });
+  }
+  
+  console.log("[api-security-testing] Skill files installed to:", SKILL_DIR);
+} catch (error) {
+  console.error("[api-security-testing] Error during installation:", error.message);
+  process.exit(1);
+}