Python AES加密解密

字节类型加密解密

from Crypto.Cipher import AES


#
class Aes_byte:
    iv: bytes = []
    key: bytes = []
    BLOCK_SIZE: int = 16  # 设定字节长度

    def __init__(self, key: bytes, iv: bytes, BLOCK_SIZE: int = 16):
        self.iv = iv
        self.key = key
        self.BLOCK_SIZE = BLOCK_SIZE
        pass

    def __str__(self):
        print("AES加密和解密---字节类型")
        pass

    # 补足字节方法
    def pad(self, value) -> bytes:
        count = len(value)
        if (count % self.BLOCK_SIZE != 0):
            add = self.BLOCK_SIZE - (count % self.BLOCK_SIZE)
        else:
            add = 0
        text = value + ("\0".encode() * add)  # 这里的"\0"必须编码成bytes，不然无法和text拼接
        return text

    # 将明文用AES加密
    def AES_encrypt(self, data: bytes) -> bytes:
        # 将长度不足16字节的字符串补齐
        buffter = self.pad(data)  # 注意在这个地方要把传过来的数据编码成bytes，不然还是会报上面说的那个错
        # 创建加密对象
        cryptor = AES.new(self.key, AES.MODE_CBC, self.iv)
        # 完成加密
        return cryptor.encrypt(buffter)  # 将明文用AES加密

    # 将明文用AES解密
    def AES_decrypt(self, data: bytes) -> bytes:
        # 将长度不足16字节的字符串补齐
        buffter = self.pad(data)  # 注意在这个地方要把传过来的数据编码成bytes，不然还是会报上面说的那个错
        # 创建加密对象
        cryptor = AES.new(self.key, AES.MODE_CBC, self.iv)
        # 完成加密
        return cryptor.decrypt(buffter)


if __name__ == "__main__":
    # 创建公共文件夹，方便后面视频读取
    public_path: str = "./response/加密解密/"
    key_path: str = "./response/加密解密/key.key"

    # 读取字节---key的
    with open(key_path, "rb") as File:
        key = File.read()

    # 加密
    with open(public_path + "666.ts", "rb") as VideoBuffter:
        video = VideoBuffter.read()
        b = Aes_byte(key, bytes(16)).AES_encrypt(video)
    with open(public_path + "encrypt.ts", "ab") as VideoBuffter:
        VideoBuffter.write(b)

    # 解密
    with open(public_path + "encrypt.ts", "rb") as VideoBuffter_en:
        b = Aes_byte(key, bytes(16)).AES_decrypt(VideoBuffter_en.read())
    with open(public_path + "decrypt.ts", "ab") as VideoBuffter_de:
        VideoBuffter_de.write(b)

字符串加密解密

import base64
from Crypto.Cipher import AES


class Aes_str:
    iv: str = []
    key: str = []
    BLOCK_SIZE: int = 16  # 设定字节长度

    def __init__(self, key: str, iv: str, BLOCK_SIZE: int = 16):
        self.iv = iv
        self.key = key
        self.BLOCK_SIZE = BLOCK_SIZE
        pass

    def __str__(self):
        print("AES加密和解密---字符串")
        pass

    # 将原始的明文用空格填充到16字节
    def pad(self, data):
        pad_data = data
        for i in range(0, 16 - len(data)):
            pad_data = pad_data + ' '
        return pad_data

    # 将明文用AES加密
    def AES_encrypt(self, data):
        # 将长度不足16字节的字符串补齐
        if len(data) < 16:
            data = self.pad(data)
        # 创建加密对象
        AES_obj = AES.new(self.key.encode("utf-8"), AES.MODE_CBC, self.iv.encode("utf-8"))
        # 完成加密
        AES_encrypt_str = AES_obj.encrypt(data.encode("utf-8"))
        # 用base64编码一下
        AES_encrypt_str = base64.b64encode(AES_encrypt_str)
        # 最后将密文转化成字符串
        AES_encrypt_str = AES_encrypt_str.decode("utf-8")
        return AES_encrypt_str

    def AES_decrypt(self, data):
        # 解密过程逆着加密过程写
        # 将密文字符串重新编码成二进制形式
        data = data.encode("utf-8")
        # 将base64的编码解开
        data = base64.b64decode(data)
        # 创建解密对象
        AES_decrypt_obj = AES.new(self.key.encode("utf-8"), AES.MODE_CBC, self.iv.encode("utf-8"))
        # 完成解密
        AES_decrypt_str = AES_decrypt_obj.decrypt(data)
        # 去掉补上的空格
        AES_decrypt_str = AES_decrypt_str.strip()
        # 对明文解码
        AES_decrypt_str = AES_decrypt_str.decode("utf-8")
        return AES_decrypt_str


if __name__ == "__main__":
    data = "123456"
    data = Aes_str("bunny20010212123", "bunny20010212---").AES_encrypt(data)
    print(data)
    data = Aes_str("bunny20010212123", "bunny20010212---").AES_decrypt(data)
    print(data)