aes加密算法python語言實作_python實作AES/DES/RSA/MD5/SM2/SM4/3DES加密算法模闆彙總

都是作者累積的,且看其珍惜,大家可以盡量可以儲存一下,如果轉載請寫好出處https://www.cnblogs.com/pythonywy

一.md5加密

1.簡介

這是一種使用非常廣泛的加密方式，不可逆的,常見16位和32位一般都是md5

import hashlib

data = '你好'

print(hashlib.md5(data.encode(encoding="UTF-8")).hexdigest()) #32位

print(hashlib.md5(data.encode(encoding="UTF-8")).hexdigest()[8:-8]) #16位

二.RSA加密

1.簡介

非對稱加密算法,也就是比較常見的公鑰私鑰加密,可逆的

2.指數和模加密無填充-模闆一

import rsa

#模

m = "ae068c2039bd2d82a529883f273cf20a48e0b6faa564e740402375a9cb332a029b8492ae342893d9c9d53d94d3ab8ae95de9607c2e03dd46cebe211532810b73cc764995ee61ef435437bcddb3f4a52fca66246dbdf2566dd85fbc4930c548e7033c2bcc825b038e8dd4b3553690e0c438bbd5ade6f5a476b1cbc1612f5d501f"

#指數

e = '10001'

#加密參數

message = '123456'

class Encrypt(object):

def __init__(self, e, m):

self.e = e

self.m = m

def encrypt(self, message):

mm = int(self.m, 16)

ee = int(self.e, 16)

rsa_pubkey = rsa.PublicKey(mm, ee)

crypto = self._encrypt(message.encode(), rsa_pubkey)

return crypto.hex()

def _pad_for_encryption(self, message, target_length):

message = message[::-1]

max_msglength = target_length - 11

msglength = len(message)

padding = b''

padding_length = target_length - msglength - 3

for i in range(padding_length):

padding += b'\x00'

return b''.join([b'\x00\x00', padding, b'\x00', message])

def _encrypt(self, message, pub_key):

keylength = rsa.common.byte_size(pub_key.n)

padded = self._pad_for_encryption(message, keylength)

payload = rsa.transform.bytes2int(padded)

encrypted = rsa.core.encrypt_int(payload, pub_key.e, pub_key.n)

block = rsa.transform.int2bytes(encrypted, keylength)

return block

if __name__ == '__main__':

en = Encrypt(e, m)

print(en.encrypt(message))

3.指數和模加密無填充-模闆二

import codecs

def rsa_encrypt(content):

public_exponent = '010001'

public_modulus = 'ae068c2039bd2d82a529883f273cf20a48e0b6faa564e740402375a9cb332a029b8492ae342893d9c9d53d94d3ab8ae95de9607c2e03dd46cebe211532810b73cc764995ee61ef435437bcddb3f4a52fca66246dbdf2566dd85fbc4930c548e7033c2bcc825b038e8dd4b3553690e0c438bbd5ade6f5a476b1cbc1612f5d501f'

content = content[::-1]

rsa = int(codecs.encode(content.encode('utf-8'), 'hex_codec'),

16) ** int(public_exponent, 16) % int(public_modulus, 16)

# 把10進制數rsa轉為16進制('x'表示16進制)，再取前256位，不夠的在最前面補0

return format(rsa, 'x').zfill(256)

4.指數和模加密無填充-模闆三

import math

if __name__ == '__main__':

# 實為16進制串，前補0

e = ''

# m也需要補00

m = '008eb933413be3234dddd2730fbb1d05c8848a43d5dc3bdd997f2a9935fba6beb9ffb36854482b0b46cf7e6f9afbbe2e2e7d606fde20bec57dbf722e7985192e8813e6b67628a6f202cf655b7d2ffce4e9dc682dd6034ae706c8e255f25e4051b9ca43f25b3ad686aac9c8f6aeb71d921c13a255c806f78a5a7b9a356c2dd274e3'

m = int.from_bytes(bytearray.fromhex(m), byteorder='big')

e = int.from_bytes(bytearray.fromhex(e), byteorder='big')

# js加密為反向，為保持一緻原文應反向處理，是以這裡原文實際為204dowls

plaintext = 'slwod402'.encode('utf-8')

# 無填充加密邏輯

input_nr = int.from_bytes(plaintext, byteorder='big')

