python模块 — cryptography

笃行之.kiss

已于 2023-09-01 10:29:12 修改

阅读量8.4k

点赞数 6

分类专栏： Python模块文章标签： python 加解密秘钥 rsa cryptography

于 2023-08-25 18:12:51 首次发布

本文链接：https://blog.csdn.net/panc_guizaijianchi/article/details/132501029

版权

Python模块专栏收录该内容

16 篇文章 9 订阅

订阅专栏

1、cryptography模块

cryptography模块是Python中用于密码学操作的核心模块。它提供了各种密码学算法、密钥生成、加密、解密、签名和验证等功能。

官网地址：cryptography · PyPI

版本要求：Python 3.7+

安装：pip install cryptography

文档：Welcome to pyca/cryptography — Cryptography 42.0.0.dev1 documentation

以下是cryptography模块的核心模块：

`cryptography.hazmat.primitives`：该模块包含了密码学原语（primitives），如散列函数、对称加密、非对称加密、消息认证码等。这些原语供开发人员直接使用。
`cryptography.hazmat.primitives.asymmetric`：该模块包含了非对称加密相关的原语，如RSA、椭圆曲线加密（ECC）等。
`cryptography.hazmat.primitives.symmetric`：该模块包含了对称加密相关的原语，如AES、DES等。
`cryptography.hazmat.primitives.hashes`：该模块包含了各种散列函数，如SHA-256、SHA-512、MD5等。
`cryptography.hazmat.primitives.serialization`：该模块包含了序列化和反序列化密码学对象的功能，如将私钥、公钥和证书转换为不同格式的字节字符串。
`cryptography.hazmat.primitives.padding`：该模块包含了各种填充方案，用于在加密和解密数据时填充数据块。
`cryptography.hazmat.primitives.ciphers`：该模块包含了低级别的加密原语，如AES、DES等加密算法的底层接口。
`cryptography.hazmat.primitives.keywrap`：该模块包含了对称密钥包装和解包装的功能，用于加密和解密对称密钥。

2、生成秘钥

2.1 生成私钥

在cryptography模块中，使用cryptography.hazmat.primitives.asymmetric.rsa模块的generate_private_key()方法生成了一个RSA私钥对象。

语法格式：

def generate_private_key(
    public_exponent: int, key_size: int, backend=None
) -> RSAPrivateKey

参数说明：

`public_exponent`：公钥指数，是RSA算法中公钥的一部分，通常选择一个固定的值，如65537（即0x10001）。这是一个安全且常见的选项。
`key_size`：密钥长度，用于确定生成的RSA私钥的强度，即位数。常见的密钥长度包括2048、3072和4096等。较长的密钥长度提供更大的安全性，但也需要更长的加密和解密时间。
`backend`：可选参数，默认值为 `None`，这个参数用于指定加密库的后端实现。如果不提供后端参数，默认情况下将使用适当的后端。
返回值：`RSAPrivateKey`，这是 `cryptography.hazmat.primitives.asymmetric.rsa` 模块中表示RSA私钥的类。

以下是一个使用`generate_private_key()`方法的示例：

from cryptography.hazmat.primitives.asymmetric import rsa

# 生成RSA私钥
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)

在上面的示例中，`generate_private_key()`方法生成了一个RSA私钥对象。我们使用参数`public_exponent=65537`和`key_size=2048`来定义生成的私钥的公钥指数和密钥长度。

注意，私钥是非常敏感的信息，需要妥善保管，并在必要时进行严格的访问控制。

2.2 生成公钥

在`cryptography`库中，可以通过私钥生成对应的公钥。公钥可以通过私钥对象的`public_key()`方法获得公钥对象。

语法格式：

def public_key(self) -> "RSAPublicKey":
    """
    The RSAPublicKey associated with this private key.
    """

以下是使用私钥对象的'public_key()'方法生成公钥的示例代码：

from cryptography.hazmat.primitives.asymmetric import rsa

# 生成RSA私钥
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)

# 生成RSA公钥
public_key = private_key.public_key()

在上述示例中，我们使用私钥对象的`public_key()`方法获得了对应的公钥对象。

