Python cryptography实战：给你的Flask/Django应用API请求加个“数字签名”验签功能

Python Cryptography实战：为Flask/Django API构建数字签名验签系统

在当今的Web服务开发中，API安全已成为不可忽视的关键环节。想象一下，当你的支付回调接口收到一笔交易通知，如何确保这个请求确实来自合法的支付平台，而非恶意攻击者伪造？当用户提交重要数据时，如何验证数据在传输过程中未被篡改？这正是数字签名技术大显身手的场景。

数字签名不同于加密，它专注于验证数据的完整性和来源真实性。典型的应用场景包括：

• 支付系统回调验证
• 跨服务API通信认证
• 敏感数据提交保护
• 微服务间安全交互

本文将基于Python的cryptography库，手把手教你实现一套完整的签名验签系统，可直接集成到Flask、Django或FastAPI等主流Web框架中。我们不会停留在理论层面，而是聚焦于实际开发中的最佳实践和常见陷阱。

1. 密码学基础与密钥管理

1.1 RSA密钥对生成

现代Web应用通常采用非对称加密体系，其中RSA算法是最常用的选择之一。让我们从生成安全的密钥对开始：

from cryptography.hazmat.primitives.asymmetric import rsa from cryptography.hazmat.primitives import serialization def generate_key_pair(key_size=2048): private_key = rsa.generate_private_key( public_exponent=65537, key_size=key_size ) public_key = private_key.public_key() return private_key, public_key

关键参数说明：

1.2 密钥存储最佳实践

生成的密钥需要安全存储，以下是PEM格式的序列化示例：

def save_key_to_file(key, filename, is_private=True, password=None): if is_private: encryption = serialization.NoEncryption() if password: encryption = serialization.BestAvailableEncryption(password) key_bytes = key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=encryption ) else: key_bytes = key.public_bytes( encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo ) with open(filename, 'wb') as f: f.write(key_bytes)

安全提示：生产环境中私钥应加密存储，并严格控制访问权限

2. 签名生成机制实现

2.1 请求数据规范化

签名前必须规范数据格式，避免因序列化差异导致验证失败：

import json from urllib.parse import urlencode def normalize_data(data): if isinstance(data, dict): # 按字母序排序键，确保一致性 sorted_data = sorted(data.items(), key=lambda x: x[0]) return urlencode(sorted_data).encode('utf-8') elif isinstance(data, str): return data.encode('utf-8') return data

2.2 签名生成核心逻辑

使用PSS填充方案和SHA-256哈希算法创建签名：

from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.asymmetric import padding def generate_signature(private_key, data): normalized_data = normalize_data(data) signature = private_key.sign( normalized_data, padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) return signature

签名流程关键点：

1. 数据规范化处理
2. 选择适当的填充方案
3. 使用强哈希算法
4. 处理二进制数据

3. 签名验证系统设计

3.1 HTTP请求签名验证

典型实现会检查Authorization头中的签名：

from flask import request, jsonify from cryptography.exceptions import InvalidSignature def verify_request(public_key): try: signature = request.headers.get('X-Signature') if not signature: return False # 获取所有请求参数 if request.method == 'GET': data = request.args else: data = request.get_json() or {} # 验证签名 public_key.verify( bytes.fromhex(signature), normalize_data(data), padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) return True except InvalidSignature: return False

3.2 Django中间件实现

对于Django项目，可以创建可复用的中间件：

from django.http import HttpResponseForbidden from cryptography.exceptions import InvalidSignature class SignatureMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): if not self._verify_signature(request): return HttpResponseForbidden("Invalid signature") return self.get_response(request) def _verify_signature(self, request): public_key = get_public_key() # 实现密钥获取逻辑 signature = request.META.get('HTTP_X_SIGNATURE') if not signature: return False try: data = self._extract_request_data(request) public_key.verify( bytes.fromhex(signature), normalize_data(data), padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) return True except InvalidSignature: return False

4. 生产环境进阶实践

4.1 性能优化策略

高频API需要考虑签名验证的性能影响：

• 签名缓存：对相同请求内容缓存验证结果
• 密钥轮换：定期更新密钥对而不中断服务
• 批量验证：对批量请求优化验证流程

from functools import lru_cache @lru_cache(maxsize=1024) def cached_verify(public_key, data, signature): try: public_key.verify( signature, normalize_data(data), padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) return True except InvalidSignature: return False

4.2 密钥轮换方案

安全密钥管理需要支持无缝轮换：

from datetime import datetime, timedelta class KeyManager: def __init__(self): self.keys = {} self.current_key_id = None self._generate_initial_keys() def _generate_initial_keys(self): priv, pub = generate_key_pair() key_id = datetime.now().strftime("%Y%m%d%H") self.keys[key_id] = {'private': priv, 'public': pub} self.current_key_id = key_id def rotate_keys(self): new_priv, new_pub = generate_key_pair() new_key_id = datetime.now().strftime("%Y%m%d%H") self.keys[new_key_id] = {'private': new_priv, 'public': new_pub} # 保留旧密钥一段时间用于过渡 self.current_key_id = new_key_id self._cleanup_old_keys() def get_current_public_key(self): return self.keys[self.current_key_id]['public'] def _cleanup_old_keys(self): expiry = datetime.now() - timedelta(days=7) for key_id in list(self.keys.keys()): key_date = datetime.strptime(key_id[:8], "%Y%m%d") if key_date < expiry: del self.keys[key_id]

4.3 错误处理与日志

完善的错误处理能快速定位问题：

import logging from flask import jsonify logger = logging.getLogger('api.security') @app.errorhandler(InvalidSignature) def handle_invalid_signature(e): logger.warning(f"Invalid signature attempt from {request.remote_addr}") return jsonify({"error": "Invalid signature"}), 403 @app.errorhandler(Exception) def handle_crypto_errors(e): logger.error(f"Crypto error: {str(e)}", exc_info=True) return jsonify({"error": "Security verification failed"}), 500

5. 测试与验证策略

5.1 单元测试设计

确保签名验证逻辑可靠：

import unittest from cryptography.hazmat.primitives.asymmetric import rsa class TestSignatureVerification(unittest.TestCase): def setUp(self): self.private_key, self.public_key = generate_key_pair() self.test_data = {"amount": 100, "currency": "USD"} def test_valid_signature(self): signature = generate_signature(self.private_key, self.test_data) try: self.public_key.verify( signature, normalize_data(self.test_data), padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) except InvalidSignature: self.fail("Valid signature failed verification") def test_tampered_data(self): signature = generate_signature(self.private_key, self.test_data) tampered_data = self.test_data.copy() tampered_data["amount"] = 999 with self.assertRaises(InvalidSignature): self.public_key.verify( signature, normalize_data(tampered_data), padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() )

5.2 性能基准测试

评估不同密钥长度的影响：

import timeit def benchmark_sign_verify(key_size): priv, pub = generate_key_pair(key_size) data = b"test_data" * 100 def sign_verify(): sig = priv.sign( data, padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) pub.verify( sig, data, padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) return timeit.timeit(sign_verify, number=100) # 测试不同密钥尺寸 for size in [2048, 3072, 4096]: elapsed = benchmark_sign_verify(size) print(f"Key size {size}: {elapsed:.3f} seconds for 100 ops")

典型测试结果对比：

在实际项目中，我们通常选择2048位密钥作为安全性和性能的平衡点，除非有特殊合规要求才会考虑更长的密钥。