gui.py

import os
import sys
import json
import platform
import psutil
import threading
from exploit import ExploitThread, ExploitResultsDialog
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QPushButton,
                             QTextEdit, QLabel, QGroupBox, QCheckBox, QComboBox, QTabWidget, QTableWidget,
                             QTableWidgetItem, QHeaderView, QProgressBar, QFileDialog, QMessageBox, QInputDialog,
                             QLineEdit, QSplitter, QFrame, QDialog, QFormLayout, QGridLayout, QScrollArea,
                             QGraphicsDropShadowEffect, QSizePolicy)
from PyQt5.QtCore import Qt, QThread, pyqtSignal, QTimer, QSize, QPropertyAnimation, QEasingCurve, QRect
from PyQt5.QtGui import QFont, QColor, QIcon, QPalette, QPainter, QLinearGradient, QBrush, QPen, QPixmap

from scanner import ScanThread
from utils import get_system_info, get_current_time, get_cvss_score
from translations import get_translation, get_cve_details
from source_analysis_gui import SourceCodeAnalysisTab

# 导入增强的翻译功能
from translations import (get_translation, get_cve_details, format_vulnerability_details, 
                         get_vulnerability_summary, translate_vulnerability_info, analyze_mitigation_status)

# 修复：Ubuntu编码问题
if platform.system() == "Linux":
    import locale
    # 设置系统编码
    try:
        locale.setlocale(locale.LC_ALL, 'zh_CN.UTF-8')
    except:
        try:
            locale.setlocale(locale.LC_ALL, 'C.UTF-8')
        except:
            pass




