devbox
ex123
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

国密算法 SM2 公钥加密 非对称加密 数字签名 密钥协商 python实现完整代码_python sm2加密

作者：ex123 | 2024-01-31 08:50:01

赞

踩

python sm2加密

SM2算法是国家密码管理局于2010年12月颁布的中国商用公钥密码标准算法。SM2基于椭圆曲线离散对数问题，计算复杂度是指数级（暂未发现亚指数级或多项式级的计算方法），相较于广泛应用的RSA公钥密码算法，在同等安全程度要求下，SM2所需密钥长度小、处理速度快。由于SM2在安全性、运算性能等方面都优于RSA算法，且具有自主知识产权，我国计划在商用密码体系中用SM2替换RSA算法。

椭圆曲线密码（ECC）的安全性明显强于RSA，参考下图：

采用Python语言编写的国密工具包主要是gmssl-python库和snowland-smx-python（pysmx）库，二者较为完整地实现了SM2、SM3、SM4等国密算法。本工具包涉及的散列运算使用了pysmx库的SM3算法，pysmx库对SM3算法的实现高效而优雅，在此向pysmx库的作者致以诚挚的敬意和感谢！

相较于现有Python国密算法工具包的SM2模块，本工具包的优势主要体现在以下3个方面：

1. 首次开源SM2密钥协商算法。gmssl库和pysmx库仅实现了SM2签名和验证、加密和解密算法，没有实现SM2密钥协商算法，互联网上也未找到实现SM2密钥协商算法的Python代码，故本工具包是首次在互联网上开源SM2密钥协商算法的Python代码。

2. 算法实现更为健壮和完整。gmssl库和pysmx库中的椭圆曲线点乘算法仅能输入有限域内的乘数（否则报错），所实现的SM2签名/验证算法不包含标准要求的Z值计算和Hash变换，除核心算法（密钥生成、签名、验证、加密、解密等）之外还缺少标准描述的一些辅助算法，gmssl库仅能输入bytes类型消息；本工具包的点乘算法能够输入任意自然数作为乘数并保证正确性，SM2签名/验证算法完整实现了Z值计算和Hash变换，除核心算法之外还实现了标准描述的一些重要辅助函数（如公钥验证、椭圆曲线系统参数验证等）。

3. 性能更佳。本工具包通过采用更高效的点乘算法、减少数据类型转换、充分运用算术运算加速技巧等途径，明显提高了计算效率。以SM2算法耗时的主要来源——椭圆曲线点乘运算为例进行测试，同等条件下本工具包的平均耗时约为gmssl库的35.5%、pysmx库的61.8%，实际运行签名与验证、加解密等算法同样具备上述幅度的性能优势。

上图中的前三个算法是本工具包实现的（具体描述参考国密局2010年SM2文档，下有链接），实测算法2性能最好，默认用的算法2。

对于需应用国密SM2算法的Python项目，可直接调用本工具包实现SM2数字签名与验证、加解密以及密钥协商等功能，也可基于本工具包提供的椭圆曲线运算相关函数自行设计算法和协议。

参考文献：

  1. 国家密码管理局关于发布《SM2椭圆曲线公钥密码算法》公告[EB/OL]．(2010-12-17) [2022-02-20]．https://sca.gov.cn/sca/xwdt/2010-12/17/content_1002386.shtml．
  2. GMSSL[EB/OL]．(2020-12-09) [2022-02-20]．https://github.com/duanhongyi/gmssl．
  3. snowland-smx[EB/OL]．(2021-01-27) [2022-02-20]．https://gitee.com/snowlandltd/ snowland-smx-python．

“没有网络安全，就没有国家安全。”让我们共同努力，推动国密算法更深层次、更广泛的研究和应用，为国家网络信息安全和自主化尽绵薄之力。

是否觉得看到上面一句就结束了？O(∩_∩)O

代码分三个部分，第一部分是椭圆曲线基础运算封装的类，第二部分是SM2封装的类，第三部分是测试代码。最简单而安全的密钥协商，可以用里面的ECDH，运行很快，当然SM2更安全！同时致敬DH算法，为信息网络安全耕耘已近半个世纪！几种密钥协商算法的运行时间如下图所示：

上图结果均不包括通信开销，其中ECDH和SM2用的是SM2 GB（GB/T 32918.5-2017，信息安全技术 SM2椭圆曲线公钥密码算法 第5部分：参数定义）规定的椭圆曲线参数（与参考文献1《SM2椭圆曲线公钥密码算法》中推荐的参数是一样的），这也是本工具包默认使用的参数。

测试代码按照参考文献1（国密局2010年《SM2椭圆曲线公钥密码算法》）的参数，复现了其结果，说明代码实现是标准且正确的。由于要复现结果，测试代码调用函数的时候输入了固定参数，其实好多参数是不用输入的，不输入就会使用SM2默认参数，或者随机数。

