【python】cryptography库学习

羽丶千落

已于 2024-08-20 09:49:32 修改

阅读量861

点赞数 21

分类专栏： Python学习文章标签： python 学习开发语言算法安全

于 2024-08-20 00:14:21 首次发布

本文链接：https://blog.csdn.net/weixin_44034444/article/details/141337723

版权

Python学习专栏收录该内容

14 篇文章 4 订阅

订阅专栏

【python】cryptography库学习

cryptography学习

学习cryptography的基本使用，后续有需要再做详细补充

cryptography学习

1-安装

pip install cryptography

2-cryptography学习

查看cryptography的目录结构

cryptography/
	hazmat/ # 主要目录，对称加解密的库文件都在此目录下
		backends/ # 此目录暂不做研究，此目录跟openssl关联较大
		bindings/ # 此目录暂不做研究，此目录跟openssl有关
		primitives/ # 本文主要学习此目录下的内容，包含对数据的填充，对称加解密，以及非对称加解密，公钥和私钥的签名验签
			asymmetric/ 非对称密码相关内容，有需要可对文件内容详细了解【常用rsa.py】
			ciphers/ 对称加密算法内容，本文主要讲述的内容
				-- aead.py：aesd算法内容，含ChaCha20Poly1305、AESCCM、AESGCM、AESOCB3。
				-- algorithms.py：对称算法的主要内容，含AES、Camellia、TripleDES、ChaCha20、SM4等等
				-- base.py：实际使用中基本用不到
				-- modes.py：加密模式
			kdf/ # 加密密钥派生和密钥存储相关，有需要自行了解
			serialization/ 序列化相关，有需要自行了解
			twofactor/ 该模块包含与双因素认证相关的算法。目前，它包含了一种基于基于哈希的消息身份验证码（HMAC）来生成和验证一次性密码值的算法。有需要自行了解
			-- cmac.py：cmac相关
			-- constant_time.py
			-- hashes.py：加密哈希函数接
			-- hmac.py：hmac算法
			-- keywrap.py：没有用过
			-- padding.py：填充
			-- poly1305.py：poly1305算法
			-- ....其他文件
	x509/ # x509证书相关内容
	-- fernet.py：对称算法的实现，使用cryptography最基础的使用，

2.1-fernet的使用

cryptography最基本的使用

Fernet方法的简单介绍

classmethod generate_key()：类方法，用于生成base64-encoded 32-byte key.

encrypt(data)：实例方法，加密数据
encrypt_at_time(data, current_time)：使用显式传递的当前时间加密传递的数据

decrypt(token, ttl=None)：实例方法，解密数据
decrypt_at_time(token, ttl, current_time)：使用显式传递的当前时间来解密令牌

extract_timestamp(token)：返回该令牌的时间戳。然后，调用者可以决定令牌是否即将到期，例如，发出一个新的令牌

MultiFernet(fernets)：MultiFernet类，这个类为Fernet实现了密钥流转。它接受一个Fernet实例列表，并实现相同的API

Fernet的使用示例

示例来源于库文档介绍中的内容

Cryptography Documentation Release 43.0.0.dev1

>>> from cryptography.fernet import Fernet
>>> key = Fernet.generate_key()
>>> f = Fernet(key)
>>> token = f.encrypt(b"my deep dark secret")
>>> token
b'...' # 每一次的结果都是不同的
>>> f.decrypt(token)
b'my deep dark secret'

2.2-padding填充

padding.py提供PKCS7和ANSIX923填充方式

PKCS7：填充到指定长度，填充内容为填充的长度

ANSIX923：填充最后一个字节为长度，其余的为0

这里以PKCS7为例：

import binascii
from cryptography.hazmat.primitives import padding


class MyPadding:
    def __init__(self, block_size: int):
        self.block_size = block_size

    def padding(self, padding_data):
        b_padding_data = padding_data.encode('utf8')
        padder = padding.PKCS7(block_size=self.block_size).padder()
        result = padder.update(b_padding_data) + padder.finalize()
        return result

    def unpadding(self, unpadding_data):
        unpadder = padding.PKCS7(block_size=self.block_size).unpadder()
        result = unpadder.update(unpadding_data) + unpadder.finalize()
        return result