crypted_nr = pow(input_nr, e, m)

keylength = math.ceil(m.bit_length() / 8)

crypted_data = crypted_nr.to_bytes(keylength, byteorder='big')

print(crypted_data.hex())

5.指數和模加密有填充

from cryptography.hazmat.backends import default_backend

from cryptography.hazmat.primitives.asymmetric import rsa

from cryptography.hazmat.primitives.asymmetric import padding

import base64

import binascii

"""

另種rsa加密

"""

def data_encrypt(text):

"""

RSA 加密

:param text: 加密前内容

:return: 加密後内容

"""

# 判斷系統,加載指定子產品

public_exponent = int("010001",16) #指數

print(public_exponent)

public_modulus=int('B23322F080BD5876C0735D585D25C7BC409F637237B07744D27FBF39FB100ABE59DF380EA6BFCDF28C286E7A0CD95BE87F6099F8F39B0E97D9782C3D33FCFB80D43D2F22A9D9417ECFD1A0B8421DEE1CD4B323E8078336E77419A97F94E60A90CA06551202F63819FC8E73425F06ECA4C05BBF8CA32366240A6C36CA61D85019',16) #模

# content = 'leadeon' + text + time.strftime("%Y%m%d%H%M%S", time.localtime())

content = text

max_length = 117

# public_key = serialization.load_pem_public_key(key, backend=default_backend())

public_key = rsa.RSAPublicNumbers(public_exponent, public_modulus).public_key(default_backend())

data = b''

for i in range(0, len(content), max_length):

data += public_key.encrypt(content[i: i + max_length].encode(),

padding.PKCS1v15())

data = base64.b64encode(data).decode()

#data =binascii.b2a_hex(data).decode() hex輸出

return data

6.公鑰加密

# 公鑰加密

import base64

import rsa

from Crypto.PublicKey import RSA

def encryptPassword(data, publicKeyStr):

'''

data:内容

publicKeyStr:不需要-----BEGIN PUBLIC KEY-----開頭，-----END PUBLIC KEY-----結尾的格式,隻要中間部分即可

key_encoded:不需要-----BEGIN PUBLIC KEY-----開頭，-----END PUBLIC KEY-----結尾的格式

'''

key_encoded='''-----BEGIN PUBLIC KEY-----

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCdZGziIrJOlRomzh7M9qzo4ibw

QmwORcVDI0dsfUICLUVRdUN+MJ8ELd55NKsfYy4dZodWX7AmdN02zm1Gk5V5i2Vw

GVWE205u7DhtRe85W1oR9WTsMact5wuqU6okJd2GKrEGotgd9iuAJm90N6TDeDZ4

KHEvVEE1yTyvrxQgkwIDAQAB

-----END PUBLIC KEY-----'''

# 1、base64解碼

publicKeyBytes = base64.b64decode(publicKeyStr.encode())

# 3、生成publicKey對象

key = RSA.import_key(publicKeyBytes)

#key = RSA.import_key(key_encoded)

# 4、對原密碼加密

encryptPassword = rsa.encrypt(data.encode(), key)

return base64.b64encode(encryptPassword).decode()

7.私鑰解密

# rsa 解密

def long_decrypt(msg):