废话不多说了，代码中有详尽注释。SM2怎么用？照着测试代码用就行！

 下面是完整代码（是否完整？能不能跑？一试便知！）。

  1. import random
  2. import time
  3. import math
  4. import numpy as np
  5. from pysmx.SM3 import digest as sm3
  6.  
  7. # 小素数列表，加快判断素数速度
  8. small_primes = np.array([2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
  9.                          43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109,
  10.                          113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191,
  11.                          193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269,
  12.                          271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353,
  13.                          359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439,
  14.                          443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523,
  15.                          541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617,
  16.                          619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709,
  17.                          719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,
  18.                          821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907,
  19.                          911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997])
  20.  
  21.  
  22. def is_prime(num):
  23.     # 排除0,1和负数
  24.     if num < 2:
  25.         return False
  26.     # 排除小素数的倍数
  27.     for prime in small_primes:
  28.         if num % prime == 0:
  29.             return False
  30.     # 未分辨出来的大整数用rabin算法判断
  31.     return rabin_miller(num)
  32.  
  33.  
  34. def rabin_miller(num):
  35.     s = num - 1
  36.     t = 0
  37.     while s & 1 == 0:
  38.         s >>= 1
  39.         t += 1
  40.     for trials in range(5):
  41.         a = random.randrange(2, num - 1)
  42.         v = pow(a, s, num)
  43.         if v != 1:
  44.             i = 0
  45.             while v != (num - 1):
  46.                 if i == t - 1:
  47.                     return False
  48.                 else:
  49.                     i = i + 1
  50.                     v = v * v % num
  51.     return True
  52.  
  53.  
  54. # 将字节转换为int
  55. def to_int(byte):
  56.     return int.from_bytes(byte, byteorder='big')
  57.  
  58.  
  59. # 转换为bytes，第二参数为字节数（可不填）
  60. def to_byte(x, size=None):
  61.     if isinstance(x, int):
  62.         if size is None:  # 计算合适的字节数
  63.             size = 0
  64.             tmp = x >> 64
  65.             while tmp:
  66.                 size += 8
  67.                 tmp >>= 64
  68.             tmp = x >> (size << 3)
  69.             while tmp:
  70.                 size += 1
  71.                 tmp >>= 8
  72.         elif x >> (size << 3):  # 指定的字节数不够则截取低位
  73.             x &= (1 << (size << 3)) - 1
  74.         return x.to_bytes(size, byteorder='big')
  75.     elif isinstance(x, str):
  76.         x = x.encode()
  77.         if size != None and len(x) > size:  # 超过指定长度
  78.             x = x[:size]  # 截取左侧字符
  79.         return x
  80.     elif isinstance(x, bytes):
  81.         if size != None and len(x) > size:  # 超过指定长度
  82.             x = x[:size]  # 截取左侧字节
  83.         return x
  84.     elif isinstance(x, tuple) and len(x) == 2 and type(x[0]) == type(x[1]) == int:
  85.         # 针对坐标形式(x, y)
  86.         return to_byte(x[0], size) + to_byte(x[1], size)
  87.     return bytes(x)
  88.  
  89.  
  90. # 将列表元素转换为bytes并连接
  91. def join_bytes(data_list):
  92.     return b''.join([to_byte(i) for i in data_list])
  93.  
  94.  
  95. # 求最大公约数
  96. def gcd(a, b):
  97.     return a if b == 0 else gcd(b, a % b)
  98.  
  99.  
  100. # 求乘法逆元过程中的辅助递归函数
  101. def get_(a, b):
  102.     if b == 0:
  103.         return 1, 0
  104.     x1, y1 = get_(b, a % b)
  105.     x, y = y1, x1 - a // b * y1
  106.     return x, y
  107.  
  108.  
  109. # 求乘法逆元
  110. def get_inverse(a, p):
  111.     # return pow(a, p-2, p) # 效率较低、n倍点的时候两种计算方法结果会有不同
  112.     if gcd(a, p) == 1:
  113.         x, y = get_(a, p)
  114.         return x % p
  115.     return 1
  116.  
  117.  
  118. def get_cpu_time():
  119.     return time.perf_counter()
  120.  
  121.  
  122. # 密钥派生函数（从一个共享的秘密比特串中派生出密钥数据）
  123. # SM2第3部分 5.4.3
  124. # Z为bytes类型
  125. # klen表示要获得的密钥数据的比特长度（8的倍数），int类型
  126. # 输出为bytes类型
  127. def KDF(Z, klen):
  128.     ksize = klen >> 3
  129.     K = bytearray()
  130.     for ct in range(1, math.ceil(ksize / HASH_SIZE) + 1):
  131.         K.extend(sm3(Z + to_byte(ct, 4)))
  132.     return K[:ksize]
  133.  
  134.  
  135. # 计算比特位数
  136. def get_bit_num(x):
  137.     if isinstance(x, int):
  138.         num = 0
  139.         tmp = x >> 64
  140.         while tmp:
  141.             num += 64
  142.             tmp >>= 64
  143.         tmp = x >> num >> 8
  144.         while tmp:
  145.             num += 8
  146.             tmp >>= 8
  147.         x >>= num
  148.         while x:
  149.             num += 1
  150.             x >>= 1
  151.         return num
  152.     elif isinstance(x, str):
  153.         return len(x.encode()) << 3
  154.     elif isinstance(x, bytes):
  155.         return len(x) << 3
  156.     return 0
  157.  
  158.  
  159. # 椭圆曲线密码类（实现一般的EC运算，不局限于SM2）
  160. class ECC:
  161.     def __init__(self, p, a, b, n, G, h=None):
  162.         self.p = p
  163.         self.a = a
  164.         self.b = b
  165.         self.n = n
  166.         self.G = G
  167.         if h:
  168.             self.h = h
  169.         self.O = (-1, -1)  # 定义仿射坐标下无穷远点（零点）
  170.  
  171.         # 预先计算Jacobian坐标两点相加时用到的常数
  172.         self._2 = get_inverse(2, p)
  173.         self.a_3 = (a + 3) % p
  174.  
  175.     # 椭圆曲线上两点相加（仿射坐标）
  176.     # SM2第1部分 3.2.3.1
  177.     # 仅提供一个参数时为相同坐标点相加
  178.     def add(self, P1, P2=None):
  179.         x1, y1 = P1
  180.         if P2 is None or P1 == P2:  # 相同坐标点相加
  181.             # 处理无穷远点
  182.             if P1 == self.O:
  183.                 return self.O
  184.             # 计算斜率k（k已不具备明确的几何意义）
  185.             k = (3 * x1 * x1 + self.a) * get_inverse(2 * y1, self.p) % self.p
  186.             # 计算目标点坐标
  187.             x3 = (k * k - x1 - x1) % self.p
  188.             y3 = (k * (x1 - x3) - y1) % self.p
  189.         else:
  190.             x2, y2 = P2
  191.             # 处理无穷远点
  192.             if P1 == self.O:
  193.                 return P2
  194.             if P2 == self.O:
  195.                 return P1
  196.             if x1 == x2:
  197.                 return self.O
  198.             # 计算斜率k
  199.             k = (y2 - y1) * get_inverse(x2 - x1, self.p) % self.p
  200.             # 计算目标点坐标
  201.             x3 = (k * k - x1 - x2) % self.p
  202.             y3 = (k * (x1 - x3) - y1) % self.p
  203.         return x3, y3
  204.  
  205.     # 椭圆曲线上的点乘运算（仿射坐标）
  206.     def multiply(self, k, P):
  207.         # 判断常数k的合理性
  208.         assert type(k) is int and k >= 0, 'factor value error'
  209.         # 处理无穷远点
  210.         if k == 0 or P == self.O:
  211.             return self.O
  212.         if k == 1:
  213.             return P
  214.         elif k == 2:
  215.             return self.add(P)
  216.         elif k == 3:
  217.             return self.add(P, self.add(P))
  218.         elif k & 1 == 0:  # k/2 * P + k/2 * P
  219.             return self.add(self.multiply(k >> 1, P))
  220.         elif k & 1 == 1:  # P + k/2 * P + k/2 * P
  221.             return self.add(P, self.add(self.multiply(k >> 1, P)))
  222.  
  223.     # 输入P，返回-P
  224.     def minus(self, P):
  225.         Q = list(P)
  226.         Q[1] = -Q[1]
  227.         return tuple(Q)
  228.  
  229.     # Jacobian加重射影坐标下两点相加
  230.     # SM2第1部分 A.1.2.3.2
  231.     # 输入点包含两项时为仿射坐标，三项为Jacobian加重射影坐标，两点坐标系可不同
  232.     # 两点相同时省略第二个参数
  233.     def Jacb_add(self, P1, P2=None):
  234.         if P2 is None or P1 == P2:  # 相同点相加
  235.             # 处理无穷远点
  236.             if P1 == self.O:
  237.                 return self.O
  238.  
  239.             # 根据参数包含的项数判断坐标系（是仿射坐标则转Jacobian坐标）
  240.             x1, y1, z1 = P1 if len(P1) == 3 else (*P1, 1)
  241.  
  242.             # t1 = 3 * x1**2 + self.a * pow(z1, 4, self.p)
  243.             # t2 = 4 * x1 * y1**2
  244.             # t3 = 8 * pow(y1, 4, self.p)
  245.             # x3 = (t1**2 - 2 * t2) % self.p
  246.             # y3 = (t1 * (t2 - x3) - t3) % self.p
  247.             # z3 = 2 * y1 * z1 % self.p            
  248.             z3 = (y1 * z1 << 1) % self.p
  249.             if z3 == 0:  # 处理无穷远点
  250.                 return self.O
  251.             T2 = y1 * y1 % self.p
  252.             T4 = (T2 << 3) % self.p
  253.             T5 = x1 * T4 % self.p
  254.             T6 = z1 * z1 % self.p
  255.             T1 = (x1 + T6) * (x1 - T6) * 3 % self.p
  256.             T1 = (T1 + self.a_3 * T6 * T6) % self.p
  257.             T3 = T1 * T1 % self.p
  258.             T2 = T2 * T4 % self.p
  259.             x3 = (T3 - T5) % self.p
  260.             T4 = T5 + (T5 + self.p >> 1) - T3 if T5 & 1 else T5 + (T5 >> 1) - T3
  261.             T1 = T1 * T4 % self.p
  262.             y3 = (T1 - T2) % self.p
  263.         else:  # 不同点相加
  264.             # 处理无穷远点
  265.             if P1 == self.O:
  266.                 return P2
  267.             if P2 == self.O:
  268.                 return P1
  269.  
  270.             # 根据参数包含的项数判断坐标系（是仿射坐标则转Jacobian坐标）
  271.             x1, y1, z1 = P1 if len(P1) == 3 else (*P1, 1)
  272.             x2, y2, z2 = P2 if len(P2) == 3 else (*P2, 1)
  273.  
  274.             if z2 != 1 and z1 != 1:
  275.                 z1_2 = z1 * z1 % self.p
  276.                 z2_2 = z2 * z2 % self.p
  277.                 t1 = x1 * z2_2 % self.p
  278.                 t2 = x2 * z1_2 % self.p
  279.                 t3 = t1 - t2
  280.                 z3 = z1 * z2 * t3 % self.p
  281.                 if z3 == 0:  # 处理无穷远点
  282.                     return self.O
  283.                 t4 = y1 * z2 * z2_2 % self.p
  284.                 t5 = y2 * z1 * z1_2 % self.p
  285.                 t6 = t4 - t5
  286.                 t7 = t1 + t2
  287.                 t8 = t4 + t5
  288.                 t3_2 = t3 * t3 % self.p
  289.                 x3 = (t6 * t6 - t7 * t3_2) % self.p
  290.                 t9 = (t7 * t3_2 - (x3 << 1)) % self.p
  291.                 y3 = (t9 * t6 - t8 * t3 * t3_2) * self._2 % self.p
  292.             else:  # 可简化计算
  293.                 if z1 == 1:  # 确保第二个点的z1=1
  294.                     x1, y1, z1, x2, y2 = x2, y2, z2, x1, y1
  295.                 T1 = z1 * z1 % self.p
  296.                 T2 = y2 * z1 % self.p
  297.                 T3 = x2 * T1 % self.p
  298.                 T1 = T1 * T2 % self.p
  299.                 T2 = T3 - x1
  300.                 z3 = z1 * T2 % self.p
  301.                 if z3 == 0:  # 处理无穷远点
  302.                     return self.O
  303.                 T3 = T3 + x1
  304.                 T1 = T1 - y1
  305.                 T4 = T2 * T2 % self.p
  306.                 T5 = T1 * T1 % self.p
  307.                 T2 = T2 * T4 % self.p
  308.                 T3 = T3 * T4 % self.p
  309.                 T4 = x1 * T4 % self.p
  310.                 x3 = T5 - T3 % self.p
  311.                 T2 = y1 * T2 % self.p
  312.                 T3 = T4 - x3
  313.                 T1 = T1 * T3 % self.p
  314.                 y3 = T1 - T2 % self.p
  315.                 # T1 = z1 * z1 % self.p
  316.                 # T3 = x2 * T1 % self.p
  317.                 # T2 = T3 - x1
  318.                 # z3 = z1 * T2 % self.p
  319.                 # if z3 == 0: # 处理无穷远点
  320.                 # return self.O
  321.                 # T1 = (T1 * y2 * z1  - y1) % self.p
  322.                 # T4 = T2 * T2 % self.p
  323.                 # x3 = T1 * T1 - (T3 + x1) * T4 % self.p
  324.                 # T1 = T1 * (x1 * T4 - x3) % self.p
  325.                 # y3 = T1 - y1 * T2 * T4 % self.p
  326.  
  327.         return x3, y3, z3
  328.  
  329.     # Jacobian加重射影坐标下的点乘运算
  330.     # SM2第1部分 A.3
  331.     # 输入点包含两项时为仿射坐标，三项为Jacobian坐标
  332.     # conv=True时结果转换为仿射坐标，否则不转换
  333.     # algo表示选择的算法， r表示算法三（滑动窗法）的窗口值
  334.     def Jacb_multiply(self, k, P, conv=True, algo=2, r=5):
  335.         # 处理无穷远点
  336.         if k == 0 or P == self.O:
  337.             return self.O
  338.  
  339.         # 仿射坐标转Jacobian坐标
  340.         # if len(P) == 2: 
  341.         # P = (*P, 1)
  342.  
  343.         # 算法一：二进制展开法
  344.         if algo == 1:
  345.             Q = P
  346.             for i in bin(k)[3:]:
  347.                 Q = self.Jacb_add(Q)
  348.                 if i == '1':
  349.                     Q = self.Jacb_add(Q, P)
  350.  
  351.         # 算法二：加减法
  352.         elif algo == 2:
  353.             h = bin(3 * k)[2:]
  354.             k = bin(k)[2:]
  355.             k = '0' * (len(h) - len(k)) + k
  356.             Q = P
  357.             minusP = self.minus(P)
  358.             for i in range(1, len(h) - 1):
  359.                 Q = self.Jacb_add(Q)
  360.                 if h[i] == '1' and k[i] == '0':
  361.                     Q = self.Jacb_add(Q, P)
  362.                 elif h[i] == '0' and k[i] == '1':
  363.                     Q = self.Jacb_add(Q, minusP)
  364.  
  365.         # 算法三：滑动窗法
  366.         # 当k为255/256位时，通过test_r函数测试，r=5复杂度最低
  367.         elif algo == 3:
  368.             k = bin(k)[2:]
  369.             l = len(k)
  370.             if r >= l:  # 如果窗口大于k的二进制位数，则本算法无意义
  371.                 return self.Jacb_multiply(int(k, 2), P, conv, 2)
  372.  
  373.             # 保存P[j]值的字典
  374.             P_ = {1: P, 2: self.Jacb_add(P)}
  375.             for i in range(1, 1 << (r - 1)):
  376.                 P_[(i << 1) + 1] = self.Jacb_add(P_[(i << 1) - 1], P_[2])
  377.  
  378.             t = r
  379.             while k[t - 1] != '1':
  380.                 t -= 1
  381.             hj = int(k[:t], 2)
  382.             Q = P_[hj]
  383.             j = t
  384.             while j < l:
  385.                 if k[j] == '0':
  386.                     Q = self.Jacb_add(Q)
  387.                     j += 1
  388.                 else:
  389.                     t = min(r, l - j)
  390.                     while k[j + t - 1] != '1':
  391.                         t -= 1
  392.                     hj = int(k[j:j + t], 2)
  393.                     Q = self.Jacb_add(self.Jacb_multiply(1 << t, Q, False, 2), P_[hj])
  394.                     j += t
  395.  
  396.         return self.Jacb_to_affine(Q) if conv else Q
  397.  
  398.     # Jacobian加重射影坐标转仿射坐标
  399.     # SM2第1部分 A.1.2.3.2
  400.     def Jacb_to_affine(self, P):
  401.         if len(P) == 2:  # 已经是仿射坐标
  402.             return P
  403.         x, y, z = P
  404.         # 处理无穷远点
  405.         if z == 0:
  406.             return self.O
  407.         z_ = get_inverse(z, self.p)  # z的乘法逆元
  408.         x2 = x * z_ * z_ % self.p
  409.         y2 = y * z_ * z_ * z_ % self.p
  410.         return x2, y2
  411.  
  412.     # 判断是否为无穷远点（零点）
  413.     def is_zero(self, P):
  414.         if len(P) == 2:  # 仿射坐标
  415.             return P == self.O
  416.         else:  # Jacobian加重射影坐标
  417.             return P[2] == 0
  418.  
  419.     # 判断是否为域Fp中的元素
  420.     # 可输入多个元素，全符合才返回True
  421.     def on_Fp(self, *x):
  422.         for i in x:
  423.             if 0 <= i < self.p:
  424.                 pass
  425.             else:
  426.                 return False
  427.         return True
  428.  
  429.     # 判断是否在椭圆曲线上
  430.     def on_curve(self, P):
  431.         if self.is_zero(P):
  432.             return False
  433.         if len(P) == 2:  # 仿射坐标
  434.             x, y = P
  435.             return y * y % self.p == (x * x * x + self.a * x + self.b) % self.p
  436.         else:  # Jacobian加重射影坐标
  437.             x, y, z = P
  438.             return y * y % self.p == (x * x * x + self.a * x * pow(z, 4, self.p) + self.b * pow(z, 6, self.p)) % self.p
  439.  
  440.     # 生成密钥对
  441.     # 返回值：d为私钥，P为公钥
  442.     # SM2第1部分 6.1
  443.     def gen_keypair(self):
  444.         d = random.randint(1, self.n - 2)
  445.         P = self.Jacb_multiply(d, self.G)
  446.         return d, P
  447.  
  448.     # 公钥验证
  449.     # SM2第1部分 6.2.1
  450.     def pk_valid(self, P):
  451.         # 判断点P的格式
  452.         if P and len(P) == 2 and type(P[0]) == type(P[1]) == int:
  453.             pass
  454.         else:
  455.             self.error = '格式有误'  # 记录错误信息
  456.             return False
  457.         # a) 验证P不是无穷远点O
  458.         if self.is_zero(P):
  459.             self.error = '无穷远点'
  460.             return False
  461.         # b) 验证公钥P的坐标xP和yP是域Fp中的元素
  462.         if not self.on_Fp(*P):
  463.             self.error = '坐标值不是域Fp中的元素'
  464.             return False
  465.         # c) 验证y^2 = x^3 + ax + b (mod p)
  466.         if not self.on_curve(P):
  467.             self.error = '不在椭圆曲线上'
  468.             return False
  469.         # d) 验证[n]P = O
  470.         if not self.is_zero(self.Jacb_multiply(self.n, P, False)):
  471.             self.error = '[n]P不是无穷远点'
  472.             return False
  473.         return True
  474.  
  475.     # 确认目前已有公私钥对
  476.     def confirm_keypair(self):
  477.         if not hasattr(self, 'pk') or not self.pk_valid(self.pk) or self.pk != self.Jacb_multiply(self.sk, self.G):
  478.             # 目前没有合格的公私钥对则生成
  479.             while True:
  480.                 d, P = self.gen_keypair()
  481.                 if self.pk_valid(P):  # 确保公钥通过验证
  482.                     self.sk, self.pk = d, P
  483.                     return
  484.  
  485.  
  486. # 国家密码管理局：SM2椭圆曲线公钥密码算法推荐曲线参数
  487. SM2_p = 0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF
  488. SM2_a = 0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC
  489. SM2_b = 0x28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93
  490. SM2_n = 0xFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123
  491. SM2_Gx = 0x32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7
  492. SM2_Gy = 0xBC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0
  493.  
  494. PARA_SIZE = 32  # 参数长度（字节）
  495. HASH_SIZE = 32  # sm3输出256位（32字节）
  496. KEY_LEN = 128  # 默认密钥位数
  497.  
  498.  
  499. # SM2类继承ECC
  500. class SM2(ECC):
  501.     # 默认使用SM2推荐曲线参数
  502.     def __init__(self, p=SM2_p, a=SM2_a, b=SM2_b, n=SM2_n, G=(SM2_Gx, SM2_Gy), h=None,
  503.                  ID=None, sk=None, pk=None, genkeypair=True):  # genkeypair表示是否自动生成公私钥对
  504.         if not h:  # 余因子h默认为1
  505.             h = 1
  506.         ECC.__init__(self, p, a, b, n, G, h)
  507.  
  508.         self.keysize = len(to_byte(n))  # 密钥长度（字节）
  509.         if type(ID) in (int, str):  # 身份ID（数字或字符串）
  510.             self.ID = ID
  511.         else:
  512.             self.ID = ''
  513.         if sk and pk:  # 如果提供的公私钥对通过验证，即使genkeypair=True也不会重新生成
  514.             self.sk = sk  # 私钥（int [1,n-2]）
  515.             self.pk = pk  # 公钥（x, y）
  516.             self.confirm_keypair()  # 验证该公私钥对，不合格则生成
  517.         elif genkeypair:  # 自动生成合格的公私钥对
  518.             self.confirm_keypair()
  519.  
  520.         # 预先计算用到的常数
  521.         if hasattr(self, 'sk'):  # 签名时
  522.             self.d_1 = get_inverse(1 + self.sk, self.n)
  523.  
  524.     # 椭圆曲线系统参数验证
  525.     # SM2第1部分 5.2.2
  526.     def para_valid(self):
  527.         # a) 验证q = p是奇素数
  528.         if not is_prime(self.p):
  529.             self.error = 'p不是素数'  # 记录错误信息
  530.             return False
  531.         # b) 验证a、b、Gx和Gy是区间[0, p−1]中的整数
  532.         if not self.on_Fp(self.a, self.b, *self.G):
  533.             self.error = 'a、b或G坐标值不是域Fp中的元素'
  534.             return False
  535.         # d) 验证(4a^3 + 27b^2) mod p != 0
  536.         if (4 * self.a * self.a * self.a + 27 * self.b * self.b) % self.p == 0:
  537.             self.error = '(4a^3 + 27b^2) mod p = 0'
  538.             return False
  539.         # e) 验证Gy^2 = Gx^3 + aGx + b (mod p)
  540.         if not self.on_curve(self.G):
  541.             self.error = 'G不在椭圆曲线上'
  542.             return False
  543.         # f) 验证n是素数，n > 2^191 且 n > 4p^1/2
  544.         if not is_prime(self.n) or self.n <= 1 << 191 or self.n <= 4 * self.p ** 0.5:
  545.             self.error = 'n不是素数或n不够大'
  546.             return False
  547.         # g) 验证[n]G = O
  548.         if not self.is_zero(self.Jacb_multiply(self.n, self.G, False)):
  549.             self.error = '[n]G不是无穷远点'
  550.             return False
  551.         # i) 验证抗MOV攻击条件和抗异常曲线攻击条件成立（A.4.2.1）
  552.         B = 27  # MOV阈B
  553.         t = 1
  554.         for i in range(B):
  555.             t = t * self.p % self.n
  556.             if t == 1:
  557.                 self.error = '不满足抗MOV攻击条件'
  558.                 return False
  559.         # 椭圆曲线的阶N=#E(Fp)计算太复杂，未实现A.4.2.2验证
  560.         # Fp上的绝大多数椭圆曲线确实满足抗异常曲线攻击条件
  561.         return True
  562.  
  563.     # 计算Z
  564.     # SM2第2部分 5.5
  565.     # ID为数字或字符串，P为公钥（不提供参数时返回自身Z值）
  566.     def get_Z(self, ID=None, P=None):
  567.         save = False
  568.         if not P:  # 不提供参数
  569.             if hasattr(self, 'Z'):  # 再次计算，返回曾计算好的自身Z值
  570.                 return self.Z
  571.             else:  # 首次计算自身Z值
  572.                 ID = self.ID
  573.                 P = self.pk
  574.                 save = True
  575.         entlen = get_bit_num(ID)
  576.         ENTL = to_byte(entlen, 2)
  577.         Z = sm3(join_bytes([ENTL, ID, self.a, self.b, *self.G, *P]))
  578.         if save:  # 保存自身Z值
  579.             self.Z = Z
  580.         return Z
  581.  
  582.     # 数字签名
  583.     # SM2第2部分 6.1
  584.     # 输入：待签名的消息M、随机数k（不填则自动生成）、输出类型（默认bytes）、对M是否hash（默认是）
  585.     # 输出：r, s（int类型）或拼接后的bytes
  586.     def sign(self, M, k=None, outbytes=True, dohash=True):
  587.         if dohash:
  588.             M_ = join_bytes([self.get_Z(), M])
  589.             e = to_int(sm3(M_))
  590.         else:
  591.             e = to_int(to_byte(M))
  592.         while True:
  593.             if not k:
  594.                 k = random.randint(1, self.n - 1)
  595.             # x1, y1 = self.multiply(k, self.G)
  596.             x1, y1 = self.Jacb_multiply(k, self.G)
  597.             r = (e + x1) % self.n
  598.             if r == 0 or r + k == self.n:
  599.                 k = 0
  600.                 continue
  601.             # s = get_inverse(1 + self.sk, self.n) * (k - r * self.sk) % self.n
  602.             s = self.d_1 * (k - r * self.sk) % self.n
  603.             if s == 0:
  604.                 k = 0
  605.             else:
  606.                 break
  607.         if outbytes:
  608.             return to_byte((r, s), self.keysize)
  609.         else:
  610.             return r, s
  611.  
  612.     # 数字签名验证
  613.     # SM2第2部分 7.1
  614.     # 输入：收到的消息M′及其数字签名(r′, s′)、签名者的身份标识IDA及公钥PA、对M是否hash（默认是）
  615.     # 输出：True or False
  616.     def verify(self, M, sig, IDA, PA, dohash=True):
  617.         if isinstance(sig, bytes):
  618.             r = to_int(sig[:self.keysize])
  619.             s = to_int(sig[self.keysize:])
  620.         else:
  621.             r, s = sig
  622.         if not 1 <= r <= self.n - 1:
  623.             return False
  624.         if not 1 <= s <= self.n - 1:
  625.             return False
  626.         if dohash:
  627.             M_ = join_bytes([self.get_Z(IDA, PA), M])
  628.             e = to_int(sm3(M_))
  629.         else:
  630.             e = to_int(to_byte(M))
  631.         t = (r + s) % self.n
  632.         if t == 0:
  633.             return False
  634.         sG = self.Jacb_multiply(s, self.G, False)
  635.         tPA = self.Jacb_multiply(t, PA, False)
  636.         x1, y1 = self.Jacb_to_affine(self.Jacb_add(sG, tPA))
  637.         R = (e + x1) % self.n
  638.         if R == r:
  639.             return True
  640.         else:  # 避免Jacobian坐标下的等价点导致判断失败
  641.             x1, y1 = self.add(self.Jacb_to_affine(sG), self.Jacb_to_affine(tPA))
  642.             R = (e + x1) % self.n
  643.             return R == r
  644.  
  645.     # A 发起协商
  646.     # SM2第3部分 6.1 A1-A3
  647.     # 返回rA、RA
  648.     def agreement_initiate(self):
  649.         return self.gen_keypair()
  650.  
  651.     # B 响应协商（option=True时计算选项部分）
  652.     # SM2第3部分 6.1 B1-B9
  653.     def agreement_response(self, RA, PA, IDA, option=False, rB=None, RB=None, klen=None):
  654.         # 参数准备
  655.         if not self.on_curve(RA):
  656.             return False, 'RA不在椭圆曲线上'
  657.         x1, y1 = RA
  658.         w = math.ceil(math.ceil(math.log(self.n, 2)) / 2) - 1
  659.         if not hasattr(self, 'sk'):
  660.             self.confirm_keypair()
  661.         h = 1  # SM2推荐曲线的余因子h=1
  662.         ZA = self.get_Z(IDA, PA)
  663.         ZB = self.get_Z()
  664.         # B1-B7
  665.         if not rB:
  666.             rB, RB = self.gen_keypair()
  667.         x2, y2 = RB
  668.         x_2 = (1 << w) + (x2 & (1 << w) - 1)
  669.         tB = (self.sk + x_2 * rB) % self.n
  670.         x_1 = (1 << w) + (x1 & (1 << w) - 1)
  671.         # V = self.multiply(h * tB, self.add(PA, self.multiply(x_1, RA)))
  672.         V = self.Jacb_multiply(h * tB, self.Jacb_add(self.Jacb_multiply(x_1, RA, False), PA))
  673.         if self.is_zero(V):
  674.             return False, 'V是无穷远点'
  675.         xV, yV = V
  676.         if not klen:
  677.             klen = KEY_LEN
  678.         KB = KDF(join_bytes([xV, yV, ZA, ZB]), klen)
  679.         if not option:
  680.             return True, (RB, KB)
  681.         # B8、B10（可选部分）
  682.         tmp = join_bytes([yV, sm3(join_bytes([xV, ZA, ZB, x1, y1, x2, y2]))])
  683.         SB = sm3(join_bytes([2, tmp]))
  684.         S2 = sm3(join_bytes([3, tmp]))
  685.         return True, (RB, KB, SB, S2)
  686.  
  687.     # A 协商确认
  688.     # SM2第3部分 6.1 A4-A10
  689.     def agreement_confirm(self, rA, RA, RB, PB, IDB, SB=None, option=False, klen=None):
  690.         # 参数准备
  691.         if not self.on_curve(RB):
  692.             return False, 'RB不在椭圆曲线上'
  693.         x1, y1, x2, y2 = *RA, *RB
  694.         w = math.ceil(math.ceil(math.log(self.n, 2)) / 2) - 1
  695.         if not hasattr(self, 'sk'):
  696.             self.confirm_keypair()
  697.         h = 1  # SM2推荐曲线的余因子h=1
  698.         ZA = self.get_Z()
  699.         ZB = self.get_Z(IDB, PB)
  700.         # A4-A8
  701.         x_1 = (1 << w) + (x1 & (1 << w) - 1)
  702.         tA = (self.sk + x_1 * rA) % self.n
  703.         x_2 = (1 << w) + (x2 & (1 << w) - 1)
  704.         # U = self.multiply(h * tA, self.add(PB, self.multiply(x_2, RB)))
  705.         U = self.Jacb_multiply(h * tA, self.Jacb_add(self.Jacb_multiply(x_2, RB, False), PB))
  706.         if self.is_zero(U):
  707.             return False, 'U是无穷远点'
  708.         xU, yU = U
  709.         if not klen:
  710.             klen = KEY_LEN
  711.         KA = KDF(join_bytes([xU, yU, ZA, ZB]), klen)
  712.         if not option or not SB:
  713.             return True, KA
  714.         # A9-A10（可选部分）
  715.         tmp = join_bytes([yU, sm3(join_bytes([xU, ZA, ZB, x1, y1, x2, y2]))])
  716.         S1 = sm3(join_bytes([2, tmp]))
  717.         if S1 != SB:
  718.             return False, 'S1 != SB'
  719.         SA = sm3(join_bytes([3, tmp]))
  720.         return True, (KA, SA)
  721.  
  722.     # B 协商确认（可选部分）
  723.     # SM2第3部分 6.1 B10
  724.     def agreement_confirm2(self, S2, SA):
  725.         if S2 != SA:
  726.             return False, 'S2 != SA'
  727.         return True, ''
  728.  
  729.     # 加密
  730.     # SM2第4部分 6.1
  731.     # 输入：待加密的消息M（bytes或str类型）、对方的公钥PB、随机数k（不填则自动生成）
  732.     # 输出(True, bytes类型密文)或(False, 错误信息)
  733.     def encrypt(self, M, PB, k=None):
  734.         if self.is_zero(self.multiply(self.h, PB)):  # S
  735.             return False, 'S是无穷远点'
  736.         M = to_byte(M)
  737.         klen = get_bit_num(M)
  738.         while True:
  739.             if not k:
  740.                 k = random.randint(1, self.n - 1)
  741.             # x2, y2 = self.multiply(k, PB)
  742.             x2, y2 = self.Jacb_multiply(k, PB)
  743.             t = to_int(KDF(join_bytes([x2, y2]), klen))
  744.             if t == 0:  # 若t为全0比特串则继续循环
  745.                 k = 0
  746.             else:
  747.                 break
  748.         # C1 = to_byte(self.multiply(k, self.G), self.keysize) # (x1, y1)
  749.         C1 = to_byte(self.Jacb_multiply(k, self.G), self.keysize)  # (x1, y1)
  750.         C2 = to_byte(to_int(M) ^ t, klen >> 3)
  751.         C3 = sm3(join_bytes([x2, M, y2]))
  752.         return True, join_bytes([C1, C2, C3])
  753.  
  754.     # 解密
  755.     # SM2第4部分 7.1
  756.     # 输入：密文C（bytes类型）
  757.     # 输出(True, bytes类型明文)或(False, 错误信息)
  758.     def decrypt(self, C):
  759.         x1 = to_int(C[:self.keysize])
  760.         y1 = to_int(C[self.keysize:self.keysize << 1])
  761.         C1 = (x1, y1)
  762.         if not self.on_curve(C1):
  763.             return False, 'C1不满足椭圆曲线方程'
  764.         if self.is_zero(self.multiply(self.h, C1)):  # S
  765.             return False, 'S是无穷远点'
  766.         # x2, y2 = self.multiply(self.sk, C1)
  767.         x2, y2 = self.Jacb_multiply(self.sk, C1)
  768.         klen = len(C) - (self.keysize << 1) - HASH_SIZE << 3
  769.         t = to_int(KDF(join_bytes([x2, y2]), klen))
  770.         if t == 0:
  771.             return False, 't为全0比特串'
  772.         C2 = C[self.keysize << 1:-HASH_SIZE]
  773.         M = to_byte(to_int(C2) ^ t, klen >> 3)
  774.         u = sm3(join_bytes([x2, M, y2]))
  775.         C3 = C[-HASH_SIZE:]
  776.         if u != C3:
  777.             return False, 'u != C3'
  778.         return True, M
  779.  
  780.  
  781. # 最简单的ECDH正确性测试
  782. def test_ECDH(verify=False):
  783.     time_1 = get_cpu_time()
  784.     sm2 = SM2(genkeypair=False)
  785.     # A、B双方生成公、私钥
  786.     dA, PA = sm2.gen_keypair()
  787.     dB, PB = sm2.gen_keypair()
  788.     # 验证ECC系统参数和公钥
  789.     if verify:
  790.         if not sm2.para_valid():
  791.             print('椭圆曲线系统参数未通过验证：%s' % sm2.error)
  792.             return
  793.         if not sm2.pk_valid(PA):
  794.             print('PA未通过验证：%s' % sm2.error)
  795.             return
  796.         if not sm2.pk_valid(PB):
  797.             print('PB未通过验证：%s' % sm2.error)
  798.             return
  799.  
  800.     # A将PA传给B，B将PB传给A
  801.  
  802.     # A、B双方计算密钥
  803.     QA = sm2.Jacb_multiply(dA, PB)
  804.     KA = KDF(to_byte(QA), KEY_LEN)
  805.     QB = sm2.Jacb_multiply(dB, PA)
  806.     KB = KDF(to_byte(QB), KEY_LEN)
  807.     time_2 = get_cpu_time()
  808.     print('ECDH密钥协商完毕，耗时%.2f ms' % ((time_2 - time_1) * 1000))
  809.     print('KA == KB?: %s, value: 0x%s, len: %d' % (KA == KB, KA.hex(), len(KA) << 3))
  810.  
  811.  
  812. # SM2密钥协商测试
  813. def test_SM2_agreement(option=False):
  814.     time_1 = get_cpu_time()
  815.     # A、B双方初始化
  816.     sm2_A = SM2(ID='Alice')
  817.     sm2_B = SM2(ID='Bob')
  818.     # A、B均掌握对方的公钥和ID
  819.     PA, IDA = sm2_A.pk, sm2_A.ID
  820.     PB, IDB = sm2_B.pk, sm2_B.ID
  821.  
  822.     # A 发起协商
  823.     rA, RA = sm2_A.agreement_initiate()
  824.     # A将RA发送给B
  825.  
  826.     # B 响应协商
  827.     res, content = sm2_B.agreement_response(RA, PA, IDA, option)
  828.     if not res:
  829.         print('B报告协商错误：', content)
  830.         return
  831.     if option:
  832.         RB, KB, SB, S2 = content
  833.     else:
  834.         RB, KB = content
  835.         SB = None
  836.     # B将RB、(选项SB)发送给A
  837.  
  838.     # A 协商确认
  839.     res, content = sm2_A.agreement_confirm(rA, RA, RB, PB, IDB, SB, option)
  840.     if not res:
  841.         print('A报告协商错误：', content)
  842.         return
  843.     if option:
  844.         KA, SA = content
  845.     else:
  846.         KA = content
  847.  
  848.     if option:
  849.         # A将(选项SA)发送给B
  850.         # B 协商确认
  851.         res, content = sm2_B.agreement_confirm2(S2, SA)
  852.         if not res:
  853.             print('B报告协商错误：', content)
  854.             return
  855.     time_2 = get_cpu_time()
  856.     print('SM2密钥协商完毕，耗时%.2f ms' % ((time_2 - time_1) * 1000))
  857.     print('KA == KB?: %s, value: 0x%s, len: %d' % (KA == KB, KA.hex(), len(KA) << 3))
  858.  
  859.  
  860. # SM2示例中的椭圆曲线系统参数
  861. def demo_para():
  862.     p = 0x8542D69E4C044F18E8B92435BF6FF7DE457283915C45517D722EDB8B08F1DFC3
  863.     a = 0x787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498
  864.     b = 0x63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A
  865.     xG = 0x421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D
  866.     yG = 0x0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2
  867.     n = 0x8542D69E4C044F18E8B92435BF6FF7DD297720630485628D5AE74EE7C32E79B7
  868.     G = (xG, yG)
  869.     h = 1
  870.     return p, a, b, n, G, h
  871.  
  872.  
  873. # SM2数字签名与验证测试
  874. # SM2第2部分 A.1 A.2
  875. def test_signature():
  876.     IDA = 'ALICE123@YAHOO.COM'
  877.     M = 'message digest'
  878.     dA = 0x128B2FA8BD433C6C068C8D803DFF79792A519A55171B1B650C23661D15897263
  879.     xA = 0x0AE4C7798AA0F119471BEE11825BE46202BB79E2A5844495E97C04FF4DF2548A
  880.     yA = 0x7C0240F88F1CD4E16352A73C17B7F16F07353E53A176D684A9FE0C6BB798E857
  881.     PA = (xA, yA)
  882.     k = 0x6CB28D99385C175C94F94E934817663FC176D925DD72B727260DBAAE1FB2F96F
  883.  
  884.     # A、B双方初始化
  885.     sm2_A = SM2(*demo_para(), IDA, dA, PA)
  886.     sm2_B = SM2(*demo_para())
  887.  
  888.     time_1 = get_cpu_time()
  889.     # A对消息M进行签名
  890.     sig = sm2_A.sign(M, k)
  891.  
  892.     # A将消息M签名(r, s)发送给B
  893.  
  894.     # B对消息M签名进行验证
  895.     res = sm2_B.verify(M, sig, IDA, PA)
  896.     time_2 = get_cpu_time()
  897.     print('SM2签名、验证完毕，耗时%.2f ms' % ((time_2 - time_1) * 1000))
  898.     print('结果：%s，R值：%s' % (res, sig[:sm2_A.keysize].hex()))
  899.     # 验证通过，输出的r值(40f1ec59f793d9f49e09dcef49130d4194f79fb1eed2caa55bacdb49c4e755d1)与SM2第2部分 A.2中的结果一致
  900.  
  901.  
  902. # SM2密钥协商测试2
  903. # SM2第3部分 A.1 A.2
  904. def test_SM2_agreement2(option=False):
  905.     IDA = 'ALICE123@YAHOO.COM'
  906.     IDB = 'BILL456@YAHOO.COM'
  907.     dA = 0x6FCBA2EF9AE0AB902BC3BDE3FF915D44BA4CC78F88E2F8E7F8996D3B8CCEEDEE
  908.     xA = 0x3099093BF3C137D8FCBBCDF4A2AE50F3B0F216C3122D79425FE03A45DBFE1655
  909.     yA = 0x3DF79E8DAC1CF0ECBAA2F2B49D51A4B387F2EFAF482339086A27A8E05BAED98B
  910.     PA = (xA, yA)
  911.     dB = 0x5E35D7D3F3C54DBAC72E61819E730B019A84208CA3A35E4C2E353DFCCB2A3B53
  912.     xB = 0x245493D446C38D8CC0F118374690E7DF633A8A4BFB3329B5ECE604B2B4F37F43
  913.     yB = 0x53C0869F4B9E17773DE68FEC45E14904E0DEA45BF6CECF9918C85EA047C60A4C
  914.     PB = (xB, yB)
  915.     rA = 0x83A2C9C8B96E5AF70BD480B472409A9A327257F1EBB73F5B073354B248668563
  916.     x1 = 0x6CB5633816F4DD560B1DEC458310CBCC6856C09505324A6D23150C408F162BF0
  917.     y1 = 0x0D6FCF62F1036C0A1B6DACCF57399223A65F7D7BF2D9637E5BBBEB857961BF1A
  918.     RA = (x1, y1)
  919.     rB = 0x33FE21940342161C55619C4A0C060293D543C80AF19748CE176D83477DE71C80
  920.     x2 = 0x1799B2A2C778295300D9A2325C686129B8F2B5337B3DCF4514E8BBC19D900EE5
  921.     y2 = 0x54C9288C82733EFDF7808AE7F27D0E732F7C73A7D9AC98B7D8740A91D0DB3CF4
  922.     RB = (x2, y2)
  923.  
  924.     time_1 = get_cpu_time()
  925.     # A、B双方初始化
  926.     sm2_A = SM2(*demo_para(), IDA, dA, PA)
  927.     sm2_B = SM2(*demo_para(), IDB, dB, PB)
  928.  
  929.     # A 发起协商
  930.     # A生成rA, RA，将RA发送给B
  931.  
  932.     # B 响应协商
  933.     res, content = sm2_B.agreement_response(RA, PA, IDA, option, rB, RB)
  934.     if not res:
  935.         print('B报告协商错误：', content)
  936.         return
  937.     if option:
  938.         RB, KB, SB, S2 = content
  939.     else:
  940.         RB, KB = content
  941.         SB = None
  942.     # B将RB、(选项SB)发送给A
  943.  
  944.     # A 协商确认
  945.     res, content = sm2_A.agreement_confirm(rA, RA, RB, PB, IDB, SB, option)
  946.     if not res:
  947.         print('A报告协商错误：', content)
  948.         return
  949.     if option:
  950.         KA, SA = content
  951.     else:
  952.         KA = content
  953.  
  954.     if option:
  955.         # A将(选项SA)发送给B
  956.         # B 协商确认
  957.         res, content = sm2_B.agreement_confirm2(S2, SA)
  958.         if not res:
  959.             print('B报告协商错误：', content)
  960.             return
  961.     time_2 = get_cpu_time()
  962.     print('SM2密钥协商完毕，耗时%.2f ms' % ((time_2 - time_1) * 1000))
  963.     print('KA == KB?: %s, value: 0x%s, len: %d' % (KA == KB, KA.hex(), len(KA) << 3))
  964.     # 协商成功，输出的密钥(55b0ac62a6b927ba23703832c853ded4)与SM2第3部分 A.2中的结果一致
  965.  
  966.  
  967. # SM2加解密测试
  968. # SM2第4部分 A.1 A.2
  969. def test_encryption():
  970.     M = 'encryption standard'
  971.     dB = 0x1649AB77A00637BD5E2EFE283FBF353534AA7F7CB89463F208DDBC2920BB0DA0
  972.     xB = 0x435B39CCA8F3B508C1488AFC67BE491A0F7BA07E581A0E4849A5CF70628A7E0A
  973.     yB = 0x75DDBA78F15FEECB4C7895E2C1CDF5FE01DEBB2CDBADF45399CCF77BBA076A42
  974.     PB = (xB, yB)
  975.     k = 0x4C62EEFD6ECFC2B95B92FD6C3D9575148AFA17425546D49018E5388D49DD7B4F
  976.  
  977.     # A、B双方初始化
  978.     sm2_A = SM2(*demo_para())
  979.     sm2_B = SM2(*demo_para(), '', dB, PB)
  980.  
  981.     time_1 = get_cpu_time()
  982.     # A用B的公钥对消息M进行加密
  983.     res, C = sm2_A.encrypt(M, PB, k)
  984.     if not res:
  985.         print('A报告加密错误：', C)
  986.         return
  987.  
  988.     # A将密文C发送给B
  989.  
  990.     # B用自己的私钥对密文C进行解密
  991.     res, M2 = sm2_B.decrypt(C)
  992.     if not res:
  993.         print('B报告解密错误：', M2)
  994.         return
  995.     time_2 = get_cpu_time()
  996.     print('SM2加解密完毕，耗时%.2f ms' % ((time_2 - time_1) * 1000))
  997.     print('结果：%s，解密得：%s(%s)' % (res, M2.hex(), M2.decode()))
  998.     # 加解密成功，解密后的16进制值(656e6372797074696f6e207374616e64617264)与SM2第4部分 A.2中的结果一致
  999.  
  1000.  
  1001. if __name__ == "__main__":
  1002.     test_ECDH()
  1003.     test_SM2_agreement(True)
  1004.     # 可复现SM2文档中的示例结果
  1005.     test_signature()
  1006.     test_SM2_agreement2(True)
  1007.     test_encryption()

“他们要打多久，就打多久，一直打到完全胜利！”

多用SM2，少用RSA，不用DH；多用SM3，少用SHA，不用MD5；多用SM4，少用AES，不用DES。支持国密，支持自主，不光是情怀，而是国密算法确实设计得好，易用，安全性高！

目前，对于国密算法的python实现，在代码开源、算法优化、稳定性方面还不及国外的成熟库，幸而我们的国家一直不乏有识之士踔厉奋发、笃行不怠、负重前行。

望大家共同努力，把网络信息安全牢牢掌握在自己手中，共勉！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/50057
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号