✨✨ 欢迎大家来到景天科技苑✨✨

🎈🎈 养成好习惯，先赞后看哦~🎈🎈

🏆 作者简介：景天科技苑

🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。

🏆《博客》：Python全栈，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏：python综合应用，基础语法到高阶实战教学

景天的主页：景天科技苑

文章目录

PyCryptodome官网安装PyCryptodome基本概念使用场景和示例代码对称加密 - AES示例代码CBC模式示例

非对称加密 - RSA示例代码

哈希函数 - SHA256示例代码

消息认证码 - HMAC示例代码

密钥管理加密模式与填充错误处理与异常性能优化安全性更新与合规性示例：使用RSA进行数字签名注意事项

总结

PyCryptodome

PyCryptodome是一个强大的Python加密库，它提供了广泛的加密算法支持，包括对称加密、非对称加密、哈希函数和消息认证码等。本文将结合实际案例，详细介绍PyCryptodome的安装、基本概念、使用场景及示例代码，帮助读者理解和使用这一强大的加密工具。

官网

https://pypi.org/project/pycryptodome/

安装PyCryptodome

首先，你需要安装PyCryptodome库。可以通过pip命令轻松完成安装：

<code>pip install pycryptodome

安装完成后，你就可以在Python脚本中导入并使用PyCryptodome提供的各种加密功能了。

基本概念

PyCryptodome提供了以下几种主要类型的加密算法：

对称加密：使用相同的密钥进行加密和解密，如AES、DES、3DES等。非对称加密：使用一对密钥（公钥和私钥）进行加密和解密，如RSA、DSA、ECC等。哈希函数：用于生成消息摘要，常用于数据完整性检查和密码存储，如SHA256、MD5等。消息认证码（MAC）：如HMAC，用于验证消息的完整性和真实性。

使用场景和示例代码

对称加密 - AES

AES（Advanced Encryption Standard）是一种广泛使用的对称加密算法。以下是一个使用AES进行加密和解密的示例：

示例代码

<code>from Crypto.Cipher import AES

from Crypto.Random import get_random_bytes

from Crypto.Util.Padding import pad, unpad

def encrypt_aes(plaintext, key):

cipher = AES.new(key, AES.MODE_ECB)

padded_data = pad(plaintext.encode(), AES.block_size)

return cipher.encrypt(padded_data)

def decrypt_aes(ciphertext, key):

cipher = AES.new(key, AES.MODE_ECB)

padded_data = cipher.decrypt(ciphertext)

return unpad(padded_data, AES.block_size).decode()

# 生成一个16字节的随机密钥

key = get_random_bytes(16)

# 加密

message = "Hello, PyCryptodome!"

encrypted = encrypt_aes(message, key)

print(f"加密后: { encrypted.hex()}")

# 解密

decrypted = decrypt_aes(encrypted, key)

print(f"解密后: { decrypted}")

注意：在实际应用中，ECB模式由于不使用初始化向量（IV）且相同的明文块会产生相同的密文块，因此不推荐用于加密长数据或敏感数据。建议使用CBC、CFB、OFB等模式，并随机生成IV。

CBC模式示例

<code>from Crypto.Cipher import AES

from Crypto.Util.Padding import pad, unpad

from Crypto.Random import get_random_bytes

import base64

# 生成随机的密钥和IV

key = get_random_bytes(16)

iv = get_random_bytes(AES.block_size)

# 明文数据

plain_text = "Hello, AES Encryption!".encode('utf-8')

# 使用PKCS#7填充明文数据

padded_data = pad(plain_text, AES.block_size)

# 创建AES加密器，使用CBC模式和之前生成的密钥及IV

cipher = AES.new(key, AES.MODE_CBC, iv)

# 加密填充后的数据

encrypted_data = cipher.encrypt(padded_data)

# 将IV和密文拼接，然后Base64编码以便于存储或传输

cipher_text_str = base64.b64encode(iv + encrypted_data).decode('utf-8')

print("加密后的数据:", cipher_text_str)

# 解密过程

decrypt_cipher = AES.new(key, AES.MODE_CBC, iv)

