ark-pentest-issue-resolver

Ark 渗透测试问题修复器

提供 Ark 平台中常见渗透测试问题的检测模式、缓解策略和修复方案。

何时使用此技能

在以下情况下使用此技能：

• 用户报告了未指定具体 CVE 的渗透测试发现
• 安全审计发现了 OWASP Top 10 漏洞
• 用户提到“XSS”“SQL 注入”“CSRF”等问题
• 需要识别并修复常见的安全配置错误

注意：未提及具体 CVE 时，ark-security-patcher Agent 会使用此技能。它有助于识别和解决标准渗透测试发现的问题。

常见渗透测试问题

1. SQL 注入

描述：攻击者可以通过用户输入注入恶意 SQL 查询。

检测模式：

# VULNERABLE: Direct string concatenation
query = f"SELECT * FROM users WHERE username = '{username}'"

# VULNERABLE: String formatting
query = "SELECT * FROM users WHERE id = %s" % user_id

缓解措施：

# SECURE: Use parameterized queries
cursor.execute("SELECT * FROM users WHERE username = ?", (username,))

# SECURE: Use ORM with parameter binding
User.objects.filter(username=username)

# SECURE: Use sqlalchemy with bound parameters
session.query(User).filter(User.username == username)

Ark 上下文：

• 检查 Python 服务：services/ark-api/、执行器服务
• 搜索：cursor.execute、db.query、SQL 字符串拼接
• 确认所有数据库查询都使用参数化语句

---

2. 跨站脚本攻击（XSS）

描述：攻击者可以将恶意 JavaScript 注入其他用户访问的网页。

类型：

• 反射型 XSS：URL/请求中的恶意脚本会在响应中反射出来
• 存储型 XSS：恶意脚本存储在数据库中，并显示给用户
• 基于 DOM 的 XSS：漏洞存在于客户端 JavaScript 中

检测模式：

// VULNERABLE: Direct innerHTML manipulation
element.innerHTML = userInput;

// VULNERABLE: Unescaped template rendering
return `<div>${userInput}</div>`;

// VULNERABLE: dangerouslySetInnerHTML in React
<div dangerouslySetInnerHTML={{__html: userInput}} />

缓解措施：

// SECURE: Use textContent
element.textContent = userInput;

// SECURE: Use React/Vue built-in escaping
return <div>{userInput}</div>

// SECURE: Sanitize HTML if HTML input is required
import DOMPurify from 'dompurify';
const clean = DOMPurify.sanitize(userInput);

// SECURE: Set Content-Security-Policy header
Content-Security-Policy: default-src 'self'; script-src 'self'

Ark 上下文：

• 检查：ark-dashboard/、docs/（Next.js 应用）
• 搜索：dangerouslySetInnerHTML、innerHTML、未转义的模板
• 确保在 Next.js 配置中正确设置 Content-Security-Policy 标头
• 确认 React 组件中的所有用户输入都经过转义

---

3. 跨站请求伪造（CSRF）

描述：攻击者诱骗用户在已通过身份验证的应用中执行非预期操作。

检测模式：

// VULNERABLE: No CSRF token validation
http.HandleFunc("/api/delete", func(w http.ResponseWriter, r *http.Request) {
    // Directly processes DELETE without token
    deleteUser(r.FormValue("id"))
})

缓解措施：

// SECURE: Use CSRF middleware
import "github.com/gorilla/csrf"

csrfMiddleware := csrf.Protect(
    []byte("32-byte-long-auth-key"),
    csrf.Secure(true),
)
http.ListenAndServe(":8000", csrfMiddleware(router))

// SECURE: Verify CSRF token
token := r.Header.Get("X-CSRF-Token")
if !csrf.Validate(token, session) {
    http.Error(w, "Invalid CSRF token", http.StatusForbidden)
    return
}

// SECURE: Use SameSite cookie attribute
http.SetCookie(w, &http.Cookie{
    Name:     "session",
    Value:    sessionID,
    SameSite: http.SameSiteStrictMode,
    Secure:   true,
    HttpOnly: true,
})

Ark 上下文：

• 检查：Go operator API 端点、Python API 服务
• 搜索：缺少 CSRF 防护的状态变更端点（POST、PUT、DELETE）
• 确认 Cookie 使用 SameSite=Strict 或 SameSite=Lax
• 为修改状态的 API 路由添加 CSRF 中间件