注意，私钥和公钥配对使用，私钥用于加密和签名，而公钥用于解密和验证签名。私钥是敏感信息，需要妥善保管，不应泄露给他人。公钥可以公开传播给其他人，以便其他人使用。

3、保存秘钥

将生成的秘钥序列化成字节序列，然后保存成pem格式。

3.1 序列化私钥

在cryptography库中，可以使用serialization模块中的'private_bytes()'函数将私钥序列化为字节流表示。

语法格式：

    def private_bytes(
        self,
        encoding: _serialization.Encoding,
        format: _serialization.PrivateFormat,
        encryption_algorithm: _serialization.KeySerializationEncryption,
    ) -> bytes:
        """
        Returns the key serialized as bytes.
        """

参数说明：

`encoding`：编码，这个参数用于指定私钥在序列化时使用的编码方式。`_serialization.Encoding` 是一个枚举类，常用的取值包括：
- `PEM`：使用 Base64 编码将私钥序列化为文本格式。
- `DER`：将私钥序列化为二进制格式。

`format`：秘钥格式，这个参数用于指定私钥序列化时的格式。`_serialization.PrivateFormat` 是一个枚举类，常用的取值包括：
-`PKCS8`：使用 PKCS#8 格式序列化私钥。
-`TraditionalOpenSSL`：使用传统的 OpenSSL 格式序列化私钥。

`encryption_algorithm`：加密算法，这个参数用于指定是否对私钥进行加密。`_serialization.KeySerializationEncryption` 是一个枚举类，常用的取值包括：
-`NoEncryption`：不对私钥进行加密，私钥将以明文形式序列化。
-`BestAvailableEncryption`：使用可用的最佳加密算法对私钥进行加密。

返回值：`bytes`：私钥序列化后的字节流表示。

以下是将私钥序列化为字节流的示例代码：

from cryptography.hazmat.primitives import serialization

# 假设私钥对象为 private_key

# 将私钥使用 PEM 格式序列化为文本格式
private_key_bytes = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.NoEncryption()
)

print(private_key_bytes)

在上述示例中，我们使用 `private_bytes()` 方法将私钥序列化为字节流表示。我们指定了参数 `encoding` 为 `PEM`，`format` 为 `PKCS8`，`encryption_algorithm` 为 `NoEncryption`，表示不对私钥进行加密。通过打印 `private_key_bytes` 可以查看私钥的字节流表示。

3.2 序列化公钥

在`cryptography`库中，可以使用serialization模块中的`public_bytes()`函数将公钥序列化为字节流表示。

语法格式：

    def public_bytes(
        self,
        encoding: _serialization.Encoding,
        format: _serialization.PublicFormat,
    ) -> bytes:
        """
        Returns the key serialized as bytes.
        """

参数说明：

`encoding`：编码，这个参数用于指定序列化公钥时使用的编码方式。`_serialization.Encoding` 是一个枚举类，常用的取值包括：
- `PEM`：使用 Base64 编码将公钥序列化为文本格式。
- `DER`：将公钥序列化为二进制格式。

`format`：公钥格式，这个参数用于指定公钥序列化时的格式。`_serialization.PublicFormat` 是一个枚举类，常用的取值包括：
- `SubjectPublicKeyInfo`：SubjectPublicKeyInfo是PKCS#8格式中用于表示公钥的一种结构。

返回值：`bytes`：公钥序列化后的字节流表示。

以下是将公钥序列化为字节流的示例代码：

from cryptography.hazmat.primitives import serialization

# 假设公钥对象为 public_key

# 使用 PEM 格式将公钥序列化为字节流
public_key_bytes = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)

print(public_key_bytes)

在上面的示例中，我们使用公钥对象的`public_bytes()`方法将公钥序列化为字节流。其中，我们指定了序列化的格式为PEM，并且使用`SubjectPublicKeyInfo`格式表示公钥。

通过选择适当的编码方式（如PEM或DER）以及公钥的格式（如SubjectPublicKeyInfo），可以将公钥序列化为字节流。这样，您可以将公钥保存到文件或通过网络传输，以便其他人使用。

3.3 保存公私钥

以下是一个将公私钥保存为pem格式的示例代码：

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