decrypted_padded_data = decrypt_cipher.decrypt(encrypted_data)

decrypted_text = unpad(decrypted_padded_data, AES.block_size).decode('utf-8')

print("解密后的数据:", decrypted_text)

非对称加密 - RSA

RSA是一种常用的非对称加密算法，适用于数据加密和数字签名。

示例代码

<code>from Crypto.PublicKey import RSA

from Crypto.Cipher import PKCS1_OAEP

import binascii

# 生成RSA密钥对

key = RSA.generate(2048)

private_key = key.export_key()

public_key = key.publickey().export_key()

# 使用RSA公钥进行加密

def encrypt_rsa(message, public_key):

recipient_key = RSA.import_key(public_key)

cipher_rsa = PKCS1_OAEP.new(recipient_key)

encrypted_message = cipher_rsa.encrypt(message.encode())

return binascii.hexlify(encrypted_message).decode('ascii')

# 使用RSA私钥进行解密

def decrypt_rsa(encrypted_message, private_key):

private_key = RSA.import_key(private_key)

cipher_rsa = PKCS1_OAEP.new(private_key)

decrypted_message = cipher_rsa.decrypt(binascii.unhexlify(encrypted_message))

return decrypted_message.decode('utf-8')

# 加密消息

message = "Hello, RSA Encryption!"

encrypted = encrypt_rsa(message, public_key)

print(f"加密后: { encrypted}")

# 解密消息

decrypted = decrypt_rsa(encrypted, private_key)

print(f"解密后: { decrypted}")

注意：在这个示例中，我们使用了<code>PKCS1_OAEP作为RSA加密的填充模式，这是一种推荐的填充模式，因为它提供了比传统的PKCS#1 v1.5更好的安全性。

哈希函数 - SHA256

哈希函数常用于生成数据的摘要，以验证数据的完整性和一致性。

示例代码

from Crypto.Hash import SHA256

def hash_data(data):

hash_obj = SHA256.new()

hash_obj.update(data.encode('utf-8'))

return hash_obj.hexdigest()

data = "Hello, SHA256 Hash!"

hash_result = hash_data(data)

print(f"SHA256哈希值: { hash_result}")

消息认证码 - HMAC

HMAC（Hash-based Message Authentication Code）是一种基于哈希函数的消息认证码算法，它结合了密钥和哈希函数来确保消息的完整性和真实性。

示例代码

<code>from Crypto.Hash import HMAC, SHA256

from Crypto.Random import get_random_bytes

def hmac_sign(data, key):

hmac_obj = HMAC.new(key, digestmod=SHA256)

hmac_obj.update(data.encode('utf-8'))

return hmac_obj.hexdigest()

# 密钥

key = get_random_bytes(16)

# 消息

message = "Hello, HMAC!"

# 生成HMAC签名

signature = hmac_sign(message, key)

print(f"HMAC签名: { signature}")

# 验证HMAC签名（在实际应用中，验证过程会与原始签名进行比较）

# 这里仅展示如何重新生成签名以供比较

verified_signature = hmac_sign(message, key)

print(f"验证HMAC签名（应与上方签名相同）: { verified_signature}")

当然，我们可以继续深入讨论PyCryptodome库的一些高级用法和最佳实践。

密钥管理

在加密应用中，密钥管理是至关重要的。不安全的密钥管理可能会导致整个加密系统的安全性失效。以下是一些密钥管理的最佳实践：

密钥生成：使用强随机数生成器生成密钥。PyCryptodome提供了<code>Crypto.Random.get_random_bytes()函数来生成安全的随机字节序列，这可以用作密钥的基础。

密钥存储：密钥应该存储在安全的位置，例如硬件安全模块（HSM）、密钥管理服务（KMS）或加密的密钥文件中。不要将密钥硬编码在源代码中。

密钥轮换：定期更换密钥以减少密钥泄露的风险。

密钥访问控制：确保只有授权人员能够访问密钥。使用访问控制列表（ACL）或基于角色的访问控制（RBAC）来管理密钥的访问权限。

加密模式与填充