---

4. 不安全的直接对象引用（IDOR）

描述：应用暴露内部实现对象（ID），但未进行适当的授权检查。

检测模式：

# VULNERABLE: No authorization check
@app.route('/api/user/<user_id>')
def get_user(user_id):
    return User.query.get(user_id)  # Any authenticated user can access any user

# VULNERABLE: Predictable IDs
@app.route('/api/document/<int:doc_id>')
def get_document(doc_id):
    return Document.query.get(doc_id)  # Sequential IDs are guessable

缓解措施：

# SECURE: Check authorization
@app.route('/api/user/<user_id>')
def get_user(user_id):
    user = User.query.get(user_id)
    if user.id != current_user.id and not current_user.is_admin:
        abort(403, "Unauthorized")
    return user

# SECURE: Use UUIDs instead of sequential IDs
import uuid
user_id = uuid.uuid4()

# SECURE: Implement resource ownership check
def check_ownership(resource_id, user_id):
    resource = Resource.query.get(resource_id)
    if resource.owner_id != user_id:
        raise PermissionDenied()

Ark 上下文：

• 检查：Python 服务和 Go operator 中的所有 REST API 端点
• 搜索：URL 路径中的直接 ID 引用、缺少授权检查
• 确认：每次访问资源时都会检查用户权限
• 考虑：使用 UUID 作为资源标识符

---

5. 安全配置错误

描述：不安全的默认配置、不完整的设置、开放的云存储、配置错误的 HTTP 标头。

常见问题：

缺少安全标头

检测：

curl -I https://ark-dashboard.example.com | grep -E "X-Frame-Options|X-Content-Type-Options|Strict-Transport-Security"

缓解措施：

// Add security headers middleware
func securityHeaders(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("X-Frame-Options", "DENY")
        w.Header().Set("X-Content-Type-Options", "nosniff")
        w.Header().Set("X-XSS-Protection", "1; mode=block")
        w.Header().Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains")
        w.Header().Set("Content-Security-Policy", "default-src 'self'")
        w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
        next.ServeHTTP(w, r)
    })
}

// Next.js configuration (next.config.js)
module.exports = {
  async headers() {
    return [
      {
        source: '/:path*',
        headers: [
          { key: 'X-Frame-Options', value: 'DENY' },
          { key: 'X-Content-Type-Options', value: 'nosniff' },
          { key: 'X-XSS-Protection', value: '1; mode=block' },
          { key: 'Strict-Transport-Security', value: 'max-age=31536000; includeSubDomains' },
          { key: 'Referrer-Policy', value: 'strict-origin-when-cross-origin' },
        ],
      },
    ]
  },
}

在生产环境中启用调试模式

检测：

grep -r "DEBUG.*=.*true" .
grep -r "NODE_ENV.*development" .

缓解措施：

• 在生产环境中设置 DEBUG=false
• 设置 NODE_ENV=production
• 从错误响应中移除堆栈跟踪
• 在生产环境中禁用详细日志记录

---

6. 敏感数据泄露

描述：应用通过日志、错误消息或不安全的传输方式暴露敏感数据。

检测模式：

# VULNERABLE: Logging sensitive data
logger.info(f"User {username} logged in with password {password}")

# VULNERABLE: Exposing secrets in error messages
raise Exception(f"Database connection failed: {db_password}")

# VULNERABLE: Sensitive data in URLs
redirect(f"/reset-password?token={reset_token}")

缓解措施：

# SECURE: Never log sensitive data
logger.info(f"User {username} logged in successfully")

# SECURE: Generic error messages
raise Exception("Database connection failed")
logger.error("DB error", exc_info=True)  # Full details only in logs

# SECURE: Use POST for sensitive data
# POST /reset-password with token in body

# SECURE: Mask sensitive data
def mask_credit_card(card_number):
    return f"****-****-****-{card_number[-4:]}"

环境变量：

# VULNERABLE: Hardcoded secrets
API_KEY = "sk_live_abc123xyz"

# SECURE: Use environment variables
API_KEY = os.getenv("API_KEY")

# SECURE: Use Kubernetes secrets
apiVersion: v1
kind: Secret
metadata:
  name: ark-secrets
type: Opaque
data:
  api-key: <base64-encoded-value>

Ark 上下文：