rsa_private_key = """-----BEGIN RSA PRIVATE KEY-----

MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQClceuXNXcT7H8ElMfzfRhgOoxqmINR7LGXk+tUrIHHP8VCJfqxTKmow45dNK+kfBRKT9+uSxFlNV5uBdfaBFX13Eq8Ynq12hgvILYihU0gUNVuESTdFGaSS60AaCbuPpD9ENVgs4hrHfJwD4PWXCSpoPPcw9s4DSsxmapcHdE8hR21uWeEbQKISrZe+wdqI5Bv+iVqqd6MbX+pO3QJ4CcmVILomAEn64dHqP1cmRZaZ59J/Y9aP9qYtiPYO0kArsxVDM6ZWkDyrbjJJcbaPBmi4JppNTD/fRhDrSdRn8CBTZEnqRKLANhb4V+qaPaU9wAOWDwJqcT18RjfTcuxWi/zAgMBAAECggEAIBabUgWNpfCdph7RNTmTC77vUxFnjvEwdKy83PxkY2fL84t4NwEeetwK9artUiK6sLsTMDPhGNckDITXm7JxlbD3Udhr4m99d06J5OIj1lu3OZTbqIF3b3J8CHMq8dRyvJKSQCIyGEyDpBZuRJo0hi3wfmYCU7nCIemi8CDcXzdGXTaRdiAW73nn+Ow8sFX+XG6/6hPw9t+0r8GhrEfknC29NIPtAQqjamrKQm4lcW9eClId7vknZoNXsWw7w3B1pHy71GDFs+wquG8A3GjHOwySptrb0XexzwEzuxR0HJOdKrsNRSUncm0eY6lfQNW0PEN6IXopK0DooyCQO00rCQKBgQDZAEL6zDXPctCaPtS8qifd/hN3aMz+XvX+O811sXYaB/5ySndaR3mApJnbcoYDvL3EvFWL3YgjWL8Qp0HX7gTrdDuOv8yY+K2i347CCU+B0E81gP1tvUCVTc3x+hLKgcOs8UDH+GouLe1qycVs2FliuYngUFaZwOX4H4MFMiTgdQKBgQDDLa4JsnwY7kR88TLteEqC2G6Jk9IPRMut/PDvdrGHyj6YEw7WbZLnyAMOEm1NeTa+bIr8mPPEEM1mrS3xaWwgn1rMqqzkSC/DpgFppiJGBGX6cDFs2fYJOFBMzKlGIoHcWdl1SSEYbzxNo5ljoK6r+UaBfMcuuS5BHQ56nKpBxwKBgF2Lu1QajGftevfDdjoOsDkGuqWTTCusDCeY6C2AXwVBxPLIH0OP5FUMoDb128foqXYSKl6tFW8HZvZq4/uN5BkMdlBHZo/bRB8eeJA1K00u27aY8KdKGnlCnTFfOJKL9iqrpd2OvVdC/UI30R/m9EGW8lT8zRhjC8A29WhcAYGxAoGAA9U20LvvkfHD6Iw4Cs/M7srfSNZdTq10LoOEG7/B9r+zAPuG1BEszF5yKOmVuerCd3TcOd+rEdOepQCLoW0HkZBvkQtc/9KnFXmCF5gKnkNh2UwwvEl/emjfstJmFJmC4VfmXFZGTxuIHKI01e8G3xuzFcHki3dZgC/Y4/GFqmsCgYBvQbz9raUVVxJwkN+9UsciTNzW10Tkt2OLYlFRiD+QAC9XK7ZjrjIkQIXEL5OrzYDTU3aHNWt3QwZskSfwFD4P118ICkVdPI9If/I0iqtQwCoIM83dtTFhJrImq0zxFn/dxhJv6ga+/CqJQmLHXMWt+vtvlSgcosvU3eYlVpoPjQ==

-----END RSA PRIVATE KEY-----"""

msg = base64.b64decode(msg)

# 私鑰解密

priobj = Cipher_pkcs1_v1_5.new(RSA.importKey(rsa_private_key))

data = priobj.decrypt(msg,None).decode()

return data

8..驗簽

from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5

from Crypto.Signature import PKCS1_v1_5

from Crypto.PublicKey import RSA

from Crypto.Hash import SHA256

import base64

class RsaUtil:

def __init__(self, pub_key, pri_key):

self.pri_key_obj = None

self.pub_key_obj = None

self.verifier = None

self.signer = None

if pub_key:

pub_key = RSA.importKey(base64.b64decode(pub_key))

self.pub_key_obj = Cipher_pkcs1_v1_5.new(pub_key)

self.verifier = PKCS1_v1_5.new(pub_key)

if pri_key:

pri_key = RSA.importKey(base64.b64decode(pri_key))

self.pri_key_obj = Cipher_pkcs1_v1_5.new(pri_key)

self.signer = PKCS1_v1_5.new(pri_key)

def public_long_encrypt(self, data, charset='utf-8'):

data = data.encode(charset)

length = len(data)

default_length = 117

res = []

for i in range(0, length, default_length):

res.append(self.pub_key_obj.encrypt(data[i:i + default_length]))

byte_data = b''.join(res)

return base64.b64encode(byte_data)

def private_long_decrypt(self, data, sentinel=b'decrypt error'):

data = base64.b64decode(data)

length = len(data)

default_length = 128

res = []

for i in range(0, length, default_length):

res.append(self.pri_key_obj.decrypt(data[i:i + default_length], sentinel))

