随笔- 81 文章- 0 评论- 1 阅读- 10万

python 实现常用的数据编码和对称加密

1、base64 编码

什么是 Base64 编码？ Base64 就是一种基于 64 个可打印字符来表示二进制数据的方法在 python 中对数据进行 base64 编码可以使用 base64 这个官方库

import base64
 
data= "mike"
 
# base编码
data = data.encode()
res = base64.b64encode(data)
print(res)
 
# base64解码
res2 = base64.b64decode(res)
print(res2)<br>print(res2.decode())

2、常见的哈希算法：

hash算法有很多：比如MD4、MD5、SHA-1 , SHA-224, SHA-256, SHA-384 和 SHA-5等等。其中MD5是比较常见的一种,也称之为MD5加密。

什么是 MD5 加密？

MD5(Message Digest Algorithm 5)，是一种哈希算法，是不可逆的，即通过 md5 加密之后没办法得到原文，没有解密算法。

python 中有一个叫做 hashlib 的官方库，对于一些常见的哈希算法这个库都实现了，咱们在工作中如果要使用 MD5 加密，直接使用 hashlib 这个库就可以实现。

from hashlib import md5
 
 
def encrypt_md5(data):
    """md5加密"""
 
    # 创建md5对象
    new_md5 = md5()
    new_md5.update(data.encode('utf-8'))
    res = new_md5.hexdigest()
    # 加密
    return res

3、DES 加密

什么是对称加密？对称加密指的的加密和解密用同一个秘钥进行加解密的加密方式。

什么是 EDS 加密？ des 对称加密，是一种比较传统的加密方式，其加密运算、解密运算使用的是同样的密钥，信息的发送者和信息的接收者在进行信息的传输与处理时，必须共同持相同的密码。

在 python 中有一个叫做 pyDes 的第三方库可以用来实现 DES 加密，使用之前需要先通过 pip 命令安装：pip install pyDes

from pyDes import des, CBC, PAD_PKCS5
import binascii
 
 
def des_encrypt(s, KEY):
    secret_key = KEY
    iv = secret_key
    k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
    en = k.encrypt(s, padmode=PAD_PKCS5)
    return binascii.b2a_hex(en).decode()
 
 
def des_descrypt(s, KEY):
    secret_key = KEY
    iv = secret_key
    k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
    de = k.decrypt(binascii.a2b_hex(s), padmode=PAD_PKCS5)
    return de.decode()
 
 
if __name__ == '__main__':
    # 秘钥
    KEY = 'mHAxsLtt'
 
    # 加密
    res = des_encrypt("python666", KEY)
    print(res)
 
  # 解密
    res2 = des_descrypt(res, KEY)
    print(res2)

4、3DES 加密

什么是 3DES 加密？ 3DES（或称为 Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是对每个数据块应用三次 DES 加密算法

python 中实现 3DES 加密可以使用，pyDes 这个模块去实现

import base64
import hashlib
import pyDes
 
 
def encrypt_3des(data):
    key = "U8NjHq1ZP10="
    hash_md5 = hashlib.md5()
    hash_md5.update(key.encode(encoding='UTF-8'))
    key = hash_md5.hexdigest()
    iv = key[0:8]
    key2 = key[0:24]
    k = pyDes.triple_des(key2, pyDes.CBC, IV=iv, pad=None, padmode=pyDes.PAD_PKCS5)
    d = k.encrypt(data.encode())
    d = base64.b64encode(d)
    return d.decode()
 
 
def descrypt_3des(data):
    key = "U8NjHq1ZP10="
    hash_md5 = hashlib.md5()
    hash_md5.update(key.encode(encoding='UTF-8'))
    key = hash_md5.hexdigest()
    iv = key[0:8]
    key2 = key[0:24]
    k = pyDes.triple_des(key2, pyDes.CBC, IV=iv, pad=None, padmode=pyDes.PAD_PKCS5)
    data = base64.b64decode(data)
    d = k.decrypt(data)
    return d.decode()
 
 
if __name__ == '__main__':
    res = encrypt_3des('lowen11111')
    print(res)
    res2 = descrypt_3des(res)
    print(res2)

5、AES 加密

什么是 AES 加密？ AES 也是一种对称加密。它是用来替代之前的 DES 的，安全性更高。

关于 python 中实现 Aes 加密的库很多，大家可以去 pypi 上自行下载安装，下面案例用的是 Crypto 这个库