• 检查：所有日志语句、错误处理程序
• 搜索：硬编码的机密、API 密钥、密码
• 确认：所有通信都使用 TLS/HTTPS
• 使用：Kubernetes Secrets 存储敏感配置

---

7. 身份验证失效

描述：身份验证机制薄弱，可能导致凭据填充、暴力破解或会话劫持。

常见问题：

密码要求过弱

缓解措施：

import re

def validate_password(password):
    """Enforce strong password policy"""
    if len(password) < 12:
        return False, "Password must be at least 12 characters"
    if not re.search(r"[A-Z]", password):
        return False, "Password must contain uppercase letter"
    if not re.search(r"[a-z]", password):
        return False, "Password must contain lowercase letter"
    if not re.search(r"[0-9]", password):
        return False, "Password must contain number"
    if not re.search(r"[!@#$%^&*]", password):
        return False, "Password must contain special character"
    return True, "Password is valid"

登录缺少速率限制

缓解措施：

import "golang.org/x/time/rate"

// Rate limiter: 5 requests per minute per IP
var limiter = rate.NewLimiter(rate.Every(time.Minute/5), 5)

func loginHandler(w http.ResponseWriter, r *http.Request) {
    if !limiter.Allow() {
        http.Error(w, "Too many requests", http.StatusTooManyRequests)
        return
    }
    // Process login
}

不安全的会话管理

缓解措施：

// SECURE: Generate cryptographically secure session IDs
import "crypto/rand"

func generateSessionID() (string, error) {
    b := make([]byte, 32)
    if _, err := rand.Read(b); err != nil {
        return "", err
    }
    return base64.URLEncoding.EncodeToString(b), nil
}

// SECURE: Set secure cookie attributes
http.SetCookie(w, &http.Cookie{
    Name:     "session_id",
    Value:    sessionID,
    Path:     "/",
    MaxAge:   3600,
    HttpOnly: true,  // Prevent JavaScript access
    Secure:   true,  // Only send over HTTPS
    SameSite: http.SameSiteStrictMode,
})

---

8. 访问控制失效

描述：用户可以执行超出其预期权限范围的操作。

检测模式：

# VULNERABLE: No permission check
@app.route('/api/admin/users', methods=['DELETE'])
def delete_user():
    user_id = request.json['user_id']
    User.query.filter_by(id=user_id).delete()

缓解措施：

# SECURE: Role-based access control (RBAC)
from functools import wraps

def require_role(*roles):
    def decorator(f):
        @wraps(f)
        def decorated_function(*args, **kwargs):
            if not current_user.is_authenticated:
                abort(401)
            if current_user.role not in roles:
                abort(403, "Insufficient permissions")
            return f(*args, **kwargs)
        return decorated_function
    return decorator

@app.route('/api/admin/users', methods=['DELETE'])
@require_role('admin', 'superuser')
def delete_user():
    user_id = request.json['user_id']
    User.query.filter_by(id=user_id).delete()

Kubernetes RBAC（适用于 Ark Operator）：

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: ark-operator
rules:
- apiGroups: ["ark.example.com"]
  resources: ["models", "prompts"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]

Ark 相关内容：

• 检查：所有 API 端点是否都进行了授权检查
• 验证：Kubernetes RBAC 规则是否正确限定了范围
• 实施：最小权限原则
• 测试：水平权限提升（用户 A 访问用户 B 的资源）

---

9. 日志记录和监控不足

描述：缺少日志记录和监控，可能导致攻击无法被及时发现。

缓解措施：

import logging
import structlog

# Configure structured logging
logger = structlog.get_logger()

# Log security events
def log_security_event(event_type, user_id, details):
    logger.info(
        "security_event",
        event_type=event_type,
        user_id=user_id,
        details=details,
        timestamp=datetime.utcnow().isoformat()
    )

# Examples of what to log
log_security_event("login_success", user.id, {"ip": request.remote_addr})
log_security_event("login_failure", username, {"ip": request.remote_addr})
log_security_event("password_change", user.id, {})
log_security_event("permission_denied", user.id, {"resource": resource_id})
log_security_event("admin_action", user.id, {"action": "delete_user", "target": target_id})

需要记录的事件：

• 身份验证成功和失败
• 授权失败
• 输入验证失败
• 管理操作
• 资源访问（尤其是敏感资源）
• 数据修改
• 安全配置更改

---

10. 服务端请求伪造（SSRF）

