菜鸟追梦旅行

这个屌丝很懒，什么也没留下！

热门标签

SM2椭圆曲线公钥密码算法(Python实现)_python实现sm2加密算法

作者：菜鸟追梦旅行 | 2024-05-06 07:05:26

踩

python实现sm2加密算法

本文目录

一、实验目的（包括实验环境、实现目标等等）
二、方案设计（包括背景、原理、必要的公式、图表、算法步骤等等）
三、方案实现（包括算法流程图、主要函数的介绍、算法实现的主要代码等等）
四、数据分析(包括算法测试数据的分析，运行结果截图等等)

一、实验目的（包括实验环境、实现目标等等）

1. 实验环境

Windows11
PyCharm2019.3.3 x64

2. 实现目标

通过编写代码实现SM2椭圆曲线公钥密码算法，加深对SM2椭圆曲线公钥密码算法的理解，体会该算法在解决实际问题的价值；
将密码学和数学知识相联系，并灵活运用到密码学的设计方案中；
提高实践能力和逻辑思维能力。

3. 实验中需要导入的库

random
math
gmssl

二、方案设计（包括背景、原理、必要的公式、图表、算法步骤等等）

1. 实验背景

SM2算法和RSA算法一样，同属于非对称算法体系，而且是椭圆曲线加密（ECC）算法的一种。但与RSA算法不同的是：RSA算法是基于大整数分解数学难题，SM2算法是基于椭圆曲线上点群离散对数难题。

相较于RSA算法，SM2算法的优点如下：

安全性高：192位的SM2密码强度已经比RSA的2048位密码强度要高，存储空间小。SM2算法的密码一般使用192~256位，RSA算法的密码一般需要2048~4096位。
签名速度快：SM2算法在私钥运算上的速度远大于RSA算法。
国产算法：由国家密码管理部门制订规范，不存在不可公开的密码。
目前普遍认为在国内被广泛使用的RSA的1024位算法不再安全，国家密码管理局下发了通知：自2011年7月1日起，投入运行并使用公钥密码的信息系统应使用SM2椭圆曲线公钥密码算法。

2. 实验原理

1. 素域Fp

当有限域Fq的q是奇素数时，素域Fp中的元素用整数0, 1, 2, …, p-1表示。其中：
加法单位元是整数0
乘法单位元是整数1
域元素的加法是整数的模p加法，即若a, b ∈ Fp，则a+b = (a+b) mod p;
域元素的乘法是整数的模p乘法，即若a, b ∈ Fp，则a·b = (a·b) mod p;

2. 素域Fp上的椭圆曲线

有限域Fq上的椭圆曲线是由点组成的集合。在仿射坐标系下，椭圆曲线上的点P（非无穷远点）的坐标表示为P = (x_p, y_p), 其中xp和p为满足一定方程的域元素，分别称为点P的x坐标和y坐标。
定义在Fp（p是大于3的素数）上的椭圆曲线方程为：
y² = x³ + ax + b, a,b ∈Fp,且(4a³ + 27b² )mod p ≠ 0
椭圆曲线E(Fp)定义为：
E(Fq) = {(x, y) | x, y ∈ Fp, 且满足上述方程} ∪ {O}, 其中O是无穷远点。
椭圆曲线E(Fp)上的点的数目用#E(Fq)表示，成为椭圆曲线E(Fp)的阶。

3. 必要的公式

1. Fp上的椭圆曲线群

椭圆曲线E(Fp)上的点按照下面的加法运算规则，构成一个交换群：

O + O = O;
∀P=(x,y)∈E(Fp ){O},P+O=P;
∀P=(x,y)∈E(Fp ){O},P的逆元素-P=(x,-y),P+(-P)=O;
两个非互逆的不同点相加的规则：
设P1 = (x₁, y₁) ∈ E(Fp)\{O}, P2 = (x₂, y₂) ∈ E(Fp)\{O}, 且 x₁ ≠ x₂
设P₃ = (x₃, y₃) = P₁ + P₂, 则x₃ = $\lambda$ ² - x₁ - x₂, y₃ = $\lambda$ (x₁ - x₃) - y₁
其中，λ= $\frac {y_2- y_1} {x_2- x_1}$

2. 倍点规则

设P1 = (x1, y1) ∈ E(Fp)\{O}, 且y1 ≠ 0, 设P3 = (x3, y3) = P1 + P2,
则x₃ = $\lambda$ ² - 2x₁, y₃ = $\lambda$ (x₁ - x₃) - y₁,
其中，λ= $\frac {3x_1^2 + a} {2y_1}$

