首页 > 脚本专栏 > python > python cryptography库

python中cryptography库的实现

2025-01-15 11:28:20 作者：羽丶千落

本文主要介绍了python中cryptography库的实现,包括Fernet、hash、AES、RSA等加密算法的使用,具有一定的参加价值,感兴趣的可以了解一下

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("signature :",binascii.b2a_hex(signature))

# 验证签名：有公钥、消息、签名值和所使用的签名算法，这个是没有返回值,验签失败会引发异常：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-----']

到此这篇关于python中cryptography库的实现的文章就介绍到这了,更多相关python cryptography库内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！