描述：攻击者诱使服务端向内部资源发起请求。

检测模式：

# VULNERABLE: Direct use of user-provided URL
import requests
url = request.args.get('url')
response = requests.get(url)  # Can access internal resources!

缓解措施：

# SECURE: Validate and whitelist URLs
import ipaddress
from urllib.parse import urlparse

ALLOWED_DOMAINS = ['api.example.com', 'cdn.example.com']

def is_safe_url(url):
    try:
        parsed = urlparse(url)

        # Only allow HTTP/HTTPS
        if parsed.scheme not in ['http', 'https']:
            return False

        # Check against whitelist
        if parsed.hostname not in ALLOWED_DOMAINS:
            return False

        # Resolve hostname and check it's not internal
        ip = socket.gethostbyname(parsed.hostname)
        if ipaddress.ip_address(ip).is_private:
            return False

        return True
    except Exception:
        return False

# Use the validator
url = request.args.get('url')
if not is_safe_url(url):
    abort(400, "Invalid URL")
response = requests.get(url)

Ark 相关内容：

• 检查：是否有任何 API 会获取用户输入的 URL
• 搜索：使用用户提供的 URL 调用 requests.get、http.Get、fetch
• 实施：为外部 API 调用设置 URL 白名单

---

11. XML 外部实体（XXE）

描述：攻击者可以在 XML 中包含外部实体，以读取文件或导致 DoS。

检测模式：

# VULNERABLE: Unsafe XML parsing
import xml.etree.ElementTree as ET
tree = ET.parse(xml_file)  # Vulnerable to XXE

缓解措施：

# SECURE: Disable external entity processing
import defusedxml.ElementTree as ET
tree = ET.parse(xml_file)  # Safe from XXE

# SECURE: Configure parser to disable DTDs
from lxml import etree
parser = etree.XMLParser(resolve_entities=False, no_network=True, dtd_validation=False)
tree = etree.parse(xml_file, parser)

---

12. 不安全的反序列化

描述：对不可信数据进行反序列化，可能导致远程代码执行。

检测模式：

# VULNERABLE: Pickle deserialization of untrusted data
import pickle
data = pickle.loads(untrusted_data)  # Can execute arbitrary code!

# VULNERABLE: YAML unsafe loading
import yaml
data = yaml.load(untrusted_yaml)  # Can execute Python code

缓解措施：

# SECURE: Use JSON instead of pickle
import json
data = json.loads(untrusted_data)

# SECURE: Use safe YAML loading
import yaml
data = yaml.safe_load(untrusted_yaml)

# SECURE: If pickle is necessary, use HMAC verification
import hmac
import hashlib

def serialize_with_hmac(obj, secret_key):
    serialized = pickle.dumps(obj)
    signature = hmac.new(secret_key, serialized, hashlib.sha256).digest()
    return signature + serialized

def deserialize_with_hmac(data, secret_key):
    signature = data[:32]
    serialized = data[32:]
    expected_signature = hmac.new(secret_key, serialized, hashlib.sha256).digest()
    if not hmac.compare_digest(signature, expected_signature):
        raise ValueError("Invalid signature")
    return pickle.loads(serialized)

---

13. 路径遍历

描述：攻击者使用 ../ 序列访问预期目录之外的文件。

检测模式：

# VULNERABLE: Direct file path from user input
filename = request.args.get('file')
with open(f'/var/www/uploads/{filename}', 'r') as f:  # Can access ../../../../etc/passwd
    content = f.read()

缓解措施：

# SECURE: Validate and sanitize file paths
import os
from pathlib import Path

UPLOAD_DIR = '/var/www/uploads'

def safe_file_path(filename):
    # Remove any directory components
    filename = os.path.basename(filename)

    # Build full path
    full_path = os.path.join(UPLOAD_DIR, filename)

    # Resolve to absolute path and verify it's within UPLOAD_DIR
    full_path = os.path.abspath(full_path)
    if not full_path.startswith(os.path.abspath(UPLOAD_DIR)):
        raise ValueError("Invalid file path")

    return full_path

# Use the validator
filename = request.args.get('file')
safe_path = safe_file_path(filename)
with open(safe_path, 'r') as f:
    content = f.read()

---

14. 命令注入

描述：攻击者可以执行任意系统命令。

检测模式：

