python11种方式实现文本加密解密算法

作者：YXN-python 阅读量：2 发布日期：2024-11-21

1. Caesar Cipher（凯撒密码）

凯撒密码是一种古老的替换加密方法，通过将字母表中的每个字母向前或向后移动固定数量的位置来进行加密。

def caesar_encrypt(text, shift):
    result = ""
    for char in text:
        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(encrypted_text, shift):
    return caesar_encrypt(encrypted_text, -shift)

# 示例
text = "Hello, World!"
shift = 3
encrypted_text = caesar_encrypt(text, shift)
print(f"原始字符串: {text}")
print(f"加密: {encrypted_text}")
print(f"解密: {caesar_decrypt(encrypted_text, shift)}")

"""
输出：
原始: Hello, World!
加密: Khoor, Zruog!
解密: Hello, World!
"""

2. Vigenere Cipher（维吉尼亚密码）

维吉尼亚密码是一种多表替换加密方法，使用一个密钥来决定每个字符的偏移量。

def vigenere_encrypt(text, key):
    result = ""
    key_index = 0
    for char in text:
        if char.isalpha():
            shift = ord(key[key_index % len(key)].upper()) - ord('A')
            if char.islower():
                result += chr((ord(char) - ord('a') + shift) % 26 + ord('a'))
            else:
                result += chr((ord(char) - ord('A') + shift) % 26 + ord('A'))
            key_index += 1
        else:
            result += char
    return result

def vigenere_decrypt(encrypted_text, key):
    result = ""
    key_index = 0
    for char in encrypted_text:
        if char.isalpha():
            shift = ord(key[key_index % len(key)].upper()) - ord('A')
            if char.islower():
                result += chr((ord(char) - ord('a') - shift) % 26 + ord('a'))
            else:
                result += chr((ord(char) - ord('A') - shift) % 26 + ord('A'))
            key_index += 1
        else:
            result += char
    return result

# 示例
text = "Hello, World!"
key = "KEY"
encrypted_text = vigenere_encrypt(text, key)
print(f"原始: {text}")
print(f"加密: {encrypted_text}")
print(f"解密: {vigenere_decrypt(encrypted_text, key)}")

"""
输出：
原始: Hello, World!
加密: Rijvs, Uyvjn!
解密: Hello, World!
"""

 

3. XOR Cipher（异或加密）

XOR 加密是一种简单的对称加密方法，通过将每个字符与一个密钥进行异或操作来实现加密和解密。

def xor_cipher(text, key):
    result = ""
    key_index = 0
    for char in text:
        result += chr(ord(char) ^ ord(key[key_index % len(key)]))
        key_index += 1
    return result

# 示例
text = "Hello, World!"
key = "KEY"
encrypted_text = xor_cipher(text, key)
print(f"原始: {text}")
print(f"加密: {encrypted_text}")
print(f"解密: {xor_cipher(encrypted_text, key)}")

"""
输出：
原始: Hello, World!
加密:  5'*uk69)=j
解密: Hello, World!
"""

 

4. AES（高级加密标准）

AES 是一种广泛使用的对称加密算法，适用于各种安全需求。

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

def aes_encrypt(text, key):
    cipher = AES.new(key, AES.MODE_CBC)
    ct_bytes = cipher.encrypt(pad(text.encode(), AES.block_size))
    iv = cipher.iv
    return (iv + ct_bytes).hex()

def aes_decrypt(encrypted_text, key):
    encrypted_text = bytes.fromhex(encrypted_text)
    iv = encrypted_text[:16]
    ct = encrypted_text[16:]
    cipher = AES.new(key, AES.MODE_CBC, iv)
    pt = unpad(cipher.decrypt(ct), AES.block_size)
    return pt.decode()

# 示例
text = "Hello, World!"
key = get_random_bytes(32)  # 256-bit key
encrypted_text = aes_encrypt(text, key)
print(f"原始: {text}")
print(f"加密: {encrypted_text}")
print(f"解密: {aes_decrypt(encrypted_text, key)}")

