Day-114-错误处理安全

# Day 111: 错误处理安全

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

---

## 清单 目录

1. [错误处理概述](#错误处理概述)
2. [错误处理原则](#错误处理原则)
3. [错误信息控制](#错误信息控制)
4. [统一错误处理](#统一错误处理)
5. [日志记录安全](#日志记录安全)
6. [异常处理框架](#异常处理框架)
7. [框架错误处理](#框架错误处理)
8. [实战案例分析](#实战案例分析)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## 错误处理概述

### 为什么需要安全错误处理

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

**错误处理重要性**：
```
1. 信息泄露预防
   - 不显示堆栈跟踪
   - 不显示 SQL 语句
   - 不显示系统信息
   - 不显示路径信息

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

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

**错误处理原则**：
```
1. 不泄露敏感信息
   - 通用错误消息
   - 技术细节隐藏
   - 系统信息隐藏

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

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

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

---

## 错误处理原则

### 不泄露敏感信息

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

**敏感信息类型**：
```
1. 系统信息
   - 操作系统版本
   - 服务器软件
   - 路径信息
   - 配置信息

2. 数据库信息
   - SQL 语句
   - 表结构
   - 字段信息
   - 连接信息

3. 用户信息
   - 用户凭证
   - 会话信息
   - 个人信息
   - 敏感数据
```

**错误信息控制**：
```python
# 不安全错误处理
try:
    query = f"SELECT * FROM users WHERE id = {user_id}"
    cursor.execute(query)
except Exception as e:
    return f"Error: {str(e)}"  # 泄露 SQL 语句

# 安全错误处理
try:
    cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
except Exception as e:
    logger.error(f"Database error: {e}", exc_info=True)
    return "An error occurred. Please try again."
```

### 统一错误处理

**统一错误处理**：
```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
```

---

## 错误信息控制

### 错误信息分类

**错误信息分类**：
```
1. 技术错误
   - 数据库错误
   - 网络错误
   - 系统错误

2. 业务错误
   - 验证错误
   - 权限错误
   - 业务逻辑错误

3. 用户错误
   - 输入错误
   - 操作错误
   - 权限不足
```

### 错误信息处理

**错误信息处理**：
```python
import logging

logger = logging.getLogger(__name__)

# 数据库错误处理
def handle_database_error(e):
    # 记录详细错误
    logger.error(f"Database error: {e}", exc_info=True)
    
    # 返回用户友好错误
    return {
        'error': 'DATABASE_ERROR',
        'message': 'Database error occurred. Please try again later.'
    }, 500

# 网络错误处理
def handle_network_error(e):
    # 记录详细错误
    logger.error(f"Network error: {e}", exc_info=True)
    
    # 返回用户友好错误
    return {
        'error': 'NETWORK_ERROR',
        'message': 'Network error occurred. Please try again later.'
    }, 500

# 通用错误处理
def handle_generic_error(e):
    # 记录详细错误
    logger.error(f"Unexpected error: {e}", exc_info=True)
    
    # 返回用户友好错误
    return {
        'error': 'INTERNAL_ERROR',
        'message': 'An unexpected error occurred. Please try again later.'
    }, 500
```

---

## 统一错误处理

### 错误处理中间件

**错误处理中间件**：
```python
from functools import wraps
from flask import jsonify
import logging

logger = logging.getLogger(__name__)

def handle_errors(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        try:
            return f(*args, **kwargs)
        except ValueError as e:
            logger.warning(f"Validation error: {e}")
            return jsonify({
                'error': 'VALIDATION_ERROR',
                'message': str(e)
            }), 400
        except PermissionError as e:
            logger.warning(f"Permission error: {e}")
            return jsonify({
                'error': 'PERMISSION_ERROR',
                'message': 'Access denied'
            }), 403
        except Exception as e:
            logger.error(f"Unexpected error: {e}", exc_info=True)
            return jsonify({
                'error': 'INTERNAL_ERROR',
                'message': 'An error occurred'
            }), 500
    return wrapper

# 使用示例
@app.route('/api/users/<user_id>')
@handle_errors
def get_user(user_id):
    user = get_user_by_id(user_id)
    if not user:
        raise ValueError('User not found')
    return jsonify(user.to_dict())
```

### 错误代码规范

**错误代码规范**：
```python
# 错误代码定义
class ErrorCode:
    # 客户端错误 (4xx)
    VALIDATION_ERROR = 'VALIDATION_ERROR'
    PERMISSION_ERROR = 'PERMISSION_ERROR'
    NOT_FOUND_ERROR = 'NOT_FOUND_ERROR'
    
    # 服务器错误 (5xx)
    DATABASE_ERROR = 'DATABASE_ERROR'
    NETWORK_ERROR = 'NETWORK_ERROR'
    INTERNAL_ERROR = 'INTERNAL_ERROR'

# 错误响应
def error_response(error_code, message, status_code):
    return {
        'error': error_code,
        'message': message,
        'timestamp': datetime.utcnow().isoformat()
    }, status_code
```

---

## 日志记录安全

### 日志记录原则

**日志记录原则**：
```
1. 记录详细错误
   - 错误类型
   - 错误时间
   - 错误位置
   - 错误堆栈

2. 不记录敏感信息
   - 不记录密码
   - 不记录令牌
   - 不记录个人信息
   - 不记录敏感数据

3. 安全日志存储
   - 日志加密
   - 访问控制
   - 日志完整性
   - 日志保留策略
```

### 安全日志实现

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

# 配置安全日志
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)

# 敏感信息过滤
class SensitiveFilter(logging.Filter):
    SENSITIVE_PATTERNS = [
        r'password=\S+',
        r'token=\S+',
        r'password":\s*"[^"]*"',
        r'token":\s*"[^"]*"'
    ]
    
    def filter(self, record):
        message = record.getMessage()
        for pattern in self.SENSITIVE_PATTERNS:
            message = re.sub(pattern, '[REDACTED]', message)
        record.msg = message
        return True

# 添加过滤器
handler.addFilter(SensitiveFilter())

# 记录安全事件
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
from functools import wraps
from flask import jsonify, request
import logging
import traceback

logger = logging.getLogger(__name__)

class APIError(Exception):
    def __init__(self, error_code, message, status_code=400):
        self.error_code = error_code
        self.message = message
        self.status_code = status_code
        super().__init__(message)

class ValidationError(APIError):
    def __init__(self, message):
        super().__init__('VALIDATION_ERROR', message, 400)

class PermissionError(APIError):
    def __init__(self, message):
        super().__init__('PERMISSION_ERROR', message, 403)

class NotFoundError(APIError):
    def __init__(self, message):
        super().__init__('NOT_FOUND_ERROR', message, 404)

# 异常处理装饰器
def handle_api_errors(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        try:
            return f(*args, **kwargs)
        except APIError as e:
            logger.warning(f"API error: {e.error_code} - {e.message}")
            return jsonify({
                'error': e.error_code,
                'message': e.message
            }), e.status_code
        except Exception as e:
            logger.error(f"Unexpected error: {e}", exc_info=True)
            return jsonify({
                'error': 'INTERNAL_ERROR',
                'message': 'An error occurred'
            }), 500
    return wrapper

# 使用示例
@app.route('/api/users/<user_id>')
@handle_api_errors
def get_user(user_id):
    user = get_user_by_id(user_id)
    if not user:
        raise NotFoundError('User not found')
    return jsonify(user.to_dict())
```

---

## 框架错误处理

### Django 错误处理

**Django 错误处理**：
```python
from django.http import JsonResponse
from django.core.exceptions import ValidationError, PermissionDenied
from django.http import Http404
import logging

logger = logging.getLogger(__name__)

# 全局异常处理
def custom_exception_handler(request, exception):
    if isinstance(exception, ValidationError):
        logger.warning(f"Validation error: {exception}")
        return JsonResponse({
            'error': 'VALIDATION_ERROR',
            'message': str(exception)
        }, status=400)
    
    if isinstance(exception, PermissionDenied):
        logger.warning(f"Permission error: {exception}")
        return JsonResponse({
            'error': 'PERMISSION_ERROR',
            'message': 'Access denied'
        }, status=403)
    
    if isinstance(exception, Http404):
        return JsonResponse({
            'error': 'NOT_FOUND_ERROR',
            'message': 'Resource not found'
        }, status=404)
    
    # 记录详细错误
    logger.error(f"Unexpected error: {exception}", exc_info=True)
    return JsonResponse({
        'error': 'INTERNAL_ERROR',
        'message': 'An error occurred'
    }, status=500)

# 配置
# settings.py
HANDLER400 = 'myapp.views.custom_exception_handler'
HANDLER403 = 'myapp.views.custom_exception_handler'
HANDLER404 = 'myapp.views.custom_exception_handler'
HANDLER500 = 'myapp.views.custom_exception_handler'
```

### Spring 错误处理

**Spring 错误处理**：
```java
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(
        GlobalExceptionHandler.class
    );
    
    @ExceptionHandler(ValidationException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public ResponseEntity<ErrorResponse> handleValidationException(
        ValidationException e
    ) {
        logger.warn("Validation error", e);
        
        ErrorResponse error = new ErrorResponse(
            "VALIDATION_ERROR",
            e.getMessage()
        );
        return ResponseEntity.status(400).body(error);
    }
    
    @ExceptionHandler(PermissionException.class)
    @ResponseStatus(HttpStatus.FORBIDDEN)
    public ResponseEntity<ErrorResponse> handlePermissionException(
        PermissionException e
    ) {
        logger.warn("Permission error", e);
        
        ErrorResponse error = new ErrorResponse(
            "PERMISSION_ERROR",
            "Access denied"
        );
        return ResponseEntity.status(403).body(error);
    }
    
    @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 error occurred"
        );
        return ResponseEntity.status(500).body(error);
    }
}

// 错误响应
@Data
@AllArgsConstructor
public class ErrorResponse {
    private String error;
    private String message;
    private String timestamp;
}
```

---

## 实战案例分析

### 案例 1: SQL 注入错误泄露

**漏洞代码**：
```python
# 不安全错误处理
@app.route('/user/<user_id>')
def get_user(user_id):
    try:
        query = f"SELECT * FROM users WHERE id = {user_id}"
        cursor.execute(query)
        return cursor.fetchone()
    except Exception as e:
        return f"SQL Error: {str(e)}"  # 泄露 SQL 语句

# 攻击
# GET /user/invalid
# 返回：SQL Error: syntax error in SQL statement "SELECT * FROM users WHERE id = invalid"
```

**安全代码**：
```python
import logging

logger = logging.getLogger(__name__)

@app.route('/user/<user_id>')
def get_user(user_id):
    try:
        # 输入验证
        try:
            user_id = int(user_id)
        except ValueError:
            raise ValueError('Invalid user ID')
        
        # 参数化查询
        cursor.execute(
            "SELECT * FROM users WHERE id = %s",
            (user_id,)
        )
        user = cursor.fetchone()
        
        if not user:
            raise ValueError('User not found')
        
        return jsonify(user.to_dict())
    except ValueError as e:
        logger.warning(f"Validation error: {e}")
        return jsonify({
            'error': 'VALIDATION_ERROR',
            'message': str(e)
        }), 400
    except Exception as e:
        logger.error(f"Database error: {e}", exc_info=True)
        return jsonify({
            'error': 'DATABASE_ERROR',
            'message': 'Database error occurred'
        }), 500
```

### 案例 2: 堆栈跟踪泄露

**漏洞代码**：
```python
# 不安全错误处理
@app.route('/api/data')
def get_data():
    try:
        data = get_data_from_database()
        return jsonify(data)
    except Exception as e:
        return f"Error: {str(e)}\n\n{traceback.format_exc()}"

# 攻击
# 返回完整堆栈跟踪
# 泄露代码路径、文件名、行号
```

**安全代码**：
```python
import logging

logger = logging.getLogger(__name__)

@app.route('/api/data')
def get_data():
    try:
        data = get_data_from_database()
        return jsonify(data)
    except Exception as e:
        # 记录详细错误（服务器日志）
        logger.error(f"Database error: {e}", exc_info=True)
        
        # 返回用户友好错误（用户可见）
        return jsonify({
            'error': 'DATABASE_ERROR',
            'message': 'Database error occurred'
        }), 500
```

---

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

---

## 总结与思考

### 核心要点回顾

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

**错误信息控制**：
```
1. 不泄露敏感信息
   - 不显示堆栈跟踪
   - 不显示 SQL 语句
   - 不显示系统信息
   - 不显示路径信息

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

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

**统一错误处理**：
```
1. 错误处理中间件
   - 装饰器模式
   - 统一处理
   - 分类处理

2. 错误代码规范
   - 错误代码定义
   - 错误响应格式
   - 状态码规范

3. 框架错误处理
   - Django 处理
   - Spring 处理
   - Flask 处理
```

**日志记录安全**：
```
1. 日志记录原则
   - 记录详细错误
   - 不记录敏感信息
   - 安全日志存储

2. 安全日志实现
   - 日志配置
   - 敏感信息过滤
   - 日志轮转

3. 异常处理框架
   - 异常类定义
   - 处理装饰器
   - 统一处理
```

### 深入思考问题

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

**零信任错误处理**：
```
1. 持续验证
   - 每次错误验证
   - 动态处理
   - 动态响应

2. 深度防御
   - 多层处理
   - 多重验证
   - 多重处理

3. 动态处理
   - 基于上下文
   - 实时调整
   - 最小权限
```

**自动化错误处理**：
```
1. 自动处理
   - 自动分类
   - 自动响应
   - 自动记录

2. 自动验证
   - 静态分析
   - 动态分析
   - 模糊测试

3. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化
```

### 实战建议

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

**开发人员**：
```
1. 错误处理
   - 统一错误处理
   - 错误信息控制
   - 日志记录

2. 框架使用
   - 使用框架处理
   - 自动处理
   - 自定义处理

3. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化
```

**安全人员**：
```
1. 安全审计
   - 代码审计
   - 错误审计
   - 日志审计

2. 渗透测试
   - 错误测试
   - 信息泄露测试
   - 日志测试

3. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化
```

**架构师**：
```
1. 错误架构
   - 错误架构
   - 处理架构
   - 日志架构

2. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化

3. 工具链
   - 错误工具
   - 处理工具
   - 日志工具
```

---

## 参考资料

### 学习资源
```
- OWASP Error Handling
  https://cheatsheetseries.owasp.org/cheatsheets/Error_Handling_Cheat_Sheet.html

- OWASP Logging
  https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html

- OWASP Logging Vocabulary
  https://cheatsheetseries.owasp.org/cheatsheets/Logging_Vocabulary_Cheat_Sheet.html
```

### 工具资源
```
- Python Logging
  https://docs.python.org/3/library/logging.html

- Java Logging
  https://docs.oracle.com/javase/8/docs/api/java/util/logging/package-summary.html

- Spring Logging
  https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#logging
```

### 书籍推荐
```
- 《错误处理技术》
- 《Error Handling》
- 《Secure Coding》
```

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

- OWASP Error Handling
  https://owasp.org/www-project-error-handling/

- OWASP Logging
  https://owasp.org/www-project-logging/
```

---

**标记 明日预告**：Day 112 - 会话管理安全

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

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

---

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