Day-127-SDL 安全开发生命周期

# Day 141: SDL 安全开发生命周期

> 应用安全系列第 34 天 | 预计阅读时间：50 分钟 | 难度：★★★★☆

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ SDL 安全开发生命周期 - Day 141     │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ SDL 不是上线前检查，是全流程嵌入。流程不嵌入，安全就是事后补救。今天系统学习 SDL。

---

## 清单 目录

1. [SDL 概述](#sdl 概述)
2. [SDL 核心原则](#sdl 核心原则)
3. [需求阶段安全](#需求阶段安全)
4. [设计阶段安全](#设计阶段安全)
5. [开发阶段安全](#开发阶段安全)
6. [测试阶段安全](#测试阶段安全)
7. [发布阶段安全](#发布阶段安全)
8. [运营阶段安全](#运营阶段安全)
9. [SDL 实施指南](#sdl 实施指南)
10. [实战案例分析](#实战案例分析)
11. [总结与思考](#总结与思考)
12. [参考资料](#参考资料)

---

## SDL 概述

### 什么是 SDL

> ▎ SDL 不是增加流程，是减少返工。现在不花时间，将来就要花更多时间。

**定义与目标**：
```
SDL (Security Development Lifecycle，安全开发生命周期) 是将安全考虑和活动集成到软件开发每个阶段的方法论。

核心目标：
1. 减少漏洞
   - 早期发现安全问题
   - 降低修复成本
   - 提高代码质量

2. 降低风险
   - 识别安全威胁
   - 实施防护措施
   - 建立应急响应

3. 满足合规
   - 法规要求
   - 行业标准
   - 客户期望
```

**SDL 演进**：
```
Microsoft SDL (2004):
- 首个系统性 SDL
- 7 个阶段
- 强制要求

OWASP SAMM (2009):
- 软件保障成熟度模型
- 5 个业务功能
- 成熟度级别

BSIMM (2008):
- 软件安全构建度量模型
- 基于实际数据
- 12 个实践领域

DevSecOps (2016):
- 安全左移
- 自动化集成
- 持续安全
```

### SDL 业务价值

**成本效益分析**：
```
漏洞修复成本对比 (NIST 数据):

阶段          修复成本    相对成本
─────────────────────────────────
需求阶段      $1         1x
设计阶段      $5         5x
编码阶段      $10        10x
测试阶段      $20        20x
生产环境      $200+      200x+

SDL 投资回报：
- 每投入 1 美元 SDL，节省 10 美元修复成本
- 漏洞数量减少 50-70%
- 安全事件减少 40-60%
- 上市时间缩短 20-30%
```

**合规价值**：
```
SDL 帮助满足的合规要求：
1. GDPR (数据保护)
   - 隐私设计 (Privacy by Design)
   - 默认隐私 (Privacy by Default)
   - 数据保护影响评估

2. PCI DSS (支付安全)
   - 安全开发实践
   - 代码审查
   - 渗透测试

3. SOC 2 (安全控制)
   - 安全开发生命周期
   - 变更管理
   - 漏洞管理

4. 等保 2.0 (中国)
   - 安全设计
   - 安全测试
   - 安全运维
```

---

## SDL 核心原则

### 七大原则

> ▎ 原则不是口号，是决策依据。依据不明确，决策就是随意的。

**原则一：安全设计**：
```
要求：
1. 安全是设计的一部分
   - 不是事后添加
   - 与功能同等重要
   - 架构层面考虑

2. 威胁建模
   - 识别威胁
   - 评估风险
   - 设计对策

3. 安全架构
   - 纵深防御
   - 最小权限
   - 故障安全
```

**原则二：安全编码**：
```
要求：
1. 遵循安全编码规范
   - 输入验证
   - 输出编码
   - 错误处理

2. 使用安全库
   - 不重复造轮子
   - 使用成熟方案
   - 定期更新

3. 代码审查
   - 同行审查
   - 安全审查
   - 自动化扫描
```

**原则三：安全测试**：
```
要求：
1. 安全功能测试
   - 认证授权测试
   - 加密功能测试
   - 日志审计测试

2. 安全漏洞测试
   - 渗透测试
   - 模糊测试
   - 漏洞扫描

3. 回归测试
   - 修复验证
   - 变更影响
   - 持续测试
```

**原则四：安全发布**：
```
要求：
1. 发布前检查
   - 漏洞扫描
   - 配置审查
   - 文档审查

2. 安全基线
   - 安全配置
   - 补丁级别
   - 依赖版本

3. 发布审批
   - 安全审批
   - 风险接受
   - 发布记录
```

**原则五：安全运营**：
```
要求：
1. 安全监控
   - 日志监控
   - 异常检测
   - 威胁检测

2. 漏洞管理
   - 漏洞接收
   - 漏洞修复
   - 漏洞披露

3. 应急响应
   - 响应流程
   - 恢复计划
   - 事后分析
```

**原则六：安全培训**：
```
要求：
1. 角色培训
   - 开发人员培训
   - 测试人员培训
   - 运维人员培训

2. 持续教育
   - 定期培训
   - 知识更新
   - 技能提升

3. 意识提升
   - 安全文化
   - 最佳实践
   - 案例分享
```

**原则七：安全度量**：
```
要求：
1. 过程度量
   - 培训覆盖率
   - 审查覆盖率
   - 测试覆盖率

2. 结果度量
   - 漏洞密度
   - 修复时间
   - 事件数量

3. 改进度量
   - 趋势分析
   - 目标对比
   - 持续改进
```

---

## 需求阶段安全

### 安全需求分析

> ▎ 需求不是功能列表，是安全边界。边界不定义，范围就是模糊的。

**安全需求分类**：
```
1. 功能安全需求
   - 认证需求
   - 授权需求
   - 审计需求
   - 加密需求

2. 数据安全需求
   - 数据分类
   - 数据保护
   - 数据保留
   - 数据销毁

3. 合规安全需求
   - 法规要求
   - 标准要求
   - 合同要求

4. 运营安全需求
   - 监控需求
   - 响应需求
   - 恢复需求
```

**安全需求模板**：
```python
# 安全需求规格说明
class SecurityRequirement:
    def __init__(self):
        self.requirements = []
    
    def add_requirement(self, req):
        """添加安全需求"""
        self.requirements.append({
            'id': req['id'],              # 需求 ID
            'category': req['category'],   # 需求类别
            'description': req['description'],  # 需求描述
            'priority': req['priority'],   # 优先级 (P0/P1/P2)
            'source': req['source'],       # 需求来源
            'acceptance_criteria': req['acceptance_criteria'],  # 验收标准
            'test_method': req['test_method'],  # 测试方法
            'compliance': req.get('compliance', []),  # 相关合规
            'status': 'draft'              # 状态
        })
    
    def validate_requirement(self, req):
        """验证需求质量"""
        issues = []
        
        # 检查完整性
        required_fields = ['id', 'category', 'description', 'priority', 
                          'acceptance_criteria', 'test_method']
        for field in required_fields:
            if field not in req or not req[field]:
                issues.append(f"Missing required field: {field}")
        
        # 检查可测试性
        if 'test_method' in req:
            if req['test_method'] not in ['manual', 'automated', 'both']:
                issues.append("Test method must be manual, automated, or both")
        
        # 检查优先级
        if 'priority' in req:
            if req['priority'] not in ['P0', 'P1', 'P2', 'P3']:
                issues.append("Priority must be P0, P1, P2, or P3")
        
        return len(issues) == 0, issues

# 安全需求示例
security_requirements = {
    'authentication': [
        {
            'id': 'AUTH-001',
            'category': '认证',
            'description': '系统必须支持多因素认证 (MFA)',
            'priority': 'P0',
            'source': '安全策略',
            'acceptance_criteria': [
                '用户可配置 TOTP 认证',
                '用户可配置短信认证',
                '管理员可强制要求 MFA'
            ],
            'test_method': 'automated',
            'compliance': ['等保 2.0', 'PCI DSS']
        },
        {
            'id': 'AUTH-002',
            'category': '认证',
            'description': '系统必须实施密码复杂度策略',
            'priority': 'P0',
            'source': '安全策略',
            'acceptance_criteria': [
                '密码最小长度 12 位',
                '必须包含大小写字母、数字、特殊字符',
                '密码历史记录 10 次'
            ],
            'test_method': 'automated',
            'compliance': ['等保 2.0']
        }
    ],
    'authorization': [
        {
            'id': 'AUTHZ-001',
            'category': '授权',
            'description': '系统必须实施基于角色的访问控制 (RBAC)',
            'priority': 'P0',
            'source': '架构设计',
            'acceptance_criteria': [
                '支持自定义角色',
                '支持角色继承',
                '支持细粒度权限'
            ],
            'test_method': 'both',
            'compliance': ['等保 2.0']
        }
    ],
    'audit': [
        {
            'id': 'AUDIT-001',
            'category': '审计',
            'description': '系统必须记录所有安全相关事件',
            'priority': 'P0',
            'source': '安全策略',
            'acceptance_criteria': [
                '记录登录/登出事件',
                '记录权限变更事件',
                '记录数据访问事件',
                '日志保留 180 天'
            ],
            'test_method': 'both',
            'compliance': ['等保 2.0', 'GDPR']
        }
    ]
}
```

### 隐私需求分析

**隐私影响评估**：
```python
# 隐私影响评估 (PIA)
class PrivacyImpactAssessment:
    def __init__(self):
        self.assessment = {}
    
    def conduct_pia(self, project_info):
        """执行隐私影响评估"""
        self.assessment = {
            'project': project_info,
            'data_collection': self.assess_data_collection(),
            'data_usage': self.assess_data_usage(),
            'data_sharing': self.assess_data_sharing(),
            'data_retention': self.assess_data_retention(),
            'user_rights': self.assess_user_rights(),
            'risks': self.identify_privacy_risks(),
            'mitigations': self.propose_mitigations()
        }
        
        return self.assessment
    
    def assess_data_collection(self):
        """评估数据收集"""
        return {
            'data_types': [],        # 收集的数据类型
            'purpose': '',           # 收集目的
            'consent': '',           # 同意机制
            'minimization': False    # 是否最小化
        }
    
    def assess_data_usage(self):
        """评估数据使用"""
        return {
            'usage_purposes': [],    # 使用目的
            'compatibility': False,  # 是否与收集目的兼容
            'automated_decision': False  # 是否有自动化决策
        }
    
    def assess_data_sharing(self):
        """评估数据共享"""
        return {
            'third_parties': [],     # 第三方列表
            'purpose': '',           # 共享目的
            'safeguards': [],        # 保护措施
            'cross_border': False    # 是否跨境
        }
    
    def assess_data_retention(self):
        """评估数据保留"""
        return {
            'retention_period': '',  # 保留期限
            'deletion_procedure': '', # 删除流程
            'archive_policy': ''     # 归档策略
        }
    
    def assess_user_rights(self):
        """评估用户权利"""
        return {
            'access': False,         # 访问权
            'rectification': False,  # 更正权
            'erasure': False,        # 删除权
            'portability': False,    # 可携带权
            'objection': False       # 反对权
        }
    
    def identify_privacy_risks(self):
        """识别隐私风险"""
        risks = []
        
        # 数据泄露风险
        risks.append({
            'risk': '数据泄露',
            'likelihood': '中',
            'impact': '高',
            'description': '个人数据可能被未授权访问'
        })
        
        # 过度收集风险
        risks.append({
            'risk': '过度收集',
            'likelihood': '中',
            'impact': '中',
            'description': '收集超出必要的个人数据'
        })
        
        # 目的变更风险
        risks.append({
            'risk': '目的变更',
            'likelihood': '低',
            'impact': '高',
            'description': '数据用于未告知的目的'
        })
        
        return risks
    
    def propose_mitigations(self):
        """提出缓解措施"""
        return [
            {
                'risk': '数据泄露',
                'mitigation': '实施加密和访问控制',
                'owner': '安全团队',
                'deadline': '上线前'
            },
            {
                'risk': '过度收集',
                'mitigation': '执行数据最小化审查',
                'owner': '产品团队',
                'deadline': '设计阶段'
            },
            {
                'risk': '目的变更',
                'mitigation': '建立数据使用审批流程',
                'owner': '合规团队',
                'deadline': '运营阶段'
            }
        ]
```

---

## 设计阶段安全

### 威胁建模

> ▎ 威胁建模不是猜攻击，是系统分析。分析不系统，防护就是零散的。

**威胁建模方法**：
```
STRIDE 威胁建模 (Microsoft):

S - Spoofing (欺骗)
├── 威胁：攻击者冒充合法用户/系统
├── 示例：凭证窃取、会话劫持
└── 对策：强认证、双向认证

T - Tampering (篡改)
├── 威胁：攻击者篡改数据或代码
├── 示例：数据篡改、代码注入
└── 对策：完整性检查、数字签名

R - Repudiation (抵赖)
├── 威胁：用户否认已执行的操作
├── 示例：否认交易、否认访问
└── 对策：审计日志、数字签名

I - Information Disclosure (信息泄露)
├── 威胁：敏感信息被未授权访问
├── 示例：数据泄露、配置泄露
└── 对策：加密、访问控制

D - Denial of Service (拒绝服务)
├── 威胁：服务不可用
├── 示例：DDoS 攻击、资源耗尽
└── 对策：限流、冗余、弹性

E - Elevation of Privilege (权限提升)
├── 威胁：获取未授权的权限
├── 示例：越权访问、提权攻击
└── 对策：最小权限、访问控制
```

**威胁建模流程**：
```python
# 威胁建模实现
class ThreatModeling:
    def __init__(self):
        self.stride_categories = {
            'spoofing': [],
            'tampering': [],
            'repudiation': [],
            'information_disclosure': [],
            'denial_of_service': [],
            'elevation_of_privilege': []
        }
        self.mitigations = []
    
    def model_threats(self, system_design):
        """执行威胁建模"""
        # 1. 分解系统
        components = self.decompose_system(system_design)
        
        # 2. 识别信任边界
        trust_boundaries = self.identify_trust_boundaries(components)
        
        # 3. 创建数据流图
        dfd = self.create_data_flow_diagram(components, trust_boundaries)
        
        # 4. STRIDE 分析
        for component in components:
            self.analyze_stride(component, dfd)
        
        # 5. 风险评估
        threats = self.assess_risk()
        
        # 6. 制定对策
        self.develop_mitigations(threats)
        
        return {
            'components': components,
            'trust_boundaries': trust_boundaries,
            'dfd': dfd,
            'threats': threats,
            'mitigations': self.mitigations
        }
    
    def decompose_system(self, system_design):
        """分解系统"""
        components = []
        
        # 识别外部实体
        for entity in system_design.get('external_entities', []):
            components.append({
                'type': 'external_entity',
                'name': entity['name'],
                'trust_level': 'untrusted'
            })
        
        # 识别进程
        for process in system_design.get('processes', []):
            components.append({
                'type': 'process',
                'name': process['name'],
                'trust_level': 'partial'
            })
        
        # 识别数据存储
        for store in system_design.get('data_stores', []):
            components.append({
                'type': 'data_store',
                'name': store['name'],
                'trust_level': 'partial',
                'data_classification': store.get('classification', 'internal')
            })
        
        return components
    
    def analyze_stride(self, component, dfd):
        """STRIDE 分析"""
        comp_type = component['type']
        
        # 外部实体的威胁
        if comp_type == 'external_entity':
            self.analyze_external_entity_threats(component)
        
        # 进程的威胁
        elif comp_type == 'process':
            self.analyze_process_threats(component, dfd)
        
        # 数据存储的威胁
        elif comp_type == 'data_store':
            self.analyze_data_store_threats(component)
    
    def analyze_external_entity_threats(self, entity):
        """分析外部实体威胁"""
        # 欺骗
        self.stride_categories['spoofing'].append({
            'component': entity['name'],
            'threat': '攻击者可能冒充合法外部实体',
            'risk_level': '高'
        })
    
    def analyze_process_threats(self, process, dfd):
        """分析进程威胁"""
        # 篡改
        self.stride_categories['tampering'].append({
            'component': process['name'],
            'threat': '输入数据可能被篡改',
            'risk_level': '高'
        })
        
        # 抵赖
        self.stride_categories['repudiation'].append({
            'component': process['name'],
            'threat': '操作可能被否认',
            'risk_level': '中'
        })
    
    def analyze_data_store_threats(self, store):
        """分析数据存储威胁"""
        # 信息泄露
        self.stride_categories['information_disclosure'].append({
            'component': store['name'],
            'threat': '存储数据可能被未授权访问',
            'risk_level': '高' if store['data_classification'] == 'sensitive' else '中'
        })
        
        # 篡改
        self.stride_categories['tampering'].append({
            'component': store['name'],
            'threat': '存储数据可能被篡改',
            'risk_level': '高'
        })
    
    def assess_risk(self):
        """风险评估"""
        threats = []
        
        for category, category_threats in self.stride_categories.items():
            for threat in category_threats:
                # 计算风险等级
                risk_score = self.calculate_risk_score(threat)
                threat['risk_score'] = risk_score
                threat['priority'] = self.get_priority(risk_score)
                threats.append(threat)
        
        # 按风险排序
        threats.sort(key=lambda x: x['risk_score'], reverse=True)
        
        return threats
    
    def calculate_risk_score(self, threat):
        """计算风险分数"""
        # 简化版：可能性 × 影响
        likelihood = {'高': 3, '中': 2, '低': 1}[threat.get('risk_level', '中')]
        impact = {'高': 3, '中': 2, '低': 1}[threat.get('risk_level', '中')]
        return likelihood * impact
    
    def get_priority(self, risk_score):
        """获取优先级"""
        if risk_score >= 6:
            return 'P0'
        elif risk_score >= 4:
            return 'P1'
        else:
            return 'P2'
    
    def develop_mitigations(self, threats):
        """制定缓解措施"""
        for threat in threats:
            if threat['priority'] in ['P0', 'P1']:
                mitigation = self.get_mitigation_for_threat(threat)
                self.mitigations.append({
                    'threat': threat['threat'],
                    'mitigation': mitigation,
                    'status': 'planned'
                })
    
    def get_mitigation_for_threat(self, threat):
        """获取威胁对策"""
        # 根据威胁类型返回对策
        if '冒充' in threat['threat']:
            return '实施强认证机制'
        elif '篡改' in threat['threat']:
            return '实施完整性验证'
        elif '泄露' in threat['threat']:
            return '实施加密和访问控制'
        elif '否认' in threat['threat']:
            return '实施审计日志'
        else:
            return '需要进一步分析'
```

### 安全架构设计

**安全架构原则**：
```python
# 安全架构设计
class SecureArchitecture:
    def __init__(self):
        self.principles = [
            'defense_in_depth',      # 纵深防御
            'least_privilege',       # 最小权限
            'secure_by_default',     # 安全默认
            'fail_secure',           # 故障安全
            'complete_mediation',    # 完全验证
            'open_design',           # 开放设计
            'separation_of_duties',  # 职责分离
            'psychological_acceptability'  # 心理可接受
        ]
    
    def design_security_architecture(self, requirements):
        """设计安全架构"""
        architecture = {
            'layers': self.design_layers(),
            'controls': self.design_controls(requirements),
            'trust_boundaries': self.define_trust_boundaries(),
            'data_flow': self.design_secure_data_flow()
        }
        
        return architecture
    
    def design_layers(self):
        """设计安全分层"""
        return {
            'network_layer': {
                'controls': [
                    '防火墙',
                    '入侵检测/防御',
                    '网络分段',
                    'DDoS 防护'
                ]
            },
            'application_layer': {
                'controls': [
                    'WAF',
                    'API 网关',
                    '认证授权',
                    '输入验证'
                ]
            },
            'data_layer': {
                'controls': [
                    '加密存储',
                    '访问控制',
                    '数据脱敏',
                    '备份恢复'
                ]
            },
            'host_layer': {
                'controls': [
                    '主机加固',
                    '端点保护',
                    '补丁管理',
                    '配置管理'
                ]
            }
        }
    
    def design_controls(self, requirements):
        """设计安全控制"""
        controls = []
        
        # 根据需求设计控制
        for req in requirements:
            if req['category'] == '认证':
                controls.append({
                    'type': 'authentication',
                    'implementation': 'OAuth 2.0 + MFA',
                    'requirement': req['id']
                })
            
            elif req['category'] == '授权':
                controls.append({
                    'type': 'authorization',
                    'implementation': 'RBAC + ABAC',
                    'requirement': req['id']
                })
            
            elif req['category'] == '审计':
                controls.append({
                    'type': 'audit',
                    'implementation': '集中日志 + SIEM',
                    'requirement': req['id']
                })
        
        return controls
    
    def define_trust_boundaries(self):
        """定义信任边界"""
        return [
            {
                'name': '互联网边界',
                'description': '外部网络与 DMZ 之间',
                'controls': ['防火墙', 'WAF', 'IDS/IPS']
            },
            {
                'name': 'DMZ 边界',
                'description': 'DMZ 与内网之间',
                'controls': ['防火墙', '跳板机']
            },
            {
                'name': '应用边界',
                'description': '用户与应用之间',
                'controls': ['认证', '授权', '输入验证']
            },
            {
                'name': '数据边界',
                'description': '应用与数据之间',
                'controls': ['加密', '访问控制', '审计']
            }
        ]
    
    def design_secure_data_flow(self):
        """设计安全数据流"""
        return {
            'ingress': {
                'path': '用户 → WAF → API 网关 → 应用',
                'controls': ['输入验证', '速率限制', '认证']
            },
            'egress': {
                'path': '应用 → 数据过滤 → 用户',
                'controls': ['输出编码', '数据脱敏']
            },
            'internal': {
                'path': '应用 → 服务网格 → 后端服务',
                'controls': ['mTLS', '服务认证']
            },
            'storage': {
                'path': '应用 → 加密层 → 存储',
                'controls': ['加密', '访问控制']
            }
        }
```

---

## 开发阶段安全

### 安全编码实践

> ▎ 编码不是实现功能，是实现安全功能。功能不安全，实现就是白搭。

**安全编码标准**：
```python
# 安全编码检查清单
class SecureCodingChecklist:
    def __init__(self):
        self.checklist = {
            'input_validation': [
                '所有用户输入是否验证',
                '是否使用白名单验证',
                '长度是否限制',
                '类型是否检查'
            ],
            'output_encoding': [
                '所有输出是否编码',
                '编码是否匹配上下文',
                '是否使用安全库'
            ],
            'authentication': [
                '密码是否哈希存储',
                '是否使用安全算法',
                '会话是否安全'
            ],
            'authorization': [
                '是否检查权限',
                '是否验证资源所有权',
                '是否实施最小权限'
            ],
            'error_handling': [
                '是否不泄露敏感信息',
                '是否有统一错误格式',
                '是否记录日志'
            ],
            'cryptography': [
                '是否使用标准算法',
                '密钥是否安全存储',
                '是否使用安全随机数'
            ],
            'data_protection': [
                '敏感数据是否加密',
                '传输是否加密',
                '缓存是否安全'
            ]
        }
    
    def review_code(self, code_file):
        """代码审查"""
        issues = []
        
        for category, checks in self.checklist.items():
            for check in checks:
                if not self.verify_check(code_file, check):
                    issues.append({
                        'category': category,
                        'check': check,
                        'severity': self.get_severity(category, check),
                        'recommendation': self.get_recommendation(category, check)
                    })
        
        return issues
    
    def verify_check(self, code_file, check):
        """验证检查项"""
        # 简化实现
        # 实际需要使用静态分析工具
        return True
    
    def get_severity(self, category, check):
        """获取严重程度"""
        high_categories = ['authentication', 'authorization', 'cryptography']
        if category in high_categories:
            return '高'
        return '中'
    
    def get_recommendation(self, category, check):
        """获取修复建议"""
        recommendations = {
            'input_validation': '实施白名单验证，使用框架提供的验证功能',
            'output_encoding': '使用框架的自动转义功能',
            'authentication': '使用成熟的认证库，如 bcrypt/argon2',
            'authorization': '实施 RBAC，每次访问都验证权限',
            'error_handling': '使用统一的错误处理机制',
            'cryptography': '使用标准加密库，不自己实现',
            'data_protection': '敏感数据加密存储和传输'
        }
        return recommendations.get(category, '需要进一步分析')
```

### 安全代码审查

**代码审查流程**：
```python
# 安全代码审查
class SecureCodeReview:
    def __init__(self):
        self.review_types = {
            'automated': self.automated_review,
            'manual': self.manual_review,
            'focused': self.focused_review
        }
    
    def conduct_review(self, code_change, review_type='automated'):
        """执行代码审查"""
        if review_type not in self.review_types:
            raise ValueError(f"Unknown review type: {review_type}")
        
        return self.review_types[review_type](code_change)
    
    def automated_review(self, code_change):
        """自动化审查"""
        results = {
            'sast': self.run_sast(code_change),
            'secrets': self.scan_secrets(code_change),
            'dependencies': self.scan_dependencies(code_change)
        }
        
        return results
    
    def manual_review(self, code_change):
        """人工审查"""
        # 审查清单
        checklist = [
            '认证授权逻辑',
            '输入验证',
            '输出编码',
            '错误处理',
            '加密使用',
            '会话管理',
            '日志记录'
        ]
        
        findings = []
        for item in checklist:
            finding = self.review_item(code_change, item)
            if finding:
                findings.append(finding)
        
        return {'findings': findings}
    
    def focused_review(self, code_change):
        """重点审查"""
        # 针对高风险变更
        high_risk_patterns = [
            'password',
            'authentication',
            'authorization',
            'encryption',
            'token',
            'secret',
            'credential'
        ]
        
        findings = []
        for pattern in high_risk_patterns:
            if self.contains_pattern(code_change, pattern):
                finding = self.review_security_sensitive(code_change, pattern)
                if finding:
                    findings.append(finding)
        
        return {'findings': findings}
    
    def run_sast(self, code_change):
        """运行静态分析"""
        # 集成 SAST 工具
        # 如：SonarQube, Fortify, Checkmarx
        return {'issues': [], 'tool': 'SAST'}
    
    def scan_secrets(self, code_change):
        """扫描密钥"""
        # 检测硬编码密钥
        # 如：truffleHog, git-secrets
        return {'secrets': [], 'tool': 'Secrets Scan'}
    
    def scan_dependencies(self, code_change):
        """扫描依赖"""
        # 检测漏洞依赖
        # 如：OWASP Dependency-Check, Snyk
        return {'vulnerabilities': [], 'tool': 'Dependency Scan'}
    
    def review_item(self, code_change, item):
        """审查特定项目"""
        # 实现具体审查逻辑
        return None
    
    def contains_pattern(self, code_change, pattern):
        """检查是否包含模式"""
        return pattern in code_change
    
    def review_security_sensitive(self, code_change, pattern):
        """审查安全敏感代码"""
        # 详细审查
        return None
```

---

## 测试阶段安全

### 安全测试策略

> ▎ 测试不是找 bug，是找安全漏洞。漏洞不找出来，上线就是给别人送钱。

**安全测试类型**：
```
1. 安全功能测试
   - 认证功能测试
   - 授权功能测试
   - 加密功能测试
   - 审计功能测试

2. 安全漏洞测试
   - 渗透测试
   - 漏洞扫描
   - 模糊测试
   - 代码审计

3. 安全回归测试
   - 漏洞修复验证
   - 变更影响测试
   - 持续安全测试
```

**安全测试计划**：
```python
# 安全测试计划
class SecurityTestPlan:
    def __init__(self):
        self.test_types = {
            'functional': self.functional_security_tests,
            'vulnerability': self.vulnerability_tests,
            'regression': self.regression_tests
        }
    
    def create_test_plan(self, requirements, threats):
        """创建测试计划"""
        plan = {
            'functional_tests': self.design_functional_tests(requirements),
            'vulnerability_tests': self.design_vulnerability_tests(threats),
            'test_data': self.prepare_test_data(),
            'environment': self.setup_test_environment(),
            'schedule': self.create_test_schedule()
        }
        
        return plan
    
    def design_functional_tests(self, requirements):
        """设计功能测试"""
        tests = []
        
        for req in requirements:
            if req['category'] == '认证':
                tests.extend(self.design_auth_tests(req))
            elif req['category'] == '授权':
                tests.extend(self.design_authz_tests(req))
            elif req['category'] == '审计':
                tests.extend(self.design_audit_tests(req))
        
        return tests
    
    def design_auth_tests(self, requirement):
        """设计认证测试"""
        return [
            {
                'id': f"AUTH-TEST-{requirement['id']}-01",
                'name': '有效凭证登录',
                'steps': ['输入有效用户名', '输入有效密码', '提交登录'],
                'expected': '登录成功'
            },
            {
                'id': f"AUTH-TEST-{requirement['id']}-02",
                'name': '无效凭证登录',
                'steps': ['输入有效用户名', '输入无效密码', '提交登录'],
                'expected': '登录失败，不泄露具体错误'
            },
            {
                'id': f"AUTH-TEST-{requirement['id']}-03",
                'name': '暴力破解防护',
                'steps': ['连续失败登录 10 次'],
                'expected': '账户锁定或验证码'
            },
            {
                'id': f"AUTH-TEST-{requirement['id']}-04",
                'name': '会话超时',
                'steps': ['登录后等待超时时间', '尝试访问受保护页面'],
                'expected': '需要重新登录'
            }
        ]
    
    def design_authz_tests(self, requirement):
        """设计授权测试"""
        return [
            {
                'id': f"AUTHZ-TEST-{requirement['id']}-01",
                'name': '垂直越权测试',
                'steps': ['普通用户尝试访问管理员功能'],
                'expected': '访问被拒绝'
            },
            {
                'id': f"AUTHZ-TEST-{requirement['id']}-02",
                'name': '水平越权测试',
                'steps': ['用户 A 尝试访问用户 B 的资源'],
                'expected': '访问被拒绝'
            },
            {
                'id': f"AUTHZ-TEST-{requirement['id']}-03",
                'name': '未授权访问测试',
                'steps': ['未登录访问受保护资源'],
                'expected': '重定向到登录页'
            }
        ]
    
    def design_audit_tests(self, requirement):
        """设计审计测试"""
        return [
            {
                'id': f"AUDIT-TEST-{requirement['id']}-01",
                'name': '登录事件记录',
                'steps': ['执行登录操作'],
                'expected': '日志记录登录事件'
            },
            {
                'id': f"AUDIT-TEST-{requirement['id']}-02",
                'name': '权限变更记录',
                'steps': ['修改用户权限'],
                'expected': '日志记录权限变更'
            },
            {
                'id': f"AUDIT-TEST-{requirement['id']}-03",
                'name': '日志完整性',
                'steps': ['检查日志字段'],
                'expected': '包含时间、用户、操作、结果'
            }
        ]
    
    def design_vulnerability_tests(self, threats):
        """设计漏洞测试"""
        tests = []
        
        for threat in threats:
            if threat['priority'] in ['P0', 'P1']:
                tests.append({
                    'threat': threat['threat'],
                    'test_type': 'penetration_test',
                    'scope': threat['component'],
                    'methodology': 'OWASP Testing Guide'
                })
        
        return tests
    
    def prepare_test_data(self):
        """准备测试数据"""
        return {
            'test_users': [
                {'role': 'admin', 'permissions': ['all']},
                {'role': 'user', 'permissions': ['read', 'write']},
                {'role': 'guest', 'permissions': ['read']}
            ],
            'test_data': {
                'valid_inputs': [],
                'invalid_inputs': [],
                'malicious_inputs': []
            }
        }
    
    def setup_test_environment(self):
        """设置测试环境"""
        return {
            'environment': 'staging',
            'isolation': 'network_isolated',
            'monitoring': 'enabled',
            'backup': 'before_test'
        }
    
    def create_test_schedule(self):
        """创建测试计划"""
        return {
            'functional_tests': '2 days',
            'vulnerability_tests': '5 days',
            'regression_tests': '1 day',
            'reporting': '1 day'
        }
```

---

## 发布阶段安全

### 发布前检查

> ▎ 发布不是终点，是新起点。起点不安全，运营就是救火。

**发布检查清单**：
```python
# 发布前安全检查
class ReleaseSecurityChecklist:
    def __init__(self):
        self.checklist = {
            'code': [
                '所有代码已审查',
                'SAST 扫描通过',
                '无高危漏洞',
                '依赖已更新'
            ],
            'configuration': [
                '生产配置已审查',
                '默认密码已修改',
                '调试功能已禁用',
                '错误信息已脱敏'
            ],
            'infrastructure': [
                '防火墙规则已配置',
                'SSL 证书已部署',
                '备份已配置',
                '监控已启用'
            ],
            'documentation': [
                '安全文档已更新',
                '运维手册已准备',
                '应急响应流程已定义',
                '用户隐私政策已发布'
            ],
            'compliance': [
                '合规检查通过',
                '隐私影响评估完成',
                '安全审批通过',
                '发布审批通过'
            ]
        }
    
    def conduct_release_review(self, release_info):
        """执行发布审查"""
        results = {
            'checklist_results': {},
            'issues': [],
            'approved': False
        }
        
        for category, checks in self.checklist.items():
            category_results = []
            for check in checks:
                status = self.verify_check(release_info, category, check)
                category_results.append({
                    'check': check,
                    'status': status
                })
                if not status:
                    results['issues'].append({
                        'category': category,
                        'check': check,
                        'severity': '高' if category in ['code', 'compliance'] else '中'
                    })
            
            results['checklist_results'][category] = category_results
        
        # 审批决策
        high_severity_issues = [i for i in results['issues'] if i['severity'] == '高']
        results['approved'] = len(high_severity_issues) == 0
        
        return results
    
    def verify_check(self, release_info, category, check):
        """验证检查项"""
        # 实际实现需要检查具体证据
        # 这里简化处理
        return True

# 发布审批流程
class ReleaseApproval:
    def __init__(self):
        self.approvers = {
            'security': 'security_team',
            'compliance': 'compliance_team',
            'operations': 'ops_team',
            'product': 'product_team'
        }
    
    def request_approval(self, release_info):
        """请求审批"""
        # 执行安全检查
        checklist = ReleaseSecurityChecklist()
        review_results = checklist.conduct_release_review(release_info)
        
        if not review_results['approved']:
            return {
                'status': 'rejected',
                'reason': '安全检查未通过',
                'issues': review_results['issues']
            }
        
        # 发送审批请求
        approvals = {}
        for role, team in self.approvers.items():
            approvals[role] = self.request_team_approval(team, release_info)
        
        # 检查审批结果
        all_approved = all(approvals.values())
        
        return {
            'status': 'approved' if all_approved else 'pending',
            'approvals': approvals,
            'review_results': review_results
        }
    
    def request_team_approval(self, team, release_info):
        """请求团队审批"""
        # 实际实现需要发送通知并等待审批
        return True
```

---

## 运营阶段安全

### 安全监控

> ▎ 监控不是装工具，是建能力。能力不建立，事件就是发现的晚。

**安全监控体系**：
```python
# 安全监控
class SecurityMonitoring:
    def __init__(self):
        self.monitoring_components = {
            'log_collection': self.setup_log_collection(),
            'siem': self.setup_siem(),
            'alerting': self.setup_alerting(),
            'dashboard': self.setup_dashboard()
        }
    
    def setup_log_collection(self):
        """设置日志收集"""
        return {
            'sources': [
                'application_logs',
                'system_logs',
                'network_logs',
                'security_logs',
                'audit_logs'
            ],
            'format': 'JSON',
            'retention': '180 days',
            'encryption': 'in_transit_and_at_rest'
        }
    
    def setup_siem(self):
        """设置 SIEM"""
        return {
            'correlation_rules': [
                'multiple_failed_logins',
                'privilege_escalation',
                'data_exfiltration',
                'malware_detection',
                'anomalous_behavior'
            ],
            'dashboards': [
                'security_overview',
                'threat_landscape',
                'compliance_status',
                'incident_response'
            ]
        }
    
    def setup_alerting(self):
        """设置告警"""
        return {
            'severity_levels': {
                'critical': {'response_time': '15min', 'escalation': 'immediate'},
                'high': {'response_time': '1h', 'escalation': '4h'},
                'medium': {'response_time': '4h', 'escalation': '24h'},
                'low': {'response_time': '24h', 'escalation': 'weekly'}
            },
            'channels': [
                'email',
                'sms',
                'slack',
                'pagerduty'
            ]
        }
    
    def setup_dashboard(self):
        """设置仪表盘"""
        return {
            'metrics': [
                'failed_login_attempts',
                'security_events',
                'vulnerability_count',
                'patch_status',
                'compliance_score'
            ],
            'refresh_rate': '5min',
            'access_control': 'role_based'
        }
```

### 漏洞管理

**漏洞管理流程**：
```python
# 漏洞管理
class VulnerabilityManagement:
    def __init__(self):
        self.process = {
            'discovery': self.vulnerability_discovery,
            'assessment': self.vulnerability_assessment,
            'prioritization': self.vulnerability_prioritization,
            'remediation': self.vulnerability_remediation,
            'verification': self.vulnerability_verification,
            'reporting': self.vulnerability_reporting
        }
    
    def manage_vulnerability(self, vuln_info):
        """管理漏洞"""
        # 1. 发现
        discovery_result = self.process['discovery'](vuln_info)
        
        # 2. 评估
        assessment_result = self.process['assessment'](discovery_result)
        
        # 3. 优先级
        priority = self.process['prioritization'](assessment_result)
        
        # 4. 修复
        remediation_result = self.process['remediation'](priority)
        
        # 5. 验证
        verification_result = self.process['verification'](remediation_result)
        
        # 6. 报告
        report = self.process['reporting'](verification_result)
        
        return report
    
    def vulnerability_discovery(self, vuln_info):
        """漏洞发现"""
        sources = [
            'security_scanner',
            'penetration_test',
            'bug_bounty',
            'vendor_advisory',
            'internal_report'
        ]
        
        return {
            'source': vuln_info.get('source', 'unknown'),
            'cve': vuln_info.get('cve'),
            'description': vuln_info.get('description'),
            'affected_component': vuln_info.get('component'),
            'discovered_at': vuln_info.get('discovered_at')
        }
    
    def vulnerability_assessment(self, discovery_result):
        """漏洞评估"""
        # CVSS 评分
        cvss_score = self.calculate_cvss(discovery_result)
        
        return {
            **discovery_result,
            'cvss_score': cvss_score,
            'cvss_vector': self.get_cvss_vector(cvss_score),
            'exploitability': self.assess_exploitability(discovery_result),
            'impact': self.assess_impact(discovery_result)
        }
    
    def calculate_cvss(self, vuln):
        """计算 CVSS 分数"""
        # 简化实现
        # 实际应使用 CVSS 计算器
        return 7.5  # 示例分数
    
    def vulnerability_prioritization(self, assessment_result):
        """漏洞优先级"""
        cvss = assessment_result['cvss_score']
        exploitability = assessment_result['exploitability']
        impact = assessment_result['impact']
        
        # 优先级计算
        if cvss >= 9.0 or exploitability == 'high':
            priority = 'P0'
            sla = '24h'
        elif cvss >= 7.0:
            priority = 'P1'
            sla = '7d'
        elif cvss >= 4.0:
            priority = 'P2'
            sla = '30d'
        else:
            priority = 'P3'
            sla = '90d'
        
        return {
            **assessment_result,
            'priority': priority,
            'sla': sla,
            'assigned_to': self.assign_owner(assessment_result)
        }
    
    def vulnerability_remediation(self, priority_info):
        """漏洞修复"""
        return {
            **priority_info,
            'remediation_type': self.get_remediation_type(priority_info),
            'fix_version': self.get_fix_version(priority_info),
            'workaround': self.get_workaround(priority_info),
            'scheduled_date': self.schedule_remediation(priority_info)
        }
    
    def vulnerability_verification(self, remediation_result):
        """漏洞验证"""
        # 验证修复
        verified = self.verify_fix(remediation_result)
        
        return {
            **remediation_result,
            'verified': verified,
            'verified_at': datetime.now() if verified else None,
            'verified_by': 'security_team' if verified else None
        }
    
    def vulnerability_reporting(self, verification_result):
        """漏洞报告"""
        return {
            'summary': {
                'total_vulnerabilities': 1,
                'by_priority': {'P0': 0, 'P1': 0, 'P2': 0, 'P3': 0},
                'by_status': {'open': 0, 'in_progress': 0, 'resolved': 0}
            },
            'details': verification_result,
            'metrics': {
                'mean_time_to_detect': '24h',
                'mean_time_to_remediate': '7d',
                'remediation_rate': '95%'
            }
        }
    
    def assess_exploitability(self, vuln):
        """评估可利用性"""
        return 'medium'
    
    def assess_impact(self, vuln):
        """评估影响"""
        return 'high'
    
    def get_remediation_type(self, vuln):
        """获取修复类型"""
        return 'patch'
    
    def get_fix_version(self, vuln):
        """获取修复版本"""
        return '1.0.1'
    
    def get_workaround(self, vuln):
        """获取临时方案"""
        return '配置缓解措施'
    
    def schedule_remediation(self, vuln):
        """安排修复"""
        return '2024-01-15'
    
    def assign_owner(self, vuln):
        """分配负责人"""
        return 'development_team'
    
    def verify_fix(self, vuln):
        """验证修复"""
        return True
```

---

## SDL 实施指南

### 实施路线图

**阶段一：基础建设 (1-3 个月)**：
```
1. 建立安全策略
   - 安全开发政策
   - 安全编码规范
   - 安全审查流程

2. 培训团队
   - 安全意识培训
   - 安全编码培训
   - 安全工具培训

3. 部署工具
   - SAST 工具
   - 依赖扫描
   - 漏洞管理
```

**阶段二：流程集成 (3-6 个月)**：
```
1. 集成 CI/CD
   - 自动化安全测试
   - 安全门禁
   - 持续监控

2. 建立度量
   - 安全指标
   - 报告机制
   - 改进流程

3. 威胁建模
   - 关键系统建模
   - 定期审查
   - 对策实施
```

**阶段三：成熟运营 (6-12 个月)**：
```
1. 持续改进
   - 定期评估
   - 流程优化
   - 工具升级

2. 文化建设
   - 安全冠军
   - 知识分享
   - 正向激励

3. 外部认证
   - 合规认证
   - 行业认可
   - 客户信任
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ██████████ 5/5 │ 生产就绪       │
└───────────────┴────────────────┴────────────────┘
综合：4.5
```
▎ 这才配得上 P8。SDL 不是流程文档，是安全文化。文化不建立，流程就是形式。

---

## 总结与思考

### 核心要点回顾

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

**SDL 框架**：
```
1. 需求阶段
   - 安全需求分析
   - 隐私影响评估
   - 合规要求识别

2. 设计阶段
   - 威胁建模
   - 安全架构
   - 安全设计评审

3. 开发阶段
   - 安全编码
   - 代码审查
   - 自动化扫描

4. 测试阶段
   - 安全功能测试
   - 漏洞测试
   - 渗透测试

5. 发布阶段
   - 发布前检查
   - 安全审批
   - 发布记录

6. 运营阶段
   - 安全监控
   - 漏洞管理
   - 应急响应
```

**关键成功因素**：
```
1. 领导支持
   - 高层重视
   - 资源投入
   - 政策支持

2. 团队参与
   - 全员参与
   - 角色明确
   - 责任落实

3. 持续改进
   - 度量驱动
   - 流程优化
   - 工具升级
```

### 深入思考问题

> ▎ 只动手不动脑，那是码农。动手又动脑，才是工程师。

**SDL 与敏捷**：
```
1. 敏捷挑战
   - 快速迭代 vs 安全审查
   - 用户故事 vs 安全需求
   - 持续交付 vs 安全审批

2. 融合方案
   - 安全用户故事
   - 自动化安全测试
   - 安全验收标准

3. 平衡点
   - 安全左移
   - 自动化优先
   - 风险接受
```

**SDL 与 DevSecOps**：
```
1. 演进关系
   - SDL 是基础
   - DevSecOps 是演进
   - 自动化是关键

2. 差异对比
   - SDL: 流程驱动
   - DevSecOps: 文化驱动
   - 融合：最佳实践

3. 实施建议
   - 从 SDL 开始
   - 向 DevSecOps 演进
   - 持续改进
```

### 实战建议

> ▎ 我给你指了路，走不走是你的事。机会给了，抓不抓得住看你。

**SDL 实施**：
```
1. 从小开始
   - 试点项目
   - 快速见效
   - 逐步推广

2. 工具先行
   - 自动化工具
   - 降低门槛
   - 提高效率

3. 文化建设
   - 安全培训
   - 知识分享
   - 正向激励
```

**持续改进**：
```
1. 度量驱动
   - 定义指标
   - 定期测量
   - 持续改进

2. 最佳实践
   - 学习业界
   - 内部沉淀
   - 分享交流

3. 成熟度提升
   - 定期评估
   - 设定目标
   - 逐步提升
```

---

## 参考资料

### 学习资源
```
- Microsoft SDL
  https://www.microsoft.com/securityengineering/sdl

- OWASP SAMM
  https://owaspsamm.org/

- BSIMM
  https://www.bsimm.com/
```

### 工具资源
```
- Threat Modeling Tool (Microsoft)
  https://www.microsoft.com/securityengineering/sdl/threatmodeling

- OWASP Threat Dragon
  https://owasp.org/www-project-threat-dragon/

- IriusRisk
  https://www.iriusrisk.com/
```

### 标准规范
```
- ISO/IEC 27034 (Application Security)
  https://www.iso.org/standard/44378.html

- NIST SSDF (Secure Software Development Framework)
  https://csrc.nist.gov/publications/detail/sp/800-218/final
```

### 书籍推荐
```
- 《The Security Development Lifecycle》
- 《Software Security: Building Security In》
- 《Secure by Design》
- 《DevSecOps Practices》
```

---

**标记 明日预告**：Day 142 - 威胁建模实战

> ▎ SDL 是流程框架，威胁建模是核心实践——明天深入威胁建模实战。

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

---

*本文是 365 天信息安全技术系列的第 141 篇，应用安全部分第 34 篇，精编版本*

*应用安全核心系列 (Day 141-155) 正式开始！*