3. 通过二进制展开法实现椭圆曲线多倍点运算

求点P的k倍点[k]P，将k用l长比特串形式表示k = $\sum_{j=0}^{l-1}$ k_j2^j, k∈{0, 1}

可按以下步骤进行求解：

置Q = O
j从l-1下降到0执行：Q = [2]Q
若kj = 1，则 Q = Q + P
执行结束后得到的Q即为P的k倍点

4. 算法步骤

1. 加密算法

设需要发送的消息为比特串M，klen为M的比特长度。
为了对明文M进行加密，作为加密者的用户A应实现以下运算步骤：
A1：用随机数发生器产生随机数k∈[1,n-1]；
A2：计算椭圆曲线点C1=[k]G=(x1,y1)，将C1的数据类型转换为比特串；
A3：计算椭圆曲线点S=[h]PB，若S是无穷远点，则报错并退出；
A4：计算椭圆曲线点[k]PB=(x2,y2)，将坐标x2、y2 的数据类型转换为比特串；
A5：计算t=KDF(x2 || y2, klen)，若t为全0比特串，则返回A1；
A6：计算C2 = M ⊕ t；
A7：计算C3 = Hash(x2 || M || y2)；
A8：输出密文C = C1 || C2 || C3。

2. 解密算法

设klen为密文中C2的比特长度。
为了对密文C=C1 || C2 || C3 进行解密，作为解密者的用户B应实现以下运算步骤：
B1：从C中取出比特串C1，将C1的数据类型转换为椭圆曲线上的点，验证C1是否满足椭圆曲线方程，若不满足则报错并退出；
B2：计算椭圆曲线点S=[h]C1，若S是无穷远点，则报错并退出；
B3：计算[dB]C1=(x2,y2)，将坐标x2、y2的数据类型转换为比特串；
B4：计算t=KDF(x2 || y2, klen)，若t为全0比特串，则报错并退出；
B5：从C中取出比特串C2，计算M′ = C2 ⊕ t；
B6：计算u = Hash(x2 || M′ || y2)，从C中取出比特串C3，若u ≠ C3，则报错并退出；
B7：输出明文M′。

三、方案实现（包括算法流程图、主要函数的介绍、算法实现的主要代码等等）

1. 流程图

1. 加密算法流程图

在这里插入图片描述

2. 解密算法流程图

在这里插入图片描述

2. 主要函数

1. 数据类型转换

本部分所定义的函数实现了域元素、字节串、比特串、整数等数据类型的转换，方便计算与阅读。

def int_to_bytes(x, k)：实现整数到字节串的转换。接收非负整数x和字节串的目标长度k，k满足2^8k > x。返回值是长为k的字节串。注意字节串长度k是给定的参数！
def bytes_to_int(M)：字节串到整数的转换。接受长度为k的字节串。返回值是整数x。
def bits_to_bytes(s)：比特串到字节串的转换。接收长度为m的比特串s。返回长度为k的字节串M。其中k = [m/8] 向上取整。先判断字符串整体是否能正好转换为字节串，即长度是否为8的倍数。若不是则左填充至长度为8的倍数。
def bytes_to_bits(M)：字节串到比特串的转换。接收长度为k的字节串M，返回长度为m的比特串s，其中m = 8k。字节串逐位处理即可。
def fielde_to_bytes(e)：域元素到字节串的转换。域元素是整数，转换成字节串要明确长度。文档规定域元素转换为字节串的长度l是ceil(ceil(log(q, 2)/8))。接收的参数是域元素a，返回l长字节串M 。
def bytes_to_fielde(M)：字节串到域元素的转换。直接调用bytes_to_int( )。接收的参数是字节串M，返回域元素a。
def fielde_to_int(a)：域元素到整数的转换。域元素就是整数，直接返回即可。
def point_to_bytes§：点到字节串的转换。接收的参数是椭圆曲线上的点p，元组表示。输出字节串S。选用未压缩表示形式，即字节串s = PC + x + y，共1 + 2l个字节。
def bytes_to_point(s)：字节串到点的转换。接收的参数是字节串s，返回椭圆曲线上的点p，点P的坐标用元组表示。
附加数据类型转换。是上述几种数据类型转换的复合转换，或者是数制之间的转换。注意字符串的填充即可。共定义了def fielde_to_bits(a)、def point_to_bits§、def int_to_bits(x) 、def bytes_to_hex(m)、def bits_to_hex(s)、def hex_to_bits(h)、def hex_to_bytes(h)、def fielde_to_hex(e)几种函数。

2.辅助函数

