AI 安全的里程碑：Claude Mythos 在 Firefox 中发现 271 个漏洞——从 Bobby Holley 的「Defender's Moment」看 AI 安全评估新纪元

"""
AI 辅助安全审计工具 - LLM 推理引擎
使用 LLM 对静态分析结果进行深度推理
"""
import os
import json
from typing import Optional

class LLMSecurityAuditor:
    """基于 LLM 的安全审计推理引擎"""
    
    SYSTEM_PROMPT = """你是一位资深的安全审计专家，拥有 20 年以上的安全研究经验。
你的任务是分析代码片段，发现潜在的安全漏洞。

请按照以下步骤进行分析：
1. 理解代码的功能和上下文
2. 识别所有用户可控的输入点
3. 追踪数据从输入到敏感操作的完整路径
4. 检查是否有适当的输入验证和清理
5. 检查内存管理是否正确（对于 C/C++）
6. 检查权限检查是否充分
7. 检查是否有绕过安全机制的边界条件

对于每个发现的漏洞，请提供：
- CVE 类型分类（CWE 编号）
- 严重程度（Critical/High/Medium/Low）
- 详细的利用场景描述
- 具体的修复建议（含代码示例）

如果代码看起来安全，也要说明为什么安全。"""
    
    def __init__(self, api_key: str, model: str = "gpt-4"):
        self.api_key = api_key
        self.model = model
        # 初始化 API 客户端
        # from openai import OpenAI
        # self.client = OpenAI(api_key=api_key)
    
    def analyze_code(self, code: str, context: str = "") -> dict:
        """分析单个代码片段"""
        prompt = f"""
请分析以下代码的安全问题：

代码上下文：
{context}

代码片段：
{code}

请按以下 JSON 格式返回分析结果：
{{
    "vulnerabilities": [
        {{
            "type": "漏洞类型",
            "cwe_id": "CWE-编号",
            "severity": "Critical/High/Medium/Low",
            "description": "详细描述",
            "exploit_scenario": "利用场景",
            "fix": "修复建议（含代码）",
            "line_numbers": [行号范围]
        }}
    ],
    "overall_assessment": "整体安全评估",
    "confidence": "High/Medium/Low"
}}
"""
        # 实际实现需要调用 LLM API
        # response = self.client.chat.completions.create(
        #     model=self.model,
        #     messages=[
        #         {"role": "system", "content": self.SYSTEM_PROMPT},
        #         {"role": "user", "content": prompt}
        #     ],
        #     temperature=0.1,
        #     response_format={"type": "json_object"}
        # )
        # return json.loads(response.choices[0].message.content)
        
        return {
            "vulnerabilities": [],
            "overall_assessment": "示例：请配置 API 后执行分析",
            "confidence": "Low"
        }
    
    def batch_analyze(self, findings: list[dict]) -> dict:
        """批量分析多个发现"""
        results = []
        for finding in findings:
            result = self.analyze_code(
                code=finding.get('code', ''),
                context=f"文件: {finding.get('file', '')}, 行: {finding.get('line', '')}"
            )
            results.append(result)
        return {"total_analyzed": len(results), "results": results}

# 使用示例
if __name__ == "__main__":
    # 配置 API Key（实际使用时从环境变量读取）
    API_KEY = os.environ.get("OPENAI_API_KEY", "your-api-key")
    
    auditor = LLMSecurityAuditor(api_key=API_KEY, model="gpt-4")
    
    # 分析一个具体的代码片段
    code = """
void process_user_input(char* input) {
    char buffer[256];
    strcpy(buffer, input);  // 危险：没有长度检查
    printf(buffer);          // 危险：格式化字符串漏洞
    free(input);             // 可能重复释放
}
"""
    
    result = auditor.analyze_code(code)
    print(json.dumps(result, indent=2, ensure_ascii=False))

"""
漏洞报告生成器
将 AI 审计结果格式化为专业的安全报告
"""
import json
from datetime import datetime
from dataclasses import dataclass, asdict
from typing import Optional

