文章目录
一、cryptography 库二、项目实战2.1、对称加密和解密（生成加密文件）2.1.1、输入文本语句（简版）2.1.2、导入文本文件
2.2、非对称加密和解密（生成加密文件）2.3、哈希函数（生成哈希对象）
一、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()}") # 打印计算得到的哈希值，转换为十六进制表示