【txt文本加密】使用 cryptography 库实现加密和解密

一、cryptography 库

cryptography 库是一个强大的 Python 库，用于实现加密和解密功能。它提供了各种加密算法，包括对称加密、非对称加密、哈希函数等。

• 对称加密（Symmetric Encryption）：使用 cryptography 库中的 Fernet 算法，通过相同的密钥进行加密和解密。
• 非对称加密（Symmetric Encryption）：使用 cryptography 库的 RSA 和 ECC 等算法，通过一对密钥（公钥和私钥）进行加密和解密。
• 哈希（Hashing）：cryptography 库提供了多种哈希函数，如 SHA-256、SHA-1、SHA-512 等。用于将任意长度的输入数据转换为固定长度的输出，通常用于安全存储密码、数据完整性验证等场景。

• 密码学（python加密库）：cryptography、GPGME bindings、PyCrypto
• 安装 cryptography 库：pip install cryptography

二、项目实战

2.1、对称加密和解密（生成加密文件）

2.1.1、输入文本语句（简版）

from cryptography.fernet import Fernet

key = Fernet.generate_key()
cipher_suite = Fernet(key)
cipher_text = cipher_suite.encrypt(b"A really secret message. Not for prying eyes.")
plain_text = cipher_suite.decrypt(cipher_text)
print(f"cipher_text = {cipher_text}")
print(f"plain_text = {plain_text}")

2.1.2、导入文本文件

from cryptography.fernet import Fernet  # pip install cryptography


"""
备注：使用Python的cryptography库中的Fernet类来对文本文件进行加密。
备注：在加密和解密过程中，密钥是至关重要的。如果密钥丢失，就无法解密文件。
"""
def generate_key():
    """生成一个新的密钥并将其保存到 secret.key 文件中。只需执行一次。"""
    key = Fernet.generate_key()  # 生成一个Fernet加密用的密钥
    print(f"密钥（secret.key） = {key}")  # 输出生成的密钥，方便查看（实际使用中应避免输出密钥）
    with open('secret.key', 'wb') as key_file:  # 以二进制写入模式打开一个名为'secret.key'的文件
        key_file.write(key)  # 将生成的密钥写入文件

def load_key():
    """从 secret.key 文件中读取密钥。"""
    return open('secret.key', 'rb').read()  # 以二进制读取模式打开'secret.key'文件，并读取其内容（密钥）

def encrypt_file(file_name):
    """读取原始文件内容，使用密钥进行加密，然后将加密后的内容写回文件。"""
    key = load_key()  # 调用load_key函数，加载密钥
    fernet = Fernet(key)  # 创建一个Fernet对象，用于加密操作

    with open(file_name, 'rb') as file:  # 以二进制读取模式打开指定的文件
        original = file.read()  # 读取文件的原始内容

    encrypted = fernet.encrypt(original)  # 使用Fernet对象对原始内容进行加密
    print(f"加密后的内容（encrypted） = {encrypted}")  # 输出加密后的内容（实际使用中应避免输出敏感数据）

    with open(file_name, 'wb') as encrypted_file:  # 以二进制写入模式打开指定的文件（覆盖原文件）
        encrypted_file.write(encrypted)  # 将加密后的内容写入文件

def decrypt_file(file_name):
    """读取加密后的文件内容，使用密钥进行解密，然后将解密后的内容写回文件。"""
    key = load_key()  # 调用load_key函数，加载密钥
    fernet = Fernet(key)  # 创建一个Fernet对象，用于解密操作

    with open(file_name, 'rb') as enc_file:  # 以二进制读取模式打开指定的文件（加密文件）
        encrypted = enc_file.read()  # 读取加密文件的内容

    decrypted = fernet.decrypt(encrypted)  # 使用Fernet对象对加密内容进行解密
    print(f"解密后的内容（decrypted） = {decrypted}")  # 输出解密后的内容（实际使用中应避免输出敏感数据）

    with open(file_name, 'wb') as dec_file:  # 以二进制写入模式打开指定的文件（覆盖加密文件）
        dec_file.write(decrypted)  # 将解密后的内容写入文件


if __name__ == '__main__':
    generate_key()              # 调用generate_key函数，生成并保存密钥（只需执行一次）
    encrypt_file('sample.txt')  # 调用encrypt_file函数，使用密钥对'sample.txt'文件进行加密
    decrypt_file('sample.txt')  # 调用decrypt_file函数，使用密钥对'sample.txt'文件进行解密

2.2、非对称加密和解密（生成加密文件）

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


def generate_keys():
    """生成RSA密钥对（私钥和公钥），并将它们保存到文件中。"""
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048,
    )
    public_key = private_key.public_key()

    # 保存私钥
    with open("private_key.pem", "wb") as private_file:
        private_file.write(
            private_key.private_bytes(
                encoding=serialization.Encoding.PEM,
                format=serialization.PrivateFormat.PKCS8,
                encryption_algorithm=serialization.NoEncryption()
            )
        )

    # 保存公钥
    with open("public_key.pem", "wb") as public_file:
        public_file.write(
            public_key.public_bytes(
                encoding=serialization.Encoding.PEM,
                format=serialization.PublicFormat.SubjectPublicKeyInfo
            )
        )


def load_private_key():
    """从文件加载私钥。"""
    with open("private_key.pem", "rb") as private_file:
        private_key = serialization.load_pem_private_key(
            private_file.read(),
            password=None,
        )
    return private_key


def load_public_key():
    """从文件加载公钥。"""
    with open("public_key.pem", "rb") as public_file:
        public_key = serialization.load_pem_public_key(
            public_file.read()
        )
    return public_key


def encrypt_message(message, public_key):
    """使用公钥加密消息。"""
    encrypted_message = public_key.encrypt(
        message,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return encrypted_message


def decrypt_message(encrypted_message, private_key):
    """使用私钥解密消息。"""
    decrypted_message = private_key.decrypt(
        encrypted_message,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return decrypted_message


if __name__ == "__main__":
    # （1）生成密钥对
    generate_keys()
    # （2）加载密钥（公钥和私钥）
    public_key = load_public_key()
    private_key = load_private_key()
    # （3）要加密的消息
    message = b"This is a secret message"

    # （4）使用公钥加密消息
    encrypted_message = encrypt_message(message, public_key)
    print(f"Encrypted message: {encrypted_message}")
    # （5）使用私钥解密消息
    decrypted_message = decrypt_message(encrypted_message, private_key)
    print(f"Decrypted message: {decrypted_message}")

2.3、哈希函数（生成哈希对象）

from cryptography.hazmat.backends import default_backend  # 导入默认的加密后端模块
from cryptography.hazmat.primitives import hashes  # 导入哈希函数模块


def hash_data(data):
    """对输入的数据进行哈希处理并返回哈希值。"""
    digest = hashes.Hash(hashes.SHA256(), backend=default_backend())  # 创建 SHA-256 哈希对象
    digest.update(data)  # 更新哈希对象，处理输入数据
    hashed_data = digest.finalize()  # 完成哈希计算并获取最终哈希值
    return hashed_data


if __name__ == "__main__":
    # 要哈希的数据
    data = b"Hello, World!"  # 将字符串转换为字节字符串，作为示例数据

    # 计算哈希值
    hashed_data = hash_data(data)  # 调用 hash_data 函数进行哈希计算
    print(f"Hashed data (SHA-256): {hashed_data.hex()}")  # 打印计算得到的哈希值，转换为十六进制表示