本部分定义的函数是用于辅助实现SM2加解密算法中某些步骤的模块，这些模块若直接在加解密算法中会使代码变长造成阅读困难，因此将其定义为单独的函数以使结构清晰。

def add_point(P, Q, p)：椭圆曲线上的点加运算。接收的参数是元组P和Q，表示相加的两个点，p为模数。返回二者的点加和。
def double_point(P, p, a): 二倍点算法。不能直接用点加算法，否则会发生除零错误。接收的参数是点P，素数p，椭圆曲线参数a。返回P的二倍点。
def mult_point(P, k, p, a)：多倍点算法。通过二进制展开法实现。接收的参数[k]p是要求的多倍点，m是模数，a是椭圆曲线参数。
def frac_to_int(up, down, p)：将分式模运算转换为整数。输入 up/down mod m, 返回该分式在模m意义下的整数。点加和二倍点运算时求λ用。
def calc_inverse(M, m)：模逆算法。返回M模m的逆。在将分式模运算转换为整数时用，分子分母同时乘上分母的模逆。
def on_curve(args, P)：验证某个点是否在椭圆曲线上。接收的参数是椭圆曲线系统参数args和要验证的点P(x, y)。
def KDF(Z, klen)：密钥派生函数KDF。接收的参数是比特串Z和要获得的密钥数据的长度klen。返回klen长度的密钥数据比特串K。

3. 加解密算法

本部分是加解密的两个函数。

def encry_sm2(args, PB, M)：加密算法。接收的参数是椭圆曲线系统参数args(p, a, b, h, G, n)。其中n是基点G的阶。PB是B的公钥，M是明文消息。
def decry_sm2(args, dB, C)：解密算法。接收的参数为椭圆曲线系统参数args(p, a, b, h, G, n)。dB是B的私钥，C是密文消息。

4. 参数获取

本部分的函数用于获取算法使用的相关数据。

def get_args( )：椭圆曲线系统参数args(p, a, b, h, G, n)的获取。
def get_key( )：密钥获取。本程序中主要是消息接收方B的公私钥的获取。

3. Python代码

import random
from math import gcd, ceil, log
from gmssl import sm3


# 数据类型装换
# 整数到字节串的转换。接收非负整数x和字节串的目标长度k，k满足2^8k > x。返回值是长为k的字节串。k是给定的参数。
def int_to_bytes(x, k):         # 整体思路是先左填充0将x变为k*8位16进制数串，再每2位合成1个字节
    if pow(256, k) <= x:
        raise Exception("无法实现整数到字节串的转换，目标字节串长度过短！")
    s = hex(x)[2:].rjust(k*2, '0')          # s是k*2位十六进制串
    M = b''
    for i in range(k):
        M = M + bytes([eval('0x' + s[i*2:i*2+2])])
    return M


# 字节串到整数的转换。接受长度为k的字节串。返回值是整数x
def bytes_to_int(M):            # 整体思路是从后向前遍历M，每个字节的基数是2^8。
    k = len(M)          # k是字节串的长度
    x = 0           # x存储最后的整数
    for i in range(k-1, -1, -1):
        x += pow(256, k-1-i) * M[i]
    return x


# 比特串到字节串的转换。接收长度为m的比特串s。返回长度为k的字节串M。其中k = [m/8] 向上取整。
def bits_to_bytes(s):           # 先判断字符串整体是否能正好转换为字节串，即长度是否为8的倍数。若不是则左填充至长度为8的倍数。
    k = ceil(len(s)/8)          # 比特串长度除以8向上取整
    s = s.rjust(k*8, '0')           # 若能整除这一步相当于没有，若不能则相当于将其左填充为长度能被8整除得k
    M = b''         # M存储要返回的字节串
    for i in range(k):
        M = M + bytes([eval('0b' + s[i*8: i*8+8])])
    return M


# 字节串到比特串的转换。接收长度为k的字节串M，返回长度为m的比特串s，其中m = 8k。字节串逐位处理即可。
def bytes_to_bits(M):           # 整体思路是把每个字节变为8位比特串，用列表存储，最后连接起来
    s_list = []
    for i in M:
        s_list.append(bin(i)[2:].rjust(8, '0'))         # 每次循环存储1个字节。左填充补0
    s = ''.join(s_list)
    return s


# 域元素到字节串的转换。域元素是整数，转换成字节串要明确长度。文档规定域元素转换为字节串的长度是ceil(ceil(log(q, 2)/8))。接收的参数是域元素a，返回字节串M
def fielde_to_bytes(e):
    q = eval('0x' + '8542D69E 4C044F18 E8B92435 BF6FF7DE 45728391 5C45517D 722EDB8B 08F1DFC3'.replace(' ', ''))
    t = ceil(log(q, 2))
    l = ceil(t / 8)
    return int_to_bytes(e, l)


