【python】一文带你领略，Python中非常强大的加密库--pycryptodome

景天科技苑

于 2024-08-17 08:30:00 发布

阅读量1.3k

点赞数 43

分类专栏： python轻松入门，基础语法到高阶实战教学文章标签： python PyCryptodome python加解密 RSA AES SHA HMC

本文链接：https://blog.csdn.net/littlefun591/article/details/141258101

版权

python轻松入门，基础语法到高阶实战教学专栏收录该内容

77 篇文章 30 订阅

订阅专栏

在这里插入图片描述

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

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

🏆 作者简介：景天科技苑
🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。
🏆《博客》：Python全栈，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏：python综合应用，基础语法到高阶实战教学
景天的主页：景天科技苑

在这里插入图片描述

PyCryptodome

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

官网

https://pypi.org/project/pycryptodome/
在这里插入图片描述

安装PyCryptodome

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

pip install pycryptodome

在这里插入图片描述

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

基本概念

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

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

使用场景和示例代码

对称加密 - AES

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

示例代码

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模式示例

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是一种常用的非对称加密算法，适用于数据加密和数字签名。

示例代码

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}")

在这里插入图片描述

注意：在这个示例中，我们使用了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）是一种基于哈希函数的消息认证码算法，它结合了密钥和哈希函数来确保消息的完整性和真实性。

示例代码

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提供了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)
    print("签名：\n", sign_data)
    print("验签：\n", is_verify)
    """
    总结
    Pycrypto提供了比较完善的加密算法。RSA广泛用于加密与解密，还有数字签名通信领域。使用Publick/Private秘钥算法中，
    加密主要用对方的公钥，解密用自己的私钥。签名用自己的私钥，验签用对方的公钥。

    - 加密解密：公钥加密，私钥解密
    - 签名验签：私钥签名，公钥验签

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

在这里插入图片描述

这个示例展示了如何使用RSA私钥对消息进行签名，并使用公钥验证签名的有效性。注意，这里使用了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进行数据加密和安全开发。