def show_quick_start_guide(parent):
    """显示快速入门指南 - 增强版本，支持"不再显示"选项"""
    # 修复：在函数开头正确导入所需组件
    from PyQt5.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, 
                                QPushButton, QTextEdit, QCheckBox, QWidget)
    from PyQt5.QtCore import Qt
    
    dialog = QDialog(parent)
    dialog.setWindowTitle("🚀 快速入门指南")
    dialog.setMinimumSize(650, 550)
    dialog.setFixedSize(700, 600)  # 固定窗口大小，防止内容溢出
    dialog.setStyleSheet("""
        QDialog {
            background-color: #f8f9fa;
        }
    """)
    
    # 设置窗口居中显示
    if parent:
        parent_geometry = parent.geometry()
        x = parent_geometry.x() + (parent_geometry.width() - 700) // 2
        y = parent_geometry.y() + (parent_geometry.height() - 600) // 2
        dialog.move(max(0, x), max(0, y))
    
    layout = QVBoxLayout(dialog)
    layout.setContentsMargins(25, 25, 25, 25)
    layout.setSpacing(20)
    
    # 标题区域
    title_container = QWidget()
    title_layout = QVBoxLayout(title_container)
    title_layout.setContentsMargins(0, 0, 0, 0)
    title_layout.setSpacing(8)
    
    title_label = QLabel("🚀 欢迎使用CPU漏洞检测工具")
    title_label.setStyleSheet("""
        QLabel {
            font-family: 'Segoe UI', 'Microsoft YaHei', 'Arial';
            font-size: 24px;
            font-weight: 700;
            color: #2c3e50;
            text-align: center;
        }
    """)
    title_label.setAlignment(Qt.AlignCenter)
    
    subtitle_label = QLabel("SpecProbe v3.0.0 - 现代化CPU安全检测平台")
    subtitle_label.setStyleSheet("""
        QLabel {
            font-family: 'Segoe UI', 'Microsoft YaHei', 'Arial';
            font-size: 14px;
            color: #667eea;
            text-align: center;
            font-weight: 500;
        }
    """)
    subtitle_label.setAlignment(Qt.AlignCenter)
    
    title_layout.addWidget(title_label)
    title_layout.addWidget(subtitle_label)
    layout.addWidget(title_container)
    
    # 内容区域 - 使用滚动文本框
    content = QTextEdit()
    content.setReadOnly(True)
    content.setStyleSheet("""
        QTextEdit {
            font-family: 'Segoe UI', 'Microsoft YaHei', 'Arial';
            font-size: 13px;
            border: 2px solid #e9ecef;
            border-radius: 12px;
            padding: 20px;
            background-color: white;
            color: #495057;
            line-height: 1.8;
        }
        QScrollBar:vertical {
            background-color: #f8f9fa;
            width: 12px;
            border-radius: 6px;
        }
        QScrollBar::handle:vertical {
            background-color: #667eea;
            border-radius: 6px;
            min-height: 20px;
        }
        QScrollBar::handle:vertical:hover {
            background-color: #764ba2;
        }
    """)
    
    guide_text = """
🎯 欢迎使用CPU漏洞检测工具！

本工具是一个现代化的CPU安全检测平台，集成了静态分析和动态PoC验证功能，帮助您全面了解系统的安全状况。

📋 主要功能模块：

🔍 1. 硬件漏洞扫描
   • 在"扫描设置"标签页中配置扫描选项
   • 支持检测20多种CPU漏洞：Spectre、Meltdown、EntryBleed等
   • 提供静态检测和动态PoC验证两种模式
   • 点击"开始扫描"执行检测（首次使用需要sudo权限）
   • 在"漏洞结果"标签页查看详细检测结果

🧬 2. 源代码安全分析
   • 在"源代码分析"标签页中添加源代码文件
   • 支持拖拽上传：直接将.c、.cpp、.java、.py等文件拖到文件列表
   • 支持多种编程语言的安全漏洞分析
   • 可选择内置或自定义QL检测脚本
   • 提供详细的代码安全评估报告

📊 3. 结果导出与报告
   • 支持导出JSON、CSV、TXT格式的原始结果
   • 可生成精美的可视化HTML报告
   • 包含详细的漏洞描述、影响分析和缓解建议
   • 支持风险评估和安全趋势分析

💡 使用技巧与注意事项：

🔧 环境准备：
   • 首次扫描时需要输入sudo密码（用于访问系统硬件信息）
   • 动态PoC分析需要运行setup_pocs.sh脚本编译测试程序
   • 源代码分析功能需要安装CodeQL工具（可选，不影响基本功能）

🎯 最佳实践：
   • 建议先运行"全部扫描"了解系统整体安全状况
   • 点击"详情"按钮查看每个漏洞的完整技术信息
   • 定期扫描以确保系统安全状态
   • 及时更新系统补丁和微码

📱 界面导航：
   • "扫描设置" - 配置检测参数和启动扫描
   • "漏洞结果" - 查看检测结果和统计信息
   • "详细输出" - 查看原始扫描日志和调试信息
   • "源代码分析" - 上传和分析源代码文件
   • "系统信息" - 查看当前系统和CPU详细信息

🛡️ 安全提醒：
   • 本工具仅用于安全研究和系统评估
   • 动态PoC测试是安全的，不会对系统造成损害
   • 所有检测结果包含详细的技术解释和缓解建议
   • 如发现高危漏洞，请及时采取相应的安全措施

❓ 需要帮助？
   • 查看"系统信息"标签了解当前运行环境
   • 点击各功能区域的"帮助"按钮获取详细说明
   • 所有检测结果都包含相关的CVE编号和参考链接

🚀 现在开始你的安全检测之旅吧！

温馨提示：如果您是首次使用，建议从"全部扫描"开始，这样可以快速了解系统的整体安全状况。
    """
    
    content.setPlainText(guide_text)
    layout.addWidget(content)
    
    # 选项区域 - 添加"不再显示"选项
    options_container = QWidget()
    options_layout = QHBoxLayout(options_container)
    options_layout.setContentsMargins(10, 10, 10, 10)
    
    # "不再显示"复选框
    dont_show_checkbox = QCheckBox("下次启动时不再显示此指南")
    dont_show_checkbox.setStyleSheet("""
        QCheckBox {
            font-family: 'Segoe UI', 'Microsoft YaHei', 'Arial';
            font-size: 12px;
            color: #6c757d;
            spacing: 8px;
        }
        QCheckBox::indicator {
            width: 16px;
            height: 16px;
            border-radius: 3px;
            border: 2px solid #bdc3c7;
            background-color: white;
        }
        QCheckBox::indicator:checked {
            background-color: #667eea;
            border-color: #667eea;
            image: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTIiIGhlaWdodD0iOSIgdmlld0JveD0iMCAwIDEyIDkiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxwYXRoIGQ9Ik0xIDQuNUw0LjUgOEwxMSAxLjUiIHN0cm9rZT0iI0ZGRkZGRiIgc3Ryb2tlLXdpZHRoPSIyIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiLz4KPC9zdmc+);
        }
        QCheckBox::indicator:hover {
            border-color: #667eea;
            background-color: rgba(102, 126, 234, 0.05);
        }
    """)
    
    options_layout.addWidget(dont_show_checkbox)
    options_layout.addStretch()
    layout.addWidget(options_container)
    
    # 按钮区域
    button_container = QWidget()
    button_layout = QHBoxLayout(button_container)
    button_layout.setContentsMargins(0, 10, 0, 0)
    button_layout.setSpacing(15)
    
    # 查看更多帮助按钮
    help_button = QPushButton("📖 查看更多帮助")
    help_button.setFixedSize(120, 40)
    help_button.setStyleSheet("""
        QPushButton {
            font-family: 'Segoe UI', 'Microsoft YaHei', 'Arial';
            background-color: #17a2b8;
            color: white;
            border: none;
            border-radius: 8px;
            padding: 8px 16px;
            font-weight: 500;
            font-size: 12px;
        }
        QPushButton:hover {
            background-color: #138496;
        }
        QPushButton:pressed {
            background-color: #117a8b;
        }
    """)
    
    def show_more_help():
        """显示更多帮助信息"""
        help_dialog = QDialog(dialog)
        help_dialog.setWindowTitle("📖 详细帮助")
        help_dialog.setMinimumSize(600, 400)
        help_dialog.setStyleSheet("QDialog { background-color: #f8f9fa; }")
        
        help_layout = QVBoxLayout(help_dialog)
        help_layout.setContentsMargins(20, 20, 20, 20)
        
        help_content = QTextEdit()
        help_content.setReadOnly(True)
        help_content.setStyleSheet(content.styleSheet())
        help_content.setPlainText("""
🔧 环境配置详细说明：

1. 动态PoC环境设置：
   • 运行 sudo ./setup_pocs.sh 下载和编译PoC
   • 编译成功后可在"扫描设置"中启用动态分析
   • 动态分析提供更准确的漏洞验证

2. CodeQL源代码分析环境：
   • 下载CodeQL CLI工具
   • 配置环境变量或在工具中指定路径
   • 支持C/C++/Java/Python等多种语言

📋 常见问题解答：

Q: 为什么需要sudo权限？
A: 漏洞检测需要读取CPU特性和内核信息，需要管理员权限。

Q: 动态分析安全吗？
A: 是的，所有PoC都是只读测试，不会修改系统或造成损害。

Q: 检测结果准确吗？
A: 工具基于官方spectre-meltdown-checker，结果高度可信。

Q: 如何解读检测结果？
A: 每个结果都有详细说明，包括CVE编号、影响描述和缓解建议。

🔗 相关资源：
   • CVE官方数据库：https://cve.mitre.org/
   • Intel安全公告：https://www.intel.com/content/www/us/en/security-center/
   • AMD安全公告：https://www.amd.com/en/corporate/product-security
        """)
        
        help_layout.addWidget(help_content)
        
        close_help_btn = QPushButton("关闭")
        close_help_btn.clicked.connect(help_dialog.accept)
        help_layout.addWidget(close_help_btn)
        
        help_dialog.exec_()
    
    help_button.clicked.connect(show_more_help)
    
    # 开始使用按钮
    start_button = QPushButton("🚀 开始使用")
    start_button.setFixedSize(120, 40)
    start_button.setStyleSheet("""
        QPushButton {
            font-family: 'Segoe UI', 'Microsoft YaHei', 'Arial';
            background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                stop:0 #667eea, stop:1 #764ba2);
            color: white;
            border: none;
            border-radius: 8px;
            padding: 8px 16px;
            font-weight: 600;
            font-size: 12px;
        }
        QPushButton:hover {
            background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                stop:0 #5a6fd8, stop:1 #6a4190);
        }
        QPushButton:pressed {
            background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                stop:0 #4e5bc4, stop:1 #5e3785);
        }
    """)
    
    def start_application():
        """开始使用应用程序"""
        # 检查用户是否选择了"不再显示"
        if dont_show_checkbox.isChecked():
            try:
                # 创建"不再显示"标记文件
                dont_show_file = os.path.expanduser('~/.cpu-vuln-scanner-dont-show')
                with open(dont_show_file, 'w', encoding='utf-8') as f:
                    import datetime
                    f.write(f"用户选择不再显示快速入门指南\n")
                    f.write(f"时间: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
                    f.write(f"版本: SpecProbe v3.0.0\n")
                print("✅ 已保存用户偏好设置：不再显示快速入门指南")
            except Exception as e:
                print(f"⚠️ 保存用户偏好设置失败: {e}")
        
        dialog.accept()
    
    start_button.clicked.connect(start_application)
    
    button_layout.addWidget(help_button)
    button_layout.addStretch()
    button_layout.addWidget(start_button)
    
    layout.addWidget(button_container)
    
    # 设置默认按钮和焦点
    start_button.setDefault(True)
    start_button.setFocus()
    
    # 执行对话框
    dialog.exec_()



def get_system_fonts():
    """获取系统适用的字体"""
    system = platform.system()
    if system == "Windows":
        return {
            'ui': ['Segoe UI', 'Microsoft YaHei', 'SimHei', 'Arial', 'sans-serif'],
            'mono': ['Consolas', 'Courier New', 'monospace']
        }
    elif system == "Darwin":  # macOS
        return {
            'ui': ['SF Pro Display', 'PingFang SC', 'Helvetica Neue', 'Arial', 'sans-serif'],
            'mono': ['SF Mono', 'Monaco', 'Menlo', 'monospace']
        }
    else:  # Linux/Unix
        return {
            'ui': ['DejaVu Sans', 'Liberation Sans', 'Noto Sans CJK SC', 'WenQuanYi Micro Hei', 'Ubuntu', 'Arial', 'sans-serif'],
            'mono': ['DejaVu Sans Mono', 'Liberation Mono', 'Ubuntu Mono', 'Courier New', 'monospace']
        }


class ModernCard(QFrame):
    """现代化卡片组件 - 修复高度控制问题"""
    def __init__(self, title="", parent=None):
        super().__init__(parent)
        self.setFrameShape(QFrame.StyledPanel)
        # 修复：默认使用preferred大小策略，允许固定高度
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
        
        # 修复：确保卡片有明确的边界约束
        self.setStyleSheet("""
            QFrame {
                background-color: white;
                border-radius: 12px;
                border: 1px solid #e8e9ea;
                margin: 2px;
            }
        """)
        
        # 添加阴影效果
        shadow = QGraphicsDropShadowEffect()
        shadow.setBlurRadius(10)
        shadow.setColor(QColor(0, 0, 0, 20))
        shadow.setOffset(0, 2)
        self.setGraphicsEffect(shadow)
        
        self.layout = QVBoxLayout(self)
        # 修复：调整内边距，为固定高度的内容留出空间
        self.layout.setContentsMargins(20, 15, 20, 15)
        self.layout.setSpacing(10)
        
        if title:
            fonts = get_system_fonts()
            self.title_label = QLabel(title)
            self.title_label.setFixedHeight(25)  # 固定标题高度
            self.title_label.setStyleSheet(f"""
                QLabel {{
                    font-family: {', '.join(fonts['ui'])};
                    font-size: 16px;
                    font-weight: 600;
                    color: #2c3e50;
                    margin-bottom: 5px;
                    border: none;
                    padding: 0px;
                }}
            """)
            self.layout.addWidget(self.title_label)


# 在ReportExporter类中也添加增强功能
class ReportExporter:
    """可视化报告导出器 - 增强版本"""
    
    def __init__(self, scan_results, system_info):
        self.scan_results = scan_results
        self.system_info = system_info
    
    def export_html_report(self, file_path):
        """导出HTML格式的可视化报告"""
        html_content = self._generate_enhanced_html_report()
        
        try:
            with open(file_path, 'w', encoding='utf-8') as f:
                f.write(html_content)
            return True, "HTML报告导出成功"
        except Exception as e:
            return False, f"HTML报告导出失败: {str(e)}"
    
    def _generate_enhanced_html_report(self):
        """生成增强的HTML报告内容"""
        # 使用增强的汇总功能
        try:
            from translations import get_vulnerability_summary
            summary = get_vulnerability_summary(self.scan_results, "zh")
            total_vulns = summary['total']
            affected_count = summary['vulnerable']
            safe_count = summary['safe']
            high_risk_count = summary['high_risk']
            medium_risk_count = summary['medium_risk']
            risk_percentage = summary['risk_percentage']
        except:
            # 回退到基本统计
            total_vulns = len(self.scan_results)
            affected_count = sum(1 for result in self.scan_results if result.get("VULNERABLE", False))
            safe_count = total_vulns - affected_count
            high_risk_count = affected_count // 2  # 估算
            medium_risk_count = affected_count - high_risk_count
            risk_percentage = round((affected_count / total_vulns * 100) if total_vulns > 0 else 0, 1)
        
        # 获取当前时间
        import datetime
        current_time = datetime.datetime.now().strftime("%Y年%m月%d日 %H:%M:%S")
        
        html_content = f"""
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>CPU漏洞检测报告</title>
    <style>
        body {{
            font-family: 'Microsoft YaHei', 'Segoe UI', 'Arial', sans-serif;
            line-height: 1.6;
            margin: 0;
            padding: 20px;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
        }}
        .container {{
            max-width: 1200px;
            margin: 0 auto;
            background: white;
            border-radius: 15px;
            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
            overflow: hidden;
        }}
        .header {{
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 30px;
            text-align: center;
        }}
        .header h1 {{
            margin: 0;
            font-size: 2.5em;
            font-weight: 300;
        }}
        .header .subtitle {{
            margin-top: 10px;
            opacity: 0.9;
            font-size: 1.1em;
        }}
        .content {{
            padding: 30px;
        }}
        .summary-grid {{
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 20px;
            margin-bottom: 30px;
        }}
        .summary-card {{
            background: #f8f9fa;
            border-radius: 10px;
            padding: 20px;
            text-align: center;
            border-left: 4px solid;
            position: relative;
            overflow: hidden;
        }}
        .summary-card.total {{ border-left-color: #3498db; }}
        .summary-card.vulnerable {{ border-left-color: #e74c3c; }}
        .summary-card.safe {{ border-left-color: #2ecc71; }}
        .summary-card.high-risk {{ border-left-color: #c0392b; }}
        .summary-card.medium-risk {{ border-left-color: #f39c12; }}
        .summary-card.risk-percentage {{ border-left-color: #9b59b6; }}
        
        .summary-number {{
            font-size: 2.5em;
            font-weight: bold;
            margin-bottom: 5px;
        }}
        .summary-label {{
            color: #666;
            font-size: 0.9em;
            text-transform: uppercase;
            letter-spacing: 1px;
        }}
        .section {{
            margin-bottom: 40px;
        }}
        .section h2 {{
            color: #2c3e50;
            border-bottom: 2px solid #667eea;
            padding-bottom: 10px;
            margin-bottom: 20px;
        }}
        .vulnerability-grid {{
            display: grid;
            gap: 20px;
        }}
        .vuln-card {{
            background: white;
            border: 1px solid #e0e0e0;
            border-radius: 10px;
            padding: 20px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
            transition: transform 0.2s;
        }}
        .vuln-card:hover {{
            transform: translateY(-2px);
            box-shadow: 0 4px 15px rgba(0,0,0,0.15);
        }}
        .vuln-card.vulnerable {{
            border-left: 4px solid #e74c3c;
            background: #fdf2f2;
        }}
        .vuln-card.safe {{
            border-left: 4px solid #2ecc71;
            background: #f0f9f0;
        }}
        .vuln-card.unknown {{
            border-left: 4px solid #f39c12;
            background: #fff9f0;
        }}
        .vuln-header {{
            display: flex;
            justify-content: space-between;
            align-items: center;
            margin-bottom: 15px;
        }}
        .vuln-title {{
            font-size: 1.2em;
            font-weight: bold;
            color: #2c3e50;
        }}
        .vuln-status {{
            padding: 5px 15px;
            border-radius: 20px;
            font-size: 0.9em;
            font-weight: bold;
        }}
        .status-vulnerable {{
            background: #e74c3c;
            color: white;
        }}
        .status-safe {{
            background: #2ecc71;
            color: white;
        }}
        .status-unknown {{
            background: #f39c12;
            color: white;
        }}
        .vuln-description {{
            color: #666;
            margin-bottom: 10px;
        }}
        .vuln-details {{
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 15px;
            margin-top: 15px;
        }}
        .detail-item {{
            background: #f8f9fa;
            padding: 10px;
            border-radius: 5px;
        }}
        .detail-label {{
            font-weight: bold;
            color: #667eea;
            font-size: 0.9em;
            margin-bottom: 5px;
        }}
        .detail-value {{
            color: #2c3e50;
            font-size: 0.9em;
        }}
        .system-info {{
            background: #f8f9fa;
            border-radius: 10px;
            padding: 20px;
            margin-bottom: 20px;
        }}
        .system-grid {{
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
            gap: 15px;
        }}
        .footer {{
            background: #2c3e50;
            color: white;
            text-align: center;
            padding: 20px;
            font-size: 0.9em;
        }}
        .chart-container {{
            background: white;
            border-radius: 10px;
            padding: 20px;
            margin: 20px 0;
            text-align: center;
        }}
        .progress-bar {{
            width: 100%;
            height: 20px;
            background-color: #e9ecef;
            border-radius: 10px;
            overflow: hidden;
            margin: 10px 0;
        }}
        .progress-fill {{
            height: 100%;
            background: linear-gradient(90deg, #2ecc71, #27ae60);
            transition: width 0.3s ease;
        }}
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>🛡️ CPU漏洞检测报告</h1>
            <div class="subtitle">生成时间: {current_time}</div>
        </div>
        
        <div class="content">
            <!-- 增强的统计概览 -->
            <div class="section">
                <h2>📊 检测概览</h2>
                <div class="summary-grid">
                    <div class="summary-card total">
                        <div class="summary-number" style="color: #3498db;">{total_vulns}</div>
                        <div class="summary-label">总检测项目</div>
                    </div>
                    <div class="summary-card vulnerable">
                        <div class="summary-number" style="color: #e74c3c;">{affected_count}</div>
                        <div class="summary-label">受影响项目</div>
                    </div>
                    <div class="summary-card safe">
                        <div class="summary-number" style="color: #2ecc71;">{safe_count}</div>
                        <div class="summary-label">安全项目</div>
                    </div>
                    <div class="summary-card high-risk">
                        <div class="summary-number" style="color: #c0392b;">{high_risk_count}</div>
                        <div class="summary-label">高危漏洞</div>
                    </div>
                    <div class="summary-card medium-risk">
                        <div class="summary-number" style="color: #f39c12;">{medium_risk_count}</div>
                        <div class="summary-label">中危漏洞</div>
                    </div>
                    <div class="summary-card risk-percentage">
                        <div class="summary-number" style="color: #9b59b6;">{risk_percentage}%</div>
                        <div class="summary-label">风险比例</div>
                    </div>
                </div>
            </div>
            
            <!-- 系统信息 -->
            <div class="section">
                <h2>🖥️ 系统信息</h2>
                <div class="system-info">
                    <div class="system-grid">
                        <div class="detail-item">
                            <div class="detail-label">操作系统</div>
                            <div class="detail-value">{self.system_info.get('os', '未知')}</div>
                        </div>
                        <div class="detail-item">
                            <div class="detail-label">CPU型号</div>
                            <div class="detail-value">{self.system_info.get('cpu', '未知')}</div>
                        </div>
                        <div class="detail-item">
                            <div class="detail-label">内核版本</div>
                            <div class="detail-value">{self.system_info.get('kernel', '未知')}</div>
                        </div>
                        <div class="detail-item">
                            <div class="detail-label">可用内存</div>
                            <div class="detail-value">{self.system_info.get('memory', '未知')}</div>
                        </div>
                    </div>
                </div>
            </div>
            
            <!-- 漏洞详情 -->
            <div class="section">
                <h2>🔍 漏洞检测详情</h2>
                <div class="vulnerability-grid">
        """
        
        # 添加每个漏洞的详细信息 - 增强版本
        for result in self.scan_results:
            vulnerable = result.get("VULNERABLE", False)
            
            if vulnerable:
                card_class = "vulnerable"
                status_class = "status-vulnerable" 
                status_text = "受影响"
            elif vulnerable is None:
                card_class = "unknown"
                status_class = "status-unknown"
                status_text = "未知"
            else:
                card_class = "safe"
                status_class = "status-safe"
                status_text = "安全"
            
            cve_id = result.get("CVE", "")
            name = result.get("NAME", "")
            description = result.get("DESCRIPTION", "暂无描述")
            impact = result.get("IMPACT", "暂无影响信息")
            mitigation = result.get("MITIGATION", "暂无缓解措施")
            infos = result.get("INFOS", "")
            mitigation_status = result.get("MITIGATION_STATUS", "")
            
            # 翻译检测信息
            try:
                from translations import translate_vulnerability_info
                translated_infos = translate_vulnerability_info(infos, "zh")
            except:
                translated_infos = infos
            
            html_content += f"""
                    <div class="vuln-card {card_class}">
                        <div class="vuln-header">
                            <div class="vuln-title">{cve_id} - {name}</div>
                            <div class="vuln-status {status_class}">{status_text}</div>
                        </div>
                        <div class="vuln-description">{description}</div>
                        <div class="vuln-details">
                            <div class="detail-item">
                                <div class="detail-label">检测信息</div>
                                <div class="detail-value">{translated_infos}</div>
                            </div>
                            <div class="detail-item">
                                <div class="detail-label">缓解状态</div>
                                <div class="detail-value">{mitigation_status}</div>
                            </div>
                            <div class="detail-item">
                                <div class="detail-label">影响</div>
                                <div class="detail-value">{impact}</div>
                            </div>
                            <div class="detail-item">
                                <div class="detail-label">缓解措施</div>
                                <div class="detail-value">{mitigation}</div>
                            </div>
                        </div>
                    </div>
            """
        
        html_content += f"""
                </div>
            </div>
        </div>
        
        <div class="footer">
            <p>📋 本报告由CPU漏洞检测工具自动生成 | 🛡️ 建议定期进行安全检测 | ⚡ 及时更新系统补丁</p>
            <p>风险评估：{risk_percentage}% | 如需技术支持，请参考相关CVE公告和厂商安全建议</p>
            <p>生成时间：{current_time} | 检测项目：{total_vulns}个</p>
        </div>
    </div>
</body>
</html>
        """
        
        return html_content


class GradientHeader(QLabel):
    """现代化渐变头部 - 修复字体问题"""
    def __init__(self, text, parent=None):
        super().__init__(text, parent)
        self.setFixedHeight(80)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
        self.setAlignment(Qt.AlignCenter)
        
        # 修复：使用系统兼容字体
        fonts = get_system_fonts()
        font = QFont()
        font.setFamily(fonts['ui'][0])  # 使用第一个可用字体
        font.setPointSize(24)
        font.setBold(True)
        self.setFont(font)
        
    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        
        # 现代化渐变背景
        gradient = QLinearGradient(0, 0, self.width(), 0)
        gradient.setColorAt(0, QColor("#667eea"))
        gradient.setColorAt(0.5, QColor("#764ba2"))
        gradient.setColorAt(1, QColor("#f093fb"))
        painter.fillRect(self.rect(), QBrush(gradient))
        
        # 文字效果
        pen = QPen(QColor("white"))
        painter.setPen(pen)
        painter.setFont(self.font())
        painter.drawText(self.rect(), Qt.AlignCenter, self.text())


class ModernProgressBar(QProgressBar):
    """现代化进度条 - 支持自适应"""
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setFixedHeight(8)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
        self.setTextVisible(False)
        self.setStyleSheet("""
            QProgressBar {
                border-radius: 4px;
                background-color: #ecf0f1;
            }
            QProgressBar::chunk {
                border-radius: 4px;
                background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                    stop:0 #667eea, stop:0.5 #764ba2, stop:1 #f093fb);
            }
        """)


class AnimatedButton(QPushButton):
    """带动画效果的按钮 - 修复字体截断问题"""
    def __init__(self, text, color_scheme="primary", parent=None):
        super().__init__(text, parent)
        self.color_scheme = color_scheme
        self.setMinimumHeight(48)  # 增加最小高度
        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
        
        # 修复：使用系统兼容字体
        fonts = get_system_fonts()
        font = QFont()
        font.setFamily(fonts['ui'][0])
        font.setPointSize(11)
        font.setWeight(QFont.Medium)
        self.setFont(font)
        self.setCursor(Qt.PointingHandCursor)
        
        # 设置按钮样式
        if color_scheme == "primary":
            self.setStyleSheet(f"""
                QPushButton {{
                    font-family: {', '.join(fonts['ui'])};
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #667eea, stop:1 #764ba2);
                    color: white;
                    border: none;
                    border-radius: 8px;
                    padding: 14px 24px;
                    font-weight: 500;
                    font-size: 13px;
                    min-height: 20px;
                }}
                QPushButton:hover {{
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #5a6fd8, stop:1 #6a4190);
                    border: 2px solid #4e5bc4;
                    padding: 12px 22px;
                }}
                QPushButton:pressed {{
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #4e5bc4, stop:1 #5e3785);
                }}
                QPushButton:disabled {{
                    background-color: #bdc3c7;
                    color: #7f8c8d;
                }}
            """)
        elif color_scheme == "danger":
            self.setStyleSheet(f"""
                QPushButton {{
                    font-family: {', '.join(fonts['ui'])};
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #ff6b6b, stop:1 #ee5a52);
                    color: white;
                    border: none;
                    border-radius: 8px;
                    padding: 14px 24px;
                    font-weight: 500;
                    font-size: 13px;
                    min-height: 20px;
                }}
                QPushButton:hover {{
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #ff5757, stop:1 #dc4c47);
                    border: 2px solid #ff4757;
                    padding: 12px 22px;
                }}
                QPushButton:pressed {{
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #ff4757, stop:1 #c44242);
                }}
            """)
        elif color_scheme == "success":
            self.setStyleSheet(f"""
                QPushButton {{
                    font-family: {', '.join(fonts['ui'])};
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #2ecc71, stop:1 #27ae60);
                    color: white;
                    border: none;
                    border-radius: 8px;
                    padding: 14px 24px;
                    font-weight: 500;
                    font-size: 13px;
                    min-height: 20px;
                }}
                QPushButton:hover {{
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #27c46e, stop:1 #239954);
                    border: 2px solid #1e8449;
                    padding: 12px 22px;
                }}
            """)
        else:  # secondary
            self.setStyleSheet(f"""
                QPushButton {{
                    font-family: {', '.join(fonts['ui'])};
                    background-color: #95a5a6;
                    color: white;
                    border: none;
                    border-radius: 8px;
                    padding: 14px 24px;
                    font-weight: 500;
                    font-size: 13px;
                    min-height: 20px;
                }}
                QPushButton:hover {{
                    background-color: #7f8c8d;
                    border: 2px solid #6c7b7d;
                    padding: 12px 22px;
                }}
            """)

class StatCard(QFrame):
    """统计卡片 - 修复字体问题"""
    def __init__(self, title, value, color, parent=None):
        super().__init__(parent)
        # 改为最小尺寸和可扩展策略
        self.setMinimumSize(160, 100)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
        self.setStyleSheet(f"""
            QFrame {{
                background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                    stop:0 {color[0]}, stop:1 {color[1]});
                border-radius: 12px;
                border: none;
            }}
        """)
        
        # 添加阴影
        shadow = QGraphicsDropShadowEffect()
        shadow.setBlurRadius(15)
        shadow.setColor(QColor(0, 0, 0, 30))
        shadow.setOffset(0, 3)
        self.setGraphicsEffect(shadow)
        
        layout = QVBoxLayout(self)
        layout.setContentsMargins(20, 15, 20, 15)
        layout.setSpacing(5)
        
        # 修复：使用系统兼容字体
        fonts = get_system_fonts()
        
        # 标题
        title_label = QLabel(title)
        title_label.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                color: rgba(255, 255, 255, 0.9);
                font-size: 14px;
                font-weight: 500;
                border: none;
            }}
        """)
        title_label.setAlignment(Qt.AlignCenter)
        layout.addWidget(title_label)
        
        # 数值
        self.value_label = QLabel(str(value))
        self.value_label.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                color: white;
                font-size: 32px;
                font-weight: 700;
                border: none;
            }}
        """)
        self.value_label.setAlignment(Qt.AlignCenter)
        layout.addWidget(self.value_label)
        
        layout.addStretch()
    
    def update_value(self, value):
        self.value_label.setText(str(value))


