python AES加密实现API

Crypto包工具

import Crypto.Cipher.AES
import Crypto.Random
import base64
import binascii
import hashlib
class Cipher_AES:
    cipher = getattr(Crypto.Cipher, "AES")
    pad = {
        "default": lambda x, y: x + (y - len(x) % y) * " ".encode("utf-8"),
        "PKCS5Padding": lambda x, y: x + (y - len(x) % y) * chr(y - len(x) % y).encode("utf-8")
    }
    unpad = {
        "default": lambda x: x.rstrip(),
        "PKCS5Padding": lambda x: x[:-ord(x[-1])]
    }
    encode = {"base64": base64.encodebytes, "hex": binascii.b2a_hex}
    decode = {"base64": base64.b64decode, "hex": binascii.a2b_hex}
    def __init__(self,
                 key=None,
                 iv=None,
                 cipher_method=None,
                 pad_method="default",
                 code_method=None):
        self.__key = key if key else "abcdefgh12345678"  # 密钥（长度必须为16、24、32）
        self.__iv = iv if iv else Crypto.Random.new().read(Cipher_AES.cipher.block_size)  # 向量（长度与密钥一致，ECB模式不需要）
        self.__cipher_method = cipher_method.upper() if cipher_method \
                                                        and isinstance(cipher_method,
                                                                       str) else "MODE_ECB"  # 加密方式，["MODE_ECB"|"MODE_CBC"|"MODE_CFB"]等
        self.__pad_method = pad_method  # 填充方式，解决 Java 问题选用"PKCS5Padding"
        self.__code_method = code_method  # 编码方式，目前只有"base64"、"hex"两种
        if self.__cipher_method == "MODE_CBC":
            self.__cipher = Cipher_AES.cipher.new(self.__key.encode("utf-8"), Cipher_AES.cipher.MODE_CBC,
                                                  self.__iv.encode("utf-8"))
        else:
            self.__cipher = Cipher_AES.cipher.new(self.__key.encode("utf-8"), Cipher_AES.cipher.MODE_ECB)
    def __getitem__(self, item):
        def get3value(item):
            return item.start, item.stop, item.step
        type_, method, _ = get3value(item)
        dict_ = getattr(Cipher_AES, type_)
        return dict_[method] if method in dict_ else dict_["default"]
    def encrypt(self, text):
        cipher_text = b"".join([
            self.__cipher.encrypt(i)
            for i in self.text_verify(text.encode("utf-8"))
        ])
        encode_func = Cipher_AES.encode.get(self.__code_method)
        if encode_func:
            cipher_text = encode_func(cipher_text)
        return cipher_text.decode("utf-8").rstrip()
    def decrypt(self, cipher_text):
        cipher_text = cipher_text.encode("utf-8")
        decode_func = Cipher_AES.decode.get(self.__code_method)
        if decode_func:
            cipher_text = decode_func(cipher_text)
        return self.pad_or_unpad(
            "unpad",
            self.__cipher.decrypt(cipher_text).decode("utf-8"))
    def text_verify(self, text):
        while len(text) > len(self.__key):
            text_slice = text[:len(self.__key)]
            text = text[len(self.__key):]
            yield text_slice
        else:
            if len(text) == len(self.__key):
                yield text
            else:
                yield self.pad_or_unpad("pad", text)
    def pad_or_unpad(self, type_, contents):
        lambda_func = self[type_:self.__pad_method]  # lambda x: x[:-ord(x[-1])]
        return lambda_func(contents, len(
            self.__key)) if type_ == "pad" else lambda_func(contents)
key = "B@#deCC%ejk569^5"
iv = key[::-1]
# cipher_method = "AES"
pad_method = "PKCS5Padding"
code_method = "base64"
cipher_text = "B+dAVKs9xMqVPKwC+KAD3g=="
text = Cipher_AES(key, None, None, pad_method,
                  code_method).decrypt(cipher_text)
print(text)

cryptography包工具

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.serialization import Encoding, PrivateFormat, NoEncryption, PublicFormat
import base64
def aes_ecb_encrypt(data, key, iv):
    """
    use AES CBC to encrypt message, using key and init vector， padding: ZeroPadding
    :param data: 待加密的数据
    :param key:
    :param iv:
    :return:
    """
    data = data.encode()   # bytes
    key = key.encode()
    # iv = iv.encode()
    backend = default_backend()
    cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=backend)
    encryptor = cipher.encryptor()
    padder = lambda s: s + (16 - len(s) % 16) * chr(0)
    padded_data = padder(data.decode()).encode("utf-8")
    enc_content = encryptor.update(padded_data) + encryptor.finalize()
    enc_data = base64.b64encode(enc_content).decode('utf8')
    enc_result = base64.b64encode(enc_data.encode()).decode('utf8')
    return enc_result
def aes_ecb_decrypt(data, key):
    data = base64.b64decode(data)
    backend = default_backend()
    cipher = Cipher(algorithms.AES(key), modes.ECB(), backend)
    decryptor = cipher.decryptor()
    enc_content = decryptor.update(data) + decryptor.finalize()
    enc_content = enc_content.decode("utf-8")
    return enc_content[:-ord(enc_content[-1])]
# def pkcs5_padding(data):
#     if not isinstance(data, bytes):
#         data = data.encode()
#
#     padder = padding.PKCS7(algorithms.AES.block_size).padder()
#
#     padded_data = padder.update(data) + padder.finalize()
#
#     return padded_data