Python实现SM3算法

使用 Python 实现 SM3 算法的博客

引言

SM3 是中国国家密码管理局设计的密码杂凑算法，是我国密码学标准（GM/T 0004-2012）的一部分。SM3 算法类似于国际广泛使用的 SHA-256 算法，但具有一些独特的优化和改进。它主要用于数字签名、数据完整性校验和生成随机数等应用场景，尤其在中国的密码产品中具有重要地位。本文将详细介绍 SM3 算法的工作原理，并使用 Python 实现一个面向对象的 SM3 算法库，最后结合一个实际场景演示其应用。

---

SM3 算法的工作原理

SM3 是一种基于 Merkle-Damgård 架构的加密散列函数，它采用 256 位的输出哈希值。SM3 使用的消息块大小为 512 位（64 字节），并采用 256 位（8 字，32 位一个字）作为初始的哈希值长度。SM3 的哈希过程大致分为以下几个步骤：

1. 消息填充（Padding）：将输入消息填充到接近块大小的倍数（512 位）的长度。
2. 初始化参数：初始化八个 32 位初始值（IV）。
3. 消息扩展：将每个 512 位的消息分组扩展为 132 个 32 位字。
4. 压缩函数：使用布尔函数、非线性函数和循环移位等操作对每一个消息分组进行压缩。
5. 输出哈希值：最终将所有块的压缩结果拼接起来，生成一个 256 位的哈希值。

SM3 算法的详细步骤

1. 消息填充：

   • 填充规则和 SHA-256 类似。首先在消息末尾添加一个“1”比特，然后添加足够的“0”比特，使消息的总长度对 512 取模后等于 448（即接近 512 位的倍数）。最后附加一个 64 位的原始消息长度表示。

2. 消息扩展：

   • 消息扩展过程将 512 位的消息分块扩展为 132 个 32 位字。前 16 个字为消息分块本身，后 116 个字则是通过前面的字组合成的。

3. 布尔函数：

   • 使用三种布尔函数进行非线性操作，类似于 SHA-256 的设计。
   • ( FF(X, Y, Z) ) 和 ( GG(X, Y, Z) ) 是两种主要的非线性布尔函数，取决于当前处理的比特位置。

4. 压缩函数：

   • 将消息块和初始哈希值进行 64 轮的压缩操作。每一轮操作使用不同的布尔函数、常量和移位来更新状态变量。

5. 输出哈希值：

   • 将每一轮的结果累加起来得到最后的哈希值输出。

---

Python 面向对象实现 SM3 算法

下面是一个基于 Python 面向对象思想的 SM3 算法实现。此实现包括消息填充、消息扩展、压缩函数和哈希计算等核心部分。

import struct

class SM3:
    def __init__(self, message):
        """
        初始化 SM3 实例，准备计算哈希值。
        """
        self.message = message
        # 初始哈希值 (IV)
        self.IV = [
            0x7380166F, 0x4914B2B9, 0x172442D7, 0xDA8A0600,
            0xA96F30BC, 0x163138AA, 0xE38DEE4D, 0xB0FB0E4E
        ]
        # 常量
        self.T = [0x79CC4519 if i < 16 else 0x7A879D8A for i in range(64)]
        self._hash = self._calculate_sm3()

    def _padding(self):
        """
        消息填充，使消息长度接近512位的倍数。
        """
        message = bytearray(self.message, 'utf-8')
        message_len = len(message) * 8  # 原始消息的位长度
        message.append(0x80)  # 添加 '1' 比特

        # 填充 '0' 比特，直到消息长度模512等于448位
        message.extend([0x00] * ((56 - len(message) % 64) % 64))

        # 添加原始消息长度的64位表示
        message += struct.pack('>Q', message_len)
        return message

    def _left_rotate(self, n, m):
        """
        循环左移操作。
        """
        return ((n << m) & 0xFFFFFFFF) | ((n >> (32 - m)) & 0xFFFFFFFF)

    def _message_extension(self, block):
        """
        消息扩展，将512位的消息扩展为132个32位字。
        """
        W = list(struct.unpack('>16L', block))  # 解析16个字

        # 扩展W[16]到W[67]
        for i in range(16, 68):
            W.append(self._P1(W[i - 16] ^ W[i - 9] ^ self._left_rotate(W[i - 3], 15)) ^
                     self._left_rotate(W[i - 13], 7) ^ W[i - 6])

        # 扩展W[68]到W[131]
        W_ = [W[i] ^ W[i + 4] for i in range(64)]
        return W, W_

    def _P1(self, X):
        """
        非线性变换 P1。
        """
        return X ^ self._left_rotate(X, 15) ^ self._left_rotate(X, 23)

    def _P0(self, X):
        """
        非线性变换 P0。
        """
        return X ^ self._left_rotate(X, 9) ^ self._left_rotate(X, 17)

    def _FF(self, X, Y, Z, j):
        """
        布尔函数 FF。
        """
        return (X ^ Y ^ Z) if j < 16 else ((X & Y) | (X & Z) | (Y & Z))

    def _GG(self, X, Y, Z, j):
        """
        布尔函数 GG。
        """
        return (X ^ Y ^ Z) if j < 16 else ((X & Y) | (~X & Z))

    def _compress(self, V, B):
        """
        压缩函数，对消息块进行压缩。
        """
        W, W_ = self._message_extension(B)
        A, B, C, D, E, F, G, H = V

        # 64轮压缩操作
        for j in range(64):
            SS1 = self._left_rotate((self._left_rotate(A, 12) + E + self._left_rotate(self.T[j], j % 32)) & 0xFFFFFFFF, 7)
            SS2 = SS1 ^ self._left_rotate(A, 12)
            TT1 = (self._FF(A, B, C, j) + D + SS2 + W_[j]) & 0xFFFFFFFF
            TT2 = (self._GG(E, F, G, j) + H + SS1 + W[j]) & 0xFFFFFFFF
            D = C
            C = self._left_rotate(B, 9)
            B = A
            A = TT1
            H = G
            G = self._left_rotate(F, 19)
            F = E
            E = self._P0(TT2)

        # 更新V值
        return [(V[i] ^ var) & 0xFFFFFFFF for i, var in enumerate([A, B, C, D, E, F, G, H])]

    def _calculate_sm3(self):
        """
        计算 SM3 哈希值的主函数。
        """
        padded_message = self._padding()
        blocks = [padded_message[i:i + 64] for i in range(0, len(padded_message), 64)]
        V = self.IV

        # 对每个消息块进行压缩
        for block in blocks:
            V = self._compress(V, block)

        return ''.join(f'{x:08x}' for x in V)

    def hexdigest(self):
        """
        返回最终的 SM3 哈希值。
        """
        return self._hash

