SM3算法的实现

SM3算法的具体过程参考：sm3加密算法

完整代码如下：

# 初始值
iv = 0x7380166f4914b2b9172442d7da8a0600a96f30bc163138aae38dee4db0fb0e4e
MAX = 2 ** 32


# 算法常量 随j的变化取不同的值
def Tj(j):
    if j <= 15:
        return 0x79cc4519
    else:
        return 0x7a879d8a


# 布尔函数FF 随j的变化取不同的表达式
def FF(x, y, z, j):
    if j <= 15:
        return x ^ y ^ z
    else:
        return (x & y) | (x & z) | (y & z)


# 布尔函数GG 随j的变化取不同的表达式
def GG(x, y, z, j):
    if j <= 15:
        return x ^ y ^ z
    else:
        return (x & y) | ((x ^ 0xFFFFFFFF) & z)


# 置换函数p0 压缩函数中的置换函数
def p0(x):
    return x ^ rotate_left(x, 9) ^ rotate_left(x, 17)


# 置换函数P1 消息扩展中的置换函数
def p1(x):
    return x ^ rotate_left(x, 15) ^ rotate_left(x, 23)


# 对消息进行填充，“1”+k个“0” 填充后的消息满足:(l+1+k) mod 512 = 448 k取最小非负整数
# 添加1、0后再添加一个64位比特串，该比特串是长度的二进制表示。填充后消息的比特长度为512的倍数
def filling(msg_bin):
    l = len(msg_bin)
    k = 448 - (l + 1) % 512
    if k < 0:
        k += 512
    l_bin = int2bin(l, 64)
    msg_filled = msg_bin + '1' + '0' * k + l_bin
    return msg_filled


# 迭代过程 迭代压缩后的消息，长度为64的字符串
def iteration(msg):
    # 将填充后的消息按512比特进行分组
    n = len(msg) // 512
    b = []
    for i in range(n):
        b.append(msg[512 * i:512 * (i + 1)])
    # 对消息进行迭代
    v = [int2bin(iv, 256)]
    for i in range(n):
        v.append(cf(v[i], b[i]))

    return bin2hex(v[n], 64)


# 对消息进行扩展 将消息分组bi扩展生成132个字W0, W1, · · · , W67, W0', W1', · · · , W63'，用于压缩函数CF
# w为68字的list, w1为64字的list
def expand(bi):
    # 将消息分组Bi划分为16个字W0, W1, · · · , W15
    w = []
    for j in range(16):
        w.append(int(bi[j * 32:(j + 1) * 32], 2))

    for j in range(16, 68):
        w_j = p1(w[j - 16] ^ w[j - 9] ^ rotate_left(w[j - 3], 15)) ^ rotate_left(w[j - 13], 7) ^ w[j - 6]
        w.append(w_j)

    w1 = []
    for j in range(64):
        w1.append(w[j] ^ w[j + 4])
    return w, w1


# 压缩函数，压缩后的比特串为256位
def cf(vi, bi):
    # 对bi进行消息扩展
    w, w1 = expand(bi)
    # 将vi拆分为 a~h 8个字 a~h为字寄存器
    t = []
    for i in range(8):
        t.append(int(vi[i * 32:(i + 1) * 32], 2))
    a, b, c, d, e, f, g, h = t
    # ss1,ss2,tt1,tt2为中间变量
    for j in range(64):
        ss1 = rotate_left((rotate_left(a, 12) + e + rotate_left(Tj(j), j)) % MAX, 7)
        ss2 = ss1 ^ rotate_left(a, 12)
        tt1 = (FF(a, b, c, j) + d + ss2 + w1[j]) % MAX
        tt2 = (GG(e, f, g, j) + h + ss1 + w[j]) % MAX
        d = c
        c = rotate_left(b, 9)
        b = a
        a = tt1
        h = g
        g = rotate_left(f, 19)
        f = e
        e = p0(tt2)

    vi_1 = int2bin(a, 32) + int2bin(b, 32) + int2bin(c, 32) + int2bin(d, 32) \
           + int2bin(e, 32) + int2bin(f, 32) + int2bin(g, 32) + int2bin(h, 32)
    vi_1 = int(vi_1, 2) ^ int(vi, 2)

    return int2bin(vi_1, 256)


# 将字符串转化为比特串
def str2bin(msg):
    l = len(msg)
    s_dec = 0
    for m in msg:
        s_dec = s_dec << 8
        s_dec += ord(m)

    msg_bin = bin(s_dec)[2:].zfill(l * 8)
    return msg_bin


# 将整数转化为比特串
def int2bin(a, k):
    return bin(a)[2:].zfill(k)


# 将整数转化为16进制的字符串
def int2hex(a, k):
    return hex(a)[2:].zfill(k)


# 将比特串转化为16进制的字符串
def bin2hex(a, k):
    return hex(int(a, 2))[2:].zfill(k)


# （字）循环左移k比特
def rotate_left(a, k):
    k = k % 32
    return ((a << k) & 0xFFFFFFFF) | ((a & 0xFFFFFFFF) >> (32 - k))


# sm3加密
def sm3(msg):
    # 字符串转化为比特串
    s_bin = str2bin(msg)
    # 消息填充
    s_fill = filling(s_bin)
    # 迭代压缩
    s_sm3 = iteration(s_fill)
    return s_sm3


if __name__ == "__main__":
    message = input('请输入明文：')
    message_sm3 = sm3(message)
    print(f'明文 {message} 加密的结果为：{message_sm3}')

运行结果展示