国密算法：利用python进行sm2非对称算法的实现，国密算法库gmssl的使用_python sm2加密

我们继续来进行国密算法的演示。
本篇演示sm2非对称算法的实现，国密算法库gmssl的使用。

一 sm2算法的特点：

• sm2: 即椭圆曲线公钥密码算法，是由国家密码管理局发布的；
• 非对称加密算法，即有一对不一样的密钥：公钥和私钥，公钥用来加密，私钥用来解密；
• 公钥和私钥：公钥，可以公开。私钥：不对外公开；
• 同一个明文，同一个公钥，每次加密结果不相等；
• 密码复杂度高，更先进，更安全，性能更快；
• 用于替换RSA算法。很多软件都在进行国密改造，指的就是用sm1/sm2/sm3/sm4替换掉原有的加解密算法。

二sm2算法的演示：

1. 定义一个通用sm2算法类

# -*- coding: utf-8 -*-

import binascii
import re
import requests
import logging

from gmssl import sm2, func

class Sm2Tools:
    """
    通用sm2算法类
    """
    class KeyStore:
        """
        SM2 密钥对类，包含密钥对生成、获取方法
        """
        _PRIVATE_KEY = ""
        _PUBLIC_KEY = ""

        def __init__(self) -> None:
            pass

        def setKey(self, priKey: str, pubKey: str) -> bool:
            """
            简单判断密钥对格式
            :param priKey: 私钥
            :param pubKey: 公钥
            :return: bool
            """
            result = re.match(r"^[a-fA-F\d]{64}$", priKey)
            if result is None:
                logging.error("KeyStore.setKey() -> priKey is invalid.")
                return False
            result = re.match(r"^[a-fA-F\d]{128}$", pubKey)
            if result is None:
                logging.error("KeyStore.setKey() -> pubKey is invalid.")
                return False
            self._PRIVATE_KEY = priKey
            self._PUBLIC_KEY = pubKey
            return True

        def createLocal(self) -> bool:
            """
            本地创建密钥对
            :return: bool
            """

            class _Generate_SM2_Key(sm2.CryptSM2):

                #初始化
                def __init__(self, private_key=None, public_key=None, ecc_table=sm2.default_ecc_table):
                    super().__init__(private_key, public_key, ecc_table)

                #获取私钥
                def get_private_key(self):
                    if self.private_key is None:
                        self.private_key = func.random_hex(self.para_len)  # d∈[1, n-2]
                    return self.private_key

                #获取共钥
                def get_public_key(self):
                    if self.public_key is None:
                        self.public_key = self._kg(int(self.get_private_key(), 16), self.ecc_table['g'])  # P=[d]G
                    return self.public_key

            try:
                _sm2Generator = _Generate_SM2_Key()
                self._PRIVATE_KEY = _sm2Generator.get_private_key()
                self._PUBLIC_KEY = _sm2Generator.get_public_key()
                return True
            except:
                logging.error("KeyStore.createLocal() can't create the correct keys. ",
                              "Please call the Lib's Designer. ")
                return False

        def getSelf(self) -> dict:
            """
            获取创建的密钥对
            :return: dict: keyStore 格式：
            {
                "PRIVATE_KEY": "",
                "PUBLIC_KEY": ""
            }
            """
            return {
                "PRIVATE_KEY": self._PRIVATE_KEY,
                "PUBLIC_KEY": self._PUBLIC_KEY
            }

        def getPrivateKey(self) -> str:
            """
            返回公钥
            :return: str
            """
            return self._PRIVATE_KEY

        def getPublicKey(self) -> str:
            """
            返回私钥
            :return: str
            """
            return self._PUBLIC_KEY

    class SM2_Util(Exception):
        """
        SM2 加解密类
        """

        _SM2_Util = None

        def __init__(self, exception="") -> None:
            """
            构造函数
            :param exception: 默认参数，用于自定义异常
            """

            self._EXCPTION = None
            self._INIT_FLAG = False

        def setKey(self, keyStore: dict) -> bool:
            """
            初始化密钥对
            :param keyStore: dict: keyStore 格式：
                {
                    "PRIVATE_KEY": "",
                    "PUBLIC_KEY": ""
                }
            :return: bool
            """
            try:
                # 判断是否为全为英文和数字，且是 16 个字符的字符串
                # 不是，则抛出异常
                if re.match(r"^[a-fA-F\d]{64}$", keyStore["PRIVATE_KEY"]) is None:
                    raise Sm2Tools.SM2_Util(exception="SM2_Util.setKey() -> PRIVATE_KEY is invalid.")
                if re.match(r"^[a-fA-F\d]{128}$", keyStore["PUBLIC_KEY"]) is None:
                    raise Sm2Tools.SM2_Util(exception="SM2_Util.setKey() -> PUBLIC_KEY is invalid.")
            except Sm2Tools.SM2_Util as e:
                logging.error(e._EXCPTION)
                return False
            self._SM2_Util = sm2.CryptSM2(public_key=keyStore["PUBLIC_KEY"], private_key=keyStore["PRIVATE_KEY"])
            self._INIT_FLAG = True
            return True

        def getSelf(self) -> sm2.CryptSM2:
            """
            获取加解密类对象
            :return: sm2.CryptSM2 类实例
            """
            return self._SM2_Util

        def encrypt(self, data: str):
            """
            进行 SM2 加密操作
            :param data: String 格式的原文 data
            :return: String 格式的密文 enc_data
            """
            data_utf8 = data.encode("utf-8")
            enc_data = self._SM2_Util.encrypt(data_utf8)
            enc_data = binascii.b2a_hex(enc_data).decode("utf-8")
            return enc_data

        def decrypt(self, enc_data: str):
            """
            进行 SM2 解密操作
            :param enc_data: String 格式的密文 enc_data
            :return: String 格式的原文 data
            """
            enc_data = binascii.a2b_hex(enc_data.encode("utf-8"))
            dec_data = self._SM2_Util.decrypt(enc_data)
            dec_data = dec_data.decode("utf-8")
            return dec_data
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

2. 通用sm2算法类的调用

def test_sm2():
    # """
    # SM2 test
    # """
    keyStore = Sm2Tools.KeyStore()
    SM2_Util = Sm2Tools.SM2_Util()
    if keyStore.createLocal():
        keysDict = keyStore.getSelf()
        SM2_Util.setKey(keysDict)
        data = "哈哈，我的国密算法改造，已完成了！！！"
        print("data: " + data)
        enc_data = SM2_Util.encrypt(data)
        print("encode_data: " + enc_data)
        dec_data = SM2_Util.decrypt(enc_data)
        print("decode_data: " + dec_data)
        if data == dec_data:
            print("data == decode_data: True")
    else:
        print("create fail")

# main 
if __name__ == '__main__':
    print("main begin");
    test_sm2();
    print("main end");

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

运行结果：

% python3 sm2_t2.py
main begin
data: 哈哈，我的国密算法改造，已完成了！！！
encode_data: 4c37771377ad989fbe4c405a0893f8cc1ee79dc5200dc8c9a6df7eddeb90fb8b210bea842d411700c31da4470c6387bd52f1ff25bbe777f36745cc5cf70e9e5fa40a0831f5951182fe8db50c9f3350c5a68466af218b2589f05227804d3ce53ceb44a85ea52fadfc6116956dd5d5c1ee0ceb44558acc3a07fffaeb4bc8b2d93f627f360df247f57c667b0e18c72d4c9677a7deec3ba54e1533
decode_data: 哈哈，我的国密算法改造，已完成了！！！
data == decode_data: True
main end