if __name__ == '__main__':
    my_padding = MyPadding(128)
    data = "123456789"
    p = my_padding.padding(data)
    print(p)
    print(type(p))
    print(binascii.b2a_hex(p))
    d = my_padding.unpadding(p)
    print(d)
    
    '''
    b'123456789\x07\x07\x07\x07\x07\x07\x07'
    <class 'bytes'>
    b'31323334353637383907070707070707'
    b'123456789'
    '''

ANSIX923：

>>> padder = padding.ANSIX923(128).padder()
>>> padded_data = padder.update(b"11111111111111112222222222")
>>> padded_data += padder.finalize()
>>> padded_data
b'11111111111111112222222222\x00\x00\x00\x00\x00\x06'
>>> unpadder = padding.ANSIX923(128).unpadder()
>>> data = unpadder.update(padded_data)
>>> data += unpadder.finalize()
>>> data
b'11111111111111112222222222'

2.3-Hash

这里简单的展示cryptography库hash的使用。

实例hash对象hashes.HASH(hashes.‘hash_name’()) -> 把‘hash_name’替换为哈希算法名即可，比如SHA1，SHA256等等，如果不清楚支持哪些，可以查看hashes.py文件，里面有列举
如果hash内容很多，可以分多次update，没有内容了，最后finalize即可
HASH：SHA1，SHA512_224，SHA512_256，SHA224，SHA256，SHA384，SHA512，SHA3_224，SHA3_256，SHA3_384，SHA3_512，SHAKE128，SHAKE256，MD5，BLAKE2b，BLAKE2s，SM3

>>> from cryptography.hazmat.primitives import hashes
>>> digest = hashes.Hash(hashes.SHA256())
>>> digest.update(b"abc")
>>> digest.update(b"123")
>>> digest.finalize()
b'l\xa1=R\xcap\xc8\x83\xe0\xf0\xbb\x10\x1eBZ\x89\xe8bM\xe5\x1d\xb2\xd29%\x93\xafj\
x84\x11\x80\x90'

如果不想使用cryptography的hash，可以使用python自带的hashlib库完成

import hashlib

__hash__ = [   'md5','sha1','sha224','sha256','sha384','sha512','blake2b','blake2s','ripemd160','whirlpool','sha3_224','sha3_256','sha3_384','sha3_512','sm3',]

class MyHash:
    def __init__(self, hash_name: str):
        self.hash_name = hash_name.lower()

    def hash(self, hash_data: str):
        if self.hash_name not in __hash__:
            raise "unsupported hash, confirm the input hash name"
        hash_object = hashlib.new(self.hash_name)
        hash_object.update(hash_data.encode('utf-8'))
        return hash_object.hexdigest()


if __name__ == '__main__':
    data = 'abc123'
    my_hash = MyHash('SHA256')
    print(my_hash.hash(data))

2.4-ciphers（对称算法AES为例）

AES等算法和CBC模式结合。使用AES加密内容，然后解密内容的一个简单例子：

>>> import os
>>> from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
>>> key = os.urandom(32)
>>> iv = os.urandom(16)
>>> cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
>>> encryptor = cipher.encryptor()
>>> ct = encryptor.update(b"a secret message") + encryptor.finalize()
>>> decryptor = cipher.decryptor()
>>> decryptor.update(ct) + decryptor.finalize()
b'a secret message'

封装使用：

如需要使用其他算法，只需要根据下方封装的，简单修改即可，大部分只需要修改加解密中使用的算法名称即可

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
需要IV的加密模式：CBC、OFB、CFB、CFB8