# 字节串到域元素的转换。直接调用bytes_to_int()。接收的参数是字节串M，返回域元素a
def bytes_to_fielde(M):         # 域元素不用填充
    return bytes_to_int(M)


# 域元素到整数的转换
def fielde_to_int(a):           # 直接返回
    return a


# 点到字节串的转换。接收的参数是椭圆曲线上的点p，元组表示。输出字节串S。选用未压缩表示形式
def point_to_bytes(P):
    xp, yp = P[0], P[1]
    x = fielde_to_bytes(xp)
    y = fielde_to_bytes(yp)
    PC = bytes([0x04])
    s = PC + x + y
    return s


# 字节串到点的转换。接收的参数是字节串s，返回椭圆曲线上的点P，点P的坐标用元组表示
def bytes_to_point(s):
    if len(s) % 2 == 0:
        raise Exception("无法实现字节串到点的转换，请检查字节串是否为未压缩形式！")
    l = (len(s) - 1) // 2
    PC = s[0]
    if PC != 4:
        raise Exception("无法实现字节串到点的转换，请检查PC是否为b'04'！")
    x = s[1: l+1]
    y = s[l+1: 2*l+1]
    xp = bytes_to_fielde(x)
    yp = bytes_to_fielde(y)
    P = (xp, yp)            # 此处缺少检验点p是否在椭圆曲线上
    return P


# 附加数据类型转换
# 域元素到比特串
def fielde_to_bits(a):
    a_bytes = fielde_to_bytes(a)
    a_bits = bytes_to_bits(a_bytes)
    return a_bits


# 点到比特串
def point_to_bits(P):
    p_bytes = point_to_bytes(P)
    p_bits = bytes_to_bits(p_bytes)
    return p_bits


# 整数到比特串
def int_to_bits(x):
    x_bits = bin(x)[2:]
    k = ceil(len(x_bits)/8)         # 8位1组，k是组数。目的是方便对齐
    x_bits = x_bits.rjust(k*8, '0')
    return x_bits


# 字节串到十六进制串
def bytes_to_hex(m):
    h_list = []         # h_list存储十六进制串中的每一部分
    for i in m:
        e = hex(i)[2:].rjust(2, '0')            # 不能把0丢掉
        h_list.append(e)
    h = ''.join(h_list)
    return h


# 比特串到十六进制
def bits_to_hex(s):
    s_bytes = bits_to_bytes(s)
    s_hex = bytes_to_hex(s_bytes)
    return s_hex


# 十六进制串到比特串
def hex_to_bits(h):
    b_list = []
    for i in h:
        b = bin(eval('0x' + i))[2:].rjust(4, '0')           # 增强型for循环，是i不是h
        b_list.append(b)
    b = ''.join(b_list)
    return b


# 十六进制到字节串
def hex_to_bytes(h):
    h_bits = hex_to_bits(h)
    h_bytes = bits_to_bytes(h_bits)
    return h_bytes


# 域元素到十六进制串
def fielde_to_hex(e):
    h_bytes = fielde_to_bytes(e)
    h = bytes_to_hex(h_bytes)
    return h