# 生成RSA私钥
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)

# 获取公钥
public_key = private_key.public_key()

# 将私钥保存为pem格式
with open('private_key.pem', 'wb') as file:
    # 将私钥序列化为字节流
    private_key_bytes = private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    )
    file.write(private_key_bytes)

# 将公钥保存为pem格式
with open('public_key.pem', 'wb') as file:
    # 将公钥序列化为字节流
    public_key_bytes = public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    file.write(public_key_bytes)

4、加载秘钥

4.1 加载pem格式的公钥

在cryptography库中，使用serialization模块的`load_pem_public_key()`方法加载pem格式的公钥。

语法格式：

def load_pem_public_key(data: bytes, backend=None) -> _PUBLIC_KEY_TYPES:

参数说明：

data：要加载的PEM格式的公钥数据，是一个`bytes`类型的对象。该参数可以是一个公钥文件的内容，也可以是PEM格式的公钥字符串。
backend：（可选）要使用的加密后端实现的实例。
返回值：`_PUBLIC_KEY_TYPES`：根据加载的公钥类型不同，返回的对象会有所不同。例如，如果加载的是RSA公钥，则返回`cryptography.hazmat.primitives.asymmetric.rsa.RSAPublicKey`对象。

以下是一个示例代码，演示了如何加载PEM格式的公钥：

from cryptography.hazmat.primitives import serialization


# 读取PEM格式的公钥
def loader_public_key():
    with open('public_key.pem', 'rb') as file:
        public_key = serialization.load_pem_public_key(
            file.read()
        )
    return public_key

4.2 加载pem格式的私钥

在cryptography库中，使用serialization模块的'load_pem_private_key()'方法加载pem格式的私钥。

语法格式：

def load_pem_private_key(
    data: bytes, password: typing.Optional[bytes], backend=None
) -> _PRIVATE_KEY_TYPES:

参数说明：

data：要加载的PEM格式的私钥数据，是一个`bytes`类型的对象。可以是一个私钥文件的内容，也可以是PEM格式的私钥字符串。
password：（可选）私钥的密码，是一个`bytes`类型的对象。如果私钥受密码保护，则需要提供密码以解密私钥。如果私钥没有密码，则可以将该参数设置为`None`。
backend：（可选）要使用的加密后端实现的实例。
返回值：_PRIVATE_KEY_TYPES：根据加载的私钥类型不同，返回的对象会有所不同。例如，如果加载的是RSA私钥，则返回`cryptography.hazmat.primitives.asymmetric.rsa.RSAPrivateKey`对象。

以下是一个示例代码，演示了如何使用`load_pem_private_key`方法加载PEM格式的私钥：

from cryptography.hazmat.primitives import serialization


# 读取PEM格式的私钥
def loader_private_key():
    with open('private_key.pem', 'rb') as file:
        private_key = serialization.load_pem_private_key(
            file.read(),
            password=None
        )
    return private_key

5、加解和解密

5.1 加密

在cryptography模块中，使用cryptography.hazmat.primitives.asymmetric.rsa模块的RSAPublicKey.encrypt()方法对明文数据进行加密。

语法格式：

def encrypt(self, plaintext: bytes, padding: AsymmetricPadding) -> bytes:

参数说明：

plaintext：要加密的原始数据，是一个`bytes`类型的对象。
padding：使用的填充方案，是一个`AsymmetricPadding`类型的对象。可以使用`padding.PKCS1v15`、`padding.OAEP`等填充方案。
返回值：加密后的数据，是一个`bytes`类型的对象。

以下是一个示例代码，演示了如何使用cryptography模块对数据进行公钥加密：

from cryptography.hazmat.primitives.asymmetric import rsa, padding

# 假设您已有一个RSA公钥用于加密
public_key = ...

# 要加密的数据
data = b"Hello, world!"