"""
输出：
原始: Hello, World!
加密: 9f28ff34c9807630b39766767caa0bbbaa83d09d468e5245891aeedffda40e70
解密: Hello, World!
"""

5. RSA（非对称加密）

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

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

def rsa_encrypt(text, public_key):
    cipher = PKCS1_OAEP.new(public_key)
    encrypted_text = cipher.encrypt(text.encode())
    return encrypted_text.hex()

def rsa_decrypt(encrypted_text, private_key):
    encrypted_text = bytes.fromhex(encrypted_text)
    cipher = PKCS1_OAEP.new(private_key)
    decrypted_text = cipher.decrypt(encrypted_text)
    return decrypted_text.decode()

# 示例
key = RSA.generate(2048)
public_key = key.publickey()
text = "Hello, World!"
encrypted_text = rsa_encrypt(text, public_key)
print(f"原始: {text}")
print(f"加密: {encrypted_text}")
print(f"解密: {rsa_decrypt(encrypted_text, key)}")

"""
输出：
原始: Hello, World!
加密: 6762d2156cb684e897c22bb2a0b72da7d69b4ff39d1117ab8ccafb4afd770c22df1be42ad3a6d13929464243d7e21d9cd050e2cce78c5df94b80c33c99af73b7756fa47c2009f46beb1b26db1e926d3178afd39ba931bdb8ae957a8ed4ee35af50fd4143afbdd5dd0a523ba147bd2d4b1da0eeaeb9ee5ed775e5e9650fad45415cf250119b620895be5ee1ca0a577e1419689c88ff9ce0c05a035ad7f77d6abe20b38a08a96b04265ac0a241d5174ab07eac0f3c07caaa1e667f6aab73bde6d9aa28af6b013f1c43e3826a6f0523482e995bed85d1f841b1629dd4d53e28f600dbee019cf2611e3a1582e12137cc76dac9d00ce2a63ee04565641825b1814b97
解密: Hello, World!
"""

6. Blowfish

Blowfish 是一种对称加密算法，适用于需要高速加密的应用。

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

def blowfish_encrypt(text, key):
    cipher = Blowfish.new(key, Blowfish.MODE_CBC)
    ct_bytes = cipher.encrypt(pad(text.encode(), Blowfish.block_size))
    iv = cipher.iv
    return (iv + ct_bytes).hex()

def blowfish_decrypt(encrypted_text, key):
    encrypted_text = bytes.fromhex(encrypted_text)
    iv = encrypted_text[:8]
    ct = encrypted_text[8:]
    cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv)
    pt = unpad(cipher.decrypt(ct), Blowfish.block_size)
    return pt.decode()

# 示例
text = "Hello, World!"
key = get_random_bytes(16)  # 128-bit key
encrypted_text = blowfish_encrypt(text, key)
print(f"原始: {text}")
print(f"加密: {encrypted_text}")
print(f"解密: {blowfish_decrypt(encrypted_text, key)}")

"""
输出：
原始: Hello, World!
加密: 3ee82cf751301fbaf611ed9e8a880dc22311e4068f473b12
解密: Hello, World!
"""

 

7. DES（数据加密标准）

DES 是一种早期的对称加密算法，虽然现在不常用，但仍然具有教育意义。

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

def des_encrypt(text, key):
    cipher = DES.new(key, DES.MODE_CBC)
    ct_bytes = cipher.encrypt(pad(text.encode(), DES.block_size))
    iv = cipher.iv
    return (iv + ct_bytes).hex()

def des_decrypt(encrypted_text, key):
    encrypted_text = bytes.fromhex(encrypted_text)
    iv = encrypted_text[:8]
    ct = encrypted_text[8:]
    cipher = DES.new(key, DES.MODE_CBC, iv)
    pt = unpad(cipher.decrypt(ct), DES.block_size)
    return pt.decode()