# VULNERABLE: Direct command execution with user input
import os
filename = request.args.get('file')
os.system(f'ls -l {filename}')  # Can inject: file.txt; rm -rf /

# VULNERABLE: Shell=True with user input
import subprocess
subprocess.call(f'ping {host}', shell=True)

缓解措施：

# SECURE: Use subprocess with list of arguments (no shell)
import subprocess
filename = request.args.get('file')
subprocess.run(['ls', '-l', filename], check=True, capture_output=True)

# SECURE: Validate and sanitize input
import shlex
def safe_command(user_input):
    # Whitelist allowed characters
    if not re.match(r'^[a-zA-Z0-9._-]+$', user_input):
        raise ValueError("Invalid input")
    return user_input

# SECURE: Use libraries instead of shell commands
# Instead of: os.system('tar -czf archive.tar.gz files/')
import tarfile
with tarfile.open('archive.tar.gz', 'w:gz') as tar:
    tar.add('files/')

Ark 相关内容：

• 检查：是否有任何代码会执行 shell 命令（尤其是在执行器中）
• 搜索：os.system、subprocess.call、shell=True
• 验证：所有外部命令都使用参数列表，而非 shell 字符串

---

15. 缺少速率限制

描述：没有防护措施来应对暴力破解、DoS 或资源耗尽攻击。

缓解措施：

# Python with Flask-Limiter
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

limiter = Limiter(
    app,
    key_func=get_remote_address,
    default_limits=["200 per day", "50 per hour"]
)

@app.route("/api/login", methods=["POST"])
@limiter.limit("5 per minute")
def login():
    # Login logic
    pass

// Go with rate limiting middleware
import "golang.org/x/time/rate"

func rateLimitMiddleware(next http.Handler) http.Handler {
    limiter := rate.NewLimiter(rate.Every(time.Second), 10) // 10 req/sec

    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if !limiter.Allow() {
            http.Error(w, "Rate limit exceeded", http.StatusTooManyRequests)
            return
        }
        next.ServeHTTP(w, r)
    })
}

Kubernetes 网络策略：

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: rate-limit-policy
spec:
  podSelector:
    matchLabels:
      app: ark-api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: ingress-controller

---

工作流：解决渗透测试问题

步骤 1：确定问题类别

将报告的问题对应到上述类别之一：

• SQL 注入 → 数据库查询
• XSS → 用户输入渲染
• CSRF → 会更改状态的 API 端点
• IDOR → 未经授权即可访问资源
• 安全配置错误 → 标头、调试模式、默认设置
• 敏感数据泄露 → 日志记录、错误消息、传输
• 身份验证失效 → 密码策略、会话管理
• 访问控制失效 → 权限检查、RBAC
• 日志记录不足 → 安全事件日志记录
• SSRF → 获取外部 URL
• XXE → XML 解析
• 不安全的反序列化 → Pickle、YAML 加载
• 路径遍历 → 文件系统访问
• 命令注入 → 系统命令执行
• 缺少速率限制 → API 防护

步骤 2：搜索易受攻击的模式

使用 grep/ripgrep 查找易受攻击的代码模式：

# SQL Injection
grep -r "cursor.execute.*%" .
grep -r "query.*format" .

# XSS
grep -r "innerHTML" .
grep -r "dangerouslySetInnerHTML" .

# Command Injection
grep -r "os.system" .
grep -r "shell=True" .

# Path Traversal
grep -r "open.*request" .

# Insecure Deserialization
grep -r "pickle.loads" .
grep -r "yaml.load" .

步骤 3：分析对 Ark 的影响

考虑哪些 Ark 组件会受到影响：

• Go Operator：ark/ - 控制器、Webhook、API 服务器
• Python 服务：services/ - 执行器服务、API 端点
• Node.js 应用程序：ark-dashboard/、docs/、ark-cli/
• Kubernetes 资源：部署配置、RBAC、网络策略

步骤 4：提供缓解方案

向用户提供：

1. 发现的易受攻击代码模式
2. 针对每种模式的修复建议
3. 测试策略
4. 可能造成的破坏性更改

实施前等待用户批准。

步骤 5：实施修复

应用上述类别中适当的缓解措施：

• 更新存在漏洞的代码模式
• 添加安全中间件/验证器
• 配置安全标头
• 按需更新依赖项

步骤 6：测试修复

# Run existing tests
make test

