Day-150-CVE 申请与管理

# Day 164: CVE 申请与管理

> 漏洞与攻防系列第 9 天 | 预计阅读时间：60 分钟 | 难度：★★★★☆

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ CVE 申请与管理 - Day 164           │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ CVE 不是随便申请，是规范流程。流程不遵守，编号就是无效的。今天深入 CVE 申请与管理。

---

## 清单 目录

1. [CVE 概述](#cve 概述)
2. [CVE 编号系统](#cve 编号系统)
3. [CVE 申请流程](#cve 申请流程)
4. [CNA 角色与职责](#cna 角色与职责)
5. [CVE 记录编写](#cve 记录编写)
6. [CVSS 评分系统](#cvss 评分系统)
7. [CVE 管理实践](#cve 管理实践)
8. [常见问题解决](#常见问题解决)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## CVE 概述

### 什么是 CVE

> ▎ CVE 不是漏洞本身，是漏洞身份证。身份证不规范，管理就是混乱的。

**定义与价值**：
```
CVE (Common Vulnerabilities and Exposures) 是公开的安全漏洞标准化标识符系统，由 MITRE 组织维护。

核心价值:
1. 标准化标识
   - 唯一漏洞 ID
   - 便于交流沟通
   - 支持工具互操作

2. 信息共享
   - 公开漏洞信息
   - 促进安全研究
   - 支持威胁情报

3. 漏洞管理
   - 跟踪漏洞状态
   - 关联安全工具
   - 支持合规要求
```

**CVE 系统结构**：
```
┌─────────────────────────────────────────────────────────┐
│              CVE 系统结构                                │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  CVE Numbering Authorities (CNA）                       │
│  ├── 授权组织分配 CVE 编号                              │
│  ├── 包括厂商、研究机构、协调中心                       │
│  └── 目前 100+ CNA 组织                                 │
│                                                         │
│  CVE Program                                          │
│  ├── MITRE 运营管理                                     │
│  ├── 制定 CVE 政策                                      │
│  └── 维护 CVE 列表                                      │
│                                                         │
│  National Vulnerability Database (NVD)                 │
│  ├── NIST 运营                                          │
│  ├── 提供 CVSS 评分                                     │
│  └── 关联 CVE 与其他数据                                │
│                                                         │
│  用户社区                                               │
│  ├── 安全研究人员                                       │
│  ├── 厂商                                               │
│  ├── 安全工具厂商                                       │
│  └── 最终用户                                           │
│                                                         │
└─────────────────────────────────────────────────────────┘
```

### CVE 编号格式

**编号规则**：
```
CVE 编号格式:

格式：CVE-YYYY-NNNNN
├── CVE: 固定前缀
├── YYYY: 发现年份或公开年份
└── NNNNN: 序列号 (至少 4 位)

示例:
├── CVE-2021-44228 (Log4j)
├── CVE-2017-0144 (EternalBlue)
└── CVE-2023-12345 (示例)

序列号规则:
├── 4 位：0001-9999 (早期)
├── 5 位：10000-99999 (现在常用)
└── 6 位+: 高容量 CNA 可用

保留编号:
├── CVE-YYYY-0000: 保留
├── CVE-YYYY-9999: 保留
└── 特定范围保留给特定 CNA
```

---

## CVE 编号系统

### CNA 组织

> ▎ CNA 不是随便找，是有权限的。权限不明确，申请就是无效的。

**CNA 类型**：
```python
# CNA 组织类型
class CNATypes:
    """CNA 组织类型"""
    
    types = {
        'vendor': {
            'name': '厂商 CNA',
            'description': '产品厂商分配自己产品的 CVE',
            'examples': [
                'Microsoft',
                'Google',
                'Apple',
                'Adobe',
                'Oracle'
            ],
            'scope': '自己产品的漏洞',
            'process': '直接向 CVE Program 申请'
        },
        
        'coordinator': {
            'name': '协调中心 CNA',
            'description': '协调多个厂商的漏洞披露',
            'examples': [
                'CERT/CC',
                'JPCERT/CC',
                'NCSC'
            ],
            'scope': '多厂商漏洞协调',
            'process': '协调后分配 CVE'
        },
        
        'researcher': {
            'name': '研究员 CNA',
            'description': '安全研究人员分配 CVE',
            'examples': [
                'HackerOne',
                'Bugcrowd',
                '学术机构'
            ],
            'scope': '研究的漏洞',
            'process': '通过 CNA 伙伴申请'
        },
        
        'open': {
            'name': '开放 CNA',
            'description': '接受外部提交的 CNA',
            'examples': [
                'MITRE (剩余漏洞)',
                'GitHub Security Lab'
            ],
            'scope': '无其他 CNA 负责的漏洞',
            'process': '直接提交申请'
        }
    }
    
    def find_appropriate_cna(self, vulnerability_info):
        """查找合适的 CNA"""
        vendor = vulnerability_info.get('vendor', '')
        product = vulnerability_info.get('product', '')
        reporter_type = vulnerability_info.get('reporter_type', 'researcher')
        
        # 优先顺序:
        # 1. 厂商 CNA (如果厂商有 CNA)
        # 2. 协调中心 (如果多厂商)
        # 3. 开放 CNA (其他情况)
        
        if self.vendor_has_cna(vendor):
            return {'type': 'vendor', 'name': self.get_vendor_cna(vendor)}
        
        if self.is_multi_vendor(vulnerability_info):
            return {'type': 'coordinator', 'name': 'CERT/CC'}
        
        if reporter_type == 'researcher':
            return {'type': 'open', 'name': 'MITRE'}
        
        return {'type': 'open', 'name': 'MITRE'}
    
    def vendor_has_cna(self, vendor):
        """检查厂商是否有 CNA"""
        cna_vendors = [
            'microsoft', 'google', 'apple', 'adobe', 'oracle',
            'cisco', 'ibm', 'redhat', 'debian', 'ubuntu',
            'mozilla', 'apache', 'linux', 'vmware'
        ]
        
        return vendor.lower() in cna_vendors
    
    def get_vendor_cna(self, vendor):
        """获取厂商 CNA"""
        cna_map = {
            'microsoft': 'Microsoft Security Response Center',
            'google': 'Google Security',
            'apple': 'Apple Product Security',
            'adobe': 'Adobe Product Security Incident Response Team',
            'oracle': 'Oracle Security Response Center',
            'cisco': 'Cisco PSIRT',
            'ibm': 'IBM Security Response Center',
            'redhat': 'Red Hat Product Security',
            'debian': 'Debian Security Team',
            'ubuntu': 'Ubuntu Security Team',
            'mozilla': 'Mozilla Security',
            'apache': 'Apache Security Team',
            'linux': 'Linux Kernel Security',
            'vmware': 'VMware Security Response Center'
        }
        
        return cna_map.get(vendor.lower(), 'MITRE')
    
    def is_multi_vendor(self, vuln_info):
        """检查是否多厂商漏洞"""
        # 影响多个厂商的产品
        affected_products = vuln_info.get('affected_products', [])
        
        vendors = set()
        for product in affected_products:
            vendors.add(product.get('vendor', ''))
        
        return len(vendors) > 1
```

### CVE 分配流程

**分配流程**：
```python
# CVE 分配流程
class CVEAllocation:
    """CVE 分配流程"""
    
    def allocate_cve(self, vulnerability_info):
        """分配 CVE 编号"""
        # 1. 确定 CNA
        cna = self.determine_cna(vulnerability_info)
        
        # 2. 检查是否已有 CVE
        existing_cve = self.check_existing_cve(vulnerability_info)
        
        if existing_cve:
            return {
                'status': 'exists',
                'cve_id': existing_cve,
                'message': 'CVE already exists'
            }
        
        # 3. 申请 CVE
        cve_id = self.request_cve(cna, vulnerability_info)
        
        # 4. 验证 CVE
        verified = self.verify_cve(cve_id)
        
        if not verified:
            return {
                'status': 'failed',
                'message': 'CVE allocation failed'
            }
        
        # 5. 关联漏洞信息
        self.associate_vulnerability_info(cve_id, vulnerability_info)
        
        return {
            'status': 'success',
            'cve_id': cve_id,
            'cna': cna,
            'allocation_date': self.get_current_date()
        }
    
    def determine_cna(self, vuln_info):
        """确定 CNA"""
        # 基于厂商、产品类型等
        vendor = vuln_info.get('vendor', '')
        
        if vendor:
            # 厂商 CNA
            return self.get_vendor_cna(vendor)
        else:
            # MITRE 作为默认
            return 'MITRE'
    
    def check_existing_cve(self, vuln_info):
        """检查是否已有 CVE"""
        # 搜索 NVD、CVE 列表等
        # 基于漏洞描述、影响产品等
        
        # 实际实现需要调用 NVD API
        return None  # 示例
    
    def request_cve(self, cna, vuln_info):
        """申请 CVE"""
        # 根据 CNA 不同，申请方式不同
        
        if cna == 'MITRE':
            return self.request_mitre_cve(vuln_info)
        elif cna == 'Microsoft':
            return self.request_microsoft_cve(vuln_info)
        # ... 其他 CNA
        
        return None
    
    def request_mitre_cve(self, vuln_info):
        """向 MITRE 申请 CVE"""
        # 通过 CVE Request 表单或 API
        
        request_data = {
            'cve_year': vuln_info.get('year', self.get_current_year()),
            'product': vuln_info.get('product', ''),
            'vendor': vuln_info.get('vendor', ''),
            'description': vuln_info.get('description', ''),
            'references': vuln_info.get('references', []),
            'reporter': vuln_info.get('reporter', '')
        }
        
        # 提交申请
        # cve_id = submit_mitre_request(request_data)
        
        return 'CVE-YYYY-NNNNN'  # 示例
    
    def verify_cve(self, cve_id):
        """验证 CVE"""
        # 检查 CVE 是否已分配
        # 通过 NVD API 或 CVE 列表
        
        return True  # 示例
    
    def associate_vulnerability_info(self, cve_id, vuln_info):
        """关联漏洞信息"""
        # 将 CVE 与漏洞详细信息关联
        # 存储到数据库或漏洞管理系统
        
        pass
```

---

## CVE 申请流程

### 申请步骤

> ▎ CVE 不是填表就行，是规范申请。申请不规范，审批就是缓慢的。

**申请流程详解**：
```python
# CVE 申请流程
class CVEApplication:
    """CVE 申请流程"""
    
    # 申请步骤
    steps = {
        'preparation': {
            'name': '准备阶段',
            'activities': [
                '收集漏洞信息',
                '确定合适 CNA',
                '准备申请材料'
            ],
            'outputs': ['漏洞报告', 'CNA 选择', '申请表格']
        },
        
        'submission': {
            'name': '提交阶段',
            'activities': [
                '填写申请表格',
                '提交漏洞报告',
                '提供 PoC (可选)'
            ],
            'outputs': ['申请提交确认']
        },
        
        'review': {
            'name': '审核阶段',
            'activities': [
                'CNA 审核',
                '补充信息 (如需)',
                'CVE 分配'
            ],
            'outputs': ['CVE 编号', '审核结果']
        },
        
        'publication': {
            'name': '发布阶段',
            'activities': [
                'CVE 记录发布',
                'NVD 同步',
                '公开披露'
            ],
            'outputs': ['CVE 记录', 'NVD 条目']
        }
    }
    
    def execute_application(self, vulnerability_info):
        """执行 CVE 申请"""
        results = {
            'vulnerability': vulnerability_info,
            'steps': {},
            'cve_id': None,
            'status': 'pending'
        }
        
        # 准备阶段
        preparation = self.prepare_application(vulnerability_info)
        results['steps']['preparation'] = preparation
        
        # 提交阶段
        submission = self.submit_application(preparation)
        results['steps']['submission'] = submission
        
        # 审核阶段
        review = self.track_review(submission)
        results['steps']['review'] = review
        
        if review['approved']:
            results['cve_id'] = review['cve_id']
            results['status'] = 'approved'
        else:
            results['status'] = 'rejected'
        
        # 发布阶段
        if results['status'] == 'approved':
            publication = self.track_publication(results['cve_id'])
            results['steps']['publication'] = publication
        
        return results
    
    def prepare_application(self, vuln_info):
        """准备申请"""
        # 收集必要信息
        required_info = {
            'product_name': vuln_info.get('product', ''),
            'vendor_name': vuln_info.get('vendor', ''),
            'affected_versions': vuln_info.get('affected_versions', []),
            'vulnerability_description': vuln_info.get('description', ''),
            'vulnerability_type': vuln_info.get('type', ''),
            'impact': vuln_info.get('impact', ''),
            'references': vuln_info.get('references', []),
            'reporter_info': vuln_info.get('reporter', {})
        }
        
        # 检查信息完整性
        missing_fields = self.check_required_fields(required_info)
        
        if missing_fields:
            return {
                'status': 'incomplete',
                'missing_fields': missing_fields,
                'ready': False
            }
        
        # 确定 CNA
        cna = self.determine_cna(vuln_info)
        
        # 准备申请表格
        application_form = self.create_application_form(required_info, cna)
        
        return {
            'status': 'ready',
            'cna': cna,
            'form': application_form,
            'ready': True
        }
    
    def check_required_fields(self, info):
        """检查必填字段"""
        required = [
            'product_name',
            'vendor_name',
            'affected_versions',
            'vulnerability_description'
        ]
        
        missing = []
        for field in required:
            if not info.get(field):
                missing.append(field)
        
        return missing
    
    def create_application_form(self, info, cna):
        """创建申请表格"""
        form = {
            'cve_year': self.get_current_year(),
            'product': info['product_name'],
            'vendor': info['vendor_name'],
            'affected_versions': info['affected_versions'],
            'description': info['vulnerability_description'],
            'type': info['vulnerability_type'],
            'impact': info['impact'],
            'references': info['references'],
            'reporter': info['reporter_info'],
            'cna': cna
        }
        
        return form
    
    def submit_application(self, preparation):
        """提交申请"""
        if not preparation['ready']:
            return {
                'status': 'failed',
                'reason': 'Application not ready'
            }
        
        cna = preparation['cna']
        form = preparation['form']
        
        # 根据 CNA 提交
        if cna == 'MITRE':
            submission = self.submit_to_mitre(form)
        elif cna == 'Microsoft':
            submission = self.submit_to_microsoft(form)
        # ... 其他 CNA
        
        return {
            'status': 'submitted',
            'submission_id': submission.get('id'),
            'submission_date': submission.get('date'),
            'cna': cna
        }
    
    def track_review(self, submission):
        """跟踪审核"""
        # 等待审核
        # 定期查询状态
        
        review_result = {
            'approved': True,
            'cve_id': 'CVE-2024-XXXXX',
            'review_date': self.get_current_date(),
            'reviewer_comments': ''
        }
        
        return review_result
    
    def track_publication(self, cve_id):
        """跟踪发布"""
        # 等待 CVE 记录发布
        # 检查 NVD 同步
        
        publication = {
            'cve_record_url': f'https://cve.mitre.org/cgi-bin/cvename.cgi?name={cve_id}',
            'nvd_url': f'https://nvd.nist.gov/vuln/detail/{cve_id}',
            'publication_date': self.get_current_date(),
            'status': 'published'
        }
        
        return publication
    
    def get_current_year(self):
        """获取当前年份"""
        from datetime import datetime
        return datetime.now().year
    
    def get_current_date(self):
        """获取当前日期"""
        from datetime import datetime
        return datetime.now().strftime('%Y-%m-%d')
```

### 申请渠道

**申请渠道对比**：
```
CVE 申请渠道:

1. MITRE CVE Request
   ├── 适用：无 CNA 厂商的漏洞
   ├── 网址：https://cveform.mitre.org/
   ├── 响应时间：1-3 工作日
   └── 要求：完整漏洞信息

2. 厂商 CNA
   ├── 适用：厂商产品漏洞
   ├── 网址：各厂商安全页面
   ├── 响应时间： varies
   └── 要求：厂商产品证明

3. 协调中心
   ├── 适用：多厂商漏洞
   ├── 网址：CERT/CC 等
   ├── 响应时间：3-7 工作日
   └── 要求：协调信息

4. GitHub Security Lab
   ├── 适用：开源项目漏洞
   ├── 网址：https://securitylab.github.com/
   ├── 响应时间：1-5 工作日
   └── 要求：开源项目证明
```

---

## CNA 角色与职责

### CNA 职责

> ▎ CNA 不是挂名，是有职责的。职责不履行，系统就是失效的。

**CNA 职责**：
```python
# CNA 职责
class CNAResponsibilities:
    """CNA 职责"""
    
    responsibilities = {
        'scope_definition': {
            'name': '范围定义',
            'description': '定义 CNA 覆盖范围',
            'activities': [
                '明确产品范围',
                '更新范围文档',
                '通知 CVE Program'
            ]
        },
        
        'cve_assignment': {
            'name': 'CVE 分配',
            'description': '分配 CVE 编号',
            'activities': [
                '审核漏洞报告',
                '分配 CVE 编号',
                '确保编号唯一'
            ]
        },
        
        'record_creation': {
            'name': '记录创建',
            'description': '创建 CVE 记录',
            'activities': [
                '编写 CVE 描述',
                '添加参考链接',
                '提供 CVSS 评分'
            ]
        },
        
        'coordination': {
            'name': '协调',
            'description': '协调漏洞披露',
            'activities': [
                '与厂商沟通',
                '协调披露时间',
                '解决争议'
            ]
        },
        
        'quality': {
            'name': '质量',
            'description': '保证记录质量',
            'activities': [
                '审核记录准确性',
                '更新过时信息',
                '纠正错误记录'
            ]
        }
    }
    
    def assess_cna_performance(self, cna_name):
        """评估 CNA 表现"""
        metrics = {
            'response_time': self.get_average_response_time(cna_name),
            'record_quality': self.assess_record_quality(cna_name),
            'coordination_effectiveness': self.assess_coordination(cna_name),
            'compliance': self.assess_compliance(cna_name)
        }
        
        overall_score = self.calculate_overall_score(metrics)
        
        return {
            'cna': cna_name,
            'metrics': metrics,
            'overall_score': overall_score,
            'rating': self.get_rating(overall_score)
        }
    
    def get_average_response_time(self, cna_name):
        """获取平均响应时间"""
        # 基于历史数据
        return 3  # 天
    
    def assess_record_quality(self, cna_name):
        """评估记录质量"""
        # 基于记录完整性、准确性
        return 'high'
    
    def assess_coordination(self, cna_name):
        """评估协调效果"""
        # 基于披露协调成功率
        return 'good'
    
    def assess_compliance(self, cna_name):
        """评估合规性"""
        # 基于 CVE Program 政策遵守
        return 'compliant'
    
    def calculate_overall_score(self, metrics):
        """计算总体分数"""
        # 综合各指标
        return 85
    
    def get_rating(self, score):
        """获取评级"""
        if score >= 90:
            return 'excellent'
        elif score >= 75:
            return 'good'
        elif score >= 60:
            return 'fair'
        else:
            return 'needs_improvement'
```

---

## CVE 记录编写

### 记录结构

> ▎ 记录不是随便写，是规范写。规范不遵守，信息就是混乱的。

**CVE 记录结构**：
```
CVE 记录字段:

1. CVE ID
   └── CVE-YYYY-NNNNN

2. 状态
   ├── RESERVED (保留)
   ├── PUBLIC (公开)
   └── REJECTED (拒绝)

3. 描述
   ├── 产品名称
   ├── 版本范围
   ├── 漏洞类型
   └── 影响说明

4. 参考链接
   ├── 厂商公告
   ├── 安全建议
   ├── 技术报告
   └── 相关新闻

5. 时间信息
   ├── 分配日期
   ├── 公开日期
   └── 修改日期

6. CVSS 评分
   ├── 基础分数
   ├── 时间分数
   └── 环境分数
```

**编写指南**：
```python
# CVE 记录编写
class CVESRecordWriter:
    """CVE 记录编写"""
    
    def create_cve_record(self, cve_id, vulnerability_info):
        """创建 CVE 记录"""
        record = {
            'cve_id': cve_id,
            'status': 'PUBLIC',
            'description': self.create_description(vulnerability_info),
            'references': self.create_references(vulnerability_info),
            'dates': self.create_dates(vulnerability_info),
            'cvss': self.create_cvss(vulnerability_info),
            'cwe': self.get_cwe(vulnerability_info)
        }
        
        return record
    
    def create_description(self, vuln_info):
        """创建描述"""
        # 描述应包含:
        # 1. 产品名称和版本
        # 2. 漏洞类型
        # 3. 影响说明
        # 4. 攻击向量 (如已知)
        
        description = (
            "{vulnerability_type} in {product} {versions} allows "
            "{attacker} to {impact}. {additional_info}"
        ).format(
            vulnerability_type=vuln_info.get('type', 'Vulnerability'),
            product=vuln_info.get('product', 'Unknown Product'),
            versions=vuln_info.get('affected_versions', 'unknown versions'),
            attacker=vuln_info.get('attacker', 'an attacker'),
            impact=vuln_info.get('impact', 'cause impact'),
            additional_info=vuln_info.get('additional_info', '')
        )
        
        return description
    
    def create_references(self, vuln_info):
        """创建参考链接"""
        references = []
        
        # 厂商公告
        if vuln_info.get('vendor_advisory'):
            references.append({
                'name': 'Vendor Advisory',
                'url': vuln_info['vendor_advisory']
            })
        
        # 技术报告
        if vuln_info.get('technical_report'):
            references.append({
                'name': 'Technical Report',
                'url': vuln_info['technical_report']
            })
        
        # 相关新闻
        if vuln_info.get('news'):
            for news in vuln_info['news']:
                references.append({
                    'name': 'News Article',
                    'url': news
                })
        
        return references
    
    def create_dates(self, vuln_info):
        """创建时间信息"""
        return {
            'assigned': vuln_info.get('assigned_date', self.get_current_date()),
            'published': vuln_info.get('published_date'),
            'modified': vuln_info.get('modified_date', self.get_current_date())
        }
    
    def create_cvss(self, vuln_info):
        """创建 CVSS 评分"""
        # 使用 CVSS v3.1
        
        cvss_data = vuln_info.get('cvss', {})
        
        return {
            'version': '3.1',
            'vector_string': cvss_data.get('vector', ''),
            'base_score': cvss_data.get('base_score', 0),
            'base_severity': cvss_data.get('severity', 'UNKNOWN')
        }
    
    def get_cwe(self, vuln_info):
        """获取 CWE 分类"""
        cwe_id = vuln_info.get('cwe_id', '')
        
        if cwe_id:
            return {
                'cwe_id': cwe_id,
                'name': self.get_cwe_name(cwe_id)
            }
        
        return None
    
    def get_cwe_name(self, cwe_id):
        """获取 CWE 名称"""
        cwe_names = {
            'CWE-89': 'SQL Injection',
            'CWE-79': 'Cross-site Scripting (XSS)',
            'CWE-120': 'Buffer Copy without Checking Size of Input',
            'CWE-787': 'Out-of-bounds Write',
            'CWE-78': 'OS Command Injection',
            'CWE-287': 'Improper Authentication'
        }
        
        return cwe_names.get(cwe_id, 'Unknown')
    
    def get_current_date(self):
        """获取当前日期"""
        from datetime import datetime
        return datetime.now().strftime('%Y-%m-%d')
```

---

## CVSS 评分系统

### CVSS 基础

> ▎ CVSS 不是随便打分，是科学评估。评估不科学，优先级就是随意的。

**CVSS v3.1 指标**：
```
CVSS v3.1 基础指标:

攻击向量 (Attack Vector, AV):
├── Network (N): 网络攻击
├── Adjacent (A): 邻近网络
├── Local (L): 本地攻击
└── Physical (P): 物理接触

攻击复杂度 (Attack Complexity, AC):
├── Low (L): 低复杂度
└── High (H): 高复杂度

权限要求 (Privileges Required, PR):
├── None (N): 无需权限
├── Low (L): 低权限
└── High (H): 高权限

用户交互 (User Interaction, UI):
├── None (N): 无需用户交互
└── Required (R): 需要用户交互

范围 (Scope, S):
├── Unchanged (U): 范围不变
└── Changed (C): 范围改变

机密性影响 (Confidentiality, C):
├── None (N): 无影响
├── Low (L): 低影响
└── High (H): 高影响

完整性影响 (Integrity, I):
├── None (N): 无影响
├── Low (L): 低影响
└── High (H): 高影响

可用性影响 (Availability, A):
├── None (N): 无影响
├── Low (L): 低影响
└── High (H): 高影响
```

**CVSS 计算**：
```python
# CVSS 评分计算
class CVSSCalculator:
    """CVSS 评分计算"""
    
    def calculate_cvss_v31(self, metrics):
        """计算 CVSS v3.1 分数"""
        # 基础指标
        av = metrics.get('AV', 'N')  # Attack Vector
        ac = metrics.get('AC', 'L')  # Attack Complexity
        pr = metrics.get('PR', 'N')  # Privileges Required
        ui = metrics.get('UI', 'N')  # User Interaction
        s = metrics.get('S', 'U')    # Scope
        c = metrics.get('C', 'H')    # Confidentiality
        i = metrics.get('I', 'H')    # Integrity
        a = metrics.get('A', 'H')    # Availability
        
        # 计算基础分数
        base_score = self.calculate_base_score(av, ac, pr, ui, s, c, i, a)
        
        # 确定严重程度
        severity = self.get_severity(base_score)
        
        # 生成向量字符串
        vector = self.generate_vector_string(metrics)
        
        return {
            'base_score': round(base_score, 1),
            'severity': severity,
            'vector': vector
        }
    
    def calculate_base_score(self, av, ac, pr, ui, s, c, i, a):
        """计算基础分数"""
        # 权重表
        av_weights = {'N': 0.85, 'A': 0.62, 'L': 0.55, 'P': 0.20}
        ac_weights = {'L': 0.77, 'H': 0.44}
        pr_weights = {
            'U': {'N': 0.85, 'L': 0.62, 'H': 0.27},
            'C': {'N': 0.85, 'L': 0.68, 'H': 0.50}
        }
        ui_weights = {'N': 0.85, 'R': 0.62}
        c_weights = {'N': 0.0, 'L': 0.22, 'H': 0.56}
        i_weights = {'N': 0.0, 'L': 0.22, 'H': 0.56}
        a_weights = {'N': 0.0, 'L': 0.22, 'H': 0.56}
        
        # 计算影响子分数
        isc_base = 1 - (
            (1 - c_weights[c]) *
            (1 - i_weights[i]) *
            (1 - a_weights[a])
        )
        
        # 计算范围
        if isc_base <= 0:
            return 0.0
        
        # 计算 Exploitability
        exploitability = (
            8.22 *
            av_weights[av] *
            ac_weights[ac] *
            pr_weights[s][pr] *
            ui_weights[ui]
        )
        
        # 计算基础分数
        if s == 'U':
            base_score = min(10, 6.42 * isc_base * exploitability)
        else:
            base_score = min(10, 7.52 * (isc_base - 0.029) - 3.25 * (isc_base * 0.973 - 0.02) ** 13 * exploitability)
        
        return base_score
    
    def get_severity(self, score):
        """获取严重程度"""
        if score >= 9.0:
            return 'CRITICAL'
        elif score >= 7.0:
            return 'HIGH'
        elif score >= 4.0:
            return 'MEDIUM'
        elif score >= 0.1:
            return 'LOW'
        else:
            return 'NONE'
    
    def generate_vector_string(self, metrics):
        """生成向量字符串"""
        parts = []
        
        for key, value in metrics.items():
            parts.append(f"{key}:{value}")
        
        return "CVSS:3.1/" + "/".join(parts)
```

---

## 常见问题解决

### 常见问题

> ▎ 问题不是不能解，是有方法解。方法不掌握，申请就是困难的。

**问题与解决**：
```
常见问题:

1. CVE 申请被拒绝
   原因：信息不完整
   解决：补充完整信息后重新申请

2. CVE 编号分配慢
   原因：CNA 工作量大
   解决：联系其他 CNA 或等待

3. 已有 CVE 但信息错误
   原因：初始信息不准确
   解决：联系 CNA 更新记录

4. 多厂商漏洞 CVE
   原因：多个产品受影响
   解决：申请多个 CVE 或协调 CNA

5. CVE 重复申请
   原因：已存在相同漏洞 CVE
   解决：使用现有 CVE
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ██████████ 5/5 │ 生产就绪       │
└───────────────┴────────────────┴────────────────┘
综合：4.5
```
▎ 这才配得上 P8。CVE 不是随便申请，是规范流程。流程不遵守，编号就是无效的。

---

## 总结与思考

### 核心要点回顾

> ▎ 复盘四步法：回顾目标、评估结果、分析原因、总结经验。别跳过——这是闭环。

**CVE 管理框架**：
```
1. CVE 系统
   - CNA 组织
   - 编号规则
   - 分配流程

2. 申请流程
   - 准备信息
   - 选择 CNA
   - 提交申请

3. 记录编写
   - 描述规范
   - 参考链接
   - CVSS 评分

4. 管理实践
   - 跟踪状态
   - 更新记录
   - 解决问题
```

**关键成功因素**：
```
1. 信息完整
   - 产品明确
   - 描述准确
   - 参考充分

2. CNA 选择
   - 厂商优先
   - 协调中心
   - MITRE 备选

3. 流程遵守
   - 负责任披露
   - 及时沟通
   - 记录更新
```

---

## 参考资料

### CVE 资源
```
- CVE Program
  https://cve.mitre.org/

- NVD (National Vulnerability Database)
  https://nvd.nist.gov/

- CVE Request Form
  https://cveform.mitre.org/
```

### CNA 列表
```
- CNA List
  https://cve.mitre.org/cve/request_id.html

- MITRE CNA
  https://cveform.mitre.org/

- GitHub Security Lab
  https://securitylab.github.com/
```

### CVSS 资源
```
- CVSS Calculator
  https://nvd.nist.gov/vuln-metrics/cvss/v3-calculator

- CVSS Specification
  https://www.first.org/cvss/specification-document
```

### 书籍推荐
```
- 《CVE Program Guide》
- 《Vulnerability Management》
- 《The CVSS Guide》
```

---

**标记 明日预告**：Day 165 - 漏洞赏金计划

> ▎ CVE 管理是编号系统，漏洞赏金是激励机制——明天看漏洞赏金计划。

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 164 篇，漏洞与攻防系列第 9 篇，精编版本*

*漏洞与攻防系列 (Day 156-165) 最后一篇明天发布！*