# 示例用法
if __name__ == "__main__":
    message = "Hello, SM3!"
    sm3 = SM3(message)
    print(f"原始消息: {message}")
    print(f"SM3 哈希值: {sm3.hexdigest()}")

代码解析

1. 消息填充与初始化：_padding 方法用于填充消息，并确保其符合 SM3 要求的 512 位块大小。

2. **逻

辑操作**：_left_rotate 方法实现了循环左移操作，这是 SM3 哈希计算中的基础操作。

3. 消息扩展：_message_extension 方法将消息块扩展为 132 个 32 位字。

4. 布尔函数与非线性变换：_FF, _GG, _P0, _P1 方法分别定义了 SM3 的布尔函数和非线性变换。

5. 压缩函数：_compress 方法实现了 SM3 的核心逻辑，包括消息调度、64 轮的哈希计算、以及状态变量更新。

6. 输出结果：hexdigest 方法返回计算所得的 SM3 哈希值。

---

应用场景：数字签名验证

SM3 算法广泛用于数字签名中，确保数据的真实性和完整性。以下是一个基于 Python 的场景演示，展示如何使用 SM3 算法生成和验证数字签名：

class DigitalSignature:
    def __init__(self, private_key):
        self.private_key = private_key  # 私钥

    def sign(self, message):
        """
        使用私钥对消息进行签名。
        """
        sm3 = SM3(message)
        hash_val = sm3.hexdigest()
        signature = self._sign_with_private_key(hash_val)
        return signature

    def verify(self, message, signature):
        """
        使用公钥验证消息签名。
        """
        sm3 = SM3(message)
        hash_val = sm3.hexdigest()
        return self._verify_with_public_key(hash_val, signature)

    def _sign_with_private_key(self, hash_val):
        """
        模拟私钥签名过程。
        """
        # 此处为简化签名过程，假设私钥为简单的转换
        return hash_val[::-1]  # 反转哈希值作为签名

    def _verify_with_public_key(self, hash_val, signature):
        """
        模拟公钥验证过程。
        """
        # 验证签名是否与原哈希值匹配
        return hash_val == signature[::-1]

# 示例使用
private_key = "user_private_key"
ds = DigitalSignature(private_key)

message = "Hello, SM3 with Digital Signature!"
signature = ds.sign(message)
print(f"消息签名: {signature}")

if ds.verify(message, signature):
    print("签名验证成功！消息未被篡改。")
else:
    print("签名验证失败！消息可能已被篡改。")

总结

本文详细介绍了 SM3 算法的原理和 Python 实现，并提供了一个基于 SM3 的数字签名验证示例。SM3 算法在中国的密码标准中起着重要作用，其高效性和安全性使其成为密码系统中数据完整性和认证的重要工具。掌握 SM3 算法的实现和应用，可以帮助更好地理解和使用现代密码学技术。