return str(b''.join(res), encoding = "utf-8")

def sign(self, data, charset='utf-8'):

h = SHA256.new(data.encode(charset))

signature = self.signer.sign(h)

return base64.b64encode(signature)

def verify(self, data, sign, charset='utf-8'):

h = SHA256.new(data.encode(charset))

return self.verifier.verify(h, base64.b64decode(sign))

三.DES

1.簡介

這是一個分組加密算法，解密和加密是同一個算法,可逆的

2.DES加密與解密以及hex輸出和bs64格式輸出

import pyDes

import base64

Key = "12345678" #加密的key

Iv = None #偏移量

def bytesToHexString(bs):

'''

bytes轉16進制

'''

return ''.join(['%02X ' % b for b in bs])

def hexStringTobytes(str):

'''16進制轉bytes'''

str = str.replace(" ", "")

return bytes.fromhex(str)

# 加密

def encrypt_str(data):

# 加密方法

#padmode填充方式

#pyDes.ECB模式

method = pyDes.des(Key, pyDes.ECB, Iv, pad=None, padmode=pyDes.PAD_PKCS5)

# 執行加密碼 hex輸出

k = method.encrypt(data)

data = bytesToHexString(k).replace(' ','')

#bs64手粗

#data =base64.b64encode(k)

return data

# 解密

def decrypt_str(data):

method = pyDes.des(Key, pyDes.ECB, Iv, pad=None, padmode=pyDes.PAD_PKCS5)

k =hexStringTobytes(data)

#bs64

#k = base64.b64decode(data)

return method.decrypt(k)

Encrypt = encrypt_str("aaa")

print(Encrypt)

Decrypt = decrypt_str(Encrypt)

print(Decrypt)

四.3des

代碼模闆

import hashlib, base64

import json

from cryptography.hazmat.primitives.padding import PKCS7

from cryptography.hazmat.primitives.ciphers import algorithms

from Crypto.Cipher import DES3

def pkcs7padding(text):

"""

明文使用PKCS7填充

最終調用DES3加密方法時，傳入的是一個byte數組，要求是16的整數倍，是以需要對明文進行處理

:param text: 待加密内容(明文)

:return:

"""

bs = DES3.block_size # 16

length = len(text)

bytes_length = len(bytes(text, encoding='utf-8'))

# tips：utf-8編碼時，英文占1個byte，而中文占3個byte

padding_size = length if (bytes_length == length) else bytes_length

padding = bs - padding_size % bs

# tips：chr(padding)看與其它語言的約定，有的會使用'\0'

padding_text = chr(padding) * padding

return text + padding_text

def pkcs7_unpad(content):

"""

解密時候用

:param content:

:return:

"""

if not isinstance(content, bytes):

content = content.encode()

pad = PKCS7(algorithms.DES3.block_size).unpadder()

pad_content = pad.update(content) + pad.finalize()

return pad_content

def encrypt(key, content):

"""

DES3加密

key,iv使用同一個

模式cbc

填充pkcs7

:param key: 密鑰

:param content: 加密内容

:return:

"""

key_bytes = bytes(key, encoding='utf-8')

iv = key_bytes

cipher = DES3.new(key_bytes, DES3.MODE_ECB)

# 處理明文

content_padding = pkcs7padding(content)

# 加密

encrypt_bytes = cipher.encrypt(bytes(content_padding, encoding='utf-8'))

# 重新編碼

result = str(base64.b64encode(encrypt_bytes), encoding='utf-8')

return result

def decrypt(key,text):

key_bytes = bytes(key, encoding='utf-8')

iv = key_bytes

cryptos = DES3.new(key_bytes, DES3.MODE_ECB)

data = cryptos.decrypt(text)

return json.loads(pkcs7_unpad(data))

五.AES加密

1.簡介

和DES差不多,可逆的

2.AES_ECB_pkcs5padding(該模闆不相容中文)

from Crypto.Cipher import AES

import base64

class Aes_ECB(object):

def __init__(self):

self.key = 'XXXXXXXXXXX' #秘鑰

self.MODE = AES.MODE_ECB

self.BS = AES.block_size

self.pad = lambda s: s + (self.BS - len(s) % self.BS) * chr(self.BS - len(s) % self.BS)

self.unpad = lambda s: s[0:-ord(s[-1])]

# str不是16的倍數那就補足為16的倍數