class ModernComboBox(QComboBox):
    """现代化下拉框 - 修复字体截断问题"""
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setMinimumHeight(42)  # 增加最小高度
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
        
        # 修复：使用系统兼容字体
        fonts = get_system_fonts()
        self.setStyleSheet(f"""
            QComboBox {{
                font-family: {', '.join(fonts['ui'])};
                border: 2px solid #e8e9ea;
                border-radius: 8px;
                padding: 10px 12px;
                background-color: white;
                font-size: 13px;
                color: #2c3e50;
                min-height: 20px;
            }}
            QComboBox:focus {{
                border-color: #667eea;
                outline: none;
            }}
            QComboBox:hover {{
                border-color: #667eea;
            }}
            QComboBox::drop-down {{
                border: none;
                width: 30px;
                border-top-right-radius: 8px;
                border-bottom-right-radius: 8px;
            }}
            QComboBox::down-arrow {{
                image: none;
                border-left: 5px solid transparent;
                border-right: 5px solid transparent;
                border-top: 5px solid #7f8c8d;
                margin-right: 10px;
            }}
            QComboBox::down-arrow:hover {{
                border-top: 5px solid #667eea;
            }}
            QComboBox QAbstractItemView {{
                font-family: {', '.join(fonts['ui'])};
                border: 2px solid #e8e9ea;
                border-radius: 8px;
                background-color: white;
                selection-background-color: #667eea;
                selection-color: white;
                padding: 5px;
                font-size: 13px;
                min-height: 25px;
            }}
            QComboBox QAbstractItemView::item {{
                padding: 8px 12px;
                border: none;
                min-height: 20px;
            }}
            QComboBox QAbstractItemView::item:hover {{
                background-color: rgba(102, 126, 234, 0.1);
                color: #2c3e50;
            }}
        """)


class ModernCheckBox(QCheckBox):
    """现代化复选框 - 修复 setWordWrap 错误"""
    def __init__(self, text, parent=None):
        super().__init__(text, parent)
        self.setMinimumHeight(40)  # 进一步增加最小高度
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)  # 改为可扩展
        
        # 修复：使用系统兼容字体
        fonts = get_system_fonts()
        self.setStyleSheet(f"""
            QCheckBox {{
                font-family: {', '.join(fonts['ui'])};
                font-size: 14px;
                color: #2c3e50;
                spacing: 12px;
                padding: 8px 5px;
                min-height: 24px;
                background-color: transparent;
            }}
            QCheckBox::indicator {{
                width: 22px;
                height: 22px;
                border-radius: 4px;
                border: 2px solid #bdc3c7;
                background-color: white;
                margin: 3px;
                position: relative;
                top: 0px;
            }}
            QCheckBox::indicator:checked {{
                background-color: #667eea;
                border-color: #667eea;
                image: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTEiIHZpZXdCb3g9IjAgMCAxNCAxMSIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTEgNS41TDUgOS41TDEzIDEuNSIgc3Ryb2tlPSIjRkZGRkZGIiBzdHJva2Utd2lkdGg9IjIuNSIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIi8+Cjwvc3ZnPg==);
            }}
            QCheckBox::indicator:hover {{
                border-color: #667eea;
                background-color: rgba(102, 126, 234, 0.05);
            }}
            QCheckBox::indicator:disabled {{
                background-color: #ecf0f1;
                border-color: #bdc3c7;
            }}
            QCheckBox:disabled {{
                color: #7f8c8d;
            }}
        """)
        
        # 修复：移除 setWordWrap 调用，因为 QCheckBox 没有这个方法
        # self.setWordWrap(False)  # 移除这行
        
        # 设置工具提示为完整文本（以防文本太长）
        self.setToolTip(text)


