Day-111-安全编码规范

# Day 108: 安全编码规范

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

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ 安全编码规范 - Day 108             │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ 收到需求，对齐目标，进入 sprint。安全编码是应用安全的基础——基础不牢，地动山摇。

---

## 清单 目录

1. [安全编码概述](#安全编码概述)
2. [输入验证规范](#输入验证规范)
3. [输出编码规范](#输出编码规范)
4. [错误处理规范](#错误处理规范)
5. [认证授权规范](#认证授权规范)
6. [会话管理规范](#会话管理规范)
7. [数据保护规范](#数据保护规范)
8. [实战案例分析](#实战案例分析)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## 安全编码概述

### 为什么需要安全编码

> ▎ 安全编码不是可选——是必须。不遵循安全编码，就是裸奔。

**安全编码重要性**：
```
1. 漏洞预防
   - 80% 漏洞可通过安全编码避免
   - 修复成本：设计阶段 < 编码阶段 < 测试阶段 < 生产阶段
   - 预防成本远低于修复成本

2. 质量提升
   - 代码质量提升
   - 可维护性提升
   - 可靠性提升

3. 合规要求
   - 行业合规要求
   - 客户安全要求
   - 法律法规要求
```

**安全编码原则**：
```
1. 最小权限
   - 只授予必要权限
   - 按需授权
   - 及时回收

2. 纵深防御
   - 多层防护
   - 冗余控制
   - 故障安全

3. 默认安全
   - 安全默认值
   - 安全配置
   - 安全编码

4. 完全验证
   - 所有输入验证
   - 所有输出编码
   - 所有错误处理
```

### 安全编码标准

**OWASP 安全编码规范**：
```
1. 输入验证
2. 输出编码
3. 认证和会话管理
4. 访问控制
5. 密码学
6. 错误处理和日志
7. 数据安全
8. 通信安全
```

**CERT 安全编码标准**：
```
1. 输入验证 (IDS)
2. 表达式 (EXP)
3. 文件 (FIO)
4. 内存管理 (MEM)
4. 并发 (CON)
5. 错误处理 (ERR)
```

---

## 输入验证规范

### 输入验证原则

> ▎ 所有输入都不可信——这是安全编码的第一原则。

**验证原则**：
```
1. 白名单验证
   - 只允许已知安全的输入
   - 比黑名单更安全
   - 推荐首选

2. 类型检查
   - 验证数据类型
   - 验证数据范围
   - 验证数据格式

3. 长度限制
   - 最大长度限制
   - 最小长度要求
   - 固定长度要求

4. 格式验证
   - 正则表达式
   - 格式规范
   - 结构验证
```

### 输入验证实现

**Python 实现**：
```python
# 白名单验证
ALLOWED_ROLES = ['admin', 'user', 'guest']

def validate_role(role):
    if role not in ALLOWED_ROLES:
        raise ValueError(f'Invalid role: {role}')
    return role

# 类型和范围检查
def validate_user_id(user_id):
    try:
        user_id = int(user_id)
        if not (0 < user_id < 1000000):
            raise ValueError('ID out of range')
        return user_id
    except (ValueError, TypeError):
        raise ValueError('Invalid ID format')

# 格式验证
import re

def validate_email(email):
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    if not re.match(pattern, email):
        raise ValueError('Invalid email format')
    return email

# 长度限制
def validate_username(username):
    if not (3 <= len(username) <= 50):
        raise ValueError('Username must be 3-50 characters')
    return username
```

**Java 实现**：
```java
// 白名单验证
public enum Role {
    ADMIN, USER, GUEST
}

public Role validateRole(String role) {
    return Role.valueOf(role.toUpperCase());
}

// 类型和范围检查
public int validateUserId(String userId) {
    try {
        int id = Integer.parseInt(userId);
        if (id <= 0 || id >= 1000000) {
            throw new IllegalArgumentException("ID out of range");
        }
        return id;
    } catch (NumberFormatException e) {
        throw new IllegalArgumentException("Invalid ID format");
    }
}

// 格式验证
public String validateEmail(String email) {
    String pattern = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
    if (!email.matches(pattern)) {
        throw new IllegalArgumentException("Invalid email format");
    }
    return email;
}
```

### 框架验证

**Django 表单验证**：
```python
from django import forms
from django.core.validators import RegexValidator, MinLengthValidator, MaxLengthValidator

class UserForm(forms.Form):
    username = forms.CharField(
        validators=[
            RegexValidator(r'^[a-zA-Z0-9_]+$', 'Invalid username'),
            MinLengthValidator(3),
            MaxLengthValidator(50)
        ]
    )
    
    email = forms.EmailField(
        validators=[
            MaxLengthValidator(100)
        ]
    )
    
    role = forms.ChoiceField(
        choices=[('admin', 'Admin'), ('user', 'User'), ('guest', 'Guest')]
    )
```

**Spring 验证**：
```java
import javax.validation.constraints.*;

public class UserForm {
    @NotNull
    @Size(min = 3, max = 50)
    @Pattern(regexp = "^[a-zA-Z0-9_]+$")
    private String username;
    
    @NotNull
    @Email
    @Size(max = 100)
    private String email;
    
    @NotNull
    @Pattern(regexp = "^(ADMIN|USER|GUEST)$")
    private String role;
}
```

---

## 输出编码规范

### 输出编码原则

> ▎ 所有输出都编码——这是安全编码的第二原则。

**编码原则**：
```
1. 上下文敏感编码
   - HTML 上下文
   - JavaScript 上下文
   - CSS 上下文
   - URL 上下文
   - 属性上下文

2. 编码时机
   - 输出时编码
   - 不存储编码数据
   - 不重复编码

3. 编码库使用
   - 使用标准库
   - 不使用自定义编码
   - 及时更新编码库
```

### 输出编码实现

**HTML 编码**：
```python
import html

# HTML 实体编码
def html_encode(text):
    return html.escape(text)

# 使用示例
user_input = '<script>alert(1)</script>'
safe_output = html_encode(user_input)
# 输出：&lt;script&gt;alert(1)&lt;/script&gt;
```

**JavaScript 编码**：
```python
import json

# JSON 编码（用于 JavaScript 上下文）
def js_encode(text):
    return json.dumps(text)

# 使用示例
user_input = '</script><script>alert(1)</script>'
safe_output = js_encode(user_input)
# 输出："<\/script><script>alert(1)<\/script>"
```

**URL 编码**：
```python
from urllib.parse import quote

# URL 编码
def url_encode(text):
    return quote(text)

# 使用示例
user_input = 'hello world'
safe_output = url_encode(user_input)
# 输出：hello%20world
```

### 框架编码

**Django 模板**：
```django

{{ user_input }}

{{ user_input|safe }}

{{ user_input|escape }}      {# HTML 编码 #}
{{ user_input|escapejs }}    {# JavaScript 编码 #}
{{ user_input|urlencode }}   {# URL 编码 #}
```

**Jinja2 模板**：
```jinja2
{# 自动编码（默认）#}
{{ user_input }}

{# 不编码（危险，慎用）#}
{{ user_input|safe }}

{# 不同上下文编码 #}
{{ user_input|e }}         {# HTML 编码 #}
{{ user_input|tojson }}    {# JSON 编码 #}
```

**Spring MVC**：
```jsp

<c:out value="${userInput}" />

${userInput}
```

---

## 错误处理规范

### 错误处理原则

> ▎ 错误处理不泄露敏感信息——这是安全编码的第三原则。

**处理原则**：
```
1. 不泄露敏感信息
   - 不显示堆栈跟踪
   - 不显示 SQL 语句
   - 不显示系统信息
   - 不显示路径信息

2. 统一错误处理
   - 统一错误页面
   - 统一错误格式
   - 统一错误代码

3. 日志记录
   - 记录详细错误
   - 不记录敏感信息
   - 安全日志存储

4. 用户友好
   - 友好错误消息
   - 指导用户操作
   - 不暴露技术细节
```

### 错误处理实现

**Python 实现**：
```python
from flask import Flask, jsonify, render_template
import logging

app = Flask(__name__)
logger = logging.getLogger(__name__)

# 全局错误处理
@app.errorhandler(Exception)
def handle_exception(e):
    # 记录详细错误（服务器日志）
    logger.error(f"Unexpected error: {e}", exc_info=True)
    
    # 返回友好错误（用户可见）
    return jsonify({
        'error': 'An unexpected error occurred',
        'message': 'Please try again later'
    }), 500

@app.errorhandler(404)
def handle_404(e):
    return jsonify({
        'error': 'Resource not found'
    }), 404

@app.errorhandler(403)
def handle_403(e):
    return jsonify({
        'error': 'Access denied'
    }), 403

# 数据库错误处理
@app.errorhandler(Exception)
def handle_db_exception(e):
    if 'SQL' in str(type(e)):
        # 不泄露 SQL 细节
        logger.error(f"Database error: {e}", exc_info=True)
        return jsonify({
            'error': 'Database error'
        }), 500
```

**Java 实现**：
```java
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(
        GlobalExceptionHandler.class
    );
    
    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ResponseEntity<ErrorResponse> handleException(Exception e) {
        // 记录详细错误
        logger.error("Unexpected error", e);
        
        // 返回友好错误
        ErrorResponse error = new ErrorResponse(
            "INTERNAL_ERROR",
            "An unexpected error occurred"
        );
        return ResponseEntity.status(500).body(error);
    }
    
    @ExceptionHandler(DataAccessException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ResponseEntity<ErrorResponse> handleDbException(DataAccessException e) {
        // 不泄露 SQL 细节
        logger.error("Database error", e);
        
        ErrorResponse error = new ErrorResponse(
            "DATABASE_ERROR",
            "Database error occurred"
        );
        return ResponseEntity.status(500).body(error);
    }
}
```

### 日志记录规范

**安全日志**：
```python
import logging
from logging.handlers import RotatingFileHandler

# 配置安全日志
logger = logging.getLogger('security')
logger.setLevel(logging.INFO)

# 轮转文件处理器
handler = RotatingFileHandler(
    '/var/log/app/security.log',
    maxBytes=10*1024*1024,  # 10MB
    backupCount=5
)

# 格式化
formatter = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
handler.setFormatter(formatter)
logger.addHandler(handler)

# 记录安全事件
def log_security_event(event_type, user_id, details):
    logger.info(f"Security Event: {event_type}, User: {user_id}, Details: {details}")

# 使用示例
log_security_event('LOGIN_SUCCESS', user.id, f"IP: {request.remote_addr}")
log_security_event('LOGIN_FAILURE', user.id, f"IP: {request.remote_addr}")
```

---

## 认证授权规范

### 认证规范

**密码存储**：
```python
import bcrypt

# 密码哈希
def hash_password(password):
    salt = bcrypt.gensalt(rounds=12)
    hashed = bcrypt.hashpw(password.encode(), salt)
    return hashed.decode()

# 密码验证
def verify_password(password, hashed):
    return bcrypt.checkpw(password.encode(), hashed.encode())

# 使用示例
hashed = hash_password('user_password')
# 存储 hashed 到数据库

# 验证
is_valid = verify_password('user_password', hashed)
```

**多因素认证**：
```python
import pyotp

# 生成 TOTP 密钥
def generate_totp_secret():
    return pyotp.random_base32()

# 验证 TOTP
def verify_totp(secret, code):
    totp = pyotp.TOTP(secret)
    return totp.verify(code)

# 使用示例
secret = generate_totp_secret()
# 存储 secret 到数据库

# 验证
is_valid = verify_totp(secret, '123456')
```

### 授权规范

**基于角色的访问控制（RBAC）**：
```python
from functools import wraps
from flask import abort

def require_role(role):
    def decorator(f):
        @wraps(f)
        def wrapped(*args, **kwargs):
            if not current_user.has_role(role):
                abort(403)
            return f(*args, **kwargs)
        return wrapped
    return decorator

# 使用示例
@app.route('/admin')
@require_role('admin')
def admin_panel():
    return render_template('admin.html')
```

**基于资源的访问控制**：
```python
def can_access_resource(user, resource):
    # 检查资源所有权
    if resource.owner_id == user.id:
        return True
    
    # 检查管理员权限
    if user.is_admin:
        return True
    
    # 检查角色权限
    if user.has_permission('read', resource.type):
        return True
    
    return False

# 使用示例
@app.route('/resources/<resource_id>')
def get_resource(resource_id):
    resource = get_resource_by_id(resource_id)
    
    if not can_access_resource(current_user, resource):
        abort(403)
    
    return jsonify(resource.to_dict())
```

---

## 会话管理规范

### 会话安全

**会话配置**：
```python
from flask import Flask, session

app = Flask(__name__)
app.config.update(
    SECRET_KEY='strong-secret-key',
    SESSION_COOKIE_HTTPONLY=True,      # 防止 XSS 窃取
    SESSION_COOKIE_SECURE=True,        # 仅 HTTPS
    SESSION_COOKIE_SAMESITE='Strict',  # 防止 CSRF
    PERMANENT_SESSION_LIFETIME=1800,   # 30 分钟
    SESSION_REFRESH_EACH_REQUEST=False
)
```

**会话管理**：
```python
from flask import session, request

# 登录时重新生成会话
@app.route('/login', methods=['POST'])
def login():
    if authenticate(request.form['username'], request.form['password']):
        session.regenerate()  # 重新生成会话 ID
        session['user_id'] = get_user_id(request.form['username'])
        return redirect('/dashboard')
    return 'Login failed'

# 登出时清除会话
@app.route('/logout')
def logout():
    session.clear()
    return redirect('/')

# 会话超时检查
@app.before_request
def check_session_timeout():
    if 'user_id' in session:
        last_activity = session.get('last_activity')
        if last_activity and time.time() - last_activity > 1800:
            session.clear()
            return redirect('/login')
        session['last_activity'] = time.time()
```

---

## 数据保护规范

### 数据加密

**敏感数据加密**：
```python
from cryptography.fernet import Fernet

# 生成密钥
def generate_key():
    return Fernet.generate_key()

# 加密数据
def encrypt_data(data, key):
    f = Fernet(key)
    return f.encrypt(data.encode()).decode()

# 解密数据
def decrypt_data(encrypted_data, key):
    f = Fernet(key)
    return f.decrypt(encrypted_data.encode()).decode()

# 使用示例
key = generate_key()
encrypted = encrypt_data('sensitive_data', key)
# 存储 encrypted 到数据库

decrypted = decrypt_data(encrypted, key)
```

### 密钥管理

**密钥存储**：
```python
import os

# 从环境变量读取密钥
def get_encryption_key():
    key = os.environ.get('ENCRYPTION_KEY')
    if not key:
        raise ValueError("Encryption key not configured")
    return key.encode()

# 使用密钥管理服务
def get_key_from_kms(key_id):
    import boto3
    kms = boto3.client('kms')
    response = kms.decrypt(KeyId=key_id)
    return response['Plaintext']
```

---

## 实战案例分析

### 案例 1: SQL 注入

**漏洞代码**：
```python
# 不安全代码
@app.route('/user/<user_id>')
def get_user(user_id):
    query = f"SELECT * FROM users WHERE id = {user_id}"
    cursor.execute(query)
    return cursor.fetchone()

# 攻击
# GET /user/1 OR 1=1
# 返回所有用户
```

**安全代码**：
```python
# 安全代码
@app.route('/user/<user_id>')
def get_user(user_id):
    # 输入验证
    try:
        user_id = int(user_id)
    except ValueError:
        abort(400)
    
    # 参数化查询
    cursor.execute(
        "SELECT * FROM users WHERE id = %s",
        (user_id,)
    )
    return cursor.fetchone()
```

### 案例 2: XSS 攻击

**漏洞代码**：
```python
# 不安全代码
@app.route('/search')
def search():
    query = request.args.get('q', '')
    return f"<h1>Search results for: {query}</h1>"

# 攻击
# GET /search?q=<script>alert(1)</script>
```

**安全代码**：
```python
from markupsafe import escape

@app.route('/search')
def search():
    query = request.args.get('q', '')
    # 输出编码
    safe_query = escape(query)
    return f"<h1>Search results for: {safe_query}</h1>"
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ████████░░ 4/5 │ 有改进空间     │
└───────────────┴────────────────┴────────────────┘
综合：3.75
```
▎ 勉强配得上 P8。别飘——安全编码规范这才刚入门。

---

## 总结与思考

### 核心要点回顾

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

**输入验证**：
```
1. 白名单验证
   - 只允许已知安全
   - 比黑名单安全
   - 首选方案

2. 类型检查
   - 验证数据类型
   - 验证数据范围
   - 验证数据格式

3. 长度限制
   - 最大长度
   - 最小长度
   - 固定长度
```

**输出编码**：
```
1. 上下文敏感
   - HTML 编码
   - JavaScript 编码
   - URL 编码
   - CSS 编码

2. 编码时机
   - 输出时编码
   - 不存储编码
   - 不重复编码

3. 编码库
   - 使用标准库
   - 不使用自定义
   - 及时更新
```

**错误处理**：
```
1. 不泄露信息
   - 不显示堆栈
   - 不显示 SQL
   - 不显示系统信息

2. 统一处理
   - 统一错误页面
   - 统一错误格式
   - 统一错误代码

3. 日志记录
   - 记录详细错误
   - 不记录敏感
   - 安全存储
```

### 深入思考问题

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

**安全左移**：
```
1. 设计阶段
   - 威胁建模
   - 安全设计
   - 安全架构

2. 编码阶段
   - 安全编码
   - 代码审查
   - 静态分析

3. 测试阶段
   - 安全测试
   - 渗透测试
   - 漏洞扫描
```

**自动化安全**：
```
1. SAST
   - 静态分析
   - 代码扫描
   - 漏洞检测

2. DAST
   - 动态分析
   - 渗透测试
   - 漏洞验证

3. 依赖扫描
   - SCA
   - 漏洞数据库
   - 自动修复
```

**DevSecOps**：
```
1. 安全左移
   - 早期介入
   - 持续测试
   - 自动化

2. 安全右移
   - 运行时保护
   - 监控告警
   - 事件响应

3. 持续改进
   - 反馈循环
   - 流程改进
   - 工具更新
```

### 实战建议

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

**开发人员**：
```
1. 安全编码
   - 输入验证
   - 输出编码
   - 错误处理

2. 安全工具
   - SAST
   - DAST
   - 依赖扫描

3. 安全测试
   - 单元测试
   - 集成测试
   - 渗透测试
```

**安全人员**：
```
1. 安全审计
   - 代码审计
   - 架构审计
   - 配置审计

2. 渗透测试
   - 黑盒测试
   - 白盒测试
   - 灰盒测试

3. 事件响应
   - 漏洞响应
   - 事件响应
   - 溯源分析
```

**架构师**：
```
1. 安全设计
   - 威胁建模
   - 安全架构
   - 安全组件

2. 持续改进
   - 安全审查
   - 漏洞管理
   - 安全培训

3. 工具链
   - 安全工具
   - 自动化
   - 监控平台
```

---

## 参考资料

### 学习资源
```
- OWASP Secure Coding Practices
  https://owasp.org/www-project-secure-coding-practices-quick-reference-guide/

- CERT Secure Coding
  https://wiki.sei.cmu.edu/confluence/display/seccode/SEI+CERT+Coding+Standards

- CWE
  https://cwe.mitre.org/
```

### 工具资源
```
- SonarQube
  https://www.sonarqube.org/

- Bandit (Python)
  https://bandit.readthedocs.io/

- SpotBugs (Java)
  https://spotbugs.github.io/
```

### 书籍推荐
```
- 《Secure Coding in C and C++》
- 《Writing Secure Code》
- 《Secure Coding: Principles and Practices》
- 《The Secure Software Development Lifecycle》
```

### 在线资源
```
- OWASP Cheat Sheets
  https://cheatsheetseries.owasp.org/

- CWE Top 25
  https://cwe.mitre.org/top25/

- SANS Top 25
  https://www.sans.org/top25-software-errors/
```

---

**标记 明日预告**：Day 109 - 输入验证技术

> ▎ 今天的内容消化了吗？消化了就继续——明天还有硬仗。

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

---

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