加密通信系统

P2P加密通信系统实践报告

一、实践目的与意义

1.1 实践目的

本实践旨在构建一个基于Web的分布式P2P密码学通信系统，通过自实现和库函数调用两种方式实现多种加密算法，并建立完整的加密通信框架。主要目标包括：

  1. 算法学习与实现：深入理解经典和现代加密算法的数学原理，通过自实现算法掌握其核心机制
  2. 系统架构设计：构建分布式P2P通信架构，实现中心服务器-客户端服务器的通信模式
  3. 加密通信实践：实现端到端加密通信，支持多种加密算法和密钥交换协议
  4. 技术栈整合：整合Python后端、Vue3前端、WebSocket通信等技术栈

1.2 实践意义

  1. 教育价值：通过自实现算法，深入理解密码学原理，提升对加密算法的认知水平
  2. 技术实践：掌握现代Web开发技术栈，包括前后端分离、实时通信、分布式架构等
  3. 安全应用：构建实用的加密通信系统，为实际应用场景提供安全通信解决方案
  4. 创新探索：结合传统密码学算法与现代Web技术，探索加密通信的新应用模式

二、实践环境

2.1 语言环境

  • Python 3.8+：后端主要开发语言，支持异步编程和现代Python特性
  • TypeScript 4.9+：前端类型安全的JavaScript超集
  • JavaScript ES6+：现代JavaScript特性支持

2.2 前端框架使用的库

  • Vue 3.5.18：渐进式JavaScript框架，采用Composition API
  • Element Plus 2.4.4：基于Vue 3的组件库，提供丰富的UI组件
  • Vite 7.0.6：现代化前端构建工具，支持快速热重载
  • Vue Router 4.5.1：Vue.js官方路由管理器
  • Pinia 3.0.3：Vue 3状态管理库
  • Socket.io-client 4.7.4：WebSocket客户端库，支持实时通信
  • Axios 1.6.2：HTTP客户端库，用于API调用
  • Big.js 6.2.1：大数运算库，支持高精度数值计算
  • Bignumber.js 9.1.2：大数运算库，支持任意精度算术

2.3 后端框架使用的库

  • FastAPI 0.104.1：现代、快速的Web框架，支持异步处理
  • Uvicorn 0.24.0：ASGI服务器，支持异步Web应用
  • Python-SocketIO 5.10.0：WebSocket服务器库，支持实时双向通信
  • Pydantic 2.5.0：数据验证和设置管理库
  • Python-multipart 0.0.6：支持文件上传的中间件

2.4 分布式通信框架使用的依赖和库

  • WebSocket：实时双向通信协议，支持低延迟消息传输
  • Socket.io：WebSocket抽象层，提供自动重连、房间管理等功能
  • Asyncio：Python异步编程库，支持并发处理
  • JSON：轻量级数据交换格式，用于消息序列化

2.5 加密算法库

  • Cryptography 41.0.7：Python加密库，提供生产级加密算法
  • PyCryptodome 3.19.0：Python加密库，支持多种加密算法
  • Python-JOSE 3.3.0：JSON Web Token处理库
  • ECDSA 0.18.0：椭圆曲线数字签名算法库
  • GMSSL 3.2.1：国密算法库，支持SM2/SM3/SM4算法
  • GMPY2 2.1.5：高精度数学运算库
  • SymPy 1.12：符号数学库，支持大数运算
  • MPMath 1.3.0：多精度浮点算术库

三、项目组分工

3.1 算法内容（详见项目内algorithm）

3.1.1 自实现算法（design目录）

对称加密算法：

  • Playfair密码：经典多图代替密码，使用5×5字母表进行加密
  • 双置换密码：双重置换加密，通过行和列置换增强安全性
  • RC4流密码：流密码算法，使用伪随机数生成器
  • 元胞自动机（CA）：基于CA的流密码，使用细胞状态演化规则
  • DES：56位分组密码，实现完整的Feistel网络结构
  • AES：128/192/256位分组密码，使用简化的S盒和轮函数

非对称加密算法：

  • RSA：512/1024/2048/3072位公钥密码，支持大数运算和模幂运算
  • ECC：椭圆曲线密码，实现P-256曲线上的点运算
  • ElGamal：离散对数公钥密码，支持加密和数字签名
  • SM2：国密椭圆曲线密码，实现完整的SM2算法规范