在选择加密模式和填充方式时，需要考虑数据的安全性、完整性和性能。

加密模式：如前所述，CBC、CFB、OFB和CTR等模式各有优缺点，适用于不同的场景。CBC模式因其使用IV而增加了随机性，但需要注意IV的传输和存储安全。

填充：加密数据通常需要填充到块大小的整数倍。PKCS#7（也称为PKCS#5对于64位块大小）是一种常用的填充方式，它提供了数据长度的信息，便于解密时恢复原始数据。

错误处理与异常

在使用PyCryptodome进行加密解密时，可能会遇到各种错误，如密钥长度不正确、IV不匹配、数据损坏等。因此，合理的错误处理和异常捕获是必要的。

try:

# 加密或解密操作

encrypted_data = encrypt_function(data, key)

except ValueError as e:

print(f"加密/解密错误: { e}")

except Exception as e:

print(f"发生未知错误: { e}")

性能优化

加密操作可能会对性能产生一定影响，特别是在处理大量数据时。以下是一些优化加密性能的方法：

使用硬件加速：某些硬件（如GPU或专用加密芯片）可以提供比CPU更快的加密性能。

并行处理：对于大数据集，可以使用多线程或多进程来并行处理加密任务。

选择合适的算法和参数：不同的加密算法和参数组合可能对性能有不同的影响。根据实际需求选择合适的算法和参数。

安全性更新与合规性

随着加密技术的不断发展，新的安全漏洞和攻击手段不断出现。因此，保持PyCryptodome库的更新和关注最新的安全公告是非常重要的。

此外，还需要确保加密应用符合相关的行业标准和法规要求，如PCI DSS、GDPR等。

示例：使用RSA进行数字签名

数字签名是RSA算法的另一个重要应用，它用于验证消息的来源和完整性。

import base64

from Crypto.PublicKey import RSA

from Crypto.Cipher import PKCS1_v1_5 as Cipher_PKC

from Crypto import Random

from Crypto.Hash import SHA256

from Crypto.Signature import PKCS1_v1_5 as Signature_PKC

class HandleRSA(object):

def create_rsa_key(self):

"""

创建RSA密钥

步骤说明：

1、从 Crypto.PublicKey 包中导入 RSA，创建一个密码

2、生成 1024/2048 位的 RSA 密钥

3、调用 RSA 密钥实例的 exportKey 方法，传入密码、使用的 PKCS 标准以及加密方案这三个参数。

4、将私钥写入磁盘的文件。

5、使用方法链调用 publickey 和 exportKey 方法生成公钥，写入磁盘上的文件。

"""

# 伪随机数生成器

random_gen = Random.new().read

# 生成秘钥对实例对象：1024是秘钥的长度

rsa = RSA.generate(1024, random_gen)

# Server的秘钥对的生成

private_pem = rsa.exportKey()

with open("server_private.pem", "wb") as f:

f.write(private_pem)

public_pem = rsa.publickey().exportKey()

with open("server_public.pem", "wb") as f:

f.write(public_pem)

# Client的秘钥对的生成

private_pem = rsa.exportKey()

with open("client_private.pem", "wb") as f:

f.write(private_pem)

public_pem = rsa.publickey().exportKey()

with open("client_public.pem", "wb") as f:

f.write(public_pem)

# Server使用Client的公钥对内容进行rsa 加密

def encrypt(self, plaintext):

"""

client 公钥进行加密

plaintext:需要加密的明文文本，公钥加密，私钥解密

"""

# 加载公钥

rsa_key = RSA.import_key(open("client_public.pem").read())

# 加密

cipher_rsa = Cipher_PKC.new(rsa_key)

en_data = cipher_rsa.encrypt(plaintext.encode("utf-8")) # 加密

# base64 进行编码

base64_text = base64.b64encode(en_data)

return base64_text.decode() # 返回字符串

# Client使用自己的私钥对内容进行rsa 解密

def decrypt(self, en_data):

"""

en_data:加密过后的数据，传进来是一个字符串

"""

# base64 解码

base64_data = base64.b64decode(en_data.encode("utf-8"))

# 读取私钥

