Day-129-安全需求分析

# Day 143: 安全需求分析

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

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ 安全需求分析 - Day 143             │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ 安全需求不是功能附件，是核心要求。要求不明确，设计就是盲目的。今天系统学习安全需求分析。

---

## 清单 目录

1. [安全需求概述](#安全需求概述)
2. [需求工程基础](#需求工程基础)
3. [安全需求分类](#安全需求分类)
4. [需求获取方法](#需求获取方法)
5. [需求分析技术](#需求分析技术)
6. [需求规格说明](#需求规格说明)
7. [需求验证确认](#需求验证确认)
8. [需求管理实践](#需求管理实践)
9. [实战案例演练](#实战案例演练)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## 安全需求概述

### 什么是安全需求

> ▎ 安全需求不是"要安全"，是具体的安全要求。要求不具体，实现就是随意的。

**定义与特点**：
```
安全需求 (Security Requirements) 是系统必须满足的安全属性和安全行为的明确描述。

核心特点：
1. 可测试性 (Testable)
   - 可以验证是否满足
   - 有明确的验收标准
   - 可量化测量

2. 明确性 (Specific)
   - 不含糊其辞
   - 无歧义
   - 清晰定义

3. 可追溯性 (Traceable)
   - 来源可追溯
   - 实现可追踪
   - 变更可跟踪

4. 优先级 (Prioritized)
   - 有明确优先级
   - 资源分配依据
   - 风险管理基础
```

**安全需求 vs 功能需求**：
```
┌─────────────────┬─────────────────┬─────────────────┐
│     维度        │   功能需求      │   安全需求      │
├─────────────────┼─────────────────┼─────────────────┤
│   关注点        │  系统做什么     │  系统如何保护   │
├─────────────────┼─────────────────┼─────────────────┤
│   描述方式      │  功能行为       │  安全属性       │
├─────────────────┼─────────────────┼─────────────────┤
│   验证方式      │  功能测试       │  安全测试       │
├─────────────────┼─────────────────┼─────────────────┤
│   优先级        │  业务驱动       │  风险驱动       │
├─────────────────┼─────────────────┼─────────────────┤
│   变更频率      │  较高           │  较低           │
└─────────────────┴─────────────────┴─────────────────┘

关系：
- 安全需求约束功能需求
- 功能需求实现安全需求
- 两者相互影响
```

### 安全需求价值

**业务价值**：
```
1. 风险降低
   - 明确安全目标
   - 指导安全设计
   - 减少安全漏洞

2. 成本节约
   - 早期发现问题
   - 减少返工成本
   - 降低运维成本

3. 合规满足
   - 满足法规要求
   - 通过安全审计
   - 获得行业认证

4. 客户信任
   - 提升安全形象
   - 增强客户信心
   - 竞争优势
```

**需求质量影响**：
```
需求质量问题导致的后果：

模糊需求 → 实现偏差 → 安全漏洞
├── 示例："系统应该安全"
├── 问题：什么是安全？如何衡量？
└── 后果：开发人员自行理解，实现不一致

遗漏需求 → 设计缺失 → 安全缺陷
├── 示例：未要求审计日志
├── 问题：事后无法追溯
└── 后果：安全事件无法调查

矛盾需求 → 实现冲突 → 安全风险
├── 示例：既要完全开放又要绝对安全
├── 问题：无法同时满足
└── 后果：设计困境或安全妥协
```

---

## 需求工程基础

### 需求工程流程

> ▎ 需求工程不是写文档，是建共识。共识不建立，需求就是纸面的。

**需求工程流程**：
```
┌─────────────────────────────────────────────────────────┐
│                  需求工程流程                            │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  需求获取 (Elicitation)                                 │
│  ├── 利益相关者访谈                                     │
│  ├── 文档分析                                           │
│  ├── 问卷调查                                           │
│  └── 工作坊                                             │
│                                                         │
│  需求分析 (Analysis)                                    │
│  ├── 需求分类                                           │
│  ├── 需求细化                                           │
│  ├── 冲突解决                                           │
│  └── 优先级排序                                         │
│                                                         │
│  需求规格 (Specification)                               │
│  ├── 需求文档编写                                       │
│  ├── 需求建模                                           │
│  ├── 需求评审                                           │
│  └── 需求基线                                           │
│                                                         │
│  需求验证 (Validation)                                  │
│  ├── 需求审查                                           │
│  ├── 原型验证                                           │
│  ├── 测试用例                                           │
│  └── 利益相关者确认                                     │
│                                                         │
│  需求管理 (Management)                                  │
│  ├── 需求跟踪                                           │
│  ├── 变更管理                                           │
│  ├── 版本控制                                           │
│  └── 状态监控                                           │
│                                                         │
└─────────────────────────────────────────────────────────┘
```

### 利益相关者分析

**利益相关者识别**：
```python
# 利益相关者分析
class StakeholderAnalysis:
    def __init__(self):
        self.stakeholders = []
    
    def identify_stakeholders(self, project_context):
        """识别利益相关者"""
        self.stakeholders = [
            {
                'category': '业务方',
                'roles': [
                    {'name': '产品负责人', 'interest': '业务目标实现', 'influence': '高'},
                    {'name': '业务用户', 'interest': '功能可用性', 'influence': '中'},
                    {'name': '运营团队', 'interest': '运营效率', 'influence': '中'}
                ]
            },
            {
                'category': '技术方',
                'roles': [
                    {'name': '架构师', 'interest': '技术可行性', 'influence': '高'},
                    {'name': '开发团队', 'interest': '实现难度', 'influence': '中'},
                    {'name': '测试团队', 'interest': '测试覆盖率', 'influence': '中'}
                ]
            },
            {
                'category': '安全方',
                'roles': [
                    {'name': '安全团队', 'interest': '安全合规', 'influence': '高'},
                    {'name': '合规团队', 'interest': '法规遵循', 'influence': '高'},
                    {'name': '审计团队', 'interest': '审计可追溯', 'influence': '中'}
                ]
            },
            {
                'category': '外部方',
                'roles': [
                    {'name': '监管机构', 'interest': '合规要求', 'influence': '高'},
                    {'name': '客户', 'interest': '数据保护', 'influence': '高'},
                    {'name': '合作伙伴', 'interest': '接口安全', 'influence': '中'}
                ]
            }
        ]
        
        return self.stakeholders
    
    def analyze_influence_interest(self):
        """分析影响力 - 兴趣矩阵"""
        matrix = {
            'high_influence_high_interest': [],  # 重点管理
            'high_influence_low_interest': [],   # 保持满意
            'low_influence_high_interest': [],   # 保持沟通
            'low_influence_low_interest': []     # 监督
        }
        
        for category in self.stakeholders:
            for role in category['roles']:
                quadrant = self.get_quadrant(role)
                matrix[quadrant].append(role)
        
        return matrix
    
    def get_quadrant(self, role):
        """获取象限"""
        influence = role['influence']
        # 简化：兴趣默认中
        if influence == '高':
            return 'high_influence_high_interest'
        else:
            return 'low_influence_high_interest'
    
    def get_engagement_strategy(self):
        """获取参与策略"""
        return {
            '重点管理': '密切合作，频繁沟通，需求确认',
            '保持满意': '定期更新，关注反馈，避免阻碍',
            '保持沟通': '信息共享，征求意见，适当参与',
            '监督': '被动更新，按需沟通'
        }
```

---

## 安全需求分类

### 分类体系

> ▎ 分类不是贴标签，是建结构。结构不清晰，管理就是混乱的。

**安全需求分类框架**：
```
一级分类 (安全属性):
├── 机密性 (Confidentiality)
├── 完整性 (Integrity)
├── 可用性 (Availability)
├── 可追溯性 (Accountability)
├── 真实性 (Authenticity)
└── 隐私性 (Privacy)

二级分类 (功能领域):
├── 认证 (Authentication)
├── 授权 (Authorization)
├── 审计 (Audit)
├── 加密 (Cryptography)
├── 会话管理 (Session Management)
├── 数据保护 (Data Protection)
├── 网络安全 (Network Security)
└── 物理安全 (Physical Security)

三级分类 (具体需求):
├── 密码策略
├── 多因素认证
├── 访问控制列表
├── 日志记录
├── ...
```

### 详细分类

**认证需求**：
```python
# 认证需求分类
authentication_requirements = {
    'password_policy': [
        {
            'id': 'AUTH-PWD-001',
            'description': '密码最小长度 12 位',
            'category': '机密性',
            'priority': 'P0',
            'source': '安全策略',
            'acceptance_criteria': [
                '系统拒绝少于 12 位的密码',
                '密码设置时有长度提示'
            ],
            'test_method': 'automated'
        },
        {
            'id': 'AUTH-PWD-002',
            'description': '密码必须包含大小写字母、数字、特殊字符',
            'category': '机密性',
            'priority': 'P0',
            'source': '安全策略',
            'acceptance_criteria': [
                '系统拒绝不符合复杂度要求的密码',
                '密码设置时有复杂度提示'
            ],
            'test_method': 'automated'
        },
        {
            'id': 'AUTH-PWD-003',
            'description': '密码历史记录 10 次',
            'category': '机密性',
            'priority': 'P1',
            'source': '最佳实践',
            'acceptance_criteria': [
                '用户不能重复使用最近 10 次的密码',
                '密码修改时有历史检查'
            ],
            'test_method': 'automated'
        }
    ],
    'mfa': [
        {
            'id': 'AUTH-MFA-001',
            'description': '管理员登录必须使用 MFA',
            'category': '真实性',
            'priority': 'P0',
            'source': '合规要求',
            'acceptance_criteria': [
                '管理员登录时强制要求 MFA',
                '支持 TOTP 和短信两种方式',
                'MFA 失败时有备用方案'
            ],
            'test_method': 'manual'
        },
        {
            'id': 'AUTH-MFA-002',
            'description': '敏感操作需要 MFA 验证',
            'category': '真实性',
            'priority': 'P0',
            'source': '安全策略',
            'acceptance_criteria': [
                '删除账户需要 MFA',
                '修改支付信息需要 MFA',
                '导出大量数据需要 MFA'
            ],
            'test_method': 'manual'
        }
    ],
    'account_lockout': [
        {
            'id': 'AUTH-LOCK-001',
            'description': '连续失败 5 次后锁定账户 15 分钟',
            'category': '机密性',
            'priority': 'P0',
            'source': '安全策略',
            'acceptance_criteria': [
                '第 5 次失败登录后账户锁定',
                '锁定时间 15 分钟',
                '锁定期间登录提示账户已锁定'
            ],
            'test_method': 'automated'
        }
    ]
}
```

**授权需求**：
```python
# 授权需求分类
authorization_requirements = {
    'rbac': [
        {
            'id': 'AUTHZ-RBAC-001',
            'description': '系统实施基于角色的访问控制',
            'category': '机密性',
            'priority': 'P0',
            'source': '架构设计',
            'acceptance_criteria': [
                '支持自定义角色',
                '支持角色 - 权限映射',
                '支持用户 - 角色分配'
            ],
            'test_method': 'both'
        },
        {
            'id': 'AUTHZ-RBAC-002',
            'description': '默认拒绝所有访问',
            'category': '机密性',
            'priority': 'P0',
            'source': '安全原则',
            'acceptance_criteria': [
                '新角色默认无任何权限',
                '权限必须显式授予',
                '权限变更需要审批'
            ],
            'test_method': 'automated'
        }
    ],
    'access_control': [
        {
            'id': 'AUTHZ-AC-001',
            'description': '用户只能访问自己的数据',
            'category': '机密性',
            'priority': 'P0',
            'source': '隐私要求',
            'acceptance_criteria': [
                '用户 A 不能访问用户 B 的数据',
                'API 返回数据经过权限过滤',
                '越权访问被拒绝并记录'
            ],
            'test_method': 'manual'
        },
        {
            'id': 'AUTHZ-AC-002',
            'description': '管理员操作需要额外授权',
            'category': '真实性',
            'priority': 'P1',
            'source': '安全策略',
            'acceptance_criteria': [
                '删除操作需要确认',
                '批量操作需要审批',
                '敏感配置变更需要双人复核'
            ],
            'test_method': 'manual'
        }
    ]
}
```

**审计需求**：
```python
# 审计需求分类
audit_requirements = {
    'logging': [
        {
            'id': 'AUDIT-LOG-001',
            'description': '记录所有认证事件',
            'category': '可追溯性',
            'priority': 'P0',
            'source': '合规要求',
            'acceptance_criteria': [
                '记录登录成功/失败',
                '记录登出事件',
                '记录 MFA 验证事件',
                '日志包含时间、用户、IP、结果'
            ],
            'test_method': 'automated'
        },
        {
            'id': 'AUDIT-LOG-002',
            'description': '记录所有权限变更事件',
            'category': '可追溯性',
            'priority': 'P0',
            'source': '合规要求',
            'acceptance_criteria': [
                '记录角色创建/修改/删除',
                '记录权限分配/回收',
                '记录变更前后值',
                '记录操作人和审批人'
            ],
            'test_method': 'automated'
        },
        {
            'id': 'AUDIT-LOG-003',
            'description': '日志保留 180 天',
            'category': '可追溯性',
            'priority': 'P1',
            'source': '合规要求',
            'acceptance_criteria': [
                '日志存储至少 180 天',
                '过期日志自动归档',
                '归档日志可检索'
            ],
            'test_method': 'manual'
        }
    ],
    'monitoring': [
        {
            'id': 'AUDIT-MON-001',
            'description': '实时监测异常登录行为',
            'category': '可追溯性',
            'priority': 'P1',
            'source': '安全策略',
            'acceptance_criteria': [
                '检测异地登录',
                '检测异常时间登录',
                '检测暴力破解',
                '5 分钟内告警'
            ],
            'test_method': 'manual'
        }
    ]
}
```

---

## 需求获取方法

### 获取技术

> ▎ 需求获取不是问问题，是挖知识。知识不挖出，需求就是表面的。

**获取方法对比**：
```
┌─────────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
│     方法        │   适用场景   │   信息深度   │   时间成本   │   参与人数   │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   访谈          │  深度了解    │  深          │  高          │  1-3 人       │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   问卷          │  广泛收集    │  浅          │  低          │  多人        │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   工作坊        │  共识建立    │  中深        │  中          │  5-15 人      │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   文档分析      │  背景了解    │  中          │  中          │  1-2 人       │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   原型演示      │  需求验证    │  中          │  中          │  3-10 人      │
└─────────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
```

### 访谈指南

**安全需求访谈**：
```python
# 安全需求访谈指南
class SecurityRequirementInterview:
    def __init__(self):
        self.interview_templates = {
            'business_stakeholder': self.business_interview_template(),
            'security_team': self.security_team_interview_template(),
            'developer': self.developer_interview_template(),
            'compliance': self.compliance_interview_template()
        }
    
    def business_interview_template(self):
        """业务方访谈模板"""
        return {
            'opening': '了解业务目标和安全期望',
            'questions': [
                {
                    'topic': '业务目标',
                    'questions': [
                        '系统的核心业务目标是什么？',
                        '哪些业务功能最关键？',
                        '业务中断的容忍时间是多少？'
                    ]
                },
                {
                    'topic': '数据资产',
                    'questions': [
                        '系统处理哪些敏感数据？',
                        '数据泄露的业务影响是什么？',
                        '数据保留有什么要求？'
                    ]
                },
                {
                    'topic': '用户群体',
                    'questions': [
                        '系统的用户类型有哪些？',
                        '不同用户的权限需求是什么？',
                        '是否有外部用户访问？'
                    ]
                },
                {
                    'topic': '风险容忍',
                    'questions': [
                        '可接受的安全风险级别是什么？',
                        '安全与便利的平衡点在哪里？',
                        '安全事件的响应期望是什么？'
                    ]
                }
            ],
            'closing': '确认优先级和后续步骤'
        }
    
    def security_team_interview_template(self):
        """安全团队访谈模板"""
        return {
            'opening': '了解安全要求和合规需求',
            'questions': [
                {
                    'topic': '安全策略',
                    'questions': [
                        '组织的安全策略有哪些？',
                        '必须遵循的安全标准是什么？',
                        '有哪些安全基线要求？'
                    ]
                },
                {
                    'topic': '威胁情报',
                    'questions': [
                        '同行业有哪些安全事件？',
                        '主要威胁来源是什么？',
                        '历史安全问题有哪些？'
                    ]
                },
                {
                    'topic': '技术控制',
                    'questions': [
                        '必须实施的安全控制有哪些？',
                        '有哪些安全工具必须集成？',
                        '安全监控有什么要求？'
                    ]
                },
                {
                    'topic': '合规审计',
                    'questions': [
                        '需要通过哪些合规认证？',
                        '审计频率和范围是什么？',
                        '合规文档有什么要求？'
                    ]
                }
            ],
            'closing': '确认安全基线和审查流程'
        }
    
    def developer_interview_template(self):
        """开发团队访谈模板"""
        return {
            'opening': '了解技术约束和实现考虑',
            'questions': [
                {
                    'topic': '技术栈',
                    'questions': [
                        '使用的技术栈是什么？',
                        '有哪些安全组件可用？',
                        '技术约束有哪些？'
                    ]
                },
                {
                    'topic': '安全实践',
                    'questions': [
                        '团队的安全开发经验如何？',
                        '使用哪些安全工具？',
                        '安全培训情况如何？'
                    ]
                },
                {
                    'topic': '实现考虑',
                    'questions': [
                        '安全需求实现的难点在哪里？',
                        '需要哪些安全支持？',
                        '测试资源是否充足？'
                    ]
                }
            ],
            'closing': '确认技术支持和培训计划'
        }
    
    def compliance_interview_template(self):
        """合规团队访谈模板"""
        return {
            'opening': '了解合规要求和监管期望',
            'questions': [
                {
                    'topic': '适用法规',
                    'questions': [
                        '系统适用哪些法律法规？',
                        '行业监管要求有哪些？',
                        '数据保护法规要求是什么？'
                    ]
                },
                {
                    'topic': '合规控制',
                    'questions': [
                        '必须实施的合规控制有哪些？',
                        '合规证据要求是什么？',
                        '合规审查流程是什么？'
                    ]
                },
                {
                    'topic': '报告要求',
                    'questions': [
                        '合规报告频率是什么？',
                        '报告内容要求有哪些？',
                        '违规通知要求是什么？'
                    ]
                }
            ],
            'closing': '确认合规时间表和审查点'
        }
    
    def conduct_interview(self, stakeholder_type, context):
        """执行访谈"""
        template = self.interview_templates.get(stakeholder_type)
        
        if not template:
            raise ValueError(f"Unknown stakeholder type: {stakeholder_type}")
        
        # 访谈记录
        interview_record = {
            'stakeholder_type': stakeholder_type,
            'date': context.get('date'),
            'participants': context.get('participants'),
            'responses': {},
            'requirements_identified': [],
            'follow_up_actions': []
        }
        
        # 按主题记录回答
        for section in template['questions']:
            topic = section['topic']
            interview_record['responses'][topic] = []
            
            for question in section['questions']:
                # 实际访谈中记录回答
                answer = context.get('answers', {}).get(question, '')
                interview_record['responses'][topic].append({
                    'question': question,
                    'answer': answer
                })
                
                # 从回答中提取需求
                req = self.extract_requirement(question, answer)
                if req:
                    interview_record['requirements_identified'].append(req)
        
        return interview_record
    
    def extract_requirement(self, question, answer):
        """从回答中提取需求"""
        # 简化实现
        # 实际需要使用 NLP 或人工分析
        if answer and len(answer) > 10:
            return {
                'source_question': question,
                'raw_requirement': answer,
                'status': 'needs_refinement'
            }
        return None
```

---

## 需求分析技术

### 需求细化

> ▎ 需求细化不是加细节，是加精度。精度不够高，实现就是模糊的。

**需求细化方法**：
```python
# 需求细化
class RequirementRefinement:
    def __init__(self):
        self.refinement_techniques = [
            'decomposition',      # 分解
            'elaboration',        # 详述
            'clarification',      # 澄清
            'quantification'      # 量化
        ]
    
    def refine_requirement(self, raw_requirement):
        """细化需求"""
        # 1. 检查完整性
        completeness_check = self.check_completeness(raw_requirement)
        
        # 2. 分解复杂需求
        if not completeness_check['complete']:
            decomposed = self.decompose(raw_requirement)
        else:
            decomposed = [raw_requirement]
        
        # 3. 详述每个需求
        refined = []
        for req in decomposed:
            elaborated = self.elaborate(req)
            refined.append(elaborated)
        
        # 4. 量化验收标准
        quantified = []
        for req in refined:
            quantified.append(self.quantify(req))
        
        return quantified
    
    def check_completeness(self, requirement):
        """检查完整性"""
        required_elements = [
            'description',           # 需求描述
            'acceptance_criteria',   # 验收标准
            'priority',              # 优先级
            'source'                 # 来源
        ]
        
        missing = []
        for element in required_elements:
            if element not in requirement or not requirement[element]:
                missing.append(element)
        
        return {
            'complete': len(missing) == 0,
            'missing': missing
        }
    
    def decompose(self, requirement):
        """分解需求"""
        # 如果需求包含多个方面，分解为多个需求
        description = requirement.get('description', '')
        
        # 检测连接词
        if '和' in description or '且' in description or 'and' in description:
            parts = self.split_by_conjunction(description)
            
            decomposed = []
            for i, part in enumerate(parts):
                decomposed.append({
                    'id': f"{requirement.get('id', 'REQ')}-{i+1}",
                    'description': part,
                    'parent': requirement.get('id'),
                    'priority': requirement.get('priority'),
                    'source': requirement.get('source')
                })
            
            return decomposed
        
        return [requirement]
    
    def elaborate(self, requirement):
        """详述需求"""
        description = requirement.get('description', '')
        
        # 添加上下文
        elaborated = {
            **requirement,
            'context': self.add_context(description),
            'rationale': self.add_rationale(description),
            'assumptions': self.add_assumptions(description),
            'constraints': self.add_constraints(description)
        }
        
        return elaborated
    
    def quantify(self, requirement):
        """量化验收标准"""
        acceptance_criteria = requirement.get('acceptance_criteria', [])
        
        quantified_criteria = []
        for criterion in acceptance_criteria:
            quantified = self.make_measurable(criterion)
            quantified_criteria.append(quantified)
        
        requirement['acceptance_criteria'] = quantified_criteria
        
        return requirement
    
    def add_context(self, description):
        """添加上下文"""
        # 分析需求描述，添加相关上下文
        return f"此需求适用于 {self.infer_scope(description)} 场景"
    
    def add_rationale(self, description):
        """添加理由"""
        return "此需求基于安全最佳实践和合规要求"
    
    def add_assumptions(self, description):
        """添加假设"""
        return ["系统有必要的技术支持", "用户有基本的安全意识"]
    
    def add_constraints(self, description):
        """添加约束"""
        return ["不能显著影响用户体验", "不能超出预算范围"]
    
    def infer_scope(self, description):
        """推断适用范围"""
        # 简化实现
        return "所有用户访问"
    
    def make_measurable(self, criterion):
        """使可测量"""
        # 添加可测量的指标
        if '时间' not in criterion and '秒' not in criterion:
            criterion += ' (响应时间 < 2 秒)'
        return criterion
    
    def split_by_conjunction(self, text):
        """按连接词分割"""
        import re
        parts = re.split(r'[和且 and]', text)
        return [p.strip() for p in parts if p.strip()]
```

### 优先级排序

**优先级模型**：
```python
# 需求优先级排序
class RequirementPrioritization:
    def __init__(self):
        self.models = {
            'moscow': self.moscow_prioritization,
            'risk_based': self.risk_based_prioritization,
            'value_effort': self.value_effort_prioritization
        }
    
    def prioritize(self, requirements, model='risk_based'):
        """优先级排序"""
        if model not in self.models:
            raise ValueError(f"Unknown model: {model}")
        
        return self.models[model](requirements)
    
    def moscow_prioritization(self, requirements):
        """MoSCoW 优先级"""
        categorized = {
            'Must': [],      # 必须有
            'Should': [],    # 应该有
            'Could': [],     # 可以有
            'Won\'t': []     # 本次不会有
        }
        
        for req in requirements:
            category = self.assign_moscow_category(req)
            categorized[category].append(req)
        
        return categorized
    
    def assign_moscow_category(self, requirement):
        """分配 MoSCoW 类别"""
        # 基于风险、合规、业务价值判断
        if requirement.get('compliance_required', False):
            return 'Must'
        
        if requirement.get('risk_level') == '高':
            return 'Must'
        
        if requirement.get('business_value') == '高':
            return 'Should'
        
        return 'Could'
    
    def risk_based_prioritization(self, requirements):
        """基于风险的优先级"""
        prioritized = []
        
        for req in requirements:
            risk_score = self.calculate_risk_score(req)
            req['risk_score'] = risk_score
            req['priority'] = self.risk_to_priority(risk_score)
            prioritized.append(req)
        
        # 按风险分数排序
        prioritized.sort(key=lambda x: x['risk_score'], reverse=True)
        
        return prioritized
    
    def calculate_risk_score(self, requirement):
        """计算风险分数"""
        # 风险 = 可能性 × 影响
        likelihood = self.get_likelihood(requirement)
        impact = self.get_impact(requirement)
        
        return likelihood * impact
    
    def get_likelihood(self, requirement):
        """获取可能性"""
        # 基于威胁情报、历史数据
        threat_category = requirement.get('threat_category', 'general')
        
        likelihood_map = {
            'authentication': 4,  # 认证相关威胁常见
            'data_breach': 3,
            'dos': 2,
            'general': 2
        }
        
        return likelihood_map.get(threat_category, 2)
    
    def get_impact(self, requirement):
        """获取影响"""
        # 基于业务影响分析
        impact_category = requirement.get('impact_category', 'medium')
        
        impact_map = {
            'critical': 5,
            'high': 4,
            'medium': 3,
            'low': 2
        }
        
        return impact_map.get(impact_category, 3)
    
    def risk_to_priority(self, risk_score):
        """风险分数转优先级"""
        if risk_score >= 16:
            return 'P0'
        elif risk_score >= 10:
            return 'P1'
        elif risk_score >= 6:
            return 'P2'
        else:
            return 'P3'
    
    def value_effort_prioritization(self, requirements):
        """价值 - 工作量优先级"""
        prioritized = []
        
        for req in requirements:
            value = self.estimate_value(req)
            effort = self.estimate_effort(req)
            
            req['value'] = value
            req['effort'] = effort
            req['value_effort_ratio'] = value / effort if effort > 0 else 0
            req['priority'] = self.ratio_to_priority(req['value_effort_ratio'])
            
            prioritized.append(req)
        
        # 按价值工作量比排序
        prioritized.sort(key=lambda x: x['value_effort_ratio'], reverse=True)
        
        return prioritized
    
    def estimate_value(self, requirement):
        """估算价值"""
        # 基于业务价值、风险降低
        return requirement.get('business_value', 3)
    
    def estimate_effort(self, requirement):
        """估算工作量"""
        # 基于实现复杂度
        return requirement.get('effort_estimate', 5)
    
    def ratio_to_priority(self, ratio):
        """比率转优先级"""
        if ratio >= 2:
            return 'P0'
        elif ratio >= 1:
            return 'P1'
        elif ratio >= 0.5:
            return 'P2'
        else:
            return 'P3'
```

---

## 需求规格说明

### 需求文档结构

> ▎ 需求文档不是写文章，是建契约。契约不严谨，交付就是扯皮的。

**需求规格说明书 (SRS) 结构**：
```
1. 引言
   ├── 1.1 目的
   ├── 1.2 范围
   ├── 1.3 定义和缩略语
   ├── 1.4 参考文献
   └── 1.5 文档结构

2. 总体描述
   ├── 2.1 产品视角
   ├── 2.2 产品功能
   ├── 2.3 用户特征
   ├── 2.4 约束
   └── 2.5 假设和依赖

3. 安全需求
   ├── 3.1 认证需求
   ├── 3.2 授权需求
   ├── 3.3 审计需求
   ├── 3.4 数据保护需求
   ├── 3.5 通信安全需求
   └── 3.6 合规需求

4. 接口需求
   ├── 4.1 用户接口
   ├── 4.2 硬件接口
   ├── 4.3 软件接口
   └── 4.4 通信接口

5. 非功能需求
   ├── 5.1 性能需求
   ├── 5.2 安全属性
   ├── 5.3 可靠性
   └── 5.4 可维护性

6. 附录
   ├── 6.1 需求跟踪矩阵
   ├── 6.2 术语表
   └── 6.3 索引
```

### 需求模板

**需求规格模板**：
```python
# 需求规格模板
class RequirementTemplate:
    @staticmethod
    def create_requirement(req_data):
        """创建标准化需求"""
        return {
            # 基本信息
            'id': req_data.get('id', 'REQ-XXX'),
            'version': req_data.get('version', '1.0'),
            'status': req_data.get('status', 'draft'),
            
            # 需求描述
            'title': req_data.get('title', ''),
            'description': req_data.get('description', ''),
            'rationale': req_data.get('rationale', ''),
            
            # 分类
            'category': req_data.get('category', ''),
            'subcategory': req_data.get('subcategory', ''),
            'security_attribute': req_data.get('security_attribute', ''),
            
            # 优先级
            'priority': req_data.get('priority', 'P2'),
            'risk_score': req_data.get('risk_score', 0),
            
            # 来源
            'source': req_data.get('source', ''),
            'source_document': req_data.get('source_document', ''),
            'stakeholders': req_data.get('stakeholders', []),
            
            # 验收标准
            'acceptance_criteria': req_data.get('acceptance_criteria', []),
            
            # 测试
            'test_method': req_data.get('test_method', 'manual'),
            'test_cases': req_data.get('test_cases', []),
            
            # 依赖
            'dependencies': req_data.get('dependencies', []),
            'constraints': req_data.get('constraints', []),
            
            # 跟踪
            'design_element': req_data.get('design_element', ''),
            'implementation': req_data.get('implementation', ''),
            'test_result': req_data.get('test_result', ''),
            
            # 变更历史
            'change_history': req_data.get('change_history', [])
        }
    
    @staticmethod
    def validate_requirement(req):
        """验证需求质量"""
        issues = []
        
        # 必填字段检查
        required_fields = ['id', 'title', 'description', 'priority', 'acceptance_criteria']
        for field in required_fields:
            if field not in req or not req[field]:
                issues.append(f"Missing required field: {field}")
        
        # 描述质量检查
        if 'description' in req:
            desc = req['description']
            if len(desc) < 10:
                issues.append("Description too short")
            if '应该' in desc or '可能' in desc:
                issues.append("Description contains ambiguous terms")
        
        # 验收标准检查
        if 'acceptance_criteria' in req:
            if len(req['acceptance_criteria']) == 0:
                issues.append("No acceptance criteria defined")
            for criterion in req['acceptance_criteria']:
                if not criterion.startswith('系统'):
                    issues.append(f"Criterion should start with '系统': {criterion}")
        
        # 优先级检查
        if 'priority' in req:
            if req['priority'] not in ['P0', 'P1', 'P2', 'P3']:
                issues.append("Invalid priority value")
        
        return {
            'valid': len(issues) == 0,
            'issues': issues
        }
```

---

## 需求验证确认

### 验证技术

> ▎ 需求验证不是走过场，是保质量。质量不保证，交付就是灾难的。

**验证方法**：
```python
# 需求验证
class RequirementValidation:
    def __init__(self):
        self.validation_methods = {
            'review': self.requirement_review,
            'walkthrough': self.requirement_walkthrough,
            'inspection': self.requirement_inspection,
            'prototype': self.prototype_validation
        }
    
    def validate(self, requirements, method='review'):
        """验证需求"""
        if method not in self.validation_methods:
            raise ValueError(f"Unknown method: {method}")
        
        return self.validation_methods[method](requirements)
    
    def requirement_review(self, requirements):
        """需求评审"""
        review_results = {
            'participants': ['安全团队', '开发团队', '测试团队', '业务方'],
            'findings': [],
            'approved': False
        }
        
        # 检查清单
        checklist = [
            '需求是否清晰无歧义',
            '需求是否可测试',
            '需求是否可追溯',
            '需求是否完整',
            '需求是否一致',
            '优先级是否合理',
            '验收标准是否明确'
        ]
        
        for req in requirements:
            req_review = self.review_single_requirement(req, checklist)
            review_results['findings'].append(req_review)
        
        # 审批决策
        critical_issues = [f for f in review_results['findings'] 
                          if f.get('severity') == 'critical']
        review_results['approved'] = len(critical_issues) == 0
        
        return review_results
    
    def review_single_requirement(self, requirement, checklist):
        """评审单个需求"""
        findings = {
            'requirement_id': requirement.get('id'),
            'issues': [],
            'severity': 'low'
        }
        
        # 逐项检查
        for item in checklist:
            issue = self.check_item(requirement, item)
            if issue:
                findings['issues'].append(issue)
                if issue['severity'] == 'critical':
                    findings['severity'] = 'critical'
        
        return findings
    
    def check_item(self, requirement, item):
        """检查项目"""
        # 简化实现
        # 实际需要根据检查项具体分析
        
        if '清晰' in item:
            if len(requirement.get('description', '')) < 20:
                return {
                    'item': item,
                    'severity': 'high',
                    'finding': '需求描述过于简短，可能不清晰'
                }
        
        if '可测试' in item:
            if not requirement.get('acceptance_criteria'):
                return {
                    'item': item,
                    'severity': 'critical',
                    'finding': '没有验收标准，无法测试'
                }
        
        if '完整' in item:
            required_fields = ['description', 'priority', 'source']
            missing = [f for f in required_fields if f not in requirement]
            if missing:
                return {
                    'item': item,
                    'severity': 'high',
                    'finding': f'缺少必要字段：{missing}'
                }
        
        return None
    
    def requirement_walkthrough(self, requirements):
        """需求走查"""
        # 逐步讲解需求，收集反馈
        walkthrough_results = {
            'session_date': '',
            'participants': [],
            'feedback': [],
            'action_items': []
        }
        
        for req in requirements:
            # 讲解需求
            explanation = self.explain_requirement(req)
            
            # 收集反馈
            feedback = self.collect_feedback(req, explanation)
            walkthrough_results['feedback'].append(feedback)
            
            # 记录行动项
            if feedback.get('needs_revision'):
                walkthrough_results['action_items'].append({
                    'requirement_id': req.get('id'),
                    'action': '修订需求',
                    'owner': '需求分析师',
                    'deadline': '1 周'
                })
        
        return walkthrough_results
    
    def requirement_inspection(self, requirements):
        """需求检查"""
        # 正式检查流程
        inspection_results = {
            'inspector': '独立检查员',
            'defects': [],
            'defect_density': 0,
            'recommendation': ''
        }
        
        total_defects = 0
        for req in requirements:
            defects = self.inspect_requirement(req)
            inspection_results['defects'].extend(defects)
            total_defects += len(defects)
        
        inspection_results['defect_density'] = total_defects / len(requirements)
        
        if inspection_results['defect_density'] > 2:
            inspection_results['recommendation'] = '需要重大修订后重新检查'
        elif inspection_results['defect_density'] > 1:
            inspection_results['recommendation'] = '需要修订后复审'
        else:
            inspection_results['recommendation'] = '可以通过'
        
        return inspection_results
    
    def prototype_validation(self, requirements):
        """原型验证"""
        # 通过原型验证需求可行性
        validation_results = {
            'prototype_version': '1.0',
            'validated_requirements': [],
            'issues_found': [],
            'recommendations': []
        }
        
        for req in requirements:
            # 检查需求是否可通过原型验证
            if req.get('test_method') in ['manual', 'both']:
                validation = self.validate_with_prototype(req)
                validation_results['validated_requirements'].append(validation)
        
        return validation_results
    
    def explain_requirement(self, requirement):
        """讲解需求"""
        return f"需求{requirement.get('id')}: {requirement.get('description')}"
    
    def collect_feedback(self, requirement, explanation):
        """收集反馈"""
        # 简化实现
        return {
            'requirement_id': requirement.get('id'),
            'feedback': '需要更详细的验收标准',
            'needs_revision': True
        }
    
    def inspect_requirement(self, requirement):
        """检查需求"""
        defects = []
        
        # 检查常见缺陷
        if '和' in requirement.get('description', ''):
            defects.append({
                'type': '复合需求',
                'severity': 'medium',
                'description': '需求包含多个方面，建议分解'
            })
        
        if not requirement.get('acceptance_criteria'):
            defects.append({
                'type': '缺少验收标准',
                'severity': 'high',
                'description': '需求没有验收标准'
            })
        
        return defects
    
    def validate_with_prototype(self, requirement):
        """通过原型验证"""
        return {
            'requirement_id': requirement.get('id'),
            'prototype_test': '通过',
            'issues': [],
            'notes': ''
        }
```

---

## 实战案例演练

### 电商平台安全需求

**案例背景**：
```
系统：B2C 电商平台
用户：消费者、商家、管理员
数据：用户信息、订单数据、支付信息
合规：GDPR、PCI DSS、网络安全法
```

**需求规格示例**：
```python
# 电商平台安全需求规格
ecommerce_security_requirements = {
    'project': 'B2C 电商平台',
    'version': '1.0',
    'date': '2024-01-15',
    'requirements': [
        {
            'id': 'SEC-AUTH-001',
            'title': '用户认证',
            'category': '认证',
            'description': '系统必须支持用户注册和登录功能，实施强密码策略和多因素认证',
            'rationale': '防止未授权访问，保护用户账户安全',
            'priority': 'P0',
            'source': '安全策略、PCI DSS',
            'acceptance_criteria': [
                '系统拒绝少于 12 位的密码',
                '密码必须包含大小写字母、数字、特殊字符',
                '管理员登录必须使用 MFA',
                '连续 5 次失败登录后账户锁定 15 分钟'
            ],
            'test_method': 'automated',
            'compliance': ['PCI DSS 8.2', '等保 2.0']
        },
        {
            'id': 'SEC-AUTHZ-001',
            'title': '访问控制',
            'category': '授权',
            'description': '系统必须实施基于角色的访问控制，用户只能访问授权的数据和功能',
            'rationale': '防止越权访问，保护数据隐私',
            'priority': 'P0',
            'source': '架构设计、GDPR',
            'acceptance_criteria': [
                '用户 A 不能访问用户 B 的订单数据',
                '商家只能管理自己的商品',
                '管理员操作需要额外授权',
                '所有越权访问尝试被拒绝并记录'
            ],
            'test_method': 'manual',
            'compliance': ['GDPR Art.32', '等保 2.0']
        },
        {
            'id': 'SEC-DATA-001',
            'title': '数据加密',
            'category': '数据保护',
            'description': '敏感数据必须加密存储和传输',
            'rationale': '防止数据泄露，满足合规要求',
            'priority': 'P0',
            'source': '合规要求、PCI DSS',
            'acceptance_criteria': [
                '支付信息使用 AES-256 加密存储',
                '所有通信使用 TLS 1.2+ 加密',
                '数据库连接使用加密',
                '密钥使用 HSM 或 KMS 管理'
            ],
            'test_method': 'both',
            'compliance': ['PCI DSS 3.4', 'GDPR Art.32']
        },
        {
            'id': 'SEC-AUDIT-001',
            'title': '安全审计',
            'category': '审计',
            'description': '系统必须记录所有安全相关事件',
            'rationale': '支持安全事件调查，满足合规要求',
            'priority': 'P0',
            'source': '合规要求',
            'acceptance_criteria': [
                '记录所有登录成功/失败事件',
                '记录所有权限变更事件',
                '记录所有敏感数据访问',
                '日志保留至少 180 天',
                '日志防篡改保护'
            ],
            'test_method': 'automated',
            'compliance': ['等保 2.0', 'PCI DSS 10']
        },
        {
            'id': 'SEC-PRIV-001',
            'title': '隐私保护',
            'category': '隐私',
            'description': '系统必须保护用户隐私，实现 GDPR 要求的用户权利',
            'rationale': '满足 GDPR 合规，保护用户隐私',
            'priority': 'P0',
            'source': 'GDPR',
            'acceptance_criteria': [
                '用户可访问自己的数据',
                '用户可更正自己的数据',
                '用户可删除自己的数据 (被遗忘权)',
                '用户可导出自己的数据 (可携带权)',
                '用户可撤回同意'
            ],
            'test_method': 'manual',
            'compliance': ['GDPR Art.15-22']
        }
    ]
}
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ██████████ 5/5 │ 生产就绪       │
└───────────────┴────────────────┴────────────────┘
综合：4.5
```
▎ 这才配得上 P8。安全需求不是文档工作，是风险管理。管理不到位，风险就是隐藏的。

---

## 总结与思考

### 核心要点回顾

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

**安全需求框架**：
```
1. 需求获取
   - 利益相关者分析
   - 访谈问卷
   - 文档分析

2. 需求分析
   - 需求分类
   - 需求细化
   - 优先级排序

3. 需求规格
   - 标准化模板
   - 验收标准
   - 测试方法

4. 需求验证
   - 评审检查
   - 原型验证
   - 利益相关者确认

5. 需求管理
   - 需求跟踪
   - 变更管理
   - 状态监控
```

**关键成功因素**：
```
1. 利益相关者参与
   - 早期参与
   - 持续沟通
   - 共识建立

2. 需求质量
   - 清晰明确
   - 可测试
   - 可追溯

3. 流程规范
   - 标准模板
   - 评审流程
   - 变更控制
```

### 深入思考问题

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

**需求工程挑战**：
```
1. 需求模糊
   - 业务方表达不清
   - 安全术语专业
   - 解决：翻译 + 示例

2. 需求变更
   - 业务变化快
   - 威胁演变快
   - 解决：敏捷 + 迭代

3. 需求冲突
   - 安全 vs 便利
   - 功能 vs 安全
   - 解决：权衡 + 优先级
```

### 实战建议

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

**入门建议**：
```
1. 使用模板
   - 标准需求模板
   - 验收标准模板
   - 降低门槛

2. 从小开始
   - 关键需求先行
   - 逐步完善
   - 快速见效

3. 建立库
   - 需求模式库
   - 最佳实践库
   - 提高效率
```

**进阶建议**：
```
1. 自动化
   - 需求管理工具
   - 自动化验证
   - 持续跟踪

2. 度量改进
   - 需求质量度量
   - 变更频率分析
   - 持续改进

3. 能力建设
   - 需求分析师培养
   - 团队能力提升
   - 组织级能力
```

---

## 参考资料

### 学习资源
```
- IEEE 29148 (Requirements Engineering)
  https://www.ieee.org/

- NIST SP 800-160 (Systems Security Engineering)
  https://csrc.nist.gov/publications/detail/sp/800-160

- OWASP Security Requirements
  https://owasp.org/www-project-security-requirements/
```

### 工具资源
```
- Jira (需求管理)
  https://www.atlassian.com/software/jira

- Confluence (需求文档)
  https://www.atlassian.com/software/confluence

- Doors (企业级需求管理)
  https://www.ibm.com/products/doors
```

### 标准规范
```
- ISO/IEC/IEEE 29148 (Requirements Engineering)
- NIST SP 800-160 Vol.1 (Systems Security Engineering)
```

### 书籍推荐
```
- 《Software Requirements》
- 《Mastering the Requirements Process》
- 《Security Requirements Engineering》
```

---

**标记 明日预告**：Day 144 - 安全架构设计

> ▎ 安全需求是输入，安全架构是输出——明天看安全架构设计。

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

---

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

*应用安全核心系列继续！*