# 密钥派生函数KDF。接收的参数是比特串Z和要获得的密钥数据的长度klen。返回klen长度的密钥数据比特串K
def KDF(Z, klen):
    v = 256           # 密码杂凑函数采用SM3
    if klen >= (pow(2, 32) - 1) * v:
        raise Exception("密钥派生函数KDF出错，请检查klen的大小！")
    ct = 0x00000001
    if klen % v == 0:
        l = klen // v
    else:
        l = klen // v + 1
    Ha = []
    for i in range(l):         # i从0到 klen/v-1（向上取整）,共l个元素
        s = Z + int_to_bits(ct).rjust(32, '0')         # s存储 Z || ct 的比特串形式 # 注意，ct要填充为32位
        s_bytes = bits_to_bytes(s)          # s_bytes存储字节串形式
        s_list = [i for i in s_bytes]
        hash_hex = sm3.sm3_hash(s_list)
        hash_bin = hex_to_bits(hash_hex)
        Ha.append(hash_bin)
        ct += 1
    if klen % v != 0:
        Ha[-1] = Ha[-1][:klen - v*(klen//v)]
    k = ''.join(Ha)
    return k


# 模逆算法。返回M模m的逆。在将分式模运算转换为整数时用，分子分母同时乘上分母的模逆。
def calc_inverse(M, m):
    if gcd(M, m) != 1:
        return None
    u1, u2, u3 = 1, 0, M
    v1, v2, v3 = 0, 1, m
    while v3 != 0:
        q = u3 // v3
        v1, v2, v3, u1, u2, u3 = (u1 - q * v1), (u2 - q * v2), (u3 - q * v3), v1, v2, v3
    return u1 % m


# 将分式模运算转换为整数。输入 up/down mod m, 返回该分式在模m意义下的整数。点加和二倍点运算时求λ用。
def frac_to_int(up, down, p):
    num = gcd(up, down)
    up //= num
    down //= num         # 分子分母约分
    return up * calc_inverse(down, p) % p


# 椭圆曲线上的点加运算。接收的参数是元组P和Q，表示相加的两个点，p为模数。返回二者的点加和
def add_point(P, Q, p):
    if P == 0:
        return Q
    if Q == 0:
        return P
    x1, y1, x2, y2 = P[0], P[1], Q[0], Q[1]
    e = frac_to_int(y2 - y1, x2 - x1, p)            # e为λ
    x3 = (e*e - x1 - x2) % p            # 注意此处也要取模
    y3 = (e * (x1 - x3) - y1) % p
    ans = (x3, y3)
    return ans


# 二倍点算法。不能直接用点加算法，否则会发生除零错误。接收的参数是点P，素数p，椭圆曲线参数a。返回P的二倍点。
def double_point(P, p, a):
    if P == 0:
        return P
    x1, y1 = P[0], P[1]
    e = frac_to_int(3 * x1 * x1 + a, 2 * y1, p)         # e是λ
    x3 = (e * e - 2 * x1) % p         # 取模！！！！！
    y3 = (e * (x1 - x3) - y1) % p
    Q = (x3, y3)
    return Q


# 多倍点算法。通过二进制展开法实现。接收的参数[k]p是要求的多倍点，m是模数，a是椭圆曲线参数。
def mult_point(P, k, p, a):
    s = bin(k)[2:]          # s是k的二进制串形式
    Q = 0
    for i in s:
        Q = double_point(Q, p, a)
        if i == '1':
            Q = add_point(P, Q, p)
    return Q


# 验证某个点是否在椭圆曲线上。接收的参数是椭圆曲线系统参数args和要验证的点P(x, y)。
def on_curve(args, P):
    p, a, b, h, G, n = args
    x, y = P
    if pow(y, 2, p) == ((pow(x, 3, p) + a*x + b) % p):
        return True
    return False


# 加密算法。接收的参数是椭圆曲线系统参数args(p, a, b, h, G, n)。其中n是基点G的阶。PB是B的公钥，M是明文消息。
def encry_sm2(args, PB, M):
    p, a, b, h, G, n = args         # 序列解包
    M_bytes = bytes(M, encoding='ascii')
    print("A1：用随机数发生器产生随机数k∈[1,n-1]")
    k = random.randint(1, n-1)
    k_hex = hex(k)[2:]          # k_hex 是k的十六进制串形式
    print("生成的随机数是：", k_hex)
    print("\nA2:计算椭圆曲线点C1=[k]G=(x1,y1)，将C1的数据类型转换为比特串")
    C1 = mult_point(G, k, p, a)
    print("椭圆曲线点C1=[k]G=(x1,y1)的坐标是:", tuple(map(hex, C1)))
    C1_bits = point_to_bits(C1)
    print("椭圆曲线点C1=[k]G=(x1,y1)的坐标的比特串形式是:", C1_bits)
    print("\nA3：计算椭圆曲线点S = [h]PB")
    S = mult_point(PB, h, p, a)
    if S == 0:
        raise Exception("计算得到的S是无穷远点")
    print("A3椭圆曲线点S = [h]PB的坐标是:", tuple(map(hex, S)))
    print("\nA4：计算椭圆曲线点[k]PB=(x2,y2)，将坐标x2、y2 的数据类型转换为比特串")
    x2, y2 = mult_point(PB, k, p, a)
    print("椭圆曲线点[k]PB=(x2,y2)的坐标是:", tuple(map(hex, (x2, y2))))
    x2_bits = fielde_to_bits(x2)
    print("x2的比特串形式是：", x2_bits)
    y2_bits = fielde_to_bits(y2)
    print("y2的比特串形式是：", y2_bits)
    print("\nA5：计算t=KDF(x2 ∥ y2, klen)，若t为全0比特串，则返回A1")
    M_hex = bytes_to_hex(M_bytes)
    klen = 4 * len(M_hex)
    print("明文消息的比特串长度klen是：", klen)
    t = KDF(x2_bits + y2_bits, klen)
    print("通过KDF算法计算得到的t=KDF(x2 ∥ y2, klen)是：", t)
    if eval('0b' + t) == 0:
        raise Exception("KDF返回了全零串，请检查KDF算法！")
    t_hex = bits_to_hex(t)
    print("t的十六进制表示形式是：", t_hex)
    print("\nA6：计算计算C2 = M ⊕ t")
    C2 = eval('0x' + M_hex + '^' + '0b' + t)
    print("计算的C2是：", hex(C2)[2:])
    print("\nA7：计算C3 = Hash(x2 ∥ M ∥ y2)")
    x2_bytes = bits_to_bytes(x2_bits)
    y2_bytes = bits_to_bytes(y2_bits)
    hash_list = [i for i in x2_bytes + M_bytes + y2_bytes]
    C3 = sm3.sm3_hash(hash_list)
    print("计算的C3 = Hash(x2 ∥ M ∥ y2)是：", C3)
    print("\nA8：输出密文C = C1 ∥ C2 ∥ C3")
    C1_hex = bits_to_hex(C1_bits)
    C2_hex = hex(C2)[2:]
    C3_hex = C3
    C_hex = C1_hex + C2_hex + C3_hex
    print("加密得到的密文是：", C_hex)
    return C_hex


# 解密算法。接收的参数为椭圆曲线系统参数args(p, a, b, h, G, n)。dB是B的私钥，C是密文消息。
def decry_sm2(args, dB, C):
    p, a, b, h, G, n = args
    print("B1：从C中取出比特串C1，将C1的数据类型转换为椭圆曲线上的点，验证C1是否满足椭圆曲线方程，若不满足则报错并退出；")
    l = ceil(log(p, 2)/8)         # l是一个域元素（比如一个点的横坐标）转换为字节串后的字节长度.则未压缩的形式下秘闻第一部分C1长度为2l+1
    bytes_l1 = 2*l+1
    print("计算得到的C1的字节串长度是：", bytes_l1)
    hex_l1 = bytes_l1 * 2            # hex_l1是密文第一部分C1的十六进制串的长度
    C_bytes = hex_to_bytes(C)
    print("将十六进制密文串转换为字节串是：", C_bytes)
    C1_bytes = C_bytes[0:2*l+1]
    print("从密文字节串中取出的C1的字节串是：", C1_bytes)
    C1 = bytes_to_point(C1_bytes)
    print("将C1字节串转换为椭圆曲线上的点是：", C1)
    if not on_curve(args, C1):          # 检验C1是否在椭圆曲线上
        raise Exception("在解密算法B1中，取得的C1不在椭圆曲线上！")
    x1, y1 = C1[0], C1[1]
    x1_hex, y1_hex = fielde_to_hex(x1), fielde_to_hex(y1)
    print("C1坐标用的十六进串形式表示是：", (x1_hex, y1_hex))
    print("\nB2：计算椭圆曲线点S=[h]C1，若S是无穷远点，则报错并退出；")
    S = mult_point(C1, h, p, a)
    print("计算得到的S是：", S)
    if S == 0:
        raise Exception("在解密算法B2中，S是无穷远点！")
    xS, yS = S[0], S[1]
    xS_hex, yS_hex = fielde_to_hex(xS), fielde_to_hex(yS)
    print("S的坐标用十六进制串形式表示是：", (xS_hex, yS_hex))
    print("\nB3：计算[dB]C1=(x2,y2)，将坐标x2、y2的数据类型转换为比特串；")
    temp = mult_point(C1, dB, p, a)
    x2, y2 = temp[0], temp[1]
    x2_hex, y2_hex = fielde_to_hex(x2), fielde_to_hex(y2)
    print("解密得到的[dB]C1=(x2,y2)的十六进制串形式是：", (x2_hex, y2_hex))
    print("\nB4:计算t=KDF(x2 ∥ y2, klen)，若t为全0比特串，则报错并退出；")
    hex_l3 = 64           # hex_l3是密文第三部分C3的十六进制串的长度。C3是通过SM3得到的hash值，是64位十六进制串。
    hex_l2 = len(C) - hex_l1 - hex_l3           # hex_l2是密文第二部分C2的十六进制串的长度。
    klen = hex_l2 * 4           # klen是密文C2中比特串的长度
    print("计算的C2的比特串长度klen是：", klen)
    x2_bits, y2_bits = hex_to_bits(x2_hex), hex_to_bits(y2_hex)
    t = KDF(x2_bits + y2_bits, klen)
    print("计算的t=KDF(x2 ∥ y2, klen)是：", t)
    if eval('0b' + t) == 0:
        raise Exception("在解密算法B4中，得到的t是全0串！")
    t_hex = bits_to_hex(t)
    print("t的十六进制串形式是：", t_hex)
    print("\nB5：从C中取出比特串C2，计算M′ = C2 ⊕ t；")
    C2_hex = C[hex_l1: -hex_l3]
    print("C2的十六进制串形式是：", C2_hex)
    M1 = eval('0x' + C2_hex + '^' + '0x' + t_hex)           # M1是M'，M′ = C2 ⊕ t
    M1_hex = hex(M1)[2:].rjust(hex_l2, '0')         # 注意位数要一致
    print("计算的M′ = C2 ⊕ t是：", M1_hex)
    print("\nB6：计算u = Hash(x2 ∥ M′ ∥ y2)，从C中取出比特串C3，若u != C3，则报错并退出；")
    M1_bits = hex_to_bits(M1_hex)
    cmp_bits = x2_bits + M1_bits + y2_bits          # cmp_bits存储用于计算哈希值以对比C3的二进制串
    cmp_bytes = bits_to_bytes(cmp_bits)
    cmp_list = [i for i in cmp_bytes]
    u = sm3.sm3_hash(cmp_list)          # u中存储
    print("计算的u = Hash(x2 ∥ M′ ∥ y2)是：", u)
    C3_hex = C[-hex_l3:]
    print("从C中取出的C3的十六进制形式是：", C3_hex)
    if u != C3_hex:
        raise Exception("在解密算法B6中，计算的u与C3不同！")
    print("\nB7：输出明文M′")
    M_bytes = hex_to_bytes(M1_hex)
    M = str(M_bytes, encoding='ascii')
    print("解密出的明文是：", M)
    return M


# 椭圆曲线系统参数args(p, a, b, h, G, n)的获取。
def get_args():
    p = eval('0x' + '8542D69E 4C044F18 E8B92435 BF6FF7DE 45728391 5C45517D 722EDB8B 08F1DFC3'.replace(' ', ''))
    a = eval('0x' + '787968B4 FA32C3FD 2417842E 73BBFEFF 2F3C848B 6831D7E0 EC65228B 3937E498'.replace(' ', ''))
    b = eval('0x' + '63E4C6D3 B23B0C84 9CF84241 484BFE48 F61D59A5 B16BA06E 6E12D1DA 27C5249A'.replace(' ', ''))
    h = 1
    xG = eval('0x' + '421DEBD6 1B62EAB6 746434EB C3CC315E 32220B3B ADD50BDC 4C4E6C14 7FEDD43D'.replace(' ', ''))
    yG = eval('0x' + '0680512B CBB42C07 D47349D2 153B70C4 E5D7FDFC BFA36EA1 A85841B9 E46E09A2'.replace(' ', ''))
    G = (xG, yG)            # G 是基点
    n = eval('0x' + '8542D69E 4C044F18 E8B92435 BF6FF7DD 29772063 0485628D 5AE74EE7 C32E79B7'.replace(' ', ''))
    args = (p, a, b, h, G, n)           # args是存储椭圆曲线参数的元组。
    return args


# 密钥获取。本程序中主要是消息接收方B的公私钥的获取。
def get_key():
    xB = eval('0x' + '435B39CC A8F3B508 C1488AFC 67BE491A 0F7BA07E 581A0E48 49A5CF70 628A7E0A'.replace(' ', ''))
    yB = eval('0x' + '75DDBA78 F15FEECB 4C7895E2 C1CDF5FE 01DEBB2C DBADF453 99CCF77B BA076A42'.replace(' ', ''))
    PB = (xB, yB)           # PB是B的公钥
    dB = eval('0x' + '1649AB77 A00637BD 5E2EFE28 3FBF3535 34AA7F7C B89463F2 08DDBC29 20BB0DA0'.replace(' ', ''))
    # dB是B的私钥
    key_B = (PB, dB)
    return key_B


print("SM2椭圆曲线公钥密码算法".center(100, '='))
print("本算法采用256位素数域上的椭圆曲线。椭圆曲线方程为：")
print("y^2 = x^3 + ax + b")

print("此为算法第1部分，获取相关数据".center(100, '='))
# 这里作为后续加解密算法参数的是元组args和key_B，ascii字符串明文消息M。均为不可变序列。在这一部分用于输出时不会改变其值
print("下面获取椭圆曲线系统参数")
args = get_args()           # 获取椭圆曲线系统参数
p, a, b, h, G, n = args         # 序列解包
p, a, b, h, xG, yG, n = tuple(map(lambda a: hex(a)[2:], (p, a, b, h, G[0], G[1], n)))   # 将参数转换为十六进制串便于输出
print("椭圆曲线系统所在素域的p是：", p)
print("椭圆曲线系统的参数a是：", a)
print("椭圆曲线系统的参数b是：", b)
print("椭圆曲线系统的余因子h是：", h)
print("椭圆曲线系统的基点G的横坐标xG是：", xG)
print("椭圆曲线系统的基点G的纵坐标yG是：", yG)

print("下面获取接收方B的公私钥")
key_B = get_key()           # 设置消息接收方的公私钥
PB, dB = key_B          # 序列解包，PB是公钥，是以元组形式存储的点(xB, yB), dB是私钥，是整数
xB, yB, dB = tuple(map(lambda a: hex(a)[2:], (PB[0], PB[1], dB)))
print("接收方B的公钥PB的横坐标xB是：", xB)
print("接收方B的公钥PB的纵坐标yB是：", yB)
print("接收方B的私钥dB是：", dB)
print("下面获取明文")
M = input('请输入要加密的明文(明文应为ascii字符组成的字符串)：')
print("获取的ascii字符串明文是：", M)
print("此为算法第2部分，加密部分".center(100, '='))
C = encry_sm2(args, key_B[0], M)            # 加密算法的参数是椭圆系统参数，B的公钥PB，ascii字符串形式的明文消息M。返回十六进制串形式的密文消息

print("此为算法第3部分，解密部分".center(100, '='))
de_M = decry_sm2(args, key_B[1], C)           # 解密算法的参数是椭圆曲线系统参数，B的私钥dB，十六进制串形式的密文消息。返回ascii字符串形式的明文消息M

print("此为算法第4部分，验证部分".center(100, '='))
print("原始明文是：", M)
print("解密得到的明文是：", de_M)
if M == de_M:
    print("恭喜您，解密成功！")
else:
    print("解密失败，请检查算法！")
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430

四、数据分析(包括算法测试数据的分析，运行结果截图等等)

椭圆曲线系统所在素域的p是：
8542d69e4c044f18e8b92435bf6ff7de457283915c45517d722edb8b08f1dfc3
椭圆曲线系统的参数a是：
787968b4fa32c3fd2417842e73bbfeff2f3c848b6831d7e0ec65228b3937e498
椭圆曲线系统的参数b是：
63e4c6d3b23b0c849cf84241484bfe48f61d59a5b16ba06e6e12d1da27c5249a
椭圆曲线系统的余因子h是：
1
椭圆曲线系统的基点G的横坐标xG是：
421debd61b62eab6746434ebc3cc315e32220b3badd50bdc4c4e6c147fedd43d
椭圆曲线系统的基点G的纵坐标yG是：
680512bcbb42c07d47349d2153b70c4e5d7fdfcbfa36ea1a85841b9e46e09a2
接收方B的公钥PB的横坐标xB是：
435b39cca8f3b508c1488afc67be491a0f7ba07e581a0e4849a5cf70628a7e0a
接收方B的公钥PB的纵坐标yB是：
75ddba78f15feecb4c7895e2c1cdf5fe01debb2cdbadf45399ccf77bba076a42
接收方B的私钥dB是：
1649ab77a00637bd5e2efe283fbf353534aa7f7cb89463f208ddbc2920bb0da0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

样例:要加密的明文为字符串“encryption standard”。对其进行加解密
程序第1部分，获取参数。程序获取加解密所需的相关数据并回显到屏幕上，如图所示：
在这里插入图片描述
程序第2部分，加密部分。按照文档所给步骤对明文进行加密。其中步骤A1-A5如图所示：

步骤A6-A8如图所示：

加密得到的密文的十六进制形式是：

040e8f6a6a306d42ff2ce2220735fc32df125b4849398d30953daa7aeb392a6cd70188211d55c6754e73fd6487b3b2af933d2f83ea8ede155834787da752338a13b9f51200a9eced22a5fdabd9dd912b006471e2558a1fd525a3dc8680ce18f17d7546b500832586af771c16ce9441cb81d96dc8
1

程序第3部分，解密部分。按照文档所给步骤对密文进行解密。其中步骤B1-B4如图所示：
在这里插入图片描述
步骤B5-B7如图所示：

解密得到的明文是：encryption standard

程序第4部分，验证部分。将原始明文与解密得到的明文进行比较，若二者相同则表明解密成功。
解密成功，结果如图所示：
在这里插入图片描述
至此，实验结束。

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