AI 驱动的漏洞发现革命：Firefox 150 修复 271 个漏洞背后的技术原理与实战指南

#!/usr/bin/env python3
"""
AI 辅助漏洞发现演示：结合 AST 分析与 LLM 语义判断
这个脚本演示了如何构建一个简易的 AI 安全审计流水线
模拟 Firefox 150 案例中 AI 发现漏洞的思路

依赖：pip install ast openai requests
"""

import ast
import json
import sys
from dataclasses import dataclass, field
from typing import Optional

# ============================================================
# 第一步：AST 静态分析 —— 提取可疑代码模式
# ============================================================

@dataclass
class VulnerabilityCandidate:
    """可疑漏洞候选"""
    file: str
    line: int
    pattern: str
    severity: str  # critical, high, medium, low
    description: str
    code_snippet: str = ""
    ai_analysis: str = ""

class SuspiciousPatternVisitor(ast.NodeVisitor):
    """AST 访问者：扫描可疑的安全模式"""

    def __init__(self, filename: str, source: str):
        self.filename = filename
        self.source_lines = source.split("\n")
        self.candidates: list[VulnerabilityCandidate] = []
        self.generic_visit(ast.parse(source))

    def visit_Call(self, node: ast.Call):
        # 检测危险的函数调用模式
        func_name = ""
        if isinstance(node.func, ast.Attribute):
            func_name = node.func.attr
        elif isinstance(node.func, ast.Name):
            func_name = node.func.id

        dangerous_patterns = {
            "eval": ("critical", "使用 eval() 可能导致代码注入"),
            "exec": ("critical", "使用 exec() 可能导致代码注入"),
            "compile": ("high", "使用 compile() 可能执行不受控代码"),
            "os.system": ("critical", "使用 os.system() 可能导致命令注入"),
            "subprocess.call": ("high", "subprocess.call 未设置 shell=False"),
            "pickle.load": ("critical", "pickle 反序列化可能导致远程代码执行"),
            "marshal.load": ("high", "marshal 反序列化不安全"),
        }

        for pattern, (severity, desc) in dangerous_patterns.items():
            if func_name == pattern or func_name.endswith(f".{pattern}"):
                snippet = self._get_snippet(node.lineno)
                self.candidates.append(VulnerabilityCandidate(
                    file=self.filename,
                    line=node.lineno,
                    pattern=pattern,
                    severity=severity,
                    description=desc,
                    code_snippet=snippet
                ))

        self.generic_visit(node)

    def visit_Assign(self, node: ast.Assign):
        # 检测硬编码的密钥/密码
        for target in node.targets:
            if isinstance(target, ast.Name):
                name_lower = target.id.lower()
                if any(kw in name_lower for kw in ["password", "secret", "api_key", "token"]):
                    if isinstance(node.value, ast.Constant):
                        snippet = self._get_snippet(node.lineno)
                        self.candidates.append(VulnerabilityCandidate(
                            file=self.filename,
                            line=node.lineno,
                            pattern="hardcoded_secret",
                            severity="high",
                            description=f"硬编码的敏感变量: {target.id}",
                            code_snippet=snippet
                        ))

        self.generic_visit(node)

    def _get_snippet(self, lineno: int) -> str:
        start = max(0, lineno - 2)
        end = min(len(self.source_lines), lineno + 2)
        return "\n".join(self.source_lines[start:end])


# ============================================================
# 第二步：LLM 语义分析 —— 判断真实风险
# ============================================================

def llm_security_review(candidates: list[VulnerabilityCandidate],
                        api_url: str, api_key: str) -> list[VulnerabilityCandidate]:
    """
    调用 LLM 对每个可疑候选进行语义级别的风险分析

    这一步模拟了 Claude Mythos 的核心能力：
    不仅看到模式，还理解代码的上下文和意图
    """
    system_prompt = """你是一个资深安全工程师。请分析以下代码片段，
判断是否存在真实的安全漏洞。考虑：
1. 攻击路径是否真实可达
2. 是否有有效的缓解措施
3. 影响范围和严重程度
4. 给出 CVSS 评分建议

只返回 JSON 格式: {"is_real_vuln": true/false, "cvss": 0-10, "explanation": "..."}"""

    reviewed = []
    for candidate in candidates:
        user_prompt = f"""分析以下代码中的安全模式:

文件: {candidate.file}
行号: {candidate.line}
模式: {candidate.pattern}
描述: {candidate.description}

代码片段:
```python
{candidate.code_snippet}
```

请判断这是否是真实的安全漏洞。"""

        # 实际调用 LLM API（这里用模拟代替）
        result = _call_llm(api_url, api_key, system_prompt, user_prompt)
        candidate.ai_analysis = result.get("explanation", "")

        # 过滤掉误报
        if result.get("is_real_vuln", False):
            reviewed.append(candidate)

    return reviewed