import base64
from Crypto.Cipher import AES
 
 
class AesEncrypt:
    # 密钥
    key = '0CoJUm6Qyw8W8jud'
    # 偏移量
    vi = '0102030405060708'
 
 
    def encrypt(self, data):
        """加密"""
        data = data.encode('utf8')
        data = (lambda s: s + (16 - len(s) % 16) * chr(16 - len(s) % 16).encode('utf-8'))(data)
        cipher = AES.new(self.key.encode('utf8'), AES.MODE_CBC, self.vi.encode('utf8'))
        encryptedbytes = cipher.encrypt(data)
        encodestrs = base64.b64encode(encryptedbytes)
        enctext = encodestrs.decode('utf8')
        return enctext
 
 
    def decrypt(self, data):
        """解密"""
        data = data.encode('utf8')
        encodebytes = base64.decodebytes(data)
        cipher = AES.new(self.key.encode('utf8'), AES.MODE_CBC, self.vi.encode('utf8'))
        text_decrypted = cipher.decrypt(encodebytes)
        unpad = lambda s: s[0:-s[-1]]
        text_decrypted = unpad(text_decrypted)
        text_decrypted = text_decrypted.decode('utf8')
        return text_decrypted
 
 
if __name__ == '__main__':
    # 注意点：加密数据中有中文的时候，会有问题
    data = "lowen23"
    aes = AesEncrypt()
    # 加密
    enctext = aes.encrypt(data)
    print(enctext)
    # # 解密
    text_decrypted = aes.decrypt(enctext)
    print(text_decrypted)

　6.rsa对称加密　

import base64
from time import time
 
# 需要安装rsa模块, pip install rsa
import rsa
 
 
# http://tool.chacuo.net/cryptchacha20  常见的加密算法
 
class HandleSign:
    server_pub = """
    -----BEGIN PUBLIC KEY-----
    MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDQENQujkLfZfc5Tu9Z1LprzedE
    O3F7gs+7bzrgPsMl29LX8UoPYvIG8C604CprBQ4FkfnJpnhWu2lvUB0WZyLq6sBr
    tuPorOc42+gLnFfyhJAwdZB6SqWfDg7bW+jNe5Ki1DtU7z8uF6Gx+blEMGo8Dg+S
    kKlZFc8Br7SHtbL2tQIDAQAB
    -----END PUBLIC KEY-----
    """
 
    @classmethod
    def encrypt(cls, msg):
        """
        非对称加密
        :param msg: 待加密字符串或者字节
        :return: 密文
        """
        msg = msg.encode('utf-8')
        pub_key = cls.server_pub.encode("utf-8")
        public_key_obj = rsa.PublicKey.load_pkcs1_openssl_pem(pub_key)  # 创建 PublicKey 对象
        cryto_msg = rsa.encrypt(msg, public_key_obj)  # 生成加密文本
        cipher_base64 = base64.b64encode(cryto_msg)  # 将加密文本转化为 base64 编码
        return cipher_base64.decode()  # 将字节类型的 base64 编码转化为字符串类型
 
    @classmethod
    def generate_sign(cls, token):
        """
        生成sign
        :param token: token, 为str类型
        :return: 时间戳和sign组成的字典
        """
        timestamp = int(time())  # 获取当前的时间戳
        prefix_50_token = token[:50]  # 获取token前50位
        message = prefix_50_token + str(timestamp)  # 将token前50位与时间戳字符串进行拼接
        sign = cls.encrypt(message)  # 生成sign
        return {"timestamp": str(timestamp), "sign": sign}
 
 
if __name__ == '__main__':
    token = "eyJhbGciOiJIUzUxMiJ9.eyiZXJfaWQiOjI2NSwizdhE5_39bsGlILoSSoTCy0G4FwCnOj4iy5svbDlSbgCJM3qRa1zsXJLJmH4A"
    cryto_info = HandleSign.generate_sign(token)
    print(cryto_info)

7.sha1 加密　　

# SHA1的全称是Secure Hash Algorithm(安全哈希算法) 。SHA1基于MD5，加密后的数据长度更长，
# 它对长度小于264的输入，产生长度为160bit的散列值。比MD5多32位。
# 因此，比MD5更加安全，但SHA1的运算速度就比MD5要慢了。
 
import hashlib
 
str = "Hell,python你好"
a = hashlib.sha1(str.encode("utf-8")).hexdigest()
print("sha1加密前为 ：", str)
print("sha1加密前后 ：", a)

8.hmac

# python中还有一个hmac模块，它对我们创建key和内容再进行处理然后再加密
# 该模块加密是先把数据存储到字典中，然后再进行加密，方法与上述方法类似
import hmac
 
hm = hmac.new('Hell,python你好'.encode(encoding='utf-8'))
print(hm.digest())
print(hm.hexdigest())