private_key = RSA.import_key(open("client_private.pem").read())

# 解密

cipher_rsa = Cipher_PKC.new(private_key)

data = cipher_rsa.decrypt(base64_data, None)

return data.decode()

# Server使用自己的私钥对内容进行签名

def signature(self, data: str):

"""

RSA私钥签名

:param data: 明文数据

:return: 签名后的字符串sign

"""

# 读取私钥

private_key = RSA.import_key(open("server_private.pem").read())

# 根据SHA256算法处理签名内容data

sha_data = SHA256.new(data.encode("utf-8")) # b类型

# 私钥进行签名

signer = Signature_PKC.new(private_key)

sign = signer.sign(sha_data)

# 将签名后的内容，转换为base64编码

sign_base64 = base64.b64encode(sign)

return sign_base64.decode()

# Client使用Server的公钥对内容进行验签

def verify(self, data: str, signature: str) -> bool:

"""

RSA公钥验签

:param data: 明文数据,签名之前的数据

:param signature: 接收到的sign签名

:return: 验签结果,布尔值

"""

# 接收到的sign签名 base64解码

sign_data = base64.b64decode(signature.encode("utf-8"))

# 加载公钥

piblic_key = RSA.importKey(open("server_public.pem").read())

# 根据SHA256算法处理签名之前内容data

sha_data = SHA256.new(data.encode("utf-8")) # b类型

# 验证签名

signer = Signature_PKC.new(piblic_key)

is_verify = signer.verify(sha_data, sign_data)

return is_verify

if __name__ == '__main__':

mrsa = HandleRSA()

mrsa.create_rsa_key()

e = mrsa.encrypt('hello client, this is a message')

d = mrsa.decrypt(e)

print(e)

print(d)

# ---------------------------------

sign_data = mrsa.signature("我叫景天")

is_verify = mrsa.verify(data="我叫景天", signature=sign_data)code>

print("签名：\n", sign_data)

print("验签：\n", is_verify)

"""

总结

Pycrypto提供了比较完善的加密算法。RSA广泛用于加密与解密，还有数字签名通信领域。使用Publick/Private秘钥算法中，

加密主要用对方的公钥，解密用自己的私钥。签名用自己的私钥，验签用对方的公钥。

- 加密解密：公钥加密，私钥解密

- 签名验签：私钥签名，公钥验签

无论是加密解密还是签名验签都使用同一对秘钥对

"""

这个示例展示了如何使用RSA私钥对消息进行签名，并使用公钥验证签名的有效性。注意，这里使用了<code>pkcs1_15签名算法，但PSS（Probabilistic Signature Scheme）是另一种更安全的RSA签名算法，特别是当考虑到针对RSA签名的某些类型攻击时（如存在性伪造攻击）。然而，PyCryptodome库中的pkcs1_15仍然是一个广泛使用且有效的选择，但如果你需要更高的安全性，可以考虑使用PSS。

注意事项

密钥长度：在实际应用中，应该使用至少2048位的RSA密钥长度来提供足够的安全性。随机性：RSA-PSS签名是概率性的，这意味着对于相同的消息和密钥对，每次签名都会生成不同的签名值（由于盐的随机性）。安全性：虽然RSA-PSS提供了比pkcs1_15更高的安全性，但仍然需要遵循良好的密钥管理实践来确保整体系统的安全性。兼容性：确保你的系统和库支持RSA-PSS。虽然PyCryptodome支持RSA-PSS，但其他库或系统可能不支持或实现方式可能有所不同。

通过这些示例和最佳实践，你应该能够更有效地使用PyCryptodome库进行数据加密和数字签名。

总结

PyCryptodome是一个功能强大的Python加密库，它提供了对称加密、非对称加密、哈希函数和消息认证码等多种加密算法的支持。通过本文的介绍，你应该已经了解了PyCryptodome的基本概念和几种主要加密算法的使用方法。在实际应用中，你需要根据具体需求选择合适的加密算法和模式，并注意密钥管理和加密数据的安全存储。

希望这篇教程能帮助你更好地理解和使用PyCryptodome进行数据加密和安全开发。