def add_to_16(value):

while len(value) % 16 != 0:

value += '\0'

return str.encode(value) # 傳回bytes

def AES_encrypt(self, text):

aes = AES.new(Aes_ECB.add_to_16(self.key), self.MODE) # 初始化加密器

encrypted_text = str(base64.encodebytes(aes.encrypt(Aes_ECB.add_to_16(self.pad(text)))),

encoding='utf-8').replace('\n', '') # 這個replace大家可以先不用，然後在調試出來的結果中看是否有'\n'換行符

# 執行加密并轉碼傳回bytes

return encrypted_text

3.AES_ECB_pkcs7padding(支援中文)

import hashlib, base64

from Crypto.Cipher import AES

from cryptography.hazmat.primitives.padding import PKCS7

from cryptography.hazmat.primitives.ciphers import algorithms

def pkcs7padding(text):

"""

明文使用PKCS7填充

最終調用AES加密方法時，傳入的是一個byte數組，要求是16的整數倍，是以需要對明文進行處理

:param text: 待加密内容(明文)

:return:

"""

bs = AES.block_size # 16

length = len(text)

bytes_length = len(bytes(text, encoding='utf-8'))

# tips：utf-8編碼時，英文占1個byte，而中文占3個byte

padding_size = length if (bytes_length == length) else bytes_length

padding = bs - padding_size % bs

# tips：chr(padding)看與其它語言的約定，有的會使用'\0'

padding_text = chr(padding) * padding

return text + padding_text

def pkcs7_unpad(content):

"""

解密時候用

:param content:

:return:

"""

if not isinstance(content, bytes):

content = content.encode()

pad = PKCS7(algorithms.AES.block_size).unpadder()

pad_content = pad.update(content) + pad.finalize()

return pad_content

def encrypt(key, content):

"""

AES加密

key,iv使用同一個

模式cbc

填充pkcs7

:param key: 密鑰

:param content: 加密内容

:return:

"""

key_bytes = bytes(key, encoding='utf-8')

iv = key_bytes

cipher = AES.new(key_bytes, AES.MODE_ECB)

# 處理明文

content_padding = pkcs7padding(content)

# 加密

encrypt_bytes = cipher.encrypt(bytes(content_padding, encoding='utf-8'))

# 重新編碼

result = str(base64.b64encode(encrypt_bytes), encoding='utf-8')

return result

def decrypt(key,text):

key_bytes = bytes(key, encoding='utf-8')

iv = key_bytes

cryptos = AES.new(key_bytes, AES.MODE_ECB)

data = cryptos.decrypt(text)

return json.loads(pkcs7_unpad(data))

4.識别是AES_128\192\256怎麼識别

根據key的長度進行識别

128 16位

192 24位

256 32位

#基本上不足的部分都是以0進行填充

5.ECB和CBC在代碼實作上的差別

CBC相比ECB多一個偏移量,至于其他地方代碼差別不大

六.SM2/SM4

GMSSL子產品介紹

GmSSL是一個開源的加密包的python實作，支援SM2/SM3/SM4等國密(國家商用密碼)算法、項目采用對商業應用友好的類BSD開源許可證，開源且可以用于閉源的商業應用。

安裝子產品

pip install gmssl

#https://github.com/duanhongyi/gmssl/blob/master/README.md官方文檔

SM2算法

RSA算法的危機在于其存在亞指數算法，對ECC算法而言一般沒有亞指數攻擊算法 SM2橢圓曲線公鑰密碼算法：我國自主知識産權的商用密碼算法，是ECC(Elliptic Curve Cryptosystem)算法的一種，基于橢圓曲線離散對數問題，計算複雜度是指數級，求解難度較大，同等安全程度要求下，橢圓曲線密碼較其他公鑰算法所需密鑰長度小很多。

gmssl是包含國密SM2算法的Python實作， 提供了 encrypt、 decrypt等函數用于加密解密， 用法如下：

1. 初始化CryptSM2

import base64

import binascii

from gmssl import sm2, func

#16進制的公鑰和私鑰

private_key = '00B9AB0B828FF68872F21A837FC303668428DEA11DCD1B24429D0C99E24EED83D5'

public_key = 'B9C9A6E04E9C91F7BA880429273747D7EF5DDEB0BB2FF6317EB00BEF331A83081A6994B8993F3F5D6EADDDB81872266C87C018FB4162F5AF347B483E24620207'

