【python】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 paddingclass MyPadding:def __init__(self, block_size: int):self.block_size = block_sizedef 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 resultdef unpadding(self, unpadding_data):unpadder = padding.PKCS7(block_size=self.block_size).unpadder()result = unpadder.update(unpadding_data) + unpadder.finalize()return resultif __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的使用。

>>> 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_paddingMODES_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 = 128key_sizes = frozenset([128, 192, 256, 512])def __init__(self,alg_key: bytes = None,alg_modes: str = 'CBC',alg_iv: bytes = b'1234567812345678'):# 默认key_size,为32if alg_key is None:self.__alg_key = gen_key(32)else:self.__alg_key = alg_keyself.__alg_iv = alg_ivself.__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_keydef 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 = ivdef 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: 6EAE64A7B78A5C0985A1CADA8FAAB7D0plain: hello worldkey: 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_sizeParameters
• public_exponent (int) – 指数，这个根据密码学的知识，这个默认都是传65537
• key_size (int) – 指的是私钥长度（位），如1024bit，2048bit，4096bit
• backend - 默认即可
Returns
返回 RSAPrivateKey 类 ，这个类也是在`rsa.py`文件中定义好的
'''

类：RSAPrivateKey（私钥类）

class RSAPrivateKey(metaclass=abc.ABCMeta):@abc.abstractmethoddef decrypt(self, ciphertext: bytes, padding: AsymmetricPadding) -> bytes:"""解密提供的密文。可以看到传参除了密文外，还需要填充算法，对应的填充算法可以查看`asymmetric`下的padding.py"""@[e-mail] key_size(self) -> int:"""密钥的长度，也就说通过generate_private_key函数传入的key_size"""@abc.abstractmethoddef public_key(self) -> RSAPublicKey:"""与此私钥关联的RSAPublicKey(也是一个类，公钥类)。"""@abc.abstractmethoddef sign(self,data: bytes,padding: AsymmetricPadding,algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],) -> bytes:"""对消息进行签名.涉及填充算法，以及hash算法"""@abc.abstractmethoddef private_numbers(self) -> RSAPrivateNumbers:"""返回RSAPrivateNumbers类，一般很少用到，不做具体研究"""@abc.abstractmethoddef private_bytes(self,encoding: _serialization.Encoding,format: _serialization.PrivateFormat,encryption_algorithm: _serialization.KeySerializationEncryption,) -> bytes:"""返回私钥的序列化"""

类：RSAPublicKey（公钥类）

class RSAPublicKey(metaclass=abc.ABCMeta):@abc.abstractmethoddef encrypt(self, plaintext: bytes, padding: AsymmetricPadding) -> bytes:"""加密给定的明文"""@[e-mail] key_size(self) -> int:"""公共模的比特长度。"""@abc.abstractmethoddef public_numbers(self) -> RSAPublicNumbers:"""返回 RSAPublicNumbers 类"""@abc.abstractmethoddef public_bytes(self,encoding: _serialization.Encoding,format: _serialization.PublicFormat,) -> bytes:"""返回公钥的序列化"""@abc.abstractmethoddef verify(self,signature: bytes,data: bytes,padding: AsymmetricPadding,algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],) -> None:"""对消息进行验签"""@abc.abstractmethoddef recover_data_from_signature(self,signature: bytes,padding: AsymmetricPadding,algorithm: typing.Optional[hashes.HashAlgorithm],) -> bytes:"""从签名中恢复原始数据。"""@abc.abstractmethoddef __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-----']