加密算法：["AES","Camellia","TripleDES","Blowfish","CAST5","ARC4","IDEA","SEED","ChaCha20","SM4"]
"""
import binascii
import os
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
import my_padding

MODES_NAME = ["CBC", "ECB", "OFB", "CFB"]


def gen_key(key_len):
    return os.urandom(key_len)


def _model_object(alg_modes, alg_iv):
    if alg_modes.upper() not in MODES_NAME:
        raise "unsupported modes, confirm the input hash name"
    modes_dict = {
        "CBC": modes.CBC(alg_iv),
        "ECB": modes.ECB(),
        "OFB": modes.OFB(alg_iv),
        "CFB": modes.CFB(alg_iv)
    }
    return modes_dict.get(alg_modes.upper())


def hex2string(hex_string):
    bytes_string = binascii.a2b_hex(hex_string)
    return bytes_string.decode('utf8')


class MyAES:
    name = 'AES'
    block_size = 128
    key_sizes = frozenset([128, 192, 256, 512])

    def __init__(self,
                 alg_key: bytes = None,
                 alg_modes: str = 'CBC',
                 alg_iv: bytes = b'1234567812345678'):
        # 默认key_size,为32
        if alg_key is None:
            self.__alg_key = gen_key(32)
        else:
            self.__alg_key = alg_key
        self.__alg_iv = alg_iv
        self.__alg_modes = _model_object(alg_modes, alg_iv)

    def get_key(self):
        return binascii.b2a_hex(self.__alg_key)

    def set_key(self, alg_key: bytes):
        # 对alg_key进行判断
        if not isinstance(alg_key, bytes):
            raise TypeError("Type error: {0} is not an instance of bytes".format(type(alg_key)))
        self.__alg_key = alg_key

    def get_iv(self):
        return binascii.b2a_hex(self.__alg_iv)

    def set_iv(self, iv: bytes):
        if not isinstance(iv, bytes):
            raise TypeError("Type error: {0} is not an instance of bytes".format(type(iv)))
        self.__alg_iv = iv

    def encrypt(self, plain_data: str):
        """
        输入字符串，完成加密操作
        :param plain_data: 明文字符串
        :return: 16进制密文字符串
        """
        # 完成数据填充，转为bytes后的填充数据
        data_padding = my_padding.MyPadding(MyAES.block_size).padding(plain_data)
        # aes对象
        my_alg = Cipher(algorithms.AES(self.__alg_key), self.__alg_modes)
        encryptor = my_alg.encryptor()
        # 加密操作完成
        result = encryptor.update(data_padding) + encryptor.finalize()
        # 转为大写的16进制字符串输出
        return binascii.b2a_hex(result).upper().decode()

    def decrypt(self, cipher_data: str):
        """
        输入16进制密文数据，返回原文
        :param cipher_data: 16进制密文数据字符串
        :return:
        """
        cipher_data_bytes = binascii.a2b_hex(cipher_data)
        my_alg = Cipher(algorithms.AES(self.__alg_key), self.__alg_modes)
        decrypt = my_alg.decryptor()
        # 解密操作完成
        result = decrypt.update(cipher_data_bytes) + decrypt.finalize()
        data_unpadding = my_padding.MyPadding(MyAES.block_size).unpadding(result)
        # 转为大写的16进制字符串输出
        return binascii.b2a_hex(data_unpadding).upper().decode()


if __name__ == '__main__':
    aes = MyAES()
    data = 'hello world'
    cipher = aes.encrypt(data)
    plain = aes.decrypt(cipher)
    print('cipher:', cipher)
    print('plain:', hex2string(plain))
    print('key:', aes.get_key())
    print('iv:', aes.get_iv())
    print('alg_name:', aes.name)
    
    '''
    cipher: 6EAE64A7B78A5C0985A1CADA8FAAB7D0
	plain: hello world
	key: b'4f56291a9aaa86fbd341ac5ca0bb10fa5d583d281b55f853172e83197effa0c2'
	iv: b'31323334353637383132333435363738'
	alg_name: AES
    '''

2.5-asymmetric(非对称算法RSA为例)

asymmetric对应的位置在//cryptography/hazmat/primitives/asymmetric路径下，cryptography库支持多种非对称算法，包括：ed25519、RSA、dh、dsa、ed448等。这个以最常见的RSA算法为例。

按照官方文档中的介绍，主要内容为：

Generation：生成一个RSA私钥
key loading：加载PEM格式的密钥
Key serialization：密钥序列化，可以获取一个base64格式的密钥
Signing：用私钥对消息进行签名，公钥可以对结果进行验签
Verification：对应公钥对消息的验签
Encryption：使用公钥对数据进行加密，这样只有拥有私钥的才可已经进行解密
Decryption：私钥解密公钥加密的信息
Padding：RSA签名需要一个特定的散列函数，并且需要使用填充，加密的时候也会涉及到对消息的填充
Numbers：包含RSA密钥的组成，可以获取到对应公钥和私钥的组成，一般不建议使用。
Handling partial RSA private keys：用不到，一般都是专业的密码使用者才有可能用到
Key interfaces：密钥对应的主要接口

查看asymmetric目录下的rsa.py文件，根据源码中的内容，学习上述的主要内容

函数：generate_private_key

def generate_private_key(
    public_exponent: int,
    key_size: int,
    backend: typing.Any = None,
)-> RSAPrivateKey:
    pass

'''
public_exponent：指数，这个根据密码学的知识，这个默认都是传65537
key_size

Parameters
• public_exponent (int) – 指数，这个根据密码学的知识，这个默认都是传65537
• key_size (int) – 指的是私钥长度（位），如1024bit，2048bit，4096bit
• backend - 默认即可
Returns
返回 RSAPrivateKey 类 ，这个类也是在`rsa.py`文件中定义好的
'''

类：RSAPrivateKey（私钥类）

class RSAPrivateKey(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def decrypt(self, ciphertext: bytes, padding: AsymmetricPadding) -> bytes:
        """
        解密提供的密文。可以看到传参除了密文外，还需要填充算法，对应的填充算法可以查看`asymmetric`下的padding.py
        """

    @property
    @abc.abstractmethod
    def key_size(self) -> int:
        """
        密钥的长度，也就说通过generate_private_key函数传入的key_size
        """

    @abc.abstractmethod
    def public_key(self) -> RSAPublicKey:
        """
        与此私钥关联的RSAPublicKey(也是一个类，公钥类)。
        """

    @abc.abstractmethod
    def sign(
        self,
        data: bytes,
        padding: AsymmetricPadding,
        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
    ) -> bytes:
        """
        对消息进行签名.涉及填充算法，以及hash算法
        """

    @abc.abstractmethod
    def private_numbers(self) -> RSAPrivateNumbers:
        """
        返回RSAPrivateNumbers类，一般很少用到，不做具体研究
        """

    @abc.abstractmethod
    def private_bytes(
        self,
        encoding: _serialization.Encoding,
        format: _serialization.PrivateFormat,
        encryption_algorithm: _serialization.KeySerializationEncryption,
    ) -> bytes:
        """
        返回私钥的序列化
        """

类：RSAPublicKey（公钥类）

class RSAPublicKey(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def encrypt(self, plaintext: bytes, padding: AsymmetricPadding) -> bytes:
        """
        加密给定的明文
        """

    @property
    @abc.abstractmethod
    def key_size(self) -> int:
        """
        公共模的比特长度。
        """

    @abc.abstractmethod
    def public_numbers(self) -> RSAPublicNumbers:
        """
        返回 RSAPublicNumbers 类
        """

    @abc.abstractmethod
    def public_bytes(
        self,
        encoding: _serialization.Encoding,
        format: _serialization.PublicFormat,
    ) -> bytes:
        """
        返回公钥的序列化
        """

    @abc.abstractmethod
    def verify(
        self,
        signature: bytes,
        data: bytes,
        padding: AsymmetricPadding,
        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
    ) -> None:
        """
        对消息进行验签
        """

    @abc.abstractmethod
    def recover_data_from_signature(
        self,
        signature: bytes,
        padding: AsymmetricPadding,
        algorithm: typing.Optional[hashes.HashAlgorithm],
    ) -> bytes:
        """
        从签名中恢复原始数据。
        """

    @abc.abstractmethod
    def __eq__(self, other: object) -> bool:
        """
        Checks equality.
        """

rsa.py的其他内容

class RSAPrivateNumbers：RSAPrivateNumbers类，前面内容中提到的，获取私钥的组成的内容，比如p，q，d等等。如果是外部知道这些私钥组成值，也可以用类方法private_key，返回RSAPrivateKey类
class RSAPublicNumbers：RSAPublicNumbers类，前面内容中提到的，获取公钥的组成的内容。比如e，n，如果是外部知道这些公钥组成值，也可以用类方法public_key，返回RSAPublicKey类
等等（其他是配套对函数，有兴趣自行了解）

非对称算法下的padding.py的使用

对应文件的位置：跟rsa.py文件位于同一级目录下，这个padding文件是专门用于非对称算法中的填充，只提供了3种填充方式：

PKCS1v15：一个简单的填充方案，可用于签名和加密。不建议PKCS1v15用于新应用，官方建议说是加密首选OAEP，签名首选PSS
PSS：RSA签名推荐的填充算法。不能与RSA加密一起使用
OAEP：RSA加密的填充算法。它不能与RSA签名一起使用

# 示例
类PKCS1v15：无需任何参数，是最简单的填充方式，每次的结果都是一样

类OAEP：需要3个参数
	参数：
		• mgf – 掩码生成函数对象. 只支持 MGF1.
		• algorithm – 哈希算法的一个实例
		• label (bytes) – 要设置的应用标签（没了解），默认None即可.
		
类PSS：需要2个参数
	参数：
		• mgf – 掩码生成函数对象. 只支持 MGF1.
		• salt_length (int) – 盐的长度。建议将其设置为PSS.DIGEST_LENGTH或PSS.MAX_LENGTH.

示例

结合上述的内容，rsa主要内容可以分为以下四部分

生成密钥对->对应私钥类->私钥类中有对应获取公钥类的方法
公钥和私钥对应的方法：常见的就是加密，解密，签名，验签
公钥和私钥的序列化
公钥和私钥组成部分的获取，或根据对应的值生成对应的公钥类私钥类

其他：serialization目录用于序列化私钥和公钥的内容，将公钥和私钥保存或加载，这里不做具体介绍，只给出示例，有需要可以去了解serialization下的内容

密钥生成，加密，解密，签名，验签，查看密钥对信息，序列化

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import serialization
import binascii


# 以下示例均来自官方文档的的内容，加以整合
# 生成密钥对，generate_private_key返回的是RSAPrivateKey类
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)

# 获取对应的公钥类RSAPublicKey
public_key = private_key.public_key()

# 使用私钥完成一些操作，解密，签名
# 使用公钥完成一些操作，加密，验签
# 签名，填充方式可以改为pkcs1v15，padding.PKCS1v15，返回签名结果
sign_message = b"A message I want to sign"
signature = private_key.sign(
    sign_message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH),
    hashes.SHA256())

print("message:",binascii.b2a_hex(message))

# 验证签名：有公钥、消息、签名值和所使用的签名算法，这个是没有返回值,验签失败会引发异常：InvalidSignature
try:
    public_key.verify(
        signature,
        sign_message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH),
        hashes.SHA256())
    print("verify：True")
except Exception:
    print("verify：False")

# 加密操作
encrypted_message = b"encrypted data"
ciphertext = public_key.encrypt(
    encrypted_message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None))

print("encrypted_message:",encrypted_message)
print("ciphertext:",binascii.b2a_hex(ciphertext))

# 解密操作
plaintext = private_key.decrypt(
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None))
print("plaintext:",plaintext)

print("\n\nRSAPrivateNumbers和RSAPublicNumbers：")
print("\n--RSAPrivateNumbers")
private_numbers = private_key.private_numbers()
print("private_key_p:",private_numbers.p)
print("private_key_q:",private_numbers.q)
print("private_key_d:",private_numbers.d)

print("\n--RSAPublicNumbers")
public_numbers = public_key.public_numbers()
print("public_numbers_e:",public_numbers.e)
print("public_numbers_n:",public_numbers.n)


print("\n\n序列化：")
print("private_key(加密):")
pem1 = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.BestAvailableEncryption(b'mypassword'))
# 将mypassword改为具体的密码
print(pem1.splitlines())
print("\nprivate_key(不加密):")
pem2 = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.TraditionalOpenSSL,
    encryption_algorithm=serialization.NoEncryption())
print(pem2.splitlines())

print("\npublic_key:")
pem3 = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo)
print(pem3.splitlines())

'''
serialization:涉及的功能还有load公钥和私钥，可加载pem，der等格式的数据，以及证书相关的数据，有需要可以去了解
'''

结果：

message: b'41206d65737361676520492077616e7420746f207369676e'
verify：True
encrypted_message: b'encrypted data'
ciphertext: b'2de0f1fe1b5d72b947b8dbf71d05c38dc68bd651726070e606b4a9458d7c0fa16dfb07172171ba859a3409218e0b7ecad7b17fe56fd35bb49e31f0841acde909975620e83a1877219d15238f6688347431c36feb7663b177a966493109fe231e99e670f25d3ffc110a5676446026760ab739adb18fec25880eac014b1f2954a3b73db5678434bf60863dd06004dc829d221d3379e3cc063a6b4b85bfc5be169cfc299635a4e49b78054c57e792122b6b9aed137f7aedf25bc597788e0dd504e7b1c1da9afb8b6f80fe302ae51695473df63062990689afb466c96971756afd83326ac45839a031060194a0eed3aa169712cf6a4269a3cc16a5b10f5c605806c3'
plaintext: b'encrypted data'

RSAPrivateNumbers和RSAPublicNumbers：

--RSAPrivateNumbers
private_key_p: 147707585390291063655757186262664106581403583389769944190047479079802050557725461099143359285822400756601173686331008082783603762936206021035899801451983264373148026750004290322897832812789405156566036002605846423080016655535724545169357406940078465489591648499524311055428140666709043701951435405479083981507
private_key_q: 129818834990747146076466076783245566173460449186750491874222727814890697974924830062686005653997995728519629633284989915391162771546276906687785728345643383550878857450814037005853925931576826949107171864400879318575256878287526216494946410211681273209849751153418151910847326891086641035970617228184947974907
private_key_d: 8810065303547375928762349845316578013736506843080962512785868984734235290147877769264533096278362621787580696227653983919152226155921915698934833065258407586046747526250001963974218056036596580241940226949193816099076733090875075170550805899822656343465349396304500236060334137387244149410275988416202842542643262376837913857243207448439181111570332656768871231679656608370503370807857876773764088762784617137105654224500539668074456531405130162650453503803762719548271686520860271816511040217898091202461965447102304587164219886390683471833950962879479877256508594964292975127590603085155442999424663885457883776781

--RSAPublicNumbers
public_numbers_e: 65537
public_numbers_n: 19175226654663889483686962299907428291529655241439907017383929316612785301398873015319640846560893067121406664962032451400135480242458058156856037813351939755130872193811111511174598277655024080213743703416336724973770112469751247100806621044026350130573166065079473679741161647303238677556416507350559120976572285358670246819946035044400185934220271734966395030418149358791928954989911148327721467003737750718274576389626687388317759384228357042486488866743832265506806649718988419123733129099398851518371219540705498141408901068424765912060559147570293587318212074428767533901711200492332308159704597121102288044849

序列化：
private_key(加密):
[b'-----BEGIN ENCRYPTED PRIVATE KEY-----', 
b'MIIFNTBfBgkqhkiG9w0BBQ0wUjAxBgkqhkiG9w0BBQwwJAQQIgxxwKU52uh4HZra', b'9yMxDwICCAAwDAYIKoZIhvcNAgkFADAdBglghkgBZQMEASoEEOmuIolT9bVH3sVl', b'FarjNV8EggTQizU+Wlfb7PPYR7Pw2/QZl3Br4q79fDrdwNTWBcF5gZg7/+2tkFCn', b'X61/kcYkt9r+znyzjRQ6q3DeW2kfGL6iKEpHnon8OZcg23ZadNw4ossUDGg0dQWD', b'xzXZ8ztM+saQW05gl622cBjcpmWH7rrD6EjOMKMSwEh1iowrnb/1vk/h5cbe72fv', b'JWAPyQMLlRZyFncXukXY2UQe5+8wJquNoSmr4bBdWy5BshUstZEj7+bquzhOn4nm', b'VL1E/u6fhx3F3nfq9HfZg5BCZo1g0otMlcNUo7ecKdqQ6Cx4P0CwoJEYd9Rr1v5O', b'KV5M0tcp7Nt1FdTX0gTJZXYa8rMor+uvjuLV8cd8e9ygxRbdAau/X0Jh6tbKS/fh', b'EI7BxHaaiZXR7wNx08A/Sbup09Bo8awebjr+gEZuiwW2lO5UvEaqXI6g3w7H2SmK', b'xB5zRa6vtZkoobUZfKLDkRYW8Q7wIm6/zfUQ/xB6V0rgVZgVZ5Yo4nQnq/teqkEC', b'MuhI++rC7liTrpydf3lr+OI67WpbHnzgodNSSNp579p1SbGYcDSQK2/FOMmEfINE', b'2+2AAcAU2pNbj/XGyE8EEl/5wv/IHCbGQXOiJhxZcFIL/cbJh9r3zM4UJQRek91k', b'fQ5UF+sJF9D7iH8+6wH3iWKRAhyRtbukHQ1J1b+qH9GwPfkJM6JTR221WfyoAi84', b'3B+BxZLRWu1rTmMu3erUt90Gua9oDfQ5awvMr7c4ng3i1lFw9uT8xPlxr9GPbA4v', b'pU5/E+VTRo6PghuDLZarTdIHH2VURW1gEzttJiVgODRyN0MEEEC80vWTW6L3gnZO', b'fYufxLySQvxULeAJL+VkRKqQQa8xC8CogLXFa+nM4qIcgU83gjfaYk6VEf/M3Fkh', b'gHinbWdRdXL4WPBLqWtGIZa5/Ybt+ElEbonPZBaasIySp0BBtKjhdQhEtf3nGh0i', b'/Mo7RnWPd5B8SPmFx9Sy0boLMle4OxsWog2lXpN0Nf3zJeSgh9AohDLm1vvxadT+', b'FVQZXN5Y2pOKbK+H621r3kDy9HqSotISa20HLGs58bSEY4YSLwzOUAcFqjBb70t4', b'oP+j0lYse8ZcAZ7sW9uubekYeA55vIKDZKuNuysnpm5QEF42Zhq1Cz0VSS/addPs', b'KbgDqSVqCALqwdWcy5K3PXa77IwZorXg1woVvL/iw7PZoJ26XB8dSPk7jD75Lza7', b'W542mxrg6TrHVZfcDEpGEchWj4Nh/80NGxSwHXEiTRow4sHxfCePyK2N61YjBykw', b'//QXjBhB3R4nDZUxvAkwkEU1mV89U9TOtF3L9pEFSeA2Z3Vlyo57++yGsPtPeIvI', b'uFg9fSL9EjOgjWNjgfa3Mn2UBWV+eOi9LTH5M6Xslhqu0/2QPF8Z2TQ9i1RjecaD', b'eaezPrgjOq9IL9NERjaT8t1ocnfZbPbNUDmAGWVC0bi16WSM/QqzagzOxVrhevoN', b'YjBKh0PF29C0d05R6nc9jW8HJAHj/CEkUtx+S4LcCYMiBwFJwHeCfYXzOYx2iLkW', b'8q7FVndB11mxg9VYDf7aXpgItNTEwTl8iJRXhLE1FDA6dO2g1t1gMmZwIvdGNXc4', b'Qta6kOyRqypsMsxmu/5U87XxgR99D5Fyljt1F3T/3ir3hIjk2xIOze8=', 
b'-----END ENCRYPTED PRIVATE KEY-----']

private_key(不加密):
[b'-----BEGIN RSA PRIVATE KEY-----', 
b'MIIEpAIBAAKCAQEAl+WlWH3VkNfRFXjxpmNrTskYDEF/MFGufYy5gfZ8+p9O2Cwk', b'RC2s6jv8dtdxi+a+GUvnks54xdnKAeOAgdd9HHs9hK0DmeGymVFUUfglfgIm3xm5', b'A33i2m6Eg/5Uipq3fVPx4sqlME2uHJs4Vb/4wN+Tz/F2xllIsSzeHR3oKg8EYc0w', b'oW3EHqLpvBUy+V5OIjlkajXFLpCIFlYMAXGbDJ9jTNP4IU8sDUc1MDCB4MyNE9Qs', b'YTjujj8YFbNmTEM3RSMV/oCTtsEmVIjxENNMb94+8tmpzMku//oQALTwZ9aKJsoV', b'VERVmu42gxJtRIYWrIpkhf713GWYUUdBwiTDMQIDAQABAoIBAEXKBmkdD6XH8tG5', b'ytVW8nO1Yy4mXai2rsQShx0WQh/oWBJsXZFRpxPL0dhMbmgH8SmwPUqvQMAuq2io', b'vV9qwZn3abFuyKvIDgXxXxt2Nsupc3Cn4eCf0z3m702x6efw5ANaMVWxI6qI1klg', b'a8bCOCltz/0HhTnmxcZZxgd8uTGxFQ431w5iqnWJ26u57eSjoxLPdAQxqbBVbwOY', b'x2clL/5MK9VDroVn6k/dnQlKjJ1YhCOLq9AlAQ8kaudhB7xNGp19d9k5LJJKZCjX', b'SuGA1Fi0Dk0AvyUsK5IQ83LutT5jZezKNE8wkc1ryj+OnYBi9zbqArdi0Euam/aT', b'4Sq1xw0CgYEA0lezj+p6vasX14PlVic/rdlmpWqQqWHZR6kltOtK+x50W0QHHtPC', b'fTyDk3hJ4DczzBmjsyVHQPjkw3dqY3KtSWOrInjoJGGOBxQgv85c+uaLXsh9iOM2', b'H64JYHboXcp5G2+So3nz6mzrlB/j9St/CrZB6d1RenWJH6y86nWrOsMCgYEAuN4/', b'kb/aZ7PbdGK71zjCHqCGK9EvV3Lo0rn/HUQSr8g/kiBsKtXOLwi9vaF+VM5xVcJ2', b'DvH835CP7zoF6/58NAh90I5nOCJ6Ukt9VsWJvx7+78QSykU9L0BJLWarA6nQlEis', b'kNSNB1NE27Zu3KHnXRaFM+LKv4pxP9CJ+Bb24vsCgYEAwBPCLxuJ9gV1AiK5nBC/', b'P7wU1d0YOPTXe27kte9fSy2mR2k5r1bkdYR7CoF/xLXkIO8Q45iZFqWyESTNC/8+', b'apQPRK1wHzjOf3xL45tIoP1CK82dhREm7Yr5mRM8Ydlw+jLKj2nf6SSJg3wTqGCN', b'5HRGgI7PxqnqC/irktbdBA0CgYEAmKBMxW0qyPFR3p3hTUf75ENNYoGa30zscYXD', b'3QqljuD5sw/3ncnVJznFRPk+jo++PDqHM8GPr5fvbWdvGi6Jpn/YN8ZJ66tzZ9wR', b'SAFgvxy9B4DOrpZJdGhTwhsAV87seHAjoJMLOCAEOo08rAUzOcRtBrBYCZkn9LKc', b'Jen3vN8CgYAStWv4jLNEGcJWweAIgQlGoaJPLGEd5aGP7au2NWtUsG1cbj8NUYox', b'CAweSjQrmvA1fHIWrMO3Cc99/04/aRQwHcLdgqCVMXBDIe9tuBo/QhTTcfC5bGye', b'X/HTMjfXHpsBUocsDpeQ/zeoKclZFQUsUbVg2Bfs292kaFr7YginHQ==', 
b'-----END RSA PRIVATE KEY-----']

public_key:
[b'-----BEGIN PUBLIC KEY-----', 
b'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAl+WlWH3VkNfRFXjxpmNr', b'TskYDEF/MFGufYy5gfZ8+p9O2CwkRC2s6jv8dtdxi+a+GUvnks54xdnKAeOAgdd9', b'HHs9hK0DmeGymVFUUfglfgIm3xm5A33i2m6Eg/5Uipq3fVPx4sqlME2uHJs4Vb/4', b'wN+Tz/F2xllIsSzeHR3oKg8EYc0woW3EHqLpvBUy+V5OIjlkajXFLpCIFlYMAXGb', b'DJ9jTNP4IU8sDUc1MDCB4MyNE9QsYTjujj8YFbNmTEM3RSMV/oCTtsEmVIjxENNM', b'b94+8tmpzMku//oQALTwZ9aKJsoVVERVmu42gxJtRIYWrIpkhf713GWYUUdBwiTD', 
b'MQIDAQAB', 
b'-----END PUBLIC KEY-----']