# 使用公钥对数据进行加密
ciphertext = public_key.encrypt(
    data,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# 将加密后的数据存储或传递给需要解密的地方

5.2 解密

在cryptography模块中，使用cryptography.hazmat.primitives.asymmetric.rsa模块RSAPrivateKey.decrypt()方法对加密后的密文进行解密。

语法格式：

def decrypt(self, ciphertext: bytes, padding: AsymmetricPadding) -> bytes:

参数说明：

ciphertext：要解密的密文数据，是一个bytes类型的对象。
padding：使用的填充方案，是一个AsymmetricPadding类型的对象。可以使用padding.PKCS1v15、padding.OAEP等填充方案。
返回值：解密后的原始数据，是一个bytes类型的对象。

以下是一个示例代码，演示了如何使用cryptography模块对数据进行私钥解密：

from cryptography.hazmat.primitives.asymmetric import rsa, padding

# 假设您已有一个RSA私钥用于解密
private_key = ...

# 要解密的数据
ciphertext = ...

# 使用私钥对数据进行解密
plaintext = private_key.decrypt(
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

6、签名和验签

6.1 签名（sign）

在cryptography模块中，使用cryptography.hazmat.primitives.asymmetric.rsa模块的RSAPrivateKey.sign()方法进行签名。

语法格式：

    def sign(
        self,
        data: bytes,
        padding: AsymmetricPadding,
        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
    ) -> bytes:

参数说明：

data：要签名的数据，是一个bytes类型的对象。
padding：使用的填充方案，是一个AsymmetricPadding类型的对象。可以使用padding.PKCS1v15、padding.PSS等填充方案。
algorithm：使用的哈希算法，可以是asym_utils.Prehashed类型的对象或hashes.HashAlgorithm类型的对象。
返回值：签名结果，是一个bytes类型的对象。

以下是一个示例代码，展示了如何使用cryptography模块对数据进行签名：

from cryptography.hazmat.primitives import hashing, serialization
from cryptography.hazmat.primitives.asymmetric import rsa, padding

# 假设您已有一个RSA私钥供签名使用
private_key = ...

# 要签名的数据
data = b"Hello, world!"

# 使用私钥对数据进行签名
signature = private_key.sign(
    data,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashing.SHA256()
)

# 将签名存储或传递给需要验证签名的地方

6.2 验签(verify)

在cryptography模块中，使用cryptography.hazmat.primitives.asymmetric.rsa模块的RSAPublicKey.verify()方法进行验签。

语法格式：

    def verify(
        self,
        signature: bytes,
        data: bytes,
        padding: AsymmetricPadding,
        algorithm: typing.Union[asym_utils.Prehashed, hashes.HashAlgorithm],
    ) -> None:

参数说明：

signature：要验证的签名，是一个`bytes`类型的对象。
data：要验证的原始数据，是一个`bytes`类型的对象。
padding：使用的填充方案，是一个`AsymmetricPadding`类型的对象。可以使用`padding.PKCS1v15`、`padding.PSS`等填充方案。
algorithm：使用的哈希算法，可以是`asym_utils.Prehashed`类型的对象或`hashes.HashAlgorithm`类型的对象。
返回值：无，如果验证通过，不会返回任何内容。如果验证失败，会触发`InvalidSignature`异常。

以下是一个示例代码，演示了如何使用cryptography模块对签名进行验证：

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

# 假设您已有一个RSA公钥供验签使用
public_key = ...

# 要验证的数据和签名
data = b"Hello, world!"
signature = ...

# 使用公钥进行签名验证
try:
    public_key.verify(
        signature,
        data,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("Signature is valid.")
except InvalidSignature:
    print("Signature is invalid.")

注意：在进行验签时，您需要使用相同的填充方案来对接收到的签名进行验证。如果填充方案不匹配，验证过程将会失败。

reference：

cryptography · PyPI

Welcome to pyca/cryptography — Cryptography 42.0.0.dev1 documentation

笃行之.kiss

关注

6
点赞
踩
36

收藏

觉得还不错? 一键收藏
1
评论
python模块 — cryptography

Cryptography模块是一个包含各种加密算法和协议的Python库，它提供了对数据进行加密、解密和签名的功能。使用cryptography模块，你可以实现对称加密、非对称加密、哈希算法等操作，帮助保护数据的安全性和隐私。版本要求：Python 3.7+安装：pip install cryptography。
复制链接

扫一扫

专栏目录