# 示例
text = "Hello, World!"
key = get_random_bytes(8)  # 64-bit key
encrypted_text = des_encrypt(text, key)
print(f"原始: {text}")
print(f"加密: {encrypted_text}")
print(f"解密: {des_decrypt(encrypted_text, key)}")

"""
输出：
原始: Hello, World!
加密: 2b1b91abaf17af3343cf3407dcc4fcda5d90fbda5eb88370
解密: Hello, World!
"""

8. 3DES（三重数据加密标准）

3DES 是 DES 的改进版本，提高了安全性。

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

def triple_des_encrypt(text, key):
    cipher = DES3.new(key, DES3.MODE_CBC)
    ct_bytes = cipher.encrypt(pad(text.encode(), DES3.block_size))
    iv = cipher.iv
    return (iv + ct_bytes).hex()

def triple_des_decrypt(encrypted_text, key):
    encrypted_text = bytes.fromhex(encrypted_text)
    iv = encrypted_text[:8]
    ct = encrypted_text[8:]
    cipher = DES3.new(key, DES3.MODE_CBC, iv)
    pt = unpad(cipher.decrypt(ct), DES3.block_size)
    return pt.decode()

# 示例
text = "Hello, World!"
key = get_random_bytes(24)  # 192-bit key
encrypted_text = triple_des_encrypt(text, key)
print(f"原始: {text}")
print(f"加密: {encrypted_text}")
print(f"解密: {triple_des_decrypt(encrypted_text, key)}")

"""
输出：
原始: Hello, World!
加密: 82918e3bb402a5944ff69c467670979a2278011e1494e1d2
解密: Hello, World!
"""

9. RC4（Rivest Cipher 4）

RC4 是一种流加密算法，适用于需要高效加密的应用。

from Crypto.Cipher import ARC4

def rc4_encrypt(text, key):
    cipher = ARC4.new(key)
    encrypted_text = cipher.encrypt(text.encode())
    return encrypted_text.hex()

def rc4_decrypt(encrypted_text, key):
    encrypted_text = bytes.fromhex(encrypted_text)
    cipher = ARC4.new(key)
    decrypted_text = cipher.decrypt(encrypted_text)
    return decrypted_text.decode()

# 示例
text = "Hello, World!"
key = b"KEY"
encrypted_text = rc4_encrypt(text, key)
print(f"原始: {text}")
print(f"加密: {encrypted_text}")
print(f"解密: {rc4_decrypt(encrypted_text, key)}")

"""
输出：
原始: Hello, World!
加密: dd059038d9a364af59f697e2d1
解密: Hello, World!
"""

10. SHA-256（哈希函数）

SHA-256 是一种哈希函数，用于生成固定长度的哈希值，常用于数据完整性校验。

import hashlib

def sha256_hash(text):
    hash_object = hashlib.sha256()
    hash_object.update(text.encode())
    return hash_object.hexdigest()

# 示例
text = "Hello, World!"
hashed_text = sha256_hash(text)
print(f"原始: {text}")
print(f"哈希: {hashed_text}")

"""
输出：
原始: Hello, World!
哈希: dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f
"""

11. HMAC（基于哈希的消息认证码）

HMAC 是一种基于哈希函数的消息认证码，用于验证消息的完整性和来源。

import hmac
import hashlib

def hmac_sha256(text, key):
    hmac_object = hmac.new(key, text.encode(), hashlib.sha256)
    return hmac_object.hexdigest()

# 示例
text = "Hello, World!"
key = b"SECRET_KEY"
hmac_value = hmac_sha256(text, key)
print(f"原始: {text}")
print(f"HMAC: {hmac_value}")

"""
输出：
原始: Hello, World!
HMAC: c832486398b1e6ee283cde1aea5b70ce453b3251cf2b45c904557a894d48b7fd
"""

 

YXN-python

2024-11-21