md5，aes，des,rsa

md5加密

import hashlib

# md5加密
def md5_encrypt(data):
    # 创建一个md5加密器
    md5 = hashlib.md5()
    # 更新加密器的状态，这需要输入的字符串转为为字节串
    md5.update(data.encode('utf-8'))
    # 获取加密后的16进制字符串
    return md5.hexdigest()


if __name__ == '__main__':
    """测试md5加密"""
    data = '123456'
    print(md5_encrypt(data))

aes加密与解密

# pip install  pycryptodome
"""
AES（高级加密标准）是一种广泛使用的对称加密算法，
适用于需要高度安全性的场景。在Python中，
可以使用pycryptodome库来实现AES加密。这个库是pycrypto的一个分支，
提供了更加安全和易用的API。
"""
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad


def aes_encrypt(key, data):
    # 创建AES加密器，使用CBC模式
    cipher = AES.new(key, AES.MODE_CBC)

    # 加密数据，数据需要先被填充到合适的长度
    ct_bytes = cipher.encrypt(pad(data, AES.block_size))

    # 返回初始化向量和加密后的数据
    # 注意：在实际应用中，你需要将iv（初始化向量）与加密后的数据一起保存或传输，以便于解密
    return cipher.iv, ct_bytes


def aes_decrypt(key, iv, ct):
    # 使用相同的密钥和模式创建解密器，同时提供初始化向量
    cipher = AES.new(key, AES.MODE_CBC, iv)

    # 解密数据并去除填充
    pt = unpad(cipher.decrypt(ct), AES.block_size)
    return pt


if __name__ == '__main__':

    # 示例使用
    key = get_random_bytes(16)  # AES密钥，长度可以是16（AES-128），24（AES-192）或32（AES-256）字节
    data = b"123456"  # 待加密的原始数据

    # 加密
    iv, encrypted_data = aes_encrypt(key, data)
    print(f"Encrypted data: {encrypted_data}")

    # 解密
    decrypted_data = aes_decrypt(key, iv, encrypted_data)
    print(f"Decrypted data: {decrypted_data}")

des加密与解密

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

def des_encrypt(key, data):
    """
    使用DES算法加密数据
    :param key: 8字节的DES密钥
    :param data: 要加密的数据
    :return: iv(初始化向量)和加密后的数据
    """
    cipher = DES.new(key, DES.MODE_CBC)
    iv = cipher.iv
    ct_bytes = cipher.encrypt(pad(data, DES.block_size))
    return iv, ct_bytes

def des_decrypt(key, iv, encrypted_data):
    """
    使用DES算法解密数据
    :param key: 8字节的DES密钥
    :param iv: 加密时使用的初始化向量
    :param encrypted_data: 加密后的数据
    :return: 解密后的数据
    """
    cipher = DES.new(key, DES.MODE_CBC, iv)
    pt = unpad(cipher.decrypt(encrypted_data), DES.block_size)
    return pt

if __name__ == '__main__':

    # 示例使用
    key = get_random_bytes(8)  # DES密钥必须是8字节长
    data = b"Hello, DES!"  # 待加密的数据

    # 加密
    iv, encrypted_data = des_encrypt(key, data)
    print(f"Encrypted data: {encrypted_data.hex()}")

    # 解密
    decrypted_data = des_decrypt(key, iv, encrypted_data)
    print(f"Decrypted data: {decrypted_data}")

rsa加密与解密

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

def generate_rsa_keypair(key_size=2048):
    """
    生成RSA密钥对
    :param key_size: 密钥长度
    :return: (公钥, 私钥)
    """
    key = RSA.generate(key_size)
    private_key = key.export_key()
    public_key = key.publickey().export_key()
    return public_key, private_key

def rsa_encrypt(public_key, data):
    """
    使用RSA公钥加密数据
    :param public_key: RSA公钥
    :param data: 要加密的数据
    :return: 加密后的数据
    """
    public_key = RSA.import_key(public_key)
    cipher = PKCS1_OAEP.new(public_key)
    encrypted_data = cipher.encrypt(data)
    return binascii.hexlify(encrypted_data)

def rsa_decrypt(private_key, encrypted_data):
    """
    使用RSA私钥解密数据
    :param private_key: RSA私钥
    :param encrypted_data: 加密后的数据
    :return: 原始数据
    """
    private_key = RSA.import_key(private_key)
    cipher = PKCS1_OAEP.new(private_key)
    decrypted_data = cipher.decrypt(binascii.unhexlify(encrypted_data))
    return decrypted_data


if __name__ == '__main__':

    # 示例
    public_key, private_key = generate_rsa_keypair()
    data = b'Hello, RSA!'

    # 加密
    encrypted_data = rsa_encrypt(public_key, data)
    print(f"Encrypted data: {encrypted_data}")

    # 解密
    decrypted_data = rsa_decrypt(private_key, encrypted_data)
    print(f"Decrypted data: {decrypted_data.decode('utf-8')}")