def _call_llm(api_url: str, api_key: str,
              system: str, user: str) -> dict:
    """调用 LLM API 进行安全分析（模拟实现）"""
    # 实际使用时替换为真实的 API 调用
    # import requests
    # response = requests.post(api_url, headers={
    #     "Authorization": f"Bearer {api_key}",
    #     "Content-Type": "application/json"
    # }, json={
    #     "model": "claude-mythos-preview",
    #     "system": system,
    #     "messages": [{"role": "user", "content": user}]
    # })
    # return response.json()["content"][0]["text"]

    # 模拟返回（仅用于演示）
    return {
        "is_real_vuln": True,
        "cvss": 7.5,
        "explanation": "模拟分析：此代码模式存在真实的安全风险"
    }


# ============================================================
# 第三步：生成漏洞报告
# ============================================================

def generate_report(reviewed: list[VulnerabilityCandidate]) -> str:
    """生成结构化漏洞报告（模拟 Mozilla 的 MFSA 格式）"""
    report = {
        "report_id": "AI-AUDIT-2026-001",
        "date": "2026-04-23",
        "total_candidates": len(reviewed),
        "vulnerabilities": []
    }

    for i, v in enumerate(reviewed, 1):
        report["vulnerabilities"].append({
            "id": f"VULN-{i:03d}",
            "file": v.file,
            "line": v.line,
            "severity": v.severity,
            "pattern": v.pattern,
            "description": v.description,
            "ai_explanation": v.ai_analysis
        })

    return json.dumps(report, indent=2, ensure_ascii=False)


# ============================================================
# 主流程
# ============================================================

def audit_file(filepath: str, api_url: str = "", api_key: str = "") -> str:
    """完整的 AI 辅助安全审计流程"""
    with open(filepath, "r") as f:
        source = f.read()

    print(f"[1/3] 扫描 {filepath}...")
    visitor = SuspiciousPatternVisitor(filepath, source)
    print(f"     发现 {len(visitor.candidates)} 个可疑模式")

    if api_url:
        print(f"[2/3] LLM 语义分析中...")
        reviewed = llm_security_review(visitor.candidates, api_url, api_key)
        print(f"     确认 {len(reviewed)} 个真实漏洞")
    else:
        reviewed = visitor.candidates

    print(f"[3/3] 生成报告...")
    report = generate_report(reviewed)
    return report


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("用法: python ai_security_audit.py <file.py> [--api-url URL --api-key KEY]")
        sys.exit(1)

    filepath = sys.argv[1]
    api_url = ""
    api_key = ""

    if "--api-url" in sys.argv:
        idx = sys.argv.index("--api-url")
        api_url = sys.argv[idx + 1]
    if "--api-key" in sys.argv:
        idx = sys.argv.index("--api-key")
        api_key = sys.argv[idx + 1]

    report = audit_file(filepath, api_url, api_key)
    print(report)

#!/usr/bin/env python3
"""
CVSS 评分计算器 —— 基于 AI 分析结果的自动化风险评估
模拟 Mozilla 安全团队对 AI 发现漏洞的优先级排序流程
"""

from dataclasses import dataclass
from enum import Enum

class AttackVector(Enum):
    NETWORK = "N"
    ADJACENT = "A"
    LOCAL = "L"
    PHYSICAL = "P"

class AttackComplexity(Enum):
    LOW = "L"
    HIGH = "H"

class PrivilegesRequired(Enum):
    NONE = "N"
    LOW = "L"
    HIGH = "H"

class UserInteraction(Enum):
    NONE = "N"
    REQUIRED = "R"

class Scope(Enum):
    UNCHANGED = "U"
    CHANGED = "C"

class Impact(Enum):
    NONE = "N"
    LOW = "L"
    HIGH = "H"

