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

最新推荐文章于 2024-01-16 17:31:41 发布
最新推荐文章于 2024-01-16 17:31:41 发布
阅读量350 收藏 2
点赞数
分类专栏： python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44253015/article/details/123981910
版权
本文介绍了如何使用Python实现常见的加密算法，包括AES-CBC、DES、RSA，以及整合了JavaScript库来增强加密能力。提供了MD5、SHA1和HMAC散列算法，以及对称与非对称加密的实例代码。
摘要由CSDN通过智能技术生成

对常见的加密方法用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
梅干菜扣肉
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Vue使用crypto-js加密库对称加密算法
m0_51431448的博客
07-04 4117
npm官网：https://www.npmjs.com/package/crypto-js 2. 按需引入 3. 加密、解密方法封装 在utils下新建crypto.js文件 4. 使用 、测试 控制台输出：
python 加密库_Python加密库入门
cumo7370的博客
07-09 1350
python 加密库 密码学俱乐部的第一条规则是：永远不要自己发明密码系统。 密码学俱乐部的第二条规则是：永远不要自己实施密码系统：在密码系统的实施阶段以及设计中都会发现许多现实世界的漏洞。 一个有用的Python密码基元库称为cryptography 。 它既具有“安全”原语，又具有“危险品”层。 “ hazmat”层需要注意密码知识，并且很容易使用它来实现安全漏洞。 在这篇介绍性文章中，...
python实现对称加密AES算法
timerring的博客
07-09 2万+
Modes of operations allow you to encrypt more data than the block size of your symmetric block cipher. Example: .In this program, you are required to demonstrate the algorithm with a third-party crypto library, . Recall that you must provide a correspondi
非对称加密算法
weixin_42551428的博客
11-05 302
与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥和私有密钥。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。常见非对称加密算法RSADSA。非对称加密算法私钥由数据接收方持有，不会在网络上传递，保证了密钥的安全。非对称加密算法通常比对称加密算法计算复杂，性能消耗高。非对称加密算法可用于数字签名。
对称加密算法——DES算法（python实现）
热门推荐
明明蠢萌的夏木君の
10-25 3万+
对称加密算法——DES算法（python实现） 感谢深信服技术详解～ 一、DES算法描述                                                                                                                                        DES算法总的说
python对称加密实现_Python Language
weixin_39783360的博客
12-08 426
例Python的内置加密功能目前仅限于散列。加密需要第二方模块，如pycrypto 。例如，它提供AES算法 ，该算法被认为是对称加密的现有技术。以下代码将使用密码加密给定的消息：import hashlibimport mathimport osfrom Crypto.Cipher import AESIV_SIZE = 16 # 128 bit, fixed for the AES al...
Python之加密
weixin_46944979的博客
09-17 126
一、MD5加密（一般用于数据库存密码） MD5加密是不可逆的，不能解密；同样的字符串，md5出来的结果都一样；任意长度的数据，算出的MD5值长度都是固定的，32位字符串； import hashlib #md5加密需导入hashlib模块 s='123456' s=s.encode() #将字符串转换为bytes，不转换报错 m=hashlib.md5(s) #创建一个md5 对象，md5是不可逆的 result=m.hexdigest() #拿到所有结果，hexdigest需要手动输入 加密时为了安全起
用python开发一个加密Excel数据的网站
01-25
1、交互式的UI操作界面 2、支持多种加密算法：md5、sha1、sha224、sha256、sha512 、支持Excel文件加密，以及单独内容加密
Python编译成.so文件进行加密后调用的实现
12-23
pyc的破解相对容易，使用cython将python文件编译成.so文件，能在一定程度上增强python源码的私密性。 编译成.so文件 环境准备：cython 测试脚本准备：test.py #-*-coding: UTF-8 -* - class test: def say(self): ...
如何使用Cython对python代码进行加密
12-17
Cython是属于PYTHON的超集，他首先会将PYTHON代码转化成C语言代码，然后通过c编译器生成可执行文件。优势：资源丰富，适合快速开发。翻译成C后速度比较快，在windows环境中用cython加密后的文件后缀是pyd文件，在...
python实现换位加密算法的示例
09-20
换位加密算法是一种古老的密码学技术，通过...总的来说，这段Python代码提供了一个基础的换位加密算法实现，对于理解加密原理和初学者实践很有帮助。然而，在实际应用中，应考虑使用更安全的加密算法，如AES、RSA等。
python对称加密算法库_对称加密算法
weixin_39831493的博客
12-08 906
对称加密算法就是传统的用一个密码进行加密和解密。例如，我们常用的WinZIP和WinRAR对压缩包的加密和解密，就是使用对称加密算法：从程序的角度看，所谓加密，就是这样一个函数，它接收密码和明文，然后输出密文：secret = encrypt(key, message);而解密则相反，它接收密码和密文，然后输出明文：plain = decrypt(key, secret);在软件开发中，常用的对称...
使用python进行AES对称加密解密
m0_47696151的博客
05-10 3646
这里写自定义目录标题常用的对称加密算法简介经典的对称区块加密模式现代的对称区块加密模式使用示例安装依赖库示例以经典的CBC模式为例以现代的OCB模式为例可能问题 常用的对称加密算法简介 有时需要对数据进行对称加解密，常用的有： DES（Data Encryption Standard，即数据加密标准）。 由于这种加密算法已经可以被暴力破解，所以已经不再安全。因此除了用它来解密以前对密文外，不应该再使用DES了。 AES（Advanced Encryption Standard，即高级加密标准），已经取代D
Python实现DES对称加密
黑哥的博客
03-20 1384
通过Python实现Des对称加密与解密，实现敏感信息的加密管理，有利于信息安全。
国密算法 SM2 公钥加密 非对称加密 数字签名 密钥协商 python实现完整代码
qq_43339242的博客
03-02 1万+
国密SM2算法的Python工具包，实现SM2数字签名与验证、公钥加解密以及密钥协商等功能，也可基于本工具包提供的椭圆曲线运算相关函数自行设计算法和协议。代码完整，复制即用。
python实现非对称加密算法_Python3非对称加密算法RSA实例详解
weixin_39598568的博客
12-20 102
本文实例讲述了Python3非对称加密算法RSA。分享给大家供大家参考，具体如下：python3 可以使用Crypto.PublicKey.RSA 和 rsa 生成公钥、私钥。其中 python3.6 Crypto 库的安装方式请参考前面一篇《Python3对称加密算法AES、DES3》rsa 加解密的库使用pip3 install rsa 就行了C:WINDOWSsystem32>pip3...
RSA非对称加密
最新发布
学海无涯
01-16 428
非对称加密算法是一类加密算法，与对称加密算法不同，非对称加密算法使用一对密钥，分别是公钥和私钥。这两个密钥是相关联的，但是不同的密钥用于加密和解密。这种加密方式的主要优势在于安全性较高。
python实现对称加密、数字签名、数字证书颁发
weixin_63137680的博客
02-23 2427
一个用python实现的对于任何文件的对称加密、数字签名以及数字证书颁发的桌面软件。
基于python的RSA算法的设计与实现
mainjay的博客
08-18 1812
基于python的RSA算法的设计与实现 介绍 现代密码学体系算法一般分为两种 对称加密算法 概念：通信双方加密和解密消息时使用相同的密钥 优点：加解密运算速度较快，适合处理大批量消息处理 缺点：很难解决密钥分发的安全性和数字签名问题 非对称加密算法 概念：发送方和接受方使用不同的密钥，发送方使用接受方的公钥对明文进行加密，接受方使用自己的私钥对密文进行解密，从而获得明文内容 优点：公钥密钥算法运算速度较慢，使用于处理密钥分发和数字签名等问题 公钥密码算法理论 公钥密码体系的实现过程 从集合论角度来看，
python调用库实现des的加密解密
06-08
可以使用Python的pyDes库来实现DES加密和解密。 首先，需要安装pyDes库，可以使用以下命令： ``` pip install pyDes ``` 接下来，我们可以使用以下代码来实现DES加密和解密： ```python from pyDes import des, CBC, PAD_PKCS5 import binascii # key为8字节的字符串 key = b'abcdefgh' # 需要加密的内容 text = 'Hello World' # 将text转换为8字节的倍数 pad_text = text + ('\0' * ((8 - len(text) % 8))) # 初始化加密器 iv = b'\0\0\0\0\0\0\0\0' # 8字节的初始化向量 k = des(key, CBC, iv, pad=None, padmode=PAD_PKCS5) # 加密 encrypt_text = k.encrypt(pad_text) # 解密 decrypt_text = k.decrypt(encrypt_text) # 输出加密和解密结果 print('加密后的内容为：', binascii.b2a_hex(encrypt_text)) print('解密后的内容为：', decrypt_text.decode()) ``` 其中，需要注意以下几点： - key必须为8字节的字符串； - 需要加密的内容需要转换为8字节的倍数，可以使用PKCS5填充方式； - 初始化向量iv必须为8字节的字符串； - CBC模式需要初始化向量，可以使用全0的字符串； - 加密和解密的结果都是二进制数据，需要使用binascii将其转换为可读的十六进制字符串。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梅干菜扣肉

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值