# 完全重写的SystemInfoTab类 - 彻底解决CPU详细信息超出边界问题
class SystemInfoTab(QWidget):
    def __init__(self, system_info, parent=None):
        super().__init__(parent)
        self.system_info = system_info
        self.init_ui()
        
    def init_ui(self):
        # 创建滚动区域作为主容器
        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll_area.setFrameShape(QScrollArea.NoFrame)
        
        # 主容器
        main_container = QWidget()
        scroll_area.setWidget(main_container)
        
        # 主布局
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.addWidget(scroll_area)
        
        # 内容布局
        layout = QVBoxLayout(main_container)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(20)
        
        # 修复：使用系统兼容字体
        fonts = get_system_fonts()
        
        # 系统信息卡片
        system_card = ModernCard("🖥️ 系统信息")
        system_card.setFixedHeight(200)  # 固定高度
        
        # 系统信息网格容器
        info_container = QWidget()
        info_grid = QGridLayout(info_container)
        info_grid.setSpacing(15)
        info_grid.setContentsMargins(10, 10, 10, 10)
        
        info_items = [
            ("操作系统", self.system_info.get("os", "未知"), "#3498db"),
            ("CPU型号", self.system_info.get("cpu", "未知"), "#e74c3c"),
            ("内核版本", self.system_info.get("kernel", "未知"), "#f39c12"),
            ("可用内存", self.system_info.get("memory", "未知"), "#2ecc71")
        ]
        
        for i, (label, value, color) in enumerate(info_items):
            row = i // 2
            col = (i % 2) * 2
            
            # 标签
            label_widget = QLabel(label + ":")
            label_widget.setFixedHeight(30)
            label_widget.setStyleSheet(f"""
                QLabel {{
                    font-family: {', '.join(fonts['ui'])};
                    font-weight: 600;
                    font-size: 14px;
                    color: {color};
                    border: none;
                }}
            """)
            
            # 值
            value_widget = QLabel(value)
            value_widget.setFixedHeight(30)
            value_widget.setStyleSheet(f"""
                QLabel {{
                    font-family: {', '.join(fonts['ui'])};
                    font-size: 13px;
                    color: #2c3e50;
                    border: none;
                    padding: 5px 8px;
                    background-color: #f8f9fa;
                    border-radius: 6px;
                }}
            """)
            value_widget.setWordWrap(True)
            value_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
            
            info_grid.addWidget(label_widget, row, col)
            info_grid.addWidget(value_widget, row, col + 1)
        
        # 设置列权重
        info_grid.setColumnStretch(1, 1)
        info_grid.setColumnStretch(3, 1)
        
        system_card.layout.addWidget(info_container)
        layout.addWidget(system_card)
        
        # 修复：CPU详细信息卡片 - 严格控制高度
        cpu_card = ModernCard("🔧 CPU详细信息")
        # 关键修复：设置固定高度，不允许扩展
        cpu_card.setFixedHeight(320)
        cpu_card.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
        
        # CPU卡片内容容器
        cpu_content_widget = QWidget()
        cpu_content_layout = QVBoxLayout(cpu_content_widget)
        cpu_content_layout.setContentsMargins(10, 5, 10, 10)
        cpu_content_layout.setSpacing(10)
        
        # 工具栏
        cpu_toolbar = QWidget()
        cpu_toolbar.setFixedHeight(40)
        cpu_toolbar_layout = QHBoxLayout(cpu_toolbar)
        cpu_toolbar_layout.setContentsMargins(0, 0, 0, 0)
        
        cpu_expand_button = QPushButton("🔍 在新窗口中查看完整信息")
        cpu_expand_button.setFixedSize(200, 32)
        cpu_expand_button.setStyleSheet(f"""
            QPushButton {{
                font-family: {', '.join(fonts['ui'])};
                background-color: #9b59b6;
                color: white;
                border: none;
                border-radius: 6px;
                padding: 6px 12px;
                font-size: 11px;
                font-weight: 500;
            }}
            QPushButton:hover {{
                background-color: #8e44ad;
            }}
        """)
        cpu_expand_button.clicked.connect(self.show_cpu_details_in_new_window)
        
        cpu_toolbar_layout.addWidget(cpu_expand_button)
        cpu_toolbar_layout.addStretch()
        
        cpu_content_layout.addWidget(cpu_toolbar)
        
        # 修复：CPU详细信息文本框 - 绝对限制高度
        self.cpu_details_text = QTextEdit()
        self.cpu_details_text.setReadOnly(True)
        # 关键修复：严格限制高度，确保不超出卡片
        fixed_text_height = 320 - 80 - 40 - 20  # 卡片高度 - 标题区域 - 工具栏 - 边距
        self.cpu_details_text.setFixedHeight(fixed_text_height)  # 固定高度180px
        self.cpu_details_text.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
        self.cpu_details_text.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        self.cpu_details_text.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        self.cpu_details_text.setStyleSheet(f"""
            QTextEdit {{
                font-family: {', '.join(fonts['mono'])};
                font-size: 9pt;
                border: 1px solid #e8e9ea;
                border-radius: 6px;
                padding: 8px;
                background-color: #f8f9fa;
                color: #2c3e50;
                line-height: 1.2;
            }}
            QScrollBar:vertical {{
                background-color: #e8e9ea;
                width: 8px;
                border-radius: 4px;
            }}
            QScrollBar::handle:vertical {{
                background-color: #667eea;
                border-radius: 4px;
                min-height: 10px;
            }}
            QScrollBar::handle:vertical:hover {{
                background-color: #764ba2;
            }}
            QScrollBar:horizontal {{
                background-color: #e8e9ea;
                height: 8px;
                border-radius: 4px;
            }}
            QScrollBar::handle:horizontal {{
                background-color: #667eea;
                border-radius: 4px;
                min-width: 10px;
            }}
        """)
        
        # 加载CPU信息
        self.load_cpu_details()
        cpu_content_layout.addWidget(self.cpu_details_text)
        
        # 将内容添加到CPU卡片
        cpu_card.layout.addWidget(cpu_content_widget)
        layout.addWidget(cpu_card)
        
        # 修复：添加拉伸空间，但不让卡片扩展
        layout.addStretch()
        
        # 设置滚动区域样式
        scroll_area.setStyleSheet(f"""
            QScrollArea {{
                background-color: transparent;
                border: none;
            }}
            QScrollBar:vertical {{
                background-color: #f8f9fa;
                width: 12px;
                border-radius: 6px;
            }}
            QScrollBar::handle:vertical {{
                background-color: #667eea;
                border-radius: 6px;
                min-height: 20px;
            }}
            QScrollBar::handle:vertical:hover {{
                background-color: #764ba2;
            }}
        """)
    
    def load_cpu_details(self):
        """加载CPU详细信息 - 截断长内容"""
        try:
            if platform.system() == "Linux":
                with open("/proc/cpuinfo", "r", encoding='utf-8') as f:
                    content = f.read()
                    
                # 修复：限制显示内容长度，避免过长内容
                lines = content.split('\n')
                if len(lines) > 50:  # 只显示前50行
                    content = '\n'.join(lines[:50]) + '\n\n... (内容已截断，点击"在新窗口中查看完整信息"查看全部)'
                
                self.cpu_info_content = content
                self.cpu_details_text.setText(content)
            else:
                self.cpu_info_content = f"CPU型号: {self.system_info.get('cpu', '未知')}\n" \
                                      f"系统: {self.system_info.get('os', '未知')}\n" \
                                      f"内核: {self.system_info.get('kernel', '未知')}\n\n" \
                                      f"详细的CPU信息需要在Linux系统中查看 /proc/cpuinfo 文件。"
                self.cpu_details_text.setText(self.cpu_info_content)
        except Exception as e:
            self.cpu_info_content = f"无法获取CPU详细信息: {str(e)}\n\n请检查系统权限或在新窗口中查看。"
            self.cpu_details_text.setText(self.cpu_info_content)
    
    def show_cpu_details_in_new_window(self):
        """在新窗口中显示完整的CPU详细信息"""
        dialog = QDialog(self)
        dialog.setWindowTitle("🔧 CPU详细信息")
        dialog.setMinimumSize(750, 550)
        dialog.resize(850, 650)
        dialog.setStyleSheet("QDialog { background-color: #f8f9fa; }")
        
        layout = QVBoxLayout(dialog)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(15)
        
        fonts = get_system_fonts()
        
        # 标题
        title_label = QLabel("🔧 CPU详细信息")
        title_label.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                font-size: 20px;
                font-weight: 700;
                color: #2c3e50;
                margin-bottom: 10px;
            }}
        """)
        layout.addWidget(title_label)
        
        # 重新加载完整内容
        full_content = ""
        try:
            if platform.system() == "Linux":
                with open("/proc/cpuinfo", "r", encoding='utf-8') as f:
                    full_content = f.read()
            else:
                full_content = getattr(self, 'cpu_info_content', '无内容')
        except:
            full_content = "无法读取CPU信息"
        
        # 文本区域
        text_edit = QTextEdit()
        text_edit.setReadOnly(True)
        text_edit.setText(full_content)
        text_edit.setStyleSheet(f"""
            QTextEdit {{
                font-family: {', '.join(fonts['mono'])};
                font-size: 11pt;
                border: 2px solid #e8e9ea;
                border-radius: 8px;
                padding: 15px;
                background-color: white;
                color: #2c3e50;
                line-height: 1.4;
            }}
            QScrollBar:vertical {{
                background-color: #f8f9fa;
                width: 12px;
                border-radius: 6px;
            }}
            QScrollBar::handle:vertical {{
                background-color: #667eea;
                border-radius: 6px;
                min-height: 20px;
            }}
        """)
        layout.addWidget(text_edit)
        
        # 按钮区域
        button_layout = QHBoxLayout()
        
        # 复制按钮
        copy_button = QPushButton("📋 复制全部内容")
        copy_button.setStyleSheet(f"""
            QPushButton {{
                font-family: {', '.join(fonts['ui'])};
                background-color: #3498db;
                color: white;
                border: none;
                border-radius: 6px;
                padding: 10px 20px;
                font-size: 12px;
                font-weight: 500;
            }}
            QPushButton:hover {{
                background-color: #2980b9;
            }}
        """)
        copy_button.clicked.connect(lambda: QApplication.clipboard().setText(text_edit.toPlainText()))
        
        # 保存按钮
        save_button = QPushButton("💾 保存到文件")
        save_button.setStyleSheet(f"""
            QPushButton {{
                font-family: {', '.join(fonts['ui'])};
                background-color: #27ae60;
                color: white;
                border: none;
                border-radius: 6px;
                padding: 10px 20px;
                font-size: 12px;
                font-weight: 500;
            }}
            QPushButton:hover {{
                background-color: #219a52;
            }}
        """)
        
        def save_to_file():
            from PyQt5.QtWidgets import QFileDialog
            file_path, _ = QFileDialog.getSaveFileName(
                dialog, "保存CPU信息", "cpu_info.txt", "文本文件 (*.txt)"
            )
            if file_path:
                try:
                    with open(file_path, 'w', encoding='utf-8') as f:
                        f.write(text_edit.toPlainText())
                    QMessageBox.information(dialog, "保存成功", f"CPU信息已保存到: {file_path}")
                except Exception as e:
                    QMessageBox.critical(dialog, "保存失败", f"无法保存文件: {str(e)}")
        
        save_button.clicked.connect(save_to_file)
        
        # 关闭按钮
        close_button = QPushButton("✖️ 关闭")
        close_button.setStyleSheet(f"""
            QPushButton {{
                font-family: {', '.join(fonts['ui'])};
                background-color: #95a5a6;
                color: white;
                border: none;
                border-radius: 6px;
                padding: 10px 20px;
                font-size: 12px;
                font-weight: 500;
            }}
            QPushButton:hover {{
                background-color: #7f8c8d;
            }}
        """)
        close_button.clicked.connect(dialog.accept)
        
        button_layout.addWidget(copy_button)
        button_layout.addWidget(save_button)
        button_layout.addStretch()
        button_layout.addWidget(close_button)
        layout.addLayout(button_layout)
        
        dialog.exec_()



# 修复：添加主函数，确保正确的应用程序启动
def main():
    """主函数 - 确保在Ubuntu中正确显示中文"""
    # 修复：设置环境变量
    if platform.system() == "Linux":
        os.environ.setdefault('LANG', 'zh_CN.UTF-8')
        os.environ.setdefault('LC_ALL', 'zh_CN.UTF-8')
    
    app = QApplication(sys.argv)
    
    # 修复：为Linux系统设置应用程序属性
    if platform.system() == "Linux":
        app.setApplicationName("SpecProbe")
        app.setApplicationDisplayName("SpecProbe")
        app.setApplicationVersion("3.0.0")
        
        # 设置默认字体
        font = QFont("DejaVu Sans", 9)
        app.setFont(font)
    
    window = VulnerabilityScannerGUI()
    window.show()
    
    return app.exec_()


if __name__ == "__main__":
    sys.exit(main())


class VulnerabilityScannerGUI(QMainWindow):
    def __init__(self):
        super().__init__()

        # 修复：设置应用程序编码和字体
        app = QApplication.instance()
        if app:
            # 设置应用程序的默认编码
            app.setApplicationDisplayName("SpecProbe")
            # 为Ubuntu设置默认字体
            if platform.system() == "Linux":
                font = QFont("DejaVu Sans", 9)
                app.setFont(font)
        
        # 修复：确保窗口标题正确编码
        self.setWindowTitle("CPU漏洞检测工具")
        self.setGeometry(150, 150, 1200, 800)
        self.setMinimumSize(1000, 700)
        # 允许用户调整窗口大小
        self.setWindowFlags(Qt.Window | Qt.WindowMinimizeButtonHint | Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint)
        self.script_path = os.path.join(os.path.dirname(__file__), "main.sh")
        self.system_info = get_system_info()

        # 修复：在init_ui()之前初始化所有必需的属性
        self.options = {
            "live_mode": True,
            "explain": True,
            "verbose": False,
            "output_format": "json",
            "cves": []
        }
        
        self.exploit_thread = None
        self.current_language = "zh"  # 新增：当前语言设置
        
        # 修复：在init_ui()之前检查PoC环境
        self.poc_available = self.check_poc_environment()
        
        # 新增：动态分析选项
        self.dynamic_analysis_enabled = True

        # 现在调用init_ui()，此时所有必需的属性都已初始化
        self.init_ui()

        if not os.path.exists(self.script_path):
            QMessageBox.critical(self, "错误", "未找到漏洞检测脚本，请确保main.sh在相同目录")
            sys.exit(1)
        
        if not os.access(self.script_path, os.X_OK):
            try:
                os.chmod(self.script_path, 0o755)
            except:
                QMessageBox.warning(self, "警告", "漏洞检测脚本没有执行权限")
        
        self.current_user = os.getenv("USER")
        self.is_root = os.geteuid() == 0
        
        # 修复：组合PoC状态和root权限状态信息
        status_messages = []
        
        # 添加PoC状态信息
        tools_dir = os.path.join(os.path.dirname(__file__), "tools")
        compiled_dir = os.path.join(tools_dir, "compiled")
        if os.path.exists(compiled_dir):
            required_pocs = ["spectre-v2", "spectre-v4", "zombieload", "entrybleed"]
            available_pocs = [poc for poc in required_pocs 
                            if os.path.exists(os.path.join(compiled_dir, poc)) 
                            and os.access(os.path.join(compiled_dir, poc), os.X_OK)]
            if available_pocs:
                status_messages.append(f"🛡️ 动态分析就绪 ({len(available_pocs)}/{len(required_pocs)} PoC可用)")
            else:
                status_messages.append("⚠️ 未找到PoC")
        else:
            status_messages.append("⚠️ 建议运行setup_pocs.sh")
        
        # 添加root权限状态信息
        if not self.is_root:
            status_messages.append(f"非root用户，扫描需要sudo权限")
        
        # 设置组合状态信息
        if status_messages:
            self.status_label.setText(" | ".join(status_messages))
        
        self.total_vulns = 0
        self.affected_count = 0
        self.safe_count = 0
        self.scan_results = []
        # 每次启动预扫描 - 友好交互版
        def startup_prescan():
            """每次启动都预扫描，确保100%成功率"""
            
            def execute_prescan():
                try:
                    # 更新状态
                    self.status_label.setText("🔄 系统预热中...")
                    self.scan_button.setEnabled(False)
                    
                    cmd = [self.script_path, "--batch", "text"]
                    
                    # 智能权限处理
                    if os.geteuid() != 0:
                        try:
                            # 先尝试无密码sudo
                            test = subprocess.run(["sudo", "-n", "true"], capture_output=True, timeout=2)
                            if test.returncode == 0:
                                cmd = ["sudo", "-n"] + cmd
                            else:
                                # 需要密码，友好地询问用户
                                from PyQt5.QtWidgets import QInputDialog, QLineEdit, QMessageBox
                                
                                reply = QMessageBox.question(
                                    self, "系统预热", 
                                    "为确保最佳扫描体验，建议进行系统预热。\n需要sudo权限，是否继续？",
                                    QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes
                                )
                                
                                if reply == QMessageBox.Yes:
                                    password, ok = QInputDialog.getText(
                                        self, "输入密码", "请输入sudo密码:",
                                        QLineEdit.Password
                                    )
                                    if ok and password:
                                        # 执行带密码的预扫描
                                        process = subprocess.Popen(
                                            ["sudo", "-S"] + cmd[1:],
                                            stdin=subprocess.PIPE,
                                            stdout=subprocess.PIPE,
                                            stderr=subprocess.STDOUT,
                                            text=True,
                                            cwd=os.path.dirname(self.script_path)
                                        )
                                        process.stdin.write(f"{password}\n")
                                        process.stdin.flush()
                                        process.stdin.close()
                                        process.communicate(timeout=90)
                                    else:
                                        return
                                else:
                                    return
                        except:
                            return
                    else:
                        # root用户直接执行
                        subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                                    timeout=90, cwd=os.path.dirname(self.script_path))
                    
                    print("✅ 启动预扫描完成，用户扫描将100%成功")
                    
                except Exception as e:
                    print(f"预扫描失败: {e}")
                finally:
                    # 恢复状态
                    self.status_label.setText("🟢 就绪 (已预热)")
                    self.scan_button.setEnabled(True)
            
            # 3秒后启动
            QTimer.singleShot(3000, lambda: threading.Thread(target=execute_prescan, daemon=True).start())

        startup_prescan()




    def init_ui(self):
        # 修复：设置窗口样式，使用系统兼容字体
        fonts = get_system_fonts()
        self.setStyleSheet(f"""
            QMainWindow {{
                background-color: #f5f6fa;
            }}
            QWidget {{
                font-family: {', '.join(fonts['ui'])};
            }}
        """)
        
        main_widget = QWidget()
        main_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        main_layout = QVBoxLayout(main_widget)
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.setSpacing(0)
        
        # 现代化头部
        self.header = GradientHeader("🛡️ CPU漏洞检测工具")
        main_layout.addWidget(self.header)
        
        # 主要内容区域
        content_widget = QWidget()
        content_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        content_widget.setStyleSheet("background-color: #f5f6fa;")
        content_layout = QVBoxLayout(content_widget)
        content_layout.setContentsMargins(20, 20, 20, 15)
        
        # 标签页
        self.main_tabs = QTabWidget()
        self.main_tabs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.main_tabs.setStyleSheet(f"""
            QTabWidget::pane {{
                border: none;
                background-color: transparent;
            }}
            QTabBar::tab {{
                font-family: {', '.join(fonts['ui'])};
                background-color: white;
                color: #7f8c8d;
                border: none;
                border-radius: 8px 8px 0 0;
                padding: 12px 30px;
                font-size: 13px;
                font-weight: 500;
                margin-right: 3px;
                margin-top: 5px;
                min-width: 120px;
                max-width: 200px;
            }}
            QTabBar::tab:selected {{
                background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                    stop:0 #667eea, stop:1 #764ba2);
                color: white;
                font-weight: 600;
            }}
            QTabBar::tab:hover:!selected {{
                background-color: #ecf0f1;
                color: #2c3e50;
            }}
        """)
        
        # 设置标签页
        self.scan_settings_tab = QWidget()
        self.setup_scan_settings_tab()
        self.main_tabs.addTab(self.scan_settings_tab, "扫描设置")

        self.results_tab = QWidget()
        self.setup_results_tab()
        self.main_tabs.addTab(self.results_tab, "漏洞结果")
        
        self.output_tab = QWidget()
        self.setup_output_tab()
        self.main_tabs.addTab(self.output_tab, "详细输出")

        # 添加源代码分析标签页
        self.source_analysis_tab = SourceCodeAnalysisTab()
        self.main_tabs.addTab(self.source_analysis_tab, "源代码分析")
        
        self.system_info_tab = SystemInfoTab(self.system_info)
        self.main_tabs.addTab(self.system_info_tab, "系统信息")
        
        content_layout.addWidget(self.main_tabs)
        main_layout.addWidget(content_widget)
        
        # 设置布局权重，让主要内容可以扩展
        main_layout.setStretchFactor(content_widget, 1)
        
        # 现代化状态栏
        status_frame = QFrame()
        status_frame.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
        status_frame.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                    stop:0 #667eea, stop:1 #764ba2);
                border: none;
                padding: 10px;
            }
        """)
        status_layout = QHBoxLayout(status_frame)
        
        self.status_label = QLabel("🟢 就绪")
        self.status_label.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                font-size: 13px;
                color: white;
                font-weight: 500;
            }}
        """)
        
        status_layout.addWidget(self.status_label)
        status_layout.addStretch()
        
        version_label = QLabel("v3.0.0")
        version_label.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                font-size: 12px;
                color: rgba(255, 255, 255, 0.8);
                font-weight: 400;
            }}
        """)
        status_layout.addWidget(version_label)
        
        main_layout.addWidget(status_frame)
        
        self.setCentralWidget(main_widget)
        # 添加帮助菜单
        self.add_help_menu()

    def setup_scan_settings_tab(self):
        # 修复：为扫描设置标签页添加滚动支持
        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        scroll_area.setFrameShape(QScrollArea.NoFrame)
        
        # 创建滚动内容容器
        scroll_content = QWidget()
        scroll_area.setWidget(scroll_content)
        
        # 设置滚动区域样式
        fonts = get_system_fonts()
        scroll_area.setStyleSheet(f"""
            QScrollArea {{
                background-color: transparent;
                border: none;
            }}
            QScrollBar:vertical {{
                background-color: #f8f9fa;
                width: 12px;
                border-radius: 6px;
            }}
            QScrollBar::handle:vertical {{
                background-color: #667eea;
                border-radius: 6px;
                min-height: 20px;
            }}
            QScrollBar::handle:vertical:hover {{
                background-color: #764ba2;
            }}
        """)
        
        # 设置主布局
        main_layout = QVBoxLayout(self.scan_settings_tab)
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.addWidget(scroll_area)
        
        # 内容布局
        layout = QVBoxLayout(scroll_content)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(25)
        
        # 扫描选项卡片
        options_card = ModernCard("⚙️ 扫描选项")
        
        # 第一组：基本扫描选项
        basic_options_group = QWidget()
        basic_options_layout = QVBoxLayout(basic_options_group)
        basic_options_layout.setContentsMargins(0, 0, 0, 0)
        basic_options_layout.setSpacing(15)
        
        # 基本选项标题
        basic_title = QLabel("基本选项")
        basic_title.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                font-size: 16px;
                font-weight: 600;
                color: #667eea;
                margin-bottom: 10px;
            }}
        """)
        basic_options_layout.addWidget(basic_title)
        
        # 基本选项复选框 - 使用垂直布局确保充足空间
        basic_checkboxes_layout = QVBoxLayout()
        basic_checkboxes_layout.setSpacing(12)
        
        self.live_mode_cb = ModernCheckBox("实时模式")
        self.live_mode_cb.setChecked(True)
        
        self.explain_cb = ModernCheckBox("显示详细解释")
        self.explain_cb.setChecked(True)
        
        self.verbose_cb = ModernCheckBox("详细输出")
        
        basic_checkboxes_layout.addWidget(self.live_mode_cb)
        basic_checkboxes_layout.addWidget(self.explain_cb)
        basic_checkboxes_layout.addWidget(self.verbose_cb)
        
        basic_options_layout.addLayout(basic_checkboxes_layout)
        
        # 第二组：高级选项
        advanced_options_group = QWidget()
        advanced_options_layout = QVBoxLayout(advanced_options_group)
        advanced_options_layout.setContentsMargins(0, 0, 0, 0)
        advanced_options_layout.setSpacing(15)
        
        # 高级选项标题
        advanced_title = QLabel("高级选项")
        advanced_title.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                font-size: 16px;
                font-weight: 600;
                color: #667eea;
                margin-bottom: 10px;
            }}
        """)
        advanced_options_layout.addWidget(advanced_title)
        
        # 动态分析选项
        self.dynamic_analysis_cb = ModernCheckBox("启用动态PoC分析 (需要编译环境)")
        self.dynamic_analysis_cb.setChecked(self.poc_available)
        self.dynamic_analysis_cb.setEnabled(self.poc_available)
        
        if not self.poc_available:
            self.dynamic_analysis_cb.setToolTip("请先运行setup_pocs.sh脚本来下载和编译PoC")
        else:
            self.dynamic_analysis_cb.setToolTip("使用实际漏洞利用代码进行动态检测")
        
        advanced_options_layout.addWidget(self.dynamic_analysis_cb)
        
        # 第三组：配置选项
        config_group = QWidget()
        config_layout = QVBoxLayout(config_group)
        config_layout.setContentsMargins(0, 0, 0, 0)
        config_layout.setSpacing(15)
        
        # 配置选项标题
        config_title = QLabel("配置选项")
        config_title.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                font-size: 16px;
                font-weight: 600;
                color: #667eea;
                margin-bottom: 10px;
            }}
        """)
        config_layout.addWidget(config_title)
        
        # 输出格式选择
        format_container = QWidget()
        format_layout = QHBoxLayout(format_container)
        format_layout.setContentsMargins(0, 0, 0, 0)
        format_layout.setSpacing(15)
        
        format_label = QLabel("输出格式:")
        format_label.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                font-weight: 600;
                color: #2c3e50;
                font-size: 14px;
                padding: 8px 0;
            }}
        """)
        format_label.setMinimumWidth(100)
        
        self.output_combo = ModernComboBox()
        self.output_combo.addItems(["JSON (推荐)", "文本"])
        self.output_combo.setMaximumWidth(250)
        
        format_layout.addWidget(format_label)
        format_layout.addWidget(self.output_combo)
        format_layout.addStretch()
        
        # CVE选择
        cve_container = QWidget()
        cve_layout = QHBoxLayout(cve_container)
        cve_layout.setContentsMargins(0, 0, 0, 0)
        cve_layout.setSpacing(15)
        
        cve_label = QLabel("选择CVE:")
        cve_label.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                font-weight: 600;
                color: #2c3e50;
                font-size: 14px;
                padding: 8px 0;
            }}
        """)
        cve_label.setMinimumWidth(100)
        
        self.cve_combo = ModernComboBox()
        self.cve_combo.addItems(["全部", "CVE-2017-5753", "CVE-2017-5715", "CVE-2017-5754", "CVE-2018-3640", 
                                "CVE-2018-3639", "CVE-2018-3615", "CVE-2018-3620", "CVE-2018-3646",
                                "CVE-2018-12126", "CVE-2018-12130", "CVE-2018-12127", "CVE-2019-11091",
                                "CVE-2019-11135", "CVE-2018-12207", "CVE-2020-0543", "CVE-2023-20593",
                                "CVE-2022-40982", "CVE-2023-20569", "CVE-2023-23583", "CVE-2022-4543"])
        self.cve_combo.setCurrentIndex(0)
        self.cve_combo.setMaximumWidth(350)
        
        cve_layout.addWidget(cve_label)
        cve_layout.addWidget(self.cve_combo)
        cve_layout.addStretch()
        
        config_layout.addWidget(format_container)
        config_layout.addWidget(cve_container)
        
        # 第四组：PoC管理
        poc_group = QWidget()
        poc_layout = QVBoxLayout(poc_group)
        poc_layout.setContentsMargins(0, 0, 0, 0)
        poc_layout.setSpacing(15)
        
        # PoC管理标题
        poc_title = QLabel("PoC环境管理")
        poc_title.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                font-size: 16px;
                font-weight: 600;
                color: #667eea;
                margin-bottom: 10px;
            }}
        """)
        poc_layout.addWidget(poc_title)
        
        # PoC管理按钮
        poc_buttons_container = QWidget()
        poc_buttons_layout = QHBoxLayout(poc_buttons_container)
        poc_buttons_layout.setContentsMargins(0, 0, 0, 0)
        poc_buttons_layout.setSpacing(15)
        
        self.setup_pocs_button = AnimatedButton("🔧 设置PoC环境", "secondary")
        self.setup_pocs_button.clicked.connect(self.setup_poc_environment)
        
        self.test_pocs_button = AnimatedButton("🧪 测试PoC", "secondary")  
        self.test_pocs_button.clicked.connect(self.test_poc_environment)
        self.test_pocs_button.setEnabled(self.poc_available)
        
        poc_buttons_layout.addWidget(self.setup_pocs_button)
        poc_buttons_layout.addWidget(self.test_pocs_button)
        poc_buttons_layout.addStretch()
        
        poc_layout.addWidget(poc_buttons_container)
        
        # 将所有组添加到选项卡片
        options_card.layout.addWidget(basic_options_group)
        options_card.layout.addSpacing(20)
        options_card.layout.addWidget(advanced_options_group)
        options_card.layout.addSpacing(20)
        options_card.layout.addWidget(config_group)
        options_card.layout.addSpacing(20)
        options_card.layout.addWidget(poc_group)
        
        layout.addWidget(options_card)
        
        # 进度卡片
        progress_card = ModernCard("📈 扫描进度")
        self.progress_bar = ModernProgressBar()
        progress_card.layout.addWidget(self.progress_bar)
        layout.addWidget(progress_card)
        
        # 操作按钮
        button_container = QWidget()
        button_layout = QHBoxLayout(button_container)
        button_layout.setContentsMargins(0, 10, 0, 10)
        button_layout.setSpacing(20)
        
        self.scan_button = AnimatedButton("🚀 开始扫描", "primary")
        self.scan_button.clicked.connect(self.start_scan)
        
        self.stop_button = AnimatedButton("⏹️ 停止扫描", "danger")
        self.stop_button.clicked.connect(self.stop_scan)
        self.stop_button.setEnabled(False)
        
        self.clear_button = AnimatedButton("🗑️ 清除结果", "secondary")
        self.clear_button.clicked.connect(self.clear_results)
        
        button_layout.addStretch()
        button_layout.addWidget(self.scan_button)
        button_layout.addWidget(self.stop_button)
        button_layout.addWidget(self.clear_button)
        button_layout.addStretch()
        
        layout.addWidget(button_container)
        layout.addStretch()

    def setup_results_tab(self):
        layout = QVBoxLayout(self.results_tab)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(20)
        
        fonts = get_system_fonts()
        
        # 统计卡片 - 支持自适应
        stats_layout = QHBoxLayout()
        stats_layout.setSpacing(20)
        
        self.total_stat = StatCard("总检测", "0", ["#3498db", "#2980b9"])
        self.affected_stat = StatCard("受影响", "0", ["#e74c3c", "#c0392b"])
        self.safe_stat = StatCard("安全", "0", ["#2ecc71", "#27ae60"])
        
        stats_layout.addWidget(self.total_stat)
        stats_layout.addWidget(self.affected_stat)
        stats_layout.addWidget(self.safe_stat)
        stats_layout.addStretch()
        
        layout.addLayout(stats_layout)
        
        # 结果表格卡片
        table_card = ModernCard("📋 漏洞检测结果")
        
        # 表格
        self.results_table = QTableWidget()
        self.results_table.setColumnCount(4)
        self.results_table.setHorizontalHeaderLabels(["CVE编号", "漏洞名称", "状态", "操作"])
        
        # 设置表格属性
        self.results_table.verticalHeader().setVisible(False)
        self.results_table.setEditTriggers(QTableWidget.NoEditTriggers)
        self.results_table.setSelectionBehavior(QTableWidget.SelectRows)
        self.results_table.setAlternatingRowColors(True)
        self.results_table.setSortingEnabled(False)
        self.results_table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        
        # 自适应列宽 - 修复操作列溢出问题
        header = self.results_table.horizontalHeader()
        header.setSectionResizeMode(0, QHeaderView.ResizeToContents)  # CVE编号自适应内容
        header.setSectionResizeMode(1, QHeaderView.Stretch)  # 漏洞名称拉伸填充
        header.setSectionResizeMode(2, QHeaderView.ResizeToContents)  # 状态自适应内容
        header.setSectionResizeMode(3, QHeaderView.Fixed)  # 操作列固定宽度
        self.results_table.setColumnWidth(3, 160)  # 修复：减小操作列宽度防止溢出
        
        # 设置表格样式
        self.results_table.setStyleSheet(f"""
            QTableWidget {{
                font-family: {', '.join(fonts['ui'])};
                gridline-color: #e8e9ea;
                border: 2px solid #e8e9ea;
                background-color: white;
                border-radius: 8px;
                font-size: 12px;
                color: #2c3e50;
            }}
            QHeaderView::section {{
                font-family: {', '.join(fonts['ui'])};
                background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                    stop:0 #667eea, stop:1 #764ba2);
                color: white;
                font-weight: 600;
                padding: 15px 10px;
                border: none;
                font-size: 13px;
                text-align: center;
            }}
            QTableWidget::item {{
                padding: 12px 8px;
                border-bottom: 1px solid #f1f2f6;
                background-color: white;
            }}
            QTableWidget::item:selected {{
                background-color: rgba(102, 126, 234, 0.1);
                color: #2c3e50;
            }}
            QTableWidget::item:alternate {{
                background-color: #f8f9fa;
            }}
        """)
        
        table_card.layout.addWidget(self.results_table)
        layout.addWidget(table_card)
        
        # 导出按钮
        export_layout = QHBoxLayout()
        self.export_button = AnimatedButton("📤 导出结果", "success")
        self.export_button.clicked.connect(self.export_results)
        self.export_button.setEnabled(False)
        
        # 添加HTML报告导出按钮
        self.export_html_button = AnimatedButton("📄 导出可视化报告", "primary")
        self.export_html_button.clicked.connect(self.export_html_report)
        self.export_html_button.setEnabled(False)
        
        export_layout.addStretch()
        export_layout.addWidget(self.export_button)
        export_layout.addWidget(self.export_html_button)
        
        layout.addLayout(export_layout)
        
        # 设置布局权重，让表格卡片可以扩展
        layout.setStretchFactor(table_card, 1)

    def setup_output_tab(self):
        layout = QVBoxLayout(self.output_tab)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(20)
        
        fonts = get_system_fonts()
        
        # 输出类型选择
        filter_card = ModernCard("🔧 输出过滤")
        
        filter_layout = QHBoxLayout()
        filter_label = QLabel("输出类型:")
        filter_label.setStyleSheet(f"font-family: {', '.join(fonts['ui'])}; font-weight: 600; color: #2c3e50; font-size: 14px;")
        
        self.output_type_combo = ModernComboBox()
        self.output_type_combo.addItems(["全部", "动态分析", "静态分析"])
        self.output_type_combo.currentIndexChanged.connect(self.filter_output)
        self.output_type_combo.setMaximumWidth(200)
        
        filter_layout.addWidget(filter_label)
        filter_layout.addWidget(self.output_type_combo)
        filter_layout.addStretch()
        
        filter_card.layout.addLayout(filter_layout)
        layout.addWidget(filter_card)
        
        # 输出内容卡片
        output_card = ModernCard("📝 详细输出")
        
        # 添加工具栏
        toolbar_layout = QHBoxLayout()
        
        expand_button = QPushButton("🔍 在新窗口中查看")
        expand_button.setFixedHeight(35)
        expand_button.setStyleSheet(f"""
            QPushButton {{
                font-family: {', '.join(fonts['ui'])};
                background-color: #9b59b6;
                color: white;
                border: none;
                border-radius: 6px;
                padding: 8px 15px;
                font-size: 12px;
                font-weight: 500;
            }}
            QPushButton:hover {{
                background-color: #8e44ad;
            }}
        """)
        expand_button.clicked.connect(self.show_output_in_new_window)
        
        toolbar_layout.addWidget(expand_button)
        toolbar_layout.addStretch()
        
        output_card.layout.addLayout(toolbar_layout)
        
        # 修复：输出文本框 - 添加与卡片边界的padding
        # 创建一个容器来包装文本框，确保与卡片边界有适当间距
        output_container = QWidget()
        output_container.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
        output_layout = QVBoxLayout(output_container)
        # 设置文本框与卡片边界的间距
        output_layout.setContentsMargins(10, 10, 10, 15)  # 左、上、右、下间距
        
        self.output_text = QTextEdit()
        self.output_text.setReadOnly(True)
        self.output_text.setMinimumHeight(180)
        # 修复：设置合适的最大高度，考虑额外的padding
        self.output_text.setMaximumHeight(260)
        self.output_text.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
        self.output_text.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        self.output_text.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        self.output_text.setStyleSheet(f"""
            QTextEdit {{
                font-family: {', '.join(fonts['mono'])};
                font-size: 11pt;
                background-color: #2c3e50;
                color: #ecf0f1;
                border: none;
                border-radius: 8px;
                padding: 15px;
                line-height: 1.4;
            }}
            QScrollBar:vertical {{
                background-color: #34495e;
                width: 12px;
                border-radius: 6px;
            }}
            QScrollBar::handle:vertical {{
                background-color: #667eea;
                border-radius: 6px;
                min-height: 20px;
            }}
            QScrollBar::handle:vertical:hover {{
                background-color: #764ba2;
            }}
        """)
        
        # 将文本框添加到容器中
        output_layout.addWidget(self.output_text)
        # 将容器添加到卡片中
        output_card.layout.addWidget(output_container)
        layout.addWidget(output_card)
        
        # 操作按钮
        button_layout = QHBoxLayout()
        button_layout.setSpacing(15)
        
        self.copy_button = AnimatedButton("📋 复制输出", "primary")
        self.copy_button.clicked.connect(self.copy_output)
        
        self.clear_output_button = AnimatedButton("🗑️ 清除输出", "secondary")
        self.clear_output_button.clicked.connect(self.clear_output)
        
        button_layout.addStretch()
        button_layout.addWidget(self.copy_button)
        button_layout.addWidget(self.clear_output_button)
        
        layout.addLayout(button_layout)
        
        # 修复：设置布局权重，让输出卡片适度扩展
        layout.setStretchFactor(filter_card, 0)
        layout.setStretchFactor(output_card, 1)

    # 以下方法保持不变，只需要在涉及字体的地方添加系统兼容性
    def start_scan(self):
        """开始扫描 - 修复版本"""
        self.options["live_mode"] = self.live_mode_cb.isChecked()
        self.options["explain"] = self.explain_cb.isChecked()
        self.options["verbose"] = self.verbose_cb.isChecked()
        self.options["output_format"] = "json" if self.output_combo.currentText().startswith("JSON") else "text"

        # 修复：正确处理动态分析选项
        self.options["dynamic_analysis"] = (
            hasattr(self, 'dynamic_analysis_cb') and 
            self.dynamic_analysis_cb.isChecked() and 
            self.poc_available
        )
        
        cve_selection = self.cve_combo.currentText()
        if cve_selection == "全部":
            self.options["cves"] = []  # 空列表表示检测所有CVE
        else:
            self.options["cves"] = [cve_selection]
        
        # 调试输出
        print(f"扫描选项: {self.options}")
        
        password = ""
        if not self.is_root:
            password, ok = QInputDialog.getText(
                self, "输入密码", 
                "需要sudo权限执行此操作，请输入您的密码:",
                QLineEdit.Password
            )
            if not ok or not password:
                QMessageBox.warning(self, "警告", "未提供密码，扫描已取消")
                return
        

        
        self.clear_results()
        
        self.scan_button.setEnabled(False)
        self.stop_button.setEnabled(True)
        self.progress_bar.setValue(0)
        self.status_label.setText("🔄 正在执行漏洞扫描...")
        
        # 修复：使用增强版扫描线程
        from scanner import EnhancedScanThread
        self.scan_thread = EnhancedScanThread(self.script_path, self.options, password)
        self.scan_thread.update_output.connect(self.update_output)
        self.scan_thread.update_progress.connect(self.update_progress)
        self.scan_thread.scan_completed.connect(self.scan_complete)
        self.scan_thread.error_occurred.connect(self.scan_error)
        self.scan_thread.start()

        # 新增：执行预热
        if not self.perform_pre_scan_warmup():
            QMessageBox.warning(self, "预热失败", "系统预热失败，扫描可能不稳定")



    def stop_scan(self):
        if hasattr(self, 'scan_thread') and self.scan_thread.isRunning():
            self.scan_thread.terminate()
            self.status_label.setText("⏹️ 扫描已取消")
            self.progress_bar.setValue(0)
            self.scan_button.setEnabled(True)
            self.stop_button.setEnabled(False)

    def update_output(self, text, output_type):
        if not hasattr(self, 'dynamic_output'):
            self.dynamic_output = []
            self.static_output = []
        
        if output_type == "dynamic":
            self.dynamic_output.append(text)
        else:
            self.static_output.append(text)
        
        self.filter_output()

    def filter_output(self):
        selected_type = self.output_type_combo.currentText()
        output_text = ""
        
        if selected_type == "全部":
            if hasattr(self, 'dynamic_output'):
                output_text += ''.join(self.dynamic_output)
            if hasattr(self, 'static_output'):
                output_text += ''.join(self.static_output)
        elif selected_type == "动态分析" and hasattr(self, 'dynamic_output'):
            output_text = ''.join(self.dynamic_output)
        elif selected_type == "静态分析" and hasattr(self, 'static_output'):
            output_text = ''.join(self.static_output)
        
        self.output_text.setText(output_text)
        self.output_text.moveCursor(self.output_text.textCursor().End)

    def update_progress(self, value):
        self.progress_bar.setValue(value)

    def scan_complete(self, results):
        """扫描完成 - 增强版本支持完整汉化"""
        self.scan_results = results
        for result in self.scan_results:
            result["CVSS"] = get_cvss_score(result.get("CVE", ""))
            result["TIMESTAMP"] = get_current_time()
        
        self.status_label.setText("✅ 扫描完成")
        self.progress_bar.setValue(100)
        self.scan_button.setEnabled(True)
        self.stop_button.setEnabled(False)
        self.export_button.setEnabled(True)
        self.export_html_button.setEnabled(True)
        
        self.update_results_table()
        self.update_stats()
        
        # 显示扫描汇总 - 支持完整中文
        try:
            from translations import get_vulnerability_summary
            summary = get_vulnerability_summary(self.scan_results, self.current_language)
            summary_text = f"""
🎉 扫描完成！

📊 {summary['summary_text']}
⚠️ {summary['risk_text']}
📈 总体风险比例：{summary['risk_percentage']}%

建议查看详细结果并采取相应的安全措施。
            """
            
            msg_box = QMessageBox(self)
            msg_box.setWindowTitle("扫描完成")
            msg_box.setIcon(QMessageBox.Information)
            msg_box.setStyleSheet("""
                QMessageBox {
                    background-color: white;
                    font-family: 'Segoe UI', 'Microsoft YaHei', 'Arial';
                    font-size: 14px;
                }
                QMessageBox QLabel {
                    color: #2c3e50;
                    font-size: 14px;
                    padding: 10px;
                    background-color: transparent;
                }
                QMessageBox QPushButton {
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #667eea, stop:1 #764ba2);
                    color: white;
                    border: none;
                    border-radius: 8px;
                    padding: 8px 16px;
                    font-weight: 500;
                    font-size: 13px;
                    min-width: 80px;
                }
            """)
            msg_box.setText(summary_text)
            msg_box.setStandardButtons(QMessageBox.Ok)
            msg_box.button(QMessageBox.Ok).setText("查看结果")
            msg_box.exec_()
            
        except Exception as e:
            print(f"显示汇总时出错: {e}")
            # 显示简化版汇总
            simple_summary = f"""
🎉 扫描完成！

检测到 {len(self.scan_results)} 个漏洞项目。
请查看"漏洞结果"标签页了解详细信息。
            """
            msg_box = QMessageBox(self)
            msg_box.setWindowTitle("扫描完成")
            msg_box.setIcon(QMessageBox.Information)
            msg_box.setText(simple_summary)
            msg_box.setStandardButtons(QMessageBox.Ok)
            msg_box.button(QMessageBox.Ok).setText("查看结果")
            msg_box.exec_()
        
        # 修复：扫描完成后跳转到漏洞结果标签页
        self.main_tabs.setCurrentIndex(1)


    def scan_error(self, error_msg):
        self.status_label.setText("❌ 扫描出错")
        self.progress_bar.setValue(0)
        self.scan_button.setEnabled(True)
        self.stop_button.setEnabled(False)
        
        self.update_output(f"\n错误: {error_msg}\n", "dynamic")
        QMessageBox.critical(self, "扫描错误", error_msg)

    def update_results_table(self):
        """更新结果表格 - 增强版本支持完整汉化"""
        self.results_table.setRowCount(len(self.scan_results))
        fonts = get_system_fonts()

        for row, result in enumerate(self.scan_results):
            # CVE编号
            cve_item = QTableWidgetItem(result.get("CVE", ""))
            font = QFont()
            font.setFamily(fonts['mono'][0])
            font.setPointSize(11)
            font.setBold(True)
            cve_item.setFont(font)
            cve_item.setTextAlignment(Qt.AlignCenter)
            self.results_table.setItem(row, 0, cve_item)
            
            # 漏洞名称 - 使用翻译后的名称
            name_item = QTableWidgetItem(result.get("NAME", ""))
            font = QFont()
            font.setFamily(fonts['ui'][0])
            font.setPointSize(11)
            name_item.setFont(font)
            name_item.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
            # 设置工具提示显示完整名称
            name_item.setToolTip(result.get("NAME", ""))
            self.results_table.setItem(row, 1, name_item)
            
            # 状态 - 增强状态显示，支持中文
            vulnerable = result.get("VULNERABLE", False)
            mitigation_status = result.get("MITIGATION_STATUS", "")
            is_dynamic = result.get("DYNAMIC_ANALYSIS", False)
            
            if vulnerable:
                if mitigation_status and ("已缓解" in mitigation_status or "部分缓解" in mitigation_status):
                    status_text = f"🟡 受影响({mitigation_status})"
                    status_color = QColor("#f39c12")
                else:
                    status_text = "🔴 受影响"
                    status_color = QColor("#e74c3c")
            elif vulnerable is None:
                status_text = "🟡 未知"
                status_color = QColor("#f39c12")
            else:
                status_text = "🟢 安全"
                status_color = QColor("#27ae60")


            if vulnerable:
                if is_dynamic:
                    status_text = "🔴 受影响 (动态验证)"
                    status_color = QColor("#e74c3c")
                else:
                    status_text = "🔴 受影响"
                    status_color = QColor("#e74c3c")
            elif vulnerable is None:
                status_text = "🟡 未知"
                status_color = QColor("#f39c12")
            else:
                if is_dynamic:
                    status_text = "🟢 安全 (动态验证)"
                    status_color = QColor("#27ae60")
                else:
                    status_text = "🟢 安全"
                    status_color = QColor("#27ae60")
                
            status_item = QTableWidgetItem(status_text)
            font = QFont()
            font.setFamily(fonts['ui'][0])
            font.setPointSize(11)
            font.setBold(True)
            status_item.setFont(font)
            status_item.setTextAlignment(Qt.AlignCenter)
            status_item.setForeground(status_color)
            
            # 设置状态工具提示
            if mitigation_status:
                status_item.setToolTip(f"缓解状态: {mitigation_status}")
            
            self.results_table.setItem(row, 2, status_item)

            # 操作按钮 - 确保不超出边界
            button_widget = QWidget()
            button_widget.setStyleSheet("background-color: transparent;")
            button_widget.setFixedSize(155, 35)
            
            button_layout = QHBoxLayout(button_widget)
            button_layout.setContentsMargins(2, 2, 2, 2)
            button_layout.setSpacing(3)
            
            # 详情按钮
            details_button = QPushButton("详情")
            details_button.setFixedSize(70, 28)
            details_button.setStyleSheet(f"""
                QPushButton {{
                    font-family: {', '.join(fonts['ui'])};
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #3498db, stop:1 #2980b9);
                    color: white;
                    border: none;
                    border-radius: 4px;
                    font-size: 10px;
                    font-weight: 600;
                    padding: 0px;
                }}
                QPushButton:hover {{
                    background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                        stop:0 #2980b9, stop:1 #21618c);
                }}
            """)
            details_button.setCursor(Qt.PointingHandCursor)
            details_button.clicked.connect(lambda checked, r=row: self.show_details(r))
            button_layout.addWidget(details_button)

            # EntryBleed攻击演示按钮
            if result.get("CVE") == "CVE-2022-4543" and result.get("VULNERABLE", False):
                exploit_button = QPushButton("攻击")
                exploit_button.setFixedSize(70, 28)
                exploit_button.setStyleSheet(f"""
                    QPushButton {{
                        font-family: {', '.join(fonts['ui'])};
                        background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                            stop:0 #e74c3c, stop:1 #c0392b);
                        color: white;
                        border: none;
                        border-radius: 4px;
                        font-size: 10px;
                        font-weight: 600;
                        padding: 0px;
                    }}
                    QPushButton:hover {{
                        background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                            stop:0 #c0392b, stop:1 #a93226);
                    }}
                """)
                exploit_button.setCursor(Qt.PointingHandCursor)
                exploit_button.clicked.connect(lambda checked, r=row: self.run_exploit(r))
                button_layout.addWidget(exploit_button)
            else:
                placeholder = QWidget()
                placeholder.setFixedSize(70, 28)
                button_layout.addWidget(placeholder)
            
            self.results_table.setCellWidget(row, 3, button_widget)
            self.results_table.setRowHeight(row, 45)

            # 在工具提示中显示分析类型
            tooltip_text = f"CVE: {result.get('CVE', '')}\n"
            tooltip_text += f"分析类型: {'动态PoC分析' if is_dynamic else '静态检测'}\n"
            if mitigation_status:
                tooltip_text += f"缓解状态: {mitigation_status}"
            
            status_item.setToolTip(tooltip_text)

    def update_stats(self):
        self.total_vulns = len(self.scan_results)
        self.affected_count = sum(1 for result in self.scan_results if result.get("VULNERABLE", False))
        self.safe_count = self.total_vulns - self.affected_count
        
        self.total_stat.update_value(self.total_vulns)
        self.affected_stat.update_value(self.affected_count)
        self.safe_stat.update_value(self.safe_count)

        # 新增动态分析统计
        dynamic_count = sum(1 for result in self.scan_results 
                        if result.get("DYNAMIC_ANALYSIS", False))
        
        if dynamic_count > 0:
            dynamic_vulnerable = sum(1 for result in self.scan_results 
                                if result.get("DYNAMIC_ANALYSIS", False) 
                                and result.get("VULNERABLE", False))
            
            # 更新状态标签
            if dynamic_vulnerable > 0:
                self.status_label.setText(
                    f"🔍 动态分析: {dynamic_count}项检测, {dynamic_vulnerable}项受影响")
            else:
                self.status_label.setText(
                    f"✅ 动态分析: {dynamic_count}项检测, 未发现活跃威胁")

    def show_details(self, row):
        """显示详情 - 增强版本支持完整汉化"""
        if 0 <= row < len(self.scan_results):
            result = self.scan_results[row]
            fonts = get_system_fonts()
            
            details_dialog = QDialog(self)
            details_dialog.setWindowTitle(f"{result.get('CVE', '')} - 详细信息")
            details_dialog.setMinimumSize(700, 700)  # 增加高度以容纳更多信息
            details_dialog.setStyleSheet("QDialog { background-color: #f8f9fa; }")
            
            layout = QVBoxLayout(details_dialog)
            layout.setContentsMargins(25, 25, 25, 25)
            layout.setSpacing(20)
            
            # 标题卡片
            title_card = ModernCard()
            title_layout = QHBoxLayout()
            
            # CVE图标和名称
            cve_label = QLabel(f"🔍 {result.get('CVE', '')}")
            cve_label.setStyleSheet(f"""
                QLabel {{
                    font-family: {', '.join(fonts['ui'])};
                    font-size: 24px;
                    font-weight: 700;
                    color: #2c3e50;
                    border: none;
                }}
            """)
            
            # 状态标签 - 增强版本，支持中文
            vulnerable = result.get("VULNERABLE", False)
            mitigation_status = result.get("MITIGATION_STATUS", "")
            
            if vulnerable:
                if mitigation_status and ("已缓解" in mitigation_status or "部分缓解" in mitigation_status):
                    status = f"🟡 受影响 ({mitigation_status})"
                    status_color = "#f39c12"
                else:
                    status = "🔴 受影响"
                    status_color = "#e74c3c"
            elif vulnerable is None:
                status = "🟡 未知"
                status_color = "#f39c12"
            else:
                status = "🟢 安全"
                status_color = "#27ae60"
                
            status_label = QLabel(status)
            status_label.setStyleSheet(f"""
                QLabel {{
                    font-family: {', '.join(fonts['ui'])};
                    font-size: 16px;
                    font-weight: 600;
                    color: {status_color};
                    border: none;
                    padding: 8px 16px;
                    background-color: rgba({','.join(str(QColor(status_color).getRgb()[:3]))}, 0.1);
                    border-radius: 20px;
                }}
            """)
            
            title_layout.addWidget(cve_label)
            title_layout.addStretch()
            title_layout.addWidget(status_label)
            title_card.layout.addLayout(title_layout)
            layout.addWidget(title_card)
    
            # 如果有PoC输出，添加专门的标签页
            if result.get("POC_OUTPUT"):
                poc_output_card = ModernCard("🧪 动态PoC分析结果")
                
                poc_output_text = QTextEdit()
                poc_output_text.setReadOnly(True)
                poc_output_text.setPlainText(result.get("POC_OUTPUT", ""))
                poc_output_text.setStyleSheet(f"""
                    QTextEdit {{
                        font-family: {', '.join(fonts['mono'])};
                        font-size: 11pt;
                        background-color: #2c3e50;
                        color: #ecf0f1;
                        border: 2px solid #e8e9ea;
                        border-radius: 8px;
                        padding: 12px;
                    }}
                """)
                
                poc_output_card.layout.addWidget(poc_output_text)
                layout.addWidget(poc_output_card)
            
            # 详细信息卡片
            details_card = ModernCard("📋 详细信息")
            
            details_text = QTextEdit()
            details_text.setReadOnly(True)
            details_text.setStyleSheet(f"""
                QTextEdit {{
                    font-family: {', '.join(fonts['ui'])};
                    font-size: 13pt;
                    border: none;
                    background-color: transparent;
                    color: #2c3e50;
                    line-height: 1.6;
                }}
            """)
            
            # 使用增强的详细信息 - 完全中文化
            cve_id = result.get("CVE", "")
            name = result.get("NAME", "")
            description = result.get("DESCRIPTION", "暂无描述信息")
            infos = result.get("INFOS", "无详细信息")
            impact = result.get("IMPACT", "无影响信息")
            mitigation = result.get("MITIGATION", "无缓解措施信息")
            references = result.get("REFERENCES", "无参考信息")
            
            # 获取CVSS评分和时间戳
            cvss_score = result.get("CVSS", "N/A")
            timestamp = result.get("TIMESTAMP", "")
            
            details_html = f"""
            <div style="line-height: 1.8;">
                <h2 style="color: #667eea; margin-bottom: 15px;">🛡️ {name}</h2>
                
                <div style="background-color: #f8f9fa; padding: 15px; border-radius: 8px; margin: 15px 0;">
                    <p><strong>🏷️ CVE编号:</strong> {cve_id}</p>
                    <p><strong>📊 CVSS评分:</strong> {cvss_score}</p>
                    <p><strong>⏰ 检测时间:</strong> {timestamp}</p>
                    <p><strong>🔒 缓解状态:</strong> {mitigation_status}</p>
                </div>
                
                <h3 style="color: #667eea; margin-top: 25px; margin-bottom: 10px;">📖 漏洞描述</h3>
                <p style="background-color: #f1f3f4; padding: 15px; border-radius: 8px;">
                    {description}
                </p>
                
                <h3 style="color: #667eea; margin-top: 25px; margin-bottom: 10px;">ℹ️ 检测详情</h3>
                <p style="background-color: #f1f3f4; padding: 15px; border-radius: 8px;">
                    {infos}
                </p>
                
                <h3 style="color: #667eea; margin-top: 25px; margin-bottom: 10px;">⚠️ 安全影响</h3>
                <p style="background-color: #f1f3f4; padding: 15px; border-radius: 8px;">
                    {impact}
                </p>
                
                <h3 style="color: #667eea; margin-top: 25px; margin-bottom: 10px;">🛠️ 缓解措施</h3>
                <p style="background-color: #f1f3f4; padding: 15px; border-radius: 8px;">
                    {mitigation}
                </p>
                
                <h3 style="color: #667eea; margin-top: 25px; margin-bottom: 10px;">🔗 参考资料</h3>
                <p style="background-color: #f1f3f4; padding: 15px; border-radius: 8px;">
                    {references}
                </p>
            </div>
            """
            
            details_text.setHtml(details_html)
            details_card.layout.addWidget(details_text)
            layout.addWidget(details_card)
            
            # 按钮区域
            button_layout = QHBoxLayout()
            
            # 复制详情按钮
            copy_button = QPushButton("📋 复制详情")
            copy_button.setStyleSheet(f"""
                QPushButton {{
                    font-family: {', '.join(fonts['ui'])};
                    background-color: #3498db;
                    color: white;
                    border: none;
                    border-radius: 6px;
                    padding: 10px 20px;
                    font-size: 12px;
                    font-weight: 500;
                }}
                QPushButton:hover {{
                    background-color: #2980b9;
                }}
            """)
            copy_button.clicked.connect(lambda: QApplication.clipboard().setText(details_text.toPlainText()))
            
            # 关闭按钮
            close_button = AnimatedButton("✖️ 关闭", "secondary")
            close_button.clicked.connect(details_dialog.accept)
            
            button_layout.addWidget(copy_button)
            button_layout.addStretch()
            button_layout.addWidget(close_button)
            layout.addLayout(button_layout)
            
            details_dialog.exec_()


    def clear_results(self):
        self.results_table.setRowCount(0)
        self.scan_results = []
        self.total_vulns = 0
        self.affected_count = 0
        self.safe_count = 0
        self.update_stats()
        self.export_button.setEnabled(False)
        self.export_html_button.setEnabled(False)

    def copy_output(self):
        clipboard = QApplication.clipboard()
        clipboard.setText(self.output_text.toPlainText())
        QMessageBox.information(self, "成功", "📋 输出内容已复制到剪贴板")

    def clear_output(self):
        self.output_text.clear()
        if hasattr(self, 'dynamic_output'):
            self.dynamic_output = []
        if hasattr(self, 'static_output'):
            self.static_output = []

    def export_results(self):
        if not self.scan_results:
            QMessageBox.warning(self, "警告", "没有可导出的结果")
            return
        
        file_path, _ = QFileDialog.getSaveFileName(
            self, "导出结果", "", "JSON文件 (*.json);;文本文件 (*.txt)"
        )
        
        if not file_path:
            return
        
        try:
            if file_path.endswith('.json'):
                with open(file_path, 'w', encoding='utf-8') as f:
                    json.dump(self.scan_results, f, indent=4, ensure_ascii=False)
            else:
                with open(file_path, 'w', encoding='utf-8') as f:
                    for result in self.scan_results:
                        f.write(f"CVE编号: {result.get('CVE', '')}\n")
                        f.write(f"漏洞名称: {result.get('NAME', '')}\n")
                        f.write(f"状态: {'受影响' if result.get('VULNERABLE', False) else '安全'}\n")
                        f.write(f"CVSS评分: {result.get('CVSS', 'N/A')}\n")
                        f.write(f"检测时间: {result.get('TIMESTAMP', '')}\n")
                        f.write("-" * 50 + "\n\n")
            
            QMessageBox.information(self, "成功", f"📤 结果已导出到: {file_path}")
        except Exception as e:
            QMessageBox.critical(self, "导出错误", f"无法导出结果: {str(e)}")

    # 修复后的HTML报告导出方法 - 解决浏览器无法打开的问题
    def export_html_report(self):
        """导出HTML可视化报告 - 修复版本"""
        if not self.scan_results:
            QMessageBox.warning(self, "警告", "没有可导出的结果")
            return
        
        # 修复：设置默认保存位置为用户桌面或文档目录
        import os
        import platform
        
        # 获取用户主目录下的合适位置
        if platform.system() == "Windows":
            default_dir = os.path.join(os.path.expanduser("~"), "Desktop")
        else:
            # Linux/macOS
            desktop_dir = os.path.join(os.path.expanduser("~"), "Desktop")
            documents_dir = os.path.join(os.path.expanduser("~"), "Documents")
            
            # 优先选择桌面，如果不存在则选择文档目录
            if os.path.exists(desktop_dir):
                default_dir = desktop_dir
            elif os.path.exists(documents_dir):
                default_dir = documents_dir
            else:
                default_dir = os.path.expanduser("~")
        
        # 修复：使用安全的文件名和路径
        import datetime
        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        default_filename = f"CPU漏洞检测报告_{timestamp}.html"
        default_path = os.path.join(default_dir, default_filename)
        
        file_path, _ = QFileDialog.getSaveFileName(
            self, "导出可视化报告", default_path, "HTML文件 (*.html)"
        )
        
        if not file_path:
            return
        
        try:
            # 修复：确保文件路径的目录存在且可写
            file_dir = os.path.dirname(file_path)
            if not os.path.exists(file_dir):
                os.makedirs(file_dir, exist_ok=True)
            
            # 检查目录是否可写
            if not os.access(file_dir, os.W_OK):
                QMessageBox.critical(self, "权限错误", 
                                f"无法写入到目录: {file_dir}\n请选择其他位置或检查权限")
                return
            
            exporter = ReportExporter(self.scan_results, self.system_info)
            success, message = exporter.export_html_report(file_path)
            
            if success:
                # 修复：验证文件是否成功创建
                if os.path.exists(file_path) and os.path.getsize(file_path) > 0:
                    # 询问是否打开报告
                    reply = QMessageBox.question(
                        self, "导出成功", 
                        f"📄 可视化报告已成功导出到:\n{file_path}\n\n"
                        f"文件大小: {os.path.getsize(file_path)} 字节\n\n"
                        f"是否立即打开查看？",
                        QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes
                    )
                    
                    if reply == QMessageBox.Yes:
                        self.open_html_report(file_path)
                else:
                    QMessageBox.warning(self, "导出警告", 
                                    f"文件已保存但可能不完整:\n{file_path}")
            else:
                QMessageBox.critical(self, "导出错误", message)
                
        except PermissionError:
            QMessageBox.critical(self, "权限错误", 
                            f"没有权限写入文件:\n{file_path}\n\n请选择其他位置或以管理员身份运行")
        except Exception as e:
            QMessageBox.critical(self, "导出错误", f"无法导出可视化报告: {str(e)}")

    def open_html_report(self, file_path):
        """打开HTML报告 - 修复版本"""
        try:
            import webbrowser
            import platform
            import subprocess
            
            # 修复：将路径转换为file:// URL格式
            if platform.system() == "Windows":
                # Windows系统
                file_url = f"file:///{file_path.replace(os.sep, '/')}"
            else:
                # Linux/macOS系统  
                file_url = f"file://{file_path}"
            
            # 尝试多种方式打开文件
            try:
                # 方法1: 使用webbrowser模块
                webbrowser.open(file_url)
                
            except Exception as e1:
                try:
                    # 方法2: 使用系统默认程序
                    if platform.system() == "Windows":
                        os.startfile(file_path)
                    elif platform.system() == "Darwin":  # macOS
                        subprocess.run(["open", file_path])
                    else:  # Linux
                        subprocess.run(["xdg-open", file_path])
                        
                except Exception as e2:
                    # 方法3: 提供手动打开提示
                    QMessageBox.information(
                        self, "请手动打开", 
                        f"无法自动打开浏览器，请手动打开以下文件:\n\n"
                        f"文件路径: {file_path}\n\n"
                        f"您可以:\n"
                        f"1. 直接双击文件\n"
                        f"2. 在浏览器中按Ctrl+O打开文件\n"
                        f"3. 将文件拖拽到浏览器窗口中\n\n"
                        f"错误信息: {str(e1)}, {str(e2)}"
                    )
                    
        except Exception as e:
            QMessageBox.critical(self, "打开失败", 
                            f"无法打开HTML报告: {str(e)}\n\n"
                            f"请手动双击文件打开:\n{file_path}")


            
    def run_exploit(self, row):
        if 0 <= row < len(self.scan_results):
            result = self.scan_results[row]
            if result.get("CVE") == "CVE-2022-4543" and result.get("VULNERABLE", False):
                reply = QMessageBox.question(
                    self, "⚠️ 确认攻击演示",
                    "此操作将模拟EntryBleed攻击以演示漏洞利用效果。\n"
                    "攻击将尝试绕过KASLR保护并获取内核基址。\n\n"
                    "确定要继续吗？",
                    QMessageBox.Yes | QMessageBox.No, QMessageBox.No
                )
                
                if reply == QMessageBox.Yes:
                    self.status_label.setText("🔴 正在执行EntryBleed攻击演示...")
                    
                    try:
                        self.exploit_thread = ExploitThread()
                        self.exploit_thread.finished.connect(self.show_exploit_results)
                        self.exploit_thread.error.connect(self.show_exploit_error)
                        self.exploit_thread.start()
                    except Exception as e:
                        self.status_label.setText("❌ 攻击启动失败")
                        QMessageBox.critical(self, "内部错误", f"无法启动攻击线程: {str(e)}")
            else:
                QMessageBox.warning(self, "无法执行", "此漏洞不受影响或无法执行攻击演示")
    
    def show_exploit_results(self, results_dir):
        self.status_label.setText("✅ 攻击演示完成")
        dialog = ExploitResultsDialog(results_dir, self)
        dialog.exec_()

    def show_exploit_error(self, error_msg):
        self.status_label.setText("❌ 攻击演示失败")
        QMessageBox.critical(self, "攻击错误", error_msg)
    
    def show_output_in_new_window(self):
        """在新窗口中显示详细输出"""
        fonts = get_system_fonts()
        
        dialog = QDialog(self)
        dialog.setWindowTitle("📝 详细输出")
        dialog.setMinimumSize(800, 600)
        dialog.resize(900, 700)
        dialog.setStyleSheet("QDialog { background-color: #f8f9fa; }")
        
        layout = QVBoxLayout(dialog)
        layout.setContentsMargins(20, 20, 20, 20)
        
        # 标题和过滤器
        header_layout = QHBoxLayout()
        
        title_label = QLabel("📝 详细输出")
        title_label.setStyleSheet(f"""
            QLabel {{
                font-family: {', '.join(fonts['ui'])};
                font-size: 20px;
                font-weight: 700;
                color: #2c3e50;
            }}
        """)
        header_layout.addWidget(title_label)
        header_layout.addStretch()
        
        # 过滤器
        filter_label = QLabel("输出类型:")
        filter_label.setStyleSheet(f"font-family: {', '.join(fonts['ui'])}; font-weight: 600; color: #2c3e50; font-size: 14px;")
        
        filter_combo = ModernComboBox()
        filter_combo.addItems(["全部", "动态分析", "静态分析"])
        filter_combo.setCurrentText(self.output_type_combo.currentText())
        
        header_layout.addWidget(filter_label)
        header_layout.addWidget(filter_combo)
        
        layout.addLayout(header_layout)
        
        # 文本区域
        text_edit = QTextEdit()
        text_edit.setReadOnly(True)
        text_edit.setText(self.output_text.toPlainText())
        text_edit.setStyleSheet(f"""
            QTextEdit {{
                font-family: {', '.join(fonts['mono'])};
                font-size: 13pt;
                background-color: #2c3e50;
                color: #ecf0f1;
                border: none;
                border-radius: 8px;
                padding: 20px;
                line-height: 1.5;
            }}
        """)
        layout.addWidget(text_edit)
        
        # 更新过滤器功能
        def update_filter():
            selected_type = filter_combo.currentText()
            output_text = ""
            
            if selected_type == "全部":
                if hasattr(self, 'dynamic_output'):
                    output_text += ''.join(self.dynamic_output)
                if hasattr(self, 'static_output'):
                    output_text += ''.join(self.static_output)
            elif selected_type == "动态分析" and hasattr(self, 'dynamic_output'):
                output_text = ''.join(self.dynamic_output)
            elif selected_type == "静态分析" and hasattr(self, 'static_output'):
                output_text = ''.join(self.static_output)
            
            text_edit.setText(output_text)
            text_edit.moveCursor(text_edit.textCursor().End)
        
        filter_combo.currentIndexChanged.connect(update_filter)
        
        # 按钮
        button_layout = QHBoxLayout()
        
        copy_button = QPushButton("📋 复制全部内容")
        copy_button.setStyleSheet(f"""
            QPushButton {{
                font-family: {', '.join(fonts['ui'])};
                background-color: #3498db;
                color: white;
                border: none;
                border-radius: 6px;
                padding: 10px 20px;
                font-size: 12px;
                font-weight: 500;
            }}
            QPushButton:hover {{
                background-color: #2980b9;
            }}
        """)
        copy_button.clicked.connect(lambda: QApplication.clipboard().setText(text_edit.toPlainText()))
        
        save_button = QPushButton("💾 保存到文件")
        save_button.setStyleSheet(f"""
            QPushButton {{
                font-family: {', '.join(fonts['ui'])};
                background-color: #27ae60;
                color: white;
                border: none;
                border-radius: 6px;
                padding: 10px 20px;
                font-size: 12px;
                font-weight: 500;
            }}
            QPushButton:hover {{
                background-color: #219a52;
            }}
        """)
        
        def save_to_file():
            file_path, _ = QFileDialog.getSaveFileName(
                dialog, "保存输出", "", "文本文件 (*.txt);;日志文件 (*.log)"
            )
            if file_path:
                try:
                    with open(file_path, 'w', encoding='utf-8') as f:
                        f.write(text_edit.toPlainText())
                    QMessageBox.information(dialog, "成功", f"输出已保存到: {file_path}")
                except Exception as e:
                    QMessageBox.critical(dialog, "错误", f"保存失败: {str(e)}")
        
        save_button.clicked.connect(save_to_file)
        
        close_button = QPushButton("✖️ 关闭")
        close_button.setStyleSheet(f"""
            QPushButton {{
                font-family: {', '.join(fonts['ui'])};
                background-color: #95a5a6;
                color: white;
                border: none;
                border-radius: 6px;
                padding: 10px 20px;
                font-size: 12px;
                font-weight: 500;
            }}
            QPushButton:hover {{
                background-color: #7f8c8d;
            }}
        """)
        close_button.clicked.connect(dialog.accept)
        
        button_layout.addWidget(copy_button)
        button_layout.addWidget(save_button)
        button_layout.addStretch()
        button_layout.addWidget(close_button)
        layout.addLayout(button_layout)
        
        dialog.exec_()

    # 添加PoC环境检查方法：
    def check_poc_environment(self):
        """检查PoC编译环境是否可用"""
        try:
            tools_dir = os.path.join(os.path.dirname(__file__), "tools")
            compiled_dir = os.path.join(tools_dir, "compiled") 
            
            if not os.path.exists(compiled_dir):
                return False
                
            # 检查关键PoC是否存在
            required_pocs = ["spectre-v2", "spectre-v4", "zombieload", "entrybleed"]
            available_pocs = []
            
            for poc in required_pocs:
                poc_path = os.path.join(compiled_dir, poc)
                if os.path.exists(poc_path) and os.access(poc_path, os.X_OK):
                    available_pocs.append(poc)
            
            if available_pocs:
                # 修复：只有在status_label存在时才更新状态
                if hasattr(self, 'status_label'):
                    self.status_label.setText(f"🛡️ 动态分析就绪 ({len(available_pocs)}/{len(required_pocs)} PoC可用)")
                return True
            else:
                # 修复：只有在status_label存在时才更新状态
                if hasattr(self, 'status_label'):
                    self.status_label.setText("⚠️ 未找到PoC，建议运行setup_pocs.sh")
                return False
                
        except Exception as e:
            # 修复：只有在status_label存在时才更新状态
            if hasattr(self, 'status_label'):
                self.status_label.setText(f"❌ PoC环境检查失败: {str(e)}")
            # 对于调试，我们可以打印错误信息
            print(f"PoC环境检查失败: {str(e)}")
            return False
            

    # 添加PoC环境管理方法：
    def setup_poc_environment(self):
        """设置PoC环境"""
        setup_script = os.path.join(os.path.dirname(__file__), "setup_pocs.sh")
        
        if not os.path.exists(setup_script):
            QMessageBox.warning(self, "文件不存在", 
                            "setup_pocs.sh脚本不存在，请确保脚本在工具根目录中")
            return
        
        reply = QMessageBox.question(self, "设置PoC环境",
                                "这将下载并编译各种CPU漏洞的PoC代码。\n"
                                "这个过程可能需要几分钟时间。\n\n"
                                "确定要继续吗？",
                                QMessageBox.Yes | QMessageBox.No,
                                QMessageBox.Yes)
        
        if reply == QMessageBox.Yes:
            self.run_setup_script(setup_script)

    def run_setup_script(self, script_path):
        """在后台运行PoC设置脚本"""
        from PyQt5.QtCore import QProcess
        
        self.setup_process = QProcess(self)
        self.setup_process.finished.connect(self.on_setup_finished)
        self.setup_process.readyReadStandardOutput.connect(self.on_setup_output)
        
        # 禁用相关按钮
        self.setup_pocs_button.setEnabled(False)
        self.setup_pocs_button.setText("🔄 正在设置...")
        
        # 启动进程
        self.setup_process.start("bash", [script_path])
    
    def on_setup_output(self):
        """处理设置脚本输出"""
        data = self.setup_process.readAllStandardOutput()
        stdout = bytes(data).decode("utf8")
        
        # 在详细输出标签页中显示进度
        self.update_output(stdout, "static")

    def on_setup_finished(self, exit_code):
        """设置脚本完成回调"""
        self.setup_pocs_button.setEnabled(True)
        self.setup_pocs_button.setText("🔧 设置PoC环境")
        
        if exit_code == 0:
            QMessageBox.information(self, "设置完成", 
                                "PoC环境设置成功！\n\n"
                                "现在可以使用动态分析功能了。")
            
            # 重新检查PoC环境
            self.poc_available = self.check_poc_environment()
            self.dynamic_analysis_cb.setEnabled(self.poc_available)
            self.dynamic_analysis_cb.setChecked(self.poc_available)
            self.test_pocs_button.setEnabled(self.poc_available)
            
        else:
            QMessageBox.critical(self, "设置失败",
                            f"PoC环境设置失败 (退出码: {exit_code})\n\n"
                            "请查看详细输出了解错误信息。")

    def test_poc_environment(self):
        """测试PoC环境"""
        test_script = os.path.join(os.path.dirname(__file__), "tools", "test_all_pocs.sh")
        
        if not os.path.exists(test_script):
            QMessageBox.warning(self, "测试脚本不存在",
                            "test_all_pocs.sh脚本不存在，请先设置PoC环境")
            return
        
        reply = QMessageBox.question(self, "测试PoC环境",
                                "这将运行所有可用的PoC进行快速测试。\n"
                                "测试过程中可能会有安全警告，这是正常的。\n\n"
                                "确定要继续吗？",
                                QMessageBox.Yes | QMessageBox.No,
                                QMessageBox.No)
        
        if reply == QMessageBox.Yes:
            self.run_test_script(test_script)

    def run_test_script(self, script_path):
        """运行PoC测试脚本"""
        from PyQt5.QtCore import QProcess
        
        self.test_process = QProcess(self)
        self.test_process.finished.connect(self.on_test_finished)
        self.test_process.readyReadStandardOutput.connect(self.on_test_output)
        
        # 切换到详细输出标签页
        self.main_tabs.setCurrentIndex(2)  # 假设详细输出是第3个标签页
        
        # 清空输出
        self.output_text.clear()
        
        # 禁用测试按钮
        self.test_pocs_button.setEnabled(False)
        self.test_pocs_button.setText("🔄 正在测试...")
        
        # 启动测试
        self.test_process.start("bash", [script_path])
        self.update_output("=== 开始PoC环境测试 ===\n", "dynamic")

    def on_test_output(self):
        """处理测试脚本输出"""
        data = self.test_process.readAllStandardOutput()
        stdout = bytes(data).decode("utf8")
        self.update_output(stdout, "dynamic")

    def on_test_finished(self, exit_code):
        """测试脚本完成回调"""
        self.test_pocs_button.setEnabled(True)
        self.test_pocs_button.setText("🧪 测试PoC")
        
        self.update_output(f"\n=== PoC测试完成 (退出码: {exit_code}) ===\n", "dynamic")
        
        if exit_code == 0:
            QMessageBox.information(self, "测试完成",
                                "所有PoC测试完成！\n\n"
                                "请查看详细输出了解测试结果。")
        else:
            QMessageBox.warning(self, "测试警告", 
                            f"某些PoC测试可能失败 (退出码: {exit_code})\n\n"
                            "这可能是正常的，具体请查看详细输出。")
            

    def update_poc_status(self):
        """更新PoC状态显示 - 在UI初始化完成后调用"""
        try:
            tools_dir = os.path.join(os.path.dirname(__file__), "tools")
            compiled_dir = os.path.join(tools_dir, "compiled") 
            
            if not os.path.exists(compiled_dir):
                if hasattr(self, 'status_label'):
                    self.status_label.setText("⚠️ 未找到PoC编译目录，建议运行setup_pocs.sh")
                return
                
            # 检查关键PoC是否存在
            required_pocs = ["spectre-v2", "spectre-v4", "zombieload", "entrybleed"]
            available_pocs = []
            
            for poc in required_pocs:
                poc_path = os.path.join(compiled_dir, poc)
                if os.path.exists(poc_path) and os.access(poc_path, os.X_OK):
                    available_pocs.append(poc)
            
            if available_pocs:
                if hasattr(self, 'status_label'):
                    self.status_label.setText(f"🛡️ 动态分析就绪 ({len(available_pocs)}/{len(required_pocs)} PoC可用)")
            else:
                if hasattr(self, 'status_label'):
                    self.status_label.setText("⚠️ 未找到PoC，建议运行setup_pocs.sh")
                
        except Exception as e:
            if hasattr(self, 'status_label'):
                self.status_label.setText(f"❌ PoC环境检查失败: {str(e)}")


    def show_quick_start_from_menu(self):
        """从菜单显示快速入门指南"""
        show_quick_start_guide(self)

    def reset_quick_start_preference(self):
        """重置快速入门偏好设置"""
        try:
            dont_show_file = os.path.expanduser('~/.cpu-vuln-scanner-dont-show')
            if os.path.exists(dont_show_file):
                os.remove(dont_show_file)
                QMessageBox.information(self, "设置重置", 
                                    "✅ 快速入门指南偏好设置已重置！\n下次启动时将重新显示指南。")
            else:
                QMessageBox.information(self, "提示", 
                                    "当前设置为每次启动都显示快速入门指南。")
        except Exception as e:
            QMessageBox.warning(self, "操作失败", f"重置设置失败: {str(e)}")

    # 如果需要在菜单栏中添加这些选项，可以在init_ui方法中添加：
    def add_help_menu(self):
        """添加帮助菜单"""
        menubar = self.menuBar()
        help_menu = menubar.addMenu('帮助(&H)')
        
        # 显示快速入门指南
        quick_start_action = help_menu.addAction('🚀 快速入门指南')
        quick_start_action.triggered.connect(self.show_quick_start_from_menu)
        
        help_menu.addSeparator()
        
        # 重置快速入门偏好
        reset_pref_action = help_menu.addAction('🔄 重置启动指南设置')
        reset_pref_action.triggered.connect(self.reset_quick_start_preference)
        
        help_menu.addSeparator()
        
        # 关于
        about_action = help_menu.addAction('ℹ️ 关于')
        about_action.triggered.connect(self.show_about_dialog)

    def show_about_dialog(self):
        """显示关于对话框"""
        QMessageBox.about(self, "关于 SpecProbe", 
                        "🛡️ SpecProbe v3.0.0\n\n"
                        "现代化CPU漏洞检测工具\n"
                        "集成静态分析和动态PoC验证\n\n"
                        "支持20多种CPU漏洞检测\n"
                        "包括Spectre、Meltdown、EntryBleed等\n\n"
                        "Copyright © 2024\n"
                        "仅供安全研究和系统评估使用")


    def perform_pre_scan_warmup(self):
        """在开始扫描前执行的预热操作"""
        try:
            self.status_label.setText("🔥 系统预热中...")
            self.update_output("🔥 开始系统环境预热...\n", "static")
            
            # 1. 预热CPU信息
            try:
                if os.path.exists("/proc/cpuinfo"):
                    with open("/proc/cpuinfo", "r") as f:
                        f.read(1024)
                    self.update_output("  ✓ CPU信息预热完成\n", "static")
            except:
                pass
            
            # 2. 预热bash环境
            try:
                subprocess.run(["bash", "--version"], 
                            capture_output=True, timeout=5)
                self.update_output("  ✓ Bash环境预热完成\n", "static")
            except:
                pass
            
            # 3. 测试sudo权限
            if not os.geteuid() == 0:
                try:
                    result = subprocess.run(["sudo", "-n", "true"], 
                                        capture_output=True, timeout=3)
                    if result.returncode == 0:
                        self.update_output("  ✓ Sudo权限预热完成\n", "static")
                    else:
                        self.update_output("  ℹ Sudo需要密码验证\n", "static")
                except:
                    pass
            
            # 4. 给系统时间稳定
            import time
            time.sleep(1)
            
            self.update_output("✅ 系统预热完成\n", "static")
            return True
            
        except Exception as e:
            self.update_output(f"⚠️ 系统预热失败: {e}\n", "static")
            return False