@dataclass
class VulnerabilityReport:
    """漏洞报告"""
    cve_id: str
    title: str
    severity: str
    cwe_id: str
    component: str
    description: str
    exploit_scenario: str
    fix_recommendation: str
    discovered_by: str
    discovery_date: str
    
    def to_markdown(self) -> str:
        """生成 Markdown 格式报告"""
        severity_emoji = {
            "Critical": "🔴",
            "High": "🟠", 
            "Medium": "🟡",
            "Low": "🟢"
        }
        emoji = severity_emoji.get(self.severity, "⚪")
        
        return f"""
### {emoji} {self.cve_id}: {self.title}

- 严重程度: {self.severity}
- CWE 编号: {self.cwe_id}
- 影响组件: {self.component}
- 发现者: {self.discovered_by}
- 发现日期: {self.discovery_date}

描述：
{self.description}

利用场景：
{self.exploit_scenario}

修复建议：
{self.fix_recommendation}
"""

class SecurityReportGenerator:
    """安全报告生成器"""
    
    def __init__(self, project_name: str):
        self.project_name = project_name
        self.vulnerabilities: list[VulnerabilityReport] = []
    
    def add_vulnerability(self, vuln: VulnerabilityReport):
        self.vulnerabilities.append(vuln)
    
    def generate_summary(self) -> str:
        """生成报告摘要"""
        total = len(self.vulnerabilities)
        by_severity = {}
        by_component = {}
        by_type = {}
        
        for v in self.vulnerabilities:
            by_severity[v.severity] = by_severity.get(v.severity, 0) + 1
            by_component[v.component] = by_component.get(v.component, 0) + 1
            by_type[v.cwe_id] = by_type.get(v.cwe_id, 0) + 1
        
        summary = f"""# {self.project_name} 安全审计报告

报告日期: {datetime.now().strftime("%Y-%m-%d")}
总漏洞数: {total}

## 按严重程度统计
{chr(10).join(f"- {sev}: {count} 个" for sev, count in sorted(by_severity.items()))}

## 按组件统计
{chr(10).join(f"- {comp}: {count} 个" for comp, count in sorted(by_component.items(), key=lambda x: -x[1])[:10])}

## 按漏洞类型统计
{chr(10).join(f"- {cwe}: {count} 个" for cwe, count in sorted(by_type.items(), key=lambda x: -x[1])[:10])}
"""
        return summary
    
    def generate_full_report(self) -> str:
        """生成完整报告"""
        report = self.generate_summary()
        report += "\n---\n\n## 漏洞详情\n"
        
        # 按严重程度排序
        severity_order = {"Critical": 0, "High": 1, "Medium": 2, "Low": 3}
        sorted_vulns = sorted(self.vulnerabilities, 
                              key=lambda v: severity_order.get(v.severity, 99))
        
        for v in sorted_vulns:
            report += v.to_markdown()
        
        return report

# 使用示例
if __name__ == "__main__":
    generator = SecurityReportGenerator("My Project")
    
    # 添加示例漏洞
    generator.add_vulnerability(VulnerabilityReport(
        cve_id="CVE-2026-XXXX",
        title="Use-After-Free in DOM Parser",
        severity="High",
        cwe_id="CWE-416",
        component="DOM: Parser",
        description="在 DOM 解析器中，当一个节点被释放后，其父节点的引用未被清除，导致 Use-After-Free。",
        exploit_scenario="攻击者可以构造恶意 HTML 页面，触发特定的 DOM 操作序列，导致已释放的内存被重新分配并写入攻击者控制的数据。",
        fix_recommendation="在释放节点时，同时清除父节点中对该节点的所有引用。使用智能指针（如 RefPtr）替代原始指针。",
        discovered_by="AI Security Auditor",
        discovery_date="2026-04-22"
    ))
    
    report = generator.generate_full_report()
    print(report)