sm2_crypt = sm2.CryptSM2(

public_key=public_key, private_key=private_key)

2. encrypt和decrypt

#資料和加密後資料為bytes類型

data = b"111"

enc_data = sm2_crypt.encrypt(data)

dec_data =sm2_crypt.decrypt(enc_data)

assert dec_data == data

3.sign和verify

data = b"111" # bytes類型

random_hex_str = func.random_hex(sm2_crypt.para_len)

sign = sm2_crypt.sign(data, random_hex_str) # 16進制

assert sm2_crypt.verify(sign, data) # 16進制

SM4算法

國密SM4(無線區域網路SMS4)算法， 一個分組算法， 分組長度為128bit， 密鑰長度為128bit， 算法具體内容參照SM4算法。

gmssl是包含國密SM4算法的Python實作， 提供了 encrypt_ecb、 decrypt_ecb、 encrypt_cbc、 decrypt_cbc等函數用于加密解密， 用法如下：

1. 初始化CryptSM4

from gmssl.sm4 import CryptSM4, SM4_ENCRYPT, SM4_DECRYPT

key = b'3l5butlj26hvv313'

value = b'111' # bytes類型

iv = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' # bytes類型

crypt_sm4 = CryptSM4()

2. encrypt_ecb和decrypt_ecb

crypt_sm4.set_key(key, SM4_ENCRYPT)

encrypt_value = crypt_sm4.crypt_ecb(value) # bytes類型

crypt_sm4.set_key(key, SM4_DECRYPT)

decrypt_value = crypt_sm4.crypt_ecb(encrypt_value) # bytes類型

assert value == decrypt_value

3. encrypt_cbc和decrypt_cbc

crypt_sm4.set_key(key, SM4_ENCRYPT)

encrypt_value = crypt_sm4.crypt_cbc(iv , value) # bytes類型

crypt_sm4.set_key(key, SM4_DECRYPT)

decrypt_value = crypt_sm4.crypt_cbc(iv , encrypt_value) # bytes類型

assert value == decrypt_value

七.其他不怎麼需要模闆的加密

1.base64加密

import base64 #base64也是用來加密的，但是這個是可以解密的

s = "password"

print(base64.b64encode(s.encode()) ) #加密

2.uuid

#有時候你會看到一些比如xxxx-xxxx-xxx-xxx誤以為是加密其實很多是uuid子產品自動生成的

随機數格式為:xxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxx

python的uuid子產品提供UUID類和函數uuid1(), uuid3(), uuid4(), uuid5()

1.uuid.uuid1([node[, clock_seq]])

基于時間戳

使用主機ID, 序列号, 和目前時間來生成UUID, 可保證全球範圍的唯一性. 但由于使用該方法生成的UUID中包含有主機的網絡位址, 是以可能危及隐私. 該函數有兩個參數, 如果 node 參數未指定, 系統将會自動調用 getnode() 函數來擷取主機的硬體位址. 如果 clock_seq 參數未指定系統會使用一個随機産生的14位序列号來代替.

2.uuid.uuid3(namespace, name)

基于名字的MD5散列值

通過計算命名空間和名字的MD5散列值來生成UUID, 可以保證同一命名空間中不同名字的唯一性和不同命名空間的唯一性, 但同一命名空間的同一名字生成的UUID相同.

3.uuid.uuid4()

基于随機數

通過随機數來生成UUID. 使用的是僞随機數有一定的重複機率.

4.uuid.uuid5(namespace, name)

基于名字的SHA-1散列值

3.md5加鹽

import hashlib

#注意加密順序

m=hashlib.md5('加密内容'.encode('utf8'))

m.update(b"鹽")

sign = m.hexdigest()

4.字元串和16進制字元串之間轉換

import binascii

binascii.b2a_hex('字元串'.encode()) 輸出b'e5ad97e7aca6e4b8b2'

binascii.a2b_hex('e5ad97e7aca6e4b8b2').decode() 輸出 '字元串'

5.HmacSHA256加密算法

from hashlib import sha256

import hmac

def get_sign(data, key):

key = key.encode('utf-8')

message = data.encode('utf-8')

sign = base64.b64encode(hmac.new(key, message, digestmod=sha256).digest())

sign = str(sign, 'utf-8')

print(sign)

return sign