哈希算法：

  • MD5：消息摘要算法，实现完整的MD5哈希函数

密钥交换算法：

  • DH密钥交换：经典Diffie-Hellman密钥交换，支持1024/2048位密钥
  • ECDH：椭圆曲线Diffie-Hellman密钥交换，支持多种曲线

3.1.2 库函数调用版本（api目录）

  • AES库：使用cryptography库实现生产级AES加密
  • DES库：使用pycryptodome库实现标准DES算法
  • RSA库：使用cryptography库实现RSA算法
  • ECC库：使用cryptography库实现椭圆曲线密码
  • DH库：使用cryptography库实现DH密钥交换
  • MD5库：使用hashlib库实现MD5哈希

四、系统设计

4.1 算法模块设计

4.1.1 自实现算法设计

RSA算法深度分析：

RSA算法作为最经典的非对称加密算法，其安全性基于大数分解的困难性。在我们的实现中，RSA算法展现了以下特点：

数学原理深度解析：

RSA算法的核心数学原理建立在数论的基础上：

  1. 大数分解问题：给定两个大素数的乘积n=p×q，要分解出p和q在计算上是困难的
  2. 欧拉函数：φ(n) = (p-1)(q-1)，表示小于n且与n互质的正整数个数
  3. 模逆元：对于公钥指数e，存在私钥指数d使得e×d ≡ 1 (mod φ(n))

密钥生成过程：

密钥生成是RSA算法最关键的步骤：

  1. 素数生成：使用Miller-Rabin素性测试生成大素数p和q
  2. 模数计算：n = p × q，这是公钥和私钥的共同模数
  3. 公钥指数选择：通常选择65537作为公钥指数e
  4. 私钥指数计算：使用扩展欧几里得算法计算d = e^(-1) mod φ(n)

明密文格式转换机制：

RSA算法的明密文转换涉及多种数据格式：

  1. 明文处理流程：

    • 输入文本 → UTF-8编码 → 字节数组 → 大整数
    • 确保明文长度不超过密钥长度限制

  2. 密文生成流程：

    • 大整数 → 模幂运算 → 密文大整数 → 十六进制字符串
    • 使用快速模幂算法优化性能

  3. 解密恢复流程：

    • 十六进制字符串 → 大整数 → 模幂运算 → 字节数组 → UTF-8字符串

性能优化策略：

  1. 快速模幂运算：使用二进制方法将O(n)的复杂度降低到O(log n)
  2. 预计算优化：预计算常用公钥指数，减少计算时间
  3. 缓存机制：缓存中间计算结果，避免重复计算

2048位密钥存储的详细实现方法：

Python的大数处理机制为RSA算法提供了强大的支持，以下是2048位密钥存储的详细实现：

Python大数处理机制：

  1. 任意精度整数：Python内置支持任意精度的整数运算，无需担心溢出问题
  2. 内存管理：Python自动管理大数的内存分配和释放
  3. 运算优化：Python对大数运算进行了底层优化，使用Karatsuba算法等高效算法

密钥生成过程详解：

1
2
3
4
5
6
7
8
9
10
11
def _generate_prime(self, bits: int) -> int:
    """生成指定位数的素数"""
    while True:
        # 生成指定位数的随机数
        candidate = random.getrandbits(bits)
        # 确保是奇数
        candidate |= 1
        # 确保位数正确
        if candidate.bit_length() == bits:
            if self._is_prime(candidate):
                return candidate

大数存储格式：

  1. 内存存储：Python将大数存储为字节数组，每个字节包含8位
  2. 字节序：使用大端序（big-endian）存储，便于网络传输
  3. 动态长度：根据数值大小动态调整存储空间

