Day-173-国密算法详解

# Day 187: 国密算法详解

> 密码学系列第 7 天 | 预计阅读时间：45 分钟 | 难度：★★★★☆

---

## 清单 目录

1. [国密算法概述](#国密算法概述)
2. [SM2 椭圆曲线公钥密码](#sm2 椭圆曲线公钥密码)
3. [SM3 密码杂凑算法](#sm3 密码杂凑算法)
4. [SM4 分组密码算法](#sm4 分组密码算法)
5. [SM9 标识密码算法](#sm9 标识密码算法)
6. [国密算法对比](#国密算法对比)
7. [国密应用实践](#国密应用实践)
8. [合规要求](#合规要求)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## 国密算法概述

### 什么是国密算法

**国密算法定义**：

```
┌─────────────────────────────────────────────────────────────┐
│                  国密算法概述                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  定义：                                                      │
│  国密算法是中国国家密码管理局制定和发布的一系列密码       │
│  算法标准，用于保障国家信息安全。                          │
│                                                             │
│  背景：                                                      │
│  ├── 1990s：中国密码算法研究起步                           │
│  ├── 2000s：SM1/SM2/SM3/SM4 相继发布                       │
│  ├── 2010s：国密算法标准化、产业化                         │
│  └── 2020s：国密算法广泛应用                               │
│                                                             │
│  目标：                                                      │
│  ├── 自主可控：摆脱对国外算法的依赖                        │
│  ├── 安全保障：满足国家信息安全需求                        │
│  ├── 产业发展：推动密码产业发展                            │
│  └── 国际竞争：参与国际密码标准竞争                        │
│                                                             │
│  管理机构：                                                  │
│  └── 国家密码管理局（OSCCA）                               │
│      负责国密算法的制定、审批和管理                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 国密算法体系

**国密算法家族**：

```
┌─────────────────────────────────────────────────────────────┐
│                  国密算法体系                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  公开算法（商用密码）：                                      │
│  ├── SM2：椭圆曲线公钥密码算法                             │
│  │   └── 功能：加密、解密、签名、验签、密钥交换            │
│  │                                                          │
│  ├── SM3：密码杂凑算法                                     │
│  │   └── 功能：哈希、消息摘要                              │
│  │                                                          │
│  ├── SM4：分组密码算法                                     │
│  │   └── 功能：数据加密、解密                              │
│  │                                                          │
│  └── SM9：标识密码算法                                     │
│      └── 功能：基于身份的加密、签名                        │
│                                                             │
│  非公开算法（内部使用）：                                    │
│  ├── SM1：分组密码算法                                     │
│  │   └── 特点：硬件实现，算法不公开                        │
│  │                                                          │
│  ├── SSX 系列：                                              │
│  │   └── 用途：特定领域应用                                │
│  │                                                          │
│  └── 其他：                                                  │
│      └── 用途：专用场景                                    │
│                                                             │
│  标准体系：                                                  │
│  ├── GM/T 0002-2012: SM4                                   │
│  ├── GM/T 0003-2012: SM2                                   │
│  ├── GM/T 0004-2012: SM3                                   │
│  ├── GM/T 0005-2012: SM2 应用规范                          │
│  ├── GM/T 0006-2012: SM2 密码算法使用规范                  │
│  └── GM/T 0010-2012: SM2 密码算法加密签名消息语法规范      │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## SM2 椭圆曲线公钥密码

### 算法概述

**SM2 基本信息**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM2 算法概述                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 标准：GM/T 0003-2012                                  │
│  ├── 发布：2010 年（商用）                                 │
│  ├── 类型：椭圆曲线公钥密码                                │
│  ├── 曲线：256 位素数域椭圆曲线                            │
│  └── 设计者：中国密码学会                                   │
│                                                             │
│  功能：                                                      │
│  ├── 数字签名：SM2 签名/验签                               │
│  ├── 密钥交换：SM2 密钥协商                                │
│  └── 公钥加密：SM2 加密/解密                               │
│                                                             │
│  曲线参数：                                                  │
│  ├── 素数 p：256 位素数                                     │
│  ├── 曲线方程：y² = x³ + ax + b (mod p)                   │
│  ├── 基点 G：256 位点                                       │
│  ├── 阶 n：256 位素数                                       │
│  └── 余因子 h：1                                           │
│                                                             │
│  与 NIST P-256 对比：                                         │
│  ├── 安全强度：相当（128 位）                              │
│  ├── 密钥长度：相同（256 位）                              │
│  ├── 性能：SM2 略优（曲线参数优化）                        │
│  └── 标准：SM2 是中国标准，P-256 是美国标准                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### SM2 签名

**SM2 数字签名算法**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM2 签名算法                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  密钥生成：                                                  │
│  1. 选择随机数 d（1 < d < n-1）作为私钥                    │
│  2. 计算公钥 P = dG（G 为基点）                            │
│  3. 私钥：d                                                │
│  4. 公钥：P                                                │
│                                                             │
│  签名流程：                                                  │
│  1. 计算消息哈希：e = H(M)                                 │
│  2. 生成随机数 k（1 < k < n-1）                            │
│  3. 计算椭圆曲线点 (x1, y1) = kG                           │
│  4. 计算 r = (e + x1) mod n                                │
│  5. 计算 s = (1 + d)^(-1) * (k - r*d) mod n               │
│  6. 输出签名：(r, s)                                       │
│                                                             │
│  验签流程：                                                  │
│  1. 验证 r, s 范围：1 ≤ r,s < n                           │
│  2. 计算消息哈希：e = H(M)                                 │
│  3. 计算 t = (r + s) mod n                                 │
│  4. 计算椭圆曲线点 (x1, y1) = sG + tP                     │
│  5. 计算 R = (e + x1) mod n                                │
│  6. 验证：R == r                                           │
│                                                             │
│  签名格式：                                                  │
│  ├── DER 编码：0x30 [总长] 0x02 [r 长] r 0x02 [s 长] s     │
│  └── 长度：约 70-72 字节                                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### SM2 加密

**SM2 公钥加密**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM2 加密算法                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  加密流程：                                                  │
│  1. 生成随机数 k（1 < k < n-1）                            │
│  2. 计算 C1 = kG（椭圆曲线点）                             │
│  3. 计算 S = kP（P 为接收方公钥）                          │
│  4. 计算密钥派生：(x2, y2) = S，密钥 = KDF(x2||y2)        │
│  5. 计算 C2 = M ⊕ 密钥（异或加密）                        │
│  6. 计算 C3 = Hash(M||x2||y2)（完整性校验）               │
│  7. 输出密文：C1 || C2 || C3                              │
│                                                             │
│  解密流程：                                                  │
│  1. 计算 S = dC1（d 为私钥）                               │
│  2. 计算密钥派生：(x2, y2) = S，密钥 = KDF(x2||y2)        │
│  3. 计算 M' = C2 ⊕ 密钥                                    │
│  4. 计算 u = Hash(M'||x2||y2)                              │
│  5. 验证：u == C3                                          │
│  6. 输出：M'                                               │
│                                                             │
│  密文格式：                                                  │
│  ├── C1：65 字节（椭圆曲线点，未压缩格式）                │
│  ├── C2：与明文等长                                         │
│  ├── C3：32 字节（SM3 哈希）                               │
│  └── 总计：97 字节 + 明文长度                              │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 代码实现

**Python SM2 实现**：

```python
from gmssl import sm2, func

# ============= SM2 签名示例 =============
def sm2_sign_demo():
    """SM2 签名/验签演示"""
    # 生成密钥对
    sm2_crypt = sm2.CryptSM2(
        public_key=None,
        private_key=None
    )
    
    # 生成随机密钥对
    import random
    private_key = func.random_hex(64)  # 256 位私钥
    public_key = sm2_crypt._pubkey(private_key)
    
    print("=== SM2 签名/验签 ===")
    print(f"私钥：{private_key[:32]}...")
    print(f"公钥：{public_key[:32]}...")
    
    # 签名
    message = b"Important message to sign"
    signature = sm2_crypt.sign(message, private_key)
    print(f"签名：{signature.hex()[:64]}...")
    
    # 验签
    is_valid = sm2_crypt.verify(signature, message, public_key)
    print(f"✓ 验签结果：{is_valid}")
    
    return is_valid

# ============= SM2 加密示例 =============
def sm2_encrypt_demo():
    """SM2 加密/解密演示"""
    # 生成密钥对
    sm2_crypt = sm2.CryptSM2(
        public_key=None,
        private_key=None
    )
    
    private_key = func.random_hex(64)
    public_key = sm2_crypt._pubkey(private_key)
    
    print("\n=== SM2 加密/解密 ===")
    print(f"公钥：{public_key[:32]}...")
    
    # 加密
    message = b"Secret message for SM2 encryption"
    ciphertext = sm2_crypt.encrypt(message, public_key)
    print(f"密文：{ciphertext.hex()[:64]}...")
    
    # 解密
    sm2_decrypt = sm2.CryptSM2(
        public_key=public_key,
        private_key=private_key
    )
    decrypted = sm2_decrypt.decrypt(ciphertext)
    print(f"解密：{decrypted}")
    print(f"✓ 加解密成功：{message == decrypted}")
    
    return message == decrypted

if __name__ == "__main__":
    sm2_sign_demo()
    sm2_encrypt_demo()
```

---

## SM3 密码杂凑算法

### 算法概述

**SM3 基本信息**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM3 算法概述                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 标准：GM/T 0004-2012                                  │
│  ├── 发布：2010 年                                          │
│  ├── 类型：密码杂凑算法（哈希函数）                        │
│  ├── 输出长度：256 位（32 字节）                            │
│  └── 分组长度：512 位                                       │
│                                                             │
│  设计目标：                                                  │
│  ├── 安全性：与 SHA-256 相当                               │
│  ├── 性能：适合软硬件实现                                   │
│  └── 自主可控：中国自主设计                                 │
│                                                             │
│  结构：                                                      │
│  ├── Merkle-Damgård 结构（类似 SHA-256）                   │
│  ├── 8 个初始值（32 位）                                    │
│  ├── 64 轮压缩函数                                         │
│  └── 非线性函数：FF、GG（与 SHA-256 不同）                 │
│                                                             │
│  安全性：                                                    │
│  ├── 碰撞抵抗：128 位安全                                   │
│  ├── 原像抵抗：256 位安全                                   │
│  ├── 无已知有效攻击                                         │
│  └── 通过国家密码管理局认证                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 算法流程

**SM3 哈希计算**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM3 算法流程                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. 消息填充：                                               │
│     输入：任意长度消息 M                                    │
│     填充：                                                  │
│     - 添加 '1' 比特                                         │
│     - 添加 '0' 比特（使长度 ≡ 448 mod 512）                │
│     - 添加 64 位长度（原始消息长度）                        │
│     输出：512 位的倍数                                      │
│                                                             │
│  2. 初始值：                                                 │
│     IV = 0x7380166f 0x4914b2b9 0x172442d7 0xda8a0600       │
│          0xa96f30bc 0x163138aa 0xe38dee4d 0xb0fb0e4e       │
│                                                             │
│  3. 压缩函数（每 512 位分组）：                               │
│     ┌─────────────────────────────────────────────────┐    │
│     │  对于每个分组：                                 │    │
│     │  1. 消息扩展：生成 132 个字 W0-W131             │    │
│     │  2. 工作变量： a,b,c,d,e,f,g,h = IV0-IV7       │    │
│     │  3. 64 轮压缩：                                  │    │
│     │     对于 j = 0 到 63:                           │    │
│     │     SS1 = ((a<<<12) + e + (Tj<<<j)) <<< 7      │    │
│     │     SS2 = SS1 XOR (a<<<12)                      │    │
│     │     TT1 = FFj(a,b,c) + d + SS2 + W'j           │    │
│     │     TT2 = GGj(e,f,g) + h + SS1 + Wj            │    │
│     │     d = c, c = b<<<9, b = a, a = TT1           │    │
│     │     h = g, g = f<<<19, f = e, e = TT2          │    │
│     │  4. 更新 IV：Hi = Hi XOR (a,b,c,d,e,f,g,h)     │    │
│     └─────────────────────────────────────────────────┘    │
│                                                             │
│  4. 输出：                                                   │
│     连接 IV0-IV7 得到 256 位哈希值                           │
│                                                             │
│  常量 Tj：                                                   │
│  ├── j = 0-15:  Tj = 0x79cc4519                            │
│  └── j = 16-63: Tj = 0x7a879d8a                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 代码实现

**Python SM3 实现**：

```python
from gmssl import sm3

# ============= SM3 哈希示例 =============
def sm3_hash_demo():
    """SM3 哈希演示"""
    print("=== SM3 哈希 ===")
    
    # 简单哈希
    message = b"Hello, SM3!"
    hash_value = sm3.sm3_hash(message)
    print(f"消息：{message.decode()}")
    print(f"SM3 哈希：{hash_value}")
    
    # 与 SHA-256 对比
    import hashlib
    sha256_hash = hashlib.sha256(message).hexdigest()
    print(f"SHA-256:   {sha256_hash}")
    
    # 雪崩效应测试
    message2 = b"Hello, SM2!"  # 仅 1 字节差异
    hash_value2 = sm3.sm3_hash(message2)
    print(f"\n消息 2: {message2.decode()}")
    print(f"SM3 哈希：{hash_value2}")
    
    # 计算差异比特数
    diff_bits = sum(
        bin(int(h1, 16) ^ int(h2, 16)).count('1')
        for h1, h2 in zip(hash_value, hash_value2)
    )
    print(f"差异比特数：{diff_bits} / 256")
    print(f"✓ 雪崩效应：{diff_bits > 100}")
    
    return hash_value

# ============= SM3 HMAC 示例 =============
def sm3_hmac_demo():
    """SM3 HMAC 演示"""
    from gmssl import sm3, func
    
    print("\n=== SM3 HMAC ===")
    
    message = b"Message to authenticate"
    key = b"secret_key"
    
    # HMAC-SM3
    hmac_value = sm3.sm3_hmac(key, message)
    print(f"消息：{message.decode()}")
    print(f"密钥：{key.decode()}")
    print(f"HMAC-SM3: {hmac_value}")
    
    return hmac_value

if __name__ == "__main__":
    sm3_hash_demo()
    sm3_hmac_demo()
```

---

## SM4 分组密码算法

### 算法概述

**SM4 基本信息**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM4 算法概述                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 标准：GM/T 0002-2012                                  │
│  ├── 发布：2006 年（商用）                                 │
│  ├── 类型：分组密码算法                                     │
│  ├── 分组长度：128 位                                       │
│  ├── 密钥长度：128 位                                       │
│  └── 轮数：32 轮                                            │
│                                                             │
│  设计特点：                                                  │
│  ├── 结构：非平衡 Feistel 网络                              │
│  ├── S 盒：8 位输入 8 位输出，非线性                         │
│  ├── 线性变换：L、L' 变换                                   │
│  └── 密钥扩展：32 轮轮密钥生成                              │
│                                                             │
│  工作模式：                                                  │
│  ├── ECB：电子密码本（不推荐）                             │
│  ├── CBC：密码分组链接                                      │
│  ├── CFB：密码反馈                                          │
│  ├── OFB：输出反馈                                          │
│  ├── CTR：计数器模式                                        │
│  └── GCM：伽罗瓦计数器模式（推荐）                         │
│                                                             │
│  与 AES 对比：                                                │
│  ├── 分组长度：相同（128 位）                              │
│  ├── 密钥长度：SM4 固定 128 位，AES 可选 128/192/256        │
│  ├── 安全性：相当                                           │
│  ├── 性能：SM4 略慢（软件实现）                            │
│  └── 标准：SM4 是中国标准，AES 是国际标准                   │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 算法流程

**SM4 加密流程**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM4 加密流程                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  输入：                                                      │
│  ├── 明文：128 位（16 字节），分为 4 个 32 位字              │
│  ├── 密钥：128 位（16 字节）                                │
│                                                             │
│  密钥扩展：                                                  │
│  1. 输入密钥 MK 分为 4 个 32 位字：MK0,MK1,MK2,MK3          │
│  2. 初始值：K0 = MK0⊕FK0, K1 = MK1⊕FK1, ...               │
│  3. 对于 r = 0 到 31:                                       │
│     Kr+4 = Kr ⊕ T'(Kr+1 ⊕ Kr+2 ⊕ Kr+3 ⊕ CKr)              │
│     - T'：非线性变换                                        │
│     - CKr：系统参数                                         │
│  4. 输出：32 个轮密钥 RK0-RK31                              │
│                                                             │
│  加密轮函数：                                                │
│  输入：X0,X1,X2,X3（明文分组）                             │
│  对于 r = 0 到 31:                                          │
│     Xr+4 = Xr ⊕ T(Xr+1 ⊕ Xr+2 ⊕ Xr+3 ⊕ RKr)               │
│     - T：非线性变换（S 盒 + 线性变换）                     │
│     - RKr：第 r 轮轮密钥                                    │
│                                                             │
│  输出：                                                      │
│  密文：Y0,Y1,Y2,Y3 = X35,X34,X33,X32（反序输出）          │
│                                                             │
│  解密：                                                      │
│  解密与加密结构相同，仅轮密钥顺序相反                       │
│  RK0↔RK31, RK1↔RK30, ..., RK15↔RK16                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 代码实现

**Python SM4 实现**：

```python
from gmssl import sm4

# ============= SM4 加密示例 =============
def sm4_encrypt_demo():
    """SM4 加密/解密演示"""
    print("=== SM4 加密/解密 ===")
    
    # 密钥（128 位）
    key = b'0123456789abcdef'  # 16 字节
    
    # 创建加密对象
    sm4_crypt = sm4.CryptSM4()
    sm4_crypt.set_key(key, sm4.SM4_ENCRYPT)
    
    # 加密（ECB 模式）
    plaintext = b"Secret message!"
    # 需要填充到 16 字节倍数
    from Crypto.Util.Padding import pad
    padded = pad(plaintext, 16)
    ciphertext = sm4_crypt.crypt_ecb(padded)
    
    print(f"明文：{plaintext}")
    print(f"密文：{ciphertext.hex()}")
    
    # 解密
    sm4_decrypt = sm4.CryptSM4()
    sm4_decrypt.set_key(key, sm4.SM4_DECRYPT)
    decrypted_padded = sm4_decrypt.crypt_ecb(ciphertext)
    
    from Crypto.Util.Padding import unpad
    decrypted = unpad(decrypted_padded, 16)
    
    print(f"解密：{decrypted}")
    print(f"✓ 加解密成功：{plaintext == decrypted}")
    
    return plaintext == decrypted

# ============= SM4 CBC 模式示例 =============
def sm4_cbc_demo():
    """SM4 CBC 模式演示"""
    print("\n=== SM4 CBC 模式 ===")
    
    # 密钥和 IV
    key = b'0123456789abcdef'
    iv = b'fedcba9876543210'
    
    # 加密
    sm4_crypt = sm4.CryptSM4()
    sm4_crypt.set_key(key, sm4.SM4_ENCRYPT)
    
    plaintext = b"Message for CBC mode encryption"
    from Crypto.Util.Padding import pad
    padded = pad(plaintext, 16)
    ciphertext = sm4_crypt.cbc_encrypt(iv, padded)
    
    print(f"明文：{plaintext.decode()}")
    print(f"密文：{ciphertext.hex()[:32]}...")
    
    # 解密
    sm4_decrypt = sm4.CryptSM4()
    sm4_decrypt.set_key(key, sm4.SM4_DECRYPT)
    decrypted_padded = sm4_decrypt.cbc_decrypt(iv, ciphertext)
    
    from Crypto.Util.Padding import unpad
    decrypted = unpad(decrypted_padded, 16)
    
    print(f"解密：{decrypted.decode()}")
    print(f"✓ CBC 加解密成功：{plaintext == decrypted}")
    
    return plaintext == decrypted

if __name__ == "__main__":
    sm4_encrypt_demo()
    sm4_cbc_demo()
```

---

## SM9 标识密码算法

### 算法概述

**SM9 基本信息**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM9 算法概述                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  基本信息：                                                  │
│  ├── 标准：GM/T 0009-2012                                  │
│  ├── 发布：2016 年（商用）                                 │
│  ├── 类型：标识密码算法（基于身份的密码）                  │
│  ├── 基础：双线性对（Boneh-Franklin 方案）                 │
│  └── 设计者：中国密码学会                                   │
│                                                             │
│  核心思想：                                                  │
│  ├── 用户公钥 = 用户身份标识（如邮箱、手机号）             │
│  ├── 无需证书：不需要 PKI 证书体系                          │
│  ├── 私钥生成：由密钥生成中心（KGC）生成                   │
│  └── 简化密钥管理：公钥可直接从身份推导                    │
│                                                             │
│  功能：                                                      │
│  ├── 标识加密：使用对方身份标识加密                        │
│  ├── 标识签名：使用自己身份标识签名                        │
│  └── 密钥交换：基于身份的密钥协商                          │
│                                                             │
│  优势：                                                      │
│  ✓ 无需证书管理                                             │
│  ✓ 公钥易于记忆（如邮箱地址）                               │
│  ✓ 适合封闭系统（企业内部、IoT）                           │
│  ✗ 需要信任 KGC（密钥托管问题）                            │
│                                                             │
│  应用场景：                                                  │
│  ├── 电子邮件加密                                          │
│  ├── 移动设备认证                                          │
│  ├── IoT 设备管理                                           │
│  └── 政务系统                                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 工作原理

**SM9 密钥生成**：

```
┌─────────────────────────────────────────────────────────────┐
│                  SM9 密钥生成                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  系统参数：                                                  │
│  ├── 双线性对：e: G1 × G2 → GT                             │
│  ├── 基点：P ∈ G1, Q ∈ G2                                  │
│  ├── 主密钥：msk（KGC 持有）                               │
│  └── 主公钥：mpk = msk * P（公开）                         │
│                                                             │
│  用户私钥生成：                                              │
│  1. 用户身份：ID（如 email@example.com）                  │
│  2. KGC 计算：H(ID) → 哈希到 G1 或 G2                        │
│  3. KGC 计算：用户私钥 = msk * H(ID)                       │
│  4. KGC 安全分发私钥给用户                                  │
│                                                             │
│  加密流程：                                                  │
│  1. 发送方获取接收方身份 ID                                │
│  2. 计算：H(ID) → 哈希到 G1                                │
│  3. 生成随机数 r                                           │
│  4. 计算：C1 = r * P                                       │
│  5. 计算：g = e(H(ID), mpk)^r                             │
│  6. 计算：C2 = M ⊕ KDF(g)                                 │
│  7. 输出密文：(C1, C2)                                     │
│                                                             │
│  解密流程：                                                  │
│  1. 接收方使用私钥 d = msk * H(ID)                         │
│  2. 计算：g = e(C1, d)                                     │
│  3. 计算：M = C2 ⊕ KDF(g)                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 国密算法对比

### 与国际算法对比

**国密 vs 国际算法**：

```
┌─────────────────────────────────────────────────────────────┐
│              国密算法与国际算法对比                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  公钥密码：                                                  │
│  ┌────────────┬────────────┬────────────┬─────────────────┐ │
│  │   算法     │   SM2      │   RSA      │    ECC (P-256)  │ │
│  ├────────────┼────────────┼────────────┼─────────────────┤ │
│  │ 密钥长度   │ 256 位     │ 2048-4096  │ 256 位           │ │
│  │ 签名长度   │ 64 字节    │ 256-512    │ 64 字节         │ │
│  │ 加密速度   │ 快         │ 慢         │ 快              │ │
│  │ 安全性     │ 128 位     │ 112-128    │ 128 位          │ │
│  │ 标准       │ 中国       │ 国际       │ 国际            │ │
│  └────────────┴────────────┴────────────┴─────────────────┘ │
│                                                             │
│  哈希算法：                                                  │
│  ┌────────────┬────────────┬────────────┬─────────────────┐ │
│  │   算法     │   SM3      │  SHA-256   │    MD5          │ │
│  ├────────────┼────────────┼────────────┼─────────────────┤ │
│  │ 输出长度   │ 256 位     │ 256 位     │ 128 位          │ │
│  │ 碰撞抵抗   │ 128 位     │ 128 位     │ 已攻破          │ │
│  │ 原像抵抗   │ 256 位     │ 256 位     │ 已攻破          │ │
│  │ 性能       │ 中等       │ 中等       │ 快              │ │
│  │ 状态       │ 安全       │ 安全       │ 不安全          │ │
│  └────────────┴────────────┴────────────┴─────────────────┘ │
│                                                             │
│  对称加密：                                                  │
│  ┌────────────┬────────────┬────────────┬─────────────────┐ │
│  │   算法     │   SM4      │   AES-128  │    AES-256      │ │
│  ├────────────┼────────────┼────────────┼─────────────────┤ │
│  │ 分组长度   │ 128 位     │ 128 位     │ 128 位          │ │
│  │ 密钥长度   │ 128 位     │ 128/256    │ 256 位          │ │
│  │ 轮数       │ 32 轮      │ 10/14 轮   │ 14 轮           │ │
│  │ 安全性     │ 128 位     │ 128/256    │ 256 位          │ │
│  │ 性能       │ 中等       │ 快 (NI)    │ 快 (HW)         │ │
│  └────────────┴────────────┴────────────┴─────────────────┘ │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 选型建议

**国密算法选型指南**：

```
┌─────────────────────────────────────────────────────────────┐
│                  国密算法选型指南                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  政务系统：                                                  │
│  ├── 强制要求：必须使用国密算法                            │
│  ├── 推荐组合：SM2 + SM3 + SM4                             │
│  └── 合规：符合等保 2.0、密码法要求                        │
│                                                             │
│  金融系统：                                                  │
│  ├── 要求：关键系统使用国密                                │
│  ├── 推荐：SM2 签名、SM4 加密、SM3 哈希                    │
│  └── 标准：符合 PBOC 3.0、JR/T 标准                        │
│                                                             │
│  企业系统：                                                  │
│  ├── 选择：根据业务需求                                    │
│  ├── 国内业务：推荐国密                                     │
│  └── 国际业务：可使用国际算法                              │
│                                                             │
│  IoT 系统：                                                   │
│  ├── 优势：SM9 标识密码适合设备管理                        │
│  ├── 轻量：SM4 硬件实现高效                                 │
│  └── 建议：SM9 + SM4 组合                                   │
│                                                             │
│  混合部署：                                                  │
│  ├── 场景：需要兼容国际系统                                 │
│  ├── 方案：同时支持国密和国际算法                          │
│  └── 协商：根据对端能力选择算法                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 国密应用实践

### SSL/TLS 国密改造

**国密 SSL 配置**：

```
┌─────────────────────────────────────────────────────────────┐
│                  国密 SSL 配置                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  国密 SSL 密码套件：                                         │
│  ├── ECC-SM2-SM4-SM3                                       │
│  │   - 密钥交换：SM2                                       │
│  │   - 签名：SM2                                           │
│  │   - 加密：SM4-CBC                                       │
│  │   - 哈希：SM3                                           │
│  │                                                          │
│  ├── ECDHE-SM2-SM4-SM3                                     │
│  │   - 密钥交换：SM2（临时）                               │
│  │   - 签名：SM2                                           │
│  │   - 加密：SM4-GCM（推荐）                               │
│  │   - 哈希：SM3                                           │
│  │                                                          │
│  └── 双证书方案：                                            │
│      - RSA 证书：兼容国际客户端                             │
│      - SM2 证书：国密客户端使用                             │
│                                                             │
│  Nginx 国密配置（Tengine）：                                 │
│  ssl_protocols TLSv1.2 TLSv1.3;                           │
│  ssl_ciphers 'ECDHE-SM2-SM4-SM3:SM2-SM4-SM3';             │
│  ssl_certificate sm2_cert.pem;                            │
│  ssl_certificate_key sm2_key.pem;                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 代码实践

**国密算法综合示例**：

```python
from gmssl import sm2, sm3, sm4, func

# ============= 国密综合应用示例 =============
def guomi_demo():
    """国密算法综合演示"""
    print("=== 国密算法综合应用 ===")
    
    # 1. SM3 哈希
    message = b"Important document"
    hash_value = sm3.sm3_hash(message)
    print(f"SM3 哈希：{hash_value}")
    
    # 2. SM2 签名
    private_key = func.random_hex(64)
    sm2_crypt = sm2.CryptSM2(public_key=None, private_key=private_key)
    public_key = sm2_crypt._pubkey(private_key)
    
    signature = sm2_crypt.sign(message, private_key)
    print(f"SM2 签名：{signature.hex()[:32]}...")
    
    is_valid = sm2_crypt.verify(signature, message, public_key)
    print(f"SM2 验签：{'✓ 有效' if is_valid else '✗ 无效'}")
    
    # 3. SM4 加密
    sm4_key = b'0123456789abcdef'
    sm4_crypt = sm4.CryptSM4()
    sm4_crypt.set_key(sm4_key, sm4.SM4_ENCRYPT)
    
    from Crypto.Util.Padding import pad
    padded = pad(message, 16)
    ciphertext = sm4_crypt.crypt_ecb(padded)
    print(f"SM4 密文：{ciphertext.hex()}")
    
    # 4. SM3 HMAC
    hmac_key = b'secret'
    hmac_value = sm3.sm3_hmac(hmac_key, message)
    print(f"HMAC-SM3: {hmac_value}")
    
    print("\n✓ 国密算法演示完成")

if __name__ == "__main__":
    guomi_demo()
```

---

## 合规要求

### 法规政策

**国密合规要求**：

```
┌─────────────────────────────────────────────────────────────┐
│                  国密合规要求                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  法律法规：                                                  │
│  ├── 《中华人民共和国密码法》（2020 年）                   │
│  │   └── 规定关键信息基础设施使用商用密码                 │
│  │                                                          │
│  ├── 《网络安全法》（2017 年）                             │
│  │   └── 要求网络运营者采取数据加密措施                   │
│  │                                                          │
│  └── 《数据安全法》（2021 年）                             │
│      └── 要求重要数据采取加密保护措施                     │
│                                                             │
│  行业标准：                                                  │
│  ├── 等保 2.0（GB/T 22239-2019）                           │
│  │   └── 要求使用合规密码算法                             │
│  │                                                          │
│  ├── 金融行业（PBOC 3.0）                                  │
│  │   └── 要求金融 IC 卡、支付系统使用国密                  │
│  │                                                          │
│  ├── 政务系统                                               │
│  │   └── 强制要求使用国密算法                             │
│  │                                                          │
│  └── 电力行业                                               │
│      └── 要求电力监控系统使用国密                         │
│                                                             │
│  合规建议：                                                  │
│  ✓ 政务系统：必须使用国密                                   │
│  ✓ 金融系统：关键系统使用国密                               │
│  ✓ 关键信息基础设施：优先使用国密                           │
│  ✓ 一般企业：根据业务需求选择                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## 总结与思考

### 核心要点回顾

**国密算法知识框架**：

```
┌─────────────────────────────────────────────────────────────┐
│                  国密算法知识框架                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  算法体系：                                                  │
│  ├── SM2：椭圆曲线公钥密码（加密、签名、密钥交换）         │
│  ├── SM3：密码杂凑算法（256 位哈希）                       │
│  ├── SM4：分组密码算法（128 位分组/密钥）                  │
│  └── SM9：标识密码算法（基于身份）                         │
│                                                             │
│  技术特点：                                                  │
│  ├── 自主可控：中国自主设计                                 │
│  ├── 安全性：与国际算法相当                                 │
│  ├── 标准化：GM/T 标准体系                                  │
│  └── 产业化：广泛应用                                       │
│                                                             │
│  应用场景：                                                  │
│  ├── 政务系统：强制使用                                     │
│  ├── 金融系统：关键系统使用                                 │
│  ├── 企业系统：根据需求选择                                 │
│  └── IoT 系统：SM9 标识密码                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 深入思考

**1. 为什么需要国密算法？**

- 自主可控：避免被卡脖子
- 国家安全：保障关键信息基础设施
- 产业发展：推动密码产业发展
- 国际竞争：参与国际标准制定

**2. 国密 vs 国际算法如何选择？**

- 政务/金融：优先国密（合规要求）
- 国际业务：考虑兼容性
- 技术层面：两者安全性相当
- 最佳实践：支持双算法，灵活切换

**3. 国密算法的未来**

- 标准化：更多国际标准采纳
- 性能优化：硬件加速支持
- 应用扩展：更多领域使用
- 后量子：国密后量子算法研究

---

## 参考资料

### 标准与规范

```
- GM/T 0002-2012: SM4 分组密码算法
- GM/T 0003-2012: SM2 椭圆曲线公钥密码算法
- GM/T 0004-2012: SM3 密码杂凑算法
- GM/T 0009-2012: SM9 标识密码算法
- 《中华人民共和国密码法》
```

### 实现库

```
Python:
- gmssl: https://github.com/duanhongyi/gmssl

Java:
- Bouncy Castle（支持国密）
- 国密 JCE 提供商

C/C++:
- OpenSSL（国密分支）
- GmSSL: https://github.com/guanzhi/GmSSL
```

### 学习资源

```
- 国家密码管理局官网
- 中国密码学会
- 《商用密码知识读本》
```

---

*365 天信息安全技术系列 | Day 187 | 密码学系列第 7 篇*

> 国密算法是中国信息安全的重要保障。理解国密，是理解中国信息安全体系的基础。

> 本文内容仅供学习和研究使用，请勿用于非法目的。

---

*本文是 365 天信息安全技术系列的第 187 篇，密码学系列第 7 篇*

*密码学系列继续！*