做一个常见加密库的python调用

对常见的加密方法用python进行了实现，方便调用
散列算法
MD5
SHA1
HMAC
对称加密
AES-CBC（包含js实现）
AES-ECB（包含js实现）
DES
非对称加密
RSA

欢迎大佬指正和优化

# coding: utf-8
"""
做一个加密库调用工具
python自己的加密库调用
协调js加密库
@author: xiao mu
@date: 2022-04-04

具体实现，对常用加密算法的调用进行封装成方便调用的形式
base64
对称加密
AES-CBC
AES-ECB
DES
3DES
非对称加密
RSA
ECC
散列算法
MD5
SHA1
HMAC

比如AES，封装起来，在要使用的时候直接传参调用就行
有时候python的不足以完全能够还原，需要加入JS加密算法
每一种加密各自写一个python实现和js实现
"""
import base64
import binascii
import hashlib
import execjs
# from Crypto import PublicKey
from Crypto import Random
from Crypto.Cipher import AES, DES, PKCS1_v1_5
from Crypto.PublicKey import RSA
from Crypto.Util.Padding import pad, unpad
from rsa import PublicKey, transform, core


class Encrypt(object):

    def __init__(self):
        pass

    def str_to_base64(self, content, encoding):
        """
        字符串转base64
        :param content:
        :param encoding:
        :return:
        """
        return str(base64.b64encode(content.encode(encoding)), encoding=encoding)

    def base64_to_str(self, content, encoding):
        """
        base64转字符串
        :param content:
        :param encoding:
        :return:
        """
        return str(base64.b64decode(bytes(content, encoding=encoding)), encoding=encoding)

    def base64_to_hex(self, content):
        """
        base64转hex
        :param content:
        :return:
        """
        return base64.b64decode(content).hex()

    def hex_to_base64(self, content):
        """
        hex转base64
        :param content:
        :return:
        """
        return base64.b64encode(content)

    def md5(self, content, encoding):
        """
        对传入的内容按照指定编码进行md5加密
        :param content:
        :param encoding:
        :return:
        """
        return hashlib.md5(content.encode(encoding=encoding)).hexdigest()

    def sha1(self, content, encoding):
        """
        对传入的内容按照指定编码进行sha1加密
        :param content:
        :param encoding:
        :return:
        """
        return hashlib.sha1(content.encode(encoding=encoding)).hexdigest()

    def _pkcs7padding(self, content, encoding):
        bs = 16
        length = len(content)
        bytes_length = len(content.encode(encoding))
        padding_size = length if (bytes_length == length) else bytes_length
        padding = bs - padding_size % bs
        padding_text = chr(padding) * padding
        self.coding = chr(padding)
        return content + padding_text

    def aes_cbc_encrypt_py(self, content, key, iv, encoding):
        """
        使用python库实现aes-cbc模式加密
        :param iv:
        :param content:
        :param key:
        :param encoding:
        :return:
        """
        key = key.encode(encoding)
        iv = iv.encode(encoding)
        aes = AES.new(key=key, mode=AES.MODE_CBC, iv=iv)
        content_padding = self._pkcs7padding(content=content, encoding=encoding)
        encrypt_bytes = aes.encrypt(content_padding.encode(encoding))
        result = str(self.hex_to_base64(encrypt_bytes), encoding=encoding)
        result = self.base64_to_hex(result).upper()
        return result

    def aes_cbc_decrypt_py(self, content, key, iv, encoding):
        """
        使用python库实现aes-cbc模式解密
        :param content:
        :param key:
        :param iv:
        :param encoding:
        :return:
        """
        key = key.encode(encoding)
        iv = iv.encode(encoding)
        aes = AES.new(key=key, mode=AES.MODE_CBC, iv=iv)
        content = binascii.a2b_hex(content)
        if len(content) % 16 != 0:
            content = pad(content, 16)
        decrypt_bytes = aes.decrypt(content)
        result = decrypt_bytes.decode(encoding, 'ignore')
        return result[:-ord(result[-1])]

    def aes_ecb_encrypt_py(self, content, key, encoding):
        """
        AES-ECB模式加密py版
        :param content:
        :param key:
        :param iv:
        :param encoding:
        :return:
        """
        key = key.encode(encoding)
        aes = AES.new(key=key, mode=AES.MODE_ECB)
        content_padding = self._pkcs7padding(content=content, encoding=encoding)
        encrypt_bytes = aes.encrypt(content_padding.encode(encoding))
        result = str(self.hex_to_base64(encrypt_bytes), encoding=encoding)
        result = self.base64_to_hex(result).upper()
        return result

    def aes_ecb_decrypt_py(self, content, key, encoding):
        """
        使用python库实现aes-ecb模式解密
        :param content:
        :param key:
        :param iv:
        :param encoding:
        :return:
        """
        key = key.encode(encoding)
        aes = AES.new(key=key, mode=AES.MODE_ECB)
        content = binascii.a2b_hex(content)
        if len(content) % 16 != 0:
            content = pad(content, 16)
        decrypt_bytes = aes.decrypt(content)
        result = decrypt_bytes.decode(encoding, 'ignore')
        return result[:-ord(result[-1])]

    def aes_cbc_encrypt_js(self, content, key, iv):
        """
        使用js实现aes-cbc模式加密
        :param content:
        :param key:
        :param iv:
        :return:
        """
        jscode = f"""
            var aes = require("crypto-js");
            var key = aes.enc.Utf8.parse("{
      
      key}");
            var iv = aes.enc.Utf8.parse("{
      
      iv}");
                function encrypt(content) [[
                    var content = aes.enc.Utf8.parse(content)
                        , result = aes.AES.encrypt(content, key, [[
                        iv: iv,
                        mode: aes.mode.CBC,
                        padding: aes.pad.Pkcs7
                    ]])
                    return result.ciphertext.toString().toUpperCase()
                ]]
            """
        jscode = jscode.replace('[[', '{').replace(']]', '}')
        ctx = execjs.compile(jscode, cwd=r'C:\Users\SI YI\AppData\Roaming\npm\node_modules')
        result = ctx.call("encrypt", content)
        return result

    def aes_cbc_decrypt_js(self, content, key, iv):
        """
        使用js实现aes-cbc模式加密
        :param content:
        :param key:
        :param iv:
        :return:
        """
        jscode = f"""
            var aes = require("crypto-js");
            var key = aes.enc.Utf8.parse("{
      
      key}");
            var iv = aes.enc.Utf8.parse("{
      
      iv}");
                function encrypt(content) [[
                    var content = aes.enc.Hex.parse(content),
                        content = aes.enc.Base64.stringify(content)
                        , result = aes.AES.decrypt(content, key, [[
                        iv: iv,
                        mode: aes.mode.CBC,
                        padding: aes.pad.Pkcs7
                    ]])
                    return result.toString(aes.enc.Utf8)
                ]]
            """
        jscode = jscode.replace('[[', '{').replace(']]', '}')
        ctx = execjs.compile(jscode, cwd=r'C:\Users\SI YI\AppData\Roaming\npm\node_modules')
        result = ctx.call("encrypt", content)
        return result

    def aes_ecb_encrypt_js(self, content, key):
        """
        使用js实现aes-ecb模式加密
        :param content:
        :param key:
        :return:
        """
        jscode = f"""
            var aes = require("crypto-js");
            var key = aes.enc.Utf8.parse("{
      
      key}");
                function encrypt(content) [[
                    var content = aes.enc.Utf8.parse(content)
                        , result = aes.AES.encrypt(content, key, [[
                        mode: aes.mode.ECB,
                        padding: aes.pad.Pkcs7
                    ]])
                    return result.ciphertext.toString().toUpperCase()
                ]]
            """
        jscode = jscode.replace('[[', '{').replace(']]', '}')
        ctx = execjs.compile(jscode, cwd=r'C:\Users\SI YI\AppData\Roaming\npm\node_modules')
        result = ctx.call("encrypt", content)
        return result

    def aes_ecb_decrypt_js(self, content, key):
        """
        使用js实现aes-ecb模式解密
        :param content:
        :param key:
        :return:
        """
        jscode = f"""
            var aes = require("crypto-js");
            var key = aes.enc.Utf8.parse("{
      
      key}");
                function encrypt(content) [[
                    var content = aes.enc.Hex.parse(content),
                        content = aes.enc.Base64.stringify(content)
                        , result = aes.AES.decrypt(content, key, [[
                        mode: aes.mode.ECB,
                        padding: aes.pad.Pkcs7
                    ]])
                    return result.toString(aes.enc.Utf8)
                ]]
            """
        jscode = jscode.replace('[[', '{').replace(']]', '}')
        ctx = execjs.compile(jscode, cwd=r'C:\Users\SI YI\AppData\Roaming\npm\node_modules')
        result = ctx.call("encrypt", content)
        return result

    def des_ecb_encrypt_py(self, content, key, encoding):
        """
        DES-ECB模式加密py版
        :param content:
        :param key:
        :param iv:
        :param encoding:
        :return:
        """
        key = key.encode(encoding)
        des = DES.new(key=key, mode=DES.MODE_ECB)
        content_padding = self._pkcs7padding(content=content, encoding=encoding)
        encrypt_bytes = des.encrypt(content_padding.encode(encoding))
        result = str(self.hex_to_base64(encrypt_bytes), encoding=encoding)
        result = self.base64_to_hex(result).upper()
        return result

    def des_ecb_decrypt_py(self, content, key, encoding):
        """
        使用python库实现des-ecb模式解密
        :param content:
        :param key:
        :param iv:
        :param encoding:
        :return:
        """
        key = key.encode(encoding)
        des = DES.new(key=key, mode=DES.MODE_ECB)
        content = binascii.a2b_hex(content)
        if len(content) % 16 != 0:
            content = pad(content, 16)
        decrypt_bytes = des.decrypt(content)
        result = decrypt_bytes.decode(encoding, 'ignore')
        return result[:-ord(result[-1])]

    def des_cbc_encrypt_py(self, content, key, iv, encoding):
        """
        使用python库实现des-cbc模式加密
        :param iv:
        :param content:
        :param key:
        :param encoding:
        :return:
        """
        key = key.encode(encoding)
        iv = iv.encode(encoding)
        des = DES.new(key=key, mode=DES.MODE_CBC, iv=iv)
        content_padding = self._pkcs7padding(content=content, encoding=encoding)
        encrypt_bytes = des.encrypt(content_padding.encode(encoding))
        result = str(self.hex_to_base64(encrypt_bytes), encoding=encoding)
        result = self.base64_to_hex(result).upper()
        return result

    def des_cbc_decrypt_py(self, content, key, iv, encoding):
        """
        使用python库实现des-cbc模式解密
        :param content:
        :param key:
        :param iv:
        :param encoding:
        :return:
        """
        key = key.encode(encoding)
        iv = iv.encode(encoding)
        des = DES.new(key=key, mode=DES.MODE_CBC, iv=iv)
        content = binascii.a2b_hex(content)
        if len(content) % 16 != 0:
            content = pad(content, 16)
        decrypt_bytes = des.decrypt(content)
        result = decrypt_bytes.decode(encoding, 'ignore')
        return result[:-ord(result[-1])]

    def rsa_encrypt_py(self, content, publickey, encoding):
        """
        rsa加密
        :param content:
        :param publickey:
        :param encoding:
        :return:
        """
        rsa = PKCS1_v1_5.new(RSA.importKey(publickey))
        encrypt_bytes = rsa.encrypt(content.encode(encoding=encoding))
        result = str(self.hex_to_base64(encrypt_bytes), encoding=encoding)
        # result = self.base64_to_hex(result).upper()
        return result

    def rsa_decrypt_py(self, content, publickey, encoding):
        """
        rsa解密
        :param content:
        :param publickey:
        :param encoding:
        :return:
        """
        # rsa_public_key = PublicKey.load_pkcs1_openssl_der(base64.b64decode(publickey))
        rsa = PKCS1_v1_5.new(RSA.importKey(publickey))
        decrypt_bytes = rsa.decrypt(base64.b64decode(content), Random.new().read)
        result = str(decrypt_bytes, encoding=encoding)
        # result = self.base64_to_hex(result).upper()
        return result