Python 实现文本加密和解密工具的方法大全

在Python中，实现文本加密和解密的方法有很多种，常见的有对称加密、非对称加密、哈希算法等。下面是一些常见的加密和解密方法及其实现。

1. 使用对称加密算法（AES）

对称加密算法使用相同的密钥进行加密和解密。AES（Advanced Encryption Standard）是一种常见的对称加密算法。

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes

# 加密函数
def encrypt_aes(plaintext, key):
    cipher = AES.new(key, AES.MODE_CBC)
    ct_bytes = cipher.encrypt(pad(plaintext.encode(), AES.block_size))
    iv = cipher.iv
    return iv + ct_bytes

# 解密函数
def decrypt_aes(ciphertext, key):
    iv = ciphertext[:AES.block_size]
    ct = ciphertext[AES.block_size:]
    cipher = AES.new(key, AES.MODE_CBC, iv)
    pt = unpad(cipher.decrypt(ct), AES.block_size)
    return pt.decode()

# 示例
key = get_random_bytes(16)  # 16字节的密钥
plaintext = "Hello, World!"
ciphertext = encrypt_aes(plaintext, key)
print("加密后的文本:", ciphertext)

decrypted_text = decrypt_aes(ciphertext, key)
print("解密后的文本:", decrypted_text)

2. 使用非对称加密算法（RSA）

非对称加密算法使用一对密钥：公钥和私钥。公钥用于加密，私钥用于解密。

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP

# 生成RSA密钥对
key = RSA.generate(2048)
private_key = key.export_key()
public_key = key.publickey().export_key()

# 加密函数
def encrypt_rsa(plaintext, public_key):
    rsa_key = RSA.import_key(public_key)
    cipher = PKCS1_OAEP.new(rsa_key)
    ciphertext = cipher.encrypt(plaintext.encode())
    return ciphertext

# 解密函数
def decrypt_rsa(ciphertext, private_key):
    rsa_key = RSA.import_key(private_key)
    cipher = PKCS1_OAEP.new(rsa_key)
    plaintext = cipher.decrypt(ciphertext)
    return plaintext.decode()

# 示例
plaintext = "Hello, World!"
ciphertext = encrypt_rsa(plaintext, public_key)
print("加密后的文本:", ciphertext)

decrypted_text = decrypt_rsa(ciphertext, private_key)
print("解密后的文本:", decrypted_text)

3. 使用哈希算法（SHA-256）

哈希算法是一种单向加密算法，通常用于生成数据的唯一指纹。哈希值不可逆，无法解密。

import hashlib

# 生成哈希值
def hash_text(text):
    sha256 = hashlib.sha256()
    sha256.update(text.encode())
    return sha256.hexdigest()

# 示例
text = "Hello, World!"
hashed_text = hash_text(text)
print("哈希值:", hashed_text)

4. 使用简单的替换密码（Caesar Cipher）

凯撒密码是一种简单的替换密码，通过将字母表中的每个字母移动固定的位置来加密。

# 加密函数
def caesar_encrypt(plaintext, shift):
    result = ""
    for char in plaintext:
        if char.isalpha():
            shift_amount = shift % 26
            if char.islower():
                result += chr((ord(char) - ord('a') + shift_amount) % 26 + ord('a'))
            else:
                result += chr((ord(char) - ord('A') + shift_amount) % 26 + ord('A'))
        else:
            result += char
    return result

# 解密函数
def caesar_decrypt(ciphertext, shift):
    return caesar_encrypt(ciphertext, -shift)

# 示例
plaintext = "Hello, World!"
shift = 3
ciphertext = caesar_encrypt(plaintext, shift)
print("加密后的文本:", ciphertext)

decrypted_text = caesar_decrypt(ciphertext, shift)
print("解密后的文本:", decrypted_text)

5. 使用Base64编码

Base64是一种常见的编码方式，虽然不是加密算法，但可以用于简单的文本混淆。

import base64

# 编码函数
def base64_encode(text):
    return base64.b64encode(text.encode()).decode()

# 解码函数
def base64_decode(encoded_text):
    return base64.b64decode(encoded_text.encode()).decode()

# 示例
text = "Hello, World!"
encoded_text = base64_encode(text)
print("Base64编码后的文本:", encoded_text)

decoded_text = base64_decode(encoded_text)
print("Base64解码后的文本:", decoded_text)

6. 使用Fernet对称加密

Fernet是Python中cryptography库提供的一种对称加密算法，使用简单且安全。

from cryptography.fernet import Fernet

# 生成密钥
key = Fernet.generate_key()
cipher_suite = Fernet(key)

# 加密函数
def encrypt_fernet(plaintext):
    return cipher_suite.encrypt(plaintext.encode())

# 解密函数
def decrypt_fernet(ciphertext):
    return cipher_suite.decrypt(ciphertext).decode()

# 示例
plaintext = "Hello, World!"
ciphertext = encrypt_fernet(plaintext)
print("加密后的文本:", ciphertext)

decrypted_text = decrypt_fernet(ciphertext)
print("解密后的文本:", decrypted_text)

总结

以上是几种常见的Python实现文本加密和解密的方法。根据不同的需求，可以选择合适的加密算法。对称加密算法（如AES）适合需要高效加密的场景，非对称加密算法（如RSA）适合需要安全传输密钥的场景，而哈希算法（如SHA-256）则适合生成数据的唯一指纹。