python3.8实现各种加密

# base64
import base64

data = 'hello, world'
encrypt = base64.b64encode(data.encode("utf8"))
decrypt = base64.b64decode(encrypt)

# MD5
import hashlib


def encrypt_md5(data):
    data = data
    md5 = hashlib.md5()
    md5.update(data.encode())
    encrypt_data = md5.hexdigest()
    return encrypt_data


# sha1
def encrypt_sha1(data):
    sha1 = hashlib.sha1(data)
    encrypt_data = sha1.hexdigest()
    return encrypt_data


# DES
from Crypto.Cipher import DES
import binascii


# pip install pycryptodome
# C:\Users\Administrator\AppData\Local\Programs\Python\Python38\Lib\site-packages
#
# 找到这个路径，下面有一个文件夹叫做crypto,将c改成C


def pad(text):
    """
    # 加密函数，如果text不是8的倍数【加密文本text必须为8的倍数！】，那就补足为8的倍数
    :param text:
    :return:
    """
    while len(text) % 8 != 0:
        text += ' '
    return text


def encrypt_des(key, data):
    key = bytes(key)  # 密钥 8位或16位,必须为bytes
    des = DES.new(key, DES.MODE_ECB)
    padded_text = pad(data)
    encrypted_text = des.encrypt(padded_text.encode('utf-8'))
    encrypt_text = binascii.b2a_hex(encrypted_text)
    return encrypt_text


def decrypt_des(key, data):
    des = DES.new(key, DES.MODE_ECB)
    encrypt_text = encrypt_des(key, data)
    data = des.decrypt(binascii.a2b_hex(encrypt_text))
    return data


# AES

"""
aes加密算法
padding : PKCS7
"""

import base64
from Crypto.Cipher import AES


class EncryptDate:
    def __init__(self, key):
        self.key = key  # 初始化密钥
        self.length = AES.block_size  # 初始化数据块大小
        self.aes = AES.new(self.key.encode("utf8"), AES.MODE_ECB)  # 初始化AES,ECB模式的实例
        # 截断函数，去除填充的字符
        self.unpad = lambda date: date[0:-ord(date[-1])]

    def pad(self, text):
        """
        #填充函数，使被加密数据的字节码长度是block_size的整数倍
        """
        count = len(text.encode('utf-8'))
        add = self.length - (count % self.length)
        entext = text + (chr(add) * add)
        return entext

    def encrypt(self, encrData):  # 加密函数
        res = self.aes.encrypt(self.pad(encrData).encode("utf8"))
        msg = str(base64.b64encode(res), encoding="utf8")
        return msg

    def decrypt(self, decrData):  # 解密函数
        res = base64.decodebytes(decrData.encode("utf8"))
        msg = self.aes.decrypt(res).decode("utf8")
        return self.unpad(msg)
"""
aes加密算法 CBC 
padding : PKCS5
"""
from Crypto.Cipher import AES  
from base64 import b64decode, b64encode


BLOCK_SIZE = AES.block_size
# 不足BLOCK_SIZE的补位(s可能是含中文，而中文字符utf-8编码占3个位置,gbk是2，所以需要以len(s.encode())，而不是len(s)计算补码)
pad = lambda s: s + (BLOCK_SIZE - len(s.encode()) % BLOCK_SIZE) * chr(BLOCK_SIZE - len(s.encode()) % BLOCK_SIZE)
# 去除补位
unpad = lambda s: s[:-ord(s[len(s) - 1:])]


class AESCipher:
    def __init__(self, secretkey: str):
        self.key = secretkey  # 密钥
        self.iv = 'dMitHORyqbeYVE0o'  # 偏移量

    def encrypt(self, text):
        """
        加密 ：先补位，再AES加密，后base64编码
        :param text: 需加密的明文
        :return:
        """
        # text = pad(text) 包pycrypto的写法，加密函数可以接受str也可以接受bytess
        text = pad(text).encode()  # 包pycryptodome 的加密函数不接受str
        cipher = AES.new(key=self.key.encode(), mode=AES.MODE_CBC, IV=self.iv.encode())
        encrypted_text = cipher.encrypt(text)
        # 进行64位的编码,返回得到加密后的bytes，decode成字符串
        return b64encode(encrypted_text).decode('utf-8')

    def decrypt(self, encrypted_text):
        """
        解密 ：偏移量为key[0:16]；先base64解，再AES解密，后取消补位
        :param encrypted_text : 已经加密的密文
        :return:
        """
        encrypted_text = b64decode(encrypted_text)
        cipher = AES.new(key=self.key.encode(), mode=AES.MODE_CBC, IV=self.iv.encode())
        decrypted_text = cipher.decrypt(encrypted_text)
        return unpad(decrypted_text).decode('utf-8')

# RSA
import rsa


# pip install rsa
def rsa_encrypt(plaintext):
    '''
    输入明文、生成公钥、私钥
    公钥对明文进行加密、字符串加密
    :return:加密结果及私钥
    '''
    pub_key, priv_key = rsa.newkeys(1024)
    plaintext = plaintext.encode()
    ciphertext = rsa.encrypt(plaintext, pub_key)
    return ciphertext, priv_key


def rsa_decrypt(ciphertext, priv_key):
    '''
    传参私钥和加密的明文
    :param ciphertext:
    :param priv_key:
    :return:解密结果
    '''
    plaintext = rsa.decrypt(ciphertext, priv_key)
    plaintext = plaintext.decode()
    return plaintext