@dataclass
class CVSSv4:
    """CVSS v4.0 简化评分器"""
    attack_vector: AttackVector
    attack_complexity: AttackComplexity
    priv_required: PrivilegesRequired
    user_interaction: UserInteraction
    scope: Scope
    confidentiality: Impact
    integrity: Impact
    availability: Impact

    def calculate(self) -> float:
        # CVSS v4.0 简化的 MacroVector 计算
        # 实际实现应使用完整的 CVSS v4.0 公式
        # 这里提供教学用的简化版本

        # Base Score 计算（简化版）
        exploitability = self._exploitability_score()
        impact_score = self._impact_score()

        if impact_score <= 0:
            return 0.0

        # ISS (Impact Sub-Score)
        iss = 1 - (
            (1 - self._impact_value(self.confidentiality)) *
            (1 - self._impact_value(self.integrity)) *
            (1 - self._impact_value(self.availability))
        )

        # 简化公式: BaseScore = round(min(1.08 * (Impact + Exploitability), 10))
        base = min(round(1.08 * (iss * 6.42 + exploitability * 3.58) * 10) / 10, 10.0)
        return base

    def _exploitability_score(self) -> float:
        av_scores = {
            AttackVector.NETWORK: 0.85,
            AttackVector.ADJACENT: 0.62,
            AttackVector.LOCAL: 0.55,
            AttackVector.PHYSICAL: 0.20
        }
        ac_scores = {
            AttackComplexity.LOW: 0.77,
            AttackComplexity.HIGH: 0.56
        }
        pr_scores = {
            PrivilegesRequired.NONE: 0.85,
            PrivilegesRequired.LOW: 0.62,
            PrivilegesRequired.HIGH: 0.27
        }
        ui_scores = {
            UserInteraction.NONE: 0.85,
            UserInteraction.REQUIRED: 0.62
        }

        return (
            8.22 *
            av_scores[self.attack_vector] *
            ac_scores[self.attack_complexity] *
            pr_scores[self.priv_required] *
            ui_scores[self.user_interaction]
        )

    def _impact_value(self, impact: Impact) -> float:
        return {
            Impact.NONE: 0.0,
            Impact.LOW: 0.22,
            Impact.HIGH: 0.56
        }[impact]

    def _impact_score(self) -> float:
        return (
            self._impact_value(self.confidentiality) +
            self._impact_value(self.integrity) +
            self._impact_value(self.availability)
        ) / 3

    def severity_label(self) -> str:
        score = self.calculate()
        if score >= 9.0:
            return "CRITICAL"
        elif score >= 7.0:
            return "HIGH"
        elif score >= 4.0:
            return "MEDIUM"
        elif score > 0:
            return "LOW"
        return "NONE"

    def vector_string(self) -> str:
        return (
            f"CVSS:4.0/AV:{self.attack_vector.value}"
            f"/AC:{self.attack_complexity.value}"
            f"/PR:{self.priv_required.value}"
            f"/UI:{self.user_interaction.value}"
            f"/SC:{self.scope.value}"
            f"/C:{self.confidentiality.value}"
            f"/I:{self.integrity.value}"
            f"/A:{self.availability.value}"
        )


# ============================================================
# 演示：对 Firefox 150 典型漏洞类型进行评分
# ============================================================

def demo_firefox_vulns():
    """模拟 Firefox 150 中发现的几类典型漏洞的 CVSS 评分"""

    vulns = [
        {
            "name": "Use-After-Free in WebGL",
            "cvss": CVSSv4(
                attack_vector=AttackVector.NETWORK,
                attack_complexity=AttackComplexity.LOW,
                priv_required=PrivilegesRequired.NONE,
                user_interaction=UserInteraction.REQUIRED,
                scope=Scope.CHANGED,
                confidentiality=Impact.HIGH,
                integrity=Impact.HIGH,
                availability=Impact.HIGH
            )
        },
        {
            "name": "XSS via innerHTML",
            "cvss": CVSSv4(
                attack_vector=AttackVector.NETWORK,
                attack_complexity=AttackComplexity.LOW,
                priv_required=PrivilegesRequired.NONE,
                user_interaction=UserInteraction.REQUIRED,
                scope=Scope.CHANGED,
                confidentiality=Impact.LOW,
                integrity=Impact.LOW,
                availability=Impact.NONE
            )
        },
        {
            "name": "Prototype Pollution",
            "cvss": CVSSv4(
                attack_vector=AttackVector.NETWORK,
                attack_complexity=AttackComplexity.HIGH,
                priv_required=PrivilegesRequired.NONE,
                user_interaction=UserInteraction.NONE,
                scope=Scope.UNCHANGED,
                confidentiality=Impact.LOW,
                integrity=Impact.HIGH,
                availability=Impact.LOW
            )
        },
        {
            "name": "Local Buffer Overflow",
            "cvss": CVSSv4(
                attack_vector=AttackVector.LOCAL,
                attack_complexity=AttackComplexity.LOW,
                priv_required=PrivilegesRequired.LOW,
                user_interaction=UserInteraction.NONE,
                scope=Scope.UNCHANGED,
                confidentiality=Impact.HIGH,
                integrity=Impact.HIGH,
                availability=Impact.HIGH
            )
        },
    ]

    print("=" * 70)
    print("Firefox 150 典型漏洞 CVSS v4.0 评分模拟")
    print("=" * 70)

    for v in vulns:
        score = v["cvss"].calculate()
        label = v["cvss"].severity_label()
        vector = v["cvss"].vector_string()

        print(f"\n漏洞: {v['name']}")
        print(f"  评分: {score:.1f} ({label})")
        print(f"  向量: {vector}")


if __name__ == "__main__":
    demo_firefox_vulns()