Day-149-漏洞披露流程

# Day 163: 漏洞披露流程

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

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ 漏洞披露流程 - Day 163             │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ 漏洞披露不是随意发，是规范流程。流程不规范，后果就是严重的。今天深入漏洞披露流程。

---

## 清单 目录

1. [漏洞披露概述](#漏洞披露概述)
2. [披露类型](#披露类型)
3. [披露流程详解](#披露流程详解)
4. [厂商沟通技巧](#厂商沟通技巧)
5. [披露平台使用](#披露平台使用)
6. [法律风险规避](#法律风险规避)
7. [披露报告编写](#披露报告编写)
8. [争议处理](#争议处理)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## 漏洞披露概述

### 什么是漏洞披露

> ▎ 漏洞披露不是曝光问题，是推动修复。修复不推动，用户就是危险的。

**定义与价值**：
```
漏洞披露 (Vulnerability Disclosure) 是将发现的安全漏洞信息告知相关方的过程，目的是推动漏洞修复，保护用户安全。

核心价值:
1. 保护用户
   - 及时通知风险
   - 推动厂商修复
   - 减少受害范围

2. 促进安全
   - 提高安全意识
   - 改进安全实践
   - 推动行业发展

3. 知识共享
   - 分享研究成果
   - 促进技术交流
   - 提升整体水平
```

**披露原则**：
```
┌─────────────────────────────────────────────────────────┐
│              漏洞披露原则                                │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  负责任披露 (Responsible Disclosure):                   │
│  ✓ 首先通知厂商                                         │
│  ✓ 给予合理修复时间                                     │
│  ✓ 不公开利用细节 (修复前)                              │
│  ✓ 协调公开披露                                         │
│                                                         │
│  完全披露 (Full Disclosure):                            │
│  ✓ 立即公开所有信息                                     │
│  ✓ 不等待厂商修复                                       │
│  ✓ 社区监督压力                                         │
│  ✓ 可能增加风险                                         │
│                                                         │
│  协调披露 (Coordinated Disclosure):                     │
│  ✓ 与厂商合作                                           │
│  ✓ 协商披露时间                                         │
│  ✓ 共同发布公告                                         │
│  ✓ 最佳实践                                             │
│                                                         │
└─────────────────────────────────────────────────────────┘
```

### 披露类型对比

**披露类型**：
```python
# 漏洞披露类型
class DisclosureTypes:
    """漏洞披露类型"""
    
    types = {
        'responsible': {
            'name': '负责任披露',
            'description': '先通知厂商，等待修复后再公开',
            'process': [
                '1. 私下通知厂商',
                '2. 等待 90 天修复期',
                '3. 厂商发布补丁',
                '4. 公开披露详情'
            ],
            'pros': [
                '给厂商修复时间',
                '减少用户风险',
                '建立良好关系'
            ],
            'cons': [
                '修复可能延迟',
                '厂商可能不配合',
                '披露时间较长'
            ],
            'recommended': True
        },
        
        'full': {
            'name': '完全披露',
            'description': '立即公开所有漏洞信息',
            'process': [
                '1. 发现漏洞',
                '2. 立即公开',
                '3. 提供 PoC',
                '4. 厂商被动响应'
            ],
            'pros': [
                '快速公开信息',
                '用户及时知晓',
                '厂商压力大'
            ],
            'cons': [
                '攻击者可能利用',
                '用户无防护时间',
                '厂商关系恶化'
            ],
            'recommended': False
        },
        
        'coordinated': {
            'name': '协调披露',
            'description': '与厂商协调披露时间和方式',
            'process': [
                '1. 通知厂商',
                '2. 协商时间表',
                '3. 厂商修复',
                '4. 联合公告'
            ],
            'pros': [
                '最佳合作方式',
                '用户风险最小',
                '修复质量高'
            ],
            'cons': [
                '需要厂商配合',
                '时间可能较长',
                '需要信任'
            ],
            'recommended': True
        },
        
        'partial': {
            'name': '部分披露',
            'description': '只公开部分信息，保留关键细节',
            'process': [
                '1. 通知厂商',
                '2. 公开基本信息',
                '3. 保留利用细节',
                '4. 修复后完全披露'
            ],
            'pros': [
                '平衡公开与风险',
                '用户知晓风险',
                '减少被利用可能'
            ],
            'cons': [
                '信息不完整',
                '用户难以评估',
                '可能引起猜测'
            ],
            'recommended': False
        }
    }
    
    def recommend_disclosure_type(self, context):
        """推荐披露类型"""
        factors = {
            'vendor_responsiveness': context.get('vendor_responsiveness', 'unknown'),
            'vulnerability_severity': context.get('severity', 'medium'),
            'exploit_available': context.get('exploit_available', False),
            'active_exploitation': context.get('active_exploitation', False),
            'user_impact': context.get('user_impact', 'medium')
        }
        
        # 如果有在野利用，建议加快披露
        if factors['active_exploitation']:
            return 'partial'  # 部分披露，提醒用户但不提供利用细节
        
        # 如果厂商配合，建议协调披露
        if factors['vendor_responsiveness'] == 'cooperative':
            return 'coordinated'
        
        # 默认建议负责任披露
        return 'responsible'
```

---

## 披露流程详解

### 标准披露流程

> ▎ 披露不是发邮件就行，是规范流程。流程不遵守，沟通就是无效的。

**披露步骤**：
```python
# 漏洞披露流程
class VulnerabilityDisclosureProcess:
    """漏洞披露流程"""
    
    # 流程阶段
    phases = {
        'discovery': {
            'name': '发现阶段',
            'description': '发现并验证漏洞',
            'activities': [
                '发现漏洞',
                '验证真实性',
                '记录详细信息',
                '评估影响'
            ],
            'outputs': ['漏洞报告', 'PoC 代码', '影响评估']
        },
        
        'vendor_notification': {
            'name': '厂商通知',
            'description': '通知漏洞厂商',
            'activities': [
                '查找联系方式',
                '编写通知邮件',
                '发送报告',
                '等待确认'
            ],
            'outputs': ['通知邮件', '厂商确认']
        },
        
        'remediation_period': {
            'name': '修复期',
            'description': '等待厂商修复',
            'activities': [
                '给予修复时间',
                '定期跟进',
                '提供技术支持',
                '验证修复方案'
            ],
            'outputs': ['跟进记录', '修复验证']
        },
        
        'public_disclosure': {
            'name': '公开披露',
            'description': '公开披露漏洞信息',
            'activities': [
                '编写披露报告',
                '选择披露渠道',
                '发布报告',
                '回应媒体询问'
            ],
            'outputs': ['披露报告', '媒体回应']
        },
        
        'post_disclosure': {
            'name': '披露后',
            'description': '披露后的跟进',
            'activities': [
                '监控利用情况',
                '协助用户修复',
                '更新报告',
                '总结经验'
            ],
            'outputs': ['后续报告', '经验总结']
        }
    }
    
    def execute_process(self, vulnerability_info):
        """执行披露流程"""
        results = {
            'vulnerability': vulnerability_info,
            'phases': {},
            'timeline': [],
            'status': 'in_progress'
        }
        
        # 发现阶段
        discovery = self.discovery_phase(vulnerability_info)
        results['phases']['discovery'] = discovery
        results['timeline'].append({
            'phase': 'discovery',
            'date': discovery['date'],
            'status': 'completed'
        })
        
        # 厂商通知
        notification = self.vendor_notification(vulnerability_info)
        results['phases']['vendor_notification'] = notification
        results['timeline'].append({
            'phase': 'vendor_notification',
            'date': notification['date'],
            'status': 'completed' if notification['acknowledged'] else 'pending'
        })
        
        # 修复期
        remediation = self.remediation_period(vulnerability_info, notification)
        results['phases']['remediation_period'] = remediation
        results['timeline'].append({
            'phase': 'remediation_period',
            'start_date': remediation['start_date'],
            'end_date': remediation['end_date'],
            'status': 'completed' if remediation['patched'] else 'ongoing'
        })
        
        # 公开披露
        disclosure = self.public_disclosure(results)
        results['phases']['public_disclosure'] = disclosure
        results['timeline'].append({
            'phase': 'public_disclosure',
            'date': disclosure['date'],
            'status': 'completed'
        })
        
        # 披露后
        post_disclosure = self.post_disclosure_phase(results)
        results['phases']['post_disclosure'] = post_disclosure
        
        results['status'] = 'completed'
        
        return results
    
    def discovery_phase(self, vuln_info):
        """发现阶段"""
        return {
            'date': vuln_info.get('discovery_date', 'unknown'),
            'cve_id': vuln_info.get('cve_id', None),
            'severity': vuln_info.get('severity', 'unknown'),
            'poc_available': vuln_info.get('poc_available', False),
            'report': self.create_vulnerability_report(vuln_info)
        }
    
    def vendor_notification(self, vuln_info):
        """厂商通知"""
        # 查找厂商联系方式
        contact = self.find_vendor_contact(vuln_info)
        
        # 编写通知邮件
        email = self.create_notification_email(vuln_info)
        
        # 发送邮件
        sent = self.send_notification(email, contact)
        
        # 等待确认
        acknowledged = self.wait_for_acknowledgment(contact, days=7)
        
        return {
            'date': sent['date'] if sent else None,
            'contact': contact,
            'email_sent': sent is not None,
            'acknowledged': acknowledged,
            'vendor_response': self.get_vendor_response()
        }
    
    def find_vendor_contact(self, vuln_info):
        """查找厂商联系方式"""
        # 优先顺序:
        # 1. security@ 域名邮箱
        # 2. 安全响应团队页面
        # 3. 漏洞赏金平台
        # 4. 通用联系方式
        
        contacts = []
        
        # 尝试 security@ 邮箱
        domain = vuln_info.get('vendor_domain', '')
        if domain:
            contacts.append(f"security@{domain}")
        
        # 查找安全页面
        security_page = self.find_security_page(domain)
        if security_page:
            contacts.extend(self.extract_contacts(security_page))
        
        # 查找漏洞赏金平台
        bounty_programs = self.find_bounty_programs(vuln_info.get('vendor_name', ''))
        if bounty_programs:
            contacts.extend(bounty_programs)
        
        return contacts[0] if contacts else None
    
    def create_notification_email(self, vuln_info):
        """创建通知邮件"""
        email = {
            'subject': f"Security Vulnerability Report - {vuln_info.get('title', 'Unknown')}",
            'to': [],
            'cc': [],
            'body': self.create_email_body(vuln_info),
            'attachments': [
                'vulnerability_report.pdf',
                'poc_code.py'  # 加密或仅提供摘要
            ]
        }
        
        return email
    
    def create_email_body(self, vuln_info):
        """创建邮件正文"""
        body = """
尊敬的 {vendor_name} 安全团队：

您好！

我是一名安全研究人员，在贵公司的 {product_name} 产品中发现了一个安全漏洞。
现将详细信息报告如下，希望能协助贵公司及时修复，保护用户安全。

【漏洞概要】
- 漏洞类型：{vulnerability_type}
- 严重程度：{severity}
- 影响版本：{affected_versions}
- CVE 编号：{cve_id}

【简要描述】
{brief_description}

【建议修复时间】
建议在 90 天内修复并发布补丁。

【披露政策】
我遵循负责任披露政策，在修复发布前不会公开漏洞详情。
如有任何问题，请随时联系我。

期待您的回复。

此致
敬礼

{researcher_name}
{contact_info}
{date}
""".format(
            vendor_name=vuln_info.get('vendor_name', ''),
            product_name=vuln_info.get('product_name', ''),
            vulnerability_type=vuln_info.get('type', ''),
            severity=vuln_info.get('severity', ''),
            affected_versions=vuln_info.get('affected_versions', ''),
            cve_id=vuln_info.get('cve_id', '待分配'),
            brief_description=vuln_info.get('description', '')[:200],
            researcher_name=vuln_info.get('researcher', '匿名'),
            contact_info=vuln_info.get('contact', ''),
            date=vuln_info.get('report_date', '')
        )
        
        return body
    
    def remediation_period(self, vuln_info, notification):
        """修复期"""
        start_date = notification['date']
        end_date = None
        patched = False
        
        # 标准修复期 90 天
        remediation_days = 90
        
        # 定期跟进
        follow_ups = []
        for day in [30, 60, 75, 85]:
            follow_ups.append({
                'day': day,
                'contacted': True,
                'response': self.get_follow_up_response(day)
            })
        
        # 检查是否修复
        if self.check_patch_available(vuln_info):
            patched = True
            end_date = self.get_patch_release_date(vuln_info)
        
        return {
            'start_date': start_date,
            'end_date': end_date,
            'remediation_days': remediation_days,
            'patched': patched,
            'follow_ups': follow_ups,
            'vendor_cooperation': self.assess_vendor_cooperation(follow_ups)
        }
    
    def public_disclosure(self, results):
        """公开披露"""
        # 检查是否可以披露
        can_disclose = self.can_public_disclose(results)
        
        if not can_disclose:
            return {
                'date': None,
                'status': 'delayed',
                'reason': 'Vendor requested more time'
            }
        
        # 编写披露报告
        report = self.create_disclosure_report(results)
        
        # 选择披露渠道
        channels = self.select_disclosure_channels(results)
        
        # 发布报告
        published = self.publish_report(report, channels)
        
        return {
            'date': published['date'],
            'channels': channels,
            'report': report,
            'status': 'published'
        }
    
    def can_public_disclose(self, results):
        """检查是否可以公开披露"""
        # 检查条件:
        # 1. 修复期已过 (90 天)
        # 2. 厂商已发布补丁
        # 3. 或厂商明确同意披露
        
        remediation = results['phases'].get('remediation_period', {})
        
        if remediation.get('patched'):
            return True
        
        days_elapsed = self.calculate_days_elapsed(remediation.get('start_date'))
        
        if days_elapsed >= 90:
            return True
        
        # 厂商同意提前披露
        if results['phases'].get('vendor_notification', {}).get('disclosure_approved'):
            return True
        
        return False
    
    def create_disclosure_report(self, results):
        """创建披露报告"""
        report = {
            'title': f"Vulnerability Disclosure: {results['vulnerability'].get('title', '')}",
            'cve_id': results['vulnerability'].get('cve_id', ''),
            'severity': results['vulnerability'].get('severity', ''),
            'description': results['vulnerability'].get('description', ''),
            'affected_products': results['vulnerability'].get('affected_products', []),
            'fixed_versions': results['phases']['remediation_period'].get('fixed_versions', []),
            'timeline': results['timeline'],
            'credits': results['vulnerability'].get('researcher', ''),
            'references': results['vulnerability'].get('references', [])
        }
        
        return report
    
    def post_disclosure_phase(self, results):
        """披露后阶段"""
        return {
            'media_coverage': self.monitor_media_coverage(results),
            'exploit_monitoring': self.monitor_exploit_activity(results),
            'user_assistance': self.assist_users(results),
            'lessons_learned': self.document_lessons_learned(results)
        }
    
    def calculate_days_elapsed(self, start_date):
        """计算经过天数"""
        from datetime import datetime
        
        if not start_date:
            return 0
        
        start = datetime.strptime(start_date, '%Y-%m-%d')
        elapsed = (datetime.now() - start).days
        
        return elapsed
```

---

## 厂商沟通技巧

### 沟通最佳实践

> ▎ 沟通不是发邮件，是建立信任。信任不建立，合作就是困难的。

**沟通技巧**：
```python
# 厂商沟通技巧
class VendorCommunication:
    """厂商沟通技巧"""
    
    # 沟通原则
    principles = [
        '专业礼貌',
        '清晰简洁',
        '提供足够信息',
        '给予合理时间',
        '保持耐心',
        '记录所有沟通'
    ]
    
    def create_initial_contact(self, vuln_info):
        """创建初次联系"""
        email = {
            'subject': 'Security Vulnerability Report - [Product Name]',
            'tone': 'professional',
            'content_length': 'concise',
            'attachments': ['detailed_report.pdf'],
            'expected_response_time': '7 days'
        }
        
        return email
    
    def handle_no_response(self, days_elapsed):
        """处理无响应"""
        if days_elapsed < 7:
            return 'wait'
        elif days_elapsed < 14:
            return 'follow_up_1'
        elif days_elapsed < 30:
            return 'follow_up_2'
        elif days_elapsed < 60:
            return 'escalate'
        else:
            return 'consider_public_disclosure'
    
    def create_follow_up_email(self, previous_contact, days_elapsed):
        """创建跟进邮件"""
        if days_elapsed < 14:
            tone = 'polite_inquiry'
        elif days_elapsed < 30:
            tone = 'firm_reminder'
        else:
            tone = 'urgent_notice'
        
        email = {
            'subject': f'Follow-up: Security Vulnerability Report (Day {days_elapsed})',
            'tone': tone,
            'reference_previous': previous_contact,
            'mention_timeline': True,
            'mention_disclosure_policy': days_elapsed >= 60
        }
        
        return email
    
    def handle_vendor_pushback(self, vendor_response):
        """处理厂商异议"""
        # 常见异议:
        # 1. "不是安全漏洞"
        # 2. "需要更多时间"
        # 3. "不要公开"
        # 4. "我们不接受外部报告"
        
        responses = {
            'not_a_vulnerability': self.handle_not_vulnerability_claim,
            'need_more_time': self.handle_time_extension_request,
            'dont_disclose': self.handle_non_disclosure_request,
            'dont_accept_reports': self.handle_no_bug_bounty
        }
        
        claim_type = vendor_response.get('claim_type', '')
        
        if claim_type in responses:
            return responses[claim_type](vendor_response)
        
        return {'action': 'negotiate'}
    
    def handle_not_vulnerability_claim(self, vendor_response):
        """处理"不是漏洞"声明"""
        # 提供技术证据
        # 引用行业标准
        # 建议第三方评估
        
        return {
            'action': 'provide_evidence',
            'evidence': ['technical_analysis', 'industry_standards', 'similar_cves'],
            'suggest_third_party': True
        }
    
    def handle_time_extension_request(self, vendor_response):
        """处理延期请求"""
        requested_extension = vendor_response.get('requested_days', 0)
        
        # 标准延期: 30 天
        # 复杂漏洞：可更长
        # 需要明确时间表
        
        if requested_extension <= 30:
            return {'action': 'approve', 'extension_days': requested_extension}
        elif requested_extension <= 60:
            return {
                'action': 'negotiate',
                'counter_offer': 30,
                'require_milestone': True
            }
        else:
            return {
                'action': 'escalate',
                'reason': 'Extension too long',
                'consider_disclosure': True
            }
    
    def handle_non_disclosure_request(self, vendor_response):
        """处理不披露请求"""
        # 评估请求合理性
        # 考虑用户安全
        # 协商披露时间
        
        return {
            'action': 'negotiate',
            'minimum_disclosure': 'basic_info',
            'maximum_delay': '120_days',
            'require_patch_date': True
        }
    
    def handle_no_bug_bounty(self, vendor_response):
        """处理无漏洞赏金"""
        # 赏金不是必须的
        # 重点是修复漏洞
        # 可以要求致谢
        
        return {
            'action': 'proceed_without_bounty',
            'request_credit': True,
            'request_cve': True
        }
```

### 沟通模板

**邮件模板**：
```
初次联系模板:

Subject: Security Vulnerability Report - [产品名称]

尊敬的 [厂商名称] 安全团队：

您好！

我是一名安全研究人员，在贵公司的 [产品名称] [版本号] 中发现了一个安全漏洞。

【漏洞概要】
- 漏洞类型：[类型]
- 严重程度：[严重/高/中/低]
- 影响版本：[版本范围]
- CVE 编号：[如有]

【简要描述】
[1-2 句描述漏洞]

完整的漏洞报告和 PoC 代码请见附件。

【建议修复时间】
建议在 90 天内修复并发布补丁。

【披露政策】
我遵循负责任披露政策，在修复发布前不会公开漏洞详情。
如有任何问题，请随时联系我。

期待您的回复。

此致
敬礼

[您的姓名]
[联系方式]
[日期]

跟进邮件模板:

Subject: Follow-up: Security Vulnerability Report (Day [天数])

尊敬的 [厂商名称] 安全团队：

您好！

我于 [日期] 向贵公司报告了一个安全漏洞（主题：[原邮件主题]）。

截至今日已过去 [天数] 天，我尚未收到确认回复。

为确保用户安全，希望能尽快得到您的确认和修复时间表。

根据我的披露政策，如果在 90 天内未发布修复，我将考虑公开披露漏洞信息。
希望能与贵公司合作，在披露前完成修复。

期待您的回复。

此致
敬礼

[您的姓名]
[联系方式]
[日期]
```

---

## 披露平台使用

### 漏洞赏金平台

> ▎ 平台不是随便用，是选对用。平台选不对，披露就是低效的。

**主要平台**：
```
漏洞赏金平台:

1. HackerOne
   ├── 最大平台
   ├── 众多厂商
   └── 规范流程

2. Bugcrowd
   ├── 第二大平台
   ├── 多种计划
   └── 快速响应

3. Synack
   ├── 精英研究员
   ├── 高报酬
   └── 严格筛选

4. 厂商自有平台
   ├── Google VRP
   ├── Microsoft MSRC
   └── Apple Security
```

**平台使用指南**：
```python
# 漏洞赏金平台使用
class BugBountyPlatform:
    """漏洞赏金平台使用"""
    
    platforms = {
        'hackerone': {
            'url': 'https://hackerone.com',
            'programs': 2000+,
            'average_bounty': '$500-$5000',
            'features': [
                '标准化报告',
                '协调披露',
                '声誉系统',
                '支付保障'
            ]
        },
        'bugcrowd': {
            'url': 'https://bugcrowd.com',
            'programs': 1000+,
            'average_bounty': '$500-$3000',
            'features': [
                '快速响应',
                '多种计划类型',
                '优先级系统',
                '研究员工具'
            ]
        }
    }
    
    def submit_report(self, platform, vuln_info):
        """提交漏洞报告"""
        report = {
            'title': vuln_info.get('title', ''),
            'summary': vuln_info.get('summary', ''),
            'description': vuln_info.get('description', ''),
            'steps_to_reproduce': vuln_info.get('reproduction_steps', []),
            'impact': vuln_info.get('impact', ''),
            'remediation': vuln_info.get('remediation', ''),
            'attachments': [
                'screenshots',
                'poc_code',
                'video_demo'
            ],
            'cvss_score': vuln_info.get('cvss_score', 0),
            'cwe_id': vuln_info.get('cwe_id', '')
        }
        
        # 提交到平台
        submission = self.platform_submit(platform, report)
        
        return submission
    
    def track_report_status(self, platform, report_id):
        """跟踪报告状态"""
        status = self.platform_get_status(platform, report_id)
        
        status_meanings = {
            'new': '已提交，等待审核',
            'triage': '正在分类',
            'accepted': '已接受',
            'rejected': '已拒绝',
            'duplicate': '重复报告',
            'informative': '信息性报告',
            'resolved': '已修复',
            'rewarded': '已发放赏金'
        }
        
        return {
            'status': status,
            'meaning': status_meanings.get(status, 'unknown'),
            'last_updated': self.get_last_update(platform, report_id)
        }
```

---

## 法律风险规避

### 法律注意事项

> ▎ 披露不是无风险，是有法律风险。风险不规避，后果就是严重的。

**法律风险**：
```
法律风险类型:

1. 未经授权访问
   ├── 可能违反计算机犯罪法
   ├── 即使善意也可能违法
   └── 需要明确授权

2. 数据隐私
   ├── 不得泄露用户数据
   ├── 不得收集敏感信息
   └── 遵守 GDPR 等法规

3. 知识产权
   ├── 不得侵犯版权
   ├── 不得泄露商业秘密
   └── 合理使用原则

4. 诽谤风险
   ├── 准确描述漏洞
   ├── 不夸大影响
   └── 基于事实
```

**风险规避指南**：
```python
# 法律风险规避
class LegalRiskMitigation:
    """法律风险规避"""
    
    guidelines = [
        '仅在授权环境测试',
        '不访问真实用户数据',
        '不造成服务中断',
        '不公开敏感信息',
        '遵循负责任披露',
        '保留所有沟通记录',
        '咨询法律意见'
    ]
    
    def assess_legal_risk(self, disclosure_plan):
        """评估法律风险"""
        risk_factors = {
            'unauthorized_access': disclosure_plan.get('unauthorized_testing', False),
            'data_access': disclosure_plan.get('accessed_user_data', False),
            'service_disruption': disclosure_plan.get('caused_disruption', False),
            'sensitive_disclosure': disclosure_plan.get('disclosing_sensitive_info', False),
            'vendor_cooperation': disclosure_plan.get('vendor_cooperative', False)
        }
        
        risk_level = 'low'
        
        if risk_factors['unauthorized_access']:
            risk_level = 'high'
        
        if risk_factors['data_access']:
            risk_level = 'high'
        
        if risk_factors['service_disruption']:
            risk_level = 'high'
        
        if not risk_factors['vendor_cooperation']:
            if risk_level == 'low':
                risk_level = 'medium'
        
        return {
            'risk_level': risk_level,
            'factors': risk_factors,
            'recommendations': self.get_recommendations(risk_factors)
        }
    
    def get_recommendations(self, risk_factors):
        """获取建议"""
        recommendations = []
        
        if risk_factors['unauthorized_access']:
            recommendations.append('仅在授权环境测试')
        
        if risk_factors['data_access']:
            recommendations.append('删除所有用户数据')
        
        if risk_factors['service_disruption']:
            recommendations.append('避免造成服务中断')
        
        if not risk_factors['vendor_cooperation']:
            recommendations.append('寻求法律意见')
        
        return recommendations
```

---

## 披露报告编写

### 报告结构

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

**报告模板**：
```markdown
# 漏洞披露报告

## 概要

- **CVE 编号**: CVE-XXXX-XXXX
- **漏洞类型**: [类型]
- **严重程度**: [CVSS 分数]
- **披露日期**: YYYY-MM-DD

## 漏洞描述

[详细描述漏洞]

## 影响产品

- 厂商：[厂商名称]
- 产品：[产品名称]
- 受影响版本：[版本范围]
- 修复版本：[修复版本]

## 技术细节

### 漏洞原理

[技术原理说明]

### 复现步骤

1. [步骤 1]
2. [步骤 2]
3. [步骤 3]

### PoC 代码

```python
# PoC 代码示例
```

## 时间线

| 日期 | 事件 |
|------|------|
| YYYY-MM-DD | 漏洞发现 |
| YYYY-MM-DD | 通知厂商 |
| YYYY-MM-DD | 厂商确认 |
| YYYY-MM-DD | 补丁发布 |
| YYYY-MM-DD | 公开披露 |

## 修复建议

1. [建议 1]
2. [建议 2]
3. [建议 3]

## 致谢

感谢 [厂商名称] 安全团队的快速响应和修复。

## 参考链接

- [厂商公告]
- [CVE 详情]
- [相关资源]

## 联系方式

[研究员联系方式]
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ██████████ 5/5 │ 生产就绪       │
└───────────────┴────────────────┴────────────────┘
综合：4.5
```
▎ 这才配得上 P8。漏洞披露不是随意发，是规范流程。流程不规范，后果就是严重的。

---

## 总结与思考

### 核心要点回顾

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

**漏洞披露框架**：
```
1. 披露类型
   - 负责任披露
   - 协调披露
   - 完全披露

2. 披露流程
   - 发现验证
   - 厂商通知
   - 修复期
   - 公开披露

3. 厂商沟通
   - 专业礼貌
   - 清晰简洁
   - 记录沟通

4. 法律风险
   - 授权测试
   - 隐私保护
   - 合规披露
```

**关键成功因素**：
```
1. 负责任
   - 保护用户
   - 协助修复
   - 适当披露

2. 专业
   - 技术准确
   - 沟通专业
   - 报告规范

3. 合法
   - 遵守法律
   - 规避风险
   - 咨询意见
```

---

## 参考资料

### 披露平台
```
- HackerOne
  https://hackerone.com/

- Bugcrowd
  https://bugcrowd.com/

- Synack
  https://www.synack.com/
```

### 厂商安全页面
```
- Google VRP
  https://www.google.com/about/appsecurity/

- Microsoft MSRC
  https://www.microsoft.com/en-us/msrc

- Apple Security
  https://www.apple.com/support/security/
```

### 披露标准
```
- ISO/IEC 29147 (Vulnerability Disclosure)
  https://www.iso.org/standard/63468.html

- CERT/CC Disclosure Policy
  https://www.sei.cmu.edu/about/divisions/cert/

- NCSC Vulnerability Disclosure
  https://www.ncsc.gov.uk/
```

### 书籍推荐
```
- 《Responsible Vulnerability Disclosure》
- 《Bug Bounty Hunting》
- 《The Vulnerability Researcher's Handbook》
```

---

**标记 明日预告**：Day 164 - CVE 申请与管理

> ▎ 漏洞披露是沟通流程，CVE 管理是编号系统——明天看 CVE 申请与管理。

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

---

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

*漏洞与攻防系列 (Day 156-165) 继续！*