python實作AES/DES/RSA/MD5/SM2/SM4/3DES加密演算法模板匯總-有解無憂

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

一.md5加密

1.簡介

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

import hashlib

data = 'https://www.cnblogs.com/pythonywy/p/你好'
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 = https://www.cnblogs.com/pythonywy/p/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 = https://www.cnblogs.com/pythonywy/p/b''
    for i in range(0, len(content), max_length):
        data += public_key.encrypt(content[i: i + max_length].encode(),
                                   padding.PKCS1v15())
    data = https://www.cnblogs.com/pythonywy/p/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()

三.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 = https://www.cnblogs.com/pythonywy/p/bytesToHexString(k).replace(' ','')
    #bs64手粗
    #data =https://www.cnblogs.com/pythonywy/p/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 = https://www.cnblogs.com/pythonywy/p/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 = https://www.cnblogs.com/pythonywy/p/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 = https://www.cnblogs.com/pythonywy/p/b"111"
enc_data = https://www.cnblogs.com/pythonywy/p/sm2_crypt.encrypt(data)
dec_data =sm2_crypt.decrypt(enc_data)
assert dec_data == data

3.`sign`和`verify`

data = https://www.cnblogs.com/pythonywy/p/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 = https://www.cnblogs.com/pythonywy/p/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 = https://www.cnblogs.com/pythonywy/p/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 = https://www.cnblogs.com/pythonywy/p/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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/224435.html

標籤：Python

上一篇：1-Python與計算機關系

下一篇：爬取某東購買豬肉的用戶評論，為生產經營提供了方向性參考

python實作AES/DES/RSA/MD5/SM2/SM4/3DES加密演算法模板匯總

一.md5加密

1.簡介

二.RSA加密

1.簡介

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

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

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

5.指數和模加密有填充

6.公鑰加密

三.DES

1.簡介

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

四.3des

代碼模板

五.AES加密

1.簡介

2.AES_ECB_pkcs5padding(該模板不兼容中文)

3.AES_ECB_pkcs7padding(支持中文)

4.識別是AES_128\192\256怎么識別

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

六.SM2/SM4

GMSSL模塊介紹

安裝模塊

SM2演算法

1. 初始化CryptSM2

2. encrypt和decrypt

3.sign和verify

SM4演算法

1. 初始化CryptSM4

2. encrypt_ecb和decrypt_ecb

3. encrypt_cbc和decrypt_cbc

七.其他不怎么需要模板的加密

1.base64加密

2.uuid

3.md5加鹽

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

5.HmacSHA256加密演算法

1. 初始化`CryptSM2`

2. `encrypt`和`decrypt`

3.`sign`和`verify`

1. 初始化`CryptSM4`

2. `encrypt_ecb`和`decrypt_ecb`

3. `encrypt_cbc`和`decrypt_cbc`