# Security-specific tests
# - Test with malicious input
# - Verify security headers
# - Check authorization enforcement
# - Validate input sanitization

步骤 7：创建包含安全背景信息的 PR

记录：

• 发现了什么漏洞
• 漏洞位于何处（文件、行号）
• 做了哪些更改来修复漏洞
• 如何验证修复
• 是否有任何不兼容的更改

---

Ark 特定安全注意事项

Kubernetes Operator 安全

CRD 验证：

// Add validation to CRD specs
// +kubebuilder:validation:Pattern=^[a-zA-Z0-9-]+$
// +kubebuilder:validation:MinLength=1
// +kubebuilder:validation:MaxLength=253
Name string `json:"name"`

RBAC 最小权限原则：

# Only grant necessary permissions
rules:
- apiGroups: ["ark.example.com"]
  resources: ["models"]
  verbs: ["get", "list"]  # Not "delete" or "*"

Python 服务安全

输入验证：

from pydantic import BaseModel, validator

class PromptRequest(BaseModel):
    prompt: str
    max_tokens: int

    @validator('prompt')
    def validate_prompt(cls, v):
        if len(v) > 10000:
            raise ValueError('Prompt too long')
        return v

    @validator('max_tokens')
    def validate_max_tokens(cls, v):
        if v < 1 or v > 4096:
            raise ValueError('Invalid max_tokens')
        return v

Node.js / Next.js 安全

环境变量：

// Only expose NEXT_PUBLIC_ vars to client
// next.config.js
module.exports = {
  env: {
    // Server-side only
    DATABASE_URL: process.env.DATABASE_URL,
  },
  publicRuntimeConfig: {
    // Client-side accessible
    API_URL: process.env.NEXT_PUBLIC_API_URL,
  },
}

Docker 安全

非 root 用户：

# Run as non-root user
RUN addgroup -g 1001 -S appuser && \
    adduser -u 1001 -S appuser -G appuser
USER appuser

精简基础镜像：

# Use distroless or alpine
FROM gcr.io/distroless/python3
# OR
FROM python:3.11-alpine

---

测试安全修复

手动测试清单

• 使用恶意输入测试（SQL 注入载荷）
• 使用 XSS 载荷测试（<script>alert('XSS')</script>）
• 使用路径遍历测试（../../../../etc/passwd）
• 测试授权绕过（用户 A 访问用户 B 的数据）
• 测试速率限制（过多请求）
• 确认存在安全标头
• 检查错误消息不会泄露敏感数据
• 确认已强制执行 HTTPS/TLS

自动化安全测试

# Static analysis
bandit -r services/  # Python
gosec ./...          # Go
npm audit            # Node.js

# Dependency scanning
safety check         # Python
go list -json -m all | nancy sleuth  # Go
npm audit fix        # Node.js

# Container scanning
trivy image ark-operator:latest

---

常见渗透测试报告关键词

在渗透测试报告中看到以下术语时，将其对应到适当的类别：

• “输入验证不足” → SQL 注入、XSS、命令注入、路径遍历
• “缺少安全标头” → 安全配置错误（#5）
• “敏感信息泄露” → 敏感数据暴露（#6）
• “缺少 CSRF 防护” → CSRF（#3）
• “访问控制失效” → IDOR（#4）或访问控制失效（#8）
• “身份验证薄弱” → 身份验证失效（#7）
• “会话管理不安全” → 身份验证失效（#7）
• “服务端请求伪造” → SSRF（#10）
• “XML 外部实体注入” → XXE（#11）
• “不安全的反序列化” → 不安全的反序列化（#12）
• “目录遍历” → 路径遍历（#13）
• “OS 命令注入” → 命令注入（#14）
• “未实施速率限制” → 缺少速率限制（#15）
• “信息泄露” → 敏感数据暴露（#6）
• “日志记录不足” → 日志记录和监控不足（#9）

---

重要说明

• 实施安全修复前，务必获得用户批准
• 彻底测试——安全修复可能会破坏功能
• 在提交消息和 PR 中清楚记录漏洞
• 更改 API 或行为时，考虑向后兼容性
• 按严重性排序：严重 > 高 > 中 > 低
• 纵深防御：应用多层安全控制
• 最小权限原则：仅授予必要的最低权限

资源

• OWASP Top 10
• OWASP Cheat Sheet Series
• CWE Top 25
• Kubernetes Security Best Practices