2048位密钥的具体实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def _generate_keys(self):
    """生成RSA密钥对"""
    # 生成两个大素数
    p_bits = self.key_size // 2  # 1024位
    q_bits = self.key_size - p_bits  # 1024位
    
    # 生成1024位素数p和q
    p = self._generate_prime(p_bits)
    q = self._generate_prime(q_bits)
    
    # 计算n = p * q (2048位)
    self.n = p * q
    
    # 计算φ(n) = (p-1)(q-1)
    phi_n = (p - 1) * (q - 1)
    
    # 选择公钥指数e = 65537
    self.e = 65537
    
    # 计算私钥指数d = e^(-1) mod φ(n)
    self.d = self._mod_inverse(self.e, phi_n)

大数转换和存储：

  1. 整数到字节数组：
1
2
# 将大整数转换为字节数组
message_bytes = message_int.to_bytes((message_int.bit_length() + 7) // 8, 'big')
  1. 字节数组到整数：
1
2
# 将字节数组转换为大整数
message_int = int.from_bytes(plaintext.encode('utf-8'), 'big')
  1. 十六进制字符串存储：
1
2
3
4
5
# 密文存储为十六进制字符串
return hex(cipher_int)[2:]

# 从十六进制字符串恢复
cipher_int = int(ciphertext, 16)

内存使用分析：

  • 2048位密钥：需要256字节存储
  • 1024位素数：需要128字节存储
  • 模数n：需要256字节存储
  • 总内存需求：约1KB用于存储完整的密钥对

性能优化实现：

  1. 快速模幂运算：
1
2
3
def _fast_exponentiation(self, base: int, exponent: int, modulus: int) -> int:
    """快速模幂运算 - Python内置优化"""
    return pow(base, exponent, modulus)
  1. 素性测试优化：
1
2
3
4
5
def _is_prime(self, n: int, k: int = 40) -> bool:
    """Miller-Rabin素性测试"""
    # 使用Python内置的pow函数进行模幂运算
    x = pow(a, d, n)
    x = pow(x, 2, n)

实际存储示例：

对于2048位RSA密钥，实际存储格式如下：

1
2
3
4
5
6
7
公钥 (n, e):
n = 0x1234567890abcdef... (256字节的十六进制字符串)
e = 65537

私钥 (n, d):
n = 0x1234567890abcdef... (256字节的十六进制字符串)
d = 0x9876543210fedcba... (256字节的十六进制字符串)

网络传输优化：

  1. 压缩存储：使用十六进制字符串减少存储空间
  2. 分块传输：大密钥可以分块传输，提高网络效率
  3. Base64编码：使用Base64编码确保跨平台兼容性

Python大数处理的技术细节：

1. 内存布局：

1
2
3
4
5
6
# Python大数的内存布局
class PyLongObject:
    ob_refcnt: int      # 引用计数
    ob_type: *PyTypeObject  # 类型指针
    ob_size: int        # 数字的绝对值大小（以digit为单位）
    ob_digit: array     # 数字数组，每个digit存储30位

2. 位运算优化：

1
2
3
4
5
# 高效的位运算操作
def _fast_exponentiation(self, base: int, exponent: int, modulus: int) -> int:
    """使用Python内置的三参数pow函数"""
    # Python的pow(base, exp, mod)使用了Montgomery约简等优化算法
    return pow(base, exponent, modulus)

3. 大数比较和运算：

1
2
3
4
5
6
7
8
# 大数运算的性能特点
def performance_analysis():
    """大数运算性能分析"""
    # 加法：O(n)，其中n是数字的位数
    # 乘法：O(n^1.585) - 使用Karatsuba算法
    # 除法：O(n^2)
    # 模幂：O(log e * n^2) - 使用快速模幂算法
    pass

4. 实际性能测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import time

def benchmark_rsa_operations():
    """RSA操作性能基准测试"""
    rsa = RSACipher(2048)
    
    # 密钥生成时间
    start_time = time.time()
    rsa.generate_keypair()
    keygen_time = time.time() - start_time
    
    # 加密时间
    message = "Hello, World! This is a test message."
    start_time = time.time()
    ciphertext = rsa.encrypt(message)
    encrypt_time = time.time() - start_time
    
    # 解密时间
    start_time = time.time()
    plaintext = rsa.decrypt(ciphertext)
    decrypt_time = time.time() - start_time
    
    print(f"2048位RSA性能测试:")
    print(f"密钥生成: {keygen_time:.2f}秒")
    print(f"加密时间: {encrypt_time:.4f}秒")
    print(f"解密时间: {decrypt_time:.4f}秒")

5. 内存使用监控：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import sys

def memory_usage_analysis():
    """内存使用分析"""
    rsa = RSACipher(2048)
    rsa.generate_keypair()
    
    # 计算各个组件的内存使用
    n_size = sys.getsizeof(rsa.n)
    e_size = sys.getsizeof(rsa.e)
    d_size = sys.getsizeof(rsa.d)
    
    print(f"2048位RSA内存使用:")
    print(f"模数n: {n_size}字节")
    print(f"公钥指数e: {e_size}字节")
    print(f"私钥指数d: {d_size}字节")
    print(f"总内存: {n_size + e_size + d_size}字节")

6. 跨平台兼容性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def cross_platform_storage():
    """跨平台存储方案"""
    # 使用标准格式确保跨平台兼容
    import json
    
    # 将大数转换为字符串存储
    key_data = {
        "n": str(rsa.n),
        "e": str(rsa.e),
        "d": str(rsa.d),
        "key_size": rsa.key_size
    }
    
    # JSON序列化
    json_str = json.dumps(key_data)
    
    # 从JSON恢复
    restored_data = json.loads(json_str)
    n = int(restored_data["n"])
    e = int(restored_data["e"])
    d = int(restored_data["d"])

7. 安全存储建议：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def secure_key_storage():
    """安全密钥存储建议"""
    # 1. 使用加密存储私钥
    from cryptography.fernet import Fernet
    
    # 2. 使用密码保护
    import hashlib
    password = "user_password"
    key = hashlib.sha256(password.encode()).digest()
    
    # 3. 分片存储
    def split_key(key_int, num_parts=3):
        """将密钥分片存储"""
        key_str = str(key_int)
        part_size = len(key_str) // num_parts
        parts = []
        for i in range(num_parts):
            start = i * part_size
            end = start + part_size if i < num_parts - 1 else len(key_str)
            parts.append(key_str[start:end])
        return parts

实际性能测试结果：

基于我们的性能测试脚本，以下是2048位RSA密钥的实际性能数据：

1. 密钥生成性能：

  • 1024位RSA：0.21秒
  • 2048位RSA：1.16秒
  • 3072位RSA：6.24秒

2. 加密解密性能（2048位RSA）：

  • 加密时间：0.0000-0.0002秒（几乎瞬时）
  • 解密时间：0.0180-0.0216秒
  • 密文长度：512字符（十六进制）

3. 内存使用分析（2048位RSA）：

  • 模数n：300字节
  • 公钥指数e：28字节
  • 私钥指数d：300字节
  • 总内存：628字节

4. 存储格式比较：

  • 十六进制字符串：1024字符
  • JSON格式：1283字符
  • Base64格式：688字符（最紧凑）

5. 位数验证：

  • 模数n：2047位（符合2048位要求）
  • 公钥指数e：17位（65537）
  • 私钥指数d：2044位

性能分析结论：

  1. 密钥生成：2048位RSA密钥生成时间约1.16秒，在实际应用中可接受
  2. 加密速度：加密操作几乎瞬时完成，适合实时通信
  3. 解密速度：解密时间约20毫秒，对用户体验影响很小
  4. 内存效率：总内存使用仅628字节，非常高效
  5. 存储优化：Base64格式存储最紧凑，适合网络传输

这些实际测试数据验证了Python大数处理机制的高效性，证明了2048位RSA密钥在实际应用中的可行性。

AES算法深度分析：

AES算法作为现代对称加密的标准，其设计体现了密码学的美学：

算法结构分析：

AES算法采用替换-置换网络（SPN）结构：

  1. 字节替换（SubBytes）：使用S盒进行非线性变换
  2. 行移位（ShiftRows）：对状态矩阵的行进行循环移位
  3. 列混合（MixColumns）：对状态矩阵的列进行线性变换
  4. 轮密钥加（AddRoundKey）：与轮密钥进行异或运算

密钥扩展算法：

密钥扩展是AES算法的重要组成部分：

  1. 初始密钥：根据密钥长度（128/192/256位）确定轮数
  2. 轮密钥生成：使用密钥调度算法生成各轮密钥
  3. S盒变换：对密钥扩展过程中的字节进行S盒变换

明密文格式转换：

AES算法的数据格式转换：

  1. 明文处理：

    • 输入文本 → UTF-8编码 → 字节数组
    • PKCS7填充 → 16字节块序列

  2. 密文生成：

    • 16字节块 → AES加密 → 加密块
    • 加密块 → 字节数组 → Base64编码

  3. 解密恢复：

    • Base64字符串 → 字节数组 → 16字节块
    • 去除填充 → UTF-8字符串

实现特点：

  • 实现完整的S盒和逆S盒
  • 支持128/192/256位密钥长度
  • 使用PKCS7填充处理任意长度数据
  • 实现CBC模式加密

ECC算法深度分析：

椭圆曲线密码学代表了现代密码学的发展方向：

椭圆曲线数学基础：

椭圆曲线的数学定义：y² = x³ + ax + b (mod p)

  1. 点运算：

    • 点加法：P + Q = R
    • 点倍乘：2P = P + P
    • 标量乘法：kP = P + P + … + P (k次)

  2. 离散对数问题：给定点P和kP，求k在计算上是困难的

椭圆曲线参数：

我们使用的简化椭圆曲线参数：

  • a = 2, b = 3, p = 97
  • 生成元G = (17, 10)
  • 阶n = 89

加密解密过程：

  1. 加密过程：

    • 选择随机数k
    • 计算C1 = k×G
    • 计算C2 = M + k×PB
    • 密文为(C1, C2)

  2. 解密过程：

    • 计算共享点S = dA×C1
    • 恢复明文M = C2 - S

明密文格式转换：

  • 明文处理：UTF-8编码 → 字节数组 → 大整数 → 椭圆曲线点
  • 密文格式：椭圆曲线点对(C1, C2) → JSON格式存储
  • 解密过程：椭圆曲线点对 → 计算共享点 → 恢复明文

实现特点：

  • 实现完整的椭圆曲线点运算
  • 支持P-256曲线参数
  • 使用二进制方法优化标量乘法
  • 实现椭圆曲线加密和解密

RC4流密码深度分析：

RC4是一种简单而有效的流密码：

算法原理：

  1. S盒初始化：使用密钥调度算法初始化256字节的S盒
  2. 密钥流生成：通过S盒置换生成伪随机密钥流
  3. 加密过程：明文与密钥流进行XOR运算

明密文格式转换：

  • 明文处理：UTF-8编码 → 字节数组
  • 密文格式：加密字节 → Base64编码字符串
  • 解密过程：Base64字符串 → 字节数组 → XOR解密 → UTF-8字符串

实现特点：

  • 使用时间戳和伪随机数生成密钥
  • 实现完整的密钥调度算法
  • 支持任意长度明文加密
  • 向后兼容十六进制格式

Playfair密码深度分析：

Playfair是经典的多图代替密码：

算法原理：

  1. 矩阵构建：使用密钥构建5×5字母矩阵（I和J合并）
  2. 明文预处理：处理重复字母，添加填充字符X
  3. 加密规则：
    • 同行：右移一位
    • 同列：下移一位
    • 矩形：取对角

明密文格式转换：

  • 明文处理：转换为大写，J替换为I，处理重复字母
  • 密文格式：字母对加密结果，保留非字母字符
  • 解密过程：字母对解密，智能去除填充字符X

实现特点：

  • 保留非字母字符（数字、标点符号等）
  • 智能处理重复字母和填充字符
  • 支持包含特殊字符的文本加密
  • 提供清理功能去除填充字符

双置换密码深度分析：

双置换密码使用两次列置换增强安全性：

算法原理：

  1. 第一次置换：使用密钥1进行列置换
  2. 第二次置换：使用密钥2进行列置换
  3. 填充处理：使用字符X填充到完整矩阵

明密文格式转换：

  • 明文处理：转换为大写，计算矩阵大小
  • 密文格式：两次置换后的字符序列
  • 解密过程：反向置换，智能去除填充字符

实现特点：

  • 支持两个不同的置换密钥
  • 智能估算原始文本长度
  • 自动去除填充字符X
  • 保持原始文本中的X字符

元胞自动机（CA）流密码深度分析：

CA流密码基于一维元胞自动机的演化规则：

算法原理：

  1. 规则定义：使用0-255的规则数定义CA行为
  2. 初始状态：使用Logistic映射生成64位初始状态
  3. 状态演化：根据规则演化生成密钥流

明密文格式转换：

  • 明文处理：UTF-8编码 → 字节数组
  • 密文格式：加密字节 → Base64编码字符串
  • 解密过程：Base64字符串 → 字节数组 → XOR解密 → UTF-8字符串

实现特点：

  • 使用Logistic映射生成初始状态
  • 支持0-255的CA规则
  • 64位状态空间
  • 向后兼容十六进制格式

DES算法深度分析：

DES是56位分组密码，使用Feistel网络结构：

算法结构：

  1. 初始置换：IP置换打乱输入顺序
  2. 16轮Feistel网络：每轮包含F函数和左右交换
  3. 最终置换：IP逆置换恢复输出顺序

明密文格式转换：

  • 明文处理：UTF-8编码 → 字节数组 → 填充到8字节倍数 → 64位块
  • 密文格式：加密块 → 字节数组 → Base64编码字符串
  • 解密过程：Base64字符串 → 字节数组 → 64位块 → 去除填充 → UTF-8字符串

实现特点：

  • 完整的S盒和置换表实现
  • 支持56位和64位密钥长度
  • 使用null字节填充
  • 向后兼容非Base64格式

ElGamal算法深度分析：

ElGamal基于离散对数问题，支持加密和数字签名：

数学原理：

  1. 密钥生成：选择大素数p和原根g，生成私钥和公钥
  2. 加密过程：c1 = g^k mod p, c2 = m × (y^k) mod p
  3. 解密过程：m = c2 × (c1^(-a)) mod p

明密文格式转换：

  • 明文处理：UTF-8编码 → 字节数组 → 大整数
  • 密文格式：密文对(c1, c2) → 逗号分隔的字符串
  • 解密过程：字符串解析 → 密文对 → 大整数 → 字节数组 → UTF-8字符串

实现特点：

  • 使用SHA-256哈希进行数字签名
  • 支持512/1024/2048/3072位密钥长度
  • 优化的素性测试和原根查找
  • 缓存机制提升性能

SM2算法深度分析：

SM2是国密椭圆曲线密码算法：

算法规范：

  1. 椭圆曲线参数：使用国密标准曲线参数
  2. 加密过程：C1 = k×G, C2 = M⊕KDF(x2||y2, mlen), C3 = Hash(x2||M||y2)
  3. 解密过程：计算共享点，验证哈希，恢复明文

明密文格式转换：

  • 明文处理：UTF-8编码 → 字节数组
  • 密文格式：C1||C3||C2 → 十六进制字符串
  • 解密过程：十六进制字符串 → 密文组件 → 解密验证 → UTF-8字符串

实现特点：

  • 完整的SM2算法规范实现
  • 支持数字签名和验证
  • 使用KDF密钥派生函数
  • 包含ZA计算和用户ID处理

MD5哈希算法深度分析：

MD5是128位消息摘要算法：

算法结构：

  1. 填充处理：添加1位和0位，使长度模512等于448
  2. 长度附加：添加64位原始长度
  3. 分块处理：每512位块进行4轮处理

明密文格式转换：

  • 输入处理：UTF-8编码 → 字节数组 → 填充处理
  • 输出格式：32位十六进制字符串
  • 验证过程：重新计算哈希值进行比较

实现特点：

  • 完整的MD5算法实现
  • 支持字符串和字节数据输入
  • 32位十六进制输出格式
  • 包含标准测试向量验证

DH密钥交换深度分析：

DH密钥交换基于离散对数问题：

数学原理：

  1. 参数生成：选择大素数p和原根g
  2. 密钥生成：生成私钥a，计算公钥A = g^a mod p
  3. 共享密钥：K = B^a mod p = A^b mod p

明密文格式转换：

  • 参数格式：大整数直接存储
  • 密钥格式：大整数直接存储
  • 共享密钥：大整数 → SHA-256哈希 → AES密钥

实现特点：

  • 预计算标准DH参数（RFC 3526）
  • 支持1024/2048位密钥长度
  • 使用标准参数提升性能
  • 缓存机制优化模幂运算

4.1.2 库函数调用设计

库函数调用版本使用生产级加密库，提供更好的性能和安全性：

  • Cryptography库：提供AES、RSA、ECC等标准算法
  • PyCryptodome库：提供DES、AES等对称加密算法
  • Hashlib库：提供MD5、SHA等哈希算法

4.2 前后端框架设计

4.2.1 前端架构设计

技术栈选择：

  • Vue 3：采用Composition API，提供更好的类型推导和代码复用
  • TypeScript：提供类型安全，减少运行时错误
  • Element Plus：提供丰富的UI组件，提升用户体验
  • Vite：现代化构建工具，支持快速开发和热重载

组件设计：

  • CryptoDemo_fixed.vue：加解密演示组件，支持多种算法
  • P2PChatSimple.vue：P2P通信组件，实现实时聊天
  • DHExchange.vue：DH密钥交换演示组件

状态管理：

  • 使用Pinia进行状态管理
  • 分离加密状态、连接状态、消息状态等

4.2.2 后端架构设计

技术栈选择：

  • FastAPI：现代Web框架，支持异步处理和自动API文档
  • WebSocket：实时双向通信，支持低延迟消息传输
  • Pydantic：数据验证和序列化，确保数据完整性

模块设计：

  • 算法模块：封装所有加密算法，提供统一接口
  • 通信模块：处理WebSocket连接和消息路由
  • 加密管理模块：管理加密会话和密钥交换

4.3 分布式框架设计

4.3.1 架构模式

系统采用中心服务器-客户端服务器架构：

1
客户端A ←→ 客户端服务器A ←→ 中心服务器 ←→ 客户端服务器B ←→ 客户端B

中心服务器：

  • 负责消息路由和房间管理
  • 处理客户端连接和断开
  • 支持远程部署和连接

客户端服务器：

  • 处理本地加密操作
  • 连接到中心服务器
  • 管理本地客户端连接

4.3.2 通信协议

WebSocket协议：

  • 支持实时双向通信
  • 自动重连机制
  • 消息类型路由

消息格式：

1
2
3
4
5
{
  "type": "message_type",
  "data": {...},
  "timestamp": 1234567890
}

消息类型：

  • join_room：加入聊天室
  • send_message：发送消息
  • initiate_encryption：发起加密通信
  • dh_key_exchange：DH密钥交换
  • file_transfer：文件传输

4.4 系统架构图

graph TB
    subgraph "前端层"
        A[Vue3前端应用]
        B[加密演示组件]
        C[P2P通信组件]
        D[DH密钥交换组件]
    end
    
    subgraph "客户端服务器层"
        E[客户端WebSocket服务器]
        F[加密管理器]
        G[消息处理器]
    end
    
    subgraph "中心服务器层"
        H[中心WebSocket服务器]
        I[消息路由器]
        J[房间管理器]
        K[加密会话管理]
    end
    
    subgraph "算法层"
        L[自实现算法]
        M[库函数调用]
        N[RSA/AES/DES/ECC等]
    end
    
    A --> E
    B --> E
    C --> E
    D --> E
    
    E --> F
    E --> G
    F --> L
    F --> M
    
    E --> H
    H --> I
    H --> J
    H --> K
    
    L --> N
    M --> N

4.5 系统使用流程图

sequenceDiagram
    participant C1 as 客户端1
    participant CS1 as 客户端服务器1
    participant Center as 中心服务器
    participant CS2 as 客户端服务器2
    participant C2 as 客户端2
    
    C1->>CS1: 连接WebSocket
    CS1->>Center: 连接中心服务器
    C2->>CS2: 连接WebSocket
    CS2->>Center: 连接中心服务器
    
    C1->>CS1: 加入房间
    CS1->>Center: 转发加入房间请求
    C2->>CS2: 加入房间
    CS2->>Center: 转发加入房间请求
    
    C1->>CS1: 发起加密通信
    CS1->>Center: 发送加密参数
    Center->>CS2: 转发加密参数
    CS2->>C2: 显示加密邀请
    
    C2->>CS2: 接受加密
    CS2->>Center: 确认加密
    Center->>CS1: 加密建立完成
    
    C1->>CS1: 发送加密消息
    CS1->>Center: 转发加密消息
    Center->>CS2: 转发加密消息
    CS2->>C2: 显示解密消息

4.6 业务逻辑图

graph TD
    A[用户启动应用] --> B[选择服务器类型]
    B --> C{服务器类型}
    C -->|中心服务器| D[连接中心服务器]
    C -->|客户端服务器| E[连接客户端服务器]
    
    D --> F[加入聊天室]
    E --> F
    
    F --> G[选择加密方式]
    G --> H{加密方式}
    H -->|无加密| I[直接发送消息]
    H -->|RSA-AES| J[RSA密钥交换]
    H -->|DH密钥交换| K[DH参数交换]
    
    J --> L[建立加密会话]
    K --> L
    
    L --> M[发送加密消息]
    I --> M
    
    M --> N[消息路由]
    N --> O[接收方解密]
    O --> P[显示消息]

4.7 分布式加密通信的算法集成设计

4.7.1 加密算法集成架构

graph TB
    subgraph "加密算法层"
        A[RSA算法]
        B[AES算法]
        C[DES算法]
        D[ECC算法]
        E[ElGamal算法]
        F[SM2算法]
        G[DH密钥交换]
        H[MD5哈希]
    end
    
    subgraph "算法接口层"
        I[加密接口]
        J[解密接口]
        K[密钥生成接口]
        L[签名接口]
        M[验证接口]
    end
    
    subgraph "通信管理层"
        N[加密会话管理]
        O[密钥交换管理]
        P[消息加密管理]
        Q[文件加密管理]
    end
    
    A --> I
    B --> I
    C --> I
    D --> I
    E --> I
    F --> I
    
    A --> J
    B --> J
    C --> J
    D --> J
    E --> J
    F --> J
    
    G --> O
    H --> M
    
    I --> N
    J --> N
    K --> N
    L --> N
    M --> N
    
    N --> P
    N --> Q

4.7.2 密钥交换流程

RSA-AES混合加密流程：

  1. 客户端生成RSA密钥对
  2. 客户端生成AES密钥
  3. 客户端使用RSA公钥加密AES密钥
  4. 服务器使用RSA私钥解密AES密钥
  5. 双方使用AES密钥进行对称加密通信

DH密钥交换流程：

  1. 双方协商DH参数（p, g）
  2. 双方生成私钥
  3. 双方计算公钥并交换
  4. 双方计算共享密钥
  5. 使用共享密钥派生AES密钥进行通信

五、系统实现

5.1 整体框架实现

5.1.1 后端主服务框架

5.1.2 算法接口实现

5.2 加解密算法实现

5.2.1 RSA算法实现

5.2.2 AES算法实现

5.2.3 RC4流密码实现

5.2.4 Playfair密码实现

5.2.5 元胞自动机（CA）流密码实现

5.2.7 ElGamal算法实现

5.2.8 SM2算法实现

5.4 系统架构深度分析

5.4.1 后端框架深度分析

FastAPI框架特点：

FastAPI作为现代Python Web框架，具有以下特点：

  1. 异步支持：基于asyncio的异步编程模型
  2. 类型安全：基于Python类型注解的自动验证
  3. 自动文档：自动生成OpenAPI文档
  4. 高性能：基于Starlette和Pydantic的高性能实现

模块化设计：

错误处理机制：

5.4.2 通信系统深度分析

WebSocket通信协议：

消息路由机制：

消息路由是通信系统的核心：

加密会话管理：

加密会话管理确保通信安全：

5.4.3 分布式架构分析

中心服务器架构：

中心服务器负责消息路由和房间管理：

客户端服务器架构：

客户端服务器处理本地加密操作

5.5 性能优化与安全特性

5.5.2 安全特性

5.5 系统测试与验证

5.5.1 算法正确性测试

5.5.2 系统集成测试

cryptography
#cryptography #pracitce
加密通信系统
http://wizard.iroot.tech/2025/09/22/加密通信系统/cryptography/
作者
Wizard
发布于
2025年9月22日
许可协议